Aperçu de l’API

`classe` `Agent`

Champs Pydantic :

name: str | None
description: str | None
ref: trace.refs.ObjectRef | None
model_name: <class 'str'>
temperature: <class 'float'>
system_message: <class 'str'>
tools: list[typing.Any]

`méthode` `step`

step(state: AgentState) → AgentState

Exécute une étape de l’agent. Arguments :

state : l’état actuel de l’environnement.
action : l’action à effectuer. Retourne : Le nouvel état de l’environnement.

`classe` `AgentState`

Champs Pydantic :

name : str | None
description : str | None
ref : trace.refs.ObjectRef | None
history : list[typing.Any]

`classe` `AnnotationSpec`

Champs Pydantic :

name : str | None
description : str | None
field_schema : dict[str, typing.Any]
unique_among_creators : <class 'bool'>
op_scope : list[str] | None

`classmethod` `preprocess_field_schema`

preprocess_field_schema(data: Any) → Any

`classmethod` `validate_field_schema`

validate_field_schema(schema: dict[str, Any]) → dict[str, Any]

`méthode` `value_is_valid`

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

`méthode` `init`

__init__(
    data: 'bytes',
    format: 'SUPPORTED_FORMATS_TYPE',
    validate_base64: 'bool' = True
) → None

`méthode` `export`

export(path: 'str | bytes | Path | PathLike') → None

Exporte les données audio vers un fichier. Arguments :

`classmethod` `from_data`

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`

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: <class 'float'>
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: <class 'bool'>
active: <class 'bool'>
scorer_debounce_config: flow.monitor.ScorerDebounceConfig | None
prompt_header: str | None
prompt_footer: str | None

`méthode` `activate`

activate() → ObjectRef

Active le moniteur. Retourne : La réf. du moniteur.

`méthode` `deactivate`

deactivate() → ObjectRef

Désactive le moniteur. Retourne : La réf. du moniteur.

`classmethod` `from_obj`

from_obj(obj: WeaveObject) → Self

`méthode` `get_prompt_footer`

get_prompt_footer() → str

Texte à ajouter après les prompts fusionnés des classifieurs.

`méthode` `get_prompt_header`

get_prompt_header(op_name: str) → str

Texte à insérer avant les prompts fusionnés des classifieurs.

`méthode` `model_post_init`

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()

`méthode` `init`

__init__(*args: 'Any', **kwargs: 'Any') → None

L’initialisation directe est désactivée. Utilisez une classmethod telle que Content.from_path() pour créer une instance. Champs Pydantic :

data: <class 'bytes'>
size: <class 'int'>
mimetype: <class 'str'>
digest: <class 'str'>
filename: <class 'str'>
content_type: typing.Literal['bytes', 'text', 'base64', 'file', 'url', 'data_url', 'data_url:base64', 'data_url:encoding', 'data_url:encoding:base64']
input_type: <class 'str'>
encoding: <class 'str'>
metadata: dict[str, typing.Any] | None
extension: str | None

`propriété` art

`propriété` ref

`méthode` `as_string`

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`

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.

`classmethod` `from_bytes`

from_bytes(
    data: 'bytes',
    extension: 'str | None' = None,
    mimetype: 'str | None' = None,
    metadata: 'dict[str, Any] | None' = None,
    encoding: 'str' = 'utf-8'
) → Self

Initialise Content à partir d’octets bruts.

`classmethod` `from_data_url`

from_data_url(url: 'str', metadata: 'dict[str, Any] | None' = None) → Self

Initialise Content à partir d’une URL de données.

`classmethod` `from_path`

from_path(
    path: 'str | Path',
    encoding: 'str' = 'utf-8',
    mimetype: 'str | None' = None,
    metadata: 'dict[str, Any] | None' = None
) → Self

Initialise Content à partir d’un chemin de fichier local.

`classmethod` `from_text`

from_text(
    text: 'str',
    extension: 'str | None' = None,
    mimetype: 'str | None' = None,
    metadata: 'dict[str, Any] | None' = None,
    encoding: 'str' = 'utf-8'
) → Self

Initialise Content à partir d’une string.

