Aperçu de l’API

`classe` `CrossProjectRefError`

Levée lorsque le calcul de digest côté client rencontre une référence à un autre projet qui ne peut pas être résolue en ID interne.

`classe` `FlushStatus`

Informations sur le statut de l’opération de vidage en cours.

`classe` `NoInternalProjectIDError`

Levée lorsque le calcul du digest côté client ne peut pas se poursuivre, car aucun ID de projet interne n’a encore été résolu.

`classe` `PendingJobCounts`

Nombre de jobs en attente par type.

`classe` `WeaveClient`

`méthode` `init`

__init__(
    entity: 'str',
    project: 'str',
    server: 'TraceServerClientInterface',
    ensure_project_exists: 'bool' = True,
    postprocess_inputs: 'PostprocessInputsFunc | None' = None,
    postprocess_output: 'PostprocessOutputFunc | None' = None,
    attributes: 'dict[str, Any] | None' = None,
    api_key: 'str | None' = None
)

`propriété` num_outstanding_jobs

Renvoie le nombre total de jobs en attente sur l’ensemble des exécuteurs et le serveur. Cette propriété permet de suivre l’avancement des tâches en arrière-plan sans bloquer le thread principal. Retourne :

int: Le nombre total de jobs en attente

`propriété` project_id

`méthode` `add_calls_to_annotation_queue`

add_calls_to_annotation_queue(
    queue_id: 'str',
    call_ids: 'list[str]',
    display_fields: 'list[str]'
) → AnnotationQueueAddCallsRes

Ajoutez des appels dans une file d’annotation. Arguments :

`méthode` `add_cost`

add_cost(
    llm_id: 'str',
    prompt_token_cost: 'float',
    completion_token_cost: 'float',
    effective_date: 'datetime | None' = None,
    prompt_token_cost_unit: 'str | None' = 'USD',
    completion_token_cost_unit: 'str | None' = 'USD',
    provider_id: 'str | None' = 'default'
) → CostCreateRes

Ajoutez un coût au projet en cours.

queue_id : ID de la file d’annotation.
call_ids : ID d’appel à ajouter à la file d’annotation.
display_fields : Chemins JSON à afficher pour les réviseurs, tels que inputs.prompt ou output.text. Exemples :

client.add_cost(llm_id="my_expensive_custom_model", prompt_token_cost=1, completion_token_cost=2)
client.add_cost(llm_id="my_expensive_custom_model", prompt_token_cost=500, completion_token_cost=1000, effective_date=datetime(1998, 10, 3))

Arguments :

llm_id : L’ID du LLM. p. ex. “gpt-4o-mini-2024-07-18”
prompt_token_cost : Le coût par token du prompt. p. ex. .0005
completion_token_cost : Le coût par token de complétion. p. ex. .0015
effective_date : Valeur par défaut : la date du jour. Objet datetime.datetime.
provider_id : Le fournisseur du LLM. Valeur par défaut : “default”. p. ex. “openai”
prompt_token_cost_unit : L’unité du coût des tokens du prompt. Valeur par défaut : “USD”. (Actuellement inutilisé, sera utilisé à l’avenir pour spécifier le type d’unité du coût, p. ex. “tokens” ou “time”)
completion_token_cost_unit : L’unité du coût des tokens de complétion. Valeur par défaut : “USD”. (Actuellement inutilisé, sera utilisé à l’avenir pour spécifier le type d’unité du coût, p. ex. “tokens” ou “time”) Retourne : Un objet CostCreateRes. Il comporte un champ nommé ids, qui est une liste de tuples. Chaque tuple contient le llm_id et l’ID de l’objet de coût créé.

`méthode` `add_tags`

add_tags(obj_ref: 'ObjectRef | str', tags: 'list[str]') → None

Ajoutez des tags à une version d’objet. Arguments :

`méthode` `clear_wandb_run_context`

clear_wandb_run_context() → None

Efface la surcharge du contexte de run de wandb. Après cet appel, les appels reviendront à utiliser le wandb.run global (s’il est disponible) pour les informations de run_id et d’étape.

obj_ref: Référence à la version de l’objet, soit un ObjectRef, soit une chaîne d’URI Weave.
tags: Liste des chaînes de tag à ajouter. Exemples :

client = weave.init("my-project")
client.set_wandb_run_context(run_id="my-run-id", step=5)
# ... effectuer quelques appels ...
client.clear_wandb_run_context()
# Les appels utiliseront à nouveau le wandb.run global

`méthode` `create_annotation_queue`

create_annotation_queue(
    name: 'str',
    scorer_refs: 'list[str]',
    description: 'str' = ''
) → str

Créez une file d’annotation pour ce projet. Arguments :

