API Overview

`class` `RemoteHTTPTraceServer`

`method` `init`

__init__(
    trace_server_url: str,
    should_batch: bool = False,
    remote_request_bytes_limit: int = 32505856,
    auth: Optional[tuple[str, str]] = None,
    extra_headers: Optional[dict[str, str]] = None
)

`method` `actions_execute_batch`

actions_execute_batch(
    req: Union[ActionsExecuteBatchReq, dict[str, Any]]
) → ActionsExecuteBatchRes

`method` `call_end`

call_end(req: Union[CallEndReq, dict[str, Any]]) → CallEndRes

`method` `call_read`

call_read(req: Union[CallReadReq, dict[str, Any]]) → CallReadRes

`method` `call_start`

call_start(req: Union[CallStartReq, dict[str, Any]]) → CallStartRes

`method` `call_start_batch`

call_start_batch(req: CallCreateBatchReq) → CallCreateBatchRes

`method` `call_update`

call_update(req: Union[CallUpdateReq, dict[str, Any]]) → CallUpdateRes

`method` `calls_delete`

calls_delete(req: Union[CallsDeleteReq, dict[str, Any]]) → CallsDeleteRes

`method` `calls_query`

calls_query(req: Union[CallsQueryReq, dict[str, Any]]) → CallsQueryRes

`method` `calls_query_stats`

calls_query_stats(
    req: Union[CallsQueryStatsReq, dict[str, Any]]
) → CallsQueryStatsRes

`method` `calls_query_stream`

calls_query_stream(
    req: Union[CallsQueryReq, dict[str, Any]]
) → Iterator[CallSchema]

`method` `completions_create`

completions_create(req: CompletionsCreateReq) → CompletionsCreateRes

`method` `completions_create_stream`

completions_create_stream(req: CompletionsCreateReq) → Iterator[dict[str, Any]]

`method` `cost_create`

cost_create(req: Union[CostCreateReq, dict[str, Any]]) → CostCreateRes

`method` `cost_purge`

cost_purge(req: Union[CostPurgeReq, dict[str, Any]]) → CostPurgeRes

`method` `cost_query`

cost_query(req: Union[CostQueryReq, dict[str, Any]]) → CostQueryRes

`method` `dataset_create_v2`

dataset_create_v2(
    req: Union[DatasetCreateV2Req, dict[str, Any]]
) → DatasetCreateV2Res

`method` `dataset_delete_v2`

dataset_delete_v2(
    req: Union[DatasetDeleteV2Req, dict[str, Any]]
) → DatasetDeleteV2Res

`method` `dataset_list_v2`

dataset_list_v2(
    req: Union[DatasetListV2Req, dict[str, Any]]
) → Iterator[DatasetReadV2Res]

`method` `dataset_read_v2`

dataset_read_v2(req: Union[DatasetReadV2Req, dict[str, Any]]) → DatasetReadV2Res

`method` `delete`

delete(url: str, *args: Any, **kwargs: Any) → Response

`method` `ensure_project_exists`

ensure_project_exists(entity: str, project: str) → EnsureProjectExistsRes

`method` `evaluate_model`

evaluate_model(req: EvaluateModelReq) → EvaluateModelRes

`method` `evaluation_create_v2`

evaluation_create_v2(
    req: Union[EvaluationCreateV2Req, dict[str, Any]]
) → EvaluationCreateV2Res

`method` `evaluation_delete_v2`

evaluation_delete_v2(
    req: Union[EvaluationDeleteV2Req, dict[str, Any]]
) → EvaluationDeleteV2Res

`method` `evaluation_list_v2`

evaluation_list_v2(
    req: Union[EvaluationListV2Req, dict[str, Any]]
) → Iterator[EvaluationReadV2Res]

`method` `evaluation_read_v2`

evaluation_read_v2(
    req: Union[EvaluationReadV2Req, dict[str, Any]]
) → EvaluationReadV2Res

`method` `evaluation_run_create_v2`

evaluation_run_create_v2(
    req: Union[EvaluationRunCreateV2Req, dict[str, Any]]
) → EvaluationRunCreateV2Res

`method` `evaluation_run_delete_v2`

evaluation_run_delete_v2(
    req: Union[EvaluationRunDeleteV2Req, dict[str, Any]]
) → EvaluationRunDeleteV2Res

`method` `evaluation_run_finish_v2`

evaluation_run_finish_v2(
    req: Union[EvaluationRunFinishV2Req, dict[str, Any]]
) → EvaluationRunFinishV2Res

`method` `evaluation_run_list_v2`

evaluation_run_list_v2(
    req: Union[EvaluationRunListV2Req, dict[str, Any]]
) → Iterator[EvaluationRunReadV2Res]

`method` `evaluation_run_read_v2`

