Aperçu de l’API

`classe` `CrossProjectRefError`

Levée lorsque le calcul du digest côté client rencontre une réf. vers 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 est impossible, 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 du serveur. Cette propriété permet de suivre la progression 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

Ajoute des appels à 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

Ajoute un coût au projet actuel.

queue_id : ID de la file d’annotation.
call_ids : ID des appels à ajouter à la file.
display_fields : chemins JSON à afficher aux relecteurs, par exemple 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. Par exemple “gpt-4o-mini-2024-07-18”
prompt_token_cost : Le coût par jeton de prompt. Par exemple .0005
completion_token_cost : Le coût par jeton de complétion. Par exemple .0015
effective_date : Par défaut, la date du jour. Un objet datetime.datetime.
provider_id : Le fournisseur du LLM. Par défaut : “default”. Par exemple “openai”
prompt_token_cost_unit : L’unité du coût des jetons de prompt. Par défaut : “USD”. (Actuellement inutilisée, elle servira à l’avenir à spécifier le type de devise du coût, par exemple “tokens” ou “time”)
completion_token_cost_unit : L’unité du coût des jetons de complétion. Par défaut : “USD”. (Actuellement inutilisée, elle servira à l’avenir à spécifier le type de devise du coût, par exemple “tokens” ou “time”) Retourne : Un objet CostCreateRes, qui possède un champ nommé ids contenant 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

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

`méthode` `clear_wandb_run_context`

clear_wandb_run_context() → None

Efface la redéfinition du contexte de run wandb. Après cet appel, les appels utiliseront à nouveau le wandb.run global (s’il est disponible) pour les informations de run_id et de step.

obj_ref : Référence à la version de l’objet, soit un ObjectRef, soit une URI string weave ///.
tags : Liste des tags (string) à ajouter. Exemples :

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

`méthode` `create_annotation_queue`

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

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

name : nom d’affichage de la file.
scorer_refs : réf. Weave des évaluateurs/champs d’annotation que les réviseurs doivent remplir.
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ée, journalise et empile 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 aucun parent n’est fourni, le run actuel sert de parent.
display_name : le nom d’affichage de l’appel. Valeur par défaut : None.
attributes : les attributs de l’appel. Valeur par défaut : None.
use_stack : indique s’il faut empiler l’appel sur la pile d’exécution. Valeur par défaut : True.
started_at : redéfinit l’heure de début de l’appel. Si la valeur est None, l’heure actuelle est utilisée. Retourne : L’objet Call 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 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’un op. Arguments :

op_name : 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

Effectue une suppression logique (soft-delete) d’une file d’annotation.

`méthode` `delete_call`

delete_call(call: 'Call') → None

`méthode` `delete_calls`

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

Supprime les appels correspondant aux ID indiqués. La suppression d’un appel entraîne également celle de tous ses 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 : liste des ID d’appels à supprimer. Ex. : [“2F0193e107-8fcf-7630-b576-977cc3062e2e”] Arguments :
object_name : nom de l’objet dont les versions doivent être supprimées.
digests : liste des digests à supprimer. Peut inclure des alias tels que “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

Fait échouer un appel avec une exception. Il s’agit d’une méthode pratique qui s’appuie sur finish_call.

`méthode` `finish`

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

Vide toutes les tâches en arrière-plan afin de garantir leur traitement. Cette méthode reste bloquante jusqu’à ce que tous les jobs actuellement en file d’attente soient traités, et affiche une barre de progression indiquant le statut des tâches en attente. Elle assure un traitement 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é téléversées vers le 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

Finalise un appel et enregistre ses résultats. Les valeurs éventuellement présentes dans call.summary sont fusionnées en profondeur avec les statistiques de synthèse calculées (par exemple, l’utilisation et le décompte des statuts) avant d’être écrites dans la base de données.

`méthode` `flush`

flush() → None

Vide les tâches asynchrones en arrière-plan ; peut être appelée plusieurs fois sans risque.

