API 개요

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

`메서드` `step`

step(state: AgentState) → AgentState

에이전트의 단일 스텝을 실행합니다. 인수(Args):

state: 환경의 현재 상태입니다.
action: 수행할 동작입니다.

반환값(Returns): 환경의 새로운 상태입니다.

원문

`class` `AgentState`

Pydantic 필드:

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

원문

`class` `AnnotationSpec`

Pydantic 필드:

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

원문

`classmethod` `preprocess_field_schema`

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

원문

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

원문

`class` `Audio`

지원되는 형식(wav 또는 mp3)의 오디오 데이터를 나타내는 클래스입니다. 이 클래스는 오디오 데이터 저장을 처리하며, 다양한 소스에서 로드하고 파일로 내보내기 위한 메서드를 제공합니다. Attributes:

format: 오디오 형식(현재 ‘wav’ 또는 ‘mp3’ 지원)
data: 바이트 형태의 원시 오디오 데이터

Args:

data: 오디오 데이터(바이트 또는 base64로 인코딩된 문자열)
format: 오디오 형식(‘wav’ 또는 ‘mp3’)
validate_base64: 입력 데이터를 base64로 디코딩할지 여부 Raises:
ValueError: 오디오 데이터가 비어 있거나 형식이 지원되지 않는 경우

원문

`메서드` `init`

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

원문

`메서드` `export`

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

오디오 데이터를 파일로 내보냅니다. 인수:

원문

`classmethod` `from_data`

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

원시 데이터와 지정된 형식에서 Audio 객체를 생성합니다.

path: 오디오 파일이 저장될 경로 Args:
data: 바이트 또는 base64 인코딩 문자열 형태의 오디오 데이터
format: 오디오 형식 (‘wav’ 또는 ‘mp3’) Returns:
Audio: 새 Audio 인스턴스

Raises:

ValueError: 형식이 지원되지 않는 경우

원문

`classmethod` `from_path`

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

파일 경로에서 Audio 객체를 생성합니다. 매개변수:

path: 오디오 파일의 경로 (.wav 또는 .mp3 확장자여야 함)

반환값:

Audio: 파일에서 로드된 새로운 Audio 인스턴스

예외:

ValueError: 파일이 존재하지 않거나 지원되지 않는 확장자인 경우

원문

`class` `Content`

여러 소스에서 가져온 콘텐츠를 표현하고, 이를 관련 메타데이터와 함께 통합된 바이트 기반 표현으로 변환하기 위한 클래스입니다. 이 클래스는 다음 클래스 메서드 중 하나를 사용하여 인스턴스를 생성해야 합니다:

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

원문

`메서드` `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

`property` ref

원문

`메서드` `as_string`

as_string() → str

데이터를 문자열로 표시합니다. 바이트는 encoding 속성을 사용해 디코딩됩니다. base64로 인코딩된 경우, 데이터는 base64 바이트로 다시 인코딩된 후 ASCII 문자열로 디코딩됩니다. 반환값: str.

원문

`classmethod` `from_base64`

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

base64로 인코딩된 문자열 또는 bytes 객체에서 Content를 초기화합니다.

원문

`classmethod` `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를 초기화합니다.

원문

`classmethod` `from_data_url`

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

데이터 URL에서 Content 객체를 초기화합니다.

원문

`classmethod` `from_path`

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

로컬 파일 경로를 이용해 Content를 초기화합니다.

원문

`classmethod` `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를 초기화합니다.

원문

`classmethod` `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 객체를 생성합니다.

원문

`classmethod` `model_validate`

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

dict로부터 Content를 재구성할 수 있도록 model_validate를 오버라이드합니다.

원문

`classmethod` `model_validate_json`

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

JSON으로부터 Content를 재구성할 수 있도록 model_validate_json을 오버라이드합니다.

원문

`메서드` `open`

open() → bool

운영 체제의 기본 애플리케이션을 사용해 파일을 엽니다. 이 메서드는 파일 유형과 연결된 기본 애플리케이션으로 파일을 열기 위해 플랫폼별 메커니즘을 사용합니다. 반환값:

bool: 파일을 여는 데 성공하면 True를 반환하고, 그렇지 않으면 False를 반환합니다.

원문

`메서드` `save`

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

파일을 지정된 대상 경로로 복사합니다. 마지막으로 저장된 복사본을 기준으로 콘텐츠의 파일명과 경로를 업데이트합니다. Args:

원문

`메서드` `serialize_data`

serialize_data(data: 'bytes') → str

JSON 모드에서 모델을 덤프할 때

원문

`method` `to_data_url`

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

콘텐츠에서 data URL을 생성합니다.

dest: 파일이 복사될 대상 경로(문자열 또는 pathlib.Path). 대상 경로는 파일이나 디렉터리일 수 있습니다. dest에 파일 확장자(예: .txt)가 없으면 대상을 디렉터리로 간주합니다. Args:
use_base64: True이면 데이터가 base64로 인코딩됩니다. 그렇지 않으면 퍼센트 인코딩됩니다. 기본값은 True입니다. Returns: data URL 문자열.

원문

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

