​

classe Agent

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

​

méthode step

step(state: AgentState) → AgentState

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

​

classe AgentState

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

​

classe AnnotationSpec

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

​

méthode de classe preprocess_field_schema

preprocess_field_schema(data: dict[str, Any]) → dict[str, Any]

​

méthode de classe validate_field_schema

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

​

méthode value_is_valid

value_is_valid(payload: Any) → bool

• payload: Les données à valider par rapport au schéma Retourne :
• bool: True si la validation réussit, False sinon

​

classe Audio

• format: Le format audio (prend actuellement en charge ‘wav’ ou ‘mp3’)
• data: Les données audio brutes sous forme d’octets

• data: Les données audio (octets ou chaîne encodée en base64)
• format: Le format audio (‘wav’ ou ‘mp3’)
• validate_base64: Indique s’il faut tenter de décoder les données d’entrée en base64 Exceptions levées :
• ValueError: Si les données audio sont vides ou si le format n’est pas pris en charge

​

méthode __init__

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

​

méthode export

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

​

méthode de classe from_data

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

• 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

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

​

méthode de classe from_path

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

• path: Chemin vers un fichier audio (doit avoir l’extension .wav ou .mp3) Retourne :
• Audio: Une nouvelle instance Audio chargée à partir du fichier

• ValueError: Si le fichier n’existe pas ou si son extension n’est pas prise en charge

​

classe ClassifierMonitor

• name: str | None
• description: str | None
• ref: trace.refs.ObjectRef | None
• sampling_rate: <class 'float'>
• scorers: list[flow.scorer.Scorer]
• op_names: list[typing.Union[typing.Literal['genai.turn_ended'], str]]
• query: trace_server.interface.query.Query | None
• is_traced: <class 'bool'>
• active: <class 'bool'>
• scorer_debounce_config: flow.monitor.ScorerDebounceConfig | None
• prompt_header: str | None
• prompt_footer: str | None

​

méthode activate

activate() → ObjectRef

​

méthode deactivate

deactivate() → ObjectRef

​

méthode de classe from_obj

from_obj(obj: WeaveObject) → Self

​

méthode get_prompt_footer

get_prompt_footer() → str

​

méthode get_prompt_header

get_prompt_header(op_name: str) → str

​

classe Content

• from_path()
• from_bytes()
• from_text()
• from_url()
• from_base64()
• from_data_url()

​

méthode __init__

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

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

​

propriété art

​

propriété ref

​

méthode as_string

as_string() → str

​

méthode de classe from_base64

from_base64(
    b64_data: 'str | bytes',
    extension: 'str | None' = None,
    mimetype: 'str | None' = None,
    metadata: 'dict[str, Any] | None' = None
) → Self

​

méthode de classe from_bytes

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

​

méthode de classe from_data_url

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

​

méthode de classe from_path

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

​

méthode de classe from_text

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

​

méthode de classe from_url

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

​

méthode de classe model_validate

model_validate(
    obj: 'Any',
    strict: 'bool | None' = None,
    from_attributes: 'bool | None' = None,
    context: 'dict[str, Any] | None' = None,
    extra: 'str | None' = None,
    by_alias: 'bool | None' = None,
    by_name: 'bool | None' = None
) → Self

​

méthode de classe model_validate_json

model_validate_json(
    json_data: 'str | bytes | bytearray',
    strict: 'bool | None' = None,
    context: 'dict[str, Any] | None' = None,
    extra: 'str | None' = None,
    by_alias: 'bool | None' = None,
    by_name: 'bool | None' = None
) → Self

​

méthode open

open() → bool

• bool: True si le fichier a été ouvert avec succès, False sinon.

​

méthode save

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

​

méthode serialize_data

serialize_data(data: 'bytes') → str

​

méthode to_data_url

to_data_url(use_base64: 'bool' = True) → str

• 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

# 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']

• name: str | None
• description: str | None
• ref: trace.refs.ObjectRef | None
• rows: trace.table.Table | trace.vals.WeaveTable

​

méthode add_rows

