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: dict[str, Any]) → dict[str, 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` `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 un objet 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 un objet 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
) → 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
) → 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` `Dataset`

Objet Dataset facile à enregistrer, avec gestion automatique des versions. Exemples :

# Créer un jeu de données
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 jeu de données
weave.publish(dataset)

# Récupérer le jeu de données
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 jeu de données en ajoutant des lignes au jeu de données existant. C’est utile pour ajouter des exemples à de grands jeux de données sans avoir à charger l’intégralité du jeu de données en mémoire. Arguments :

rows: Les lignes à ajouter au jeu de données. Retourne : Le jeu de données 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: Union[ForwardRef('HFDataset'), ForwardRef('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 jeu de données à 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

`classmethod` `from_obj`

from_obj(obj: WeaveObject) → Self

`classmethod` `load`

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

`classmethod` `load_file`

load_file(filepath: str | Path) → Self

`méthode` `messages_table`

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

`méthode` `print`

print() → str

`méthode` `publish`

publish(name: str | None = None) → 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 0x110ab76a0>, json_schema_input_type=PydanticUndefined)]] | None
preprocess_model_input: collections.abc.Callable[[dict], dict] | None
trials: <class 'int'>
metadata: dict[str, typing.Any] | None
evaluation_name: str | collections.abc.Callable[trace.call.Call, str] | None

`méthode` `evaluate`

evaluate(model: Op | Model) → dict

`classmethod` `from_obj`

from_obj(obj: WeaveObject) → Self

`méthode` `get_eval_results`

get_eval_results(model: Op | Model) → EvaluationResults

`méthode` `get_evaluate_calls`

get_evaluate_calls() → PaginatedIterator[CallSchema, WeaveObject]

Récupère tous les appels d’évaluation ayant utilisé cet objet É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 exécutions d’évaluation.

Exceptions levées :

ValueError: Si l’évaluation n’a pas de ref (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 du scorer 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 du scorer. Chaque ID de trace représente un run d’Évaluation, et la liste contient tous les appels du scorer 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 scorers à 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 scorers
- Les valeurs sont des listes de résultats de scorer pour ce run et ce scorer

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 scorer
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(_Evaluation__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 le gestionnaire de contexte pour capturer des opérations imbriquées
with ev.log_prediction(inputs={'q': 'Hello'}) as pred:
     # Toutes les opérations ici (comme les LLM calls) 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 summary. 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 scorers à 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

Enregistre 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 summary dans l’Évaluation. Cela calcule le summary, 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 au résumé 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` `Markdown`

Un objet Markdown affichable.

dest: Chemin de destination vers lequel le fichier sera copié (string or pathlib.Path) Le chemin de destination peut être un fichier ou un répertoire. 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

`class` `MessagesPrompt`

`méthode` `init`

__init__(messages: list[dict])

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

`classmethod` `from_obj`

from_obj(obj: WeaveObject) → Self

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

`class` `Monitor`

Configure un moniteur pour attribuer automatiquement un score aux appels entrants. 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[str]
query: trace_server.interface.query.Query | None
active: <class 'bool'>

`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

`class` `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 (Optional[str]): Nom lisible par l’humain de l’objet.
description (Optional[str]): Description de ce que représente l’objet.
ref (Optional[ObjectRef]): 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.52.24/weave/trace/refs.py#L159" />

## <kbd>class</kbd> `ObjectRef`
ObjectRef(entity: 'str', project: 'str', name: 'str', _digest: 'str | Future[str]', _extra: 'tuple[str | Future[str], ...]' = ()) 

<SourceLink url="https://github.com/wandb/weave/blob/v0.52.24/../../../../weave/trace/refs/__init__" />

### <kbd>method</kbd> `__init__`

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

`propriété` digest

`propriété` extra

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

uri() → str