`classmethod` `from_url`

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`

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`

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`

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`

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`

serialize_data(data: 'bytes') → str

Lors de la sérialisation du modèle en mode json

`méthode` `to_data_url`

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: <class 'str'>
conversation_name: <class 'str'>
agent_name: <class 'str'>
model: <class 'str'>
agent_id: <class 'str'>
agent_description: <class 'str'>
agent_version: <class 'str'>
include_content: <class 'bool'>
continue_parent_trace: <class 'bool'>
attributes: dict[str, typing.Any]

`méthode` `end`

end() → None

`méthode` `model_post_init`

model_post_init(context: 'Any') → None

`méthode` `start_turn`

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 :

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

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.

`classmethod` `convert_to_table`

convert_to_table(rows: Any) → Table | WeaveTable

`classmethod` `from_calls`

from_calls(calls: Iterable[Call]) → Self

`classmethod` `from_hf`

from_hf(hf_dataset: 'HFDataset | HFDatasetDict') → Self

`classmethod` `from_obj`

from_obj(obj: WeaveObject) → Self

`classmethod` `from_pandas`

from_pandas(df: 'DataFrame') → Self

`méthode` `select`

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.

`méthode` `to_hf`

to_hf() → HFDataset

`méthode` `to_pandas`

to_pandas() → DataFrame

`classe` `EasyPrompt`

`méthode` `init`

__init__(
    content: str | dict | list | None = None,
    role: str | None = None,
    dedent: bool = False,
    **kwargs: Any
) → None

Champs Pydantic :

name: str | None
description: str | None
ref: trace.refs.ObjectRef | None
data: <class 'list'>
config: <class 'dict'>
requirements: <class 'dict'>

`propriété` as_str

Regroupe tous les messages dans une seule string.

`propriété` is_bound

`propriété` messages

`propriété` placeholders

`propriété` system_message

Regrouper tous les messages dans un message de prompt système.

`propriété` system_prompt

Regrouper tous les messages dans un objet de prompt système.

`propriété` unbound_placeholders

`méthode` `append`

append(item: Any, role: str | None = None, dedent: bool = False) → None

`méthode` `as_dict`

as_dict() → dict[str, Any]

`méthode` `as_pydantic_dict`

as_pydantic_dict() → dict[str, Any]

`méthode` `bind`

bind(*args: Any, **kwargs: Any) → Prompt

`méthode` `bind_rows`

bind_rows(dataset: list[dict] | Any) → list['Prompt']

`méthode` `config_table`

config_table(title: str | None = None) → Table

`méthode` `configure`

configure(config: dict | None = None, **kwargs: Any) → Prompt

`méthode` `dump`

dump(fp: <class 'IO'>) → None

`méthode` `dump_file`

dump_file(filepath: str | Path) → None

`méthode` `format`

format(**kwargs: Any) → Any

`classmethod` `from_obj`

from_obj(obj: WeaveObject) → Self

`classmethod` `load`

load(fp: <class 'IO'>) → Self

`classmethod` `load_file`

load_file(filepath: str | Path) → Self

`méthode` `messages_table`

messages_table(title: str | None = None) → Table

`méthode` `print`

print() → str

`méthode` `publish`

publish(
    name: str | None = None,
    tags: list[str] | None = None,
    aliases: list[str] | None = None
) → ObjectRef

`méthode` `require`

require(param_name: str, **kwargs: Any) → Prompt

`méthode` `run`

run() → Any

`méthode` `validate_requirement`

validate_requirement(key: str, value: Any) → list

`méthode` `validate_requirements`

validate_requirements(values: dict[str, Any]) → list

`méthode` `values_table`

values_table(title: str | None = None) → Table

`classe` `Evaluation`

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 :

# 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 : <class 'dataset.dataset.Dataset'>
scorers : list[typing.Annotated[trace.op_protocol.Op | flow.scorer.Scorer, BeforeValidator(func=<function cast_to_scorer at 0x7f136d430d60>, json_schema_input_type=PydanticUndefined)]] | None
preprocess_model_input : collections.abc.Callable[[dict], dict] | None
trials : <class 'int'>
metadata : dict[str, typing.Any] | None
evaluation_name : str | collections.abc.Callable[trace.call.Call, str] | None

`méthode` `evaluate`

evaluate(model: Op | Model) → dict

`classmethod` `from_obj`

from_obj(obj: WeaveObject) → Self

`méthode` `get_eval_results`

get_eval_results(model: Op | Model) → EvaluationResults

`méthode` `get_evaluate_calls`

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 :

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`

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 :

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`

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 :

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

`méthode` `model_post_init`

model_post_init(context: Any) → None

`méthode` `predict_and_score`

predict_and_score(model: Op | Model, example: dict) → dict

`méthode` `summarize`

summarize(eval_table: EvaluationResults) → dict

`classe` `EvaluationLogger`

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 :

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 :

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})

`méthode` `init`

__init__(
    name: 'str | None' = None,
    model: 'Model | dict | str | None' = None,
    dataset: 'Dataset | list[dict] | str | None' = None,
    eval_attributes: 'dict[str, Any] | None' = None,
    scorers: 'list[str] | None' = None
) → None

`property` attributes

`property` ui_url

`méthode` `fail`

fail(exception: 'BaseException') → None

Méthode utilitaire permettant de marquer l’évaluation comme ayant échoué à l’aide d’une exception.

`méthode` `finish`

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`

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 :