`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écouvre les clés d’attributs personnalisés typés présentes sur les spans d’agent correspondants. Utile pour alimenter les sélecteurs de filtres et de colonnes : renvoie les clés d’attributs personnalisés (ainsi que les types de leurs valeurs) 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 cette valeur sur False dans les environnements où la barre de progression s’afficherait mal (par exemple, les environnements CI).
callback : Fonction de callback facultative qui reçoit les mises à jour de statut. Redéfinit use_progress_bar. Arguments :
query : Expression de filtre de style Mongo permettant de restreindre les spans.
started_after : Ne prendre en compte que les spans démarrés à partir de cette date.
started_before : Ne prendre en compte que les spans démarrés avant cette date.
limit : Nombre maximum de clés d’attributs à renvoyer.
offset : Nombre de clés à ignorer (pour la pagination). Retourne : Un AgentCustomAttrsSchemaRes contenant 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 courant des séries temporelles et des métriques groupées. Pour des statistiques par intervalles numériques ou d’autres options avancées, appelez directement server.agent_spans_stats. Arguments :

start : début de la plage temporelle (inclus).
metrics : une ou plusieurs métriques à agréger (par exemple, des sommes de jetons).
end : fin de la plage temporelle. Si ce paramètre est omis, l’instant présent est utilisé par défaut.
query : expression de filtre de type Mongo permettant de restreindre les spans.
group_by : champs de span selon lesquels regrouper les agrégations.
granularity : largeur des tranches temporelles, en secondes, pour les statistiques de séries temporelles.
timezone : fuseau horaire IANA utilisé pour aligner les tranches temporelles. Retourne : Un objet AgentSpanStatsRes contenant 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

Interroge les spans d’agent de ce projet, avec un filtrage facultatif. Renvoie un PaginatedIterator (comme get_calls) qui récupère les pages au fur et à mesure du parcours ; len(...) indique le nombre total de spans. Arguments :

agent_name : si défini, limite les résultats à cet agent (raccourci pratique pour une query sur le champ agent_name).
query : expression de filtre de style 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 à générer. None les génère tous.
offset : nombre de spans à ignorer avant de commencer la génération (pour la pagination).
page_size : nombre de spans récupérés par requête. Retourne : Un PaginatedIterator sur des 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 : trace dont la vue du chat doit être récupérée.
include_feedback : si true, inclut 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 de chat sur plusieurs tours de conversation d’une conversation. Chaque tour de conversation correspond à une trace. Arguments :

conversation_id : la conversation dont les tours de conversation doivent être récupérés.
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 la valeur est true, inclut le feedback associé aux messages. Retourne : Un objet AgentConversationChatRes contenant les turns triés.

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

Liste les versions d’un agent donné, avec des statistiques agrégées. Renvoie 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 : agent dont les versions doivent être listées.
sort_by : champs selon lesquels trier les résultats.
limit : nombre maximum de versions à générer. None génère toutes les versions.
offset : nombre de versions à ignorer avant de commencer à générer (pour la pagination).
page_size : nombre de versions récupérées par requête. Retourne : Un PaginatedIterator sur des 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 fur et à mesure que vous le parcourez ; len(...) indique le nombre total d’agents, et l’indexation et le découpage (slicing) sont pris en charge. Arguments :

agent_name : si défini, limite les résultats à cet agent.
sort_by : champs selon lesquels trier les résultats.
limit : nombre maximum d’agents à générer. None les génère tous.
offset : nombre d’agents à ignorer avant de commencer à générer (pour la pagination).
page_size : nombre d’agents récupérés par requête. Retourne : Un PaginatedIterator sur des 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 URI string weave ///. Retourne : Liste de string 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

Lit une file d’annotation unique à 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 à partir de son ID. Arguments :

call_id : l’ID de l’appel à obtenir.
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. Limiter le nombre de colonnes peut améliorer les performances. Certaines colonnes sont toujours incluses id, project_id, trace_id, op_name, started_at Retourne : Un objet d’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 d’évaluation, et peut servir de base à des interfaces de trace personnalisées ou à des outils d’analyse. Conseil de performances : 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 selon des champs comme op_name, parent_ids, etc.
limit : Nombre maximum 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 le filtrage avancé. Les opérateurs Mongo ne sont pas tous pris en charge.
include_costs : Si True, inclut les informations de jetons et de coûts dans summary.weave.
include_feedback : Si True, inclut le 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 faire correspondre le wb_user_id de chaque appel à un wb_username.
columns : Liste des champs à renvoyer pour chaque appel. Réduire cette liste peut améliorer considérablement les performances. (Certains champs, comme id, trace_id, op_name et started_at, sont toujours inclus.)
scored_by : Filtre selon un ou plusieurs évaluateurs (nom ou URI de réf.). Si plusieurs évaluateurs sont indiqués, ils sont combinés avec un ET logique.
page_size : Nombre d’appels récupérés par page. Ajustez cette valeur pour optimiser les performances des requêtes volumineuses.

Retourne :

CallsIter : Itérateur sur des objets Call. Prend en charge le découpage (slicing), 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ère un objet Evaluation spécifique à partir de son URI. Les URI d’évaluation suivent généralement le format suivant : weave:///entity/project/object/Evaluation:version Vous pouvez également obtenir l’évaluation à partir de son nom « lisible » : get_evaluation(“Evaluation:v1”) Arguments :

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

Retourne :

Evaluation : L’objet Evaluation correspondant à l’URI fourni.

Exceptions levées :

TypeError : Si l’objet situé à l’URI n’est pas une instance d’Evaluation.
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 Evaluation du projet courant. Retourne :

list[Evaluation] : Une liste de tous les objets Evaluation du projet courant. 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 le feedback. Exemples :

# Récupérer un objet feedback précis.
# Notez que cet appel renvoie tout de même une collection, censée
# contenir zéro ou un élément.
client.get_feedback("1B4082A3-4EDA-4BEB-BFEB-2D16ED59AA07")

# Trouver tous les objets feedback associés à une réaction donnée.
client.get_feedback(reaction="👍", limit=10)

# Trouver tous les objets feedback d’un type de feedback donné à l’aide
# d’une requête de style MongoDB.
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 de type MongoDB. Accepte également, par commodité, une string contenant l’UUID d’un feedback.
reaction : par commodité, permet de filtrer selon un emoji de réaction précis.
offset : le décalage à partir duquel récupérer les objets feedback.
limit : le nombre maximum d’objets 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, sous la forme d’un ObjectRef ou d’une URI string weave:///. Retourne : Liste de tags de type string. 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 à la fois les tags et les alias d’une version d’objet en un appel unique. Arguments :

obj_ref : Référence à la version d’objet, soit un ObjectRef, soit une URI string weave ///. Retourne : Un tuple (tags, alias). Chaque élément est une liste de string. Renvoie des listes vides si la version d’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

Lie une version de prompt publiée au registre. Arguments :

prompt : un prompt publié, un ObjectRef ou une URI string weave ///… entièrement qualifiée.
target_path : chemin de destination dans le registre, au format <registry_project>/<portfolio_name>, par exemple wandb-registry-prompts/my-prompt-collection.
aliases : alias facultatifs à joindre à la version créée dans le registre. Retourne :
LinkAssetToRegistryRes : réponse analysée du point de terminaison registry-link.

`méthode` `list_aliases`

list_aliases() → list[str]

Répertorie tous les alias distincts du projet. Retourne : Liste de tous les alias du projet, sous forme de string.

`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]

