__init__(
    entity: 'str',
    project: 'str',
    server: 'TraceServerClientInterface',
    ensure_project_exists: 'bool' = True,
    postprocess_inputs: 'PostprocessInputsFunc | None' = None,
    postprocess_output: 'PostprocessOutputFunc | None' = None,
    attributes: 'dict[str, Any] | None' = None,
    api_key: 'str | None' = None
)

add_calls_to_annotation_queue(
    queue_id: 'str',
    call_ids: 'list[str]',
    display_fields: 'list[str]'
) → AnnotationQueueAddCallsRes

add_cost(
    llm_id: 'str',
    prompt_token_cost: 'float',
    completion_token_cost: 'float',
    effective_date: 'datetime | None' = None,
    prompt_token_cost_unit: 'str | None' = 'USD',
    completion_token_cost_unit: 'str | None' = 'USD',
    provider_id: 'str | None' = 'default'
) → CostCreateRes

client.add_cost(llm_id="my_expensive_custom_model", prompt_token_cost=1, completion_token_cost=2)
client.add_cost(llm_id="my_expensive_custom_model", prompt_token_cost=500, completion_token_cost=1000, effective_date=datetime(1998, 10, 3))

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

clear_wandb_run_context() → None

client = weave.init("my-project")
client.set_wandb_run_context(run_id="my-run-id", step=5)
# ... 몇 가지 Call 수행 ...
client.clear_wandb_run_context()
# 이제 Call은 다시 전역 wandb.run을 사용합니다

create_annotation_queue(
    name: 'str',
    scorer_refs: 'list[str]',
    description: 'str' = ''
) → str

create_call(
    op: 'str | Op',
    inputs: 'dict[str, Any]',
    parent: 'Call | None' = None,
    attributes: 'dict[str, Any] | None' = None,
    display_name: 'str | Callable[[Call], str] | None' = None,
    use_stack: 'bool' = True,
    _call_id_override: 'str | None' = None,
    started_at: 'datetime | None' = None
) → Call

delete_all_object_versions(object_name: 'str') → int

delete_all_op_versions(op_name: 'str') → int

delete_annotation_queue(queue_id: 'str') → AnnotationQueueSchema

delete_call(call: 'Call') → None

delete_calls(call_ids: 'list[str]') → None

delete_object_version(object: 'ObjectRef') → None

delete_object_versions(object_name: 'str', digests: 'list[str]') → int

delete_op_version(op: 'OpRef') → None

fail_call(call: 'Call', exception: 'BaseException') → None

finish(
    use_progress_bar: 'bool' = True,
    callback: 'Callable[[FlushStatus], None] | None' = None
) → None

finish_call(
    call: 'Call',
    output: 'Any' = None,
    exception: 'BaseException | None' = None,
    op: 'Op | None' = None,
    ended_at: 'datetime | None' = None
) → None

flush() → None

get(ref: 'ObjectRef', objectify: 'bool' = True) → Any

get_agent_custom_attributes(
    query: 'Query | None' = None,
    started_after: 'datetime | None' = None,
    started_before: 'datetime | None' = None,
    limit: 'int' = 200,
    offset: 'int' = 0
) → AgentCustomAttrsSchemaRes

client = weave.init("entity/project")
resp = client.get_agent_custom_attributes()
for attr in resp.attributes:
     print(attr.key, attr.value_type, attr.span_count)

get_agent_span_stats(
    start: 'datetime',
    metrics: 'list[AgentSpanStatsMetricSpec]',
    end: 'datetime | None' = None,
    query: 'Query | None' = None,
    group_by: 'list[AgentGroupByRef] | None' = None,
    granularity: 'int | None' = None,
    timezone: 'str' = 'UTC'
) → AgentSpanStatsRes

client = weave.init("entity/project")
resp = client.get_agent_span_stats(start=start, metrics=metrics)
for row in resp.rows:
     print(row)

get_agent_spans(
    agent_name: 'str | None' = None,
    query: 'Query | None' = None,
    sort_by: 'list[AgentSortBy] | None' = None,
    limit: 'int | None' = None,
    offset: 'int | None' = None,
    page_size: 'int' = 100
) → AgentSpansIter

client = weave.init("entity/project")
for span in client.get_agent_spans(agent_name="my-agent"):
     print(span.span_id, span.span_name, span.input_tokens)

get_agent_turn(
    trace_id: 'str',
    include_feedback: 'bool' = False
) → AgentTraceChatRes

client = weave.init("entity/project")
resp = client.get_agent_turn(trace_id="...", include_feedback=True)
for message in resp.messages:
     print(message.type)

get_agent_turns(
    conversation_id: 'str',
    limit: 'int' = 50,
    offset: 'int' = 0,
    include_feedback: 'bool' = False
) → AgentConversationChatRes

client = weave.init("entity/project")
resp = client.get_agent_turns(conversation_id="...", limit=20)
for turn in resp.turns:
     for message in turn.messages:
         print(message.type)

get_agent_versions(
    agent_name: 'str',
    sort_by: 'list[AgentSortBy] | None' = None,
    limit: 'int | None' = None,
    offset: 'int | None' = None,
    page_size: 'int' = 100
) → AgentVersionsIter

client = weave.init("entity/project")
for version in client.get_agent_versions(agent_name="my-agent"):
     print(version.agent_version, version.total_input_tokens)

get_agents(
    agent_name: 'str | None' = None,
    sort_by: 'list[AgentSortBy] | None' = None,
    limit: 'int | None' = None,
    offset: 'int | None' = None,
    page_size: 'int' = 100
) → AgentsIter

