API 概要

`クラス` `Agent`

Pydantic のフィールド:

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

`method` `step`

step(state: AgentState) → AgentState

エージェントのstepを実行します。 引数:

state: 環境の現在の状態。
action: 実行するアクション。 戻り値: 環境の新しい状態。

`クラス` `AgentState`

Pydantic のフィールド:

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

`クラス` `AnnotationSpec`

Pydantic のフィールド:

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

`クラスメソッド` `preprocess_field_schema`

preprocess_field_schema(data: Any) → Any

`クラスメソッド` `validate_field_schema`

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

`method` `value_is_valid`

value_is_valid(payload: Any) → bool

payload がこの annotation spec のスキーマに適合するかを検証します。 引数:

payload: スキーマに対して検証するデータ 戻り値:
bool: 検証に成功した場合は True、それ以外の場合は False

`クラス` `Audio`

サポート対象の形式 (wav または mp3) のオーディオデータを表すクラスです。このクラスはオーディオデータを保持し、さまざまなソースからの読み込みやファイルへの書き出しを行うためのメソッドを提供します。 Attributes:

format: オーディオ形式 (現在サポートされているのは ‘wav’ または ‘mp3’)
data: bytes としての生のオーディオデータ

引数:

data: オーディオデータ (bytes または base64 エンコードされた文字列)
format: オーディオ形式 (‘wav’ または ‘mp3’)
validate_base64: 入力データの base64 デコードを試行するかどうか 送出される例外
ValueError: オーディオデータが空の場合、または形式がサポートされていない場合

`method` `init`

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

`method` `export`

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

オーディオデータをファイルにエクスポートします。 引数:

`クラスメソッド` `from_data`

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

生データと指定した形式から Audio オブジェクトを作成します。

path: オーディオファイルの書き込み先パス 引数:
data: bytes または base64 エンコードされた文字列形式のオーディオデータ
format: オーディオ形式 (‘wav’ または ‘mp3’) 戻り値:
Audio: 新しい Audio インスタンス

送出される例外:

ValueError: format で指定した形式がサポートされていない場合

`クラスメソッド` `from_path`

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

ファイルパスから Audio オブジェクトを作成します。 引数:

path: オーディオファイルへのパス (拡張子は .wav または .mp3 である必要があります) 戻り値:
Audio: ファイルから読み込まれた新しい Audio インスタンス

送出される例外:

ValueError: ファイルが存在しない場合、またはサポートされていない拡張子の場合

`クラス` `ClassifierMonitor`

複数の scorer を 1 つの分類器に統合するモニターです。分類器モニターは、同じモデルを対象とする複数の LLMAsAJudgeScorers のプロンプトを、1 回のスコアリング call にまとめます。 Pydantic のフィールド:

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

`method` `activate`

activate() → ObjectRef

モニターを有効にします。 戻り値: モニターへの参照。

`method` `deactivate`

deactivate() → ObjectRef

モニターを停止します。 戻り値: モニターへの参照。

`クラスメソッド` `from_obj`

from_obj(obj: WeaveObject) → Self

`method` `get_prompt_footer`

get_prompt_footer() → str

マージされた分類器プロンプトの後に追加するテキスト。

`method` `get_prompt_header`

get_prompt_header(op_name: str) → str

マージされた分類器プロンプトの前に追加するテキスト。

`method` `model_post_init`

model_post_init(context: Any) → None

クライアントが利用可能な場合は、構築時に op_names を正規化します。公開処理にはオブジェクトごとの hook がないため、素の weave.publish(monitor) (activate() なし) もカバーできるように、ここで短い名を展開します。公開を行う場合は通常 weave.init を呼び出しているため、モニターの構築時にはクライアントが設定されています。ユニットテスト、インスペクション、worker で保存済みモニターをデシリアライズする場合など、クライアントなしで構築するユースケースもいくつかあります。get_weave_client() のガードにより、クライアントなしでも構築できます。この場合、正規化は行われませんが、保存済みモニターにはすでに完全な ref が保持されているため、問題ないはずです。 SDK を使用している場合でも、正規化されないままモニターを作成できてしまうエッジケースがあります。これは、ユーザーがモニターを構築し、その後 weave.init を呼び出してから公開する場合です。このユースケースの回避策としては、activate() または deactivate() を呼び出す方法が考えられます。

`クラス` `Content`

さまざまなソースのコンテンツを表すクラスです。関連するメタデータとともに、バイト列ベースの統一表現に変換します。このクラスは、以下のいずれかの classmethod を使用してインスタンス化する必要があります。

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

`method` `init`

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

直接初期化することはできません。インスタンスを作成するには、Content.from_path() のようなクラスメソッドを使用してください。 Pydantic のフィールド:

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

`プロパティ` art

`プロパティ` ref

`method` `as_string`

as_string() → str

データを文字列として表示します。バイト列は encoding 属性を使用してデコードされます。base64 の場合、データはいったん base64 のバイト列として再エンコードされ、その後 ASCII 文字列にデコードされます。 戻り値: str.

`クラスメソッド` `from_base64`

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

base64 でエンコードされた文字列またはバイト列から Content を初期化します。

`クラスメソッド` `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

生のバイト列からContentを初期化します。

`クラスメソッド` `from_data_url`

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

データ URL から Content を初期化します。

`クラスメソッド` `from_path`

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

ローカルファイルのパスからContentを初期化します。

`クラスメソッド` `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

文字列からContentを初期化します。

`クラスメソッド` `from_url`

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

HTTP(S) URL からバイト列を取得して Content を初期化します。コンテンツをダウンロードし、ヘッダー、URL パス、データに基づいて MIME タイプと拡張子を推定したうえで、取得したバイト列から Content オブジェクトを構築します。

`クラスメソッド` `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

dict からの Content の再構成を処理できるように、model_validate をオーバーライドします。

`クラスメソッド` `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

JSON から Content を再構成できるように、model_validate_json をオーバーライドします。

`method` `open`

open() → bool

オペレーティングシステムの既定のアプリケーションを使用して、ファイルを開きます。この method は、ファイルタイプに関連付けられた既定のアプリケーションでファイルを開くために、プラットフォーム固有の仕組みを使用します。 戻り値:

bool: ファイルを正常に開けた場合は True、それ以外の場合は False。

`method` `save`

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

ファイルを指定した保存先パスにコピーします。最後に保存したコピーを反映するように、コンテンツのファイル名とパスを更新します。 引数:

`method` `serialize_data`

serialize_data(data: 'bytes') → str

モデルをJSONモードでダンプする場合

`method` `to_data_url`

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

コンテンツからデータ URL を生成します。

dest: ファイルのコピー先となるパス (string または pathlib.Path) 。コピー先のパスには、ファイルまたはディレクトリを指定できます。dest にファイル拡張子 (例: .txt) がない場合、コピー先はディレクトリとして扱われます。 引数:
use_base64: True の場合、データは base64 エンコードされます。それ以外の場合はパーセントエンコードされます。デフォルトは True です。 戻り値: データ URL 文字列。

`クラス` `Conversation`

会話です。conversation_id ごとにターンをグループ化します (span はありません) 。 continue_parent_trace は、この会話が作成するターンのトレース分離を制御します。デフォルトの False は、各ターンがそれぞれ独自の OTel トレースを開始することを意味します (スタンドアロンの Agents タブのビューでは、これが適切です) 。アプリケーションに外側のトレース (例: fastapi でインストルメントされたリクエスト) があり、その中にエージェントの呼び出しを含める必要がある場合は、True に設定します。 Pydantic のフィールド:

conversation_id: <class 'str'>
conversation_name: <class 'str'>
agent_name: <class 'str'>
model: <class 'str'>
include_content: <class 'bool'>
continue_parent_trace: <class 'bool'>
attributes: dict[str, typing.Any]

`method` `end`

end() → None

`method` `model_post_init`

model_post_init(context: 'Any') → None

`method` `start_turn`

start_turn(
    user_message: 'str' = '',
    model: 'str' = '',
    agent_name: 'str' = '',
    system_instructions: 'list[str] | None' = None
) → Turn

新しいターンを作成します。前のターンがまだ開いている場合は、自動的に終了します。 _current_turn の contextvar を設定することで、コンテキストマネージャーを使用しているかどうかにかかわらず、get_current_turn() を通じてターンを参照できます。また、この会話から continue_parent_trace を引き継ぎます。 system_instructions (エージェントのシステムプロンプト) は、ターンの invoke_agent span に保持されます。返された Turn への属性代入によって後から設定することもでき、start_llm と同様です。

`クラス` `Dataset`

簡単に保存でき、自動的にバージョン管理される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."}
])

# データセットを公開する
weave.publish(dataset)

# データセットを取得する
dataset_ref = weave.ref('grammar').get()

# 特定のサンプルにアクセスする
example_label = dataset_ref.rows[2]['sentence']

Pydantic のフィールド:

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

`method` `add_rows`

add_rows(rows: Iterable[dict]) → Dataset

既存のデータセットに行を追記して、新しいバージョンのデータセットを作成します。これは、データセット全体をメモリに読み込まずに、大規模なデータセットへサンプルを追加する場合に便利です。 引数:

rows: データセットに追加する行。 戻り値: 更新後のデータセット。

`クラスメソッド` `convert_to_table`

convert_to_table(rows: Any) → Table | WeaveTable

`クラスメソッド` `from_calls`

from_calls(calls: Iterable[Call]) → Self

`クラスメソッド` `from_hf`

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

`クラスメソッド` `from_obj`

from_obj(obj: WeaveObject) → Self

`クラスメソッド` `from_pandas`

from_pandas(df: 'DataFrame') → Self

`method` `select`

select(indices: Iterable[int]) → Self

指定したインデックスに基づいて、データセットから行を選択します。 引数:

indices: 選択する行を指定する整数インデックスのイテラブル。 戻り値: 選択した行のみを含む新しい Dataset オブジェクト。

`method` `to_hf`

to_hf() → HFDataset

`method` `to_pandas`

to_pandas() → DataFrame

`クラス` `EasyPrompt`

