> ## Documentation Index > Fetch the complete documentation index at: https://wb-21fd5541-dependabot-github-actions-actions-cache-6.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 `ClassifierMonitor` Un moniteur qui fusionne plusieurs évaluateurs en un seul classificateur. Les moniteurs de classificateur combinent les prompts de plusieurs LLMAsAJudgeScorers ciblant le même modèle en un seul appel d'évaluation. **Champs Pydantic :** * `name`: `str | None` * `description`: `str | None` * `ref`: `trace.refs.ObjectRef | None` * `sampling_rate`: `` * `scorers`: `list[flow.scorer.Scorer]` * `op_names`: `list[typing.Union[typing.Literal['genai.turn_ended'], str]]` * `query`: `trace_server.interface.query.Query | None` * `is_traced`: `` * `active`: `` * `scorer_debounce_config`: `flow.monitor.ScorerDebounceConfig | None` * `prompt_header`: `str | None` * `prompt_footer`: `str | None` ### méthode `activate` ```python theme={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 ``` *** ### méthode `get_prompt_footer` ```python theme={null} get_prompt_footer() → str ``` Texte à ajouter après les prompts du classifieur fusionné. *** ### méthode `get_prompt_header` ```python theme={null} get_prompt_header(op_name: str) → str ``` Texte à ajouter avant les prompts fusionnés du classificateur. *** ## 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 dataset 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 dataset en ajoutant des lignes au dataset existant. C’est utile pour ajouter des exemples à de grands datasets sans avoir à charger l’intégralité du dataset en mémoire. **Arguments :** * `rows`: Les lignes à ajouter au dataset. **Retourne :** Le dataset mis à jour. *** ### méthode de classe `convert_to_table` ```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: 'HFDataset | 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 dataset à partir des indices fournis. **Arguments :** * `indices` : Un itérable d’indices entiers indiquant quelles lignes sélectionner. **Retourne :** Un nouvel objet Dataset contenant uniquement les lignes sélectionnées. *** ### méthode `to_hf` ```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 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 :** ```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(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 synthèse. Garantit que tous les appels de prédiction ainsi que l’appel d’évaluation principal sont finalisés. Cette méthode est appelée automatiquement si le logger est utilisé comme gestionnaire de contexte. *** ### méthode `log_example` ```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 évaluateurs à 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 ``` Journalise une prédiction dans l’Évaluation. Retourne un ScoreLogger qui peut être utilisé directement ou comme gestionnaire de contexte. **Arguments :** * `inputs`: Les données d’entrée de la prédiction * `output`: La valeur de sortie. La valeur par défaut est None. Peut être définie plus tard avec pred.output. **Retourne :** ScoreLogger pour journaliser les scores et, éventuellement, finaliser la prédiction. Exemple (direct) : * `pred = ev.log_prediction({'q'`: '...'}, output="answer") pred.log\_score("correctness", 0.9) pred.finish() Exemple (gestionnaire de contexte) : * `with ev.log_prediction({'q'`: '...'}) as pred: response = model(...) pred.output = response pred.log\_score("correctness", 0.9) # Appelle automatiquement finish() à la sortie *** ### méthode `log_summary` ```python theme={null} log_summary(summary: 'dict | None' = None, auto_summarize: 'bool' = True) → None ``` Enregistre un dict de synthèse dans l’Évaluation. Cela calcule la synthèse, appelle l’op summarize, puis clôt l’évaluation, ce qui signifie qu’il n’est plus possible d’enregistrer de prédictions ni de scores. *** ### méthode `set_view` ```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 à la synthèse de l’appel principal de l’évaluation sous `weave.views`. Enregistre le contenu fourni comme objet dans le projet et inscrit son URI de référence sous `summary.weave.views.` 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 `LLM` Un appel d’API à un LLM. Correspond à un span OTel de chat. * `dest`: chemin de destination vers lequel le fichier sera copié (`string` ou `pathlib.Path`) Le chemin de destination peut être un fichier ou un répertoire. **Champs Pydantic :** * `model`: `` * `provider_name`: `` * `response_id`: `` * `response_model`: `` * `output_type`: `` * `system_instructions`: `list[str]` * `usage`: `` * `reasoning`: `` * `finish_reasons`: `list[str]` * `input_messages`: `list[session.types.Message]` * `output_messages`: `list[session.types.Message]` * `media_attachments`: `list[session.types.MediaAttachment]` * `request_temperature`: `float | None` * `request_max_tokens`: `int | None` * `request_top_p`: `float | None` * `request_frequency_penalty`: `float | None` * `request_presence_penalty`: `float | None` * `request_seed`: `int | None` * `request_stop_sequences`: `list[str]` * `request_choice_count`: `int | None` * `started_at`: `datetime.datetime | None` * `ended_at`: `datetime.datetime | None` ### méthode `attach_media` ```python theme={null} attach_media( content: 'bytes | str' = '', uri: 'str' = '', file_id: 'str' = '', mime_type: 'str' = '', modality: 'str' = '' ) → LLM ``` Ajoutez un média à cet appel LLM. Vous devez fournir exactement un seul des paramètres content, uri ou file\_id. La modalité est déduite de mime\_type lorsqu’elle n’est pas explicitement définie. *** ### méthode `attach_media_url` ```python theme={null} attach_media_url(url: 'str', modality: 'str' = '') → LLM ``` Associez une URL de média à cet appel LLM. Méthode pratique par rapport à `attach_media` pour le cas courant où l’appelant dispose d’une chaîne URL provenant d’un message en amont et ne veut pas l’inspecter. Les URL `data:` sont analysées en `mime_type` + contenu en ligne (kind=blob) ; les URI simples deviennent `kind=uri`. Les URL vides sont ignorées. Renvoie `self` pour permettre le chaînage. *** ### méthode `end` ```python theme={null} end() → None ``` *** ### méthode `model_post_init` ```python theme={null} model_post_init(context: 'Any') → None ``` *** ### méthode `output` ```python theme={null} output(content: 'str') → LLM ``` Ajouter un message d’assistant à output\_messages. *** ### méthode `record` ```python theme={null} record( input_messages: 'list[Message] | None' = None, output_messages: 'list[Message] | None' = None, media_attachments: 'list[MediaAttachment] | None' = None, usage: 'Usage | None' = None, reasoning: 'Reasoning | str | None' = None, response_id: 'str | None' = None, response_model: 'str | None' = None, finish_reasons: 'list[str] | None' = None, output_type: 'str | None' = None ) → LLM ``` Définissez plusieurs champs d’un appel LLM en un seul appel. Les agents instrumentés manuellement construisent généralement un span de chat en renseignant huit champs distincts ou plus à la fin d’un appel LLM (`input_messages`, `output_messages`, `usage`, `response_id`, etc.). `record(...)` les regroupe en un seul appel avec arguments nommés afin de garder un point d’enregistrement compact. Seuls les champs explicitement transmis (non-`None`) sont appliqués — les valeurs existantes sont conservées. `reasoning` accepte soit une instance de `Reasoning`, soit une simple chaîne de caractères (encapsulée automatiquement). Renvoie `self` pour le chaînage. *** ### méthode `think` ```python theme={null} think(content: 'str') → LLM ``` Définit le contenu de raisonnement/de chaîne de pensée. *** ## classe `LogResult` Résultat d’un appel `log_*` batch. **Champs Pydantic :** * `session_id`: `` * `trace_ids`: `list[str]` * `root_span_ids`: `list[str]` * `span_count`: `` *** ## classe `Markdown` Un objet Markdown affichable. **Arguments :** * `markup` (str): Une chaîne contenant du Markdown. * `code_theme` (str, facultatif): Thème Pygments pour les blocs de code. La valeur par défaut est "monokai". Voir [https://pygments.org/styles/](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 ``` *** ## classe `MediaAttachment` Une pièce jointe multimédia dans un appel LLM. * `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 :** * `kind`: `typing.Literal['blob', 'uri', 'file']` * `modality`: `` * `mime_type`: `` * `content`: `bytes | str` * `uri`: `` * `file_id`: `` *** ## classe `Message` Un message dans une conversation. Deux styles de construction sont pris en charge : 1. À plat (rétrocompatibilité, pratique pour le texte brut) : `Message(role="assistant", content="Hi there")` 2. Avec parties explicites (plus riche — prend en charge les appels d’outil, le raisonnement et le texte combinés, ainsi que les médias intégrés) : `Message(role="assistant", parts=[TextPart(content="Let me check"), ToolCallPart(id="c1", name="get_weather", arguments='{...}')])` Lorsque `parts` n’est pas vide, il s’agit de la représentation canonique. Lorsqu’il est vide, le sérialiseur synthétise un unique TextPart (ou ToolCallResponsePart pour `role="tool"`) à partir des champs à plat. **Champs Pydantic :** * `role`: `typing.Literal['user', 'assistant', 'system', 'tool']` * `content`: `` * `tool_call_id`: `` * `tool_name`: `` * `parts`: `list[typing.Annotated[session.types.TextPart | session.types.ReasoningPart | session.types.ToolCallPart | session.types.ToolCallResponsePart | session.types.BlobPart | session.types.UriPart | session.types.FilePart, FieldInfo(annotation=NoneType, required=True, discriminator='type')]]` ### méthode de classe `assistant` ```python theme={null} assistant( text: 'str' = '', tool_calls: 'list[ToolCallPart] | None' = None ) → Message ``` Créez un message d’assistant avec un texte facultatif et des appels d’outil. Utilisez du texte brut pour les réponses simples ; transmettez `tool_calls` lorsque l’assistant demande un ou plusieurs outils. Lorsque les deux sont présents, le texte est émis sous la forme d’un `TextPart` initial, suivi de chaque `ToolCallPart`, afin que la vue de conversation les affiche en ligne. *** ### méthode de classe `system` ```python theme={null} system(text: 'str') → Message ``` Créez un message système à partir de texte brut. *** ### méthode de classe `tool_result` ```python theme={null} tool_result(call_id: 'str', output: 'Any') → Message ``` Créez un message de résultat pour un appel d’outil demandé précédemment. `output` peut être une chaîne, un dictionnaire, une liste, une valeur scalaire ou `None` — le `ToolCallResponsePart` sous-jacent encode en JSON les valeurs qui ne sont pas des chaînes. *** ### méthode de classe `user` ```python theme={null} user(text: 'str') → Message ``` Crée un message utilisateur à partir de texte brut. *** ## classe `MessagesPrompt` ### méthode `__init__` ```python theme={null} __init__(messages: list[dict]) ``` **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 ``` *** ## classe `Model` Conçue pour représenter une combinaison de code et de données qui opère sur une entrée. Par exemple, elle peut appeler un LLM avec un prompt pour faire une prédiction ou générer du texte. Lorsque vous modifiez les attributs ou le code qui définissent votre modèle, ces changements seront enregistrés et la version sera mise à jour. Cela vous permet de comparer les prédictions entre différentes versions de votre modèle. Utilisez cette classe pour itérer sur les prompts ou essayer le dernier LLM, puis comparer les prédictions dans différentes configurations. **Exemples :** ```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 ``` *** ## classe `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[typing.Union[typing.Literal['genai.turn_ended'], str]]` * `query`: `trace_server.interface.query.Query | None` * `is_traced`: `` * `active`: `` * `scorer_debounce_config`: `flow.monitor.ScorerDebounceConfig | None` ### 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 ``` *** ## classe `Object` Classe de base pour les objets de Weave qui peuvent être suivis et versionnés. Cette classe étend le `BaseModel` de Pydantic afin de fournir des fonctionnalités propres à Weave pour le suivi des objets, leur référencement et leur sérialisation. Les objets peuvent avoir des noms, des descriptions et des références, ce qui permet de les stocker dans le système Weave et de les en récupérer. **Attributs :** * `name` (str | None): Nom lisible par l’humain de l’objet. * `description` (str | None): Description de ce que représente l’objet. * `ref` (ObjectRef | None): Référence à l’objet dans le système Weave. **Exemples :** ```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) ```` --- ### classmethod `strip_weave_serialization_metadata` ```python strip_weave_serialization_metadata(data: Any) → Any ```` Supprimez des entrées de dictionnaire les métadonnées de sérialisation de Weave. La sérialisation de Weave ajoute \_type, \_class\_name et \_bases aux dictionnaires pour reconstruire le type. Il ne s’agit pas de véritables champs du modèle et ils doivent être supprimés avant la validation Pydantic, qui utilise extra="forbid". *** ## classe `ObjectRef` ObjectRef(entity: 'str', project: 'str', name: 'str', \_digest: 'str | Future\[str]', \_extra: 'tuple\[str | Future\[str], ...]' = ()) ### méthode `__init__` ```python theme={null} __init__( entity: 'str', project: 'str', name: 'str', _digest: 'str | Future[str]', _extra: 'tuple[str | Future[str], ]' = () ) → None ``` *** #### propriété digest *** #### propriété extra *** #### propriété is\_digest\_resolved *** ### méthode `as_param_dict` ```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 ``` *** ## classe `Prompt` **Champs Pydantic :** * `name`: `str | None` * `description`: `str | None` * `ref`: `trace.refs.ObjectRef | None` ### méthode `format` ```python theme={null} format(**kwargs: Any) → Any ``` *** ## classe `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(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 `Session` Une session de conversation. Regroupe les tours de conversation par conversation\_id (sans span). `continue_parent_trace` contrôle l’isolation des traces pour les tours de conversation créés par cette session. La valeur par défaut `False` signifie que chaque tour de conversation démarre sa propre trace OTel (le bon choix pour la vue autonome de l’onglet Agents). Définissez `True` lorsque l’application a une trace englobante (par exemple, une requête FastAPI instrumentée) qui doit contenir l’invocation de l’agent. **Champs Pydantic :** * `session_id`: `` * `session_name`: `` * `agent_name`: `` * `model`: `` * `include_content`: `` * `continue_parent_trace`: `` ### méthode `end` ```python theme={null} end() → None ``` *** ### méthode `model_post_init` ```python theme={null} model_post_init(context: 'Any') → None ``` *** ### méthode `start_turn` ```python theme={null} start_turn( user_message: 'str' = '', model: 'str' = '', agent_name: 'str' = '' ) → Turn ``` Créer un nouveau tour de conversation. Termine automatiquement le tour de conversation précédent s’il est toujours ouvert. Définit la variable de contexte `_current_turn` afin que le tour de conversation soit accessible via `get_current_turn()`, qu’un gestionnaire de contexte soit utilisé ou non. Propage `continue_parent_trace` à partir de cette session. *** ## 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 `SubAgent` Un appel d’agent délégué au sein d’un tour de conversation. Correspond à un `span` OTel imbriqué `invoke_agent` dans la même trace. **champs Pydantic :** * `name`: `` * `model`: `` * `agent_id`: `` * `agent_description`: `` * `agent_version`: `` * `started_at`: `datetime.datetime | None` * `ended_at`: `datetime.datetime | None` ### méthode `end` ```python theme={null} end() → None ``` *** ### méthode `llm` ```python theme={null} llm( model: 'str' = '', provider_name: 'str' = '', system_instructions: 'list[str] | None' = None ) → LLM ``` Démarrer un appel de LLM dans ce sous-agent. Définit la variable de contexte `_current_llm` afin que le LLM soit accessible via `get_current_llm()`, qu’un gestionnaire de contexte soit utilisé ou non. *** ### méthode `tool` ```python theme={null} tool(name: 'str', arguments: 'str' = '', tool_call_id: 'str' = '') → Tool ``` Lancez l’exécution d’un outil dans ce sous-agent. *** ## classe `Table` ### méthode `__init__` ```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 de conversation 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 ``` *** ## classe `Tool` Une exécution d’outil. Correspond au span OTel `execute_tool`. `arguments` et `result` utilisent l’annotation `JSONString` : le code appelant peut attribuer un dict / une liste / un scalaire, et le SDK l’encode en JSON lors de l’instanciation ou de l’attribution. La valeur stockée est toujours une chaîne, conformément au format de transmission défini par la semconv GenAI. **Champs Pydantic :** * `name`: `` * `arguments`: `` * `result`: `` * `tool_call_id`: `` * `tool_type`: `` * `tool_description`: `` * `tool_definitions`: `` * `duration_ms`: `` * `started_at`: `datetime.datetime | None` * `ended_at`: `datetime.datetime | None` ### méthode `end` ```python theme={null} end() → None ``` *** ## classe `Turn` Un échange entre un utilisateur et un agent. Correspond à un span OTel `invoke_agent`. Par défaut, chaque tour de conversation démarre sa propre trace OTel (`continue_parent_trace=False`), de sorte que l’onglet Agents affiche une trace par tour de conversation. Définissez `continue_parent_trace=True` sur la Session (ou directement sur le Turn) lorsqu’une trace parente externe est déjà active et que vous souhaitez y imbriquer l’invocation de l’agent — par exemple, dans une requête FastAPI instrumentée. **Champs Pydantic :** * `agent_name`: `` * `model`: `` * `agent_id`: `` * `agent_description`: `` * `agent_version`: `` * `messages`: `list[session.types.Message]` * `spans`: `list[session.session.LLM | session.session.Tool | session.session.SubAgent]` * `continue_parent_trace`: `` * `started_at`: `datetime.datetime | None` * `ended_at`: `datetime.datetime | None` ### méthode `end` ```python theme={null} end() → None ``` *** ### méthode `llm` ```python theme={null} llm( model: 'str' = '', provider_name: 'str' = '', system_instructions: 'list[str] | None' = None ) → LLM ``` Démarre un appel LLM (span de chat, enfant de ce tour de conversation). Définit le contextvar `_current_llm` pour que le LLM soit accessible via `get_current_llm()`, qu’un gestionnaire de contexte soit utilisé ou non. *** ### méthode `model_post_init` ```python theme={null} model_post_init(context: 'Any') → None ``` *** ### méthode `subagent` ```python theme={null} subagent(name: 'str', model: 'str' = '') → SubAgent ``` Démarre un appel à un sous-agent (span `invoke_agent` imbriqué, dans la même trace). *** ### méthode `tool` ```python theme={null} tool(name: 'str', arguments: 'str' = '', tool_call_id: 'str' = '') → Tool ``` Lance l’exécution d’un outil (span execute\_tool, enfant de ce tour de conversation). *** ### méthode `user` ```python theme={null} user(content: 'str') → Turn ``` Ajoutez un message utilisateur au milieu d’un tour de conversation. *** ## classe `Utilisation` Utilisation des jetons pour un appel LLM. **champs Pydantic :** * `input_tokens`: `` * `output_tokens`: `` * `reasoning_tokens`: `` * `cache_creation_input_tokens`: `` * `cache_read_input_tokens`: `` *** ### 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 `end_llm` ```python theme={null} end_llm() → None ``` Termine l’appel LLM en cours (via contextvar). *** ### fonction `end_session` ```python theme={null} end_session() → None ``` Terminez la session actuelle (depuis contextvar). *** ### fonction `end_turn` ```python theme={null} end_turn() → None ``` Terminez le tour de conversation actuel (depuis contextvar). *** ### 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_current_llm` ```python theme={null} get_current_llm() → LLM | None ``` Renvoyer l’appel LLM actif depuis `contextvar`, ou None. *** ### fonction `get_current_session` ```python theme={null} get_current_session() → Session | None ``` Renvoyer la session active stockée dans contextvar, ou None. *** ### fonction `get_current_turn` ```python theme={null} get_current_turn() → Turn | None ``` Renvoyer le tour de conversation actif à partir de contextvar, ou None. *** ### 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, postprocess_inputs: 'PostprocessInputsFunc | None' = None, postprocess_output: 'PostprocessOutputFunc | None' = None, attributes: 'dict[str, Any] | None' = None, global_postprocess_inputs: 'PostprocessInputsFunc | None' = None, global_postprocess_output: 'PostprocessOutputFunc | None' = None, global_attributes: 'dict[str, Any] | None' = None ) → WeaveClient ``` Initialisez le suivi Weave avec journalisation dans un projet wandb. La journalisation est initialisée globalement, vous n’avez donc pas besoin de conserver une référence à la valeur de retour de init. Après init, les appels aux fonctions décorées avec weave.op seront enregistrés dans le projet spécifié. **Arguments :** REMARQUE : Le post-traitement au niveau du client s’exécute après le post-traitement propre à chaque op. L’ordre est toujours le suivant : 1. Post-traitement spécifique à l’op 2. Post-traitement au niveau du client * `project_name` : Le nom de l’équipe Weights & Biases et du projet dans lesquels enregistrer les journaux. Si vous ne spécifiez pas d’équipe, votre entité par défaut est utilisée. Pour trouver ou mettre à jour votre entité par défaut, référez-vous à [Paramètres utilisateur](https://docs.wandb.ai/platform/app/settings-page/user-settings#default-team) dans la documentation W\&B Models. * `settings` : Configuration générale du client Weave. Peut être une instance de UserSettings ou un dictionnaire contenant l’une des clés suivantes (toutes facultatives). Tous les paramètres peuvent également être configurés via des variables d’environnement à l’aide du préfixe WEAVE\_ (par exemple, WEAVE\_DISABLED=true). Paramètres disponibles : - `disabled` (bool) : Désactive les traces sur toutes les fonctions. Par défaut : `False` - `print_call_link` (bool) : Affiche dans le terminal des liens vers l’interface Weave pour les opérations. Par défaut : `True` - `log_level` (str) : Définit le type d’informations à journaliser (`DEBUG`, `INFO`, `WARNING`, `ERROR`, `CRITICAL`). Par défaut : `INFO` - `display_viewer` (str) : Contrôle la manière dont Weave affiche les objets dans la console (`auto`, `rich`, `print`). Par défaut : `auto` - `capture_code` (bool) : Capture le code des opérations tracées dans votre projet Weave. Par défaut : `True` - `implicitly_patch_integrations` (bool) : Applique automatiquement des patchs aux bibliothèques prises en charge. Par défaut : `True` - `redact_pii` (bool) : Analyse toutes les données de trace à la recherche d’informations sensibles, comme les e-mails, les numéros de téléphone et les cartes de crédit, puis les remplace par des valeurs de substitution avant l’envoi au serveur. Nécessite les packages presidio-analyzer et presidio-anonymizer. * `Default`: `False` - `redact_pii_fields` (list\[str]): Spécifie quels types d’entités PII masquer lorsque `redact_pii` est défini sur True. Si vide, le jeu par défaut de Presidio est utilisé. Exemples \['EMAIL','PHONE\_NUMBER','CREDIT\_CARD','US\_SSN']. Voir la liste complète à l’adresse [https://microsoft.github.io/presidio/supported\_entities/](https://microsoft.github.io/presidio/supported_entities/) * `Par défaut` : `[]` - `redact_pii_exclude_fields` (list\[str]) : Types d’entités PII à exclure. Par défaut : `[]` - `capture_client_info` (bool) : Capture les informations de version de Python et du SDK. Par défaut : `True` - `capture_system_info` (bool) : Capture les informations du système d’exploitation. Par défaut : `True` - `client_parallelism` (int) : Nombre de workers pour les opérations en arrière-plan. Par défaut : `auto` - `use_server_cache` (bool) : Active la mise en cache locale sur disque des réponses du serveur. - `server_cache_size_limit` (int) : Limite de taille du cache en octets. Par défaut : `1_000_000_000` - `server_cache_dir` (str) : Répertoire du cache serveur. Par défaut : `temporary` - `scorers_dir` (str) : Répertoire des points de contrôle de modèle des évaluateurs. Par défaut : `~/.cache/wandb/weave-scorers` - `max_calls_queue_size` (int) : Taille maximale de la file d'attente (0 = sans limite). Par défaut : `100_000` - `retry_max_interval` (float) : Intervalle maximal entre les tentatives, en secondes. Par défaut : `300` - `retry_max_attempts` (int) : Nombre maximal de tentatives. Par défaut : `3` - `enable_disk_fallback` (bool) : Écrit les éléments abandonnés sur disque. Par défaut : `True` - `use_parallel_table_upload` (bool) : Active le téléversement parallèle par fragments pour les grands tableaux. Si False, les tableaux sont téléversés séquentiellement en fragments plus petits. * `Default`: `True` - `http_timeout` (float): Temps d’attente maximal, en secondes, pour l’exécution des requêtes HTTP. Cela inclut le temps de connexion, le transfert des données et le traitement côté serveur. Augmentez cette valeur pour les réseaux lents ou lorsque vous travaillez avec des charges utiles volumineuses. * `Default`: `30.0` - `use_stainless_server` (bool): Utilise le client HTTP généré par Stainless, qui offre une meilleure sécurité de typage, des réessais automatiques et une gestion des erreurs améliorée. Cette fonctionnalité est expérimentale et pourrait devenir la valeur par défaut dans de futures versions. * `Default`: `False` - `use_calls_complete` (bool): Utilise un mode d’écriture optimisé qui regroupe les données d’appel complètes (début et fin) dans une seule requête au lieu de requêtes de début et de fin distinctes. Cela réduit la charge du serveur et améliore les performances, en particulier pour les opérations de courte durée. * `Default`: `True` * `autopatch_settings`: (Obsolète) Configuration des intégrations autopatch. Utilisez plutôt un patching explicite. * `postprocess_inputs` : Une fonction appliquée aux entrées de chaque op dont ce client effectue le traçage. * `postprocess_output` : Une fonction appliquée au résultat de chaque op tracée par ce client. * `attributes` : Dictionnaire d'attributs appliqués à chaque trace produite par ce client. **Retourne :** Un client Weave. *** ### fonction `link_prompt_to_registry` ```python theme={null} link_prompt_to_registry( prompt: 'LinkablePrompt', target_path: 'str', aliases: 'Sequence[str] | None' = None ) → LinkAssetToRegistryRes ``` Liez une version publiée d’un prompt au registre. **Arguments :** * `prompt` : Un prompt publié, un `ObjectRef` ou une chaîne URI `weave ///...` pleinement qualifiée. * `target_path` : Chemin de destination du registre au format `/`, par exemple `wandb-registry-prompts/my-prompt-collection`. * `aliases` : Alias facultatifs à associer à la version du registre créée. **Retourne :** * `LinkAssetToRegistryRes` : Réponse analysée du point de terminaison `registry-link`. *** ### fonction `list_aliases` ```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 ... ) Logging with attributes and display name: >>> call = weave.log_call( ... op="process_data", ... inputs={"data": [1, 2, 3]}, ... output={"mean": 2.0}, ... attributes={"version": "1.0", "env": "prod"}, ... display_name="Data Processing" ... ) Logging a failed operation: >>> try: ... result = risky_operation() ... except Exception as e: ... call = weave.log_call( ... op="risky_operation", ... inputs={}, ... output=None, ... exception=e ... ) Nesting calls: >>> parent_call = weave.log_call("parent", {"input": 1}, 2) >>> child_call = weave.log_call( ... "child", ... {"input": 2}, ... 4, ... parent=parent_call ... ) Logging without adding to call stack: >>> call = weave.log_call( ... op="background_task", ... inputs={"task_id": 123}, ... output="completed", ... use_stack=False # Ne pas placer sur la pile d'appels ... ) --- ### function `log_session` ```python log_session( turns: 'list[Turn]', session_id: 'str' = '', session_name: 'str' = '', agent_name: 'str' = '', model: 'str' = '', include_content: 'bool' = True, continue_parent_trace: 'bool' = False ) → LogResult ```` Journalisez une session complète via l’API impérative. L’attribut `.spans` de chaque tour de conversation contient ses spans enfants. Génère automatiquement `session_id` si celui-ci est vide. Par défaut, chaque tour de conversation dispose de sa propre trace OTel. *** ### fonction `log_turn` ```python theme={null} log_turn( session_id: 'str', agent_name: 'str' = '', session_name: 'str' = '', model: 'str' = '', messages: 'list[Message] | None' = None, spans: 'list[LLM | Tool | SubAgent] | None' = None, started_at: 'datetime | None' = None, ended_at: 'datetime | None' = None, include_content: 'bool' = True, continue_parent_trace: 'bool' = False ) → LogResult ``` Émettez de manière impérative un tour de conversation et ses spans enfants vers OTel. À utiliser lorsque les gestionnaires de contexte ne sont pas adaptés (conteneurs sans état, callbacks, workers de file d'attente). Chaque span enfant transmis doit avoir `started_at` / `ended_at` défini ; les horodatages des spans OTel émis proviennent de ces champs. À défaut, les horodatages du span enfant le plus ancien et du plus récent sont utilisés, puis `now()`, lorsque le tour de conversation ne fournit pas les siens. *** ### fonction `op` ```python theme={null} 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 `otel_traces_endpoint` ```python theme={null} otel_traces_endpoint(base_url: str | None = None) → str ``` Renvoyer l’URL complète du point de terminaison HTTP OTLP pour l’ingestion des traces GenAI de Weave. Les appelants externes (par exemple, les sondes exécutées au démarrage qui veulent vérifier que le point de terminaison d’ingestion est accessible avant de s’en remettre au BatchSpanProcessor, qui ignore silencieusement les exports) doivent appeler cette fonction plutôt que de construire l’URL manuellement. Le chemin est géré par le SDK et peut être modifié. * `func` : La fonction à décorer. * `name` : Nom personnalisé de l’op. Par défaut, le nom de la fonction. * `call_display_name` : Nom d’affichage des appels ; peut être une chaîne ou un callable. * `postprocess_inputs` : Fonction qui transforme les entrées avant la journalisation. * `postprocess_output` : Fonction qui transforme la sortie avant la journalisation. * `tracing_sample_rate` : Fraction des appels à tracer (de 0.0 à 1.0). * `enable_code_capture` : Indique s’il faut capturer le code source pour cet op. * `accumulator` : Fonction qui accumule les résultats pour les ops en flux. * `eager_call_start` : Si True, les démarrages d’appel sont envoyés immédiatement au lieu d’être regroupés par lots. Utile pour les opérations de longue durée, comme les évaluations, qui doivent être visibles immédiatement dans l’interface utilisateur. **Arguments :** *** ### fonction `publish` ```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. * `base_url` : URL de base du trace server. Par défaut, `weave_trace_server_url()`. **Arguments :** * `obj` : L’objet à enregistrer et à versionner. * `name` : Le nom sous lequel enregistrer l’objet. * `tags` : Liste facultative de tags à ajouter à la version publiée de l’objet. * `aliases` : Liste facultative d’alias à définir sur la version publiée de l’objet. **Retourne :** Une Ref Weave vers l’objet enregistré. *** ### fonction `ref` ```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 `start_llm` ```python theme={null} start_llm( model: 'str' = '', provider_name: 'str' = '', system_instructions: 'list[str] | None' = None ) → LLM ``` Crée et active un appel LLM. Utilise le tour de conversation actuel s’il est disponible. Si aucun tour de conversation n’est actif, renvoie un LLM déconnecté (aucune contextvar définie). Passez explicitement `provider_name`. Le SDK ne l’infère pas à partir de l’ID du modèle : les déductions basées sur le préfixe attribuent à tort les modèles sur lesquels les utilisateurs ont effectué un fine-tuning (par exemple, un modèle nommé `text-...`) et intègrent à la télémétrie des hypothèses sur les futurs noms de modèles, qu’il est coûteux de corriger par la suite. *** ### fonction `start_session` ```python theme={null} start_session( agent_name: 'str' = '', model: 'str' = '', session_id: 'str' = '', session_name: 'str' = '', include_content: 'bool' = True, continue_parent_trace: 'bool' = False ) → Session ``` Crée et active une session. Définit la contextvar pour permettre l’accès intermodule. *** ### fonction `start_subagent` ```python theme={null} start_subagent(name: 'str', model: 'str' = '') → SubAgent ``` Créez un span d'invocation de sous-agent. Le span OTel de SubAgent devient automatiquement enfant du span actuellement actif dans le contexte OTel — généralement un span de tour de conversation s'il y en a un. Sa signature est calquée sur `start_tool` ; le contexte OTel gère la propagation parent-enfant, sans nécessiter de délégation explicite. *** ### fonction `start_tool` ```python theme={null} start_tool(name: 'str', arguments: 'str' = '', tool_call_id: 'str' = '') → Tool ``` Créez un span d’exécution d’outil. Le span OTel de l’outil devient automatiquement l’enfant du span courant dans le contexte OTel — généralement un span de tour de conversation s’il est actif. Aucune délégation explicite au tour de conversation n’est nécessaire : la propagation parent-enfant s’effectue via le contexte OTel, et non via les `contextvars` du SDK Session. *** ### fonction `start_turn` ```python theme={null} start_turn( user_message: 'str' = '', model: 'str' = '', agent_name: 'str' = '' ) → Turn ``` Crée et active un tour de conversation. Utilise la session en cours si elle est disponible. Si aucune session n’est active, renvoie un tour de conversation déconnecté qui n’est PAS défini dans la contextvar. Cela signifie que `get_current_turn()` renverra None. Utilisez plutôt `session.start_turn()` si vous avez besoin d’un accès intermodule basé sur la contextvar. *** ### fonction `thread` ```python theme={null} thread( thread_id: 'str | object | None' =