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

`méthode de classe` `preprocess_field_schema`

preprocess_field_schema(data: Any) → Any

`méthode de classe` `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 un payload 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`

Une classe qui représente 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 (prend actuellement en charge ‘wav’ ou ‘mp3’)
data: Les données audio brutes sous forme d’octets

Arguments :

data: Les données audio (octets ou chaîne 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 :

`méthode de classe` `from_data`

from_data(data: 'str | bytes', format: 'str') → Self

Crée un objet Audio à partir de données brutes et du format spécifié.

path: Chemin où écrire le fichier audio Arguments :
data: Données audio sous forme d’octets ou de chaîne encodée en base64
format: Format audio (‘wav’ ou ‘mp3’) Retourne :
Audio: Une nouvelle instance de Audio

Exceptions levées :

ValueError: Si le format n’est pas pris en charge

`méthode de classe` `from_path`

from_path(path: 'str | bytes | Path | PathLike') → Self

Crée un objet Audio à partir du chemin d’un fichier. Arguments :

path: Chemin vers un fichier audio (doit avoir l’extension .wav ou .mp3) 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 classificateur. Les moniteurs de classificateur combinent 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 : Une référence au moniteur.

`méthode` `deactivate`

deactivate() → ObjectRef

Désactive le moniteur. Retourne : Une référence au moniteur.

`méthode de classe` `from_obj`

from_obj(obj: WeaveObject) → Self

`méthode` `get_prompt_footer`

get_prompt_footer() → str

Texte à ajouter après les prompts du classificateur fusionné.

`méthode` `get_prompt_header`

get_prompt_header(op_name: str) → str

Texte à ajouter avant les prompts fusionnés du classificateur.

`méthode` `model_post_init`

model_post_init(context: Any) → None

Normalisez op_names à la construction lorsqu’un client est disponible. La publication n’a pas de hook par objet. Ainsi, pour couvrir aussi un simple weave.publish(monitor) (sans activate()), développez ici les noms courts : en général, quiconque publie a déjà appelé weave.init, donc le client est défini lorsque le moniteur est construit. Plusieurs cas d’utilisation créent l’objet sans client, par exemple pour des tests unitaires, de l’inspection ou la désérialisation d’un moniteur stocké dans un worker. La vérification sur get_weave_client() permet cette construction sans client. La normalisation n’aura pas lieu dans ce cas, 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 où un moniteur peut être créé avec le SDK sans être normalisé : si l’utilisateur construit le moniteur, puis appelle weave.init, puis le publie. Appeler activate() ou deactivate() peut constituer une solution de contournement pour ce cas d’utilisation.

`classe` `Content`

Une classe qui représente du contenu provenant de différentes sources, en le convertissant en une représentation unifiée sous forme d’octets, avec les métadonnées associées. Cette classe doit être instanciée à l’aide de l’une de ses méthodes de classe :

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. Veuillez utiliser une méthode de classe 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 chaîne de caractères. Les octets sont décodés à l’aide de l’attribut encoding. Si la valeur est en base64, les données sont réencodées en octets base64, puis décodées en chaîne ASCII. Retourne : str.

`méthode de classe` `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 chaîne ou d’octets encodés en base64.

`méthode de classe` `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.

`méthode de classe` `from_data_url`

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

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

`méthode de classe` `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 du chemin d’un fichier local.

`méthode de classe` `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 chaîne de texte.

`méthode de classe` `from_url`

from_url(
    url: 'str',
    headers: 'dict[str, Any] | None' = None,
    timeout: 'int | None' = 30,
    metadata: 'dict[str, Any] | None' = None
) → Self

Initialise l’objet Content à partir des octets récupérés depuis une URL HTTP(S). Télécharge le contenu, détermine 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.

`méthode de classe` `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éfinissez model_validate pour prendre en charge la reconstruction de Content à partir d’un dict.

`méthode de classe` `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éfinissez model_validate_json pour gérer la reconstruction de Content à partir de JSON.

`méthode` `open`

open() → bool

Ouvrez le fichier à l’aide de l’application par défaut du système d’exploitation. Cette méthode utilise 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 été ouvert avec succès, False sinon.

`méthode` `save`

save(dest: 'str | Path') → None

Copiez le fichier dans le chemin de destination spécifié. Met à jour le nom du fichier ainsi que le chemin du contenu pour qu’ils correspondent à 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é (chaîne de caractères 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 ex. .txt), la destination sera considérée comme un répertoire. Arguments :
use_base64: Si True, les données seront encodées en base64. Sinon, elles seront encodées par pourcentage. La valeur par défaut est True. Retourne : Une chaîne contenant une URL de données.

`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. La valeur par défaut False signifie que chaque tour de conversation démarre sa propre trace OTel (le bon choix pour la vue autonome de l’onglet Agents). Définissez True lorsque l’application a une trace englobante (par exemple, une requête FastAPI instrumentée) qui doit contenir l’invocation de l’agent. Champs Pydantic :

conversation_id: <class 'str'>
conversation_name: <class 'str'>
agent_name: <class 'str'>
model: <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' = '',
    system_instructions: 'list[str] | None' = None
) → Turn

Créer un nouveau tour de conversation. Termine automatiquement le tour de conversation précédent s’il est toujours ouvert. Définit la variable de contexte _current_turn afin que le tour de conversation soit accessible via get_current_turn(), qu’un gestionnaire de contexte soit utilisé ou non. Propage continue_parent_trace à partir de cette conversation. system_instructions (le prompt système de l’agent) est conservé dans le span invoke_agent du tour de conversation ; il peut également être défini ultérieurement par attribution d’attribut sur le Turn renvoyé, comme dans start_llm.

`classe` `Dataset`

Objet dataset facile à enregistrer, avec 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 spécifique
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. C’est utile pour ajouter des exemples à de grands datasets sans avoir à charger l’intégralité du dataset en mémoire. Arguments :

rows: Les lignes à ajouter au dataset. Retourne : Le dataset mis à jour.

`méthode de classe` `convert_to_table`

convert_to_table(rows: Any) → Table | WeaveTable

`méthode de classe` `from_calls`

from_calls(calls: Iterable[Call]) → Self

`méthode de classe` `from_hf`

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

`méthode de classe` `from_obj`

from_obj(obj: WeaveObject) → Self

`méthode de classe` `from_pandas`

from_pandas(df: 'DataFrame') → Self

`méthode` `select`

select(indices: Iterable[int]) → Self

Sélectionnez des lignes du dataset à partir des indices fournis. Arguments :

indices : Un itérable d’indices entiers indiquant quelles 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 en une seule chaîne.

`propriété` is_bound

`propriété` messages

espaces réservés de `propriété`

`propriété` system_message

Regroupe tous les messages en un message de prompt système.

`propriété` system_prompt

Regroupe tous les messages en 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

`méthode de classe` `from_obj`

from_obj(obj: WeaveObject) → Self

`méthode de classe` `load`

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

`méthode de classe` `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

`class` `Evaluation`

Configure une évaluation comprenant un ensemble d’évaluateurs et un jeu de données. L’appel à evaluation.evaluate(model) transmet les lignes d’un jeu de données à un modèle en faisant correspondre les noms des colonnes du jeu de données aux noms des arguments de model.predict. Ensuite, tous les évaluateurs sont appelés et les résultats sont enregistrés dans Weave. Si vous souhaitez prétraiter les lignes du jeu de données, vous pouvez passer une fonction à preprocess_model_input. Exemples :

# Collectez 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:
     # C'est ici que vous définiriez la logique pour évaluer la sortie du modèle
     return {'match': expected == model_output['generated_text']}

@weave.op
def function_to_evaluate(question: str):
     # c'est ici que vous ajouteriez votre appel LLM et retourneriez 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')
# Lancez 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 0x7f7d21ca09a0>, 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

`méthode de classe` `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 Évaluation. Notez que cette méthode renvoie un CallsIter plutôt qu’un appel unique, car il peut y avoir plusieurs appels d’évaluation pour une seule évaluation (par exemple, si vous exécutez plusieurs fois la même évaluation). 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/exécutée).

Exemples :

evaluation = Evaluation(dataset=examples, scorers=[scorer])
await evaluation.evaluate(model)  # Exécuter l'évaluation en premier
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 de l’évaluateur pour chaque Run d’Évaluation, regroupés par ID de trace. Retourne :

dict[str, list[Call]] : Un dictionnaire qui associe les ID de trace à des listes d’objets Appel de l’évaluateur. Chaque ID de trace représente un Run d’Évaluation, et la liste contient tous les appels de l’évaluateur exécutés pendant 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 résultats des évaluateurs à partir des Runs d’évaluation. Retourne :

dict[str, dict[str, list[Any]]: Une structure de dictionnaire imbriquée où :
- Les clés du premier niveau sont les ID de trace (Runs d’évaluation)
- Les clés du deuxième niveau sont les noms des évaluateurs
- Les valeurs sont des listes de résultats d’évaluateur pour ce Run et cet évaluateur

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

`class` `EvaluationLogger`

Cette classe fournit une interface impérative pour enregistrer des évaluations. Une évaluation démarre automatiquement lorsque la première prédiction est enregistrée via la méthode log_prediction, et se termine lorsque la méthode log_summary est appelée. Chaque fois que vous enregistrez une prédiction, vous obtenez un objet ScoreLogger. Vous pouvez utiliser cet objet pour enregistrer les scores et les métadonnées de cette prédiction. Pour plus d’informations, voir la classe ScoreLogger. Utilisation de base - enregistrez directement les prédictions avec les entrées et les sorties :

ev = EvaluationLogger()

# Enregistrer les prédictions avec les entrées/sorties 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 des sorties dynamiques et des opérations imbriquées :

ev = EvaluationLogger()

# Utilisez un gestionnaire de contexte pour capturer les opérations imbriquées
with ev.log_prediction(inputs={'q': 'Hello'}) as pred:
     # Toutes les opérations ici (comme les appels LLM) deviennent automatiquement
     # des enfants de l'appel predict
     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

attributs de la `propriété`

`propriété` ui_url

`méthode` `fail`

fail(exception: 'BaseException') → None

Méthode utilitaire qui fait échouer l’Évaluation en levant une exception.

`méthode` `finish`

finish(exception: 'BaseException | None' = None) → None

Libère explicitement les ressources d’évaluation sans enregistrer de synthèse. Garantit que tous les appels de prédiction ainsi que l’appel d’évaluation principal sont finalisés. Cette méthode est appelée automatiquement si 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

Journalisez un exemple complet avec les entrées, la sortie et les scores. Il s’agit d’une méthode utilitaire qui 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 à leurs scores 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. Retourne un ScoreLogger qui peut être utilisé directement ou comme gestionnaire de contexte. Arguments :

inputs: Les données d’entrée de la prédiction
output: La valeur de sortie. La valeur par défaut est None. Peut être définie plus tard avec pred.output. Retourne : ScoreLogger pour journaliser les scores et, éventuellement, finaliser la prédiction.

Exemple (direct) :

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

Enregistre un dict de synthèse dans l’Évaluation. Cela calcule la synthèse, appelle l’op summarize, puis clôt l’évaluation, ce qui signifie qu’il n’est plus possible d’enregistrer 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

Associe une vue à la synthèse de l’appel principal de l’évaluation sous weave.views. Enregistre le contenu fourni comme objet dans le projet et inscrit son URI de référence sous summary.weave.views.<name> pour l’appel evaluate de l’évaluation. Les entrées de type chaîne sont encapsulées en contenu texte à l’aide de Content.from_text avec l’extension ou le type MIME fourni. Arguments :

name : Le nom de la vue à afficher, utilisé comme clé sous summary.weave.views.
content : Une instance de weave.Content ou une chaîne à sérialiser.
extension : Extension de fichier facultative pour les entrées de contenu de type chaîne.
mimetype : Type MIME facultatif pour les entrées de contenu de type chaîne.
metadata : Métadonnées facultatives associées au Content nouvellement créé.
encoding : Encodage du texte pour les entrées de contenu de type chaîne. Retourne : None

Exemples : import weave

ev = weave.EvaluationLogger() ev.set_view(“report”, ”# Report”, extension=“md”)

`class` `File`

Classe représentant un fichier avec son chemin, son type MIME et sa taille.

`méthode` `init`

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

Initialise un objet File. Arguments :

`propriété` filename

Obtient le nom du fichier.

path: Chemin vers le fichier (string ou pathlib.Path)
mimetype: Type MIME facultatif du fichier ; sera 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

Ouvrez le fichier avec l’application par défaut du système d’exploitation. Cette méthode utilise le mécanisme propre à la plateforme pour ouvrir le fichier avec l’application par défaut associée au type de fichier. Retourne :

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

`méthode` `save`

save(dest: 'str | Path') → None

Copiez le fichier dans le chemin de destination spécifié. Arguments :

`class` `LLM`

Un appel d’API à un 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

Enregistrez un événement de span OTel à un instant donné au sein de ce span. À utiliser pour des données de marqueur / de cycle de vie — prompts d’autorisation (par ex. weave.permission_request), transitions du cycle de vie (par ex. spawned / streaming / finished), ou tout autre jalon personnalisé qui survient à un instant précis pendant la durée de vie du span (par opposition à 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 de with). En dehors de cette plage, l’appel n’a aucun effet et journalise un avertissement.

`méthode` `attach_media`

attach_media(
    content: 'bytes | str' = '',
    uri: 'str' = '',
    file_id: 'str' = '',
    mime_type: 'str' = '',
    modality: 'str' = ''
) → LLM

Ajoutez 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 stocke uniquement cette réf. Vous devez fournir exactement un seul des paramètres 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é afin que l’appel renvoie immédiatement sans bloquer l’appelant ; un thread est lancé par pièce jointe, de sorte que plusieurs téléversements se poursuivent en parallèle. L’espace réservé MediaAttachment est ajouté de manière synchrone et son ref est renseigné une fois le téléversement terminé. Il est garanti que les réf. sont renseignées avant l’émission du span (le chemin de build 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

Associez une URL de média à cet appel LLM. Méthode pratique par rapport à attach_media pour le cas courant où l’appelant dispose d’une chaîne URL provenant d’un message en amont. Les URL data: sont analysées en octets et publiées ; les URI simples sont récupérées et 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

Ajouter un message d’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éfinissez plusieurs champs d’un appel LLM en un seul appel. Les agents instrumentés manuellement construisent généralement un span de chat en renseignant huit champs distincts ou plus à 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 afin de garder un point d’enregistrement compact. Seuls les champs explicitement transmis (non-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 le chaînage.

`méthode` `set_attributes`

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

Ajoutez 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"}). Cette méthode reflète 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 plage, l’appel n’a aucun effet et journalise un avertissement. Pour l’ingestion par lot, renseignez directement les champs déclarés de l’objet et transmettez-le à log_turn / log_conversation.

`méthode` `think`

think(content: 'str') → LLM

Définit le contenu de raisonnement/de chaîne de pensée.

`classe` `LogResult`

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

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

`classe` `Markdown`

Un objet Markdown affichable. Arguments :

markup (str): Une chaîne contenant du Markdown.
code_theme (str, facultatif): Thème Pygments pour les blocs de code. La valeur par défaut est “monokai”. Voir https://pygments.org/styles/ pour les thèmes de code.
justify (JustifyMethod, facultatif): Valeur de justification des paragraphes. La valeur par défaut est None.
style (Union[str, Style], facultatif): Style facultatif à appliquer au Markdown.
hyperlinks (bool, facultatif): Active les liens hypertexte. La valeur par défaut est 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`

Une pièce jointe multimédia dans un appel LLM. Contient toujours un 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’y être stockés.

inline_code_lexer: (str, facultatif) : lexer à 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 ne pas appliquer de coloration. Valeur par défaut : None. champs Pydantic :
ref: <class 'str'>
modality: <class 'str'>
mime_type: <class 'str'>

`classe` `Message`

Un message dans une conversation. Deux styles de construction sont pris en charge :

À plat (rétrocompatibilité, pratique pour le texte brut) : Message(role="assistant", content="Hi there")
Avec parties explicites (plus riche — prend en charge les appels d’outil, le raisonnement et le texte combinés, 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 s’agit de la représentation canonique. Lorsqu’il est vide, le sérialiseur synthétise un unique TextPart (ou ToolCallResponsePart pour role="tool") à partir des champs à plat. 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')]]

`méthode de classe` `assistant`

assistant(
    text: 'str' = '',
    tool_calls: 'list[ToolCallPart] | None' = None
) → Message

Créez un message d’assistant avec un texte facultatif et des appels d’outil. Utilisez du texte brut pour les réponses simples ; transmettez tool_calls lorsque l’assistant demande 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 de conversation les affiche en ligne.

`méthode de classe` `system`

system(text: 'str') → Message

Créez un message système à partir de texte brut.

`méthode de classe` `tool_result`

tool_result(call_id: 'str', output: 'Any') → Message

Créez un message de résultat pour un appel d’outil demandé précédemment. output peut être une chaîne, un dictionnaire, une liste, une valeur scalaire ou None — le ToolCallResponsePart sous-jacent encode en JSON les valeurs qui ne sont pas des chaînes.

`méthode de classe` `user`

user(text: 'str') → Message

Crée 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

Met en forme un seul message en remplaçant les variables du modèle. Cette méthode délègue la logique de mise en forme proprement dite à la fonction autonome format_message_with_template_vars.

`méthode de classe` `from_obj`

from_obj(obj: WeaveObject) → Self

`classe` `Model`

Conçue pour représenter une combinaison de code et de données qui opère sur une entrée. Par exemple, elle 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éfinissent votre modèle, ces changements seront enregistrés et la version sera mise à jour. Cela vous permet de comparer les prédictions entre différentes versions de votre modèle. Utilisez cette classe pour itérer sur les prompts ou essayer le dernier LLM, puis comparer les prédictions dans différentes configurations. Exemples :

class YourModel(Model):
     attribute1: str
     attribute2: int

     @weave.op
     def predict(self, input_data: str) -> dict:
         # La logique du modèle se trouve ici
         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 pour attribuer automatiquement un score aux appels entrants. Notez que le nom de l’op sera converti en réf. Weave à l’aide de l’entité et du projet du client Weave. Si vous travaillez sur plusieurs entités et Projects avec le même client, vous devrez spécifier une réf. Weave entièrement qualifiée. Voir _normalized_op_names pour plus de détails. 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 : Une réf. au moniteur.

`méthode` `deactivate`

deactivate() → ObjectRef

Désactive le moniteur. Retourne : Une réf. au moniteur.

`méthode de classe` `from_obj`

from_obj(obj: WeaveObject) → Self

`méthode` `model_post_init`

model_post_init(context: Any) → None

Normalisez op_names lors de la construction lorsqu’un client est disponible. La publication ne dispose pas de hook par objet. Ainsi, pour couvrir également un simple weave.publish(monitor) (sans activate()), développez ici les noms courts : toute personne qui publie a généralement appelé weave.init, donc le client est défini au moment où le moniteur est construit. Plusieurs cas d’utilisation construisent l’objet sans client, par exemple pour les tests unitaires, l’inspection ou la désérialisation d’un moniteur stocké dans un worker. La vérification dans get_weave_client() permet cette construction sans client. La normalisation n’aura pas lieu dans ce cas, mais cela devrait convenir, car les moniteurs stockés contiennent déjà des réf. complètes. Il existe un cas limite où un moniteur peut être créé avec le SDK sans normalisation : si l’utilisateur construit le moniteur, puis appelle weave.init, avant de le publier. Appeler activate() ou deactivate() peut constituer une solution de contournement pour ce cas d’utilisation.

`classe` `Object`

Classe de base pour les objets de Weave qui peuvent être suivis et versionnés. Cette classe étend le BaseModel de Pydantic afin de fournir des fonctionnalités propres à Weave pour le suivi des objets, leur référencement et leur sérialisation. Les objets peuvent avoir des noms, des descriptions et des références, ce qui permet de les stocker dans le système Weave et de les en récupérer. Attributs :

name (str | None): Nom lisible par l’humain 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

`méthode de classe` `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. 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")

`méthode de classe` `handle_relocatable_object`

handle_relocatable_object(
    v: Any,
    handler: ValidatorFunctionWrapHandler,
    info: ValidationInfo
) → Any

Gère la validation des objets déplaçables, notamment ObjectRef et WeaveObject. Ce validateur traite les cas particuliers où la valeur d’entrée est un ObjectRef ou un WeaveObject qui doit être correctement converti en instance d’objet standard. Il garantit que les références sont préservées et que les types ignorés sont correctement pris en charge pendant le processus de validation. Arguments :

v (Any): La valeur à valider.
handler (ValidatorFunctionWrapHandler): Le gestionnaire de validation pydantic standard.
info (ValidationInfo): Les informations de 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 des cas tels que : ```python

Lorsqu’un ObjectRef est passé

obj = MyObject(some_object_ref)

Lorsqu’un WeaveObject est passé

obj = MyObject(some_weave_object)

---

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

### <kbd>classmethod</kbd> `strip_weave_serialization_metadata`

```python
strip_weave_serialization_metadata(data: Any) → Any

Supprimez des entrées de dictionnaire les métadonnées de sérialisation de Weave. La sérialisation de Weave ajoute _type, _class_name et _bases aux dictionnaires pour reconstruire le type. Il ne s’agit pas de véritables champs du modèle et ils doivent ê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 à l’API fluide permettant de manipuler des objets SavedView.

`méthode` `init`

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

`propriété` entité

`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 pour 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 qui correspondent 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 connues.

`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

`méthode de classe` `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

Publier la vue enregistrée sur le serveur.

`méthode` `set_columns`

set_columns(*columns: 'str') → SavedView

Définissez 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 pour afficher cette vue enregistrée dans l’UI. Notez qu’il s’agit de la page de « résultat » avec les traces, etc., et non de l’URL de l’objet de 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

`méthode de classe` `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 comme propriétés en lecture/écriture qui font office de proxy vers conversation_id / conversation_name. La classe Session d’origine les définissait comme champs du modèle ; ainsi, l’ancien code qui lit ou attribue s.session_id continue 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'>
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

`méthode de classe` `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 imbriqué invoke_agent 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

Enregistrez un événement de span OTel à un instant donné dans ce span. À utiliser pour des données de marquage / de cycle de vie — demandes d’autorisation (par ex. weave.permission_request), transitions du cycle de vie (par ex. spawned / streaming / finished), ou tout autre jalon personnalisé qui survient à un instant donné pendant la durée de vie du span (par opposition à 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 de with). En dehors de cette fenêtre, l’appel est sans effet et journalise un avertissement.

`méthode` `end`

end() → None

`méthode` `llm`

llm(
    model: 'str' = '',
    provider_name: 'str' = '',
    system_instructions: 'list[str] | None' = None
) → LLM

Démarrer un appel de LLM dans ce sous-agent. Définit la variable de contexte _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éfinissez plusieurs champs de sous-agent en un seul appel. Regroupe en un seul appel avec arguments nommés les attributions champ par champ qu’un agent instrumenté manuellement effectuerait sinon sur un sous-agent (system_instructions, agent_id, …). Seuls les champs explicitement transmis (non None) sont appliqués — les valeurs existantes sont conservées. Renvoie self pour permettre l’enchaînement. Reflète Turn.record / LLM.record. Remarque : dans le flux de streaming (with), le span du sous-agent prend son nom à partir de name dans __enter__. Définissez donc name via start_subagent / turn.subagent plutôt que via record si vous avez besoin que le nom du span le reflète ; record met tout de même à jour l’attribut gen_ai.agent.name.

`méthode` `set_attributes`

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

Ajoutez 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"}). Cette méthode reflète Span.set_attributes d’OTel. Doit être appelé entre le début et la fin du span, c.-à-d. à l’intérieur d’un bloc with. En dehors de cette plage, l’appel n’a aucun effet et journalise un avertissement. Pour l’ingestion par lot, renseignez directement les champs déclarés de l’objet et passez-le à log_turn / log_conversation.

`méthode` `tool`

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

Lancez l’exécution d’un 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

Ajoutez une ligne au tableau.

`méthode` `pop`

pop(index: 'int') → None

Supprimez du tableau la ligne située à l’index donné.

`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 n’est pas idéal. Cette classe automatise la copie des contextvars, de sorte que l’utilisation de ce thread “fonctionne tout simplement”, comme l’utilisateur s’y attend probablement. Vous pouvez obtenir le même effet 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

`propriété` daemon

Valeur booléenne indiquant si ce thread est un thread démon. Cette valeur doit être définie avant l’appel à start(), sinon une RuntimeError est levée. Sa valeur initiale est héritée du thread qui l’a créé ; le thread principal n’est pas un thread démon et, par conséquent, tous les threads créés dans le thread principal ont par défaut la valeur daemon = False. L’ensemble du programme Python se termine lorsqu’il ne reste plus que des threads démons.

`propriété` 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.

`propriété` nom

Une chaîne utilisée uniquement à des fins d’identification. Ce nom n’a pas de signification particulière. Plusieurs threads peuvent recevoir le même nom. Le nom initial est défini par le constructeur.

`propriété` native_id

Identifiant natif entier de ce thread, ou None s’il n’a pas été démarré. Il s’agit d’un entier non négatif. Voir la fonction get_native_id(). Il correspond à l’ID du thread tel que rapporté 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')

Initialisez ThreadContext à l’aide du thread_id spécifié. Arguments :

`propriété` thread_id

Renvoie le thread_id de ce contexte.

thread_id : l’identifiant du thread pour ce contexte, ou None s’il est désactivé. Retourne : L’identifiant du thread, ou None si le suivi du thread est désactivé.

`propriété` turn_id

Obtient le turn_id actuel 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. Il s’agit d’un remplacement direct de concurrent.futures.ThreadPoolExecutor qui garantit que les appels Weave se comportent comme prévu au sein de 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 parent, ce qui peut entraîner la perte du contexte d’appel — ce n’est pas souhaitable ! Cette classe automatise la copie des contextvars, de sorte que l’utilisation de cet exécuteur “fonctionne tout simplement”, comme l’utilisateur s’y attend probablement. Vous pouvez obtenir le même effet 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 au span OTel execute_tool. arguments et result utilisent l’annotation JSONString : le code appelant peut attribuer un dict / une liste / un scalaire, et le SDK l’encode en JSON lors de l’instanciation ou de l’attribution. La valeur stockée est toujours une chaîne, conformément au format de transmission défini par la semconv 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

Enregistrez un événement de span OTel à un instant donné dans ce span. À utiliser pour des données de marquage / de cycle de vie — prompts d’autorisation (par ex. weave.permission_request), transitions du cycle de vie (par ex. spawned / streaming / finished), ou tout autre jalon personnalisé qui survient à un instant donné pendant la durée de vie du span (par opposition à 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 de with). En dehors de cette fenêtre, l’appel est sans effet et consigne un avertissement.

`méthode` `end`

end() → None

`méthode` `set_attributes`

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

Ajoutez des attributs OTel arbitraires à ce span. Passez un dictionnaire, que vous ayez une seule clé ou plusieurs — pour une seule clé, utilisez span.set_attributes({"weave.tag": "value"}). Cette méthode reflète 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 plage, l’appel n’a aucun effet et journalise un avertissement. Pour l’ingestion par lot, renseignez directement les champs déclarés de l’objet et passez-le à log_turn / log_conversation.

`classe` `Turn`

Un échange entre un utilisateur et un agent. Correspond à un span OTel invoke_agent. Par défaut, chaque tour de conversation démarre sa propre trace OTel (continue_parent_trace=False), de sorte que l’onglet Agents affiche une trace par tour de conversation. Définissez continue_parent_trace=True sur la Conversation (ou directement sur le Turn) lorsqu’une trace parente externe est déjà active et que vous souhaitez y imbriquer l’appel d’agent — par exemple, dans une requête FastAPI instrumentée. 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

Enregistrez un événement de span OTel à un instant donné dans ce span. À utiliser pour des données de marqueur / de cycle de vie — demandes d’autorisation (par ex. weave.permission_request), transitions du cycle de vie (par ex. spawned / streaming / finished), ou tout autre jalon personnalisé survenant à un instant donné pendant la durée de vie du span (par opposition à 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 de with). En dehors de cette plage, l’appel est sans effet et journalise un avertissement.

`méthode` `end`

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 le contextvar _current_llm pour 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 d’un tour de conversation en un seul appel. Regroupe en un seul appel avec arguments nommés les attributions champ par champ qu’un agent instrumenté manuellement effectuerait autrement 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. Reproduit le comportement de LLM.record. Remarque : dans le flux de streaming (with), le span du tour de conversation est nommé à partir de agent_name dans __enter__ ; définissez donc agent_name via start_turn plutôt que via record si vous avez besoin que le nom du span en tienne compte. record met néanmoins à jour l’attribut gen_ai.agent.name.

`méthode` `set_attributes`

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

Ajoutez des attributs OTel arbitraires à ce span. Passez un dictionnaire, que vous ayez une seule clé ou plusieurs — si vous n’avez qu’une seule clé, utilisez span.set_attributes({"weave.tag": "value"}). Cette méthode reprend le comportement 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 plage, l’appel n’a aucun effet et journalise un avertissement. Pour l’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 à un sous-agent (span invoke_agent imbriqué, dans la même trace).

`méthode` `tool`

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

Lance l’exécution d’un outil (span execute_tool, enfant de ce tour de conversation).

`méthode` `user`

user(content: 'str') → Turn

Ajoutez un message utilisateur au milieu d’un tour de conversation.

`classe` `Utilisation`

Utilisation des jetons pour 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

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

`fonction` `as_op`

as_op(fn: 'Callable[P, R]') → Op[P, R]

Étant donnée 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 ne devrait donc avoir aucun effet à l’exécution. Vous pouvez toutefois l’utiliser pour satisfaire les vérificateurs de type si vous devez accéder aux attributs d’OpDef de manière sûre du point de vue du typage.

obj_ref: Référence à la version de l’objet, soit un ObjectRef (renvoyé par weave.publish()), soit une chaîne d’URI weave ///.
tags: Liste des chaînes de tag à 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 pour un appel. Exemple :

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

`fonction` `end_conversation`

end_conversation() → None

Terminez la conversation actuelle (depuis contextvar).

`fonction` `end_llm`

end_llm() → None

Termine l’appel LLM en cours (via contextvar).

`fonction` `end_session`

end_session() → None

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

`fonction` `end_turn`

end_turn() → None

Terminez le tour de conversation actuel (depuis contextvar).

`fonction` `finish`

finish() → None

Arrête la journalisation dans Weave. Après l’appel à finish, les appels des fonctions décorées avec weave.op ne seront plus enregistrés. Vous devrez exécuter weave.init() de nouveau pour reprendre la journalisation.

`fonction` `get`

get(uri: 'str | ObjectRef') → Any

Une fonction utilitaire pour obtenir un objet à partir d’un URI. De nombreux objets enregistrés par Weave sont automatiquement inscrits sur le serveur Weave. Cette fonction vous permet de récupérer ces objets à partir de leur URI. Arguments :

uri: Un URI de référence Weave complet. 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 de la version de l’objet, sous la forme d’un ObjectRef ou d’une chaîne d’URI weave ///. Retourne : Liste de chaînes d’alias.

`fonction` `get_client`

get_client() → WeaveClient | None

`fonction` `get_current_call`

get_current_call() → Call | None

Obtenir l’objet Appel de l’Op en cours d’exécution, au sein de cet Op. Retourne : L’objet Appel de l’Op en cours d’exécution, ou None si le suivi n’a pas été initialisé ou si cette méthode est appelée en dehors d’un Op. Remarque :

Le dictionnaire attributes de l’Appel renvoyé devient immuable une fois l’appel lancé. 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 résumé calculées à la fin de l’appel.

`fonction` `get_current_conversation`

get_current_conversation() → Conversation | None

Renvoyer la conversation active stockée dans contextvar, ou None.

`fonction` `get_current_llm`

get_current_llm() → LLM | None

Renvoyer l’appel LLM actif depuis 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

Renvoyer le tour de conversation actif à partir de 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, soit un ObjectRef, soit une chaîne URI weave:///. Retourne : Liste de chaînes de tags.

`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, soit un ObjectRef, soit une chaîne d’URI weave ///. Retourne : Un tuple (tags, alias). Chacun est une liste de chaînes.

`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

Initialisez 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. Après init, les appels aux fonctions décorées avec weave.op seront enregistré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 Weights & Biases et du projet dans lesquels enregistrer les journaux. Si vous ne spécifiez pas d’équipe, votre entité par défaut est utilisée. Pour trouver ou mettre à jour votre entité par défaut, référez-vous à Paramètres utilisateur dans la documentation W&B Models.
settings : Configuration générale du client Weave. Peut être une instance de UserSettings ou un dictionnaire contenant l’une des clés suivantes (toutes facultatives). Tous les paramètres peuvent également être configurés via des variables d’environnement à l’aide du préfixe WEAVE_ (par exemple, WEAVE_DISABLED=true). Paramètres disponibles : - disabled (bool) : Désactive les traces sur toutes les fonctions. Par défaut : False - print_call_link (bool) : Affiche dans le terminal des liens vers l’interface Weave pour les opérations. 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) : Contrôle la manière dont Weave affiche les objets dans la console (auto, rich, print). Par défaut : auto - capture_code (bool) : Capture le code des opérations tracées dans votre projet Weave. Par défaut : True - implicitly_patch_integrations (bool) : Applique automatiquement des patchs aux 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 e-mails, les numéros de téléphone et les cartes de crédit, puis les remplace par des valeurs de substitution avant l’envoi au serveur. Nécessite les packages presidio-analyzer et presidio-anonymizer.
Default: False - redact_pii_fields (list[str]): Spécifie quels types d’entités PII masquer lorsque redact_pii est défini sur True. Si vide, le jeu 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/
Par défaut : [] - 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 et du SDK. Par défaut : True - capture_system_info (bool) : Capture les informations du système d’exploitation. Par défaut : True - client_parallelism (int) : Nombre de workers pour les opérations 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) : Limite de taille du cache en octets. Par défaut : 1_000_000_000 - server_cache_dir (str) : Répertoire du cache serveur. Par défaut : temporary - scorers_dir (str) : Répertoire des points de contrôle de modèle des évaluateurs. Par défaut : ~/.cache/wandb/weave-scorers - max_calls_queue_size (int) : Taille maximale de la file d’attente (0 = sans limite). Par défaut : 100_000 - retry_max_interval (float) : Intervalle maximal entre les tentatives, en secondes. Par défaut : 300 - retry_max_attempts (int) : Nombre maximal de tentatives. Par défaut : 3 - enable_disk_fallback (bool) : Écrit les éléments abandonnés sur disque. Par défaut : True - use_parallel_table_upload (bool) : Active le téléversement parallèle par fragments pour les grands tableaux. Si False, les tableaux sont téléversés séquentiellement en fragments plus petits.
Default: True - http_timeout (float): Temps d’attente maximal, en secondes, pour l’exécution des requêtes HTTP. Cela inclut le temps de connexion, le transfert des données et le traitement côté serveur. Augmentez cette valeur pour les réseaux lents ou lorsque vous travaillez avec 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écurité de typage, des réessais automatiques et une gestion des erreurs améliorée. Cette fonctionnalité est expérimentale et pourrait devenir la valeur par défaut dans de futures versions.
Default: False - use_calls_complete (bool): Utilise un mode d’écriture optimisé qui regroupe les données d’appel complètes (début et fin) dans une seule requête au lieu de 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 opérations de courte durée.
Default: True - use_otel_v2: (bool): Achemine les intégrations compatibles avec OTel via leur variante OTel.
Default: True
autopatch_settings: (Obsolète) Configuration des intégrations autopatch. Utilisez plutôt un patching explicite.
postprocess_inputs : Une fonction appliquée aux entrées de chaque op dont ce client effectue le traçage.
postprocess_output : Une fonction appliquée au résultat de chaque op tracée par ce client.
attributes : 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

Liez une version publiée d’un prompt au registre. Arguments :

prompt : Un prompt publié, un ObjectRef ou une chaîne URI weave ///... pleinement qualifiée.
target_path : Chemin de destination du registre au format <registry_project>/<portfolio_name>, par exemple wandb-registry-prompts/my-prompt-collection.
aliases : Alias facultatifs à associer à la version du registre créée. Retourne :
LinkAssetToRegistryRes : Réponse analysée du point de terminaison registry-link.

`fonction` `list_aliases`

list_aliases() → list[str]

Répertoriez tous les alias distincts du projet. Retourne : Liste triée de tous les alias du projet.

list_tags() → list[str]

Listez tous les tags distincts du projet. Retourne : Liste triée de tous les tags du projet, sous forme de chaînes de caractères.

`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

Journalisez un appel directement dans Weave sans utiliser le modèle de 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 modèle de 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 pour l’appel. Les opérations anonymes (chaînes ne faisant pas référence à des ops publiées) sont prises en charge.
inputs (dict[str, Any]): Un dictionnaire des paramètres d’entrée de l’opération.
output (Any): La sortie ou le résultat de l’opération.
parent (Appel | None): Appel parent facultatif sous 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 en existe un). La valeur par défaut est None.
attributes (dict[str, Any] | None): Métadonnées facultatives à attacher à l’appel. Elles sont figées une fois l’appel créé. La valeur par défaut est None.
display_name (str | Callable[[Appel], str] | None): Nom d’affichage facultatif pour l’appel dans l’interface utilisateur. Peut être une chaîne ou un callable qui prend l’appel en argument et renvoie une chaîne. La valeur par défaut est None.
use_stack (bool): Indique s’il faut placer l’appel sur la pile d’exécution. Lorsque la valeur est True, l’appel sera disponible dans le contexte d’appel et accessible via weave.require_current_call(). Lorsque la valeur est False, l’appel est enregistré mais n’est pas ajouté à la pile d’appels. La valeur par défaut est True.
exception (BaseException | None): Exception facultative à journaliser si l’opération a échoué. La valeur par défaut est None.

Retourne :

Call: L’objet Appel 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 placer sur la pile d'appels
    ... )

