arize-phoenix 4.12.0rc1__py3-none-any.whl → 4.12.1rc1__py3-none-any.whl

{arize_phoenix-4.12.0rc1.dist-info → arize_phoenix-4.12.1rc1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: arize-phoenix
-Version: 4.12.0rc1
+Version: 4.12.1rc1
 Summary: AI Observability and Evaluation
 Project-URL: Documentation, https://docs.arize.com/phoenix/
 Project-URL: Issues, https://github.com/Arize-ai/phoenix/issues
@@ -22,6 +22,7 @@ Requires-Dist: aiosqlite
 Requires-Dist: alembic<2,>=1.3.0
 Requires-Dist: arize-phoenix-evals>=0.13.1
 Requires-Dist: cachetools
+Requires-Dist: fastapi
 Requires-Dist: grpcio
 Requires-Dist: hdbscan>=0.8.33
 Requires-Dist: httpx
@@ -40,8 +41,8 @@ Requires-Dist: pandas>=1.0
 Requires-Dist: protobuf<6.0,>=3.20
 Requires-Dist: psutil
 Requires-Dist: pyarrow
+Requires-Dist: pydantic!=2.0.*,<3,>=1.0
 Requires-Dist: python-multipart
-Requires-Dist: pyyaml
 Requires-Dist: scikit-learn
 Requires-Dist: scipy
 Requires-Dist: sqlalchemy[asyncio]<3,>=2.0.4
@@ -56,9 +57,9 @@ Requires-Dist: uvicorn
 Requires-Dist: wrapt
 Provides-Extra: container
 Requires-Dist: opentelemetry-exporter-otlp; extra == 'container'
+Requires-Dist: opentelemetry-instrumentation-fastapi; extra == 'container'
 Requires-Dist: opentelemetry-instrumentation-grpc; extra == 'container'
 Requires-Dist: opentelemetry-instrumentation-sqlalchemy; extra == 'container'
-Requires-Dist: opentelemetry-instrumentation-starlette; extra == 'container'
 Requires-Dist: opentelemetry-proto>=1.12.0; extra == 'container'
 Requires-Dist: opentelemetry-sdk; extra == 'container'
 Requires-Dist: opentelemetry-semantic-conventions; extra == 'container'

{arize_phoenix-4.12.0rc1.dist-info → arize_phoenix-4.12.1rc1.dist-info}/RECORD

@@ -5,7 +5,7 @@ phoenix/exceptions.py,sha256=n2L2KKuecrdflB9MsCdAYCiSEvGJptIsfRkXMoJle7A,169
 phoenix/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 phoenix/services.py,sha256=aTxhcOA1pZHB6U-B3TEcp6fqDF5oT0xCUvEUNMZVTUQ,5175
 phoenix/settings.py,sha256=cO-qgis_S27nHirTobYI9hHPfZH18R--WMmxNdsVUwc,273
-phoenix/version.py,sha256=vDTXhJ8GZFVcgTBE3Q26tNDA2kuyeZwK6HnXlO91H70,26
+phoenix/version.py,sha256=C3HccMWHAx9lnG5eI9Z6SvQ8MEwqYKi1vrfgajsjMXM,26
 phoenix/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 phoenix/core/embedding_dimension.py,sha256=zKGbcvwOXgLf-yrJBpQyKtd-LEOPRKHnUToyAU8Owis,87
 phoenix/core/model.py,sha256=km_a--PBHOuA337ClRw9xqhOHhrUT6Rl9pz_zV0JYkQ,4843
@@ -60,14 +60,14 @@ phoenix/pointcloud/pointcloud.py,sha256=4zAIkKs2xOUbchpj4XDAV-iPMXrfAJ15TG6rlIYG
 phoenix/pointcloud/projectors.py,sha256=zO_RrtDYSv2rqVOfIP2_9Cv11Dc8EmcZR94xhFcBYPU,1057
 phoenix/pointcloud/umap_parameters.py,sha256=3UQSjrysVOvq2V4KNpTMqNqNiK0BsTZnPBHWZ4fyJtQ,1708
 phoenix/server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-phoenix/server/app.py,sha256=u8s2AEUUDsY1uIpk3d8cMVHnAL6N57Ulb-k88kVvbMA,19673
+phoenix/server/app.py,sha256=g-UDuF90bnE1nnW6peZY_-1_pplP4ERb2bnD2vERfRg,18758
 phoenix/server/grpc_server.py,sha256=faktLxEtWGlCB1bPR4QwwTsRoQloahKMx0hAWqRGI5s,3379
 phoenix/server/main.py,sha256=dRyODpwkNi_3as14fnZ8LWW_JLWtpXHldRy9SNjNtws,11251
 phoenix/server/prometheus.py,sha256=j9DHB2fERuq_ZKmwVaqR-9wx5WcPPuU1Cm5Bhg5241Y,2996
 phoenix/server/telemetry.py,sha256=T_2OKrxNViAeaANlNspEekg_Y5uZIFWvKAnpz8Aoqvk,2762
-phoenix/server/thread_server.py,sha256=dP6cm6Cf08jNhDA1TRlVZpziu1YgtPDmaeIJMm725eI,2154
+phoenix/server/thread_server.py,sha256=RwXQGP_QhGD7le6WB7xEygEEuwBl5Ck_Zo8xGIYGi9M,2135
 phoenix/server/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-phoenix/server/api/context.py,sha256=DiK2IRMBbMvBF0uK20YBftApJXau4GSDHltVZX2yERQ,2957
+phoenix/server/api/context.py,sha256=G9bmB3h-a4Top6wGAu91ymS-YE6D1DYQyWtPIlZnbgc,2811
 phoenix/server/api/interceptor.py,sha256=ykDnoC_apUd-llVli3m1CW18kNSIgjz2qZ6m5JmPDu8,1294
 phoenix/server/api/queries.py,sha256=eq2xHaQF-x4k6AGSY6b6mU2pie9bj-AJML6P2Mr0_DM,19886
 phoenix/server/api/schema.py,sha256=BcxdqO5CSGqpKd-AAJHMjFlzaK9oJA8GJuxmMfcdjn4,434
@@ -134,19 +134,21 @@ phoenix/server/api/mutations/project_mutations.py,sha256=d_xtYkYfZ5flpVgEkGknKB8
 phoenix/server/api/mutations/span_annotations_mutations.py,sha256=Pfaq4y-FGskPit4z_9GvsyWeBwK1g3CDi2UhGKxyjFE,4973
 phoenix/server/api/mutations/trace_annotations_mutations.py,sha256=4xm-zg8PEjwjfVRsWzBD_iiOS94JI6UYtK3fV2dtA4M,5013
 phoenix/server/api/openapi/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-phoenix/server/api/openapi/main.py,sha256=WY0pj3B7siQyyYqKyhqnzWC7P8MtEtiukOBUjGwLXfw,153
-phoenix/server/api/openapi/schema.py,sha256=uuSYe1Ecu72aXRgTNjyMu-9ZPE13DAHJPKtedS-MsSs,451
+phoenix/server/api/openapi/main.py,sha256=KNutA_7AvV_WlGX8cOkvvDujcJKQ7AD1HT6rTpCpR8A,616
+phoenix/server/api/openapi/schema.py,sha256=oVZoflWMfzOrLKMIrjr3iLnJ13rmN-t_DOe9g6KoN5s,471
 phoenix/server/api/routers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 phoenix/server/api/routers/utils.py,sha256=M41BoH-fl37izhRuN2aX7lWm7jOC20A_3uClv9TVUUY,583
-phoenix/server/api/routers/v1/__init__.py,sha256=D1EFRWG4PcsTubeF3A3ENlNatCRq26AA52FxW11BGjM,3048
-phoenix/server/api/routers/v1/dataset_examples.py,sha256=XfqOvDKF1oxb0pkeYfBycwwGt3LnSyyGdMLKC5VKoGQ,6690
-phoenix/server/api/routers/v1/datasets.py,sha256=r0WcNxF8SKVa3-4rrTIg4Andwr4NmRmW1ybpKuxR9qw,33639
-phoenix/server/api/routers/v1/evaluations.py,sha256=8g6P_e2BweV3RDU0esFmpkb0L5fCwonQPXiJ0y6HLwg,9126
-phoenix/server/api/routers/v1/experiment_evaluations.py,sha256=TE1GMSOLN_96uAaJpnRpIH2u9x6_ebtkECgZRHvqt-w,5098
-phoenix/server/api/routers/v1/experiment_runs.py,sha256=jy4SynmzdtQMoUzlowmG6wsVU14SsLAzfcW4JOhXjeQ,8154
-phoenix/server/api/routers/v1/experiments.py,sha256=uVdmhyJgYI-UqOiRSJ-8OcVpL8a6Z02B5H2Rt_7yboY,11829
-phoenix/server/api/routers/v1/spans.py,sha256=tryWFoJVFRLALzt6dfPmBBhKMS0s3hhlYdTathxVEU4,9638
-phoenix/server/api/routers/v1/traces.py,sha256=PBIrpdJHVJ9gyiukCy1Ck1w0xts0VEHtRKaF7Noa248,8434
+phoenix/server/api/routers/v1/__init__.py,sha256=nb49zcOdAi3DSGuC9gUubN9Yri-o7-WFdlGak4jGuFw,1462
+phoenix/server/api/routers/v1/dataset_examples.py,sha256=6ep0Trojax_NbwpCOlofNG9p4xMu6VJgZPMjkAUJQOA,5627
+phoenix/server/api/routers/v1/datasets.py,sha256=-QzKYNV0DCWfw3D_k_KO1iF_PY57fNAvx7NGznNWt0g,32294
+phoenix/server/api/routers/v1/evaluations.py,sha256=xNhS_VOA8S0BIijb1NSAOW677PzLOVl39Fl00g_T7Vo,9553
+phoenix/server/api/routers/v1/experiment_evaluations.py,sha256=xoVhU71U3c1QJSXiKsAa4yiH-UAqkyVc7uKPyIHjrYY,4682
+phoenix/server/api/routers/v1/experiment_runs.py,sha256=7qvLYgqH58nxqhTnJ0hPf0PBfVmZnbxquodSnEGoQxk,6059
+phoenix/server/api/routers/v1/experiments.py,sha256=iS2IBgR7WX1rgYlO90b2sleVU-C0y57RgI5TslCYMFw,9812
+phoenix/server/api/routers/v1/pydantic_compat.py,sha256=FeK8oe2brqu-djsoqRxiKL4tw5cHmi89OHVfCFxYsAo,2890
+phoenix/server/api/routers/v1/spans.py,sha256=yMs3Sm6s6JLV2nlmpnQ-ZJ_In0aTY5M3uOlLi-Wzb9c,8967
+phoenix/server/api/routers/v1/traces.py,sha256=Zl_hGHd-4rA0tXegH_GVoN9Ij84vbPB8oHu28fzGHA8,8029
+phoenix/server/api/routers/v1/utils.py,sha256=xvl2v-BKUkqmFVMmgmmWGFKuRBTrUdoiAeT3mCYEE68,3086
 phoenix/server/api/types/Annotation.py,sha256=7Ym7iuVcbwHlw2yIRylz4nATAF_Cm-Z17qcjiooj1cc,751
 phoenix/server/api/types/AnnotatorKind.py,sha256=rPgGdbN1Gvc109sGQ_ZH-gfJbp93V9wlarzTEJNtUwI,236
 phoenix/server/api/types/Cluster.py,sha256=ac4YfT1OH3xLVmex7EUmB6b9IpULnhLTt554LR0jglE,5689
@@ -202,7 +204,6 @@ phoenix/server/api/types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZ
 phoenix/server/api/types/node.py,sha256=V0Xh9U4cGkz3iMg-vzEXtcs6cumU29JFPiU-JuGzjWI,848
 phoenix/server/api/types/pagination.py,sha256=PcaJ0s4exsTKgCZC4aFm1cgZNrGpHSdo6PbkWzPcweg,9077
 phoenix/server/openapi/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-phoenix/server/openapi/docs.py,sha256=fTb9q2oOSKC5bLVQy2Dsg3Bs0mGkCOKX1ypX7731sE0,7044
 phoenix/server/static/apple-touch-icon-114x114.png,sha256=xtFVXAYQnJkpUApg2D1hltSTuyO4Is4sD4A0ZkikiVU,9486
 phoenix/server/static/apple-touch-icon-120x120.png,sha256=iqZVAk634BbjJMozA8aHYyw15JjhIlIrG41FA2DFFaE,9957
 phoenix/server/static/apple-touch-icon-144x144.png,sha256=VgARtkHKoU8zikb3_G83h_cb02kpPcoJqO78yRh1AfU,10047
@@ -224,9 +225,9 @@ phoenix/server/static/assets/vendor-codemirror-CrdxOlMs.js,sha256=KMJHeNKQyBjzBz
 phoenix/server/static/assets/vendor-recharts-PKRvByVe.js,sha256=Uul1I5FtZKipkx1ku4y2OqWd86GiO4aB4dA9o_LJbvM,282859
 phoenix/server/static/assets/vendor-three-DwGkEfCM.js,sha256=0D12ZgKzfKCTSdSTKJBFR2RZO_xxeMXrqDp0AszZqHY,620972
 phoenix/server/templates/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-phoenix/server/templates/index.html,sha256=lgWe7Smx5KT6XYqnLC2-ZJYtxCJIC-if0-_6TesO1_Q,3884
+phoenix/server/templates/index.html,sha256=gVpjB8pCMiubdMh2DA9mTCtV5AVTXJH_9u5PmG2t7Vk,4238
 phoenix/session/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-phoenix/session/client.py,sha256=aq5AhgyoI-rJU5eTNFAk8SzdBl6hiZvj7fWrC09s4aI,32523
+phoenix/session/client.py,sha256=niTRnsmLb6OdrwNvFNgVqrkft5ZRpYYZoWq4WhjS_AI,32555
 phoenix/session/data_extractor.py,sha256=gkEM3WWZAlWGMfRgQopAQlid4cSi6GNco-sdrGir0qc,2788
 phoenix/session/evaluation.py,sha256=aKeV8UVOyq3b7CYOwt3cWuLz0xzvMjX7vlEPILJ_fcs,5311
 phoenix/session/session.py,sha256=1ZGR0pBmah8bqX353MDf4sq7XuK904EfxNLo0B9z_sU,26714
@@ -266,8 +267,8 @@ phoenix/utilities/logging.py,sha256=lDXd6EGaamBNcQxL4vP1au9-i_SXe0OraUDiJOcszSw,
 phoenix/utilities/project.py,sha256=qWsvKnG1oKhOFUowXf9qiOL2ia7jaFe_ijFFHEt8GJo,431
 phoenix/utilities/re.py,sha256=PDve_OLjRTM8yQQJHC8-n3HdIONi7aNils3ZKRZ5uBM,2045
 phoenix/utilities/span_store.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-arize_phoenix-4.12.0rc1.dist-info/METADATA,sha256=RrJgXQpDjiI30wmDKUZrcbBoM6vb3f2suCGJC4mtuQ0,11455
-arize_phoenix-4.12.0rc1.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-arize_phoenix-4.12.0rc1.dist-info/licenses/IP_NOTICE,sha256=JBqyyCYYxGDfzQ0TtsQgjts41IJoa-hiwDrBjCb9gHM,469
-arize_phoenix-4.12.0rc1.dist-info/licenses/LICENSE,sha256=HFkW9REuMOkvKRACuwLPT0hRydHb3zNg-fdFt94td18,3794
-arize_phoenix-4.12.0rc1.dist-info/RECORD,,
+arize_phoenix-4.12.1rc1.dist-info/METADATA,sha256=9EuJLBvIpbylubhJ6sCVH2zk-_klCyHiBYHqyGdAB5M,11494
+arize_phoenix-4.12.1rc1.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+arize_phoenix-4.12.1rc1.dist-info/licenses/IP_NOTICE,sha256=JBqyyCYYxGDfzQ0TtsQgjts41IJoa-hiwDrBjCb9gHM,469
+arize_phoenix-4.12.1rc1.dist-info/licenses/LICENSE,sha256=HFkW9REuMOkvKRACuwLPT0hRydHb3zNg-fdFt94td18,3794
+arize_phoenix-4.12.1rc1.dist-info/RECORD,,

phoenix/server/api/context.py

@@ -1,12 +1,10 @@
 from dataclasses import dataclass
 from datetime import datetime
 from pathlib import Path
-from typing import AsyncContextManager, Callable, Optional, Union
+from typing import AsyncContextManager, Callable, Optional
 
 from sqlalchemy.ext.asyncio import AsyncSession
-from starlette.requests import Request
-from starlette.responses import Response
-from starlette.websockets import WebSocket
+from strawberry.fastapi import BaseContext
 from typing_extensions import TypeAlias
 
 from phoenix.core.model_schema import Model
@@ -67,9 +65,7 @@ ProjectRowId: TypeAlias = int
 
 
 @dataclass
-class Context:
-    request: Union[Request, WebSocket]
-    response: Optional[Response]
+class Context(BaseContext):
     db: Callable[[], AsyncContextManager[AsyncSession]]
     data_loaders: DataLoaders
     cache_for_dataloaders: Optional[CacheForDataLoaders]

phoenix/server/api/openapi/main.py

@@ -1,6 +1,22 @@
+import json
+from argparse import ArgumentParser
+from typing import Optional, Tuple
+
 from .schema import get_openapi_schema
 
 if __name__ == "__main__":
-    import yaml  # type: ignore
+    parser = ArgumentParser()
+    parser.add_argument(
+        "--compress",
+        action="store_true",
+        help="Whether to output a compressed version of the OpenAPI schema",
+    )
+    args = parser.parse_args()
 
-    print(yaml.dump(get_openapi_schema(), indent=2))
+    indent: Optional[int] = None
+    separator: Optional[Tuple[str, str]] = None
+    if args.compress:
+        separator = (",", ":")
+    else:
+        indent = 2
+    print(json.dumps(get_openapi_schema(), indent=indent, separators=separator))

phoenix/server/api/openapi/schema.py

@@ -1,16 +1,16 @@
-from typing import Any
+from typing import Any, Dict
 
-from starlette.schemas import SchemaGenerator
+from fastapi.openapi.utils import get_openapi
 
-from phoenix.server.api.routers.v1 import V1_ROUTES
+from phoenix.server.api.routers.v1 import REST_API_VERSION
+from phoenix.server.api.routers.v1 import router as v1_router
 
-OPENAPI_SCHEMA_GENERATOR = SchemaGenerator(
-    {"openapi": "3.0.0", "info": {"title": "Arize-Phoenix API", "version": "1.0"}}
-)
 
-
-def get_openapi_schema() -> Any:
-    """
-    Exports an OpenAPI schema for the Phoenix REST API as a JSON object.
-    """
-    return OPENAPI_SCHEMA_GENERATOR.get_schema(V1_ROUTES)  # type: ignore
+def get_openapi_schema() -> Dict[str, Any]:
+    return get_openapi(
+        title="Arize-Phoenix REST API",
+        version=REST_API_VERSION,
+        openapi_version="3.1.0",
+        description="Schema for Arize-Phoenix REST API",
+        routes=v1_router.routes,
+    )

phoenix/server/api/routers/v1/__init__.py

@@ -1,89 +1,42 @@
-from typing import Any, Awaitable, Callable, Mapping, Tuple
-
-import wrapt
-from starlette import routing
-from starlette.requests import Request
-from starlette.responses import Response
+from fastapi import APIRouter, Depends, HTTPException, Request
 from starlette.status import HTTP_403_FORBIDDEN
 
-from . import (
-    datasets,
-    evaluations,
-    experiment_evaluations,
-    experiment_runs,
-    experiments,
-    spans,
-    traces,
-)
-from .dataset_examples import list_dataset_examples
-
+from .datasets import router as datasets_router
+from .evaluations import router as evaluations_router
+from .experiment_evaluations import router as experiment_evaluations_router
+from .experiment_runs import router as experiment_runs_router
+from .experiments import router as experiments_router
+from .spans import router as spans_router
+from .traces import router as traces_router
+from .utils import add_errors_to_responses
 
-@wrapt.decorator  # type: ignore
-async def forbid_if_readonly(
-    wrapped: Callable[[Request], Awaitable[Response]],
-    _: Any,
-    args: Tuple[Request],
-    kwargs: Mapping[str, Any],
-) -> Response:
-    request, *_ = args
-    if request.app.state.read_only:
-        return Response(status_code=HTTP_403_FORBIDDEN)
-    return await wrapped(*args, **kwargs)
+REST_API_VERSION = "1.0"
 
 
-class Route(routing.Route):
-    def __init__(self, path: str, endpoint: Callable[..., Any], **kwargs: Any) -> None:
-        super().__init__(path, forbid_if_readonly(endpoint), **kwargs)
-
-
-V1_ROUTES = [
-    Route("/v1/evaluations", evaluations.post_evaluations, methods=["POST"]),
-    Route("/v1/evaluations", evaluations.get_evaluations, methods=["GET"]),
-    Route("/v1/traces", traces.post_traces, methods=["POST"]),
-    Route("/v1/trace_annotations", traces.annotate_traces, methods=["POST"]),
-    Route("/v1/spans", spans.query_spans_handler, methods=["POST"]),
-    Route("/v1/spans", spans.get_spans_handler, methods=["GET"]),
-    Route("/v1/span_annotations", spans.annotate_spans, methods=["POST"]),
-    Route("/v1/datasets/upload", datasets.post_datasets_upload, methods=["POST"]),
-    Route("/v1/datasets", datasets.list_datasets, methods=["GET"]),
-    Route("/v1/datasets/{id:str}", datasets.delete_dataset_by_id, methods=["DELETE"]),
-    Route("/v1/datasets/{id:str}", datasets.get_dataset_by_id, methods=["GET"]),
-    Route("/v1/datasets/{id:str}/csv", datasets.get_dataset_csv, methods=["GET"]),
-    Route(
-        "/v1/datasets/{id:str}/jsonl/openai_ft",
-        datasets.get_dataset_jsonl_openai_ft,
-        methods=["GET"],
-    ),
-    Route(
-        "/v1/datasets/{id:str}/jsonl/openai_evals",
-        datasets.get_dataset_jsonl_openai_evals,
-        methods=["GET"],
-    ),
-    Route("/v1/datasets/{id:str}/examples", list_dataset_examples, methods=["GET"]),
-    Route("/v1/datasets/{id:str}/versions", datasets.get_dataset_versions, methods=["GET"]),
-    Route(
-        "/v1/datasets/{dataset_id:str}/experiments",
-        experiments.create_experiment,
-        methods=["POST"],
-    ),
-    Route(
-        "/v1/experiments/{experiment_id:str}",
-        experiments.read_experiment,
-        methods=["GET"],
-    ),
-    Route(
-        "/v1/experiments/{experiment_id:str}/runs",
-        experiment_runs.create_experiment_run,
-        methods=["POST"],
-    ),
-    Route(
-        "/v1/experiments/{experiment_id:str}/runs",
-        experiment_runs.list_experiment_runs,
-        methods=["GET"],
-    ),
-    Route(
-        "/v1/experiment_evaluations",
-        experiment_evaluations.upsert_experiment_evaluation,
-        methods=["POST"],
+async def prevent_access_in_read_only_mode(request: Request) -> None:
+    """
+    Prevents access to the REST API in read-only mode.
+    """
+    if request.app.state.read_only:
+        raise HTTPException(
+            detail="The Phoenix REST API is disabled in read-only mode.",
+            status_code=HTTP_403_FORBIDDEN,
+        )
+
+
+router = APIRouter(
+    prefix="/v1",
+    dependencies=[Depends(prevent_access_in_read_only_mode)],
+    responses=add_errors_to_responses(
+        [
+            HTTP_403_FORBIDDEN  # adds a 403 response to each route in the generated OpenAPI schema
+        ]
     ),
-]
+)
+router.include_router(datasets_router)
+router.include_router(experiments_router)
+router.include_router(experiment_runs_router)
+router.include_router(experiment_evaluations_router)
+router.include_router(traces_router)
+router.include_router(spans_router)
+router.include_router(evaluations_router)

phoenix/server/api/routers/v1/dataset_examples.py

@@ -1,178 +1,157 @@
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+from fastapi import APIRouter, HTTPException, Path, Query
 from sqlalchemy import and_, func, select
 from starlette.requests import Request
-from starlette.responses import JSONResponse, Response
 from starlette.status import HTTP_404_NOT_FOUND
 from strawberry.relay import GlobalID
 
-from phoenix.db.models import Dataset, DatasetExample, DatasetExampleRevision, DatasetVersion
-
-
-async def list_dataset_examples(request: Request) -> Response:
-    """
-    summary: Get dataset examples by dataset ID
-    operationId: getDatasetExamples
-    tags:
-      - datasets
-    parameters:
-      - in: path
-        name: id
-        required: true
-        schema:
-          type: string
-        description: Dataset ID
-      - in: query
-        name: version_id
-        schema:
-          type: string
-        description: Dataset version ID. If omitted, returns the latest version.
-    responses:
-      200:
-        description: Success
-        content:
-          application/json:
-            schema:
-              type: object
-              properties:
-                data:
-                  type: object
-                  properties:
-                    dataset_id:
-                      type: string
-                      description: ID of the dataset
-                    version_id:
-                      type: string
-                      description: ID of the version
-                    examples:
-                      type: array
-                      items:
-                        type: object
-                        properties:
-                          id:
-                            type: string
-                            description: ID of the dataset example
-                          input:
-                            type: object
-                            description: Input data of the example
-                          output:
-                            type: object
-                            description: Output data of the example
-                          metadata:
-                            type: object
-                            description: Metadata of the example
-                          updated_at:
-                            type: string
-                            format: date-time
-                            description: ISO formatted timestamp of when the example was updated
-                        required:
-                          - id
-                          - input
-                          - output
-                          - metadata
-                          - updated_at
-                  required:
-                    - dataset_id
-                    - version_id
-                    - examples
-      403:
-        description: Forbidden
-      404:
-        description: Dataset does not exist.
-    """
-    dataset_id = GlobalID.from_id(request.path_params["id"])
-    raw_version_id = request.query_params.get("version_id")
-    version_id = GlobalID.from_id(raw_version_id) if raw_version_id else None
-
-    if (dataset_type := dataset_id.type_name) != "Dataset":
-        return Response(
-            content=f"ID {dataset_id} refers to a {dataset_type}", status_code=HTTP_404_NOT_FOUND
+from phoenix.db.models import (
+    Dataset as ORMDataset,
+)
+from phoenix.db.models import (
+    DatasetExample as ORMDatasetExample,
+)
+from phoenix.db.models import (
+    DatasetExampleRevision as ORMDatasetExampleRevision,
+)
+from phoenix.db.models import (
+    DatasetVersion as ORMDatasetVersion,
+)
+
+from .pydantic_compat import V1RoutesBaseModel
+from .utils import ResponseBody, add_errors_to_responses
+
+router = APIRouter(tags=["datasets"])
+
+
+class DatasetExample(V1RoutesBaseModel):
+    id: str
+    input: Dict[str, Any]
+    output: Dict[str, Any]
+    metadata: Dict[str, Any]
+    updated_at: datetime
+
+
+class ListDatasetExamplesData(V1RoutesBaseModel):
+    dataset_id: str
+    version_id: str
+    examples: List[DatasetExample]
+
+
+class ListDatasetExamplesResponseBody(ResponseBody[ListDatasetExamplesData]):
+    pass
+
+
+@router.get(
+    "/datasets/{id}/examples",
+    operation_id="getDatasetExamples",
+    summary="Get examples from a dataset",
+    responses=add_errors_to_responses([HTTP_404_NOT_FOUND]),
+)
+async def get_dataset_examples(
+    request: Request,
+    id: str = Path(description="The ID of the dataset"),
+    version_id: Optional[str] = Query(
+        default=None,
+        description=(
+            "The ID of the dataset version " "(if omitted, returns data from the latest version)"
+        ),
+    ),
+) -> ListDatasetExamplesResponseBody:
+    dataset_gid = GlobalID.from_id(id)
+    version_gid = GlobalID.from_id(version_id) if version_id else None
+
+    if (dataset_type := dataset_gid.type_name) != "Dataset":
+        raise HTTPException(
+            detail=f"ID {dataset_gid} refers to a {dataset_type}", status_code=HTTP_404_NOT_FOUND
         )
 
-    if version_id and (version_type := version_id.type_name) != "DatasetVersion":
-        return Response(
-            content=f"ID {version_id} refers to a {version_type}", status_code=HTTP_404_NOT_FOUND
+    if version_gid and (version_type := version_gid.type_name) != "DatasetVersion":
+        raise HTTPException(
+            detail=f"ID {version_gid} refers to a {version_type}", status_code=HTTP_404_NOT_FOUND
         )
 
     async with request.app.state.db() as session:
         if (
             resolved_dataset_id := await session.scalar(
-                select(Dataset.id).where(Dataset.id == int(dataset_id.node_id))
+                select(ORMDataset.id).where(ORMDataset.id == int(dataset_gid.node_id))
             )
         ) is None:
-            return Response(
-                content=f"No dataset with id {dataset_id} can be found.",
+            raise HTTPException(
+                detail=f"No dataset with id {dataset_gid} can be found.",
                 status_code=HTTP_404_NOT_FOUND,
             )
 
         # Subquery to find the maximum created_at for each dataset_example_id
         # timestamp tiebreaks are resolved by the largest id
         partial_subquery = select(
-            func.max(DatasetExampleRevision.id).label("max_id"),
-        ).group_by(DatasetExampleRevision.dataset_example_id)
+            func.max(ORMDatasetExampleRevision.id).label("max_id"),
+        ).group_by(ORMDatasetExampleRevision.dataset_example_id)
 
-        if version_id:
+        if version_gid:
             if (
                 resolved_version_id := await session.scalar(
-                    select(DatasetVersion.id).where(
+                    select(ORMDatasetVersion.id).where(
                         and_(
-                            DatasetVersion.dataset_id == resolved_dataset_id,
-                            DatasetVersion.id == int(version_id.node_id),
+                            ORMDatasetVersion.dataset_id == resolved_dataset_id,
+                            ORMDatasetVersion.id == int(version_gid.node_id),
                         )
                     )
                 )
             ) is None:
-                return Response(
-                    content=f"No dataset version with id {version_id} can be found.",
+                raise HTTPException(
+                    detail=f"No dataset version with id {version_id} can be found.",
                     status_code=HTTP_404_NOT_FOUND,
                 )
             # if a version_id is provided, filter the subquery to only include revisions from that
             partial_subquery = partial_subquery.filter(
-                DatasetExampleRevision.dataset_version_id <= resolved_version_id
+                ORMDatasetExampleRevision.dataset_version_id <= resolved_version_id
             )
         else:
             if (
                 resolved_version_id := await session.scalar(
-                    select(func.max(DatasetVersion.id)).where(
-                        DatasetVersion.dataset_id == resolved_dataset_id
+                    select(func.max(ORMDatasetVersion.id)).where(
+                        ORMDatasetVersion.dataset_id == resolved_dataset_id
                     )
                 )
             ) is None:
-                return Response(
-                    content="Dataset has no versions.",
+                raise HTTPException(
+                    detail="Dataset has no versions.",
                     status_code=HTTP_404_NOT_FOUND,
                 )
 
         subquery = partial_subquery.subquery()
         # Query for the most recent example revisions that are not deleted
         query = (
-            select(DatasetExample, DatasetExampleRevision)
+            select(ORMDatasetExample, ORMDatasetExampleRevision)
             .join(
-                DatasetExampleRevision,
-                DatasetExample.id == DatasetExampleRevision.dataset_example_id,
+                ORMDatasetExampleRevision,
+                ORMDatasetExample.id == ORMDatasetExampleRevision.dataset_example_id,
             )
             .join(
                 subquery,
-                (subquery.c.max_id == DatasetExampleRevision.id),
+                (subquery.c.max_id == ORMDatasetExampleRevision.id),
             )
-            .filter(DatasetExample.dataset_id == resolved_dataset_id)
-            .filter(DatasetExampleRevision.revision_kind != "DELETE")
-            .order_by(DatasetExample.id.asc())
+            .filter(ORMDatasetExample.dataset_id == resolved_dataset_id)
+            .filter(ORMDatasetExampleRevision.revision_kind != "DELETE")
+            .order_by(ORMDatasetExample.id.asc())
         )
         examples = [
-            {
-                "id": str(GlobalID("DatasetExample", str(example.id))),
-                "input": revision.input,
-                "output": revision.output,
-                "metadata": revision.metadata_,
-                "updated_at": revision.created_at.isoformat(),
-            }
+            DatasetExample(
+                id=str(GlobalID("DatasetExample", str(example.id))),
+                input=revision.input,
+                output=revision.output,
+                metadata=revision.metadata_,
+                updated_at=revision.created_at,
+            )
             async for example, revision in await session.stream(query)
         ]
-    return JSONResponse(
-        {
-            "data": {
-                "dataset_id": str(GlobalID("Dataset", str(resolved_dataset_id))),
-                "version_id": str(GlobalID("DatasetVersion", str(resolved_version_id))),
-                "examples": examples,
-            }
-        }
+    return ListDatasetExamplesResponseBody(
+        data=ListDatasetExamplesData(
+            dataset_id=str(GlobalID("Dataset", str(resolved_dataset_id))),
+            version_id=str(GlobalID("DatasetVersion", str(resolved_version_id))),
+            examples=examples,
+        )
     )