기존 데이터셋에 행을 추가하여 새 데이터셋 버전을 생성합니다. 전체 데이터셋을 메모리에 모두 로드하지 않고도 대규모 데이터셋에 예제를 추가할 때 유용합니다. Args:

rows: 데이터셋에 추가할 행입니다. Returns: 업데이트된 데이터셋입니다.

원문

`classmethod` `convert_to_table`

convert_to_table(rows: Any) → Table | WeaveTable

원문

`classmethod` `from_calls`

from_calls(calls: Iterable[Call]) → Self

원문

`classmethod` `from_hf`

from_hf(
    hf_dataset: Union[ForwardRef('HFDataset'), ForwardRef('HFDatasetDict')]
) → Self

원문

`classmethod` `from_obj`

from_obj(obj: WeaveObject) → Self

원문

`classmethod` `from_pandas`

from_pandas(df: 'DataFrame') → Self

원문

`method` `select`

select(indices: Iterable[int]) → Self

제공된 인덱스를 기준으로 데이터셋에서 행을 선택합니다. Args:

indices: 선택할 행을 지정하는 정수 인덱스로 이루어진 iterable. Returns: 선택된 행만 포함하는 새로운 Dataset 객체를 반환합니다.

원문

`메서드` `to_hf`

to_hf() → HFDataset

원문

`method` `to_pandas`

to_pandas() → DataFrame

원문

`class` `EasyPrompt`

원문

`메서드` `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'>

`property` as_str

모든 메시지를 하나의 문자열로 이어 붙입니다.

`property` is_bound

`property` messages

`property` 플레이스홀더

`property` system_message

모든 메시지를 하나의 시스템 프롬프트 메시지로 합칩니다.

`property` system_prompt

모든 메시지를 결합해 system prompt 객체를 구성합니다.

`속성` unbound_placeholders

원문

`메서드` `append`

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

원문

`메서드` `as_dict`

as_dict() → dict[str, Any]

원문

`method` `as_pydantic_dict`

as_pydantic_dict() → dict[str, Any]

원문

`메서드` `bind`

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

원문

`메서드` `bind_rows`

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

원문

`메서드` `config_table`

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

원문

`메서드` `configure`

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

원문

`메서드` `dump`

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

원문

`method` `dump_file`

dump_file(filepath: str | Path) → None

원문

`method` `format`

format(**kwargs: Any) → Any

원문

`classmethod` `from_obj`

from_obj(obj: WeaveObject) → Self

원문

`classmethod` `load`

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

원문

`classmethod` `load_file`

load_file(filepath: str | Path) → Self

원문

`메서드` `messages_table`

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

원문

`메서드` `print`

print() → str

원문

`메서드` `publish`

publish(name: str | None = None) → ObjectRef

원문

`메서드` `require`

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

원문

`메서드` `run`

run() → Any

원문

`메서드` `validate_requirement`

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

원문

`메서드` `validate_requirements`

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

원문

`메서드` `values_table`

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

원문

`class` `Evaluation`

스코어러 집합과 데이터셋을 포함하는 Evaluation을 설정합니다. evaluation.evaluate(model)을 호출하면 데이터셋의 각 행을 모델에 전달하면서, 데이터셋 열 이름을 model.predict의 인수 이름과 매칭합니다. 그런 다음 모든 스코어러를 호출하고 결과를 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 호출을 추가하고 출력을 반환하는 부분입니다
     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 0x110ab76a0>, json_schema_input_type=PydanticUndefined)]] | None
preprocess_model_input: collections.abc.Callable[[dict], dict] | None
trials: <class 'int'>
metadata: dict[str, typing.Any] | None
evaluation_name: str | collections.abc.Callable[trace.call.Call, str] | None

원문

`메서드` `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]

이 Evaluation 객체를 사용한 모든 평가 호출을 가져옵니다. 하나의 평가에 대해 여러 번 평가 호출이 발생할 수 있으므로(예: 동일한 평가를 여러 번 실행한 경우), 이 메서드는 단일 호출이 아닌 CallsIter를 반환합니다. 반환값:

CallsIter: 평가 실행을 나타내는 Call 객체에 대한 반복자입니다.

예외:

ValueError: 평가에 ref가 없는 경우(아직 저장되거나 실행되지 않은 경우).

예시:

evaluation = Evaluation(dataset=examples, scorers=[scorer])
await evaluation.evaluate(model)  # 먼저 평가를 실행
calls = evaluation.get_evaluate_calls()
for call in calls:
     print(f"평가 실행: {call.id} at {call.started_at}")

원문

`method` `get_score_calls`

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

각 평가 실행에 대한 scorer 호출을 trace ID별로 그룹화하여 조회합니다. 반환값:

dict[str, list[Call]]: trace ID를 scorer Call 객체 리스트에 매핑하는 딕셔너리입니다. 각 trace ID는 하나의 평가 실행을 나타내며, 리스트에는 해당 실행 동안 수행된 모든 scorer 호출이 포함됩니다.

예시:

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

평가 실행에서 scorer의 출력값을 추출하고 정리합니다. 반환 값:

dict[str, dict[str, list[Any]]]: 다음과 같은 중첩된 딕셔너리 구조입니다:
- 1단계 키는 trace ID(평가 실행)입니다.
- 2단계 키는 scorer 이름입니다.
- 값은 해당 실행과 scorer에 대한 출력값 리스트입니다.

예시:

evaluation = Evaluation(dataset=examples, scorers=[accuracy_scorer, f1_scorer])
await evaluation.evaluate(model)
scores = evaluation.get_scores()
# 추적 및 스코어러별 점수 접근
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}]
     }
}

원문

`메서드` `model_post_init`

model_post_init(_Evaluation__context: Any) → None

원문

`메서드` `predict_and_score`

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

원문

`method` `summarize`

summarize(eval_table: EvaluationResults) → dict

원문

`class` `EvaluationLogger`

이 클래스는 평가를 로깅하기 위한 명령형 인터페이스를 제공합니다. 첫 번째 예측이 log_prediction 메서드를 사용하여 로깅되면 평가가 자동으로 시작되고, log_summary 메서드가 호출되면 종료됩니다. 예측을 로깅할 때마다 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 호출)은 자동으로
     # predict 호출의 하위 항목이 됩니다
     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

`property` 어트리뷰트

`property` ui_url

원문

`메서드` `fail`

fail(exception: 'BaseException') → None

예외를 발생시켜 평가를 실패로 처리하는 편의 메서드입니다.

원문

`메서드` `finish`

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

요약을 기록하지 않고 평가 리소스를 명시적으로 정리합니다. 모든 예측 호출과 주요 평가 호출이 완료되었는지 보장합니다. 로거를 컨텍스트 매니저로 사용하는 경우 이 메서드는 자동으로 호출됩니다.

원문

`메서드` `log_example`

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

입력, 출력, 점수를 포함한 완전한 예제를 기록합니다. 이 메서드는 모든 데이터를 미리 가지고 있을 때 log_prediction과 log_score를 한 번에 수행할 수 있도록 결합한 편의 메서드입니다. 인자(Args):

inputs: 예측에 사용되는 입력 데이터
output: 출력값
scores: 스코어러 이름을 점수 값에 매핑하는 딕셔너리 예시(Example):

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

원문

`메서드` `log_prediction`

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

Evaluation에 예측을 기록합니다. 직접 또는 컨텍스트 매니저로 사용할 수 있는 ScoreLogger를 반환합니다. Args:

inputs: 예측에 사용할 입력 데이터
output: 출력 값입니다. 기본값은 None입니다. 나중에 pred.output으로 설정할 수 있습니다. Returns: 점수를 기록하고, 필요에 따라 예측을 완료(finish)하는 데 사용하는 ScoreLogger입니다.

Example (direct):

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

Example (context manager):

with ev.log_prediction({'q': ’…’}) as pred: response = model(…) pred.output = response pred.log_score(“correctness”, 0.9) # 종료 시 자동으로 finish()를 호출합니다

원문

`메서드` `log_summary`

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

Evaluation에 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 아래에 뷰를 첨부합니다. 제공된 콘텐츠를 프로젝트 내 객체로 저장하고, 해당 평가의 evaluate 호출에 대해 그 참조 URI를 summary.weave.views.<name> 아래에 기록합니다. 문자열 입력은 제공된 확장자 또는 MIME 타입과 함께 Content.from_text를 사용해 텍스트 콘텐츠로 래핑됩니다. 인자:

name: 표시할 뷰 이름으로, summary.weave.views 아래의 키로 사용됩니다.
content: 직렬화할 weave.Content 인스턴스 또는 문자열입니다.
extension: 문자열 콘텐츠 입력에 대한 선택적 파일 확장자입니다.
mimetype: 문자열 콘텐츠 입력에 대한 선택적 MIME 타입입니다.
metadata: 새로 생성된 Content에 첨부할 선택적 메타데이터입니다.
encoding: 문자열 콘텐츠 입력에 사용할 텍스트 인코딩입니다.

반환값: 없음 예시: import weave

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

원문

`class` `File`

파일 경로, MIME 타입, 크기 정보를 포함하는 파일을 나타내는 클래스입니다. 원문

`메서드` `init`

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

File 객체를 초기화합니다. Args:

`property` filename

파일의 이름을 가져옵니다.

path: 파일 경로(문자열 또는 pathlib.Path)
mimetype: 선택적 파일 MIME 타입 — 지정하지 않으면 확장자에서 추론됩니다
반환값:
str: 디렉터리 경로를 제외한 파일 이름입니다.

원문

`메서드` `open`

open() → bool

운영체제의 기본 애플리케이션을 사용해 파일을 엽니다. 이 메서드는 플랫폼별 메커니즘을 사용하여, 파일 형식과 연결된 기본 애플리케이션으로 파일을 엽니다. 반환값:

bool: 파일을 여는 데 성공하면 True를, 그렇지 않으면 False를 반환합니다.

원문

`메서드` `save`

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

지정된 대상 경로에 파일을 복사합니다. 매개변수:

원문

`class` `Markdown`