---

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

### <kbd>fonction</kbd> `log_conversation`

```python
log_conversation(
    turns: 'list[Turn]',
    conversation_id: 'str' = '',
    conversation_name: 'str' = '',
    agent_name: 'str' = '',
    model: 'str' = '',
    include_content: 'bool' = True,
    continue_parent_trace: 'bool' = False,
    attributes: 'Attributes' = None
) → LogResult

Journalisez une conversation complète via l’API impérative. L’attribut .spans de chaque tour de conversation fournit ses éléments enfants. Génère automatiquement conversation_id s’il est vide. Par défaut, chaque tour de conversation obtient sa propre trace OTel. agent_name / model sont des valeurs par défaut au niveau de la conversation — la valeur définie sur le Turn lui-même prévaut ; la valeur de la conversation n’est utilisée que si le Turn la laisse vide. Le continue_parent_trace de la conversation s’applique à chaque tour de conversation (un continue_parent_trace défini par Turn est intentionnellement remplacé ici). Les attributes sont apposés sur chaque span émis. Utilisez des clés personnalisées, non semconv : une clé qui entre en conflit avec l’attribut gen_ai.* / weave.* propre à un span n’est pas prise en charge (la valeur qui l’emporte 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 à 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

Émettez de manière impérative un tour de conversation et ses spans enfants vers OTel. À utiliser lorsque les gestionnaires de contexte ne sont pas adaptés (conteneurs sans état, callbacks, workers de file d’attente). Chaque span enfant transmis doit avoir started_at / ended_at défini ; les horodatages des spans OTel émis proviennent de ces champs. À défaut, les horodatages du span enfant le plus ancien et du plus récent sont utilisés, puis now(), lorsque le tour de conversation ne fournit pas les siens. Les champs d’identité de l’agent (agent_id / agent_description / agent_version) reflètent le chemin de streaming. Les attributes sont appliqués à chaque span émis ; le chemin de streaming les lit plutôt à partir de la conversation active. Utilisez des clés personnalisées non semconv : une clé qui entre en collision avec l’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 pour transformer une fonction ou une méthode en op Weave. Compatible avec le synchrone comme avec l’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

Renvoyer 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 exécutées au démarrage qui veulent vérifier que le point de terminaison d’ingestion est accessible avant de s’en remettre au BatchSpanProcessor, qui ignore silencieusement les exports) doivent appeler cette fonction plutôt que de construire l’URL manuellement. Le chemin est géré par le SDK et peut être modifié.

func : La 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 chaîne 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 pour cet op.
accumulator : Fonction qui accumule les résultats pour les ops en flux.
attributes : Attributs par défaut fusionnés dans chaque appel créé par cet op, avec la priorité la plus basse. Un contexte weave.attributes() et des attributs par appel explicites les redéfinissent en cas de collision de clé. La clé réservée “weave” ne peut pas être définie ici.
eager_call_start : Si True, les démarrages d’appel sont envoyés immédiatement au lieu d’être regroupés par lots. Utile pour les opérations de longue durée, comme les évaluations, qui doivent être visibles 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

Enregistrer et versionner un objet Python. Weave crée une nouvelle version de l’objet si son nom existe déjà et que son hachage de contenu ne correspond pas à la dernière version de cet objet.

base_url : URL de base du trace server. 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 publiée de l’objet.
aliases : Liste facultative d’alias à définir sur la version publiée de l’objet. Retourne : Une Ref Weave vers l’objet enregistré.

`fonction` `ref`

ref(location: 'str') → ObjectRef

Crée une Ref vers un objet Weave existant. Cela ne récupère pas directement l’objet, mais vous permet de la transmettre à d’autres fonctions de l’API Weave. Arguments :

emplacement : un URI de Ref Weave ou, si weave.init() a été appelé, name:version ou name. Si aucune version n’est fournie, latest est utilisé. Retourne : une Ref 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

Supprimez les tags d’une version d’objet.

obj_ref : Référence à l’objet, soit un ObjectRef, soit une chaîne d’URI Weave.
alias : Un nom d’alias ou une liste de noms d’alias à supprimer. Arguments :

`fonction` `require_current_call`

require_current_call() → Call

Obtenez l’objet Appel de l’Op en cours d’exécution, au sein de cette Op. Cela vous permet d’accéder aux attributs de l’Appel, comme son ID ou le 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 avez l’ID de l’Appel, par exemple via l’interface utilisateur, vous pouvez utiliser la méthode get_call sur le WeaveClient renvoyé par weave.init pour récupérer l’objet Appel correspondant.

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

Sinon, après avoir défini votre Op, vous pouvez utiliser sa méthode call. 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 chaîne d’URI weave:///.
tags: Liste des tags à supprimer. Retourne : L’objet Appel de l’Op en cours d’exécution

Exceptions levées :

NoCurrentCallError: Si 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

Associez une vue personnalisée au résumé de l’appel en cours dans _weave.views.<name>.

obj_ref: Référence à la version de l’objet, soit un ObjectRef, soit une chaîne d’URI weave:///.
alias: Un nom d’alias ou une liste de noms d’alias à définir (par ex., “production”). Arguments :
name: Le nom de la vue (clé dans summary._weave.views).
content: Une instance de weave.Content ou une chaîne brute. Les chaînes 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 chaîne.
mimetype: Type MIME facultatif à utiliser lorsque content est une chaîne.
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éez et activez une conversation. Définit la contextvar pour permettre un accès entre modules. Les attributes sont ajoutés à chaque span émis par cette conversation (par exemple, une identité d’intégration comme weave.integration.*). Utilisez des clés personnalisées, non semconv : définissez les champs de convention sémantique via les paramètres typés (conversation_name, model, …). Une clé qui entre en collision avec l’attribut gen_ai.* / weave.* propre à un span n’est pas prise en charge ; la valeur retenue dépend du chemin d’exécution (streaming vs 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). Passez explicitement provider_name. Le SDK ne l’infère pas à partir de l’ID du modèle : les déductions basées sur le préfixe attribuent à tort les modèles sur lesquels les utilisateurs ont effectué un fine-tuning (par exemple, un modèle nommé text-...) et intègrent à la télémétrie des hypothèses sur les futurs noms de modèles, qu’il est coûteux de corriger par la suite.

`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 à conversation_id / conversation_name.