add_rows(rows: Iterable[dict]) → Dataset

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

​

méthode de classe convert_to_table

convert_to_table(rows: Any) → Table | WeaveTable

​

méthode de classe from_calls

from_calls(calls: Iterable[Call]) → Self

​

méthode de classe from_hf

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

​

méthode de classe from_obj

from_obj(obj: WeaveObject) → Self

​

méthode de classe from_pandas

from_pandas(df: 'DataFrame') → Self

​

méthode select

select(indices: Iterable[int]) → Self

• indices : Un itérable d’indices entiers indiquant quelles lignes sélectionner. Retourne : Un nouvel objet Dataset contenant uniquement les lignes sélectionnées.

​

méthode to_hf

to_hf() → HFDataset

​

méthode to_pandas

to_pandas() → DataFrame

​

classe EasyPrompt

​

méthode __init__

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

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

​

propriété as_str

​

propriété is_bound

​

propriété messages

​

espaces réservés de propriété

​

propriété system_message

​

propriété system_prompt

​

propriété unbound_placeholders

​

méthode append

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

​

méthode as_dict

as_dict() → dict[str, Any]

​

méthode as_pydantic_dict

as_pydantic_dict() → dict[str, Any]

​

méthode bind

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

​

méthode bind_rows

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

​

méthode config_table

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

​

méthode configure

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

​

méthode dump

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

​

méthode dump_file

dump_file(filepath: str | Path) → None

​

méthode format

format(**kwargs: Any) → Any

​

méthode de classe from_obj

from_obj(obj: WeaveObject) → Self

​

méthode de classe load

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

​

méthode de classe load_file

load_file(filepath: str | Path) → Self

​

méthode messages_table

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

​

méthode print

print() → str

​

méthode publish

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

​

méthode require

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

​

méthode run

run() → Any

​

méthode validate_requirement

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

​

méthode validate_requirements

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

​

méthode values_table

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

​

class Evaluation

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

• name: str | None
• description: str | None
• ref: trace.refs.ObjectRef | None
• dataset: <class 'dataset.dataset.Dataset'>
• scorers: list[typing.Annotated[trace.op_protocol.Op | flow.scorer.Scorer, BeforeValidator(func=<function cast_to_scorer at 0x7f1615b1b600>, json_schema_input_type=PydanticUndefined)]] | None
• preprocess_model_input: collections.abc.Callable[[dict], dict] | None
• trials: <class 'int'>
• metadata: dict[str, typing.Any] | None
• evaluation_name: str | collections.abc.Callable[trace.call.Call, str] | None

​

méthode evaluate

evaluate(model: Op | Model) → dict

​

méthode de classe from_obj

from_obj(obj: WeaveObject) → Self

​

méthode get_eval_results

get_eval_results(model: Op | Model) → EvaluationResults

​

méthode get_evaluate_calls

get_evaluate_calls() → PaginatedIterator[CallSchema, WeaveObject]

• CallsIter: Un itérateur sur des objets Appel représentant des Runs d’évaluation.

• ValueError: Si l’évaluation n’a pas de ref (elle n’a pas encore été enregistrée/exécutée).

evaluation = Evaluation(dataset=examples, scorers=[scorer])
await evaluation.evaluate(model)  # Exécuter l'évaluation en premier
calls = evaluation.get_evaluate_calls()
for call in calls:
     print(f"Evaluation run: {call.id} at {call.started_at}")

​

méthode get_score_calls

get_score_calls() → dict[str, list[Call]]

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

evaluation = Evaluation(dataset=examples, scorers=[accuracy_scorer, f1_scorer])
await evaluation.evaluate(model)
score_calls = evaluation.get_score_calls()
for trace_id, calls in score_calls.items():
     print(f"Trace {trace_id}: {len(calls)} scorer calls")
     for call in calls:
         scorer_name = call.summary.get("weave", {}).get("trace_name")
         print(f"  Scorer: {scorer_name}, Output: {call.output}")

​

méthode get_scores

get_scores() → dict[str, dict[str, list[Any]]]

• 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

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