evaluation_run_read_v2(
    req: Union[EvaluationRunReadV2Req, dict[str, Any]]
) → EvaluationRunReadV2Res

`method` `evaluation_status`

evaluation_status(req: EvaluationStatusReq) → EvaluationStatusRes

`method` `feedback_create`

feedback_create(
    req: Union[FeedbackCreateReq, dict[str, Any]]
) → FeedbackCreateRes

`method` `feedback_create_batch`

feedback_create_batch(req: FeedbackCreateBatchReq) → FeedbackCreateBatchRes

`method` `feedback_purge`

feedback_purge(req: Union[FeedbackPurgeReq, dict[str, Any]]) → FeedbackPurgeRes

`method` `feedback_query`

feedback_query(req: Union[FeedbackQueryReq, dict[str, Any]]) → FeedbackQueryRes

`method` `feedback_replace`

feedback_replace(
    req: Union[FeedbackReplaceReq, dict[str, Any]]
) → FeedbackReplaceRes

`method` `file_content_read`

file_content_read(req: FileContentReadReq) → FileContentReadRes

`method` `file_create`

file_create(req: FileCreateReq) → FileCreateRes

`method` `files_stats`

files_stats(req: FilesStatsReq) → FilesStatsRes

`classmethod` `from_env`

from_env(should_batch: bool = False) → RemoteHTTPTraceServer

`method` `get`

get(url: str, *args: Any, **kwargs: Any) → Response

`method` `get_call_processor`

get_call_processor() → Optional[AsyncBatchProcessor]

Custom method not defined on the formal TraceServerInterface to expose the underlying call processor. Should be formalized in a client-side interface.

`method` `get_feedback_processor`

get_feedback_processor() → Optional[AsyncBatchProcessor]

Custom method not defined on the formal TraceServerInterface to expose the underlying feedback processor. Should be formalized in a client-side interface.

`method` `image_create`

image_create(req: ImageGenerationCreateReq) → ImageGenerationCreateRes

`method` `model_create_v2`

model_create_v2(req: Union[ModelCreateV2Req, dict[str, Any]]) → ModelCreateV2Res

`method` `model_delete_v2`

model_delete_v2(req: Union[ModelDeleteV2Req, dict[str, Any]]) → ModelDeleteV2Res

`method` `model_list_v2`

model_list_v2(
    req: Union[ModelListV2Req, dict[str, Any]]
) → Iterator[ModelReadV2Res]

`method` `model_read_v2`

model_read_v2(req: Union[ModelReadV2Req, dict[str, Any]]) → ModelReadV2Res

`method` `obj_create`

obj_create(req: Union[ObjCreateReq, dict[str, Any]]) → ObjCreateRes

`method` `obj_delete`

obj_delete(req: ObjDeleteReq) → ObjDeleteRes

`method` `obj_read`

obj_read(req: Union[ObjReadReq, dict[str, Any]]) → ObjReadRes

`method` `objs_query`

objs_query(req: Union[ObjQueryReq, dict[str, Any]]) → ObjQueryRes

`method` `op_create`

op_create(req: Union[OpCreateReq, dict[str, Any]]) → OpCreateRes

`method` `op_create_v2`

op_create_v2(req: Union[OpCreateV2Req, dict[str, Any]]) → OpCreateV2Res

`method` `op_delete_v2`

op_delete_v2(req: Union[OpDeleteV2Req, dict[str, Any]]) → OpDeleteV2Res

`method` `op_list_v2`

op_list_v2(req: Union[OpListV2Req, dict[str, Any]]) → Iterator[OpReadV2Res]

`method` `op_read`

op_read(req: Union[OpReadReq, dict[str, Any]]) → OpReadRes

`method` `op_read_v2`

op_read_v2(req: Union[OpReadV2Req, dict[str, Any]]) → OpReadV2Res

`method` `ops_query`

ops_query(req: Union[OpQueryReq, dict[str, Any]]) → OpQueryRes

`method` `otel_export`

otel_export(req: OtelExportReq) → OtelExportRes

`method` `post`

post(url: str, *args: Any, **kwargs: Any) → Response

`method` `prediction_create_v2`

prediction_create_v2(
    req: Union[PredictionCreateV2Req, dict[str, Any]]
) → PredictionCreateV2Res

`method` `prediction_delete_v2`

prediction_delete_v2(
    req: Union[PredictionDeleteV2Req, dict[str, Any]]
) → PredictionDeleteV2Res

`method` `prediction_finish_v2`

prediction_finish_v2(
    req: Union[PredictionFinishV2Req, dict[str, Any]]
) → PredictionFinishV2Res

`method` `prediction_list_v2`

prediction_list_v2(
    req: Union[PredictionListV2Req, dict[str, Any]]
) → Iterator[PredictionReadV2Res]

`method` `prediction_read_v2`