`fonction` `start_subagent`

start_subagent(
    name: 'str',
    model: 'str' = '',
    system_instructions: 'list[str] | None' = None
) → SubAgent

Créez un span d’invocation de sous-agent. Le span OTel de SubAgent devient automatiquement enfant du span actuellement actif dans le contexte OTel — généralement un span de tour de conversation s’il y en a un. Sa signature est calquée sur start_tool ; le contexte OTel gère la propagation parent-enfant, sans nécessiter de délégation explicite.

`fonction` `start_tool`

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

Créez 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 tour de conversation s’il est 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 tour de conversation déconnecté qui n’est PAS défini dans la contextvar. Cela signifie que get_current_turn() renverra None. Utilisez plutôt conversation.start_turn() si vous avez besoin d’un accès intermodule basé sur la contextvar.

`fonction` `thread`

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

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

# GÉNÉRER AUTOMATIQUEMENT thread_id
with weave.thread() as t:
     print(f"Thread ID: {t.thread_id}")
     result = my_function("input")  # Cet appel aura 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 aura thread_id="custom_thread"

# Désactiver le threading
with weave.thread(None) as t:
     result = my_function("input")  # Cet appel aura thread_id=None

Arguments :

thread_id : l’identifiant du thread à associer aux appels dans ce contexte. S’il n’est pas fourni, un UUID v7 sera généré automatiquement. Si la valeur est None, le suivi du thread sera désactivé. Renvoie :
ThreadContext : un objet donnant accès à thread_id et à l’turn_id actuel.