렌더링 가능한 Markdown 객체입니다.

dest: 파일이 복사될 대상 경로(문자열 또는 pathlib.Path). 대상 경로는 파일 또는 디렉터리가 될 수 있습니다. 인자(Args):
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

원문

`class` `MessagesPrompt`

원문

`메서드` `init`

__init__(messages: list[dict])

inline_code_lexer: (str, optional): 인라인 코드 하이라이트가 활성화된 경우 사용할 lexer입니다. 기본값은 None입니다.
inline_code_theme: (Optional[str], optional): 인라인 코드 하이라이트에 사용할 Pygments 테마입니다. 하이라이트를 사용하지 않으려면 None으로 설정합니다. 기본값은 None입니다. Pydantic 필드:
name: str | None
description: str | None
ref: trace.refs.ObjectRef | None
messages: list[dict]

원문

`메서드` `format`

format(**kwargs: Any) → list

원문

`method` `format_message`

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

템플릿 변수를 치환해 단일 메시지를 포맷합니다. 이 메서드는 실제 포맷팅 로직을 위해 독립 함수인 format_message_with_template_vars에 처리를 위임합니다.

원문

`classmethod` `from_obj`

from_obj(obj: WeaveObject) → Self

원문

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

원문

`method` `get_infer_method`

get_infer_method() → Callable

원문

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

Pydantic 필드:

name: str | None
description: str | None
ref: trace.refs.ObjectRef | None
sampling_rate: <class 'float'>
scorers: list[flow.scorer.Scorer]
op_names: list[str]
query: trace_server.interface.query.Query | None
active: <class 'bool'>

원문

`메서드` `activate`

activate() → ObjectRef

모니터를 활성화합니다. Returns: 모니터에 대한 참조를 반환합니다.

원문

`method` `deactivate`

deactivate() → ObjectRef

모니터를 비활성화합니다. 반환값: 모니터에 대한 참조(ref)입니다.

원문

`classmethod` `from_obj`

from_obj(obj: WeaveObject) → Self

원문

`class` `Object`

버전 관리 및 추적이 가능한 Weave 객체의 기본 클래스입니다. 이 클래스는 Pydantic의 BaseModel을 상속하여 객체 추적, 참조, 직렬화를 위한 Weave 전용 기능을 제공합니다. 객체는 이름, 설명, 참조를 가질 수 있으며, 이를 통해 Weave 시스템에 저장하고 검색하여 조회할 수 있습니다. Attributes:

name (Optional[str]): 객체에 대한 사람이 읽을 수 있는 이름입니다.
description (Optional[str]): 객체가 무엇을 나타내는지에 대한 설명입니다.
ref (Optional[ObjectRef]): Weave 시스템 내에서 해당 객체를 가리키는 참조입니다.

Examples:

# 간단한 객체 생성
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

원문

`classmethod` `from_uri`

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

Weave URI로부터 객체 인스턴스를 생성합니다. Args:

uri (str): 객체를 가리키는 Weave URI입니다.
objectify (bool): 결과를 객체로 변환할지 여부입니다. 기본값은 True입니다.

Returns:

Self: URI로부터 생성된 이 클래스의 인스턴스입니다.

Raises:

NotImplementedError: 이 클래스가 역직렬화를 위해 필요한 메서드를 구현하지 않은 경우 발생합니다.

Examples:

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를 포함한 재배치 가능한 객체의 검증을 처리합니다. 이 검증기는 입력이 표준 Object 인스턴스로 올바르게 변환되어야 하는 ObjectRef 또는 WeaveObject인 특수한 경우를 처리합니다. 검증 과정에서 참조가 유지되고, 무시하도록 설정된 타입이 올바르게 처리되도록 보장합니다. 인자(Args):

v (Any): 검증할 값.
handler (ValidatorFunctionWrapHandler): 표준 pydantic 검증 핸들러.
info (ValidationInfo): 검증 컨텍스트 정보.

반환값(Returns):

Any: 검증된 객체 인스턴스.

예시(Examples): 이 메서드는 객체 생성 및 검증 중에 자동으로 호출됩니다. 다음과 같은 경우를 처리합니다: ```python

ObjectRef가 전달된 경우

obj = MyObject(some_object_ref)

WeaveObject가 전달된 경우

obj = MyObject(some_weave_object)

---

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

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

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

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

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

`property` 다이제스트

`property` extra

원문

`method` `as_param_dict`

as_param_dict() → dict

원문

`메서드` `delete`

delete() → None

원문

`메서드` `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

원문

`메서드` `uri`

uri() → str

원문

`메서드` `with_attr`

with_attr(attr: 'str') → Self

원문

`method` `with_extra`

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

원문

`메서드` `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

원문

`class` `Prompt`

Pydantic 필드:

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

원문

`method` `format`

format(**kwargs: Any) → Any

원문

`class` `SavedView`

SavedView 객체를 다루기 위한 플루언트 스타일 클래스입니다. 원문

`메서드` `init`

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

`property` 엔터티

`property` label

`속성` 프로젝트

`property` view_type

원문

`메서드` `add_column`

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

원문

`메서드` `add_columns`

add_columns(*columns: 'str') → SavedView

그리드에 여러 열을 편리하게 추가하기 위한 메서드입니다.

원문

`메서드` `add_filter`

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

원문

`method` `add_sort`

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

원문

`메서드` `column_index`

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

원문

`method` `filter_op`

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

원문

`메서드` `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

