> ## Documentation Index
> Fetch the complete documentation index at: https://docs.coreweave.com/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 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__`
```python theme={"system"}
__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`
```python theme={"system"}
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`
```python theme={"system"}
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 :**
```python theme={"system"}
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éé.
***
```python theme={"system"}
add_tags(obj_ref: 'ObjectRef | str', tags: 'list[str]') → None
```
Ajoute des tags à une version d’objet.
**Arguments :**
***
méthode `clear_wandb_run_context`
```python theme={"system"}
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 :**
```python theme={"system"}
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`
```python theme={"system"}
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`
```python theme={"system"}
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`
```python theme={"system"}
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`
```python theme={"system"}
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`
```python theme={"system"}
delete_annotation_queue(queue_id: 'str') → AnnotationQueueSchema
```
Effectue une suppression logique (soft-delete) d’une file d’annotation.
***
méthode `delete_call`
```python theme={"system"}
delete_call(call: 'Call') → None
```
***
méthode `delete_calls`
```python theme={"system"}
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`
```python theme={"system"}
delete_object_version(object: 'ObjectRef') → None
```
***
méthode `delete_object_versions`
```python theme={"system"}
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`
```python theme={"system"}
delete_op_version(op: 'OpRef') → None
```
***
méthode `fail_call`
```python theme={"system"}
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`
```python theme={"system"}
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`
```python theme={"system"}
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`
```python theme={"system"}
flush() → None
```
Vide les tâches asynchrones en arrière-plan ; peut être appelée plusieurs fois sans risque.
***
méthode `get`
```python theme={"system"}
get(ref: 'ObjectRef', objectify: 'bool' = True) → Any
```
***
méthode `get_agent_custom_attributes`
```python theme={"system"}
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 :**
```python theme={"system"}
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={"system"}
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 :**
```python theme={"system"}
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={"system"}
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 :**
```python theme={"system"}
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={"system"}
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 :**
```python theme={"system"}
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={"system"}
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 :**
```python theme={"system"}
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={"system"}
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 :**
```python theme={"system"}
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={"system"}
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 :**
```python theme={"system"}
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={"system"}
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`
```python theme={"system"}
get_annotation_queue(queue_id: 'str') → AnnotationQueueSchema
```
Lit une file d’annotation unique à partir de son ID.
***
méthode `get_annotation_queue_stats`
```python theme={"system"}
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={"system"}
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`
```python theme={"system"}
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 :**
```python theme={"system"}
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={"system"}
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 :**
```python theme={"system"}
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={"system"}
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 :**
```python theme={"system"}
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={"system"}
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 :**
```python theme={"system"}
# 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.
***
```python theme={"system"}
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.
***
```python theme={"system"}
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`
```python theme={"system"}
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 `/`, 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`
```python theme={"system"}
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`
```python theme={"system"}
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`
```python theme={"system"}
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.
***
```python theme={"system"}
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`
```python theme={"system"}
purge_costs(ids: 'list[str] | str') → None
```
Supprime les coûts du projet en cours.
**Exemples :**
```python theme={"system"}
client.purge_costs([ids])
client.purge_costs(ids)
```
**Arguments :**
***
méthode `query_costs`
```python theme={"system"}
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 :**
```python theme={"system"}
# 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`
```python theme={"system"}
remove_aliases(obj_ref: 'ObjectRef | str', alias: 'str | list[str]') → None
```
Supprime un ou plusieurs alias d’un objet.
**Arguments :**
***
```python theme={"system"}
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`
```python theme={"system"}
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`
```python theme={"system"}
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 :**
```python theme={"system"}
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={"system"}
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`
```python theme={"system"}
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 :**
```python theme={"system"}
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`
```python theme={"system"}
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`
```python theme={"system"}
get_obj_name(val: 'Any') → str
```
***
fonction `get_parallelism_settings`
```python theme={"system"}
get_parallelism_settings() → tuple[int | None, int | None]
```
***
fonction `map_to_refs`
```python theme={"system"}
map_to_refs(obj: 'Any') → Any
```
***
fonction `print_call_link`
```python theme={"system"}
print_call_link(call: 'Call') → None
```
***
fonction `redact_sensitive_keys`
```python theme={"system"}
redact_sensitive_keys(obj: 'Any') → Any
```
***
fonction `sanitize_object_name`
```python theme={"system"}
sanitize_object_name(name: 'str') → str
```
## Related topics
- [WeaveClient](/fr/products/wandb/weave/reference/typescript-sdk/interfaces/weaveclient.md)