name: Nom affiché de la file.
scorer_refs: Références Weave des évaluateurs/champs d’annotation à renseigner par les réviseurs.
description: Consignes facultatives destinées aux réviseurs ou description de la file. Retourne : L’ID de la file d’annotation créée.

`méthode` `create_call`

create_call(
    op: 'str | Op',
    inputs: 'dict[str, Any]',
    parent: 'Call | None' = None,
    attributes: 'dict[str, Any] | None' = None,
    display_name: 'str | Callable[[Call], str] | None' = None,
    use_stack: 'bool' = True,
    _call_id_override: 'str | None' = None,
    started_at: 'datetime | None' = None
) → Call

Créer, journaliser et empiler un appel sur la pile d’exécution. Arguments :

op : L’opération qui produit l’appel, ou le nom d’une opération anonyme.
inputs : Les entrées de l’opération.
parent : L’appel parent. Si parent n’est pas fourni, le run actuel est utilisé comme parent.
display_name : Le nom d’affichage de l’appel. La valeur par défaut est None.
attributes : Les attributs de l’appel. La valeur par défaut est None.
use_stack : Indique s’il faut empiler l’appel sur la pile d’exécution. La valeur par défaut est True.
started_at : Redéfinit l’heure de début de l’appel. Si None, utilise l’heure actuelle. Retourne : L’objet Appel créé.

`méthode` `delete_all_object_versions`

delete_all_object_versions(object_name: 'str') → int

Supprime toutes les versions d’un objet. Arguments :

object_name : Le nom de l’objet dont toutes les versions doivent être supprimées. Retourne : Le nombre de versions supprimées.

`méthode` `delete_all_op_versions`

delete_all_op_versions(op_name: 'str') → int

Supprime toutes les versions d’une op. Arguments :

op_name : Le nom de l’op dont les versions doivent être supprimées. Retourne : Le nombre de versions supprimées.

`méthode` `delete_annotation_queue`

delete_annotation_queue(queue_id: 'str') → AnnotationQueueSchema

Supprimer de manière réversible une file d’annotation.

`méthode` `delete_call`

delete_call(call: 'Call') → None

`méthode` `delete_calls`

delete_calls(call_ids: 'list[str]') → None

Supprimez les appels à l’aide de leurs IDs. La suppression d’un appel supprime également tous ses appels enfants. Arguments :

`méthode` `delete_object_version`

delete_object_version(object: 'ObjectRef') → None

`méthode` `delete_object_versions`

delete_object_versions(object_name: 'str', digests: 'list[str]') → int

Supprime des versions spécifiques d’un objet.

call_ids : Une liste d’ID d’appel à supprimer. Ex. : [“2F0193e107-8fcf-7630-b576-977cc3062e2e”] Arguments :
object_name : Le nom de l’objet dont les versions doivent être supprimées.
digests : Liste des digests à supprimer. Peut inclure des alias comme “latest” ou “v0”. Retourne : Le nombre de versions supprimées.

`méthode` `delete_op_version`

delete_op_version(op: 'OpRef') → None

`méthode` `fail_call`

fail_call(call: 'Call', exception: 'BaseException') → None

Signale l’échec d’un appel avec une exception. Il s’agit d’une méthode utilitaire pour finish_call.

`méthode` `finish`

finish(
    use_progress_bar: 'bool' = True,
    callback: 'Callable[[FlushStatus], None] | None' = None
) → None

Effectue le vidage de toutes les tâches en arrière-plan afin de s’assurer qu’elles sont traitées. Cette méthode bloque jusqu’à ce que tous les jobs actuellement en file d’attente soient traités, en affichant une barre de progression pour indiquer le statut des tâches en attente. Elle permet le traitement en parallèle pendant l’exécution du thread principal et peut améliorer les performances lorsque le code utilisateur se termine avant que les données n’aient été envoyées au serveur. Arguments :

`méthode` `finish_call`

finish_call(
    call: 'Call',
    output: 'Any' = None,
    exception: 'BaseException | None' = None,
    op: 'Op | None' = None,
    ended_at: 'datetime | None' = None
) → None

Finaliser un appel et enregistrer ses résultats. Toutes les valeurs présentes dans call.summary sont fusionnées de manière récursive avec les statistiques récapitulatives calculées (par ex. les nombres d’utilisations et de statuts) avant d’être écrites dans la base de données.

`méthode` `flush`

flush() → None

Effectue le vidage des tâches asynchrones en arrière-plan ; peut être appelée sans risque plusieurs fois.

`méthode` `get`

get(ref: 'ObjectRef', objectify: 'bool' = True) → Any

`méthode` `get_agent_custom_attributes`