ev = EvaluationLogger()
ev.log_example(
    inputs={'q': 'What is 2+2?'},
    output='4',
    scores={'correctness': 1.0, 'fluency': 0.9}
)

`méthode` `log_prediction`

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`

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`

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.<name> 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.

`méthode` `init`

__init__(path: 'str | Path', mimetype: 'str | None' = None)

Initialise un objet File. Arguments :

`property` filename

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`

open() → bool

bool : True si le fichier a bien été ouvert, False sinon.

`méthode` `save`

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: <class 'str'>
provider_name: <class 'str'>
response_id: <class 'str'>
response_model: <class 'str'>
output_type: <class 'str'>
system_instructions: list[str]
usage: <class 'conversation.types.Usage'>
reasoning: <class 'conversation.types.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`

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/.

À 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. 

---

<SourceLink url="https://github.com/wandb/weave/blob/v0.53.1/weave/conversation/conversation.py#L462" />

### <kbd>méthode</kbd> `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`

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.

`méthode` `end`

end() → None

`méthode` `model_post_init`

model_post_init(context: 'Any') → None

`méthode` `output`

output(content: 'str') → LLM

Ajoute un message assistant à output_messages.

`méthode` `record`

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`

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`

think(content: 'str') → LLM

Définit le contenu du raisonnement (chaîne de pensée).

`classe` `LogResult`

Résultat d’un appel log_* par lot. Champs Pydantic :

conversation_id : <class 'str'>
trace_ids : list[str]
root_span_ids : list[str]
span_count : <class 'int'>

`classe` `Markdown`

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/ 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.

`méthode` `init`

__init__(
    markup: 'str',
    code_theme: 'str' = 'monokai',
    justify: 'JustifyMethod | None' = None,
    style: 'str | Style' = 'none',
    hyperlinks: 'bool' = True,
    inline_code_lexer: 'str | None' = None,
    inline_code_theme: 'str | None' = None
) → None

`classe` `MediaAttachment`

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: <class 'str'>
modality: <class 'str'>
mime_type: <class 'str'>

`classe` `Message`

Un message unique au sein d’une conversation. Deux styles de construction sont pris en charge :

Plat (rétrocompatible, pratique pour du texte brut) : Message(role="assistant", content="Hi there")
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: <class 'str'>
tool_call_id: <class 'str'>
tool_name: <class 'str'>
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`

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`

system(text: 'str') → Message

Construit un message système à partir de texte brut.