`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

`class` `Prompt`

Champs Pydantic :

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

`méthode` `format`

format(**kwargs: Any) → Any

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

`méthode de classe` `from_obj`

from_obj(obj: WeaveObject) → Self

`méthode` `model_post_init`

model_post_init(_Scorer__context: Any) → None

`méthode` `score`

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

`méthode` `summarize`

summarize(score_rows: list) → dict | None

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

`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 au niveau des types. 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` `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_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 tracking 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` `init`

init(
    project_name: 'str',
    settings: 'UserSettings | dict[str, Any] | None' = None,
    autopatch_settings: 'AutopatchSettings | 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 : Les paramètres de post-traitement globaux sont appliqués à toutes les ops après le post-traitement propre à chaque op. L’ordre est toujours le suivant : 1. Post-traitement spécifique à l’op 2. Post-traitement global

project_name: Le nom de l’équipe Weights & Biases et du projet dans lequel effectuer la journalisation. 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.
autopatch_settings: (Obsolète) Configuration des intégrations d’autopatch. Utilisez plutôt un patch explicite.
global_postprocess_inputs: Une fonction qui sera appliquée à toutes les entrées de toutes les ops.
global_postprocess_output: Une fonction qui sera appliquée à toutes les sorties de toutes les ops.
global_attributes: Un dictionnaire d’attributs qui sera appliqué à toutes les traces. Retourne : Un client Weave.

`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’UI. 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
    ... )

    Journalisation avec attributs et nom d'affichage :
    >>> 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"
    ... )

    Journalisation d'une opération échouée :
    >>> try:
    ...     result = risky_operation()
    ... except Exception as e:
    ...     call = weave.log_call(
    ...         op="risky_operation",
    ...         inputs={},
    ...         output=None,
    ...         exception=e
    ...     )

    Imbrication d'appels :
    >>> parent_call = weave.log_call("parent", {"input": 1}, 2)
    >>> child_call = weave.log_call(
    ...     "child",
    ...     {"input": 2},
    ...     4,
    ...     parent=parent_call
    ... )

    Journalisation sans ajout à la pile d'appels :
    >>> call = weave.log_call(
    ...     op="background_task",
    ...     inputs={"task_id": 123},
    ...     output="completed",
    ...     use_stack=False  # Ne pas ajouter à la pile d'appels
    ... )

---

<SourceLink url="https://github.com/wandb/weave/blob/v0.52.24/weave/trace/op.py#L1202" />

### <kbd>fonction</kbd> `op`

```python
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
) → 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é.

`fonction` `publish`

publish(obj: 'Any', name: 'str | None' = None) → ObjectRef

Enregistrez et créez une version d’un objet Python. Weave crée une nouvelle version de l’objet si un objet portant ce nom existe déjà et que son empreinte de contenu ne correspond pas à celle de sa dernière version. Arguments :

obj: L’objet à enregistrer et à versionner.
name: Le nom sous lequel enregistrer l’objet. Retourne : Une référence 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` `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’UI, 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)

Retourne : L’objet Appel de l’Op en cours d’exécution Exceptions levées :

NoCurrentCallError: Si tracking n’a pas été initialisé ou si cette méthode est appelée en dehors d’un Op.

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

thread(
    thread_id: 'str | None | object' = <object object at 0x1105c49a0>
) → 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

Premiers pas

Guides

Guides pratiques

Référence

Détails et assistance

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

​classmethod from_obj

​classmethod load

​classmethod load_file

​méthode messages_table

​méthode print

​méthode publish

​méthode require

​méthode run

​méthode validate_requirement

​méthode validate_requirements

​méthode values_table

​class Evaluation

​méthode evaluate

​classmethod from_obj

​méthode get_eval_results

​méthode get_evaluate_calls

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

`classmethod` `from_obj`

`classmethod` `load`

`classmethod` `load_file`

`méthode` `messages_table`

`méthode` `print`

`méthode` `publish`

`méthode` `require`

`méthode` `run`

`méthode` `validate_requirement`

`méthode` `validate_requirements`

`méthode` `values_table`

`class` `Evaluation`

`méthode` `evaluate`

`classmethod` `from_obj`

`méthode` `get_eval_results`

`méthode` `get_evaluate_calls`

`méthode` `get_score_calls`

`méthode` `get_scores`

`méthode` `model_post_init`

`méthode` `predict_and_score`

`méthode` `summarize`