get_agent_custom_attributes(
    query: 'Query | None' = None,
    started_after: 'datetime | None' = None,
    started_before: 'datetime | None' = None,
    limit: 'int' = 200,
    offset: 'int' = 0
) → AgentCustomAttrsSchemaRes

Découvrir les clés typées d’attributs personnalisés sur les spans d’agent correspondants. Utile pour alimenter les sélecteurs de filtres/colonnes : renvoie les clés d’attributs personnalisés (et leurs types de valeur) observées sur les spans sélectionnés.

use_progress_bar : Indique s’il faut afficher une barre de progression pendant le vidage. Définissez-la sur False dans les environnements où une barre de progression ne s’afficherait pas correctement (par ex., les environnements CI).
callback : Fonction de rappel facultative qui reçoit des mises à jour de statut. Remplace use_progress_bar. Arguments :
query : Une expression de filtre de style Mongo pour restreindre les spans.
started_after : Prendre en compte uniquement les spans démarrés à partir de cette date/heure.
started_before : Prendre en compte uniquement les spans démarrés avant cette date/heure.
limit : Nombre maximum de clés d’attribut à renvoyer.
offset : Nombre de clés à ignorer (pour la pagination). Retourne : Un AgentCustomAttrsSchemaRes avec attributes et has_more.

Exemple :

client = weave.init("entity/project")
resp = client.get_agent_custom_attributes()
for attr in resp.attributes:
     print(attr.key, attr.value_type, attr.span_count)

`méthode` `get_agent_span_stats`

get_agent_span_stats(
    start: 'datetime',
    metrics: 'list[AgentSpanStatsMetricSpec]',
    end: 'datetime | None' = None,
    query: 'Query | None' = None,
    group_by: 'list[AgentGroupByRef] | None' = None,
    granularity: 'int | None' = None,
    timezone: 'str' = 'UTC'
) → AgentSpanStatsRes

Calcule des agrégations prêtes pour les graphiques sur les spans d’agent. Couvre le cas le plus courant des séries temporelles / métriques groupées. Pour les statistiques par intervalles numériques ou d’autres options avancées, appelez directement server.agent_spans_stats. Arguments :

start: Début de l’intervalle de temps (inclus).
metrics: Une ou plusieurs métriques à agréger (par ex. des sommes de jetons).
end: Fin de l’intervalle de temps. Utilise l’heure actuelle par défaut s’il est omis.
query: Une expression de filtre de style Mongo pour restreindre les spans.
group_by: Champs de span sur lesquels regrouper les agrégations.
granularity: Largeur des intervalles temporels, en secondes, pour les statistiques de séries temporelles.
timezone: Fuseau horaire IANA utilisé pour aligner les intervalles temporels. Retourne : Un AgentSpanStatsRes avec columns et rows.

Exemple :

client = weave.init("entity/project")
resp = client.get_agent_span_stats(start=start, metrics=metrics)
for row in resp.rows:
     print(row)

`méthode` `get_agent_spans`

get_agent_spans(
    agent_name: 'str | None' = None,
    query: 'Query | None' = None,
    sort_by: 'list[AgentSortBy] | None' = None,
    limit: 'int | None' = None,
    offset: 'int | None' = None,
    page_size: 'int' = 100
) → AgentSpansIter

Interrogez les spans d’agent pour ce projet, avec un filtre facultatif. Renvoie un PaginatedIterator (comme get_calls) qui récupère les pages à mesure que vous le parcourez ; len(...) indique le nombre total de spans. Arguments :

agent_name: S’il est défini, limite les résultats à cet agent (raccourci pratique pour un query sur le champ agent_name).
query: Une expression de filtre de type Mongo. Combinée à agent_name via $and lorsque les deux sont fournis.
sort_by: Champs selon lesquels trier les résultats.
limit: Nombre maximum de spans à renvoyer. None les renvoie tous.
offset: Nombre de spans à ignorer avant de commencer à les renvoyer (pour la pagination).
page_size: Nombre de spans récupérés par requête. Retourne : Un PaginatedIterator sur AgentSpanSchema.

Exemple :

client = weave.init("entity/project")
for span in client.get_agent_spans(agent_name="my-agent"):
     print(span.span_id, span.span_name, span.input_tokens)

`méthode` `get_agent_turn`

get_agent_turn(
    trace_id: 'str',
    include_feedback: 'bool' = False
) → AgentTraceChatRes

Obtenir la vue structurée du chat (messages) pour un seul tour de conversation. Un tour de conversation correspond à une trace. Arguments :

trace_id : La trace dont il faut récupérer la vue du chat.
include_feedback : Si true, inclure le feedback sur les messages. Retourne : Un AgentTraceChatRes contenant les messages ordonnés du tour de conversation.

