> ## Documentation Index
> Fetch the complete documentation index at: https://wb-21fd5541-run-filter-ui-updates.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
# weave
> Référence du SDK Python pour Weave
export const SourceLink = ({url}) =>
Source
;
# Aperçu de l’API
***
## classe `Agent`
**Champs Pydantic :**
* `name`: `str | None`
* `description`: `str | None`
* `ref`: `trace.refs.ObjectRef | None`
* `model_name`: ``
* `temperature`: ``
* `system_message`: ``
* `tools`: `list[typing.Any]`
### méthode `step`
```python theme={null}
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`: ``
* `op_scope`: `list[str] | None`
### méthode de classe `preprocess_field_schema`
```python theme={null}
preprocess_field_schema(data: dict[str, Any]) → dict[str, Any]
```
***
### méthode de classe `validate_field_schema`
```python theme={null}
validate_field_schema(schema: dict[str, Any]) → dict[str, Any]
```
***
### méthode `value_is_valid`
```python theme={null}
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__`
```python theme={null}
__init__(
data: 'bytes',
format: 'SUPPORTED_FORMATS_TYPE',
validate_base64: 'bool' = True
) → None
```
***
### méthode `export`
```python theme={null}
export(path: 'str | bytes | Path | PathLike') → None
```
Exporte les données audio vers un fichier.
**Arguments :**
***
### méthode de classe `from_data`
```python theme={null}
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`
```python theme={null}
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__`
```python theme={null}
__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`: ``
* `size`: ``
* `mimetype`: ``
* `digest`: ``
* `filename`: ``
* `content_type`: `typing.Literal['bytes', 'text', 'base64', 'file', 'url', 'data_url', 'data_url:base64', 'data_url:encoding', 'data_url:encoding:base64']`
* `input_type`: ``
* `encoding`: ``
* `metadata`: `dict[str, typing.Any] | None`
* `extension`: `str | None`
***
#### propriété art
#### propriété ref
***
### méthode `as_string`
```python theme={null}
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`
```python theme={null}
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`
```python theme={null}
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`
```python theme={null}
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`
```python theme={null}
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`
```python theme={null}
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`
```python theme={null}
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`
```python theme={null}
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`
```python theme={null}
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`
```python theme={null}
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`
```python theme={null}
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`
```python theme={null}
serialize_data(data: 'bytes') → str
```
Lors de la sérialisation du modèle en mode JSON
***
### méthode `to_data_url`
```python theme={null}
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 jeu de données facile à enregistrer, avec gestion automatique des versions.
**Exemples :**
```python theme={null}
# 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`
```python theme={null}
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`
```python theme={null}
convert_to_table(rows: Any) → Table | WeaveTable
```
***
### méthode de classe `from_calls`
```python theme={null}
from_calls(calls: Iterable[Call]) → Self
```
***
### méthode de classe `from_hf`
```python theme={null}
from_hf(
hf_dataset: Union[ForwardRef('HFDataset'), ForwardRef('HFDatasetDict')]
) → Self
```
***
### méthode de classe `from_obj`
```python theme={null}
from_obj(obj: WeaveObject) → Self
```
***
### méthode de classe `from_pandas`
```python theme={null}
from_pandas(df: 'DataFrame') → Self
```
***
### méthode `select`
```python theme={null}
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`
```python theme={null}
to_hf() → HFDataset
```
***
### méthode `to_pandas`
```python theme={null}
to_pandas() → DataFrame
```
***
## classe `EasyPrompt`
### méthode `__init__`
```python theme={null}
__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`: ``
* `config`: ``
* `requirements`: ``
***
#### 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`
```python theme={null}
append(item: Any, role: str | None = None, dedent: bool = False) → None
```
***
### méthode `as_dict`
```python theme={null}
as_dict() → dict[str, Any]
```
***
### méthode `as_pydantic_dict`
```python theme={null}
as_pydantic_dict() → dict[str, Any]
```
***
### méthode `bind`
```python theme={null}
bind(*args: Any, **kwargs: Any) → Prompt
```
***
### méthode `bind_rows`
```python theme={null}
bind_rows(dataset: list[dict] | Any) → list['Prompt']
```
***
### méthode `config_table`
```python theme={null}
config_table(title: str | None = None) → Table
```
***
### méthode `configure`
```python theme={null}
configure(config: dict | None = None, **kwargs: Any) → Prompt
```
***
### méthode `dump`
```python theme={null}
dump(fp: ) → None
```
***
### méthode `dump_file`
```python theme={null}
dump_file(filepath: str | Path) → None
```
***
### méthode `format`
```python theme={null}
format(**kwargs: Any) → Any
```
***
### méthode de classe `from_obj`
```python theme={null}
from_obj(obj: WeaveObject) → Self
```
***
### méthode de classe `load`
```python theme={null}
load(fp: ) → Self
```
***
### méthode de classe `load_file`
```python theme={null}
load_file(filepath: str | Path) → Self
```
***
### méthode `messages_table`
```python theme={null}
messages_table(title: str | None = None) → Table
```
***
### méthode `print`
```python theme={null}
print() → str
```
***
### méthode `publish`
```python theme={null}
publish(
name: str | None = None,
tags: list[str] | None = None,
aliases: list[str] | None = None
) → ObjectRef
```
***
### méthode `require`
```python theme={null}
require(param_name: str, **kwargs: Any) → Prompt
```
***
### méthode `run`
```python theme={null}
run() → Any
```
***
### méthode `validate_requirement`
```python theme={null}
validate_requirement(key: str, value: Any) → list
```
***
### méthode `validate_requirements`
```python theme={null}
validate_requirements(values: dict[str, Any]) → list
```
***
### méthode `values_table`
```python theme={null}
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 :**
```python theme={null}
# 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`: ``
* `scorers`: `list[typing.Annotated[trace.op_protocol.Op | flow.scorer.Scorer, BeforeValidator(func=, json_schema_input_type=PydanticUndefined)]] | None`
* `preprocess_model_input`: `collections.abc.Callable[[dict], dict] | None`
* `trials`: ``
* `metadata`: `dict[str, typing.Any] | None`
* `evaluation_name`: `str | collections.abc.Callable[trace.call.Call, str] | None`
### méthode `evaluate`
```python theme={null}
evaluate(model: Op | Model) → dict
```
***
### méthode de classe `from_obj`
```python theme={null}
from_obj(obj: WeaveObject) → Self
```
***
### méthode `get_eval_results`
```python theme={null}
get_eval_results(model: Op | Model) → EvaluationResults
```
***
### méthode `get_evaluate_calls`
```python theme={null}
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 ref (elle n’a pas encore été enregistrée/exécutée).
**Exemples :**
```python theme={null}
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`
```python theme={null}
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 :**
```python theme={null}
evaluation = Evaluation(dataset=examples, scorers=[accuracy_scorer, f1_scorer])
await evaluation.evaluate(model)
score_calls = evaluation.get_score_calls()
for trace_id, calls in score_calls.items():
print(f"Trace {trace_id}: {len(calls)} scorer calls")
for call in calls:
scorer_name = call.summary.get("weave", {}).get("trace_name")
print(f" Scorer: {scorer_name}, Output: {call.output}")
```
***
### méthode `get_scores`
```python theme={null}
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 :**
```python theme={null}
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`
```python theme={null}
model_post_init(_Evaluation__context: Any) → None
```
***
### méthode `predict_and_score`
```python theme={null}
predict_and_score(model: Op | Model, example: dict) → dict
```
***
### méthode `summarize`
```python theme={null}
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 :
```python theme={null}
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 :
```python theme={null}
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__`
```python theme={null}
__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`
```python theme={null}
fail(exception: 'BaseException') → None
```
Méthode utilitaire qui fait échouer l’Évaluation en levant une exception.
***
### méthode `finish`
```python theme={null}
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`
```python theme={null}
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 :**
```python theme={null}
ev = EvaluationLogger()
ev.log_example(
inputs={'q': 'What is 2+2?'},
output='4',
scores={'correctness': 1.0, 'fluency': 0.9}
)
```
***
### méthode `log_prediction`
```python theme={null}
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`
```python theme={null}
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`
```python theme={null}
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.` 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__`
```python theme={null}
__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`
```python theme={null}
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`
```python theme={null}
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/](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__`
```python theme={null}
__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__`
```python theme={null}
__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`
```python theme={null}
format(**kwargs: Any) → list
```
***
### méthode `format_message`
```python theme={null}
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`
```python theme={null}
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 :**
```python theme={null}
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`
```python theme={null}
get_infer_method() → Callable
```
***
## class `Monitor`
Configure un moniteur pour attribuer automatiquement un score aux appels entrants.
**Exemples :**
```python theme={null}
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`: ``
* `scorers`: `list[flow.scorer.Scorer]`
* `op_names`: `list[str]`
* `query`: `trace_server.interface.query.Query | None`
* `is_traced`: ``
* `active`: ``
* `scorer_debounce_config`: `flow.monitor.ScorerDebounceConfig | None`
### méthode `activate`
```python theme={null}
activate() → ObjectRef
```
Active le moniteur.
**Retourne :**
Une référence au moniteur.
***
### méthode `deactivate`
```python theme={null}
deactivate() → ObjectRef
```
Désactive le moniteur.
**Retourne :**
Une référence au moniteur.
***
### méthode de classe `from_obj`
```python theme={null}
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 :**
```python theme={null}
# 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`
```python theme={null}
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 :**
```python theme={null}
obj = MyObject.from_uri("weave:///entity/project/object:digest")
```
***
### méthode de classe `handle_relocatable_object`
```python theme={null}
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)
````
---
## class `ObjectRef`
ObjectRef(entity: 'str', project: 'str', name: 'str', _digest: 'str | Future[str]', _extra: 'tuple[str | Future[str], ...]' = ())
### méthode `__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`
```python theme={null}
as_param_dict() → dict
```
***
### méthode `delete`
```python theme={null}
delete() → None
```
***
### méthode `get`
```python theme={null}
get(objectify: 'bool' = True) → Any
```
***
### méthode `is_descended_from`
```python theme={null}
is_descended_from(potential_ancestor: 'ObjectRef') → bool
```
***
### méthode `maybe_parse_uri`
```python theme={null}
maybe_parse_uri(s: 'str') → AnyRef | None
```
***
### méthode `parse_uri`
```python theme={null}
parse_uri(uri: 'str') → ObjectRef
```
***
### méthode `with_attr`
```python theme={null}
with_attr(attr: 'str') → Self
```
***
### méthode `with_extra`
```python theme={null}
with_extra(extra: 'tuple[str | Future[str], ]') → Self
```
***
### méthode `with_index`
```python theme={null}
with_index(index: 'int') → Self
```
***
### méthode `with_item`
```python theme={null}
with_item(item_digest: 'str | Future[str]') → Self
```
***
### méthode `with_key`
```python theme={null}
with_key(key: 'str') → Self
```
***
## class `Prompt`
**Champs Pydantic :**
* `name`: `str | None`
* `description`: `str | None`
* `ref`: `trace.refs.ObjectRef | None`
### méthode `format`
```python theme={null}
format(**kwargs: Any) → Any
```
***
## class `SavedView`
Une classe à l’API fluide permettant de manipuler des objets SavedView.
### méthode `__init__`
```python theme={null}
__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`
```python theme={null}
add_column(path: 'str | ObjectPath', label: 'str | None' = None) → SavedView
```
***
### méthode `add_columns`
```python theme={null}
add_columns(*columns: 'str') → SavedView
```
Méthode utilitaire pour ajouter plusieurs colonnes à la grille.
***
### méthode `add_filter`
```python theme={null}
add_filter(
field: 'str',
operator: 'str',
value: 'Any | None' = None
) → SavedView
```
***
### méthode `add_sort`
```python theme={null}
add_sort(field: 'str', direction: 'SortDirection') → SavedView
```
***
### méthode `column_index`
```python theme={null}
column_index(path: 'int | str | ObjectPath') → int
```
***
### méthode `filter_op`
```python theme={null}
filter_op(op_name: 'str | None') → SavedView
```
***
### méthode `get_calls`
```python theme={null}
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`
```python theme={null}
get_known_columns(num_calls_to_query: 'int | None' = None) → list[str]
```
Obtenir l’ensemble des colonnes connues.
***
### méthode `get_table_columns`
```python theme={null}
get_table_columns() → list[TableColumn]
```
***
### méthode `hide_column`
```python theme={null}
hide_column(col_name: 'str') → SavedView
```
***
### méthode `insert_column`
```python theme={null}
insert_column(
idx: 'int',
path: 'str | ObjectPath',
label: 'str | None' = None
) → SavedView
```
***
### méthode de classe `load`
```python theme={null}
load(ref: 'str') → Self
```
***
### méthode `page_size`
```python theme={null}
page_size(page_size: 'int') → SavedView
```
***
### méthode `pin_column_left`
```python theme={null}
pin_column_left(col_name: 'str') → SavedView
```
***
### méthode `pin_column_right`
```python theme={null}
pin_column_right(col_name: 'str') → SavedView
```
***
### méthode `remove_column`
```python theme={null}
remove_column(path: 'int | str | ObjectPath') → SavedView
```
***
### méthode `remove_columns`
```python theme={null}
remove_columns(*columns: 'str') → SavedView
```
Supprime des colonnes de la vue enregistrée.
***
### méthode `remove_filter`
```python theme={null}
remove_filter(index_or_field: 'int | str') → SavedView
```
***
### méthode `remove_filters`
```python theme={null}
remove_filters() → SavedView
```
Supprime tous les filtres de la vue enregistrée.
***
### méthode `rename`
```python theme={null}
rename(label: 'str') → SavedView
```
***
### méthode `rename_column`
```python theme={null}
rename_column(path: 'int | str | ObjectPath', label: 'str') → SavedView
```
***
### méthode `save`
```python theme={null}
save() → SavedView
```
Publier la vue enregistrée sur le serveur.
***
### méthode `set_columns`
```python theme={null}
set_columns(*columns: 'str') → SavedView
```
Définissez les colonnes à afficher dans la grille.
***
### méthode `show_column`
```python theme={null}
show_column(col_name: 'str') → SavedView
```
***
### méthode `sort_by`
```python theme={null}
sort_by(field: 'str', direction: 'SortDirection') → SavedView
```
***
### méthode `to_grid`
```python theme={null}
to_grid(limit: 'int | None' = None) → Grid
```
***
### méthode `to_rich_table_str`
```python theme={null}
to_rich_table_str() → str
```
***
### méthode `ui_url`
```python theme={null}
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`
```python theme={null}
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`
```python theme={null}
from_obj(obj: WeaveObject) → Self
```
***
### méthode `model_post_init`
```python theme={null}
model_post_init(_Scorer__context: Any) → None
```
***
### méthode `score`
```python theme={null}
score(output: Any, **kwargs: Any) → Any
```
***
### méthode `summarize`
```python theme={null}
summarize(score_rows: list) → dict | None
```
***
## classe `StringPrompt`
### méthode `__init__`
```python theme={null}
__init__(content: str)
```
**Champs Pydantic :**
* `name`: `str | None`
* `description`: `str | None`
* `ref`: `trace.refs.ObjectRef | None`
* `content`: ``
### méthode `format`
```python theme={null}
format(**kwargs: Any) → str
```
***
### méthode de classe `from_obj`
```python theme={null}
from_obj(obj: WeaveObject) → Self
```
***
## classe `Table`
### méthode `__init__`
```python theme={null}
__init__(rows: 'list[dict]') → None
```
***
#### propriété rows
***
### méthode `append`
```python theme={null}
append(row: 'dict') → None
```
Ajoutez une ligne au tableau.
***
### méthode `pop`
```python theme={null}
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 :
```python theme={null}
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__`
```python theme={null}
__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`
```python theme={null}
run() → None
```
***
## classe `ThreadContext`
Objet de contexte donnant accès aux informations sur le thread et le tour en cours.
### méthode `__init__`
```python theme={null}
__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 :
```python theme={null}
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__`
```python theme={null}
__init__(*args: 'Any', **kwargs: 'Any') → None
```
***
### méthode `map`
```python theme={null}
map(
fn: 'Callable',
*iterables: 'Iterable[Any]',
timeout: 'float | None' = None,
chunksize: 'int' = 1
) → Iterator
```
***
### méthode `submit`
```python theme={null}
submit(fn: 'Callable', *args: 'Any', **kwargs: 'Any') → Any
```
***
### fonction `add_tags`
```python theme={null}
add_tags(obj_ref: 'ObjectRef | str', tags: 'list[str]') → None
```
Ajoutez des tags à une version d’objet.
**Arguments :**
***
### fonction `as_op`
```python theme={null}
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`
```python theme={null}
attributes(attributes: 'dict[str, Any]') → Iterator
```
Gestionnaire de contexte permettant de définir des attributs pour un appel.
**Exemple :**
```python theme={null}
with weave.attributes({'env': 'production'}):
print(my_function.call("World"))
```
***
### fonction `finish`
```python theme={null}
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`
```python theme={null}
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 :**
```python theme={null}
weave.init("weave_get_example")
dataset = weave.Dataset(rows=[{"a": 1, "b": 2}])
ref = weave.publish(dataset)
dataset2 = weave.get(ref) # identique à dataset !
```
***
### fonction `get_aliases`
```python theme={null}
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`
```python theme={null}
get_client() → WeaveClient | None
```
***
### fonction `get_current_call`
```python theme={null}
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_tags`
```python theme={null}
get_tags(obj_ref: 'ObjectRef | str') → list[str]
```
Obtenir les tags d’une version d’objet.
**Arguments :**
* `obj_ref` : Référence à la version de l’objet, soit un `ObjectRef`, soit une chaîne URI `weave:///`.
**Retourne :**
Liste de chaînes de tags.
***
### fonction `get_tags_and_aliases`
```python theme={null}
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`
```python theme={null}
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](https://docs.wandb.ai/guides/models/app/settings-page/user-settings/#default-team) 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 `list_aliases`
```python theme={null}
list_aliases() → list[str]
```
Répertoriez tous les alias distincts du projet.
**Retourne :**
Liste triée de tous les alias du projet.
***
### fonction `list_tags`
```python theme={null}
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`
```python theme={null}
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 :
````python theme={null}
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
... )
---
### fonction `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,
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 `publish`
```python theme={null}
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.
* `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.
* `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 :**
* `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`
```python theme={null}
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`
```python theme={null}
remove_aliases(obj_ref: 'ObjectRef | str', alias: 'str | list[str]') → None
```
Supprime un ou plusieurs alias d’un objet.
**Arguments :**
***
### fonction `remove_tags`
```python theme={null}
remove_tags(obj_ref: 'ObjectRef | str', tags: 'list[str]') → None
```
Supprimez les tags d’une version d’objet.
* `obj_ref` : Référence à l’objet, soit un ObjectRef, soit une chaîne d’URI Weave.
* `alias` : Un nom d’alias ou une liste de noms d’alias à supprimer.
**Arguments :**
***
### fonction `require_current_call`
```python theme={null}
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.
```python theme={null}
@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.
```python theme={null}
client = weave.init("")
mycall = client.get_call("")
```
Sinon, après avoir défini votre Op, vous pouvez utiliser sa méthode `call`. Par exemple :
```python theme={null}
@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`
```python theme={null}
set_aliases(obj_ref: 'ObjectRef | str', alias: 'str | list[str]') → None
```
Définit un ou plusieurs alias pour une version d’objet.
**Arguments :**
***
### fonction `set_view`
```python theme={null}
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.`.
* `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 `thread`
```python theme={null}
thread(
thread_id: 'str | None | object' =