이 저장된 뷰의 필터 및 설정에 맞는 호출을 가져옵니다.

원문

`메서드` `get_known_columns`

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

존재하는 것으로 확인된 열 집합을 가져옵니다.

원문

`메서드` `get_table_columns`

get_table_columns() → list[TableColumn]

원문

`메서드` `hide_column`

hide_column(col_name: 'str') → SavedView

원문

`메서드` `insert_column`

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

원문

`classmethod` `load`

load(ref: 'str') → Self

원문

`메서드` `page_size`

page_size(page_size: 'int') → SavedView

원문

`메서드` `pin_column_left`

pin_column_left(col_name: 'str') → SavedView

원문

`메서드` `pin_column_right`

pin_column_right(col_name: 'str') → SavedView

원문

`method` `remove_column`

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

원문

`메서드` `remove_columns`

remove_columns(*columns: 'str') → SavedView

저장된 뷰에서 열을 제거합니다.

원문

`메서드` `remove_filter`

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

원문

`메서드` `remove_filters`

remove_filters() → SavedView

저장된 보기에서 모든 필터를 제거합니다.

원문

`메서드` `rename`

rename(label: 'str') → SavedView

원문

`메서드` `rename_column`

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

원문

`메서드` `save`

save() → SavedView

저장된 뷰를 서버에 게시합니다.

원문

`메서드` `set_columns`

set_columns(*columns: 'str') → SavedView

그리드에 표시할 열을 설정합니다.

원문

`method` `show_column`

show_column(col_name: 'str') → SavedView

원문

`메서드` `sort_by`

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

원문

`method` `to_grid`

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

원문

`메서드` `to_rich_table_str`

to_rich_table_str() → str

원문

`메서드` `ui_url`

ui_url() → str | None

UI에서 이 저장된 뷰를 표시하기 위한 URL입니다. 이 URL은 뷰 객체의 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

원문

`classmethod` `from_obj`

from_obj(obj: WeaveObject) → Self

원문

`메서드` `model_post_init`

model_post_init(_Scorer__context: Any) → None

원문

`메서드` `score`

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

원문

`method` `summarize`

summarize(score_rows: list) → dict | None

원문

`class` `StringPrompt`

원문