Exemple :

client = weave.init("entity/project")
resp = client.get_agent_turn(trace_id="...", include_feedback=True)
for message in resp.messages:
     print(message.type)

`méthode` `get_agent_turns`

get_agent_turns(
    conversation_id: 'str',
    limit: 'int' = 50,
    offset: 'int' = 0,
    include_feedback: 'bool' = False
) → AgentConversationChatRes

Obtenir la vue du chat sur plusieurs tours de conversation d’une conversation. Chaque tour de conversation correspond à une trace. Arguments :

conversation_id : La conversation dont récupérer les tours de conversation.
limit : Nombre maximum de tours de conversation à renvoyer.
offset : Nombre de tours de conversation les plus récents à ignorer (pour la pagination).
include_feedback : Si true, inclure le feedback sur les messages. Retourne : Un AgentConversationChatRes contenant les turns dans l’ordre.

Exemple :

client = weave.init("entity/project")
resp = client.get_agent_turns(conversation_id="...", limit=20)
for turn in resp.turns:
     for message in turn.messages:
         print(message.type)

`méthode` `get_agent_versions`

get_agent_versions(
    agent_name: 'str',
    sort_by: 'list[AgentSortBy] | None' = None,
    limit: 'int | None' = None,
    offset: 'int | None' = None,
    page_size: 'int' = 100
) → AgentVersionsIter

Lister les versions d’un agent donné, avec des statistiques agrégées. Retourne un PaginatedIterator (comme get_calls) qui récupère les pages au fur et à mesure que vous le parcourez ; len(...) indique le nombre total de versions. Arguments :

agent_name: L’agent dont lister les versions.
sort_by: Champs selon lesquels trier les résultats.
limit: Nombre maximum de versions à générer. None les génère toutes.
offset: Nombre de versions à ignorer avant de les générer (pour la pagination).
page_size: Nombre de versions récupérées par requête. Retourne : Un PaginatedIterator de AgentVersionSchema.

Exemple :

client = weave.init("entity/project")
for version in client.get_agent_versions(agent_name="my-agent"):
     print(version.agent_version, version.total_input_tokens)

`méthode` `get_agents`

get_agents(
    agent_name: 'str | None' = None,
    sort_by: 'list[AgentSortBy] | None' = None,
    limit: 'int | None' = None,
    offset: 'int | None' = None,
    page_size: 'int' = 100
) → AgentsIter

Liste les agents de ce projet avec des statistiques agrégées. Renvoie un PaginatedIterator (comme get_calls) qui récupère les pages de manière transparente au fil de son utilisation ; len(...) indique le nombre total d’agents, et l’indexation ainsi que le découpage en tranches sont pris en charge. Arguments :

agent_name : S’il est défini, limite les résultats à cet agent.
sort_by : Champs selon lesquels trier les résultats.
limit : Nombre maximal d’agents à renvoyer. None les renvoie tous.
offset : Nombre d’agents à ignorer avant de les renvoyer (pour la pagination).
page_size : Nombre d’agents récupérés par requête. Retourne : Un PaginatedIterator sur AgentSchema.

Exemple :

client = weave.init("entity/project")
for agent in client.get_agents(limit=20):
     print(agent.agent_name, agent.total_input_tokens)

`méthode` `get_aliases`

get_aliases(obj_ref: 'ObjectRef | str') → list[str]

Obtenir les alias d’une version d’objet. Arguments :

obj_ref : Référence à la version de l’objet, soit un ObjectRef, soit une chaîne d’URI weave:///. Retourne : Liste de chaînes d’alias. Inclut l’alias virtuel “latest” si la version de l’objet est la plus récente.

`méthode` `get_annotation_queue`

get_annotation_queue(queue_id: 'str') → AnnotationQueueSchema

Lire une file d’annotation à partir de son ID.

`méthode` `get_annotation_queue_stats`

get_annotation_queue_stats(
    queue_ids: 'list[str]'
) → list[AnnotationQueueStatsSchema]

Obtenir les statistiques d’achèvement des éléments des files d’annotation.

`méthode` `get_call`

get_call(
    call_id: 'str',
    include_costs: 'bool' = False,
    include_feedback: 'bool' = False,
    columns: 'list[str] | None' = None
) → WeaveObject

Obtenir un appel unique par son ID. Arguments :

call_id : L’ID de l’appel à récupérer.
include_costs : Si true, les informations de coût sont incluses dans summary.weave
include_feedback : Si true, les informations de feedback sont incluses dans summary.weave.feedback
columns : Liste des colonnes à inclure dans la réponse. Si None, toutes les colonnes sont incluses. Spécifier moins de colonnes peut améliorer les performances. Certaines colonnes sont toujours incluses id, project_id, trace_id, op_name, started_at Retourne : Un objet appel.