`classmethod` `tool_result`

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`

user(text: 'str') → Message

Construit un message utilisateur à partir de texte brut.

`classe` `MessagesPrompt`

`méthode` `init`

__init__(messages: list[dict])

Champs Pydantic :

name : str | None
description : str | None
ref : trace.refs.ObjectRef | None
messages : list[dict]

`méthode` `format`

format(**kwargs: Any) → list

`méthode` `format_message`

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.

`classmethod` `from_obj`

from_obj(obj: WeaveObject) → Self

`classe` `Model`

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 :

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

`méthode` `get_infer_method`

get_infer_method() → Callable

`classe` `Monitor`

Configure un moniteur chargé d’attribuer automatiquement un score aux appels entrants. Notez que le nom de l’op sera converti en réf. Weave à partir de l’entity et du projet du client Weave. Si vous travaillez sur plusieurs entities et projets avec le même client, vous devrez indiquer une réf. Weave entièrement qualifiée. Pour plus de détails, voir _normalized_op_names. Exemples :

import weave
from weave.scorers import ValidJSONScorer

json_scorer = ValidJSONScorer()

my_monitor = weave.Monitor(
     name="my-monitor",
     description="This is a test monitor",
     sampling_rate=0.5,
     op_names=["my_op"],
     query={
         "$expr": {
             "$gt": [
                 {
                         "$getField": "started_at"
                     },
                     {
                         "$literal": 1742540400
                     }
                 ]
             }
         }
     },
     scorers=[json_scorer],
)

my_monitor.activate()

Champs Pydantic :

name : str | None
description : str | None
ref : trace.refs.ObjectRef | None
sampling_rate : <class 'float'>
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 : <class 'bool'>
active : <class 'bool'>
scorer_debounce_config : flow.monitor.ScorerDebounceConfig | None

`méthode` `activate`

activate() → ObjectRef

Active le moniteur. Retourne : La réf. du moniteur.

`méthode` `deactivate`

deactivate() → ObjectRef

Désactive le moniteur. Retourne : La réf. du moniteur.

`classmethod` `from_obj`

from_obj(obj: WeaveObject) → Self

`méthode` `model_post_init`

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 :

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

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 :

obj = MyObject.from_uri("weave:///entity/project/object:digest")

`classmethod` `handle_relocatable_object`

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)

---

<SourceLink url="https://github.com/wandb/weave/blob/v0.53.1/weave/object/obj.py#L91" />

### <kbd>classmethod</kbd> `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”.

`classe` `ObjectRef`

ObjectRef(entity: ‘str’, project: ‘str’, name: ‘str’, _digest: ‘str | Future[str]’, _extra: ‘tuple[str | Future[str], …]’ = ())

`méthode` `init`

__init__(
    entity: 'str',
    project: 'str',
    name: 'str',
    _digest: 'str | Future[str]',
    _extra: 'tuple[str | Future[str], ]' = ()
) → None

`propriété` digest

`propriété` extra

`propriété` is_digest_resolved

`méthode` `as_param_dict`

as_param_dict() → dict

`méthode` `delete`

delete() → None

`méthode` `get`

get(objectify: 'bool' = True) → Any

`méthode` `is_descended_from`

is_descended_from(potential_ancestor: 'ObjectRef') → bool

`méthode` `maybe_parse_uri`

maybe_parse_uri(s: 'str') → AnyRef | None

`méthode` `parse_uri`

parse_uri(uri: 'str') → ObjectRef

`méthode` `with_attr`

with_attr(attr: 'str') → Self

`méthode` `with_extra`

with_extra(extra: 'tuple[str | Future[str], ]') → Self

`méthode` `with_index`

with_index(index: 'int') → Self

`méthode` `with_item`

with_item(item_digest: 'str | Future[str]') → Self

`méthode` `with_key`

with_key(key: 'str') → Self

`classe` `Prompt`

Champs Pydantic :

name : str | None
description : str | None
ref : trace.refs.ObjectRef | None

`méthode` `format`

format(**kwargs: Any) → Any

`classe` `SavedView`

Une classe de style fluent permettant de manipuler les objets SavedView.

`méthode` `init`

__init__(view_type: 'str' = 'traces', label: 'str' = 'SavedView') → None

`propriété` entity

`propriété` label

`propriété` project

`propriété` view_type

`méthode` `add_column`

add_column(path: 'str | ObjectPath', label: 'str | None' = None) → SavedView

`méthode` `add_columns`

add_columns(*columns: 'str') → SavedView

Méthode utilitaire permettant d’ajouter plusieurs colonnes à la grille.

`méthode` `add_filter`

add_filter(
    field: 'str',
    operator: 'str',
    value: 'Any | None' = None
) → SavedView

`méthode` `add_sort`

add_sort(field: 'str', direction: 'SortDirection') → SavedView