`fonction` `wandb_init_hook`

wandb_init_hook() → None

Aperçu

feedback

⌘I

​Aperçu de l’API

​classe Agent

​méthode step

​classe AgentState

​classe AnnotationSpec

​méthode de classe preprocess_field_schema

​méthode de classe validate_field_schema

​méthode value_is_valid

​classe Audio

​méthode __init__

​méthode export

​méthode de classe from_data

​méthode de classe from_path

​classe ClassifierMonitor

​méthode activate

​méthode deactivate

​méthode de classe 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

​méthode de classe from_base64

​méthode de classe from_bytes

​méthode de classe from_data_url

​méthode de classe from_path

​méthode de classe from_text

​méthode de classe from_url

​méthode de classe model_validate

​méthode de classe 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

​méthode de classe convert_to_table

​méthode de classe from_calls

​méthode de classe from_hf

​méthode de classe from_obj

​méthode de classe 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

​espaces réservés de propriété

​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

​méthode de classe from_obj

​méthode de classe load

​méthode de classe 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`

`méthode de classe` `preprocess_field_schema`

`méthode de classe` `validate_field_schema`

`méthode` `value_is_valid`

`classe` `Audio`

`méthode` `init`

`méthode` `export`

`méthode de classe` `from_data`

`méthode de classe` `from_path`

`classe` `ClassifierMonitor`

`méthode` `activate`

`méthode` `deactivate`

`méthode de classe` `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`

`méthode de classe` `from_base64`

`méthode de classe` `from_bytes`

`méthode de classe` `from_data_url`

`méthode de classe` `from_path`

`méthode de classe` `from_text`

`méthode de classe` `from_url`

`méthode de classe` `model_validate`

`méthode de classe` `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`

`méthode de classe` `convert_to_table`

`méthode de classe` `from_calls`

`méthode de classe` `from_hf`

`méthode de classe` `from_obj`

`méthode de classe` `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

espaces réservés de `propriété`

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

`méthode de classe` `from_obj`

`méthode de classe` `load`

`méthode de classe` `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`