`메서드` `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

원문

`classmethod` `from_obj`

from_obj(obj: WeaveObject) → Self

원문

`class` `Table`

원문

`메서드` `init`

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

`property` 행

원문

`method` `append`

append(row: 'dict') → None

테이블에 행을 추가합니다.

원문

`method` `pop`

pop(index: 'int') → None

지정된 인덱스의 행을 테이블에서 제거합니다.

원문

`class` `ContextAwareThread`

호출자의 컨텍스트를 가진 상태로 함수를 실행하는 스레드입니다. 이는 threading.Thread를 그대로 대체해 사용할 수 있는 클래스로, 스레드 내부에서도 호출이 예상대로 동작하도록 보장합니다. Weave는 특정 contextvars가 설정되어 있어야 하는데(call_context.py 참고), 새 스레드는 부모로부터 컨텍스트를 자동으로 복사하지 않기 때문에 호출 컨텍스트가 사라질 수 있습니다. 이는 바람직하지 않습니다! 이 클래스는 contextvars 복사를 자동화하여, 사용자가 기대하는 것처럼 이 스레드를 사용하면 “그냥 잘 동작”하도록 합니다. 이 클래스를 사용하지 않고도, 대신 아래와 같이 작성하여 동일한 효과를 얻을 수 있습니다:

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

원문

`메서드` `init`

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

`property` daemon

이 스레드가 데몬 스레드인지 여부를 나타내는 boolean 값입니다. 이 속성은 start()가 호출되기 전에 설정해야 하며, 그렇지 않으면 RuntimeError가 발생합니다. 이 속성의 초기값은 생성한 스레드로부터 상속되며, 메인 스레드는 데몬 스레드가 아니므로 메인 스레드에서 생성된 모든 스레드는 기본적으로 daemon = False입니다. 오직 데몬 스레드만 남았을 때 전체 Python 프로그램이 종료됩니다.

`property` ident

이 스레드의 식별자이며, 스레드가 아직 시작되지 않은 경우 None입니다. 이 값은 0이 아닌 정수입니다. get_ident() 함수를 참조하십시오. 스레드가 종료된 후 다른 스레드가 생성될 때 스레드 식별자는 재사용될 수 있습니다. 스레드가 종료된 이후에도 이 식별자는 계속 사용할 수 있습니다.

`property` name

식별용으로만 사용되는 문자열입니다. 별도의 의미를 갖지 않습니다. 여러 스레드에 동일한 name을 지정할 수 있습니다. 초기 name 값은 생성자에서 설정됩니다.

`property` native_id

이 스레드의 네이티브 정수 스레드 ID로, 스레드가 시작되지 않았다면 None입니다. 이 값은 음수가 아닌 정수입니다. get_native_id() 함수를 참조하세요. 이는 커널에서 보고하는 스레드 ID를 나타냅니다.

원문

`메서드` `run`

run() → None

원문

`class` `ThreadContext`

현재 스레드 및 턴(turn) 정보에 접근할 수 있도록 해주는 컨텍스트 객체입니다. 원문

`메서드` `init`

__init__(thread_id: 'str | None')

지정된 thread_id를 사용해 ThreadContext를 초기화합니다. 매개변수:

`property` thread_id

이 컨텍스트에 대한 thread_id를 가져옵니다.

thread_id: 이 컨텍스트에 대한 스레드 식별자 또는 비활성화된 경우 None입니다. Returns: 스레드 식별자 또는 스레드 추적이 비활성화된 경우 None입니다.

`property` turn_id

활성 컨텍스트에서 현재 turn_id를 가져옵니다. 반환값: 설정되어 있으면 현재 turn_id, 그렇지 않으면 None.

원문

`class` `ContextAwareThreadPoolExecutor`

호출자의 컨텍스트에서 함수를 실행하는 ThreadPoolExecutor입니다. 이 클래스는 concurrent.futures.ThreadPoolExecutor를 그대로 대체할 수 있는 구현으로, executor 내부에서 Weave 호출이 기대한 대로 동작하도록 보장합니다. Weave는 특정 contextvars가 설정되어 있어야 합니다(call_context.py 참조). 하지만 새 스레드는 부모로부터 컨텍스트를 자동으로 복사하지 않기 때문에 호출 컨텍스트가 손실될 수 있으며, 이는 바람직하지 않습니다. 이 클래스는 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)

원문

`메서드` `init`

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

원문

`메서드` `map`

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

원문

`메서드` `submit`

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

원문

`function` `as_op`

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

@weave.op 데코레이터가 적용된 함수가 주어지면, 해당 함수의 Op를 반환합니다. @weave.op 데코레이터가 적용된 함수는 이미 Op의 인스턴스이므로, 런타임에서는 이 함수가 아무 작업도 수행하지 않는 no-op이어야 합니다. 다만 타입 체커를 만족시키기 위해 OpDef 속성에 타입 안전하게 접근해야 하는 경우 이 함수를 사용할 수 있습니다. 인자(Args):

fn: @weave.op 데코레이터가 적용된 함수. 반환값(Returns): 함수의 Op.

원문

`function` `attributes`

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

호출 시 속성을 설정하는 컨텍스트 관리자입니다. 예시:

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

원문

`function` `finish`

finish() → None

Weave로의 로깅을 중지합니다. finish 호출 이후에는 weave.op 데코레이터가 적용된 함수를 호출하더라도 더 이상 로깅되지 않습니다. 로깅을 다시 시작하려면 weave.init()을 다시 호출해야 합니다.

원문

`function` `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과 동일!

원문

`function` `get_client`

get_client() → WeaveClient | None

원문

`function` `get_current_call`

get_current_call() → Call | None

현재 실행 중인 Op 내부에서, 그 Op에 대한 현재 실행 중인 Call 객체를 가져옵니다. Returns: 현재 실행 중인 Op에 대한 Call 객체를 반환하거나, 추적이 초기화되지 않았거나 이 메서드가 Op 외부에서 호출된 경우에는 None을 반환합니다. Note:

반환된 Call의 attributes 딕셔너리는 호출이 시작되면 변경할 수 없게 됩니다. Op를 호출하기 전에 호출 메타데이터를 설정하려면 :func:weave.attributes를 사용하십시오. summary 필드는 Op가 실행되는 동안 업데이트될 수 있으며, 호출이 종료될 때 계산된 요약 정보와 병합됩니다.

원문

`function` `init`

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

Weave 추적을 초기화하고 wandb 프로젝트에 로그를 기록합니다. 로깅은 전역으로 초기화되므로 init의 반환값에 대한 참조를 유지할 필요가 없습니다. init 이후에는 weave.op 데코레이터가 적용된 함수 호출이 지정된 프로젝트에 로깅됩니다. 인수(Args): 참고: 전역 후처리 설정은 각 op 고유의 후처리 이후에 모든 op에 적용됩니다. 순서는 항상 다음과 같습니다. 1. op별 후처리 2. 전역 후처리

project_name: 로그를 기록할 Weights & Biases 팀과 프로젝트의 이름입니다. 팀을 지정하지 않으면 기본 엔터티가 사용됩니다. 기본 엔터티를 찾거나 업데이트하려면 W&B Models 문서의 User Settings를 참고하세요.
settings: Weave 클라이언트 전반에 대한 구성입니다.
autopatch_settings: (사용 중단됨) 자동 패치 통합에 대한 구성입니다. 대신 명시적 패치를 사용하세요.
global_postprocess_inputs: 모든 op의 모든 입력에 적용될 함수입니다.
global_postprocess_output: 모든 op의 모든 출력에 적용될 함수입니다.
global_attributes: 모든 트레이스에 적용될 속성 딕셔너리입니다. 반환값(Returns): Weave 클라이언트.