`method` `init`

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

Pydantic のフィールド:

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

`プロパティ` as_str

すべてのメッセージを結合して1つの文字列にします。

`プロパティ` is_bound

`プロパティ` messages

`プロパティ` プレースホルダー

`プロパティ` system_message

すべてのメッセージを結合して、1つのsystem promptメッセージにします。

`プロパティ` system_prompt

すべてのメッセージを結合して、system prompt オブジェクトにします。

`プロパティ` unbound_placeholders

`method` `append`

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

`method` `as_dict`

as_dict() → dict[str, Any]

`method` `as_pydantic_dict`

as_pydantic_dict() → dict[str, Any]

`method` `bind`

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

`method` `bind_rows`

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

`method` `config_table`

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

`method` `configure`

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

`method` `dump`

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

`method` `dump_file`

dump_file(filepath: str | Path) → None

`method` `format`

format(**kwargs: Any) → Any

`クラスメソッド` `from_obj`

from_obj(obj: WeaveObject) → Self

`クラスメソッド` `load`

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

`クラスメソッド` `load_file`

load_file(filepath: str | Path) → Self

`method` `messages_table`

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

`method` `print`

print() → str

`method` `publish`

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

`method` `require`

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

`method` `run`

run() → Any

`method` `validate_requirement`

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

`method` `validate_requirements`

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

`method` `values_table`

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

`class` `評価`

scorer のセットとデータセットを含む評価を設定します。 evaluation.evaluate(model) を呼び出すと、データセットの各行がモデルに渡されます。このとき、データセットの列名は model.predict の引数名に対応付けられます。その後、すべての scorer が呼び出され、結果は Weave に保存されます。データセットの行を前処理したい場合は、preprocess_model_input に関数を渡せます。例:

# サンプルを収集する
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"},
]

# カスタムスコアリング関数を定義する
@weave.op
def match_score1(expected: str, model_output: dict) -> dict:
     # ここにモデル出力をスコアリングするロジックを定義する
     return {'match': expected == model_output['generated_text']}

@weave.op
def function_to_evaluate(question: str):
     # ここに LLM Call を追加して出力を返す
     return  {'generated_text': 'Paris'}

# スコアリング関数を使ってサンプルをスコアリングする
evaluation = Evaluation(
     dataset=examples, scorers=[match_score1]
)

# 評価のトラッキングを開始する
weave.init('intro-example')
# 評価を実行する
asyncio.run(evaluation.evaluate(function_to_evaluate))

Pydantic のフィールド:

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

`method` `evaluate`

evaluate(model: Op | Model) → dict

`classmethod` `from_obj`

from_obj(obj: WeaveObject) → Self

`method` `get_eval_results`

get_eval_results(model: Op | Model) → EvaluationResults

`method` `get_evaluate_calls`

get_evaluate_calls() → PaginatedIterator[CallSchema, WeaveObject]

この 評価 オブジェクトを使用したすべての評価 call を取得します。これは単一の call ではなく CallsIter を返すことに注意してください。1 つの評価に対して複数の評価 call が存在する可能性があるためです (たとえば、同じ評価を複数回実行した場合) 。 戻り値:

CallsIter: 評価 run を表す Call オブジェクトのイテレータ。

送出:

ValueError: 評価に ref がない場合 (まだ保存または実行されていない場合) 。

例:

evaluation = Evaluation(dataset=examples, scorers=[scorer])
await evaluation.evaluate(model)  # Run evaluation first
calls = evaluation.get_evaluate_calls()
for call in calls:
     print(f"Evaluation run: {call.id} at {call.started_at}")

`method` `get_score_calls`

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

各評価 run の Scorer call を、trace ID ごとにグループ化して取得します。 戻り値:

dict[str, list[Call]]: trace ID から Scorer の Call オブジェクトのリストへのマッピングを格納した辞書。各 trace ID は 1 つの評価 run を表し、リストにはその run 中に実行されたすべての Scorer call が含まれます。

例:

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

`method` `get_scores`

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

評価 run から Scorer の出力を抽出し、整理します。 戻り値:

dict[str, dict[str, list[Any]]]: 次のようなネストされた辞書構造です。
- 第1レベルのキーは trace ID (評価 run)
- 第2レベルのキーは Scorer 名
- 値は、その run と Scorer に対応する Scorer の出力のリスト

例:

evaluation = Evaluation(dataset=examples, scorers=[accuracy_scorer, f1_scorer])
await evaluation.evaluate(model)
scores = evaluation.get_scores()
# trace と scorer ごとにスコアにアクセスする
for trace_id, trace_scores in scores.items():
         print(f"Evaluation run {trace_id}:")
         for scorer_name, outputs in trace_scores.items():
             print(f"  {scorer_name}: {outputs}")

想定される出力:

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

`method` `model_post_init`

model_post_init(context: Any) → None

`method` `predict_and_score`

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

`method` `summarize`

summarize(eval_table: EvaluationResults) → dict

`class` `EvaluationLogger`

このクラスは、評価をログするための命令型インターフェースを提供します。最初の予測を log_prediction method でログすると、自動的に評価が開始され、log_summary method が呼び出されると終了します。予測をログするたびに、ScoreLogger オブジェクトが返されます。このオブジェクトを使用して、その予測に対応するスコアとメタデータをログできます。詳細は、ScoreLogger クラスを参照してください。基本的な使用方法 - 入力と出力を直接指定して予測をログします:

ev = EvaluationLogger()

# 既知の入力/出力で予測をログする
pred = ev.log_prediction(inputs={'q': 'Hello'}, outputs={'a': 'Hi there!'})
pred.log_score("correctness", 0.9)

# 評価を終了する
ev.log_summary({"avg_score": 0.9})

高度な使い方 - 動的な出力とネストされたオペレーションにはコンテキストマネージャーを使用します:

ev = EvaluationLogger()

# ネストされたオペレーションを取得する必要がある場合はコンテキストマネージャーを使用します
with ev.log_prediction(inputs={'q': 'Hello'}) as pred:
     # ここでのオペレーション（LLM calls など）は自動的に
     # predict call の子になります
     response = your_llm_call(...)
     pred.output = response.content
     pred.log_score("correctness", 0.9)

# 評価を終了します
ev.log_summary({"avg_score": 0.9})

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

`プロパティ` 属性

`プロパティ` ui_url

`method` `fail`

fail(exception: 'BaseException') → None

評価を例外で失敗させるための便利な method。

`method` `finish`

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

サマリーをログせず、評価リソースを明示的にクリーンアップします。すべての予測 call とメインの評価 call を確実に終了します。ロガーをコンテキストマネージャーとして使用している場合は、自動的に呼び出されます。

`method` `log_example`

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

入力、出力、スコアを含む完全な例をログします。これは、必要なデータがすべて事前にそろっている場合に、log_prediction と log_score をまとめて実行できる便利な method です。 引数:

inputs: 予測の入力データ
output: 出力値
scores: Scorer 名を score 値に対応付ける辞書例:

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

`method` `log_prediction`

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

予測を評価にログします。直接使用することも、コンテキストマネージャーとして使用することもできる ScoreLogger を返します。 引数:

inputs: 予測の入力データ
output: 出力値。デフォルトは None です。後で pred.output を使用して設定できます。 戻り値: スコアのログ記録や、必要に応じて予測の終了に使用できる ScoreLogger。

例 (直接使用する場合) :

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) # 終了時に自動的に finish() が呼び出されます

`method` `log_summary`

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

評価に summary dict をログします。これにより summary が計算され、summarize op が呼び出された後、評価が確定されます。つまり、以降は予測やスコアをログできなくなります。

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

weave.views の下で、評価のメイン call の summary に view を追加します。指定されたコンテンツをプロジェクト内のオブジェクトとして保存し、その参照 URI を、評価の evaluate call の summary.weave.views.<name> に書き込みます。文字列入力は、指定された拡張子または MIME タイプを使って、Content.from_text によりテキストコンテンツとしてラップされます。 引数:

name: 表示する view の名前。summary.weave.views 配下のキーとして使用されます。
content: シリアライズする weave.Content インスタンス、または文字列。
extension: 文字列コンテンツ入力に使用する省略可能なファイル拡張子。
mimetype: 文字列コンテンツ入力に使用する省略可能な MIME タイプ。
metadata: 新しく作成される Content に付加する省略可能なメタデータ。
encoding: 文字列コンテンツ入力のテキストエンコーディング。 戻り値: None

例: import weave

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

`class` `File`

パス、MIMEタイプ、サイズ情報を持つファイルを表すクラス。

`method` `init`

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

Fileオブジェクトを初期化します。 引数:

`プロパティ` filename

ファイル名を取得します。

path: ファイルのパス (string または pathlib.Path)
mimetype: 省略可能なファイルの MIME タイプ。指定しない場合は拡張子から推定されます 戻り値:
str: ディレクトリパスを含まないファイル名。

`method` `open`

open() → bool

オペレーティングシステムの既定のアプリケーションを使用してファイルを開きます。この method では、ファイルのタイプに関連付けられた既定のアプリケーションでファイルを開くために、プラットフォーム固有の仕組みを使用します。 戻り値:

bool: ファイルを正常に開けた場合は True、それ以外の場合は False。

`method` `save`

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

ファイルを指定したコピー先のパスにコピーします。 引数:

`class` `LLM`

1 回の LLM API Call です。chat OTel span にマッピングされます。

dest: file のコピー先パスです (string または pathlib.Path) 。コピー先パスには、file またはディレクトリを指定できます。 Pydantic のフィールド:
model: <class 'str'>
provider_name: <class 'str'>
response_id: <class 'str'>
response_model: <class 'str'>
output_type: <class 'str'>
system_instructions: list[str]
usage: <class 'conversation.types.Usage'>
reasoning: <class 'conversation.types.Reasoning'>
finish_reasons: list[str]
input_messages: list[conversation.types.Message]
output_messages: list[conversation.types.Message]
media_attachments: list[conversation.types.MediaAttachment]
request_temperature: float | None
request_max_tokens: int | None
request_top_p: float | None
request_frequency_penalty: float | None
request_presence_penalty: float | None
request_seed: int | None
request_stop_sequences: list[str]
request_choice_count: int | None
started_at: datetime.datetime | None
ended_at: datetime.datetime | None