`méthode` `get_calls`

get_calls(
    filter: 'CallsFilterLike | None' = None,
    limit: 'int | None' = None,
    offset: 'int | None' = None,
    sort_by: 'list[SortByLike] | None' = None,
    query: 'QueryLike | None' = None,
    include_costs: 'bool' = False,
    include_feedback: 'bool' = False,
    include_storage_size: 'bool' = False,
    include_total_storage_size: 'bool' = False,
    include_usernames: 'bool' = False,
    columns: 'list[str] | None' = None,
    expand_columns: 'list[str] | None' = None,
    return_expanded_column_values: 'bool' = True,
    scored_by: 'str | list[str] | None' = None,
    page_size: 'int' = 1000
) → CallsIter

Récupère une liste d’appels tracés (opérations) pour ce projet. Cette méthode fournit une interface puissante et flexible pour interroger les données de trace. Elle prend en charge la pagination, le filtrage, le tri, la projection de champs et les métadonnées de scoring, et peut servir à créer des interfaces utilisateur de trace personnalisées ou des outils d’analyse. Conseil de performance : spécifiez columns et utilisez filter ou query pour réduire la taille des résultats. Arguments :

filter: Filtre de haut niveau permettant d’affiner les résultats à partir de champs comme op_name, parent_ids, etc.
limit: Nombre maximal d’appels à renvoyer.
offset: Nombre d’appels à ignorer avant de renvoyer les résultats (utilisé pour la pagination).
sort_by: Liste des champs selon lesquels trier les résultats (par exemple, started_at desc).
query: Expression de type Mongo pour un filtrage avancé. Tous les opérateurs Mongo ne sont pas pris en charge.
include_costs: Si True, inclut les informations de token/coût dans summary.weave.
include_feedback: Si True, inclut les feedback dans summary.weave.feedback.
include_storage_size: Si True, inclut la taille de stockage d’un appel.
include_total_storage_size: Si True, inclut la taille de stockage totale d’une trace.
include_usernames: Si True, tente de résoudre le wb_user_id de chaque appel en wb_username.
columns: Liste des champs à renvoyer pour chaque appel. Réduire cette liste peut considérablement améliorer les performances. (Certains champs comme id, trace_id, op_name et started_at sont toujours inclus.)
scored_by: Filtre sur un ou plusieurs évaluateurs (nom ou URI de référence). Plusieurs évaluateurs sont combinés avec un ET.
page_size: Nombre d’appels récupérés par page. Ajustez cette valeur pour optimiser les performances dans les requêtes volumineuses.

Retourne :

CallsIter: Un itérateur sur des objets Call. Prend en charge le découpage, l’itération et .to_pandas().

Exemple :

calls = client.get_calls(
     filter=CallsFilter(op_names=["my_op"]),
     columns=["inputs", "output", "summary"],
     limit=100,
)
for call in calls:
     print(call.inputs, call.output)

`méthode` `get_evaluation`

get_evaluation(uri: 'str') → Evaluation

Récupérer un objet Évaluation spécifique à partir de son URI. Les URI d’évaluation suivent généralement le format : weave:///entity/project/object/Evaluation:version Vous pouvez également obtenir l’évaluation par son nom « convivial » : get_evaluation(“Évaluation:v1”) Arguments :

uri (str) : L’identifiant de ressource unique de l’évaluation à récupérer.

Retourne :

Évaluation : L’objet Évaluation correspondant à l’URI fourni.

Exceptions levées :

TypeError : Si l’objet situé à l’URI n’est pas une instance de Évaluation.
ValueError : Si l’URI n’est pas valide ou si l’objet est introuvable.

Exemples :

client = weave.init("my-project")
evaluation = client.get_evaluation("weave:///entity/project/object/my-eval:v1")
print(evaluation.name)

`méthode` `get_evaluations`

get_evaluations() → list[Evaluation]

Récupère tous les objets Évaluation du projet actuel. Retourne :

list[Evaluation]: Une liste de tous les objets Évaluation du projet actuel. Une liste vide si aucune évaluation n’est trouvée ou si toutes les conversions échouent.

Exemples :

client = weave.init("my-project")
evaluations = client.get_evaluations()
print(f"Found {len(evaluations)} evaluations")
for eval in evaluations:
     print(f"Evaluation: {eval.name}")

`méthode` `get_feedback`

get_feedback(
    query: 'Query | str | None' = None,
    reaction: 'str | None' = None,
    offset: 'int' = 0,
    limit: 'int' = 100
) → FeedbackQuery

Interroger le projet pour obtenir des retours. Exemples :