{
     "trace_123": {
     "accuracy_scorer": [{"accuracy": 0.85}],
     "f1_scorer": [{"f1": 0.78}]
     }
}

​

méthode model_post_init

model_post_init(context: Any) → None

​

méthode predict_and_score

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

​

méthode summarize

summarize(eval_table: EvaluationResults) → dict

​

class EvaluationLogger

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

ev = EvaluationLogger()

# Utilisez un gestionnaire de contexte pour capturer les opérations imbriquées
with ev.log_prediction(inputs={'q': 'Hello'}) as pred:
     # Toutes les opérations ici (comme les appels LLM) deviennent automatiquement
     # des enfants de l'appel predict
     response = your_llm_call(...)
     pred.output = response.content
     pred.log_score("correctness", 0.9)

# Terminer l'évaluation
ev.log_summary({"avg_score": 0.9})

​

méthode __init__

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

​

attributs de la propriété

​

propriété ui_url

​

méthode fail

fail(exception: 'BaseException') → None

​

méthode finish

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

​

méthode log_example

log_example(
    inputs: 'dict[str, Any]',
    output: 'Any',
    scores: 'dict[str, ScoreType]'
) → None

• inputs: Les données d’entrée de la prédiction
• output: La valeur de sortie
• scores: Dictionnaire associant les noms des évaluateurs à leurs scores Exemple :

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

​

méthode log_prediction

log_prediction(inputs: 'dict[str, Any]', output: 'Any' = None) → ScoreLogger

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

• pred = ev.log_prediction({'q': ’…’}, output=“answer”) pred.log_score(“correctness”, 0.9) pred.finish()

• with ev.log_prediction({'q': ’…’}) as pred: response = model(…) pred.output = response pred.log_score(“correctness”, 0.9) # Appelle automatiquement finish() à la sortie

​

méthode log_summary

log_summary(summary: 'dict | None' = None, auto_summarize: 'bool' = True) → None

​

méthode set_view

set_view(
    name: 'str',
    content: 'Content | str',
    extension: 'str | None' = None,
    mimetype: 'str | None' = None,
    metadata: 'dict[str, Any] | None' = None,
    encoding: 'str' = 'utf-8'
) → None

• 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

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

​

class File

​

méthode __init__

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

​

propriété filename

• path: Chemin vers le fichier (string ou pathlib.Path)
• mimetype: Type MIME facultatif du fichier ; sera déduit de l’extension s’il n’est pas fourni Retourne :
• str: Le nom du fichier sans le chemin du répertoire.

​

méthode open

open() → bool

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

​

méthode save

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

​

class LLM

• dest: chemin de destination vers lequel le fichier sera copié (string ou pathlib.Path) Le chemin de destination peut être un fichier ou un répertoire. Champs Pydantic :
• model: <class 'str'>
• provider_name: <class 'str'>
• response_id: <class 'str'>
• response_model: <class 'str'>
• output_type: <class 'str'>
• system_instructions: list[str]
• usage: <class 'session.types.Usage'>
• reasoning: <class 'session.types.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

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

​

méthode attach_media_url

attach_media_url(url: 'str', modality: 'str' = '') → LLM

​

méthode end

end() → None

​

méthode model_post_init

model_post_init(context: 'Any') → None

​

méthode output

output(content: 'str') → LLM

​

méthode record

record(
    input_messages: 'list[Message] | None' = None,
    output_messages: 'list[Message] | None' = None,
    media_attachments: 'list[MediaAttachment] | None' = None,
    usage: 'Usage | None' = None,
    reasoning: 'Reasoning | str | None' = None,
    response_id: 'str | None' = None,
    response_model: 'str | None' = None,
    finish_reasons: 'list[str] | None' = None,
    output_type: 'str | None' = None
) → LLM

​

méthode think

think(content: 'str') → LLM

​

classe LogResult

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

​

classe Markdown

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

​

méthode __init__

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

​

classe MediaAttachment

• 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: <class 'str'>
• mime_type: <class 'str'>
• content: bytes | str
• uri: <class 'str'>
• file_id: <class 'str'>