`method` `add_event`

add_event(
    name: 'str',
    attributes: 'dict[str, Any] | None' = None,
    timestamp: 'datetime | None' = None
) → Self

この span 内のある時点で、OTel span イベントを記録します。マーカー / lifecycle データに使用します。たとえば、permission prompt (例: weave.permission_request) 、lifecycle の遷移 (例: spawned / streaming / finished) 、または span の存続期間中の特定の時点で発生する任意の custom マイルストーンです (span 全体に対するプロパティである attribute とは異なります) 。 span の開始から終了までの間 (with の内側) で呼び出す必要があります。この範囲外では、この呼び出しは no-op となり、警告がログされます。

`method` `attach_media`

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

この LLM Call にメディアを添付します。指定されたデータから Content オブジェクトを作成し、それを公開して weave:// ref を取得し、その ref のみを保存します。content、uri、またはfile_idのいずれか 1 つを必ず指定してください。公開処理 (メディアのアップロードを行います) は専用のバックグラウンドスレッドで実行されるため、呼び出し元をブロックせず、call はすぐに返ります。添付ごとに 1 つのスレッドがディスパッチされるため、複数のアップロードを並列に進められます。プレースホルダーの MediaAttachment は同期的に追加され、アップロードが完了するとその ref が設定されます。ref は span が送出される前に必ず設定されます (build path は _await_uploads を介して進行中のアップロードを待機します) 。

`method` `attach_media_url`

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

この LLM Call にメディア URL を添付します。呼び出し元が上流のメッセージから URL string を受け取る一般的なケース向けに、attach_media を簡単に利用できるようにしたものです。data: URL は bytes として解析されて公開され、通常の URI は取得されて公開されます。空の URL は無視されます。チェーンできるように self を返します。

`メソッド` `end`

end() → None

`メソッド` `model_post_init`

model_post_init(context: 'Any') → None

`メソッド` `output`

output(content: 'str') → LLM

output_messages にアシスタントメッセージを追加します。

`メソッド` `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

1 回の Call で、複数の LLM Call フィールドを設定します。手動でインストルメントされたエージェントでは通常、LLM Call の最後に 8 個以上の個別フィールド (input_messages、output_messages、usage、response_id など) を割り当てて、chat span を組み立てます。record(...) はそれらを 1 回のキーワード引数による Call にまとめるため、記録箇所を簡潔に保てます。明示的に渡された (None 以外の) フィールドのみが適用され、既存の値は保持されます。reasoning は Reasoning インスタンスまたは通常の string のいずれも受け入れます (自動的にラップされます) 。チェーンのために self を返します。

`メソッド` `set_attributes`

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

このスパンに任意の OTel 属性を設定します。キーが 1 つでも複数でも、dict を渡してください。キーが 1 つだけの場合は、span.set_attributes({"weave.tag": "value"}) を使用します。これは OTel の Span.set_attributes に対応しています。スパンの開始から終了までの間、つまり with ブロック内で呼び出す必要があります。この範囲外で呼び出しても何も実行されず、警告がログされます。バッチ取り込みの場合は、オブジェクトで宣言されたフィールドに直接値を設定し、それを log_turn / log_conversation に渡してください。

`メソッド` `think`

think(content: 'str') → LLM

推論/思考過程の内容を設定します。

`クラス` `LogResult`

一括 log_* Call の結果。 Pydantic のフィールド:

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

`クラス` `Markdown`

Markdown を表示可能なオブジェクト。 引数:

markup (str): Markdown を含む文字列。
code_theme (str, optional): コードブロック用の Pygments テーマ。デフォルトは “monokai” です。コードテーマについては https://pygments.org/styles/ を参照してください。
justify (JustifyMethod, optional): 段落の justify 値。デフォルトは None です。
style (Union[str, Style], optional): Markdown に適用する任意のスタイル。
hyperlinks (bool, optional): ハイパーリンクを有効にします。デフォルトは True です。

`メソッド` `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

`クラス` `MediaAttachment`

LLM Call に添付されるメディア。常に weave:// コンテンツ ref URI を保持します。生のバイト列、data-URL、およびプレーンな HTTP URI は、ここに格納される前に LLM.attach_media によって公開済みの Content オブジェクトに変換されます。

inline_code_lexer: (str, optional): インラインコードのハイライトが有効な場合に使用するレキサー。デフォルトは None です。
inline_code_theme: (Optional[str], optional): インラインコードのハイライトに使用する Pygments テーマ。ハイライトを無効にする場合は None。デフォルトは None です。 Pydantic のフィールド:
ref: <class 'str'>
modality: <class 'str'>
mime_type: <class 'str'>

`クラス` `Message`

会話内の 1 つのメッセージです。 2 つの構築スタイルがサポートされます。

フラット形式 (後方互換性があり、プレーンテキストで扱いやすい) : Message(role="assistant", content="Hi there")
明示的なパーツ形式 (より高機能で、tool call、推論とテキストの混在、インラインメディアをサポート) : Message(role="assistant", parts=[TextPart(content="Let me check"), ToolCallPart(id="c1", name="get_weather", arguments='{...}')])

parts が空でない場合、これが正規の表現になります。空の場合、シリアライザーはフラットフィールドから単一の TextPart (または role="tool" の場合は ToolCallResponsePart) を生成します。 Pydantic のフィールド:

role: typing.Literal['user', 'assistant', 'system', 'tool']
content: <class 'str'>
tool_call_id: <class 'str'>
tool_name: <class 'str'>
parts: list[typing.Annotated[conversation.types.TextPart | conversation.types.ReasoningPart | conversation.types.ToolCallPart | conversation.types.ToolCallResponsePart | conversation.types.BlobPart | conversation.types.UriPart | conversation.types.FilePart, FieldInfo(annotation=NoneType, required=True, discriminator='type')]]

`クラスメソッド` `assistant`

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

省略可能なテキストと tool Calls を含むアシスタントメッセージを作成します。簡単な返信にはプレーンテキストを使用し、アシスタントが 1 つ以上のツールを要求する場合は tool_calls を渡します。両方を指定した場合、テキストは先頭の TextPart として出力され、その後に各 ToolCallPart が続くため、チャットビューではそれらがインラインで表示されます。

`クラスメソッド` `system`

system(text: 'str') → Message

プレーンテキストからシステムメッセージを生成します。

`クラスメソッド` `tool_result`

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

以前にリクエストされた tool Call のツール結果メッセージを作成します。 output には string、dict、list、スカラー、または None を指定できます。基盤となる ToolCallResponsePart は、文字列以外の値を JSON エンコードします。

`クラスメソッド` `user`

user(text: 'str') → Message

プレーンテキストからユーザーメッセージを作成します。

`クラス` `MessagesPrompt`

`メソッド` `init`

__init__(messages: list[dict])

Pydantic のフィールド:

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

`メソッド` `format`

format(**kwargs: Any) → list

`メソッド` `format_message`

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

テンプレート変数を置き換えて、1つのメッセージを整形します。このメソッドは、実際の整形処理を行うスタンドアロンの format_message_with_template_vars function に委譲します。

`クラスメソッド` `from_obj`

from_obj(obj: WeaveObject) → Self

`クラス` `Model`

入力に対して処理を行うコードとデータの組み合わせを表すことを目的としています。たとえば、プロンプトを使って LLM を呼び出し、予測を行ったりテキストを生成したりできます。モデルを定義する属性やコードを変更すると、その変更はログされ、バージョンが更新されます。これにより、モデルの異なるバージョン間で予測を比較できます。これを使用して、プロンプトを改善したり、最新の LLM を試したり、異なる設定間で予測を比較したりできます。例:

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

     @weave.op
     def predict(self, input_data: str) -> dict:
         # モデルのロジックをここに記述
         prediction = self.attribute1 + ' ' + input_data
         return {'pred': prediction}

Pydantic のフィールド:

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

`メソッド` `get_infer_method`

get_infer_method() → Callable

`クラス` `Monitor`

受信したCallを自動的にスコアリングするモニターを設定します。 op名は、Weave client の entity と project を使って weave ref に変換されることに注意してください。同じ client で複数の Entities と Projects を扱う場合は、完全修飾された weave ref を指定する必要があります。詳しくは _normalized_op_names を参照してください。例:

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

Pydantic のフィールド:

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

`メソッド` `activate`

activate() → ObjectRef

モニターを有効にします。 戻り値: モニターへの参照。

`メソッド` `deactivate`

deactivate() → ObjectRef

モニターを停止します。 戻り値: モニターへの参照。

`クラスメソッド` `from_obj`

from_obj(obj: WeaveObject) → Self

`メソッド` `model_post_init`

model_post_init(context: Any) → None

クライアントを利用できる場合は、構築時に op_names を正規化します。公開時にはオブジェクトごとの hook がないため、素の weave.publish(monitor) (activate() なし) もカバーできるよう、ここで短縮名を展開します。公開を行う場合は通常 weave.init を呼び出しているため、モニターの構築時点でクライアントは設定されています。ユニットテスト、インスペクション、worker で保存済みモニターをデシリアライズする場合など、クライアントなしで構築するユースケースもいくつかあります。get_weave_client() のガードにより、クライアントがなくても構築できます。この場合は正規化は行われませんが、保存済みモニターにはすでに完全な ref が保持されているため、問題ないはずです。 SDK を使う場合、正規化せずにモニターを作成できてしまうエッジケースがあります。ユーザーがモニターを構築してから weave.init を呼び出し、その後に公開する場合です。このユースケースの回避策として、activate() または deactivate() を呼び出すことができます。

`クラス` `Object`

トラッキングとバージョン管理が可能な Weave オブジェクトの基底クラスです。このクラスは Pydantic の BaseModel を拡張し、オブジェクトのトラッキング、参照、シリアライズのための Weave 固有の機能を提供します。オブジェクトには名、説明、参照を設定でき、Weave システムで保存および取得できます。 属性:

name (str | None): オブジェクトの人間が読み取れる名前。
description (str | None): オブジェクトが表す内容の説明。
ref (ObjectRef | None): Weave システム内のオブジェクトへの参照。

例:

# シンプルなオブジェクトを作成する
obj = Object(name="my_object", description="A test object")

# URIからオブジェクトを作成する
obj = Object.from_uri("weave:///entity/project/object:digest")

Pydantic のフィールド:

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

`クラスメソッド` `from_uri`

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

Weave URI からオブジェクトのインスタンスを作成します。 引数:

uri (str): オブジェクトを指す Weave URI。
objectify (bool): 結果をオブジェクト化するかどうか。デフォルトは True です。

戻り値:

Self: URI から生成されたこのクラスのインスタンス。

送出される例外:

NotImplementedError: クラスがデシリアライズに必要なメソッドを実装していない場合。

例:

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

`classmethod` `handle_relocatable_object`

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

ObjectRef や WeaveObject を含む再配置可能なオブジェクトの検証を処理します。このバリデーターは、入力が ObjectRef または WeaveObject で、標準の Object インスタンスに適切に変換する必要がある特別なケースを処理します。検証プロセス中に参照が保持され、無視対象のタイプが正しく処理されるようにします。 引数:

v (Any): 検証する値。
handler (ValidatorFunctionWrapHandler): 標準の pydantic 検証ハンドラー。
info (ValidationInfo): 検証コンテキスト情報。

戻り値:

Any: 検証済みのオブジェクトインスタンス。