client = weave.init("entity/project")
for agent in client.get_agents(limit=20):
     print(agent.agent_name, agent.total_input_tokens)

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

get_annotation_queue(queue_id: 'str') → AnnotationQueueSchema

get_annotation_queue_stats(
    queue_ids: 'list[str]'
) → list[AnnotationQueueStatsSchema]

get_call(
    call_id: 'str',
    include_costs: 'bool' = False,
    include_feedback: 'bool' = False,
    columns: 'list[str] | None' = None
) → WeaveObject

get_calls(
    filter: 'CallsFilterLike | None' = None,
    limit: 'int | None' = None,
    offset: 'int | None' = None,
    sort_by: 'list[SortByLike] | None' = None,
    query: 'QueryLike | None' = None,
    include_costs: 'bool' = False,
    include_feedback: 'bool' = False,
    include_storage_size: 'bool' = False,
    include_total_storage_size: 'bool' = False,
    include_usernames: 'bool' = False,
    columns: 'list[str] | None' = None,
    expand_columns: 'list[str] | None' = None,
    return_expanded_column_values: 'bool' = True,
    scored_by: 'str | list[str] | None' = None,
    page_size: 'int' = 1000
) → CallsIter

calls = client.get_calls(
     filter=CallsFilter(op_names=["my_op"]),
     columns=["inputs", "output", "summary"],
     limit=100,
)
for call in calls:
     print(call.inputs, call.output)

get_evaluation(uri: 'str') → Evaluation

client = weave.init("my-project")
evaluation = client.get_evaluation("weave:///entity/project/object/my-eval:v1")
print(evaluation.name)

get_evaluations() → list[Evaluation]

client = weave.init("my-project")
evaluations = client.get_evaluations()
print(f"Found {len(evaluations)} evaluations")
for eval in evaluations:
     print(f"Evaluation: {eval.name}")

get_feedback(
    query: 'Query | str | None' = None,
    reaction: 'str | None' = None,
    offset: 'int' = 0,
    limit: 'int' = 100
) → FeedbackQuery

# 특정 피드백 객체를 가져옵니다.
# 이 경우에도 컬렉션이 반환되며,
# 항목이 없거나 하나만 포함될 것으로 예상됩니다.
client.get_feedback("1B4082A3-4EDA-4BEB-BFEB-2D16ED59AA07")

# 특정 반응이 있는 모든 피드백 객체를 찾습니다.
client.get_feedback(reaction="👍", limit=10)

# mongo 스타일 쿼리로 특정 피드백 유형의
# 모든 피드백 객체를 찾습니다.
from weave.trace_server.interface.query import Query

query = Query(
    **{
        "$expr": {
            "$eq": [
                {"$getField": "feedback_type"},
                {"$literal": "wandb.reaction.1"},
            ],
        }
    }
)
client.get_feedback(query=query)

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

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

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

list_aliases() → list[str]

list_annotation_queue_items(
    queue_id: 'str',
    filter: 'AnnotationQueueItemsFilter | None' = None,
    sort_by: 'list[SortBy] | None' = None,
    limit: 'int | None' = None,
    offset: 'int | None' = None,
    include_position: 'bool' = False
) → list[AnnotationQueueItemSchema]

list_annotation_queues(
    name: 'str | None' = None,
    sort_by: 'list[SortBy] | None' = None,
    limit: 'int | None' = None,
    offset: 'int | None' = None
) → list[AnnotationQueueSchema]

list_tags() → list[str]

purge_costs(ids: 'list[str] | str') → None

client.purge_costs([ids])
client.purge_costs(ids)

query_costs(
    query: 'Query | str | None' = None,
    llm_ids: 'list[str] | None' = None,
    offset: 'int' = 0,
    limit: 'int' = 100
) → list[CostQueryOutput]

# 특정 비용 객체를 가져옵니다.
# 이 경우에도 컬렉션을 반환하며, 컬렉션에는
# 항목이 없거나 하나만 포함될 것으로 예상됩니다.
client.query_costs("1B4082A3-4EDA-4BEB-BFEB-2D16ED59AA07")

# 특정 반응이 있는 모든 비용 객체를 찾습니다.
client.query_costs(llm_ids=["gpt-4o-mini-2024-07-18"], limit=10)

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

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

save(val: 'Any', name: 'str', branch: 'str' = 'latest') → Any

search_agents(
    query: 'str' = '',
    agent_name: 'str | None' = None,
    conversation_id: 'str | None' = None,
    trace_id: 'str | None' = None,
    limit: 'int' = 20,
    offset: 'int' = 0
) → AgentSearchRes

client = weave.init("entity/project")
resp = client.search_agents(query="timeout", agent_name="my-agent")
for conversation in resp.results:
     print(conversation.conversation_id, conversation.matched_messages)

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

set_wandb_run_context(run_id: 'str', step: 'int | None' = None) → None

client = weave.init("my-project")
client.set_wandb_run_context(run_id="my-run-id", step=5)
# 이제 모든 Call이 step 5에서 entity/project/my-run-id에 연결됩니다

# 또는 step 없이 설정합니다
client.set_wandb_run_context(run_id="my-run-id")
# Call이 step 없이 entity/project/my-run-id에 연결됩니다

update_annotation_queue(
    queue_id: 'str',
    name: 'str | None' = None,
    description: 'str | None' = None,
    scorer_refs: 'list[str] | None' = None
) → AnnotationQueueSchema

get_obj_name(val: 'Any') → str

get_parallelism_settings() → tuple[int | None, int | None]

map_to_refs(obj: 'Any') → Any

print_call_link(call: 'Call') → None

redact_sensitive_keys(obj: 'Any') → Any

sanitize_object_name(name: 'str') → str