prediction_read_v2(
    req: Union[PredictionReadV2Req, dict[str, Any]]
) → PredictionReadV2Res

`method` `project_stats`

project_stats(req: ProjectStatsReq) → ProjectStatsRes

`method` `refs_read_batch`

refs_read_batch(req: Union[RefsReadBatchReq, dict[str, Any]]) → RefsReadBatchRes

`method` `score_create_v2`

score_create_v2(req: Union[ScoreCreateV2Req, dict[str, Any]]) → ScoreCreateV2Res

`method` `score_delete_v2`

score_delete_v2(req: Union[ScoreDeleteV2Req, dict[str, Any]]) → ScoreDeleteV2Res

`method` `score_list_v2`

score_list_v2(
    req: Union[ScoreListV2Req, dict[str, Any]]
) → Iterator[ScoreReadV2Res]

`method` `score_read_v2`

score_read_v2(req: Union[ScoreReadV2Req, dict[str, Any]]) → ScoreReadV2Res

`method` `scorer_create_v2`

scorer_create_v2(
    req: Union[ScorerCreateV2Req, dict[str, Any]]
) → ScorerCreateV2Res

`method` `scorer_delete_v2`

scorer_delete_v2(
    req: Union[ScorerDeleteV2Req, dict[str, Any]]
) → ScorerDeleteV2Res

`method` `scorer_list_v2`

scorer_list_v2(
    req: Union[ScorerListV2Req, dict[str, Any]]
) → Iterator[ScorerReadV2Res]

`method` `scorer_read_v2`

scorer_read_v2(req: Union[ScorerReadV2Req, dict[str, Any]]) → ScorerReadV2Res

`method` `server_info`

server_info() → ServerInfoRes

`method` `set_auth`

set_auth(auth: tuple[str, str]) → None

`method` `table_create`

table_create(req: Union[TableCreateReq, dict[str, Any]]) → TableCreateRes

`method` `table_create_from_digests`

table_create_from_digests(
    req: Union[TableCreateFromDigestsReq, dict[str, Any]]
) → TableCreateFromDigestsRes

Create a table by specifying row digests instead of actual rows.

`method` `table_query`

table_query(req: Union[TableQueryReq, dict[str, Any]]) → TableQueryRes

`method` `table_query_stats`

table_query_stats(
    req: Union[TableQueryStatsReq, dict[str, Any]]
) → TableQueryStatsRes

`method` `table_query_stats_batch`

table_query_stats_batch(
    req: Union[TableQueryStatsReq, dict[str, Any]]
) → TableQueryStatsRes

`method` `table_query_stream`

table_query_stream(req: TableQueryReq) → Iterator[TableRowSchema]

`method` `table_update`

table_update(req: TableUpdateReq) → TableUpdateRes

Similar to calls/batch_upsert, we can dynamically adjust the payload size due to the property that table updates can be decomposed into a series of updates.

`method` `threads_query_stream`

threads_query_stream(req: ThreadsQueryReq) → Iterator[ThreadSchema]

Guides

Cookbooks

Reference

Open Source

Community

​API Overview

​class RemoteHTTPTraceServer

​method __init__

​method actions_execute_batch

​method call_end

​method call_read

​method call_start

​method call_start_batch

​method call_update

​method calls_delete

​method calls_query

​method calls_query_stats

​method calls_query_stream

​method completions_create

​method completions_create_stream

​method cost_create

​method cost_purge

​method cost_query

​method dataset_create_v2

​method dataset_delete_v2

​method dataset_list_v2

​method dataset_read_v2

​method delete

​method ensure_project_exists

​method evaluate_model

​method evaluation_create_v2

​method evaluation_delete_v2

​method evaluation_list_v2

​method evaluation_read_v2

​method evaluation_run_create_v2

​method evaluation_run_delete_v2

​method evaluation_run_finish_v2

​method evaluation_run_list_v2

​method evaluation_run_read_v2

​method evaluation_status

​method feedback_create

​method feedback_create_batch

​method feedback_purge

​method feedback_query

​method feedback_replace

​method file_content_read

​method file_create

​method files_stats

​classmethod from_env

​method get

​method get_call_processor

​method get_feedback_processor

​method image_create

​method model_create_v2

​method model_delete_v2

​method model_list_v2

​method model_read_v2

​method obj_create

​method obj_delete

​method obj_read

​method objs_query

​method op_create

​method op_create_v2

​method op_delete_v2

​method op_list_v2

​method op_read

​method op_read_v2

​method ops_query

​method otel_export

​method post

​method prediction_create_v2

​method prediction_delete_v2

​method prediction_finish_v2

​method prediction_list_v2

​method prediction_read_v2

​method project_stats

​method refs_read_batch

​method score_create_v2

​method score_delete_v2

​method score_list_v2