원문

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

데코레이터 패턴을 사용하지 않고 Weave에 호출을 직접 기록합니다. 이 함수는 Weave에 연산을 기록하기 위한 명령형 API를 제공합니다. 이미 실행된 호출을 나중에 기록해야 할 때나, 데코레이터 패턴이 사용 사례에 적합하지 않을 때 유용합니다. Args:

op (str): 기록할 연산 이름입니다. 이 값은 호출의 op_name으로 사용됩니다. 게시된 op를 가리키지 않는 문자열(익명 연산)도 지원됩니다.
inputs (dict[str, Any]): 연산의 입력 파라미터 딕셔너리입니다.
output (Any): 연산의 출력/결과입니다.
parent (Call | None): 이 호출을 중첩시킬 선택적 부모 호출입니다. 제공하지 않으면 호출은 루트 수준 호출이 되거나, 현재 호출 컨텍스트가 존재하는 경우 해당 컨텍스트 아래에 중첩됩니다. 기본값은 None입니다.
attributes (dict[str, Any] | None): 호출에 첨부할 선택적 메타데이터입니다. 호출이 생성되면 이 값들은 변경할 수 없게(frozen) 됩니다. 기본값은 None입니다.
display_name (str | Callable[[Call], str] | None): UI에서 호출에 표시할 선택적 이름입니다. 문자열이거나, Call을 인자로 받아 문자열을 반환하는 호출 가능 객체일 수 있습니다. 기본값은 None입니다.
use_stack (bool): 이 호출을 런타임 스택에 푸시할지 여부입니다. True이면 호출은 호출 컨텍스트에서 사용 가능하며 weave.require_current_call()을 통해 접근할 수 있습니다. False이면 호출은 기록되지만 호출 스택에는 추가되지 않습니다. 기본값은 True입니다.
exception (BaseException | None): 연산이 실패했을 때 기록할 선택적 예외입니다. 기본값은 None입니다.

Returns:

Call: 전체 트레이스 정보가 포함된, 생성 및 완료된 Call 객체입니다.

Examples: 기본 사용 예:

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  # 호출 스택에 추가하지 않습니다
    ... )

---

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

### <kbd>function</kbd> `op`

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

함수나 메서드를 Weave op로 변환(weave op-ify)하기 위한 데코레이터입니다. 동기 및 비동기 함수 모두에서 동작합니다. 이터레이터 함수를 자동으로 감지하고, 이에 맞는 동작을 적용합니다.

원문

`function` `publish`

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

Python 객체를 저장하고 버전 관리를 수행합니다. Weave는 객체 이름이 이미 존재하고 해당 객체의 내용 해시가 그 객체의 최신 버전과 일치하지 않는 경우, 객체의 새 버전을 생성합니다. 인자:

obj: 저장하고 버전 관리를 수행할 객체.
name: 객체를 저장할 이름. 반환값: 저장된 객체를 가리키는 Weave Ref.

원문

`function` `ref`

ref(location: 'str') → ObjectRef

기존 Weave 객체에 대한 Ref를 생성합니다. 이 함수는 객체를 직접 가져오지 않고, 다른 Weave API 함수에 전달할 수 있도록 합니다. 인자(Args):

location: Weave Ref URI이거나, weave.init()이 호출된 경우 name:version 또는 name. 버전을 제공하지 않으면 latest가 사용됩니다. 반환값(Returns): 객체에 대한 Weave Ref를 반환합니다.

원문

`함수` `require_current_call`

require_current_call() → Call

현재 실행 중인 op 내부에서 해당 op의 Call 객체를 가져옵니다. 이를 통해 실행 중에 Call의 id나 feedback과 같은 속성에 접근할 수 있습니다.

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

Op이 반환된 후에도 Call에 접근할 수 있습니다. UI 등에서 가져온 Call의 id가 있다면, weave.init이 반환한 WeaveClient의 get_call 메서드를 사용하여 Call 객체를 조회할 수 있습니다.

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

또는 Op를 정의한 다음에는 해당 Op의 call 메서드를 직접 호출할 수도 있습니다. 예를 들어:

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

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

반환값: 현재 실행 중인 Op의 Call 객체 예외:

NoCurrentCallError: 추적이 초기화되지 않았거나 이 메서드가 Op 외부에서 호출된 경우.

원문