`méthode` `column_index`

column_index(path: 'int | str | ObjectPath') → int

`méthode` `filter_op`

filter_op(op_name: 'str | None') → SavedView

`méthode` `get_calls`

get_calls(
    limit: 'int | None' = None,
    offset: 'int | None' = None,
    include_costs: 'bool' = False,
    include_feedback: 'bool' = False,
    all_columns: 'bool' = False
) → CallsIter

Obtenir les appels correspondant aux filtres et aux paramètres de cette vue enregistrée.

`méthode` `get_known_columns`

get_known_columns(num_calls_to_query: 'int | None' = None) → list[str]

Obtenir l’ensemble des colonnes dont l’existence est connue.

`méthode` `get_table_columns`

get_table_columns() → list[TableColumn]

`méthode` `hide_column`

hide_column(col_name: 'str') → SavedView

`méthode` `insert_column`

insert_column(
    idx: 'int',
    path: 'str | ObjectPath',
    label: 'str | None' = None
) → SavedView

`classmethod` `load`

load(ref: 'str') → Self

`méthode` `page_size`

page_size(page_size: 'int') → SavedView

`méthode` `pin_column_left`

pin_column_left(col_name: 'str') → SavedView

`méthode` `pin_column_right`

pin_column_right(col_name: 'str') → SavedView

`méthode` `remove_column`

remove_column(path: 'int | str | ObjectPath') → SavedView

`méthode` `remove_columns`

remove_columns(*columns: 'str') → SavedView

Supprime des colonnes de la vue enregistrée.

`méthode` `remove_filter`

remove_filter(index_or_field: 'int | str') → SavedView

`méthode` `remove_filters`

remove_filters() → SavedView

Supprime tous les filtres de la vue enregistrée.

`méthode` `rename`

rename(label: 'str') → SavedView

`méthode` `rename_column`

rename_column(path: 'int | str | ObjectPath', label: 'str') → SavedView

`méthode` `save`

save() → SavedView

Publie la vue enregistrée sur le serveur.

`méthode` `set_columns`

set_columns(*columns: 'str') → SavedView

Définit les colonnes à afficher dans la grille.

`méthode` `show_column`

show_column(col_name: 'str') → SavedView

`méthode` `sort_by`

sort_by(field: 'str', direction: 'SortDirection') → SavedView

`méthode` `to_grid`

to_grid(limit: 'int | None' = None) → Grid

`méthode` `to_rich_table_str`

to_rich_table_str() → str

`méthode` `ui_url`

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.

`méthode` `unpin_column`

unpin_column(col_name: 'str') → SavedView

`classe` `Scorer`

Champs Pydantic :

name : str | None
description : str | None
ref : trace.refs.ObjectRef | None
column_map : dict[str, str] | None

`propriété` display_name

`classmethod` `from_obj`

from_obj(obj: WeaveObject) → Self

`méthode` `model_post_init`

model_post_init(context: Any) → None

`méthode` `score`

score(output: Any, **kwargs: Any) → Any

`méthode` `summarize`

summarize(score_rows: list) → dict | None

`classe` `Session`

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.

`méthode` `init`

__init__(**data: 'Any') → None

Champs Pydantic :

conversation_id : <class 'str'>
conversation_name : <class 'str'>
agent_name : <class 'str'>
model : <class 'str'>
agent_id : <class 'str'>
agent_description : <class 'str'>
agent_version : <class 'str'>
include_content : <class 'bool'>
continue_parent_trace : <class 'bool'>
attributes : dict[str, typing.Any]

`propriété` session_id

Alias obsolète de :attr:conversation_id.

`propriété` session_name

Alias obsolète de :attr:conversation_name.

`classe` `StringPrompt`

`méthode` `init`

__init__(content: str)

Champs Pydantic :

name: str | None
description: str | None
ref: trace.refs.ObjectRef | None
content: <class 'str'>

`méthode` `format`

format(**kwargs: Any) → str

`classmethod` `from_obj`

from_obj(obj: WeaveObject) → Self

`classe` `SubAgent`

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: <class 'str'>
model: <class 'str'>
agent_id: <class 'str'>
agent_description: <class 'str'>
agent_version: <class 'str'>
system_instructions: list[str]
started_at: datetime.datetime | None
ended_at: datetime.datetime | None

