> ## Documentation Index
> Fetch the complete documentation index at: https://docs.wandb.ai/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_aliases`
```python theme={null}
get_aliases(obj_ref: 'ObjectRef | str') → list[str]
```
Obtenir les alias d’une version d’objet.
* `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 :**
* `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 `Evaluation` 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("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 de `Evaluation`.
* `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 `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
```