​

classe Message

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='{...}')])

• role: typing.Literal['user', 'assistant', 'system', 'tool']
• content: <class 'str'>
• tool_call_id: <class 'str'>
• tool_name: <class 'str'>
• 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

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

​

méthode de classe system

system(text: 'str') → Message

​

méthode de classe tool_result

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

​

méthode de classe user

user(text: 'str') → Message

​

classe MessagesPrompt

​

méthode __init__

__init__(messages: list[dict])

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

​

méthode format

format(**kwargs: Any) → list

​

méthode format_message

format_message(message: dict, **kwargs: Any) → dict

​

méthode de classe from_obj

from_obj(obj: WeaveObject) → Self

​

classe Model

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}

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

​

méthode get_infer_method

get_infer_method() → Callable

​

classe Monitor

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

• name: str | None
• description: str | None
• ref: trace.refs.ObjectRef | None
• sampling_rate: <class 'float'>
• scorers: list[flow.scorer.Scorer]
• op_names: list[typing.Union[typing.Literal['genai.turn_ended'], str]]
• query: trace_server.interface.query.Query | None
• is_traced: <class 'bool'>
• active: <class 'bool'>
• scorer_debounce_config: flow.monitor.ScorerDebounceConfig | None

​

méthode activate

activate() → ObjectRef

​

méthode deactivate

deactivate() → ObjectRef

​

méthode de classe from_obj

from_obj(obj: WeaveObject) → Self

​

classe Object

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

# 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")

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

​

méthode de classe from_uri

from_uri(uri: str, objectify: bool = True) → Self

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

• Self: Une instance de la classe créée à partir de l’URI.

• NotImplementedError: Si la classe n’implémente pas les méthodes requises pour la désérialisation.

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

​

méthode de classe handle_relocatable_object

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

• v (Any): La valeur à valider.
• handler (ValidatorFunctionWrapHandler): Le gestionnaire de validation pydantic standard.
• info (ValidationInfo): Les informations de contexte de validation.

• Any: L’instance d’objet validée.

---

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

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

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

​

classe ObjectRef

​

méthode __init__

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

​

propriété digest

​

propriété extra

​

propriété is_digest_resolved

​

méthode as_param_dict

as_param_dict() → dict

​

méthode delete

delete() → None

​

méthode get

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

​

méthode is_descended_from

is_descended_from(potential_ancestor: 'ObjectRef') → bool

​

méthode maybe_parse_uri

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

​

méthode parse_uri

parse_uri(uri: 'str') → ObjectRef

​

méthode with_attr

with_attr(attr: 'str') → Self

​

méthode with_extra

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

​

méthode with_index

with_index(index: 'int') → Self

​

méthode with_item

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

​

méthode with_key

with_key(key: 'str') → Self

​

classe Prompt

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

​

méthode format

format(**kwargs: Any) → Any

​

classe SavedView

​

méthode __init__

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

​

propriété entité

​

propriété label

​

propriété project

​

propriété view_type

​

méthode add_column

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

​

méthode add_columns

add_columns(*columns: 'str') → SavedView

​

méthode add_filter

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

​

méthode add_sort

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

​

méthode column_index

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

​

méthode filter_op

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

​

méthode get_calls

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

​

méthode get_known_columns

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

​

méthode get_table_columns

get_table_columns() → list[TableColumn]

​

méthode hide_column

hide_column(col_name: 'str') → SavedView

​

méthode insert_column

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

​

méthode de classe load

load(ref: 'str') → Self

​

méthode page_size

page_size(page_size: 'int') → SavedView

​

méthode pin_column_left

pin_column_left(col_name: 'str') → SavedView

​

méthode pin_column_right

pin_column_right(col_name: 'str') → SavedView

​

méthode remove_column

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

​

méthode remove_columns

remove_columns(*columns: 'str') → SavedView

​

méthode remove_filter

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

​

méthode remove_filters

remove_filters() → SavedView

​

méthode rename

rename(label: 'str') → SavedView

​

méthode rename_column

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

​

méthode save