`méthode` `add_event`

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/.

À 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. 

---

<SourceLink url="https://github.com/wandb/weave/blob/v0.53.1/weave/conversation/conversation.py#L843" />

### <kbd>méthode</kbd> `end`

```python
end() → None

`méthode` `llm`

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`

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`

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`

tool(name: 'str', arguments: 'str' = '', tool_call_id: 'str' = '') → Tool

Démarre une exécution d’outil dans ce sous-agent.

`classe` `Table`

`méthode` `init`

__init__(rows: 'list[dict]') → None

`propriété` rows

`méthode` `append`

append(row: 'dict') → None

Ajoute une ligne au tableau.

`méthode` `pop`

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 :

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()

`méthode` `init`

__init__(*args: 'Any', **kwargs: 'Any') → None

`property` daemon

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`

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`

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

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)

`méthode` `init`

__init__(*args: 'Any', **kwargs: 'Any') → None

`méthode` `map`

map(
    fn: 'Callable',
    *iterables: 'Iterable[Any]',
    timeout: 'float | None' = None,
    chunksize: 'int' = 1
) → Iterator

`méthode` `submit`

submit(fn: 'Callable', *args: 'Any', **kwargs: 'Any') → Any

`classe` `Tool`

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 : <class 'str'>
arguments : <class 'str'>
result : <class 'str'>
tool_call_id : <class 'str'>
tool_type : <class 'str'>
tool_description : <class 'str'>
tool_definitions : <class 'str'>
duration_ms : <class 'int'>
started_at : datetime.datetime | None
ended_at : datetime.datetime | None

`méthode` `add_event`

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/.

À 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. 

---

<SourceLink url="https://github.com/wandb/weave/blob/v0.53.1/weave/conversation/conversation.py#L382" />

### <kbd>method</kbd> `end`

```python
end() → None

`méthode` `set_attributes`

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: <class 'str'>
model: <class 'str'>
agent_id: <class 'str'>
agent_description: <class 'str'>
agent_version: <class 'str'>
system_instructions: list[str]
messages: list[conversation.types.Message]
spans: list[conversation.conversation.LLM | conversation.conversation.Tool | conversation.conversation.SubAgent]
continue_parent_trace: <class 'bool'>
started_at: datetime.datetime | None
ended_at: datetime.datetime | None

`méthode` `add_event`

add_event(
    name: 'str',
    attributes: 'dict[str, Any] | None' = None,
    timestamp: 'datetime | None' = None
) → Self

À 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. 

---

<SourceLink url="https://github.com/wandb/weave/blob/v0.53.1/weave/conversation/conversation.py#L1033" />

### <kbd>method</kbd> `end`

```python
end() → None

`méthode` `llm`

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.

`méthode` `model_post_init`

model_post_init(context: 'Any') → None

`méthode` `record`

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`

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`

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`

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`

user(content: 'str') → Turn

Ajoute un message utilisateur au cours d’un tour de conversation.

`classe` `Usage`

Utilisation des jetons d’un appel LLM. Champs Pydantic :

input_tokens : <class 'int'>
output_tokens : <class 'int'>
reasoning_tokens : <class 'int'>
cache_creation_input_tokens : <class 'int'>
cache_read_input_tokens : <class 'int'>

`fonction` `add_tags`

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

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

`fonction` `as_op`

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`

attributes(attributes: 'dict[str, Any]') → Iterator

Gestionnaire de contexte permettant de définir des attributs sur un appel. Exemple :

with weave.attributes({'env': 'production'}):
     print(my_function.call("World"))

`fonction` `end_conversation`

end_conversation() → None

Termine la conversation en cours (à partir de la contextvar).

`fonction` `end_llm`

end_llm() → None

Termine l’appel LLM en cours (à partir de la contextvar).

`fonction` `end_session`

end_session() → None

Alias obsolète de :func:weave.end_conversation.

`fonction` `end_turn`

end_turn() → None

Termine le tour de conversation en cours (à partir de la contextvar).

`fonction` `finish`

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`

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 :

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`

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.

`fonction` `get_client`

get_client() → WeaveClient | None

`fonction` `get_current_call`

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`

