> ## Documentation Index
> Fetch the complete documentation index at: https://wb-21fd5541-sa-registry-access.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
# weave_client
> Référence du SDK Python pour weave.trace.weave_client
export const SourceLink = ({url}) =>
Source
;
# 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__`
```python theme={null}
__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`
```python theme={null}
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`
```python theme={null}
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 :**
```python theme={null}
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`
```python theme={null}
add_tags(obj_ref: 'ObjectRef | str', tags: 'list[str]') → None
```
Ajoutez des tags à une version d’objet.
**Arguments :**
***
### méthode `clear_wandb_run_context`
```python theme={null}
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 :**
```python theme={null}
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`
```python theme={null}
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`
```python theme={null}
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`
```python theme={null}
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`
```python theme={null}
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`
```python theme={null}
delete_annotation_queue(queue_id: 'str') → AnnotationQueueSchema
```
Supprimer de manière réversible une file d’annotation.
***
### méthode `delete_call`
```python theme={null}
delete_call(call: 'Call') → None
```
***
### méthode `delete_calls`
```python theme={null}
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`
```python theme={null}
delete_object_version(object: 'ObjectRef') → None
```
***
### méthode `delete_object_versions`
```python theme={null}
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`
```python theme={null}
delete_op_version(op: 'OpRef') → None
```
***
### méthode `fail_call`
```python theme={null}
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`
```python theme={null}
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`
```python theme={null}
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`
```python theme={null}
flush() → None
```
Effectue le vidage des tâches asynchrones en arrière-plan ; peut être appelée sans risque plusieurs fois.
***
### méthode `get`
```python theme={null}
get(ref: 'ObjectRef', objectify: 'bool' = True) → Any
```
***
### méthode `get_agent_custom_attributes`
```python theme={null}
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 :**
```python theme={null}
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`
```python theme={null}
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 :**
```python theme={null}
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`
```python theme={null}
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 :**
```python theme={null}
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`
```python theme={null}
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 :**
```python theme={null}
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`
```python theme={null}
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 :**
```python theme={null}
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`
```python theme={null}
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 :**
```python theme={null}
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`
```python theme={null}
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 :**
```python theme={null}
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`
```python theme={null}
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`
```python theme={null}
get_annotation_queue(queue_id: 'str') → AnnotationQueueSchema
```
Lire une file d’annotation à partir de son ID.
***
### méthode `get_annotation_queue_stats`
```python theme={null}
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`
```python theme={null}
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`
```python theme={null}
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 :**
```python theme={null}
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`
```python theme={null}
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 :**
```python theme={null}
client = weave.init("my-project")
evaluation = client.get_evaluation("weave:///entity/project/object/my-eval:v1")
print(evaluation.name)
```
***
### méthode `get_evaluations`
```python theme={null}
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 :**
```python theme={null}
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`
```python theme={null}
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 :**
```python theme={null}
# 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`
```python theme={null}
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`
```python theme={null}
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`
```python theme={null}
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 `/`, 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`
```python theme={null}
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`
```python theme={null}
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`
```python theme={null}
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.
***
### méthode `list_tags`
```python theme={null}
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`
```python theme={null}
purge_costs(ids: 'list[str] | str') → None
```
Supprime les coûts du projet actuel.
**Exemples :**
```python theme={null}
client.purge_costs([ids])
client.purge_costs(ids)
```
**Arguments :**
***
### méthode `query_costs`
```python theme={null}
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 :**
```python theme={null}
# 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`
```python theme={null}
remove_aliases(obj_ref: 'ObjectRef | str', alias: 'str | list[str]') → None
```
Supprimez un ou plusieurs alias d’un objet.
**Arguments :**
***
### méthode `remove_tags`
```python theme={null}
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`
```python theme={null}
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`
```python theme={null}
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 :**
```python theme={null}
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`
```python theme={null}
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`
```python theme={null}
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 :**
```python theme={null}
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`
```python theme={null}
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`
```python theme={null}
get_obj_name(val: 'Any') → str
```
***
### fonction `get_parallelism_settings`
```python theme={null}
get_parallelism_settings() → tuple[int | None, int | None]
```
***
### fonction `map_to_refs`
```python theme={null}
map_to_refs(obj: 'Any') → Any
```
***
### fonction `print_call_link`
```python theme={null}
print_call_link(call: 'Call') → None
```
***
### fonction `redact_sensitive_keys`
```python theme={null}
redact_sensitive_keys(obj: 'Any') → Any
```
***
### fonction `sanitize_object_name`
```python theme={null}
sanitize_object_name(name: 'str') → str
```