# Récupérer un objet de feedback spécifique.
# Notez que cela renvoie toujours une collection, qui est censée
# contenir zéro ou un élément.
client.get_feedback("1B4082A3-4EDA-4BEB-BFEB-2D16ED59AA07")

# Trouver tous les objets de feedback avec une réaction spécifique.
client.get_feedback(reaction="👍", limit=10)

# Trouver tous les objets de feedback avec un type de feedback spécifique
# via une requête au format Mongo.
from weave.trace_server.interface.query import Query

query = Query(
    **{
        "$expr": {
            "$eq": [
                {"$getField": "feedback_type"},
                {"$literal": "wandb.reaction.1"},
            ],
        }
    }
)
client.get_feedback(query=query)

Arguments :

query: Une expression de requête au format Mongo. Pour plus de simplicité, accepte également une chaîne UUID de feedback.
reaction: Pour plus de simplicité, permet de filtrer par un emoji de réaction spécifique.
offset: Le décalage à partir duquel commencer à récupérer les objets de feedback.
limit: Le nombre maximal d’objets de feedback à récupérer. Retourne : Un objet FeedbackQuery.

`méthode` `get_tags`

get_tags(obj_ref: 'ObjectRef | str') → list[str]

Obtenir les tags d’une version d’objet. Arguments :

obj_ref : Référence à la version d’objet, soit un ObjectRef, soit une chaîne d’URI weave:///. Retourne : Liste de chaînes de caractères de tag. Renvoie une liste vide si la version d’objet n’a aucun tag.

`méthode` `get_tags_and_aliases`

get_tags_and_aliases(obj_ref: 'ObjectRef | str') → tuple[list[str], list[str]]

Obtenir les tags et les alias d’une version d’objet en un appel unique. Arguments :

obj_ref : Référence à la version de l’objet, soit un ObjectRef, soit une chaîne d’URI weave:///. Retourne : Un tuple (tags, alias). Chacun correspond à une liste de chaînes. Renvoie des listes vides si la version de l’objet n’a ni tags ni alias.

`méthode` `link_prompt_to_registry`

link_prompt_to_registry(
    prompt: 'LinkablePrompt',
    target_path: 'str',
    aliases: 'Sequence[str] | None' = None
) → LinkAssetToRegistryRes

Liez une version de prompt publiée au Registry. Arguments :

prompt: Un prompt publié, une ObjectRef ou une chaîne d’URI Weave ///… pleinement qualifiée.
target_path: Chemin de destination dans le Registry au format <registry_project>/<portfolio_name>, par exemple wandb-registry-prompts/my-prompt-collection.
aliases: Alias facultatifs à associer à la version créée dans le Registry. Retourne :
LinkAssetToRegistryRes: Réponse analysée du point de terminaison registry-link.

`méthode` `list_aliases`

list_aliases() → list[str]

Listez tous les alias distincts du projet. Retourne : Liste de tous les alias du projet sous forme de chaînes.

`méthode` `list_annotation_queue_items`

list_annotation_queue_items(
    queue_id: 'str',
    filter: 'AnnotationQueueItemsFilter | None' = None,
    sort_by: 'list[SortBy] | None' = None,
    limit: 'int | None' = None,
    offset: 'int | None' = None,
    include_position: 'bool' = False
) → list[AnnotationQueueItemSchema]

Lister les appels attribués à une file d’annotation.

`méthode` `list_annotation_queues`

list_annotation_queues(
    name: 'str | None' = None,
    sort_by: 'list[SortBy] | None' = None,
    limit: 'int | None' = None,
    offset: 'int | None' = None
) → list[AnnotationQueueSchema]

Lister les files d’annotation de ce projet.

list_tags() → list[str]

Listez tous les tags distincts du projet. Retourne : Liste de toutes les chaînes de caractères des tags du projet.

`méthode` `purge_costs`

purge_costs(ids: 'list[str] | str') → None

Supprime les coûts du projet actuel. Exemples :

client.purge_costs([ids])
client.purge_costs(ids)

Arguments :

`méthode` `query_costs`

query_costs(
    query: 'Query | str | None' = None,
    llm_ids: 'list[str] | None' = None,
    offset: 'int' = 0,
    limit: 'int' = 100
) → list[CostQueryOutput]

Interroge le projet pour récupérer les coûts.

ids : les ID de coûts à purger. Peut s’agir d’un seul ID ou d’une liste d’ID. Exemples :

# Récupère un objet de coût spécifique.
# Notez que cela renvoie toujours une collection, qui est censée
# contenir zéro ou un élément.
client.query_costs("1B4082A3-4EDA-4BEB-BFEB-2D16ED59AA07")