Liste 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]

Liste les files d’annotation de ce projet.

list_tags() → list[str]

Liste tous les tags distincts du projet. Retourne : Liste de tous les tags du projet, sous forme de string.

`méthode` `purge_costs`

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

Supprime les coûts du projet en cours. 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 obtenir ses coûts.

ids : ID des coûts à purger. Peut être un ID unique ou une liste d’ID. Exemples :

# Récupérer un objet de coût précis.
# Notez que cet appel renvoie tout de même une collection, censée
# contenir zéro ou un élément.
client.query_costs("1B4082A3-4EDA-4BEB-BFEB-2D16ED59AA07")

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

Arguments :

query : une expression de requête de type MongoDB. Par commodité, accepte également une string contenant l’UUID d’un coût.
llm_ids : par 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 maximum 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

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

`méthode` `remove_tags`

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

Supprime des tags d’une version d’objet.

obj_ref : Référence à l’objet, soit un ObjectRef, soit une URI string weave /// (le digest n’est pas utilisé, car la portée des alias est limitée à l’objet).
alias : Un nom d’alias ou une liste de noms d’alias à supprimer. Arguments :

`méthode` `save`

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

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

obj_ref : Référence à la version de l’objet, soit un ObjectRef, soit une URI string weave ///.
tags : Liste des tags (string) à supprimer. Arguments :
val : L’objet à enregistrer.
name : Le nom sous lequel enregistrer l’objet.
branch : La branche sous laquelle enregistrer l’objet. Valeur par défaut : “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

Recherche les messages d’agent par contenu, regroupés par conversation. Recherche dans le contenu des messages (et/ou selon les filtres structurés ci-dessous) et renvoie les conversations correspondantes, accompagnées des messages trouvés. Si query est vide, la méthode effectue une récupération structurée selon les filtres. Arguments :

query : sous-chaîne à rechercher dans le contenu des messages. Une valeur vide renvoie tous les messages.
agent_name : limite la recherche aux messages de cet agent.
conversation_id : limite la recherche à une seule conversation.
trace_id : limite 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 contenant results (les 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éfinit 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

Redéfinit le run_id et le step wandb 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 lié au symbole global wandb.run.

obj_ref : référence à la version de l’objet, sous la forme d’un ObjectRef ou d’une URI string weave ///.
alias : nom d’alias ou liste de noms d’alias à définir (par exemple, « production »). Arguments :
run_id : ID du run (sans le préfixe entity/projet). Le client ajoute automatiquement le préfixe entity/projet.
step : numéro de step à utiliser pour les appels. Si None, aucun step n’est défini. Exemples :

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

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

`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

Met à 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

​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`