`function` `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.<name> 위치에 커스텀 뷰를 추가합니다. Args:

name: 뷰 이름 (summary._weave.views 아래의 키).
content: weave.Content 인스턴스 또는 일반 문자열. 문자열은 제공된 extension 또는 mimetype을 사용하여 Content.from_text로 래핑됩니다.
extension: content가 문자열일 때 사용할 선택적 파일 확장자.
mimetype: content가 문자열일 때 사용할 선택적 MIME 타입.
metadata: 텍스트에서 Content를 생성할 때 함께 첨부할 선택적 메타데이터.
encoding: 텍스트에서 Content를 생성할 때 적용할 텍스트 인코딩. Returns: None

Examples: import weave

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

원문

`function` `thread`

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

컨텍스트 내에서 수행되는 호출에 thread_id를 설정하는 컨텍스트 매니저입니다. 예시:

# thread_id 자동 생성
with weave.thread() as t:
     print(f"Thread ID: {t.thread_id}")
     result = my_function("input")  # 이 호출에는 자동 생성된 thread_id가 적용됩니다
     print(f"Current turn: {t.turn_id}")

# 명시적 thread_id
with weave.thread("custom_thread") as t:
     result = my_function("input")  # 이 호출에는 thread_id="custom_thread"가 적용됩니다

# 스레딩 비활성화
with weave.thread(None) as t:
     result = my_function("input")  # 이 호출에는 thread_id=None이 적용됩니다

인자:

thread_id: 이 컨텍스트에서 호출과 연결할 스레드 식별자입니다. 제공되지 않으면 UUID v7이 자동으로 생성됩니다. None이면 스레드 추적이 비활성화됩니다.

반환:

ThreadContext: thread_id와 현재 turn_id에 접근할 수 있는 객체입니다.

원문

`function` `wandb_init_hook`

wandb_init_hook() → None

시작하기

가이드

쿡북

레퍼런스

자세한 정보와 지원

오픈 소스

커뮤니티

​API 개요

​class Agent

​메서드 step

​class AgentState

​class AnnotationSpec

​classmethod preprocess_field_schema

​classmethod validate_field_schema

​method value_is_valid

​class Audio

​메서드 __init__

​메서드 export

​classmethod from_data

​classmethod from_path

​class Content

​메서드 __init__

​속성 art

​property ref

​메서드 as_string

​classmethod from_base64

​classmethod from_bytes

​classmethod from_data_url

​classmethod from_path

​classmethod from_text

​classmethod from_url

​classmethod model_validate

​classmethod model_validate_json

​메서드 open

​메서드 save

​메서드 serialize_data

​method to_data_url

​class Dataset

​method add_rows

​classmethod convert_to_table

​classmethod from_calls

​classmethod from_hf

​classmethod from_obj

​classmethod from_pandas

​method select

​메서드 to_hf

​method to_pandas

​class EasyPrompt

​메서드 __init__

​property as_str

​property is_bound

​property messages

​property 플레이스홀더

​property system_message

​property system_prompt

​속성 unbound_placeholders

​메서드 append

​메서드 as_dict

​method as_pydantic_dict

​메서드 bind

​메서드 bind_rows

​메서드 config_table

​메서드 configure

​메서드 dump

​method dump_file

​method format

​classmethod from_obj

​classmethod load

​classmethod load_file

​메서드 messages_table

​메서드 print

​메서드 publish

​메서드 require

​메서드 run

​메서드 validate_requirement

​메서드 validate_requirements

​메서드 values_table

​class Evaluation

​메서드 evaluate

​classmethod from_obj

API 개요

`class` `Agent`

`메서드` `step`

`class` `AgentState`

`class` `AnnotationSpec`

`classmethod` `preprocess_field_schema`

`classmethod` `validate_field_schema`

`method` `value_is_valid`

`class` `Audio`

`메서드` `init`

`메서드` `export`

`classmethod` `from_data`

`classmethod` `from_path`

`class` `Content`

`메서드` `init`

`속성` art

`property` ref

`메서드` `as_string`

`classmethod` `from_base64`

`classmethod` `from_bytes`

`classmethod` `from_data_url`

`classmethod` `from_path`

`classmethod` `from_text`

`classmethod` `from_url`

`classmethod` `model_validate`

`classmethod` `model_validate_json`

`메서드` `open`

`메서드` `save`

`메서드` `serialize_data`

`method` `to_data_url`

`class` `Dataset`

`method` `add_rows`

`classmethod` `convert_to_table`

`classmethod` `from_calls`

`classmethod` `from_hf`

`classmethod` `from_obj`

`classmethod` `from_pandas`

`method` `select`

`메서드` `to_hf`

`method` `to_pandas`

`class` `EasyPrompt`

`메서드` `init`

`property` as_str

`property` is_bound

`property` messages

`property` 플레이스홀더

`property` system_message

`property` system_prompt

`속성` unbound_placeholders

`메서드` `append`

`메서드` `as_dict`

`method` `as_pydantic_dict`

`메서드` `bind`

`메서드` `bind_rows`

`메서드` `config_table`

`메서드` `configure`

`메서드` `dump`

`method` `dump_file`

`method` `format`

`classmethod` `from_obj`

`classmethod` `load`

`classmethod` `load_file`

`메서드` `messages_table`

`메서드` `print`

`메서드` `publish`

`메서드` `require`

`메서드` `run`

`메서드` `validate_requirement`

`메서드` `validate_requirements`

`메서드` `values_table`

`class` `Evaluation`

`메서드` `evaluate`

`classmethod` `from_obj`

`method` `get_eval_results`

`method` `get_evaluate_calls`

`method` `get_score_calls`

`method` `get_scores`

`메서드` `model_post_init`

`메서드` `predict_and_score`

`method` `summarize`