# Trouver tous les objets de coût avec une réaction spécifique.
client.query_costs(llm_ids=["gpt-4o-mini-2024-07-18"], limit=10)

Arguments :

query : Une expression de requête de type Mongo. Pour plus de commodité, accepte également un UUID de coût sous forme de chaîne.
llm_ids : Pour plus de commodité, permet de filtrer sur un ensemble de llm_ids.
offset : Le décalage à partir duquel commencer à récupérer les objets de coût.
limit : Le nombre maximal d’objets de coût à récupérer. Retourne : Un objet CostQuery.

`méthode` `remove_aliases`

remove_aliases(obj_ref: 'ObjectRef | str', alias: 'str | list[str]') → None

Supprimez un ou plusieurs alias d’un objet. Arguments :

`méthode` `remove_tags`

remove_tags(obj_ref: 'ObjectRef | str', tags: 'list[str]') → None

Supprimez les tags d’une version d’objet.

obj_ref : Référence à l’objet, soit un ObjectRef, soit une chaîne d’URI Weave (le digest n’est pas utilisé, car les alias ont une portée limitée à l’objet).
alias : Nom d’alias ou liste de noms d’alias à supprimer. Arguments :

`méthode` `save`

save(val: 'Any', name: 'str', branch: 'str' = 'latest') → Any

N’appelez pas directement cette méthode ; utilisez plutôt weave.publish().

obj_ref : Référence vers la version de l’objet, soit un ObjectRef, soit une chaîne d’URI weave:///.
tags : Liste des chaînes de caractères des tags à supprimer. Arguments :
val : L’objet à enregistrer.
name : Le nom sous lequel enregistrer l’objet.
branch : La branche sous laquelle enregistrer l’objet. La valeur par défaut est “latest”. Retourne : Une version désérialisée de l’objet enregistré.

`méthode` `search_agents`

search_agents(
    query: 'str' = '',
    agent_name: 'str | None' = None,
    conversation_id: 'str | None' = None,
    trace_id: 'str | None' = None,
    limit: 'int' = 20,
    offset: 'int' = 0
) → AgentSearchRes

Rechercher les messages d’agent par contenu, regroupés par conversation. Recherche dans le contenu des messages (et/ou à l’aide des filtres structurés ci-dessous) et renvoie les conversations correspondantes avec les messages qui correspondent. Une valeur query vide transforme cette opération en recherche structurée sur les filtres. Arguments :

query : Sous-chaîne à rechercher dans le contenu du message. Une valeur vide correspond à tous les messages.
agent_name : Restreint la recherche aux messages provenant de cet agent.
conversation_id : Restreint la recherche à une seule conversation.
trace_id : Restreint la recherche à une seule trace.
limit : Nombre maximum de messages correspondants à prendre en compte.
offset : Nombre de correspondances à ignorer (pour la pagination). Retourne : Un AgentSearchRes avec results (conversations correspondantes).

Exemple :

client = weave.init("entity/project")
resp = client.search_agents(query="timeout", agent_name="my-agent")
for conversation in resp.results:
     print(conversation.conversation_id, conversation.matched_messages)

`méthode` `set_aliases`

set_aliases(obj_ref: 'ObjectRef | str', alias: 'str | list[str]') → None

Définissez un ou plusieurs alias pour une version d’objet. Arguments :

`méthode` `set_wandb_run_context`

set_wandb_run_context(run_id: 'str', step: 'int | None' = None) → None

Surcharge le run_id wandb et l’étape pour les appels créés par ce client. Cela vous permet d’associer des appels Weave à un run wandb spécifique qui n’est pas rattaché au symbole global wandb.run.

obj_ref: Référence vers la version de l’objet, soit un ObjectRef, soit une chaîne d’URI weave:///.
alias: Un nom d’alias ou une liste de noms d’alias à définir (par exemple, “production”). Arguments :
run_id: L’ID du run (sans le préfixe entité/projet). Le client ajoutera automatiquement le préfixe entité/projet.
step: Le numéro d’étape à utiliser pour les appels. Si None, l’étape ne sera pas définie. Exemples :

client = weave.init("my-project")
client.set_wandb_run_context(run_id="my-run-id", step=5)
# Tous les appels seront désormais associés à entity/project/my-run-id à l'étape 5

# Ou sans étape
client.set_wandb_run_context(run_id="my-run-id")
# Les appels seront associés à entity/project/my-run-id sans étape

`méthode` `update_annotation_queue`

update_annotation_queue(
    queue_id: 'str',
    name: 'str | None' = None,
    description: 'str | None' = None,
    scorer_refs: 'list[str] | None' = None
) → AnnotationQueueSchema

Mettre à jour les métadonnées de la file d’annotation.

`fonction` `get_obj_name`