get_current_conversation() → Conversation | None

Renvoie la conversation active à partir de la contextvar, ou None.

`fonction` `get_current_llm`

get_current_llm() → LLM | None

Renvoie l’appel LLM actif depuis la contextvar, ou None.

`fonction` `get_current_session`

get_current_session() → Conversation | None

Alias obsolète de :func:weave.get_current_conversation.

`fonction` `get_current_turn`

get_current_turn() → Turn | None

Renvoie le tour de conversation actif à partir de la contextvar, ou None.

`fonction` `get_tags`

get_tags(obj_ref: 'ObjectRef | str') → list[str]

Obtenir les tags d’une version d’objet. Arguments :

obj_ref : Référence à la version 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`

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`

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

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 <registry_project>/<portfolio_name>, par exemple wandb-registry-prompts/my-prompt-collection.
aliases : alias facultatifs à joindre à la version créée dans le registre. Retourne :
LinkAssetToRegistryRes : réponse analysée renvoyée par le point de terminaison registry-link.

`fonction` `list_aliases`

list_aliases() → list[str]

Liste tous les alias distincts du projet. Retourne : Liste triée de tous les alias (string) du projet.

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`

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 :

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
    ... )

---

<SourceLink url="https://github.com/wandb/weave/blob/v0.53.1/weave/conversation/conversation.py#L1584" />

### <kbd>function</kbd> `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).

`fonction` `log_session`

log_session(
    turns: 'list[Turn]',
    session_id: 'str' = '',
    session_name: 'str' = '',
    agent_name: 'str' = '',
    model: 'str' = '',
    include_content: 'bool' = True,
    continue_parent_trace: 'bool' = False,
    attributes: 'Attributes' = None
) → LogResult

Alias obsolète de :func:weave.log_conversation. session_id / session_name correspondent respectivement à conversation_id / conversation_name.

`fonction` `log_turn`

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`

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`

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`

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`

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`

remove_aliases(obj_ref: 'ObjectRef | str', alias: 'str | list[str]') → None

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

`fonction` `remove_tags`

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

Supprime des tags d’une version d’objet.

obj_ref : Référence à l’objet, soit un ObjectRef, soit une string URI weave ///.
alias : Nom d’alias ou liste de noms d’alias à supprimer. Arguments :

`fonction` `require_current_call`

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.

@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.

client = weave.init("<project>")
mycall = client.get_call("<call_id>")

Vous pouvez également utiliser la méthode call de votre op après l’avoir défini. Par exemple :

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

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`

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.<name>.

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`

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`

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.

`fonction` `start_session`

start_session(
    agent_name: 'str' = '',
    model: 'str' = '',
    session_id: 'str' = '',
    session_name: 'str' = '',
    include_content: 'bool' = True,
    continue_parent_trace: 'bool' = False,
    attributes: 'Attributes' = None
) → Conversation

Alias obsolète de :func:weave.start_conversation. session_id / session_name correspondent respectivement à conversation_id / conversation_name.

`fonction` `start_subagent`

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`

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`

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.

`fonction` `thread`

thread(
    thread_id: 'str | object | None' = <object object at 0x7f136d9f4bd0>
) → Iterator[ThreadContext]

Gestionnaire de contexte permettant de définir le thread_id des appels effectués dans ce contexte. Exemples :

# Génération automatique du thread_id
with weave.thread() as t:
     print(f"Thread ID: {t.thread_id}")
     result = my_function("input")  # Cet appel recevra le thread_id généré automatiquement
     print(f"Current turn: {t.turn_id}")

# thread_id explicite
with weave.thread("custom_thread") as t:
     result = my_function("input")  # Cet appel recevra thread_id="custom_thread"

# Désactivation du regroupement en threads
with weave.thread(None) as t:
     result = my_function("input")  # Cet appel recevra thread_id=None

Arguments :

thread_id : identifiant du thread à associer aux appels dans ce contexte. S’il n’est pas fourni, un UUID v7 est généré automatiquement. S’il vaut None, le suivi des threads est désactivé. Génère :
ThreadContext : objet donnant accès à thread_id et au turn_id actuel.

`fonction` `wandb_init_hook`

wandb_init_hook() → None

