> ## 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
> Référence du SDK Python pour weave
export const SourceLink = ({url}) =>
Source
;
```python theme={"system"}
value_is_valid(payload: Any) → bool
```
Valide une charge utile par rapport au schéma de cette spécification d'annotation.
**Arguments :**
* `payload` : les données à valider par rapport au schéma
**Retourne :**
* `bool` : True si la validation réussit, False sinon
***
classe `Audio`
Classe représentant des données audio dans un format pris en charge (wav ou mp3).
Cette classe gère le stockage des données audio et fournit des méthodes pour les charger depuis différentes sources et les exporter vers des fichiers.
**Attributs :**
* `format` : Le format audio (actuellement, 'wav' ou 'mp3' sont pris en charge)
* `data` : Les données audio brutes, sous forme d’octets
**Arguments :**
* `data` : Les données audio (octets ou string encodée en base64)
* `format` : Le format audio ('wav' ou 'mp3')
* `validate_base64` : Indique s’il faut tenter de décoder les données d’entrée en base64
**Exceptions levées :**
* `ValueError` : Si les données audio sont vides ou si le format n’est pas pris en charge
```python theme={"system"}
export(path: 'str | bytes | Path | PathLike') → None
```
Exporte les données audio vers un fichier.
**Arguments :**
***
classmethod `from_data`
```python theme={"system"}
from_data(data: 'str | bytes', format: 'str') → Self
```
Crée un objet Audio à partir de données brutes et d’un format spécifié.
* `path` : chemin où le fichier audio doit être écrit
**Arguments :**
* `data` : données audio sous forme d’octets ou de string encodée en base64
* `format` : format audio ('wav' ou 'mp3')
**Retourne :**
* `Audio` : une nouvelle instance d’Audio
**Exceptions levées :**
* `ValueError` : si le format n’est pas pris en charge
***
classmethod `from_path`
```python theme={"system"}
from_path(path: 'str | bytes | Path | PathLike') → Self
```
Crée un objet Audio à partir d’un chemin de fichier.
**Arguments :**
* `path` : chemin d’accès à un fichier audio (extension .wav ou .mp3 obligatoire)
**Retourne :**
* `Audio` : une nouvelle instance Audio chargée à partir du fichier
**Exceptions levées :**
* `ValueError` : si le fichier n'existe pas ou si son extension n'est pas prise en charge
***
classe `ClassifierMonitor`
Un moniteur qui fusionne plusieurs évaluateurs en un seul classifieur.
Les moniteurs de classification regroupent les prompts de plusieurs LLMAsAJudgeScorers ciblant le même modèle en un seul appel d’évaluation.
**Champs Pydantic :**
* `name`: `str | None`
* `description`: `str | None`
* `ref`: `trace.refs.ObjectRef | None`
* `sampling_rate`: ``
* `scorers`: `list[flow.scorer.Scorer]`
* `op_names`: `list[typing.Union[typing.Literal['genai.turn_ended'], str]]`
* `query`: `trace_server.interface.query.Query | None`
* `is_traced`: ``
* `active`: ``
* `scorer_debounce_config`: `flow.monitor.ScorerDebounceConfig | None`
* `prompt_header`: `str | None`
* `prompt_footer`: `str | None`
méthode `activate`
```python theme={"system"}
activate() → ObjectRef
```
Active le moniteur.
**Retourne :**
La réf. du moniteur.
***
méthode `deactivate`
```python theme={"system"}
deactivate() → ObjectRef
```
Désactive le moniteur.
**Retourne :**
La réf. du moniteur.
***
```python theme={"system"}
get_prompt_footer() → str
```
Texte à ajouter après les prompts fusionnés des classifieurs.
***
méthode `get_prompt_header`
```python theme={"system"}
get_prompt_header(op_name: str) → str
```
Texte à insérer avant les prompts fusionnés des classifieurs.
***
méthode `model_post_init`
```python theme={"system"}
model_post_init(context: Any) → None
```
Normalise `op_names` lors de la construction lorsqu’un client est disponible.
La publication ne dispose d’aucun hook par objet. Pour couvrir également un simple appel à `weave.publish(monitor)` (sans `activate()`), les noms courts sont donc développés ici : toute personne qui publie a généralement déjà appelé `weave.init`, de sorte que le client est défini au moment de la construction du moniteur.
Dans plusieurs cas d’usage, la construction s’effectue sans client : tests unitaires, inspection, ou encore désérialisation d’un moniteur stocké dans un worker. La vérification sur `get_weave_client()` permet la construction sans client. Dans ce cas, la normalisation n’a pas lieu, ce qui ne devrait pas poser de problème, car les moniteurs stockés contiennent déjà des réf. complètes.
Il existe un cas limite dans lequel un moniteur peut être créé avec le SDK sans être normalisé : lorsque l’utilisateur construit le moniteur, appelle ensuite weave.init, puis le publie. Pour contourner ce problème, vous pouvez appeler `activate()` ou `deactivate()`.
***
classe `Content`
Classe permettant de représenter du contenu issu de diverses sources en le convertissant en une représentation unifiée sous forme d’octets, accompagnée des métadonnées associées.
Cette classe doit être instanciée à l’aide de l’une de ses classmethods :
* from\_path()
* from\_bytes()
* from\_text()
* from\_url()
* from\_base64()
* from\_data\_url()
```python theme={"system"}
as_string() → str
```
Affiche les données sous forme de string. Les octets sont décodés à l’aide de l’attribut `encoding`. Si l’encodage est base64, les données sont réencodées en octets base64, puis décodées en string ASCII.
**Retourne :**
str.
***
classmethod `from_base64`
```python theme={"system"}
from_base64(
b64_data: 'str | bytes',
extension: 'str | None' = None,
mimetype: 'str | None' = None,
metadata: 'dict[str, Any] | None' = None
) → Self
```
Initialise Content à partir d’une string ou d’octets encodés en base64.
***
```python theme={"system"}
from_url(
url: 'str',
headers: 'dict[str, Any] | None' = None,
timeout: 'int | None' = 30,
metadata: 'dict[str, Any] | None' = None
) → Self
```
Initialise un objet Content en récupérant des octets depuis une URL HTTP(S).
Télécharge le contenu, déduit le type MIME et l’extension à partir des en-têtes, du chemin de l’URL et des données, puis construit un objet Content à partir des octets obtenus.
***
classmethod `model_validate`
```python theme={"system"}
model_validate(
obj: 'Any',
strict: 'bool | None' = None,
from_attributes: 'bool | None' = None,
context: 'dict[str, Any] | None' = None,
extra: 'str | None' = None,
by_alias: 'bool | None' = None,
by_name: 'bool | None' = None
) → Self
```
Redéfinit model\_validate pour gérer la reconstruction de Content à partir d’un dict.
***
classmethod `model_validate_json`
```python theme={"system"}
model_validate_json(
json_data: 'str | bytes | bytearray',
strict: 'bool | None' = None,
context: 'dict[str, Any] | None' = None,
extra: 'str | None' = None,
by_alias: 'bool | None' = None,
by_name: 'bool | None' = None
) → Self
```
Redéfinit model\_validate\_json pour gérer la reconstruction de Content à partir de JSON.
***
méthode `open`
```python theme={"system"}
open() → bool
```
Ouvre le fichier avec l'application par défaut du système d'exploitation.
Cette méthode s'appuie sur le mécanisme propre à la plateforme pour ouvrir le fichier avec l'application par défaut associée à son type.
**Retourne :**
* `bool` : True si le fichier a bien été ouvert, False sinon.
***
méthode `save`
```python theme={"system"}
save(dest: 'str | Path') → None
```
Copie le fichier vers le chemin de destination spécifié. Met à jour le nom de fichier et le chemin du contenu pour refléter la dernière copie enregistrée.
**Arguments :**
***
méthode `serialize_data`
```python theme={"system"}
serialize_data(data: 'bytes') → str
```
Lors de la sérialisation du modèle en mode json
***
méthode `to_data_url`
```python theme={"system"}
to_data_url(use_base64: 'bool' = True) → str
```
Construit une URL de données à partir du contenu.
* `dest` : chemin de destination vers lequel le fichier sera copié (string ou pathlib.Path). Le chemin de destination peut être un fichier ou un répertoire. Si dest n’a pas d’extension de fichier (par exemple .txt), la destination est considérée comme un répertoire.
**Arguments :**
* `use_base64` : si True, les données sont encodées en base64. Sinon, elles sont encodées en pourcentage (percent-encoding). Valeur par défaut : True.
**Retourne :**
Une URL de données sous forme de string.
***
classe `Conversation`
Une conversation. Regroupe les tours de conversation par conversation\_id (sans span).
`continue_parent_trace` contrôle l’isolation des traces pour les tours de conversation créés par cette conversation. Avec la valeur par défaut `False`, chaque tour de conversation démarre sa propre trace OTel (le choix adapté à la vue autonome de l’onglet Agents). Définissez `True` lorsque l’application dispose d’une trace externe (par exemple, une requête instrumentée par fastapi) qui doit englober l’appel d’agent.
**Champs Pydantic :**
* `conversation_id`: ``
* `conversation_name`: ``
* `agent_name`: ``
* `model`: ``
* `agent_id`: ``
* `agent_description`: ``
* `agent_version`: ``
* `include_content`: ``
* `continue_parent_trace`: ``
* `attributes`: `dict[str, typing.Any]`
```python theme={"system"}
start_turn(
user_message: 'str' = '',
model: 'str' = '',
agent_name: 'str' = '',
agent_id: 'str' = '',
agent_description: 'str' = '',
agent_version: 'str' = '',
system_instructions: 'list[str] | None' = None
) → Turn
```
Crée un nouveau tour de conversation. Termine automatiquement le tour de conversation précédent s’il est encore ouvert.
Définit la contextvar `_current_turn` afin que le tour de conversation soit accessible via `get_current_turn()`, qu’un gestionnaire de contexte soit utilisé ou non. Chacun des paramètres `agent_name` / `model` / `agent_id` / `agent_description` / `agent_version` reprend la valeur par défaut de la conversation s’il est laissé vide ; `continue_parent_trace` est hérité. Vous pouvez redéfinir n’importe lequel d’entre eux ultérieurement via `turn.record(...)`.
`system_instructions` (le prompt système de l'agent) est porté par le span invoke\_agent du tour de conversation ; vous pouvez également le définir ultérieurement en affectant l’attribut sur le `Turn` renvoyé, comme pour `start_llm`.
***
classe `Dataset`
Objet Dataset offrant un enregistrement simplifié et une gestion automatique des versions.
**Exemples :**
```python theme={"system"}
# Créer un dataset
dataset = Dataset(name='grammar', rows=[
{'id': '0', 'sentence': "He no likes ice cream.", 'correction': "He doesn't like ice cream."},
{'id': '1', 'sentence': "She goed to the store.", 'correction': "She went to the store."},
{'id': '2', 'sentence': "They plays video games all day.", 'correction': "They play video games all day."}
])
# Publier le dataset
weave.publish(dataset)
# Récupérer le dataset
dataset_ref = weave.ref('grammar').get()
# Accéder à un exemple précis
example_label = dataset_ref.rows[2]['sentence']
```
**Champs Pydantic :**
* `name`: `str | None`
* `description`: `str | None`
* `ref`: `trace.refs.ObjectRef | None`
* `rows`: `trace.table.Table | trace.vals.WeaveTable`
méthode `add_rows`
```python theme={"system"}
add_rows(rows: Iterable[dict]) → Dataset
```
Crée une nouvelle version du dataset en ajoutant des lignes au dataset existant.
Cette méthode permet d’ajouter des exemples à des datasets volumineux sans avoir à charger l’intégralité du dataset en mémoire.
**Arguments :**
* `rows` : les lignes à ajouter au dataset.
**Retourne :**
Le dataset mis à jour.
***
```python theme={"system"}
select(indices: Iterable[int]) → Self
```
Sélectionne des lignes du dataset à partir des indices fournis.
**Arguments :**
* `indices` : un itérable d’indices entiers indiquant les lignes à sélectionner.
**Retourne :**
Un nouvel objet Dataset contenant uniquement les lignes sélectionnées.
***
Configure une évaluation comprenant un ensemble d’évaluateurs et un dataset.
L’Appel à evaluation.evaluate(model) transmet les lignes d’un dataset à un modèle, en faisant correspondre les noms des colonnes du dataset aux noms des arguments de model.predict.
La méthode appelle ensuite tous les évaluateurs et enregistre les résultats dans Weave.
Pour prétraiter les lignes du dataset, vous pouvez transmettre une fonction à preprocess\_model\_input.
**Exemples :**
```python theme={"system"}
# Rassemblez vos exemples
examples = [
{"question": "What is the capital of France?", "expected": "Paris"},
{"question": "Who wrote 'To Kill a Mockingbird'?", "expected": "Harper Lee"},
{"question": "What is the square root of 64?", "expected": "8"},
]
# Définissez une fonction de score personnalisée
@weave.op
def match_score1(expected: str, model_output: dict) -> dict:
# Définissez ici la logique d'évaluation de la sortie du modèle
return {'match': expected == model_output['generated_text']}
@weave.op
def function_to_evaluate(question: str):
# ajoutez ici votre appel LLM et renvoyez la sortie
return {'generated_text': 'Paris'}
# Évaluez vos exemples à l'aide de fonctions de score
evaluation = Evaluation(
dataset=examples, scorers=[match_score1]
)
# Démarrez le suivi de l'évaluation
weave.init('intro-example')
# Exécutez l'évaluation
asyncio.run(evaluation.evaluate(function_to_evaluate))
```
**Champs Pydantic :**
* `name` : `str | None`
* `description` : `str | None`
* `ref` : `trace.refs.ObjectRef | None`
* `dataset` : ``
* `scorers` : `list[typing.Annotated[trace.op_protocol.Op | flow.scorer.Scorer, BeforeValidator(func=, json_schema_input_type=PydanticUndefined)]] | None`
* `preprocess_model_input` : `collections.abc.Callable[[dict], dict] | None`
* `trials` : ``
* `metadata` : `dict[str, typing.Any] | None`
* `evaluation_name` : `str | collections.abc.Callable[trace.call.Call, str] | None`
méthode `evaluate`
```python theme={"system"}
evaluate(model: Op | Model) → dict
```
***
```python theme={"system"}
get_eval_results(model: Op | Model) → EvaluationResults
```
***
méthode `get_evaluate_calls`
```python theme={"system"}
get_evaluate_calls() → PaginatedIterator[CallSchema, WeaveObject]
```
Récupère tous les Appels d’évaluation ayant utilisé cet objet Evaluation.
Notez que cette méthode renvoie un CallsIter plutôt qu’un Appel unique, car une même évaluation peut donner lieu à plusieurs Appels d’évaluation (par exemple, si vous exécutez la même évaluation plusieurs fois).
**Retourne :**
* `CallsIter` : Un itérateur sur des objets Appel représentant des runs d’évaluation.
**Exceptions levées :**
* `ValueError` : Si l’évaluation n’a pas de réf. (elle n’a pas encore été enregistrée ni exécutée).
**Exemples :**
```python theme={"system"}
evaluation = Evaluation(dataset=examples, scorers=[scorer])
await evaluation.evaluate(model) # Exécutez d’abord l’évaluation
calls = evaluation.get_evaluate_calls()
for call in calls:
print(f"Evaluation run: {call.id} at {call.started_at}")
```
***
méthode `get_score_calls`
```python theme={"system"}
get_score_calls() → dict[str, list[Call]]
```
Récupère les Appels d’évaluateur pour chaque run d’évaluation, regroupés par ID de trace.
**Retourne :**
* `dict[str, list[Call]]` : Un dictionnaire associant les ID de trace à des listes d’objets Appel d’évaluateur. Chaque ID de trace correspond à un run d’évaluation et la liste contient tous les Appels d’évaluateur exécutés au cours de ce run.
**Exemples :**
```python theme={"system"}
evaluation = Evaluation(dataset=examples, scorers=[accuracy_scorer, f1_scorer])
await evaluation.evaluate(model)
score_calls = evaluation.get_score_calls()
for trace_id, calls in score_calls.items():
print(f"Trace {trace_id}: {len(calls)} scorer calls")
for call in calls:
scorer_name = call.summary.get("weave", {}).get("trace_name")
print(f" Scorer: {scorer_name}, Output: {call.output}")
```
***
méthode `get_scores`
```python theme={"system"}
get_scores() → dict[str, dict[str, list[Any]]]
```
Extrait et organise les sorties des évaluateurs à partir des runs d’évaluation.
**Retourne :**
* `dict[str, dict[str, list[Any]]]` : Une structure de dictionnaire imbriqué dans laquelle :
* les clés de premier niveau sont les ID de trace (runs d’évaluation) ;
* les clés de second niveau sont les noms des évaluateurs ;
* les valeurs sont des listes de sorties d’évaluateur pour le run et l’évaluateur correspondants.
**Exemples :**
```python theme={"system"}
evaluation = Evaluation(dataset=examples, scorers=[accuracy_scorer, f1_scorer])
await evaluation.evaluate(model)
scores = evaluation.get_scores()
# Accéder aux scores par trace et par évaluateur
for trace_id, trace_scores in scores.items():
print(f"Evaluation run {trace_id}:")
for scorer_name, outputs in trace_scores.items():
print(f" {scorer_name}: {outputs}")
```
Sortie attendue :
```
{
"trace_123": {
"accuracy_scorer": [{"accuracy": 0.85}],
"f1_scorer": [{"f1": 0.78}]
}
}
```
***
Cette classe fournit une interface impérative pour journaliser des évaluations.
Une évaluation démarre automatiquement lorsque la première prédiction est journalisée à l’aide de la méthode `log_prediction`, et se termine lorsque la méthode `log_summary` est appelée.
Chaque fois que vous journalisez une prédiction, un objet `ScoreLogger` vous est renvoyé. Cet objet vous permet de journaliser des scores et des métadonnées propres à cette prédiction. Pour plus d'informations, voir la classe `ScoreLogger`.
Utilisation de base – journaliser directement des prédictions avec leurs entrées et sorties :
```python theme={"system"}
ev = EvaluationLogger()
# Journaliser des prédictions dont les entrées/sorties sont connues
pred = ev.log_prediction(inputs={'q': 'Hello'}, outputs={'a': 'Hi there!'})
pred.log_score("correctness", 0.9)
# Terminer l’évaluation
ev.log_summary({"avg_score": 0.9})
```
Utilisation avancée : utiliser un gestionnaire de contexte pour les sorties dynamiques et les opérations imbriquées :
```python theme={"system"}
ev = EvaluationLogger()
# Utilisez un gestionnaire de contexte pour capturer des opérations imbriquées
with ev.log_prediction(inputs={'q': 'Hello'}) as pred:
# Toute opération effectuée ici (comme un appel LLM) devient automatiquement
# un enfant de l’appel de prédiction
response = your_llm_call(...)
pred.output = response.content
pred.log_score("correctness", 0.9)
# Terminer l’évaluation
ev.log_summary({"avg_score": 0.9})
```
```python theme={"system"}
fail(exception: 'BaseException') → None
```
Méthode utilitaire permettant de marquer l’évaluation comme ayant échoué à l’aide d’une exception.
***
méthode `finish`
```python theme={"system"}
finish(exception: 'BaseException | None' = None) → None
```
Libère explicitement les ressources de l’évaluation sans journaliser de synthèse.
Garantit que tous les Appels de prédiction ainsi que l’Appel principal de l’évaluation sont finalisés. Cette méthode est appelée automatiquement lorsque le logger est utilisé comme gestionnaire de contexte.
***
méthode `log_example`
```python theme={"system"}
log_example(
inputs: 'dict[str, Any]',
output: 'Any',
scores: 'dict[str, ScoreType]'
) → None
```
Journalise un exemple complet avec les entrées, la sortie et les scores.
Cette méthode utilitaire combine log\_prediction et log\_score lorsque vous disposez de toutes les données dès le départ.
**Arguments :**
* `inputs` : les données d’entrée de la prédiction
* `output` : la valeur de sortie
* `scores` : dictionnaire associant les noms des évaluateurs aux valeurs de score
**Exemple :**
```python theme={"system"}
ev = EvaluationLogger()
ev.log_example(
inputs={'q': 'What is 2+2?'},
output='4',
scores={'correctness': 1.0, 'fluency': 0.9}
)
```
***
méthode `log_prediction`
```python theme={"system"}
log_prediction(inputs: 'dict[str, Any]', output: 'Any' = None) → ScoreLogger
```
Journalise une prédiction dans l’Évaluation.
Renvoie un ScoreLogger utilisable directement ou comme gestionnaire de contexte.
**Arguments :**
* `inputs` : les données d’entrée de la prédiction
* `output` : la valeur de sortie. Valeur par défaut : None. Peut être définie ultérieurement via pred.output.
**Retourne :**
Un ScoreLogger permettant de journaliser des scores et, si besoin, de finaliser la prédiction.
Exemple (utilisation directe) :
* `pred = ev.log_prediction({'q'`: '...'}, output="answer") pred.log\_score("correctness", 0.9) pred.finish()
Exemple (gestionnaire de contexte) :
* `with ev.log_prediction({'q'`: '...'}) as pred: response = model(...) pred.output = response pred.log\_score("correctness", 0.9) # Appelle automatiquement finish() à la sortie
***
méthode `log_summary`
```python theme={"system"}
log_summary(summary: 'dict | None' = None, auto_summarize: 'bool' = True) → None
```
Journalise un dict de synthèse dans l’Évaluation.
Cette méthode calcule la synthèse, appelle l’op summarize, puis finalise l’évaluation : il n’est alors plus possible de journaliser de prédictions ni de scores.
***
méthode `set_view`
```python theme={"system"}
set_view(
name: 'str',
content: 'Content | str',
extension: 'str | None' = None,
mimetype: 'str | None' = None,
metadata: 'dict[str, Any] | None' = None,
encoding: 'str' = 'utf-8'
) → None
```
Joint une vue à la synthèse de l’Appel principal de l'évaluation, sous `weave.views`.
Enregistre le contenu fourni en tant qu'objet dans le projet et écrit son URI de référence sous `summary.weave.views.` pour l’Appel `evaluate` de l'évaluation. Les entrées de type string sont encapsulées en tant que contenu textuel à l'aide de `Content.from_text`, avec l'extension ou le type MIME fourni.
**Arguments :**
* `name` : nom de la vue à afficher, utilisé comme clé sous `summary.weave.views`.
* `content` : instance de `weave.Content` ou string à sérialiser.
* `extension` : extension de fichier facultative pour les entrées de contenu de type string.
* `mimetype` : type MIME facultatif pour les entrées de contenu de type string.
* `metadata` : métadonnées facultatives jointes au `Content` nouvellement créé.
* `encoding` : encodage du texte pour les entrées de contenu de type string.
**Retourne :**
None
**Exemples :**
` import weave`
> > > ev = weave.EvaluationLogger()
> > > ev.set\_view("report", "# Report", extension="md")
***
classe `File`
Classe représentant un fichier, avec des informations sur son chemin, son type MIME et sa taille.
Obtenir le nom du fichier.
* `path` : chemin du fichier (string ou pathlib.Path)
* `mimetype` : type MIME facultatif du fichier ; déduit de l’extension s’il n’est pas fourni
**Retourne :**
* `str` : le nom du fichier, sans le chemin du répertoire.
***
méthode `open`
```python theme={"system"}
open() → bool
```
Ouvre le fichier avec l'application par défaut du système d'exploitation.
Cette méthode s'appuie sur le mécanisme propre à la plateforme pour ouvrir le fichier avec l'application par défaut associée à son type.
**Retourne :**
* `bool` : True si le fichier a bien été ouvert, False sinon.
***
méthode `save`
```python theme={"system"}
save(dest: 'str | Path') → None
```
Copie le fichier vers le chemin de destination spécifié.
**Arguments :**
***
classe `LLM`
Un Appel d’API LLM. Correspond à un span OTel de chat.
* `dest` : chemin de destination vers lequel le fichier sera copié (string ou pathlib.Path). Le chemin de destination peut être un fichier ou un répertoire.
**Champs Pydantic :**
* `model`: ``
* `provider_name`: ``
* `response_id`: ``
* `response_model`: ``
* `output_type`: ``
* `system_instructions`: `list[str]`
* `usage`: ``
* `reasoning`: ``
* `finish_reasons`: `list[str]`
* `input_messages`: `list[conversation.types.Message]`
* `output_messages`: `list[conversation.types.Message]`
* `media_attachments`: `list[conversation.types.MediaAttachment]`
* `request_temperature`: `float | None`
* `request_max_tokens`: `int | None`
* `request_top_p`: `float | None`
* `request_frequency_penalty`: `float | None`
* `request_presence_penalty`: `float | None`
* `request_seed`: `int | None`
* `request_stop_sequences`: `list[str]`
* `request_choice_count`: `int | None`
* `started_at`: `datetime.datetime | None`
* `ended_at`: `datetime.datetime | None`
méthode `add_event`
```python theme={"system"}
add_event(
name: 'str',
attributes: 'dict[str, Any] | None' = None,
timestamp: 'datetime | None' = None
) → Self
```
Enregistre un événement de span OTel à un instant donné au sein de ce span.
.. deprecated:
\`\`\` Enregistrez plutôt ces données avec `set_attributes`. OpenTelemetry abandonne progressivement l’API Span Event (`Span.add_event`). `add_event` fonctionne toujours, et les données d’événements de span existantes restent valides. Voir [https://opentelemetry.io/blog/2026/deprecating-span-events/](https://opentelemetry.io/blog/2026/deprecating-span-events/).
````
À utiliser pour les données de marqueur ou de cycle de vie : demandes d’autorisation (par ex. ``weave.permission_request``), transitions de cycle de vie (par ex. ``spawned`` / ``streaming`` / ``finished``) ou tout jalon personnalisé survenant à un instant précis de la durée de vie du span (contrairement à un attribut, qui est une propriété du span dans son ensemble).
Doit être appelée entre le début et la fin du span (à l’intérieur du bloc ``with``). En dehors de cette fenêtre, l’Appel n’a aucun effet et journalise un avertissement.
---
### méthode `attach_media`
```python
attach_media(
content: 'bytes | str' = '',
uri: 'str' = '',
file_id: 'str' = '',
mime_type: 'str' = '',
modality: 'str' = ''
) → LLM
````
Joindre un média à cet Appel LLM.
Crée un objet `Content` à partir des données fournies, le publie pour obtenir une réf. `weave://` et ne stocke que cette réf. Vous devez fournir exactement un des paramètres suivants : `content`, `uri` ou `file_id`.
La publication (qui téléverse le média) s’exécute sur un thread d’arrière-plan dédié : l’Appel rend donc la main immédiatement, sans bloquer l’appelant. Un thread est lancé par pièce jointe, ce qui permet d’effectuer plusieurs téléversements en parallèle. L’objet `MediaAttachment` provisoire est ajouté de manière synchrone, et sa `ref` est renseignée une fois le téléversement terminé. Les réfs sont toujours renseignées avant l’émission du span (le chemin de construction attend la fin des téléversements en cours via `_await_uploads`).
***
méthode `attach_media_url`
```python theme={"system"}
attach_media_url(url: 'str', modality: 'str' = '') → LLM
```
Joint une URL de média à cet Appel LLM.
Raccourci pratique pour `attach_media` dans le cas courant où l’appelant dispose d’une URL sous forme de string provenant d’un message en amont. Les URL `data:` sont décodées en octets puis publiées ; les URI simples sont récupérées puis publiées. Les URL vides sont ignorées. Renvoie `self` pour permettre le chaînage.
***
```python theme={"system"}
output(content: 'str') → LLM
```
Ajoute un message assistant à output\_messages.
***
méthode `record`
```python theme={"system"}
record(
input_messages: 'list[Message] | None' = None,
output_messages: 'list[Message] | None' = None,
media_attachments: 'list[MediaAttachment] | None' = None,
usage: 'Usage | None' = None,
reasoning: 'Reasoning | str | None' = None,
response_id: 'str | None' = None,
response_model: 'str | None' = None,
finish_reasons: 'list[str] | None' = None,
output_type: 'str | None' = None
) → LLM
```
Définit plusieurs champs d’appel LLM en un seul appel.
Les agents instrumentés manuellement construisent généralement un span de chat en attribuant au moins huit champs distincts à la fin d’un appel LLM (`input_messages`, `output_messages`, `usage`, `response_id`, etc.). `record(...)` les regroupe en un seul appel avec arguments nommés, ce qui permet de garder compact le code d’enregistrement.
Seuls les champs explicitement transmis (autres que `None`) sont appliqués ; les valeurs existantes sont conservées. `reasoning` accepte soit une instance de `Reasoning`, soit une simple chaîne de caractères (encapsulée automatiquement). Renvoie `self` pour permettre le chaînage.
***
méthode `set_attributes`
```python theme={"system"}
set_attributes(attributes: 'dict[str, Any]') → Self
```
Ajoute des attributs OTel arbitraires à ce span.
Passez un dict, que vous ayez une seule clé ou plusieurs : pour une seule clé, utilisez `span.set_attributes({"weave.tag": "value"})`. Équivalent de `Span.set_attributes` d'OTel.
Doit être appelée entre le début et la fin du span, c'est-à-dire à l'intérieur d'un bloc `with`. En dehors de cette fenêtre, l'appel est sans effet (no-op) et journalise un avertissement. Pour l'ingestion par lots, renseignez directement les champs déclarés de l'objet et passez celui-ci à `log_turn` / `log_conversation`.
***
méthode `think`
```python theme={"system"}
think(content: 'str') → LLM
```
Définit le contenu du raisonnement (chaîne de pensée).
***
Un objet Markdown pouvant faire l’objet d’un rendu.
**Arguments :**
* `markup` (str) : Une chaîne de caractères contenant du markdown.
* `code_theme` (str, facultatif) : Thème Pygments pour les blocs de code. Valeur par défaut : "monokai". Voir [https://pygments.org/styles/](https://pygments.org/styles/) pour les thèmes de code disponibles.
* `justify` (JustifyMethod, facultatif) : Valeur de justification des paragraphes. Valeur par défaut : None.
* `style` (Union\[str, Style], facultatif) : Style facultatif à appliquer au markdown.
* `hyperlinks` (bool, facultatif) : Active les liens hypertextes. Valeur par défaut : `True`.
Un média joint à un appel LLM.
Contient toujours une URI de réf. de contenu `weave://`. Les octets bruts, les URL de données et les URI HTTP simples sont convertis en objet `Content` publié par `LLM.attach_media` avant d’être stockés ici.
* `inline_code_lexer` : (str, facultatif) : analyseur lexical à utiliser si la coloration syntaxique du code en ligne est activée. Valeur par défaut : None.
* `inline_code_theme` : (Optional\[str], facultatif) : thème Pygments pour la coloration syntaxique du code en ligne, ou None pour désactiver la coloration. Valeur par défaut : None.
**Champs Pydantic :**
* `ref`: ``
* `modality`: ``
* `mime_type`: ``
***
classe `Message`
Un message unique au sein d’une conversation.
Deux styles de construction sont pris en charge :
1. Plat (rétrocompatible, pratique pour du texte brut) : `Message(role="assistant", content="Hi there")`
2. Parties explicites (plus complet — prend en charge les appels d’outil, le mélange de raisonnement et de texte, ainsi que les médias intégrés) : `Message(role="assistant", parts=[TextPart(content="Let me check"), ToolCallPart(id="c1", name="get_weather", arguments='{...}')])`
Lorsque `parts` n’est pas vide, il constitue la représentation canonique. S’il est vide, le sérialiseur génère un unique TextPart (ou ToolCallResponsePart pour `role="tool"`) à partir des champs plats.
**Champs Pydantic :**
* `role`: `typing.Literal['user', 'assistant', 'system', 'tool']`
* `content`: ``
* `tool_call_id`: ``
* `tool_name`: ``
* `parts`: `list[typing.Annotated[conversation.types.TextPart | conversation.types.ReasoningPart | conversation.types.ToolCallPart | conversation.types.ToolCallResponsePart | conversation.types.BlobPart | conversation.types.UriPart | conversation.types.FilePart, FieldInfo(annotation=NoneType, required=True, discriminator='type')]]`
classmethod `assistant`
```python theme={"system"}
assistant(
text: 'str' = '',
tool_calls: 'list[ToolCallPart] | None' = None
) → Message
```
Construit un message de l’assistant avec, de manière facultative, du texte et des appels d’outil.
Utilisez du texte brut pour les réponses simples ; passez `tool_calls` lorsque l’assistant fait appel à un ou plusieurs outils. Lorsque les deux sont présents, le texte est émis sous la forme d’un `TextPart` initial, suivi de chaque `ToolCallPart`, afin que la vue du chat les affiche en ligne.
***
classmethod `system`
```python theme={"system"}
system(text: 'str') → Message
```
Construit un message système à partir de texte brut.
***
classmethod `tool_result`
```python theme={"system"}
tool_result(call_id: 'str', output: 'Any') → Message
```
Construit un message de résultat d’outil pour un appel d’outil demandé précédemment.
`output` peut être une chaîne de caractères, un dict, une liste, un scalaire ou `None`. Le `ToolCallResponsePart` sous-jacent encode en JSON les valeurs autres que des chaînes.
***
classmethod `user`
```python theme={"system"}
user(text: 'str') → Message
```
Construit un message utilisateur à partir de texte brut.
***
```python theme={"system"}
format(**kwargs: Any) → list
```
***
méthode `format_message`
```python theme={"system"}
format_message(message: dict, **kwargs: Any) → dict
```
Formate un seul message en remplaçant les variables de modèle.
Cette méthode délègue la logique de formatage proprement dite à la fonction autonome format\_message\_with\_template\_vars.
***
Destiné à capturer une combinaison de code et de données qui traite une entrée. Par exemple, il peut appeler un LLM avec un prompt pour faire une prédiction ou générer du texte.
Lorsque vous modifiez les attributs ou le code qui définit votre modèle, ces modifications sont journalisées et la version est mise à jour. Vous pouvez ainsi comparer les prédictions entre les différentes versions de votre modèle. Utilisez cette fonctionnalité pour itérer sur vos prompts ou pour essayer le dernier LLM et comparer les prédictions obtenues avec différents paramètres
**Exemples :**
```python theme={"system"}
class YourModel(Model):
attribute1: str
attribute2: int
@weave.op
def predict(self, input_data: str) -> dict:
# Placez ici la logique du modèle
prediction = self.attribute1 + ' ' + input_data
return {'pred': prediction}
```
**Champs Pydantic :**
* `name` : `str | None`
* `description` : `str | None`
* `ref` : `trace.refs.ObjectRef | None`
```python theme={"system"}
model_post_init(context: Any) → None
```
Normalise `op_names` lors de la construction lorsqu’un client est disponible.
La publication ne dispose d’aucun hook par objet. Pour couvrir également un simple `weave.publish(monitor)` (sans `activate()`), les noms courts sont donc développés ici : quiconque publie a généralement déjà appelé `weave.init`, si bien que le client est défini au moment de la construction du moniteur.
Dans plusieurs cas d’usage, la construction se fait sans client : tests unitaires, inspection ou désérialisation d’un moniteur stocké dans un worker, par exemple. La vérification sur `get_weave_client()` autorise la construction sans client. La normalisation n’a alors pas lieu, mais cela ne devrait pas poser de problème, car les moniteurs stockés contiennent déjà des réf. complètes.
Il existe un cas limite dans lequel un moniteur peut être créé avec le SDK sans être normalisé : lorsque l’utilisateur construit le moniteur, appelle ensuite weave.init, puis le publie. Pour contourner ce problème, vous pouvez appeler `activate()` ou `deactivate()`.
***
classe `Object`
Classe de base pour les objets Weave pouvant être suivis et versionnés.
Cette classe étend la classe BaseModel de Pydantic afin de fournir des fonctionnalités propres à Weave pour le suivi, le référencement et la sérialisation des objets. Les objets peuvent avoir un nom, une description et des références, qui permettent de les stocker dans le système Weave et de les en récupérer.
**Attributs :**
* `name` (str | None) : Nom lisible de l’objet.
* `description` (str | None) : Description de ce que représente l’objet.
* `ref` (ObjectRef | None) : Référence à l’objet dans le système Weave.
**Exemples :**
```python theme={"system"}
# Créer un objet simple
obj = Object(name="my_object", description="A test object")
# Créer un objet à partir d’un URI
obj = Object.from_uri("weave:///entity/project/object:digest")
```
**Champs Pydantic :**
* `name` : `str | None`
* `description` : `str | None`
* `ref` : `trace.refs.ObjectRef | None`
classmethod `from_uri`
```python theme={"system"}
from_uri(uri: str, objectify: bool = True) → Self
```
Crée une instance d’objet à partir d’un URI Weave.
**Arguments :**
* `uri` (str) : L’URI Weave qui pointe vers l’objet.
* `objectify` (bool) : Indique si le résultat doit être converti en objet. Valeur par défaut : True.
**Retourne :**
* `Self` : Une instance de la classe créée à partir de l’URI.
**Exceptions levées :**
* `NotImplementedError` : Si la classe n'implémente pas les méthodes requises pour la désérialisation.
**Exemples :**
```python theme={"system"}
obj = MyObject.from_uri("weave:///entity/project/object:digest")
```
***
classmethod `handle_relocatable_object`
```python theme={"system"}
handle_relocatable_object(
v: Any,
handler: ValidatorFunctionWrapHandler,
info: ValidationInfo
) → Any
```
Gère la validation des objets relocalisables, notamment ObjectRef et WeaveObject.
Ce validateur traite les cas particuliers où l’entrée est un ObjectRef ou un WeaveObject qui doit être correctement converti en instance standard de Object. Il garantit que les références sont conservées et que les types ignorés sont correctement pris en charge au cours du processus de validation.
**Arguments :**
* `v` (Any) : La valeur à valider.
* `handler` (ValidatorFunctionWrapHandler) : Le gestionnaire de validation pydantic standard.
* `info` (ValidationInfo) : Informations sur le contexte de validation.
**Retourne :**
* `Any` : L’instance d’objet validée.
**Exemples :**
Cette méthode est appelée automatiquement lors de la création et de la validation d’un objet. Elle gère notamment les cas suivants : \`\`\`python
Lorsqu’un ObjectRef est transmis
obj = MyObject(some\_object\_ref)
Lorsqu’un WeaveObject est transmis
obj = MyObject(some\_weave\_object)
````
---
### classmethod `strip_weave_serialization_metadata`
```python
strip_weave_serialization_metadata(data: Any) → Any
````
Supprime les métadonnées de sérialisation de Weave des entrées de type dict.
La sérialisation de Weave ajoute \_type, \_class\_name et \_bases aux dicts afin de permettre la reconstruction du type. Il ne s’agit pas de véritables champs du modèle : ils doivent donc être supprimés avant la validation Pydantic, qui utilise extra="forbid".
***
```python theme={"system"}
ui_url() → str | None
```
URL permettant d’afficher cette vue enregistrée dans l’interface utilisateur.
Notez qu’il s’agit de la page de « résultats » contenant les traces, etc., et non de l’URL de l’objet vue.
***
Alias obsolète de :class:`weave.Conversation`.
Accepte les anciens champs de constructeur `session_id` / `session_name` et les expose également sous forme de propriétés en lecture/écriture, redirigées vers `conversation_id` / `conversation_name`. Dans la classe `Session` d’origine, il s’agissait de champs de modèle : l’ancien code qui lit ou attribue `s.session_id` continue donc de fonctionner.
Un appel d’agent délégué au sein d’un tour de conversation.
Correspond à un span OTel `invoke_agent` imbriqué dans la même trace.
**Champs Pydantic :**
* `name`: ``
* `model`: ``
* `agent_id`: ``
* `agent_description`: ``
* `agent_version`: ``
* `system_instructions`: `list[str]`
* `started_at`: `datetime.datetime | None`
* `ended_at`: `datetime.datetime | None`
méthode `add_event`
```python theme={"system"}
add_event(
name: 'str',
attributes: 'dict[str, Any] | None' = None,
timestamp: 'datetime | None' = None
) → Self
```
Enregistre un événement de span OTel à un instant donné dans ce span.
.. deprecated:
\`\`\` Enregistrez plutôt ces données avec `set_attributes`. OpenTelemetry abandonne progressivement l’API Span Event (`Span.add_event`). `add_event` fonctionne toujours et les données d’événements de span existantes restent valides. Voir [https://opentelemetry.io/blog/2026/deprecating-span-events/](https://opentelemetry.io/blog/2026/deprecating-span-events/).
````
À utiliser pour les données de marqueur ou de cycle de vie : demandes d’autorisation (par ex. ``weave.permission_request``), transitions de cycle de vie (par ex. ``spawned`` / ``streaming`` / ``finished``) ou tout jalon personnalisé survenant à un instant précis pendant la durée de vie du span (contrairement à un attribut, qui est une propriété du span dans son ensemble).
Doit être appelée entre le début et la fin du span (à l’intérieur du bloc ``with``). En dehors de cette fenêtre, l’appel n’a aucun effet et journalise un avertissement.
---
### méthode `end`
```python
end() → None
````
***
méthode `llm`
```python theme={"system"}
llm(
model: 'str' = '',
provider_name: 'str' = '',
system_instructions: 'list[str] | None' = None
) → LLM
```
Démarre un appel LLM au sein de ce sous-agent.
Définit la contextvar `_current_llm` afin que le LLM soit accessible via `get_current_llm()`, qu'un gestionnaire de contexte soit utilisé ou non.
***
méthode `record`
```python theme={"system"}
record(
name: 'str | None' = None,
model: 'str | None' = None,
system_instructions: 'list[str] | None' = None,
agent_id: 'str | None' = None,
agent_description: 'str | None' = None,
agent_version: 'str | None' = None
) → SubAgent
```
Définit plusieurs champs du sous-agent en un seul appel.
Regroupe en un seul appel à arguments nommés les affectations champ par champ qu’un agent instrumenté manuellement effectuerait sinon sur un sous-agent (`system_instructions`, `agent_id`, ...). Seuls les champs explicitement transmis (différents de `None`) sont appliqués ; les valeurs existantes sont conservées. Renvoie `self` pour permettre le chaînage. Fonctionne comme `Turn.record` / `LLM.record`.
Remarque : dans le cas du streaming (`with`), le nom du span du sous-agent est défini à partir de `name` lors de `__enter__`. Si vous souhaitez que le nom du span reflète `name`, définissez-le donc via `start_subagent` / `turn.subagent` plutôt que via `record` ; `record` met tout de même à jour l’attribut `gen_ai.agent.name`.
***
méthode `set_attributes`
```python theme={"system"}
set_attributes(attributes: 'dict[str, Any]') → Self
```
Appose des attributs OTel arbitraires sur ce span.
Passez un dict, que vous ayez une seule clé ou plusieurs : pour une seule clé, utilisez `span.set_attributes({"weave.tag": "value"})`. Équivalent de `Span.set_attributes` d'OTel.
Doit être appelé entre le début et la fin du span, c'est-à-dire à l'intérieur d'un bloc `with`. En dehors de cette fenêtre, l'appel est sans effet (no-op) et journalise un avertissement. Pour l'ingestion par lots, renseignez directement les champs déclarés de l'objet, puis passez-le à `log_turn` / `log_conversation`.
***
méthode `tool`
```python theme={"system"}
tool(name: 'str', arguments: 'str' = '', tool_call_id: 'str' = '') → Tool
```
Démarre une exécution d’outil dans ce sous-agent.
***
```python theme={"system"}
append(row: 'dict') → None
```
Ajoute une ligne au tableau.
***
méthode `pop`
```python theme={"system"}
pop(index: 'int') → None
```
Supprime du tableau la ligne située à l’index spécifié.
***
classe `ContextAwareThread`
Un Thread qui exécute des fonctions avec le contexte de l’appelant.
Il s’agit d’un remplacement direct de threading.Thread qui garantit que les appels se comportent comme prévu à l’intérieur du thread. Weave exige que certaines contextvars soient définies (voir call\_context.py), mais les nouveaux threads ne copient pas automatiquement le contexte du parent, ce qui peut entraîner la perte du contexte d’appel, ce qui est fâcheux ! Cette classe automatise la copie des contextvars : ce thread « fonctionne tout simplement », comme l’utilisateur s’y attend sans doute.
Vous pouvez obtenir le même résultat sans cette classe en écrivant plutôt :
```python theme={"system"}
def run_with_context(func, *args, **kwargs):
context = copy_context()
def wrapper():
context.run(func, *args, **kwargs)
return wrapper
thread = threading.Thread(target=run_with_context(your_func, *args, **kwargs))
thread.start()
```
Valeur booléenne indiquant si ce thread est un thread démon.
Elle doit être définie avant l’appel à start(), sinon une RuntimeError est levée. Sa valeur initiale est héritée du thread qui le crée ; le thread principal n’étant pas un thread démon, tous les threads créés dans le thread principal ont par défaut daemon = False.
L’ensemble du programme Python se termine lorsqu’il ne reste plus que des threads démons.
***
property ident
Identifiant de ce thread, ou None s’il n’a pas encore été démarré.
Il s’agit d’un entier non nul. Voir la fonction get\_ident(). Les identifiants de thread peuvent être réutilisés lorsqu’un thread se termine et qu’un autre thread est créé. L’identifiant reste disponible même après la fin du thread.
***
property name
Chaîne de caractères utilisée uniquement à des fins d’identification.
Elle n’a aucune valeur sémantique. Plusieurs threads peuvent porter le même nom. Le nom initial est défini par le constructeur.
***
property native\_id
Identifiant entier natif de ce thread, ou None s’il n’a pas encore été démarré.
Il s’agit d’un entier positif ou nul. Voir la fonction get\_native\_id(). Cette valeur correspond à l’identifiant du thread tel qu’indiqué par le noyau.
***
méthode `run`
```python theme={"system"}
run() → None
```
***
classe `ThreadContext`
Objet de contexte donnant accès aux informations sur le thread et le tour de conversation en cours.
méthode `__init__`
```python theme={"system"}
__init__(thread_id: 'str | None')
```
Initialise ThreadContext avec le thread\_id spécifié.
**Arguments :**
***
property thread\_id
Obtenir le thread\_id de ce contexte.
* `thread_id` : L’identifiant du thread de ce contexte, ou None si le suivi est désactivé.
**Retourne :**
L’identifiant du thread, ou None si le suivi des threads est désactivé.
***
property turn\_id
Obtient le turn\_id actuel à partir du contexte actif.
**Retourne :**
Le turn\_id actuel s’il est défini, sinon None.
***
classe `ContextAwareThreadPoolExecutor`
Un ThreadPoolExecutor qui exécute des fonctions avec le contexte de l’appelant.
Cette classe remplace directement concurrent.futures.ThreadPoolExecutor et garantit que les appels Weave se comportent comme prévu dans l’exécuteur. Weave exige que certaines contextvars soient définies (voir call\_context.py), mais les nouveaux threads ne copient pas automatiquement le contexte du thread parent, ce qui peut entraîner la perte du contexte d’appel, ce qu’il faut éviter ! Cette classe automatise la copie des contextvars, de sorte que cet exécuteur « fonctionne tout simplement », comme l’utilisateur s’y attend probablement.
Vous pouvez obtenir le même résultat sans cette classe en écrivant plutôt :
```python theme={"system"}
with concurrent.futures.ThreadPoolExecutor() as executor:
contexts = [copy_context() for _ in range(len(vals))]
def _wrapped_fn(*args):
return contexts.pop().run(fn, *args)
executor.map(_wrapped_fn, vals)
```
Une exécution d’outil. Correspond à un span OTel execute\_tool.
`arguments` et `result` utilisent l’annotation `JSONString` : les appelants peuvent attribuer un dict, une liste ou un scalaire, que le SDK encode en JSON lors de la construction ou de l’attribution. La valeur stockée est toujours une chaîne de caractères, conformément au format de transmission défini par les conventions sémantiques GenAI.
**Champs Pydantic :**
* `name` : ``
* `arguments` : ``
* `result` : ``
* `tool_call_id` : ``
* `tool_type` : ``
* `tool_description` : ``
* `tool_definitions` : ``
* `duration_ms` : ``
* `started_at` : `datetime.datetime | None`
* `ended_at` : `datetime.datetime | None`
méthode `add_event`
```python theme={"system"}
add_event(
name: 'str',
attributes: 'dict[str, Any] | None' = None,
timestamp: 'datetime | None' = None
) → Self
```
Enregistre un événement de span OTel à un instant donné au sein de ce span.
.. deprecated:
\`\`\` Enregistrez plutôt ces données avec `set_attributes`. OpenTelemetry est en train d’abandonner progressivement l’API Span Event (`Span.add_event`). `add_event` fonctionne toujours et les données d’événements de span existantes restent valides. Voir [https://opentelemetry.io/blog/2026/deprecating-span-events/](https://opentelemetry.io/blog/2026/deprecating-span-events/).
````
À utiliser pour les données de marqueur ou de cycle de vie : demandes d’autorisation (par ex. ``weave.permission_request``), transitions de cycle de vie (par ex. ``spawned`` / ``streaming`` / ``finished``) ou tout jalon personnalisé qui survient à un instant précis pendant la durée de vie du span (contrairement à un attribut, qui est une propriété du span dans son ensemble).
Doit être appelée entre le début et la fin du span (dans le bloc ``with``). En dehors de cette fenêtre, l’appel est sans effet et journalise un avertissement.
---
### method `end`
```python
end() → None
````
***
méthode `set_attributes`
```python theme={"system"}
set_attributes(attributes: 'dict[str, Any]') → Self
```
Appose des attributs OTel arbitraires sur ce span.
Passez un dict, que vous ayez une seule clé ou plusieurs : pour une seule clé, utilisez `span.set_attributes({"weave.tag": "value"})`. Équivalent de `Span.set_attributes` d'OTel.
Doit être appelée entre le début et la fin du span, c'est-à-dire à l'intérieur d'un bloc `with`. En dehors de cet intervalle, l'appel n'a aucun effet (no-op) et journalise un avertissement. Pour une ingestion par lots, renseignez directement les champs déclarés de l'objet, puis passez-le à `log_turn` / `log_conversation`.
***
classe `Turn`
Un échange entre l’utilisateur et l’agent. Correspond à un span OTel invoke\_agent.
Par défaut, chaque tour de conversation démarre sa propre trace OTel (`continue_parent_trace=False`) : l’onglet Agents affiche donc une trace par tour de conversation. Définissez `continue_parent_trace=True` sur la Conversation (ou directement sur le Turn) lorsqu’une trace externe est déjà active et que vous souhaitez y imbriquer l’appel d’agent — par exemple, dans une requête instrumentée par fastapi.
**Champs Pydantic :**
* `agent_name`: ``
* `model`: ``
* `agent_id`: ``
* `agent_description`: ``
* `agent_version`: ``
* `system_instructions`: `list[str]`
* `messages`: `list[conversation.types.Message]`
* `spans`: `list[conversation.conversation.LLM | conversation.conversation.Tool | conversation.conversation.SubAgent]`
* `continue_parent_trace`: ``
* `started_at`: `datetime.datetime | None`
* `ended_at`: `datetime.datetime | None`
méthode `add_event`
```python theme={"system"}
add_event(
name: 'str',
attributes: 'dict[str, Any] | None' = None,
timestamp: 'datetime | None' = None
) → Self
```
Enregistre un événement de span OTel à un instant donné dans ce span.
.. deprecated:
\`\`\` Enregistrez plutôt ces données avec `set_attributes`. OpenTelemetry abandonne progressivement l’API Span Event (`Span.add_event`). `add_event` fonctionne toujours et les données d’événements de span existantes restent valides. Voir [https://opentelemetry.io/blog/2026/deprecating-span-events/](https://opentelemetry.io/blog/2026/deprecating-span-events/).
````
À utiliser pour les données de marqueur ou de cycle de vie : demandes d’autorisation (par ex. ``weave.permission_request``), transitions de cycle de vie (par ex. ``spawned`` / ``streaming`` / ``finished``) ou tout jalon personnalisé qui survient à un instant précis pendant la durée de vie du span (contrairement à un attribut, qui est une propriété du span dans son ensemble).
Doit être appelé entre le début et la fin du span (à l’intérieur du bloc ``with``). En dehors de cet intervalle, l’appel est sans effet et journalise un avertissement.
---
### method `end`
```python
end() → None
````
***
méthode `llm`
```python theme={"system"}
llm(
model: 'str' = '',
provider_name: 'str' = '',
system_instructions: 'list[str] | None' = None
) → LLM
```
Démarre un appel LLM (span de chat, enfant de ce tour de conversation).
Définit la contextvar `_current_llm` afin que le LLM soit accessible via `get_current_llm()`, qu’un gestionnaire de contexte soit utilisé ou non.
***
```python theme={"system"}
record(
messages: 'list[Message] | None' = None,
system_instructions: 'list[str] | None' = None,
agent_name: 'str | None' = None,
model: 'str | None' = None,
agent_id: 'str | None' = None,
agent_description: 'str | None' = None,
agent_version: 'str | None' = None
) → Turn
```
Définit plusieurs champs du tour de conversation en un seul appel.
Regroupe en un seul appel à arguments nommés les affectations champ par champ qu’un agent instrumenté manuellement devrait sinon effectuer sur un tour de conversation (`system_instructions`, `agent_id`, ...). Seuls les champs explicitement transmis (non `None`) sont appliqués ; les valeurs existantes sont conservées. `messages` **remplace** les messages existants du tour de conversation (contrairement à `Turn.user(...)`, qui ajoute un seul message). Renvoie `self` pour permettre le chaînage. Fonctionne comme `LLM.record`.
Remarque : sur le chemin de streaming (`with`), le span du tour de conversation est nommé d’après `agent_name` lors de `__enter__`. Si le nom du span doit refléter `agent_name`, définissez-le donc via `start_turn` plutôt que via `record` ; `record` met tout de même à jour l’attribut `gen_ai.agent.name`.
***
méthode `set_attributes`
```python theme={"system"}
set_attributes(attributes: 'dict[str, Any]') → Self
```
Appose des attributs OTel arbitraires sur ce span.
Passez un dict, que vous ayez une seule clé ou plusieurs : pour une seule clé, utilisez `span.set_attributes({"weave.tag": "value"})`. Reproduit la méthode `Span.set_attributes` d'OTel.
Doit être appelée entre le début et la fin du span, c.-à-d. à l'intérieur d'un bloc `with`. En dehors de cet intervalle, l'appel est sans effet (no-op) et journalise un avertissement. Pour une ingestion par lot, renseignez directement les champs déclarés de l'objet et passez-le à `log_turn` / `log_conversation`.
***
méthode `subagent`
```python theme={"system"}
subagent(
name: 'str',
model: 'str' = '',
system_instructions: 'list[str] | None' = None
) → SubAgent
```
Démarre un appel de sous-agent (span invoke\_agent imbriqué, dans la même trace).
***
méthode `tool`
```python theme={"system"}
tool(name: 'str', arguments: 'str' = '', tool_call_id: 'str' = '') → Tool
```
Démarre une exécution d’outil (span execute\_tool, enfant de ce tour de conversation).
***
méthode `user`
```python theme={"system"}
user(content: 'str') → Turn
```
Ajoute un message utilisateur au cours d’un tour de conversation.
***
```python theme={"system"}
add_tags(obj_ref: 'ObjectRef | str', tags: 'list[str]') → None
```
Ajouter des tags à une version d’objet.
**Arguments :**
***
fonction `as_op`
```python theme={"system"}
as_op(fn: 'Callable[P, R]') → Op[P, R]
```
Étant donné une fonction décorée avec @weave.op, renvoie son Op.
Les fonctions décorées avec @weave.op sont déjà des instances d’Op ; cette fonction n’a donc aucun effet à l’exécution (no-op). Vous pouvez toutefois l’utiliser pour satisfaire les vérificateurs de types si vous devez accéder aux attributs d’OpDef de manière sûre sur le plan du typage.
* `obj_ref` : Référence à la version de l’objet, soit un ObjectRef (renvoyé par weave.publish()), soit une chaîne URI weave ///.
* `tags` : Liste des chaînes de tags à ajouter.
**Arguments :**
* `fn` : Une fonction décorée avec weave.op.
**Retourne :**
L’Op de la fonction.
***
fonction `attributes`
```python theme={"system"}
attributes(attributes: 'dict[str, Any]') → Iterator
```
Gestionnaire de contexte permettant de définir des attributs sur un appel.
**Exemple :**
```python theme={"system"}
with weave.attributes({'env': 'production'}):
print(my_function.call("World"))
```
***
fonction `end_conversation`
```python theme={"system"}
end_conversation() → None
```
Termine la conversation en cours (à partir de la contextvar).
***
fonction `end_llm`
```python theme={"system"}
end_llm() → None
```
Termine l’appel LLM en cours (à partir de la contextvar).
***
fonction `end_session`
```python theme={"system"}
end_session() → None
```
Alias obsolète de :func:`weave.end_conversation`.
***
fonction `end_turn`
```python theme={"system"}
end_turn() → None
```
Termine le tour de conversation en cours (à partir de la contextvar).
***
fonction `finish`
```python theme={"system"}
finish() → None
```
Arrête la journalisation vers Weave.
Après l’appel à finish, les appels des fonctions décorées avec weave.op ne sont plus journalisés. Pour reprendre la journalisation, vous devez exécuter à nouveau weave.init().
***
fonction `get`
```python theme={"system"}
get(uri: 'str | ObjectRef') → Any
```
Une fonction utilitaire permettant d’obtenir un objet à partir d’une URI.
De nombreux objets journalisés par Weave sont automatiquement enregistrés auprès du serveur Weave. Cette fonction vous permet de récupérer ces objets à partir de leur URI.
**Arguments :**
* `uri` : une URI de réf. Weave entièrement qualifiée.
**Retourne :**
L’objet.
**Exemple :**
```python theme={"system"}
weave.init("weave_get_example")
dataset = weave.Dataset(rows=[{"a": 1, "b": 2}])
ref = weave.publish(dataset)
dataset2 = weave.get(ref) # identique à dataset !
```
***
fonction `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 chaîne URI weave ///.
**Retourne :**
Liste d’alias de type string.
***
```python theme={"system"}
get_current_call() → Call | None
```
Obtenir l’objet Call de l’Op en cours d’exécution, à l’intérieur de cet Op.
**Retourne :**
L’objet Call de l’Op en cours d’exécution, ou None si le suivi n’a pas été initialisé ou si cette méthode est invoquée en dehors d’un Op.
**Remarque :**
> Le dictionnaire `attributes` du Call renvoyé devient immuable dès que l’appel démarre. Utilisez :func:`weave.attributes` pour définir les métadonnées de l’appel avant d’invoquer un Op. Le champ `summary` peut être mis à jour pendant l’exécution de l’Op et sera fusionné avec les informations de synthèse calculées lorsque l’appel se terminera.
***
fonction `get_current_conversation`
```python theme={"system"}
get_current_conversation() → Conversation | None
```
Renvoie la conversation active à partir de la contextvar, ou None.
***
fonction `get_current_llm`
```python theme={"system"}
get_current_llm() → LLM | None
```
Renvoie l’appel LLM actif depuis la contextvar, ou None.
***
fonction `get_current_session`
```python theme={"system"}
get_current_session() → Conversation | None
```
Alias obsolète de :func:`weave.get_current_conversation`.
***
fonction `get_current_turn`
```python theme={"system"}
get_current_turn() → Turn | None
```
Renvoie le tour de conversation actif à partir de la contextvar, ou None.
***
fonction `get_tags`
```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 de l’objet, sous la forme d’un ObjectRef ou d’une URI string weave ///.
**Retourne :**
Liste de tags sous forme de strings.
***
fonction `get_tags_and_aliases`
```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 de l’objet, sous la forme d’un ObjectRef ou d’une URI weave:/// de type string.
**Retourne :**
Un tuple (tags, alias). Chaque élément est une liste de string.
***
fonction `init`
```python theme={"system"}
init(
project_name: 'str',
settings: 'UserSettings | dict[str, Any] | None' = None,
autopatch_settings: 'AutopatchSettings | None' = None,
postprocess_inputs: 'PostprocessInputsFunc | None' = None,
postprocess_output: 'PostprocessOutputFunc | None' = None,
attributes: 'dict[str, Any] | None' = None,
global_postprocess_inputs: 'PostprocessInputsFunc | None' = None,
global_postprocess_output: 'PostprocessOutputFunc | None' = None,
global_attributes: 'dict[str, Any] | None' = None
) → WeaveClient
```
Initialise le suivi Weave, avec journalisation dans un projet wandb.
La journalisation est initialisée globalement : vous n’avez donc pas besoin de conserver une référence à la valeur de retour de init.
Une fois init appelé, les appels aux fonctions décorées avec weave.op sont journalisés dans le projet spécifié.
**Arguments :**
REMARQUE : le post-traitement au niveau du client s’exécute après le post-traitement propre à chaque op. L’ordre est toujours le suivant : 1. Post-traitement spécifique à l’op 2. Post-traitement au niveau du client
* `project_name` : le nom de l’équipe et du projet Weights & Biases dans lesquels journaliser les données. Si vous ne spécifiez pas d’équipe, votre entity par défaut est utilisé. Pour trouver ou modifier votre entity par défaut, référez-vous à la page [Paramètres utilisateur](/fr/products/wandb/platform/app/settings-page/user-settings#default-team) de la documentation W\&B Models.
* `settings` : configuration générale du client Weave. Peut être une instance de UserSettings ou un dict contenant l’une des clés suivantes (toutes facultatives). Tous les paramètres peuvent également être configurés par
des variables d’environnement avec le préfixe WEAVE\_ (par exemple, WEAVE\_DISABLED=true). Paramètres disponibles : - `disabled` (bool) : désactive le traçage de toutes les fonctions. Par défaut : `False` - `print_call_link`
(bool) : affiche dans le terminal des liens vers l’interface Weave pour les ops. Par défaut : `True` - `log_level` (str) : définit le type d’informations à journaliser (`DEBUG`, `INFO`, `WARNING`, `ERROR`, `CRITICAL`). Par défaut : `INFO` -
`display_viewer` (str) : détermine la façon dont Weave affiche les objets dans la console (`auto`, `rich`, `print`). Par défaut : `auto` - `capture_code` (bool) : capture le code des ops tracés dans votre projet Weave.
Par défaut : `True` - `implicitly_patch_integrations` (bool) : patche automatiquement les bibliothèques prises en charge. Par défaut : `True` - `redact_pii` (bool) : analyse toutes les données de trace à la recherche d’informations sensibles, comme les adresses e-mail, les numéros
de téléphone et les numéros de carte bancaire, et les remplace par des valeurs de substitution avant l’envoi au serveur. Nécessite les paquets presidio-analyzer et presidio-anonymizer.
* `Default` : `False` - `redact_pii_fields` (list\[str]) : indique les types d’entités PII à masquer lorsque `redact_pii` vaut True. Si la liste est vide, l’ensemble par défaut de Presidio est utilisé. Exemples : \['EMAIL','PHONE\_NUMBER','CREDIT\_CARD','US\_SSN']. Voir la liste complète à l’adresse [https://microsoft.github.io/presidio/supported\_entities/](https://microsoft.github.io/presidio/supported\_entities/)
* `Default` : `[]` - `redact_pii_exclude_fields` (list\[str]) : types d’entités PII à exclure. Par défaut : `[]` - `capture_client_info` (bool) : capture les informations de version de Python/du SDK. Par défaut : `True` -
`capture_system_info` (bool) : capture les informations sur le système d’exploitation. Par défaut : `True` - `client_parallelism` (int) : nombre de workers pour les ops en arrière-plan. Par défaut : `auto` - `use_server_cache` (bool) : active la mise en cache locale
sur disque des réponses du serveur. - `server_cache_size_limit` (int) : taille maximale du cache, en octets. Par défaut : `1_000_000_000` - `server_cache_dir` (str) : répertoire du cache du serveur. Par défaut : `temporary` -
`scorers_dir` (str) : répertoire des points de contrôle des modèles d’évaluateurs. Par défaut : `~/.cache/wandb/weave-scorers` - `max_calls_queue_size` (int) : taille maximale de la file d’attente (0 = illimitée). Par défaut : `100_000` -
`retry_max_interval` (float) : intervalle maximal entre les nouvelles tentatives, en secondes. Par défaut : `300` - `retry_max_attempts` (int) : nombre maximal de nouvelles tentatives. Par défaut : `3` - `enable_disk_fallback` (bool) : écrit sur le disque les éléments
rejetés. Par défaut : `True` - `use_parallel_table_upload` (bool) : active le téléversement parallèle par fragments pour les tableaux volumineux. Si False, les tableaux sont téléversés séquentiellement, en fragments plus petits.
* `Default` : `True` - `http_timeout` (float) : délai maximal, en secondes, accordé aux requêtes HTTP pour se terminer. Ce délai inclut le temps de connexion, le transfert des données et le traitement côté serveur. Augmentez cette valeur si le réseau est lent ou si vous manipulez des charges utiles volumineuses.
* `Default` : `30.0` - `use_stainless_server` (bool) : utilise le client HTTP généré par Stainless, qui offre une meilleure sûreté de typage, de nouvelles tentatives automatiques et une gestion des erreurs améliorée. Cette fonctionnalité est expérimentale et pourrait devenir le comportement par défaut dans de futures versions.
* `Default` : `False` - `use_calls_complete` (bool) : utilise un chemin d’écriture optimisé qui regroupe les données complètes d’un appel (début et fin) dans une seule requête, plutôt que dans des requêtes de début et de fin distinctes. Cela réduit la charge du serveur et améliore les performances, en particulier pour les ops de courte durée.
* `Default` : `True` - `use_otel_v2` : (bool) : Achemine les intégrations compatibles OTel via leur variante OTel.
* `Par défaut` : `True`
* `autopatch_settings` : (Obsolète) Configuration des intégrations d’autopatch. Utilisez plutôt le patching explicite.
* `postprocess_inputs` : fonction appliquée aux entrées de chaque op tracé par ce client.
* `postprocess_output` : fonction appliquée à la sortie de chaque op tracé par ce client.
* `attributes` : un dictionnaire d’attributs appliqués à chaque trace produite par ce client.
**Retourne :**
Un client Weave.
***
fonction `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 string d’URI 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 renvoyée par le point de terminaison registry-link.
***
fonction `list_aliases`
```python theme={"system"}
list_aliases() → list[str]
```
Liste tous les alias distincts du projet.
**Retourne :**
Liste triée de tous les alias (string) du projet.
***
fonction `list_tags`
```python theme={"system"}
list_tags() → list[str]
```
Lister tous les tags distincts du projet.
**Retourne :**
Liste triée de tous les tags (de type string) du projet.
***
fonction `log_call`
```python theme={"system"}
log_call(
op: 'str',
inputs: 'dict[str, Any]',
output: 'Any',
parent: 'Call | None' = None,
attributes: 'dict[str, Any] | None' = None,
display_name: 'str | Callable[[Call], str] | None' = None,
use_stack: 'bool' = True,
exception: 'BaseException | None' = None
) → Call
```
Journalise un appel directement dans Weave sans utiliser le patron décorateur.
Cette fonction fournit une API impérative pour journaliser des opérations dans Weave. Elle est utile lorsque vous souhaitez journaliser des appels après leur exécution, ou lorsque le patron décorateur ne convient pas à votre cas d'usage.
**Arguments :**
* `op` (str) : Le nom de l’opération à journaliser. Il sera utilisé comme op\_name de l’appel. Les opérations anonymes (strings ne faisant pas référence à des ops publiés) sont prises en charge.
* `inputs` (dict\[str, Any]) : Un dictionnaire des paramètres d’entrée de l’opération.
* `output` (Any) : La sortie/le résultat de l’opération.
* `parent` (Call | None) : Appel parent facultatif dans lequel imbriquer cet appel. S’il n’est pas fourni, l’appel sera un appel de niveau racine (ou imbriqué dans le contexte d’appel actuel, s’il existe). Par défaut : None.
* `attributes` (dict\[str, Any] | None) : Métadonnées facultatives à joindre à l’appel. Elles sont figées une fois l’appel créé. Par défaut : None.
* `display_name` (str | Callable\[\[Call], str] | None) : Nom d’affichage facultatif de l’appel dans l’interface utilisateur. Peut être une string ou un callable qui prend l’appel et renvoie une string. Par défaut : None.
* `use_stack` (bool) : Indique s’il faut empiler l’appel sur la pile du runtime. Si True, l’appel sera disponible dans le contexte d’appel et accessible via weave.require\_current\_call(). Si False, l’appel est journalisé mais n’est pas ajouté à la pile d’appels. Par défaut : True.
* `exception` (BaseException | None) : Exception facultative à journaliser si l’opération a échoué. Par défaut : None.
**Retourne :**
* `Call` : L’objet Call créé et terminé, avec les informations de trace complètes.
**Exemples :**
Utilisation de base :
````python theme={"system"}
import weave
>>> weave.init('my-project')
>>> call = weave.log_call(
... op="my_function",
... inputs={"x": 5, "y": 10},
... output=15
... )
Logging with attributes and display name:
>>> call = weave.log_call(
... op="process_data",
... inputs={"data": [1, 2, 3]},
... output={"mean": 2.0},
... attributes={"version": "1.0", "env": "prod"},
... display_name="Data Processing"
... )
Logging a failed operation:
>>> try:
... result = risky_operation()
... except Exception as e:
... call = weave.log_call(
... op="risky_operation",
... inputs={},
... output=None,
... exception=e
... )
Nesting calls:
>>> parent_call = weave.log_call("parent", {"input": 1}, 2)
>>> child_call = weave.log_call(
... "child",
... {"input": 2},
... 4,
... parent=parent_call
... )
Logging without adding to call stack:
>>> call = weave.log_call(
... op="background_task",
... inputs={"task_id": 123},
... output="completed",
... use_stack=False # Ne pas ajouter à la pile d'appels
... )
---
### function `log_conversation`
```python
log_conversation(
turns: 'list[Turn]',
conversation_id: 'str' = '',
conversation_name: 'str' = '',
agent_name: 'str' = '',
model: 'str' = '',
agent_id: 'str' = '',
agent_description: 'str' = '',
agent_version: 'str' = '',
include_content: 'bool' = True,
continue_parent_trace: 'bool' = False,
attributes: 'Attributes' = None
) → LogResult
````
Émet de manière impérative une conversation complète.
L'attribut `.spans` de chaque Turn fournit ses enfants. Génère automatiquement `conversation_id` s'il est vide. Par défaut, chaque tour de conversation dispose de sa propre trace OTel. `agent_name` / `model` / `agent_id` / `agent_description` / `agent_version` sont des valeurs par défaut au niveau de la conversation — la valeur propre à un Turn est prioritaire ; la valeur de la conversation n'est utilisée que si le Turn ne la renseigne pas. Le paramètre `continue_parent_trace` de la conversation s'applique à chaque tour de conversation (tout `continue_parent_trace` défini au niveau d'un Turn est ici volontairement ignoré).
Les `attributes` sont apposés sur chaque span émis. Utilisez des clés personnalisées, hors conventions sémantiques (semconv) : une clé qui entre en conflit avec un attribut `gen_ai.*` / `weave.*` propre à un span n'est pas prise en charge (la valeur retenue dépend du chemin d'exécution).
***
```python theme={"system"}
log_turn(
conversation_id: 'str',
agent_name: 'str' = '',
conversation_name: 'str' = '',
model: 'str' = '',
agent_id: 'str' = '',
agent_description: 'str' = '',
agent_version: 'str' = '',
messages: 'list[Message] | None' = None,
system_instructions: 'list[str] | None' = None,
spans: 'list[LLM | Tool | SubAgent] | None' = None,
started_at: 'datetime | None' = None,
ended_at: 'datetime | None' = None,
include_content: 'bool' = True,
continue_parent_trace: 'bool' = False,
attributes: 'Attributes' = None
) → LogResult
```
Émet de manière impérative un tour de conversation et ses spans enfants vers OTel.
À utiliser lorsque les gestionnaires de contexte ne sont pas envisageables (conteneurs sans état, callbacks, workers de file d'attente). Chaque span enfant transmis doit avoir `started_at` / `ended_at` définis ; les horodatages des spans OTel émis proviennent de ces champs. Si le tour de conversation ne fournit pas ses propres horodatages, l'horodatage le plus ancien/le plus récent des enfants est utilisé, puis `now()` à défaut. `agent_id` / `agent_description` / `agent_version` se comportent comme dans le chemin de streaming.
Les `attributes` sont appliqués à chaque span émis ; le chemin de streaming, lui, les lit à partir de la conversation active. Utilisez des clés personnalisées, hors conventions sémantiques : une clé qui entre en conflit avec un attribut `gen_ai.*` / `weave.*` propre à un span n'est pas prise en charge (la valeur retenue dépend du chemin).
***
fonction `op`
```python theme={"system"}
op(
func: 'Callable[P, R] | None' = None,
name: 'str | None' = None,
call_display_name: 'str | CallDisplayNameFunc | None' = None,
postprocess_inputs: 'PostprocessInputsFunc | None' = None,
postprocess_output: 'PostprocessOutputFunc | None' = None,
tracing_sample_rate: 'float' = 1.0,
enable_code_capture: 'bool' = True,
accumulator: 'Callable[[Any | None, Any], Any] | None' = None,
kind: 'OpKind | None' = None,
color: 'OpColor | None' = None,
attributes: 'dict[str, Any] | None' = None,
eager_call_start: 'bool' = False
) → Callable[[Callable[P, R]], Op[P, R]] | Op[P, R]
```
Un décorateur permettant de transformer une fonction ou une méthode en op Weave. Fonctionne aussi bien en mode synchrone qu'asynchrone. Détecte automatiquement les fonctions itératrices et applique le comportement approprié.
**Arguments :**
***
fonction `otel_traces_endpoint`
```python theme={"system"}
otel_traces_endpoint(base_url: str | None = None) → str
```
Renvoie l’URL complète du point de terminaison HTTP OTLP pour l’ingestion des traces GenAI de Weave.
Les appelants externes (par exemple, les sondes de démarrage qui doivent vérifier que le point de terminaison d’ingestion est joignable avant de s’en remettre au BatchSpanProcessor, qui abandonne les exports sans avertissement) doivent appeler cette fonction plutôt que de construire l’URL eux-mêmes. Le chemin relève du SDK et est susceptible de changer.
* `func` : fonction à décorer.
* `name` : nom personnalisé de l’op. Par défaut, le nom de la fonction.
* `call_display_name` : nom d’affichage des appels ; peut être une string ou un callable.
* `postprocess_inputs` : fonction qui transforme les entrées avant la journalisation.
* `postprocess_output` : fonction qui transforme la sortie avant la journalisation.
* `tracing_sample_rate` : fraction des appels à tracer (de 0.0 à 1.0).
* `enable_code_capture` : indique s’il faut capturer le code source de cette op.
* `accumulator` : fonction qui accumule les résultats des ops en streaming.
* `attributes` : attributs par défaut fusionnés dans chaque appel créé par cette op, avec la priorité la plus faible. Un contexte `weave.attributes()` et des attributs par appel explicites les redéfinissent en cas de conflit de clé. La clé réservée "weave" ne peut pas être définie ici.
* `eager_call_start` : si True, les débuts d’appel sont envoyés immédiatement plutôt que par lots. Utile pour les opérations de longue durée, comme les évaluations, qui doivent apparaître immédiatement dans l’interface utilisateur.
**Arguments :**
***
fonction `publish`
```python theme={"system"}
publish(
obj: 'Any',
name: 'str | None' = None,
tags: 'list[str] | None' = None,
aliases: 'list[str] | None' = None
) → ObjectRef
```
Enregistre un objet Python et en crée une version.
Weave crée une nouvelle version de l’objet si un objet portant ce nom existe déjà et que son hachage de contenu ne correspond pas à celui de la dernière version de cet objet.
* `base_url` : URL de base du trace server. Valeur par défaut : `weave_trace_server_url()`.
**Arguments :**
* `obj` : l’objet à enregistrer et à versionner.
* `name` : le nom sous lequel enregistrer l’objet.
* `tags` : liste facultative de tags à ajouter à la version d’objet publiée.
* `aliases` : liste facultative d’alias à définir sur la version d’objet publiée.
**Retourne :**
Une réf. Weave vers l’objet enregistré.
***
fonction `ref`
```python theme={"system"}
ref(location: 'str') → ObjectRef
```
Crée une Ref vers un objet Weave existant. Cette fonction ne récupère pas directement l’objet, mais vous permet de le transmettre à d’autres fonctions de l’API Weave.
**Arguments :**
* `location` : URI de réf. Weave ou, si `weave.init()` a été appelé, `name:version` ou `name`. Si aucune version n’est fournie, `latest` est utilisé.
**Retourne :**
Une réf. Weave vers l’objet.
***
fonction `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 :**
***
fonction `remove_tags`
```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 string URI weave ///.
* `alias` : Nom d’alias ou liste de noms d’alias à supprimer.
**Arguments :**
***
fonction `require_current_call`
```python theme={"system"}
require_current_call() → Call
```
Obtient l’objet Call de l’op en cours d’exécution, depuis cet op.
Cela vous permet d’accéder aux attributs de l’appel, tels que son id ou son feedback, pendant son exécution.
```python theme={"system"}
@weave.op
def hello(name: str) -> None:
print(f"Hello {name}!")
current_call = weave.require_current_call()
print(current_call.id)
```
Il est également possible d'accéder à un appel une fois que l'op a renvoyé son résultat.
Si vous disposez de l'id de l'appel, obtenu par exemple depuis l'interface utilisateur, vous pouvez utiliser la méthode `get_call` du `WeaveClient` renvoyé par `weave.init` pour récupérer l'objet Call.
```python theme={"system"}
client = weave.init("")
mycall = client.get_call("")
```
Vous pouvez également utiliser la méthode `call` de votre op après l’avoir défini. Par exemple :
```python theme={"system"}
@weave.op
def add(a: int, b: int) -> int:
return a + b
result, call = add.call(1, 2)
print(call.id)
```
* `obj_ref` : référence à la version de l’objet, soit un ObjectRef, soit une string d’URI weave ///.
* `tags` : liste des strings de tag à supprimer.
**Retourne :**
L’objet Call de l’op en cours d’exécution
**Exceptions levées :**
* `NoCurrentCallError` : si le suivi n’a pas été initialisé ou si cette méthode est appelée en dehors d’un op.
***
fonction `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 :**
***
fonction `set_view`
```python theme={"system"}
set_view(
name: 'str',
content: 'Content | str',
extension: 'str | None' = None,
mimetype: 'str | None' = None,
metadata: 'dict[str, Any] | None' = None,
encoding: 'str' = 'utf-8'
) → None
```
Joindre une vue personnalisée à la synthèse de l’appel en cours, sous `_weave.views.`.
* `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 :**
* `name` : Nom de la vue (clé sous `summary._weave.views`).
* `content` : Instance `weave.Content` ou string brute. Les strings sont encapsulées via `Content.from_text` à l’aide de l’extension ou du type MIME fourni.
* `extension` : Extension de fichier facultative à utiliser lorsque `content` est une string.
* `mimetype` : Type MIME facultatif à utiliser lorsque `content` est une string.
* `metadata` : Métadonnées facultatives à joindre lors de la création de `Content` à partir de texte.
* `encoding` : Encodage de texte à appliquer lors de la création de `Content` à partir de texte.
**Retourne :**
None
**Exemples :**
` import weave`
> > > weave.init("proj")
> > > @weave.op
> > > ... def foo():
> > > ... weave.set\_view("readme", "# Hello", extension="md")
> > > ... return 1
> > > foo()
***
fonction `start_conversation`
```python theme={"system"}
start_conversation(
agent_name: 'str' = '',
model: 'str' = '',
conversation_id: 'str' = '',
conversation_name: 'str' = '',
include_content: 'bool' = True,
continue_parent_trace: 'bool' = False,
attributes: 'Attributes' = None
) → Conversation
```
Crée et active une conversation. Définit la contextvar pour permettre l’accès depuis d’autres modules.
Les `attributes` sont apposés sur chaque span émis par cette conversation (par exemple, une identité d’intégration comme `weave.integration.*`). Utilisez des clés personnalisées, hors conventions sémantiques (semconv) : pour les champs des conventions sémantiques, passez par les paramètres typés (`conversation_name`, `model`, ...). Une clé qui entre en conflit avec un attribut `gen_ai.*` / `weave.*` propre à un span n’est pas prise en charge ; la valeur retenue dépend du chemin d’exécution (streaming ou `log_turn`).
***
fonction `start_llm`
```python theme={"system"}
start_llm(
model: 'str' = '',
provider_name: 'str' = '',
system_instructions: 'list[str] | None' = None
) → LLM
```
Crée et active un appel LLM. Utilise le tour de conversation actuel s’il est disponible.
Si aucun tour de conversation n’est actif, renvoie un LLM déconnecté (aucune contextvar définie).
Transmettez explicitement `provider_name`. Le SDK ne le déduit pas de l’identifiant du modèle : une déduction fondée sur le préfixe attribue à tort les modèles issus d’un fine-tuning effectué par l’utilisateur (par exemple, un modèle nommé `text-...`) et inscrit dans la télémétrie des hypothèses sur les futurs noms de modèles, qu'il est coûteux de corriger a posteriori.
***
```python theme={"system"}
start_subagent(
name: 'str',
model: 'str' = '',
system_instructions: 'list[str] | None' = None
) → SubAgent
```
Crée un span d’appel de sous-agent.
Le span OTel du SubAgent devient automatiquement l'enfant du span courant dans le contexte OTel — généralement un span Turn, s'il y en a un actif. Même structure que `start_tool` : le contexte OTel gère la propagation parent-enfant, sans qu'aucune délégation explicite soit nécessaire.
***
fonction `start_tool`
```python theme={"system"}
start_tool(name: 'str', arguments: 'str' = '', tool_call_id: 'str' = '') → Tool
```
Crée un span d’exécution d’outil.
Le span OTel de l’outil devient automatiquement l’enfant du span courant dans le contexte OTel, généralement un span de Turn s’il y en a un actif. Aucune délégation explicite au tour de conversation n’est nécessaire : la propagation parent-enfant s’effectue via le contexte OTel, et non via les contextvars du SDK Conversation.
***
fonction `start_turn`
```python theme={"system"}
start_turn(
user_message: 'str' = '',
model: 'str' = '',
agent_name: 'str' = '',
system_instructions: 'list[str] | None' = None
) → Turn
```
Crée et active un tour de conversation. Utilise la conversation en cours si elle est disponible.
Si aucune conversation n’est active, renvoie un Turn déconnecté qui n’est PAS défini dans la contextvar. Par conséquent, `get_current_turn()` renverra None. Utilisez plutôt `conversation.start_turn()` si vous avez besoin d’un accès entre modules reposant sur la contextvar.
***