例: この method は、オブジェクトの作成時および検証時に自動的に呼び出されます。次のようなケースを処理します: ```python

ObjectRef を渡した場合

obj = MyObject(some_object_ref)

WeaveObject を渡した場合

obj = MyObject(some_weave_object)

---

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

### <kbd>クラスメソッド</kbd> `strip_weave_serialization_metadata`

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

dict 入力から Weave のシリアライズメタデータを削除します。 Weave のシリアライズでは、型を再構成するために dict に _type、_class_name、_bases が追加されます。これらは実際のモデルフィールドではないため、extra=“forbid” を使用する Pydantic の検証前に削除する必要があります。

`クラス` `ObjectRef`

ObjectRef(entity: ‘str’, project: ‘str’, name: ‘str’, _digest: ‘str | Future[str]’, _extra: ‘tuple[str | Future[str], …]’ = ())

`メソッド` `init`

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

`プロパティ` ダイジェスト

`プロパティ` extra

`プロパティ` is_digest_resolved

`method` `as_param_dict`

as_param_dict() → dict

`method` `delete`

delete() → None

`method` `get`

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

`method` `is_descended_from`

is_descended_from(potential_ancestor: 'ObjectRef') → bool

`method` `maybe_parse_uri`

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

`method` `parse_uri`

parse_uri(uri: 'str') → ObjectRef

`method` `with_attr`

with_attr(attr: 'str') → Self

`method` `with_extra`

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

`method` `with_index`

with_index(index: 'int') → Self

`method` `with_item`

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

`method` `with_key`

with_key(key: 'str') → Self

`クラス` `Prompt`

Pydantic のフィールド:

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

`method` `format`

format(**kwargs: Any) → Any

`クラス` `SavedView`

SavedView オブジェクトを扱うための、fluent スタイルのクラスです。

`method` `init`

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

`プロパティ` entity

`プロパティ` label

`プロパティ` project

`プロパティ` view_type

`method` `add_column`

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

`method` `add_columns`

add_columns(*columns: 'str') → SavedView

グリッドに複数の列を簡単に追加できる便利な method です。

`method` `add_filter`

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

`method` `add_sort`

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

`method` `column_index`

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

`method` `filter_op`

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

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

この保存済みビューのフィルターと設定に一致する call を取得します。

`method` `get_known_columns`

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

存在が確認されている列の集合を取得します。

`method` `get_table_columns`

get_table_columns() → list[TableColumn]

`method` `hide_column`

hide_column(col_name: 'str') → SavedView

`method` `insert_column`

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

`クラスメソッド` `load`

load(ref: 'str') → Self

`method` `page_size`

page_size(page_size: 'int') → SavedView

`method` `pin_column_left`

pin_column_left(col_name: 'str') → SavedView

`method` `pin_column_right`

pin_column_right(col_name: 'str') → SavedView

`method` `remove_column`

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

`method` `remove_columns`

remove_columns(*columns: 'str') → SavedView

保存済みビューから列を削除します。

`method` `remove_filter`

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

`method` `remove_filters`

remove_filters() → SavedView

保存済みビューに設定されているフィルターをすべて削除します。

`method` `rename`

rename(label: 'str') → SavedView

`method` `rename_column`

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

`method` `save`

save() → SavedView

保存済みビューをサーバーに公開します。

`method` `set_columns`

set_columns(*columns: 'str') → SavedView

グリッドに表示する列を設定します。

`method` `show_column`

show_column(col_name: 'str') → SavedView

`method` `sort_by`

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

`method` `to_grid`

to_grid(limit: 'int | None' = None) → Grid

`method` `to_rich_table_str`

to_rich_table_str() → str

`method` `ui_url`

ui_url() → str | None

UI でこの保存済みビューを表示するための URL。これは view オブジェクトの URL ではなく、トレースなどが表示される “result” ページの URL である点に注意してください。

`method` `unpin_column`

unpin_column(col_name: 'str') → SavedView

`class` `Scorer`

Pydantic のフィールド:

name: str | None
description: str | None
ref: trace.refs.ObjectRef | None
column_map: dict[str, str] | None

`プロパティ` display_name

`クラスメソッド` `from_obj`

from_obj(obj: WeaveObject) → Self

`method` `model_post_init`

model_post_init(context: Any) → None

`method` `score`

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

`method` `summarize`

summarize(score_rows: list) → dict | None

`クラス` `Session`

:class:weave.Conversation の非推奨エイリアスです。古い session_id / session_name コンストラクタフィールドを受け付け、これらを conversation_id / conversation_name へのプロキシとなる読み書き可能なプロパティとしても公開します。元の Session ではこれらがモデルフィールドだったため、s.session_id を参照または代入する既存のコードも引き続き動作します。

`method` `init`

__init__(**data: 'Any') → None

Pydantic のフィールド:

conversation_id: <class 'str'>
conversation_name: <class 'str'>
agent_name: <class 'str'>
model: <class 'str'>
include_content: <class 'bool'>
continue_parent_trace: <class 'bool'>
attributes: dict[str, typing.Any]

`プロパティ` session_id

:attr:conversation_id の非推奨エイリアスです。

`プロパティ` session_name

:attr:conversation_name の非推奨エイリアスです。

`クラス` `StringPrompt`

`method` `init`

__init__(content: str)

Pydantic のフィールド:

name: str | None
description: str | None
ref: trace.refs.ObjectRef | None
content: <class 'str'>

`method` `format`

format(**kwargs: Any) → str

`クラスメソッド` `from_obj`

from_obj(obj: WeaveObject) → Self

`クラス` `SubAgent`

1 つのターン内で委譲されるエージェント呼び出しです。同じトレース内のネストされた invoke_agent OTel スパンに対応します。 Pydantic のフィールド:

name: <class 'str'>
model: <class 'str'>
agent_id: <class 'str'>
agent_description: <class 'str'>
agent_version: <class 'str'>
system_instructions: list[str]
started_at: datetime.datetime | None
ended_at: datetime.datetime | None

`method` `add_event`

add_event(
    name: 'str',
    attributes: 'dict[str, Any] | None' = None,
    timestamp: 'datetime | None' = None
) → Self

この span 内の特定の時点で、OTel span イベントを記録します。マーカー / ライフサイクルデータ (権限プロンプト (例: weave.permission_request) 、ライフサイクル遷移 (例: spawned / streaming / finished) ) や、span の存続期間中の特定の時点で発生する任意のカスタムマイルストーンに使用します (span 全体に対するプロパティである属性とは異なります) 。 span の開始から終了までの間 (with 内) に呼び出す必要があります。この範囲外では、この呼び出しは no-op となり、警告をログします。

`method` `end`

end() → None

`method` `llm`

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

このサブエージェント内で LLM 呼び出しを開始します。コンテキストマネージャーを使用しているかどうかに関係なく、get_current_llm() から LLM を参照できるように、_current_llm contextvar を設定します。

`method` `record`

record(
    name: 'str | None' = None,
    model: 'str | None' = None,
    system_instructions: 'list[str] | None' = None,
    agent_id: 'str | None' = None,
    agent_description: 'str | None' = None,
    agent_version: 'str | None' = None
) → SubAgent

1 回の呼び出しで複数のサブエージェントフィールドを設定します。手動でインストルメントした agent がサブエージェントに対して通常行う各フィールドの代入 (system_instructions、agent_id など) を、1 回のキーワード呼び出しにまとめます。明示的に渡されたフィールド (None 以外) のみが適用され、既存の値は保持されます。チェーンできるように self を返します。Turn.record / LLM.record と同様の動作です。注: ストリーミング (with) パスでは、サブエージェント span の名前は __enter__ 時点の name から決まります。そのため、span 名にそれを反映させる必要がある場合は、record ではなく start_subagent / turn.subagent で name を設定してください。record を使っても gen_ai.agent.name 属性は更新されます。

`method` `set_attributes`

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

この span に任意の OTel 属性を設定します。キーが 1 つでも複数でも、dict を渡してください。キーが 1 つだけの場合は span.set_attributes({"weave.tag": "value"}) を使用します。これは OTel の Span.set_attributes に対応します。 span の開始から終了までの間、つまり with ブロック内で呼び出す必要があります。この期間外で呼び出しても no-op となり、警告がログされます。バッチ取り込みでは、オブジェクトで宣言されたフィールドに直接値を設定してから、log_turn / log_conversation に渡してください。

`method` `tool`

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

このサブエージェント内でツール実行を開始します。

`クラス` `Table`

`method` `init`

__init__(rows: 'list[dict]') → None

`プロパティ` rows

`method` `append`

append(row: 'dict') → None

表に行を追加します。

`method` `pop`

pop(index: 'int') → None

指定したインデックスにある行を表から削除します。

`class` `ContextAwareThread`

呼び出し元のコンテキストで関数を実行する Thread。これは、スレッド内で Call が期待どおりに動作するようにする threading.Thread のドロップイン置換です。Weave では特定の contextvars が設定されている必要があります (call_context.py を参照) が、新しいスレッドは親からコンテキストを自動ではコピーしないため、Call コンテキストが失われることがあります。これは好ましくありません。このクラスは contextvar のコピーを自動化するので、このスレッドを使うだけで、ユーザーの期待どおりに動作します。このクラスを使わなくても、代わりに次のように書けば同じ効果を得られます。

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

`method` `init`

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

`プロパティ` daemon

このスレッドがデーモンスレッドであるかどうかを示す真偽値です。これは start() が呼び出される前に設定する必要があります。そうしないと RuntimeError が発生します。初期値はこのスレッドを生成したスレッドから継承されます。メインスレッドはデーモンスレッドではないため、メインスレッドで作成されたすべてのスレッドはデフォルトで daemon = False になります。デーモンスレッドだけが残ると、Python プログラム全体は終了します。

`プロパティ` ident

このスレッドの識別子です。まだ開始されていない場合は None になります。これは 0 以外の整数です。get_ident() 関数を参照してください。スレッドが終了して別のスレッドが作成されると、スレッド識別子が再利用されることがあります。この識別子は、スレッドの終了後も利用できます。

`プロパティ` 名

識別のためにのみ使用される文字列です。特別な意味はありません。複数のスレッドに同じ名を付けることができます。初期名はコンストラクタで設定されます。

`プロパティ` native_id

このスレッドのネイティブな整数のスレッド ID です。まだ開始されていない場合は None です。これは 0 以上の整数です。get_native_id() 関数を参照してください。これは、カーネルによって報告されるスレッド ID を表します。

`method` `run`

run() → None

`class` `ThreadContext`

現在のスレッドとターンの情報にアクセスするためのコンテキストオブジェクト。

`method` `init`

__init__(thread_id: 'str | None')

指定したthread_idを使用してThreadContextを初期化します。 引数:

`プロパティ` thread_id

このコンテキストの thread_id を取得します。

thread_id: このコンテキストのスレッド識別子。無効な場合は None。 戻り値: スレッド識別子。スレッドのトラッキングが無効な場合は None。

`プロパティ` turn_id

アクティブなコンテキスト内の現在の turn_id を取得します。 戻り値: 設定されていれば現在の turn_id、設定されていなければ None。

`class` `ContextAwareThreadPoolExecutor`

呼び出し元のコンテキストで関数を実行する ThreadPoolExecutor。これは concurrent.futures.ThreadPoolExecutor のドロップイン置換で、executor 内でも Weave の Call が想定どおりに動作するようにします。Weave では特定の contextvars を設定しておく必要があります (call_context.py を参照) 。しかし、新しいスレッドは親のコンテキストを自動的には引き継がないため、call コンテキストが失われることがあります。これは望ましくありません。このクラスは contextvar のコピーを自動化するので、この executor を使用すれば、ユーザーの期待どおりに「そのまま動作」します。このクラスを使わなくても、代わりに次のように書けば同じ効果を得られます。

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)

`method` `init`

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

`method` `map`

map(
    fn: 'Callable',
    *iterables: 'Iterable[Any]',
    timeout: 'float | None' = None,
    chunksize: 'int' = 1
) → Iterator

`method` `submit`

submit(fn: 'Callable', *args: 'Any', **kwargs: 'Any') → Any

`class` `Tool`

1 回分のツール実行です。execute_tool OTel span に対応します。 arguments と result には JSONString アノテーションが使用されます。呼び出し元は dict / list / scalar を代入でき、SDK は構築時または代入時にそれを JSON エンコードします。保存される値は常に string で、GenAI semconv の wire format と一致します。 Pydantic のフィールド:

name: <class 'str'>
arguments: <class 'str'>
result: <class 'str'>
tool_call_id: <class 'str'>
tool_type: <class 'str'>
tool_description: <class 'str'>
tool_definitions: <class 'str'>
duration_ms: <class 'int'>
started_at: datetime.datetime | None
ended_at: datetime.datetime | None

`method` `add_event`

add_event(
    name: 'str',
    attributes: 'dict[str, Any] | None' = None,
    timestamp: 'datetime | None' = None
) → Self

この span 内の特定の時点で、OTel の span イベントを記録します。マーカーやライフサイクルのデータに使用します。たとえば、権限プロンプト (例: weave.permission_request) 、ライフサイクルの遷移 (例: spawned / streaming / finished) 、または span の存続期間中のある時点で発生する任意の custom マイルストーンなどです (span 全体のプロパティである attribute とは対照的です) 。 span の start から end の間 (with ブロック内) で呼び出す必要があります。この範囲外で呼び出すと、呼び出しは no-op となり、警告をログします。

`method` `end`

end() → None

`method` `set_attributes`

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

この span に任意の OTel 属性を設定します。キーが 1 つでも複数でも、dict を渡してください。キーが 1 つだけの場合は、span.set_attributes({"weave.tag": "value"}) を使用します。これは OTel の Span.set_attributes に対応しています。 span の開始から終了までの間、つまり with ブロック内で呼び出す必要があります。この範囲外で呼び出しても no-op となり、警告がログされます。バッチ取り込みの場合は、オブジェクトで宣言されているフィールドに直接値を設定し、それを log_turn / log_conversation に渡してください。

`class` `Turn`

ユーザーとエージェントの 1 回のやり取りです。invoke_agent の OTel span に対応します。デフォルトでは、各ターンは独自の OTel トレースを開始し (continue_parent_trace=False) 、Agents タブにはターンごとに 1 つのトレースが表示されます。外側のトレースがすでにアクティブで、エージェント呼び出しをその内側にネストしたい場合は、Conversation (または Turn に直接) で continue_parent_trace=True を設定してください。たとえば、fastapi でインストルメントされたリクエスト内の場合です。 Pydantic のフィールド:

agent_name: <class 'str'>
model: <class 'str'>
agent_id: <class 'str'>
agent_description: <class 'str'>
agent_version: <class 'str'>
system_instructions: list[str]
messages: list[conversation.types.Message]
spans: list[conversation.conversation.LLM | conversation.conversation.Tool | conversation.conversation.SubAgent]
continue_parent_trace: <class 'bool'>
started_at: datetime.datetime | None
ended_at: datetime.datetime | None

`method` `add_event`

add_event(
    name: 'str',
    attributes: 'dict[str, Any] | None' = None,
    timestamp: 'datetime | None' = None
) → Self

この span 内の特定の時点で、OTel span イベントを記録します。マーカー / ライフサイクルデータに使用します。たとえば、権限プロンプト (例: weave.permission_request) 、ライフサイクルの遷移 (例: spawned / streaming / finished) 、または span の存続期間中のある時点で発生する任意のカスタムマイルストーンです (span 全体のプロパティである attribute とは異なります) 。 span の開始から終了までの間 (with 内) に呼び出す必要があります。この範囲外では、この呼び出しは no-op となり、警告をログします。

`method` `end`

end() → None

`method` `llm`

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

LLM Call を開始します (このターンの子である chat span) 。コンテキストマネージャーを使用しているかどうかにかかわらず、get_current_llm() を介して LLM にアクセスできるように、contextvar _current_llm を設定します。

`method` `model_post_init`

model_post_init(context: 'Any') → None

`method` `record`

record(
    messages: 'list[Message] | None' = None,
    system_instructions: 'list[str] | None' = None,
    agent_name: 'str | None' = None,
    model: 'str | None' = None,
    agent_id: 'str | None' = None,
    agent_description: 'str | None' = None,
    agent_version: 'str | None' = None
) → Turn

1 回の呼び出しで複数のターンフィールドを設定します。手動でインストルメントしたエージェントが通常はターンに対してフィールドごとに行う代入 (system_instructions、agent_id、…) を、1 回のキーワード呼び出しにまとめます。明示的に渡された (None ではない) フィールドのみが適用され、既存の値は保持されます。messages はターンの既存のメッセージを置き換えます (単一のメッセージを追加する Turn.user(...) とは異なります) 。チェーン用に self を返します。LLM.record に対応しています。注: ストリーミング (with) パスでは、ターン span の名前は __enter__ 時点で agent_name から設定されます。そのため、span 名にこれを反映させる必要がある場合は、record ではなく start_turn で agent_name を設定してください。なお、record でも gen_ai.agent.name 属性は更新されます。

`method` `set_attributes`

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

この span に任意の OTel 属性を設定します。キーが 1 つでも複数でも、dict を渡してください。キーが 1 つだけの場合は、span.set_attributes({"weave.tag": "value"}) を使用します。これは OTel の Span.set_attributes に対応しています。 span の開始から終了までの間、つまり with ブロック内で呼び出す必要があります。この範囲外で呼び出しても no-op となり、警告がログされます。バッチ取り込みの場合は、オブジェクトで宣言されているフィールドを直接設定し、それを log_turn / log_conversation に渡してください。

`method` `subagent`

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

サブエージェントの呼び出しを開始します (同じトレース内のネストされた invoke_agent span) 。

`method` `tool`

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

ツール実行を開始します (このターンの子である execute_tool span) 。

`method` `user`

user(content: 'str') → Turn

ターンの途中でユーザーメッセージを追加します。

`class` `Usage`

LLM Call における token 使用量です。 Pydantic のフィールド:

input_tokens: <class 'int'>
output_tokens: <class 'int'>
reasoning_tokens: <class 'int'>
cache_creation_input_tokens: <class 'int'>
cache_read_input_tokens: <class 'int'>

`関数` `add_tags`

add_tags(obj_ref: 'ObjectRef | str', tags: 'list[str]') → None

オブジェクトのバージョンにタグを追加します。 引数:

`関数` `as_op`

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

@weave.op でデコレートされた関数を受け取り、その Op を返します。 @weave.op でデコレートされた関数はすでに Op のインスタンスであるため、この関数は実行時には実質的に何もしません。ただし、OpDef の属性に型安全にアクセスする必要がある場合は、型チェッカーを満たす目的で使用できます。

obj_ref: オブジェクトのバージョンへの参照。ObjectRef (weave.publish() によって返される) または weave /// URI 文字列のいずれかです。
tags: 追加するタグ文字列のリスト。 引数:
fn: @weave.op でデコレートされた関数。 戻り値: 関数の Op。

`関数` `attributes`

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

Call に属性を設定するコンテキストマネージャー。例:

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

`関数` `end_conversation`

end_conversation() → None

現在の会話を終了します (contextvarから) 。

`関数` `end_llm`

end_llm() → None

contextvar から取得した現在の LLM Call を終了します。

`関数` `end_session`

end_session() → None

:func:weave.end_conversation の非推奨エイリアスです。

`関数` `end_turn`

end_turn() → None

contextvar から現在のターンを終了します。

`関数` `finish`

finish() → None

Weave へのログ記録を停止します。 finish の実行後は、weave.op でデコレートされた関数の call はログされなくなります。ログ記録を再開するには、weave.init() をもう一度実行する必要があります。

`関数` `get`

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

URI からオブジェクトを取得するための便利な関数です。 Weave でログされた多くのオブジェクトは、自動的に Weave サーバーに登録されます。この関数を使うと、それらのオブジェクトを URI から取得できます。 引数:

uri: 完全修飾された Weave ref URI。 戻り値: オブジェクト。

例:

weave.init("weave_get_example")
dataset = weave.Dataset(rows=[{"a": 1, "b": 2}])
ref = weave.publish(dataset)

dataset2 = weave.get(ref)  # datasetと同じ！

`関数` `get_aliases`

get_aliases(obj_ref: 'ObjectRef | str') → list[str]

オブジェクトのバージョンのエイリアスを取得します。 引数:

obj_ref: オブジェクトのバージョンへの参照。ObjectRef または weave:/// URI 文字列を指定します。 戻り値: エイリアス文字列のリストです。

`関数` `get_client`

get_client() → WeaveClient | None

`関数` `get_current_call`

get_current_call() → Call | None

現在実行中の Op の内部で、その Op の Call オブジェクトを取得します。 戻り値: 現在実行中の Op の Call オブジェクト。トラッキングが初期化されていない場合、またはこの method が Op の外で呼び出された場合は None です。 注記:

返された Call の attributes dict は、call が開始されると不変になります。Op を呼び出す前に call のメタデータを設定するには、:func:weave.attributes を使用してください。summary フィールドは Op の実行中に更新でき、call の終了時に計算された summary 情報とマージされます。

`関数` `get_current_conversation`

get_current_conversation() → Conversation | None

contextvar からアクティブな会話を返します。ない場合は None を返します。

`関数` `get_current_llm`

get_current_llm() → LLM | None

contextvar からアクティブな LLM Call を返します。なければ None を返します。

`関数` `get_current_session`

get_current_session() → Conversation | None

:func:weave.get_current_conversation の非推奨エイリアスです。

`関数` `get_current_turn`

get_current_turn() → Turn | None

contextvar から現在アクティブな turn を返します。存在しない場合は None を返します。

`関数` `get_tags`

get_tags(obj_ref: 'ObjectRef | str') → list[str]

オブジェクトのバージョンのタグを取得します。 引数:

obj_ref: オブジェクトのバージョンへの参照。ObjectRef または weave /// URI 文字列を指定します。 戻り値: タグ文字列のリストです。

`関数` `get_tags_and_aliases`

get_tags_and_aliases(obj_ref: 'ObjectRef | str') → tuple[list[str], list[str]]

オブジェクトのバージョンのタグとエイリアスを、1回の Call でまとめて取得します。 引数:

obj_ref: オブジェクトのバージョンへの参照です。ObjectRef または weave /// URI 文字列を指定します。 戻り値: (タグ, エイリアス) のタプルです。どちらも文字列のリストです。

`関数` `init`

init(
    project_name: 'str',
    settings: 'UserSettings | dict[str, Any] | None' = None,
    autopatch_settings: 'AutopatchSettings | None' = None,
    postprocess_inputs: 'PostprocessInputsFunc | None' = None,
    postprocess_output: 'PostprocessOutputFunc | None' = None,
    attributes: 'dict[str, Any] | None' = None,
    global_postprocess_inputs: 'PostprocessInputsFunc | None' = None,
    global_postprocess_output: 'PostprocessOutputFunc | None' = None,
    global_attributes: 'dict[str, Any] | None' = None
) → WeaveClient

Weave のトラッキングを初期化し、wandb プロジェクトにログします。ログはグローバルに初期化されるため、init の戻り値への参照を保持しておく必要はありません。 init の実行後、weave.op でデコレートされた関数の Call は、指定したプロジェクトにログされます。 引数: 注: クライアントレベルの後処理は、各 op 独自の後処理の後に実行されます。順序は常に次のとおりです: 1. op 固有の後処理 2. クライアントレベルの後処理

project_name: ログ先の Weights & Biases のチーム名と project 名です。チームを指定しない場合は、デフォルトの entity が使用されます。デフォルトの entity を確認または更新するには、W&B Models ドキュメントの User Settings を参照してください。
settings: Weave クライアント全般の設定です。UserSettings インスタンス、または次のいずれかのキーを含む dict (いずれも省略可能) を指定できます。すべての設定は、接頭辞 WEAVE_ を使用する環境変数でも設定できます (例: WEAVE_DISABLED=true) 。使用可能な設定: - disabled (bool): すべての関数でトレースを無効にします。デフォルト: False - print_call_link (bool): ops について、Weave UI へのリンクをターミナルに出力します。デフォルト: True - log_level (str): ログする情報の種類を設定します (DEBUG, INFO, WARNING, ERROR, CRITICAL) 。デフォルト: INFO - display_viewer (str): Weave がコンソールでオブジェクトをどのように表示するかを制御します (auto, rich, print) 。デフォルト: auto - capture_code (bool): トレース対象の ops のコードを Weave プロジェクトに取得します。デフォルト: True - implicitly_patch_integrations (bool): サポートされるライブラリに自動的にパッチを適用します。デフォルト: True - redact_pii (bool): メールアドレス、電話番号、クレジットカードなどの機密情報がないか、すべてのトレースデータをスキャンし、サーバーに送信する前にプレースホルダー値に置き換えます。presidio-analyzer パッケージと presidio-anonymizer パッケージが必要です。
Default: False - redact_pii_fields (list[str]): redact_pii が True の場合に、マスクする PII エンティティのタイプを指定します。空の場合は、Presidio のデフォルトセットを使用します。例 [‘EMAIL’,‘PHONE_NUMBER’,‘CREDIT_CARD’,‘US_SSN’]。完全なリストは https://microsoft.github.io/presidio/supported_entities/ を参照してください
Default: [] - redact_pii_exclude_fields (list[str]): 除外する PII エンティティタイプ。Default: [] - capture_client_info (bool): Python/SDK のバージョン情報を取得します。Default: True - capture_system_info (bool): OS 情報を取得します。Default: True - client_parallelism (int): バックグラウンド Ops 用ワーカーの数。Default: auto - use_server_cache (bool): サーバー応答のローカルディスクキャッシュを有効にします。 - server_cache_size_limit (int): バイト単位のキャッシュサイズの上限。Default: 1_000_000_000 - server_cache_dir (str): サーバーキャッシュ用のディレクトリ。Default: temporary - scorers_dir (str): Scorer モデルチェックポイント用のディレクトリ。Default: ~/.cache/wandb/weave-scorers - max_calls_queue_size (int): キューの最大サイズ (0 = 無制限) 。Default: 100_000 - retry_max_interval (float): 再試行の最大間隔 (秒) 。Default: 300 - retry_max_attempts (int): 最大再試行回数。Default: 3 - enable_disk_fallback (bool): 破棄された項目をディスクに書き込みます。Default: True - use_parallel_table_upload (bool): 大きな表の並列チャンク upload を有効にします。False の場合、表はより小さなチャンクに分けて順次 upload されます。
Default: True - http_timeout (float): HTTP リクエストの完了を待機する最大時間 (秒) です。これには、接続時間、データ転送時間、サーバーでの処理時間が含まれます。ネットワークが低速な場合や、大きなペイロードを扱う場合は、この値を増やしてください。
Default: 30.0 - use_stainless_server (bool): より高い型安全性、自動リトライ、改善されたエラー処理を備えた、Stainless 生成の HTTP クライアントを使用します。これは実験的な機能であり、将来のバージョンではデフォルトになる可能性があります。
Default: False - use_calls_complete (bool): 開始/終了を個別にリクエストする代わりに、完了した Call データ (開始と終了) を 1 つのリクエストにまとめて送信する、最適化された書き込みパスを使用します。これによりサーバー負荷が軽減され、特に短時間で終了する Ops でパフォーマンスが向上します。
Default: True - use_otel_v2: (bool): OTel 対応インテグレーションを、それぞれの OTel バリアント経由でルーティングします。
Default: True
autopatch_settings: (非推奨) autopatch インテグレーションの設定です。代わりに、明示的にパッチを適用してください。
postprocess_inputs: このクライアントによってトレースされるすべての op の入力に適用される関数。
postprocess_output: このクライアントがトレースする各 op の出力に適用される関数。
attributes: このクライアントによって生成されるすべての trace に適用される属性の辞書。 戻り値: Weave クライアント。

`関数` `link_prompt_to_registry`

link_prompt_to_registry(
    prompt: 'LinkablePrompt',
    target_path: 'str',
    aliases: 'Sequence[str] | None' = None
) → LinkAssetToRegistryRes

公開済みのpromptバージョンをRegistryにリンクします。 引数:

prompt: 公開済みのprompt、ObjectRef、または完全修飾された weave ///… URI string。
target_path: <registry_project>/<portfolio_name> 形式のRegistryの宛先パス。例: wandb-registry-prompts/my-prompt-collection。
aliases: 作成されるRegistryバージョンに付与するオプションのエイリアス。 戻り値:
LinkAssetToRegistryRes: registry-link endpoint からのパース済みレスポンス。

`関数` `list_aliases`

list_aliases() → list[str]

プロジェクト内のすべての重複のないエイリアスを一覧表示します。 戻り値: プロジェクト内のすべてのエイリアス文字列をソートしたリスト。

list_tags() → list[str]

プロジェクト内のすべての重複しないタグを一覧表示します。 戻り値: プロジェクト内のすべてのタグ文字列をソートしたリスト。

`関数` `log_call`

log_call(
    op: 'str',
    inputs: 'dict[str, Any]',
    output: 'Any',
    parent: 'Call | None' = None,
    attributes: 'dict[str, Any] | None' = None,
    display_name: 'str | Callable[[Call], str] | None' = None,
    use_stack: 'bool' = True,
    exception: 'BaseException | None' = None
) → Call

デコレーターパターンを使用せずに、call を Weave に直接ログします。この関数は、オペレーションを Weave にログするための命令型 API を提供します。すでに実行済みの call をあとからログしたい場合や、ユースケースにデコレーターパターンが適していない場合に便利です。 引数:

op (str): ログするオペレーション名です。これは、その call の op_name として使用されます。匿名オペレーション (公開済みの ops を参照しない文字列) もサポートされます。
inputs (dict[str, Any]): オペレーションの入力パラメーターを格納した辞書です。
output (Any): オペレーションの出力 / 結果です。
parent (Call | None): この call をネストするための省略可能な親 call です。指定しない場合、この call はルートレベルの call になります (現在の call コンテキストが存在する場合は、その下にネストされます) 。デフォルトは None です。
attributes (dict[str, Any] | None): call に付加する省略可能なメタデータです。これらは call の作成後に固定されます。デフォルトは None です。
display_name (str | Callable[[Call], str] | None): UI で call に表示する省略可能な表示名です。文字列、または call を受け取って文字列を返す callable を指定できます。デフォルトは None です。
use_stack (bool): call をランタイムスタックに積むかどうかです。True の場合、call は call コンテキスト内で利用可能になり、weave.require_current_call() でアクセスできます。False の場合、call はログされますが、call スタックには追加されません。デフォルトは True です。
exception (BaseException | None): オペレーションが失敗した場合にログする省略可能な例外です。デフォルトは None です。

戻り値:

Call: 完全なトレース情報を含む、作成および完了済みの Call オブジェクトです。

例: 基本的な使用方法:

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  # call スタックに追加しない
    ... )

---

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

### <kbd>関数</kbd> `log_conversation`

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

命令型で完全な会話を出力します。各 Turn の.spans属性には、その子要素が含まれます。conversation_idが空の場合は自動生成されます。デフォルトでは、各 turn はそれぞれ独自の OTel trace を持ちます。agent_name / modelは会話レベルのデフォルトです。Turn 自身の値が優先され、Turn 側で空の場合にのみ会話の値が補完されます。会話のcontinue_parent_traceはすべての turn に適用されます (Turn ごとのcontinue_parent_traceは、意図的にここでは無効になります) 。 attributesは、出力されるすべてのスパンに付与されます。カスタムの semconv 以外のキーを使用してください。スパン自身のgen_ai.* / weave.*属性と競合するキーはサポートされません (どちらの値が優先されるかはパスによって異なります) 。

`function` `log_session`

log_session(
    turns: 'list[Turn]',
    session_id: 'str' = '',
    session_name: 'str' = '',
    agent_name: 'str' = '',
    model: 'str' = '',
    include_content: 'bool' = True,
    continue_parent_trace: 'bool' = False,
    attributes: 'Attributes' = None
) → LogResult

:func:weave.log_conversation の非推奨エイリアスです。 session_id / session_name は conversation_id / conversation_name に対応します。

`関数` `log_turn`

log_turn(
    conversation_id: 'str',
    agent_name: 'str' = '',
    conversation_name: 'str' = '',
    model: 'str' = '',
    agent_id: 'str' = '',
    agent_description: 'str' = '',
    agent_version: 'str' = '',
    messages: 'list[Message] | None' = None,
    system_instructions: 'list[str] | None' = None,
    spans: 'list[LLM | Tool | SubAgent] | None' = None,
    started_at: 'datetime | None' = None,
    ended_at: 'datetime | None' = None,
    include_content: 'bool' = True,
    continue_parent_trace: 'bool' = False,
    attributes: 'Attributes' = None
) → LogResult

命令的に 1 つの turn とその子スパンを OTel に送出します。コンテキストマネージャーを使用できない場合 (ステートレスなコンテナー、コールバック、キューワーカー) に使用します。渡す各子スパンには started_at / ended_at を設定しておく必要があります。送出される OTel スパンの Timestamp は、これらのフィールドから取得されます。turn 自身で値が指定されていない場合は、最も早い/遅い子の Timestamp が使用され、それもない場合は now() にフォールバックします。エージェントのアイデンティティフィールド (agent_id / agent_description / agent_version) は、ストリーミングパスと同じです。 attributes は、送出されるすべてのスパンに付与されます。ストリーミングパスでは、代わりにこれらをアクティブな会話から読み取ります。独自の、semconv ではないキーを使用してください。スパン自身の gen_ai.* / weave.* 属性と競合するキーはサポートされません (どちらの値が優先されるかはパスによって異なります)。

`関数` `op`

op(
    func: 'Callable[P, R] | None' = None,
    name: 'str | None' = None,
    call_display_name: 'str | CallDisplayNameFunc | None' = None,
    postprocess_inputs: 'PostprocessInputsFunc | None' = None,
    postprocess_output: 'PostprocessOutputFunc | None' = None,
    tracing_sample_rate: 'float' = 1.0,
    enable_code_capture: 'bool' = True,
    accumulator: 'Callable[[Any | None, Any], Any] | None' = None,
    kind: 'OpKind | None' = None,
    color: 'OpColor | None' = None,
    attributes: 'dict[str, Any] | None' = None,
    eager_call_start: 'bool' = False
) → Callable[[Callable[P, R]], Op[P, R]] | Op[P, R]

関数またはmethodを Weave の op に変換するデコレータです。sync と async の両方に対応しています。イテレータ関数を自動的に検出し、適切な動作を適用します。 引数:

`関数` `otel_traces_endpoint`

otel_traces_endpoint(base_url: str | None = None) → str

Weave GenAI トレース取り込み用の完全な OTLP HTTP エンドポイント URL を返します。外部の呼び出し元 (たとえば、BatchSpanProcessor がエクスポートを暗黙的に破棄することに任せる前に、取り込みエンドポイントに到達可能かどうかを検証したい起動時プローブなど) は、URL を手作業で組み立てるのではなく、これを呼び出してください。このパスは SDK が管理しており、変更される可能性があります。

func: デコレートする関数。
name: op のカスタム名。デフォルトは関数名です。
call_display_name: Call の表示名。文字列または callable を指定できます。
postprocess_inputs: ログする前に入力を変換する関数。
postprocess_output: ログする前に出力を変換する関数。
tracing_sample_rate: トレースする Call の割合 (0.0～1.0) 。
enable_code_capture: この op のソースコードを取得するかどうか。
accumulator: ストリーミング op の結果を蓄積する関数。
attributes: この op が作成するすべての Call に、最も低い優先順位でマージされるデフォルトの属性です。weave.attributes() コンテキストおよび明示的な Call ごとの属性は、キーが衝突した場合にこれらより優先されます。予約済みの “weave” キーはここでは設定できません。
eager_call_start: True の場合、Call の開始はバッチ処理されず、すぐに送信されます。評価のように実行時間の長い operation を UI にすぐ表示する必要がある場合に便利です。 引数:

`関数` `publish`

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

Python オブジェクトを保存し、バージョン管理します。オブジェクトの名がすでに存在し、そのコンテンツハッシュがそのオブジェクトの最新バージョンと一致しない場合、Weave はそのオブジェクトの新しいバージョンを作成します。

base_url: トレースサーバーのベース URL。デフォルトは weave_trace_server_url() です。 引数:
obj: 保存してバージョン管理するオブジェクト。
name: オブジェクトの保存時に使用する名。
tags: 公開されたオブジェクトバージョンに追加する任意のタグのリスト。
aliases: 公開されたオブジェクトバージョンに設定する任意のエイリアスのリスト。 戻り値: 保存されたオブジェクトへの Weave Ref。

`関数` `ref`

ref(location: 'str') → ObjectRef

既存の Weave オブジェクトへの Ref を作成します。オブジェクト自体を直接取得するわけではありませんが、他の Weave API 関数に渡せるようになります。 引数:

location: Weave Ref URI、または weave.init() が呼び出されている場合は name:version もしくは name。バージョンが指定されていない場合は latest が使用されます。 戻り値: オブジェクトを指す Weave Ref。

`関数` `remove_aliases`

remove_aliases(obj_ref: 'ObjectRef | str', alias: 'str | list[str]') → None

オブジェクトから1つ以上のエイリアスを削除します。 引数:

`関数` `remove_tags`

remove_tags(obj_ref: 'ObjectRef | str', tags: 'list[str]') → None

オブジェクトのバージョンからタグを削除します。

obj_ref: オブジェクトへの参照です。ObjectRef または weave /// URI 文字列を指定します。
alias: 削除するエイリアス名、またはエイリアス名のリストです。 引数:

`関数` `require_current_call`

require_current_call() → Call

現在実行中の Op の内部で、その Op に対応する Call オブジェクトを取得します。これにより、実行中でも id や feedback などの Call の属性にアクセスできます。

@weave.op
def hello(name: str) -> None:
     print(f"Hello {name}!")
     current_call = weave.require_current_call()
     print(current_call.id)

Op の実行後でも、Call にアクセスできます。 Call の ID があれば (UI で確認したものなど) 、weave.init が返す WeaveClient の get_call method を使用して、Call オブジェクトを取得できます。

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

あるいは、Op を定義した後にその call method を使用することもできます。例:

@weave.op
def add(a: int, b: int) -> int:
     return a + b

result, call = add.call(1, 2)
print(call.id)

obj_ref: オブジェクトのバージョンへの参照。ObjectRef または weave /// URI 文字列のいずれかです。
tags: 削除するタグ文字列のリスト。 戻り値: 現在実行中の Op の Call オブジェクト

発生する例外:

NoCurrentCallError: トラッキングが初期化されていない場合、またはこの method が Op の外で呼び出された場合。

`関数` `set_aliases`

set_aliases(obj_ref: 'ObjectRef | str', alias: 'str | list[str]') → None

オブジェクトのバージョンに1つ以上のエイリアスを設定します。 引数:

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

現在のcall summaryの_weave.views.<name>にカスタムviewを追加します。

obj_ref: オブジェクトのバージョンへの参照。ObjectRef または weave /// URI 文字列のいずれかです。
alias: 設定するエイリアス名、またはエイリアス名のリスト (例: “production”) 。 引数:
name: viewの名前 (summary._weave.views 配下のキー) 。
content: weave.Content インスタンス、または生の文字列。文字列は、指定された拡張子またはMIMEタイプを使用して Content.from_text でラップされます。
extension: content が文字列の場合に使用するオプションのファイル拡張子。
mimetype: content が文字列の場合に使用するオプションのMIMEタイプ。
metadata: テキストから Content を作成する際に付加するオプションのメタデータ。
encoding: テキストから Content を作成する際に適用するテキストエンコーディング。 戻り値: なし

例: import weave

weave.init(“proj”) @weave.op … def foo(): … weave.set_view(“readme”, ”# Hello”, extension=“md”) … return 1 foo()

`function` `start_conversation`

start_conversation(
    agent_name: 'str' = '',
    model: 'str' = '',
    conversation_id: 'str' = '',
    conversation_name: 'str' = '',
    include_content: 'bool' = True,
    continue_parent_trace: 'bool' = False,
    attributes: 'Attributes' = None
) → Conversation

会話を作成してアクティブ化します。モジュールをまたいでアクセスできるように contextvar を設定します。 attributes は、この会話が生成するすべてのスパンに付与されます (例: weave.integration.* のようなインテグレーションのアイデンティティ) 。カスタムの非 semconv キーを使用してください。semantic-convention フィールドは、型付きパラメータ (conversation_name、model、…) で設定します。スパン自身の gen_ai.* / weave.* 属性と衝突するキーはサポートされません。どちらの値が優先されるかは経路依存です (ストリーミングか log_turn かによって異なります) 。

`関数` `start_llm`

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

LLM call を作成して有効化します。利用可能であれば現在の turn を使用します。アクティブな turn がない場合は、切り離された状態の LLM (contextvar は設定されません) を返します。 provider_name は明示的に渡してください。SDK はモデル ID からこれを推論しません。接頭辞ベースの推測では、ユーザーが Fine-tune したモデル (例: text-... という名前のモデル) を誤って判定し、将来のモデル名に関する前提を telemetry に組み込んでしまうため、事後に修正するコストが高くなります。

`関数` `start_session`

start_session(
    agent_name: 'str' = '',
    model: 'str' = '',
    session_id: 'str' = '',
    session_name: 'str' = '',
    include_content: 'bool' = True,
    continue_parent_trace: 'bool' = False,
    attributes: 'Attributes' = None
) → Conversation

:func:weave.start_conversation の非推奨エイリアスです。 session_id / session_name は conversation_id / conversation_name にマッピングされます。

`function` `start_subagent`

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

サブエージェント呼び出し用のスパンを作成します。 SubAgent の OTel スパンは、OTel コンテキスト内で現在アクティブなスパンの子として自動的に設定されます。通常、Turn スパンがアクティブであれば、その子になります。形は start_tool と同様で、親子関係の伝播は OTel コンテキストが処理するため、明示的な委譲は不要です。

`関数` `start_tool`

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

ツール実行スパンを作成します。 Tool の OTel スパンは、OTel コンテキスト内の現在のスパンの子として自動的に設定されます。通常、アクティブな Turn スパンがある場合は、その子になります。turn を明示的に委譲する必要はありません。親子関係の伝播は Conversation SDK の contextvars ではなく、OTel コンテキストを通じて行われます。

`関数` `start_turn`

start_turn(
    user_message: 'str' = '',
    model: 'str' = '',
    agent_name: 'str' = '',
    system_instructions: 'list[str] | None' = None
) → Turn

turn を作成してアクティブ化します。利用可能な場合は、現在の会話を使用します。アクティブな会話がない場合は、contextvar に設定されない、切り離された Turn を返します。つまり、get_current_turn() は None を返します。contextvar ベースでモジュール間アクセスを行う必要がある場合は、代わりに conversation.start_turn() を使用してください。

`関数` `thread`

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

コンテキスト内のcallに thread_id を設定するためのコンテキストマネージャー。例：

# thread_id を自動生成する
with weave.thread() as t:
     print(f"Thread ID: {t.thread_id}")
     result = my_function("input")  # この call には自動生成された thread_id が付与される
     print(f"Current turn: {t.turn_id}")

# thread_id を明示的に指定する
with weave.thread("custom_thread") as t:
     result = my_function("input")  # この call には thread_id="custom_thread" が付与される

# スレッド追跡を無効にする
with weave.thread(None) as t:
     result = my_function("input")  # この call には thread_id=None が付与される

引数:

thread_id: このコンテキストで Call に関連付けるスレッド識別子。指定しない場合は、UUID v7 が自動生成されます。None の場合は、スレッドのトラッキングが無効化されます。 返される値:
ThreadContext: thread_id と現在の turn_id にアクセスできるオブジェクト。

`関数` `wandb_init_hook`

wandb_init_hook() → None

概要

feedback

⌘I

​API 概要

​クラス Agent

​method step

​クラス AgentState

​クラス AnnotationSpec

​クラスメソッド preprocess_field_schema

​クラスメソッド validate_field_schema

​method value_is_valid

​クラス Audio

​method __init__

​method export

​クラスメソッド from_data

​クラスメソッド from_path

​クラス ClassifierMonitor

​method activate

​method deactivate

​クラスメソッド from_obj

​method get_prompt_footer

​method get_prompt_header

​method model_post_init

​クラス Content

​method __init__

​プロパティ art

​プロパティ ref

​method as_string

​クラスメソッド from_base64

​クラスメソッド from_bytes

​クラスメソッド from_data_url

​クラスメソッド from_path

​クラスメソッド from_text

​クラスメソッド from_url

​クラスメソッド model_validate

​クラスメソッド model_validate_json

​method open

​method save

​method serialize_data

​method to_data_url

​クラス Conversation

​method end

​method model_post_init

​method start_turn

​クラス Dataset

​method add_rows

​クラスメソッド convert_to_table

​クラスメソッド from_calls

​クラスメソッド from_hf

​クラスメソッド from_obj

​クラスメソッド from_pandas

​method select

​method to_hf

​method to_pandas

​クラス EasyPrompt

​method __init__

​プロパティ as_str

​プロパティ is_bound

​プロパティ messages

​プロパティ プレースホルダー

​プロパティ system_message

​プロパティ system_prompt

​プロパティ unbound_placeholders

​method append

​method as_dict

​method as_pydantic_dict

​method bind

​method bind_rows

​method config_table

​method configure

​method dump

​method dump_file

​method format

​クラスメソッド from_obj

​クラスメソッド load

​クラスメソッド load_file

​method messages_table

​method print

​method publish

​method require

​method run

​method validate_requirement

​method validate_requirements

API 概要

`クラス` `Agent`

`method` `step`

`クラス` `AgentState`

`クラス` `AnnotationSpec`

`クラスメソッド` `preprocess_field_schema`

`クラスメソッド` `validate_field_schema`

`method` `value_is_valid`

`クラス` `Audio`

`method` `init`

`method` `export`

`クラスメソッド` `from_data`

`クラスメソッド` `from_path`

`クラス` `ClassifierMonitor`

`method` `activate`

`method` `deactivate`

`クラスメソッド` `from_obj`

`method` `get_prompt_footer`

`method` `get_prompt_header`

`method` `model_post_init`

`クラス` `Content`

`method` `init`

`プロパティ` art

`プロパティ` ref

`method` `as_string`

`クラスメソッド` `from_base64`

`クラスメソッド` `from_bytes`

`クラスメソッド` `from_data_url`

`クラスメソッド` `from_path`

`クラスメソッド` `from_text`

`クラスメソッド` `from_url`

`クラスメソッド` `model_validate`

`クラスメソッド` `model_validate_json`

`method` `open`

`method` `save`

`method` `serialize_data`

`method` `to_data_url`

`クラス` `Conversation`

`method` `end`

`method` `model_post_init`

`method` `start_turn`

`クラス` `Dataset`

`method` `add_rows`

`クラスメソッド` `convert_to_table`

`クラスメソッド` `from_calls`

`クラスメソッド` `from_hf`

`クラスメソッド` `from_obj`

`クラスメソッド` `from_pandas`

`method` `select`

`method` `to_hf`

`method` `to_pandas`

`クラス` `EasyPrompt`

`method` `init`

`プロパティ` as_str

`プロパティ` is_bound

`プロパティ` messages

`プロパティ` プレースホルダー

`プロパティ` system_message

`プロパティ` system_prompt

`プロパティ` unbound_placeholders

`method` `append`

`method` `as_dict`

`method` `as_pydantic_dict`

`method` `bind`

`method` `bind_rows`

`method` `config_table`

`method` `configure`

`method` `dump`

`method` `dump_file`

`method` `format`

`クラスメソッド` `from_obj`

`クラスメソッド` `load`

`クラスメソッド` `load_file`

`method` `messages_table`

`method` `print`

`method` `publish`

`method` `require`

`method` `run`

`method` `validate_requirement`

`method` `validate_requirements`