get_obj_name(val: 'Any') → str

`fonction` `get_parallelism_settings`

get_parallelism_settings() → tuple[int | None, int | None]

`fonction` `map_to_refs`

map_to_refs(obj: 'Any') → Any

`fonction` `print_call_link`

print_call_link(call: 'Call') → None

`fonction` `redact_sensitive_keys`

redact_sensitive_keys(obj: 'Any') → Any

`fonction` `sanitize_object_name`

sanitize_object_name(name: 'str') → str

util

trace_server_interface

⌘I

​Aperçu de l’API

​classe CrossProjectRefError

​classe FlushStatus

​classe NoInternalProjectIDError

​classe PendingJobCounts

​classe WeaveClient

​méthode __init__

​propriété num_outstanding_jobs

​propriété project_id

​méthode add_calls_to_annotation_queue

​méthode add_cost

​méthode add_tags

​méthode clear_wandb_run_context

​méthode create_annotation_queue

​méthode create_call

​méthode delete_all_object_versions

​méthode delete_all_op_versions

​méthode delete_annotation_queue

​méthode delete_call

​méthode delete_calls

​méthode delete_object_version

​méthode delete_object_versions

​méthode delete_op_version

​méthode fail_call

​méthode finish

​méthode finish_call

​méthode flush

​méthode get

​méthode get_agent_custom_attributes

​méthode get_agent_span_stats

​méthode get_agent_spans

​méthode get_agent_turn

​méthode get_agent_turns

​méthode get_agent_versions

​méthode get_agents

​méthode get_aliases

​méthode get_annotation_queue

​méthode get_annotation_queue_stats

​méthode get_call

​méthode get_calls

​méthode get_evaluation

​méthode get_evaluations

​méthode get_feedback

​méthode get_tags

​méthode get_tags_and_aliases

​méthode link_prompt_to_registry

​méthode list_aliases

​méthode list_annotation_queue_items

​méthode list_annotation_queues

​méthode list_tags

​méthode purge_costs

​méthode query_costs

​méthode remove_aliases

​méthode remove_tags

​méthode save

​méthode search_agents

​méthode set_aliases

​méthode set_wandb_run_context

​méthode update_annotation_queue

​fonction get_obj_name

​fonction get_parallelism_settings

​fonction map_to_refs

​fonction print_call_link

​fonction redact_sensitive_keys

​fonction sanitize_object_name

Aperçu de l’API

`classe` `CrossProjectRefError`

`classe` `FlushStatus`

`classe` `NoInternalProjectIDError`

`classe` `PendingJobCounts`

`classe` `WeaveClient`

`méthode` `init`

`propriété` num_outstanding_jobs

`propriété` project_id

`méthode` `add_calls_to_annotation_queue`

`méthode` `add_cost`

`méthode` `add_tags`

`méthode` `clear_wandb_run_context`

`méthode` `create_annotation_queue`

`méthode` `create_call`

`méthode` `delete_all_object_versions`

`méthode` `delete_all_op_versions`

`méthode` `delete_annotation_queue`

`méthode` `delete_call`

`méthode` `delete_calls`

`méthode` `delete_object_version`

`méthode` `delete_object_versions`

`méthode` `delete_op_version`

`méthode` `fail_call`

`méthode` `finish`

`méthode` `finish_call`

`méthode` `flush`

`méthode` `get`

`méthode` `get_agent_custom_attributes`

`méthode` `get_agent_span_stats`

`méthode` `get_agent_spans`

`méthode` `get_agent_turn`

`méthode` `get_agent_turns`

`méthode` `get_agent_versions`

`méthode` `get_agents`

`méthode` `get_aliases`

`méthode` `get_annotation_queue`

`méthode` `get_annotation_queue_stats`

`méthode` `get_call`

`méthode` `get_calls`

`méthode` `get_evaluation`

`méthode` `get_evaluations`

`méthode` `get_feedback`

`méthode` `get_tags`

`méthode` `get_tags_and_aliases`

`méthode` `link_prompt_to_registry`

`méthode` `list_aliases`

`méthode` `list_annotation_queue_items`

`méthode` `list_annotation_queues`

`méthode` `list_tags`

`méthode` `purge_costs`

`méthode` `query_costs`

`méthode` `remove_aliases`

`méthode` `remove_tags`

`méthode` `save`

`méthode` `search_agents`

`méthode` `set_aliases`

`méthode` `set_wandb_run_context`

`méthode` `update_annotation_queue`

`fonction` `get_obj_name`

`fonction` `get_parallelism_settings`

`fonction` `map_to_refs`

`fonction` `print_call_link`

`fonction` `redact_sensitive_keys`

`fonction` `sanitize_object_name`