Dernière modification le 30 septembre 2026

​Aperçu de l’API

​classe Agent

​méthode step

​classe AgentState

​classe AnnotationSpec

​classmethod preprocess_field_schema

​classmethod validate_field_schema

​méthode value_is_valid

​classe Audio

​méthode __init__

​méthode export

​classmethod from_data

​classmethod from_path

​classe ClassifierMonitor

​méthode activate

​méthode deactivate

​classmethod from_obj

​méthode get_prompt_footer

​méthode get_prompt_header

​méthode model_post_init

​classe Content

​méthode __init__

​propriété art

​propriété ref

​méthode as_string

​classmethod from_base64

​classmethod from_bytes

​classmethod from_data_url

​classmethod from_path

​classmethod from_text

​classmethod from_url

​classmethod model_validate

​classmethod model_validate_json

​méthode open

​méthode save

​méthode serialize_data

​méthode to_data_url

​classe Conversation

​méthode end

​méthode model_post_init

​méthode start_turn

​classe Dataset

​méthode add_rows

​classmethod convert_to_table

​classmethod from_calls

​classmethod from_hf

​classmethod from_obj

​classmethod from_pandas

​méthode select

​méthode to_hf

​méthode to_pandas

​classe EasyPrompt

​méthode __init__

​propriété as_str

​propriété is_bound

​propriété messages

​propriété placeholders

​propriété system_message

​propriété system_prompt

​propriété unbound_placeholders

​méthode append

​méthode as_dict

​méthode as_pydantic_dict

​méthode bind

​méthode bind_rows

​méthode config_table

​méthode configure

​méthode dump

​méthode dump_file

​méthode format

​classmethod from_obj

​classmethod load

​classmethod load_file

​méthode messages_table

​méthode print

​méthode publish

​méthode require

​méthode run

​méthode validate_requirement

​méthode validate_requirements

Aperçu de l’API

`classe` `Agent`

`méthode` `step`

`classe` `AgentState`

`classe` `AnnotationSpec`

`classmethod` `preprocess_field_schema`

`classmethod` `validate_field_schema`

`méthode` `value_is_valid`

`classe` `Audio`

`méthode` `init`

`méthode` `export`

`classmethod` `from_data`

`classmethod` `from_path`

`classe` `ClassifierMonitor`

`méthode` `activate`

`méthode` `deactivate`

`classmethod` `from_obj`

`méthode` `get_prompt_footer`

`méthode` `get_prompt_header`

`méthode` `model_post_init`

`classe` `Content`

`méthode` `init`

`propriété` art

`propriété` ref

`méthode` `as_string`

`classmethod` `from_base64`

`classmethod` `from_bytes`

`classmethod` `from_data_url`

`classmethod` `from_path`

`classmethod` `from_text`

`classmethod` `from_url`

`classmethod` `model_validate`

`classmethod` `model_validate_json`

`méthode` `open`

`méthode` `save`

`méthode` `serialize_data`

`méthode` `to_data_url`

`classe` `Conversation`

`méthode` `end`

`méthode` `model_post_init`

`méthode` `start_turn`

`classe` `Dataset`

`méthode` `add_rows`

`classmethod` `convert_to_table`

`classmethod` `from_calls`

`classmethod` `from_hf`

`classmethod` `from_obj`

`classmethod` `from_pandas`

`méthode` `select`

`méthode` `to_hf`

`méthode` `to_pandas`

`classe` `EasyPrompt`

`méthode` `init`

`propriété` as_str

`propriété` is_bound

`propriété` messages

`propriété` placeholders

`propriété` system_message

`propriété` system_prompt

`propriété` unbound_placeholders

`méthode` `append`

`méthode` `as_dict`

`méthode` `as_pydantic_dict`

`méthode` `bind`

`méthode` `bind_rows`

`méthode` `config_table`

`méthode` `configure`

`méthode` `dump`

`méthode` `dump_file`

`méthode` `format`

`classmethod` `from_obj`

`classmethod` `load`

`classmethod` `load_file`

`méthode` `messages_table`

`méthode` `print`

`méthode` `publish`

`méthode` `require`

`méthode` `run`

`méthode` `validate_requirement`

`méthode` `validate_requirements`