arize-phoenix 4.10.2rc2__tar.gz → 4.11.0__tar.gz

{arize_phoenix-4.10.2rc2 → arize_phoenix-4.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: arize-phoenix
-Version: 4.10.2rc2
+Version: 4.11.0
 Summary: AI Observability and Evaluation
 Project-URL: Documentation, https://docs.arize.com/phoenix/
 Project-URL: Issues, https://github.com/Arize-ai/phoenix/issues
@@ -22,7 +22,6 @@ 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
@@ -41,8 +40,8 @@ Requires-Dist: pandas>=1.0
 Requires-Dist: protobuf<6.0,>=3.20
 Requires-Dist: psutil
 Requires-Dist: pyarrow
-Requires-Dist: pydantic<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
@@ -57,9 +56,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.10.2rc2 → arize_phoenix-4.11.0}/pyproject.toml

@@ -59,8 +59,7 @@ dependencies = [
   "cachetools",
   "python-multipart",  # see https://www.starlette.io/#dependencies
   "arize-phoenix-evals>=0.13.1",
-  "fastapi",
-  "pydantic>=1.0,<3",
+  "pyyaml", # for OpenAPI
 ]
 dynamic = ["version"]
 
@@ -110,7 +109,7 @@ container = [
   "opentelemetry-proto>=1.12.0",
   "opentelemetry-exporter-otlp",
   "opentelemetry-semantic-conventions",
-  "opentelemetry-instrumentation-fastapi",
+  "opentelemetry-instrumentation-starlette",
   "opentelemetry-instrumentation-sqlalchemy",
   "opentelemetry-instrumentation-grpc",
   "py-grpc-prometheus",
@@ -160,10 +159,8 @@ dependencies = [
   "protobuf==3.20",  # version minimum (for tests)
   "responses",
   "tiktoken",
-  "typing-extensions==4.5.0; python_version=='3.8'",
-  "typing-extensions==4.6.0; python_version=='3.9'",
-  "pydantic==1.9.0; python_version<='3.9'",  # minimum version of pydantic compatible with openai
-  "pydantic==2.8.2; python_version=='3.12'",
+  "typing-extensions==4.5.0; python_version<'3.12'",
+  "typing-extensions==4.6.0; python_version>='3.12'",
   "httpx", # For OpenAI testing
   "respx", # For OpenAI testing
   "nest-asyncio", # for executor testing
@@ -190,15 +187,12 @@ dependencies = [
   "opentelemetry-proto>=1.12.0",
   "opentelemetry-exporter-otlp",
   "opentelemetry-semantic-conventions",
-  "opentelemetry-instrumentation-fastapi",
+  "opentelemetry-instrumentation-starlette",
   "opentelemetry-instrumentation-sqlalchemy",
   "opentelemetry-instrumentation-grpc",
   "py-grpc-prometheus",
   "strawberry-graphql[opentelemetry]==0.235.0",  # need to pin version because we're monkey-patching
   "requests",  # this is needed to type-check third-party packages
-  "pydantic==1.10.17; python_version=='3.8'",  # lower minor versions of pydantic break strawberry mypy plugin
-  "pydantic==1.10.17; python_version=='3.9'",  # lower minor versions of pydantic break strawberry mypy plugin
-  "pydantic==2.8.2; python_version=='3.12'",
 ]
 
 [[tool.hatch.envs.type.matrix]]
@@ -293,6 +287,7 @@ testpypi = [
   "twine upload  --verbose --repository testpypi dist/*",
 ]
 pypi = [
+  "check-wheel-contents dist/",
   "twine upload --verbose dist/*",
 ]
 
@@ -312,12 +307,11 @@ build = 'strawberry export-schema phoenix.server.api.schema:schema > app/schema.
 
 [tool.hatch.envs.openapi]
 dependencies = [
-  "pydantic==2.8.2",
-  "fastapi==0.111.0",
+  "pyyaml",
 ]
 
 [tool.hatch.envs.openapi.scripts]
-build = "python -m phoenix.server.api.openapi.main > schemas/openapi.json"
+build = 'python -m phoenix.server.api.openapi.main > schemas/openapi.yaml'
 
 [tool.hatch.envs.proto]
 detached = true
@@ -382,7 +376,6 @@ module = [
   "sqlean",
   "grpc.*",
   "py_grpc_prometheus.*",
-  "orjson",  # suppress fastapi internal type errors
 ]
 ignore_missing_imports = true
 
@@ -412,4 +405,4 @@ select = ["E", "F", "W", "I", "NPY201"]
 force-single-line = false
 
 [tool.ruff.format]
-line-ending = "lf"
+line-ending = "lf"

{arize_phoenix-4.10.2rc2 → arize_phoenix-4.11.0}/src/phoenix/server/api/context.py

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

arize_phoenix-4.11.0/src/phoenix/server/api/openapi/main.py

@@ -0,0 +1,6 @@
+from .schema import get_openapi_schema
+
+if __name__ == "__main__":
+    import yaml  # type: ignore
+
+    print(yaml.dump(get_openapi_schema(), indent=2))

arize_phoenix-4.11.0/src/phoenix/server/api/openapi/schema.py

@@ -0,0 +1,16 @@
+from typing import Any
+
+from starlette.schemas import SchemaGenerator
+
+from phoenix.server.api.routers.v1 import V1_ROUTES
+
+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

arize_phoenix-4.11.0/src/phoenix/server/api/routers/v1/__init__.py

@@ -0,0 +1,89 @@
+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 starlette.status import HTTP_403_FORBIDDEN
+
+from . import (
+    datasets,
+    evaluations,
+    experiment_evaluations,
+    experiment_runs,
+    experiments,
+    spans,
+    traces,
+)
+from .dataset_examples import list_dataset_examples
+
+
+@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)
+
+
+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"],
+    ),
+]

arize_phoenix-4.11.0/src/phoenix/server/api/routers/v1/dataset_examples.py

@@ -0,0 +1,178 @@
+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
+        )
+
+    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
+        )
+
+    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))
+            )
+        ) is None:
+            return Response(
+                content=f"No dataset with id {dataset_id} 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)
+
+        if version_id:
+            if (
+                resolved_version_id := await session.scalar(
+                    select(DatasetVersion.id).where(
+                        and_(
+                            DatasetVersion.dataset_id == resolved_dataset_id,
+                            DatasetVersion.id == int(version_id.node_id),
+                        )
+                    )
+                )
+            ) is None:
+                return Response(
+                    content=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
+            )
+        else:
+            if (
+                resolved_version_id := await session.scalar(
+                    select(func.max(DatasetVersion.id)).where(
+                        DatasetVersion.dataset_id == resolved_dataset_id
+                    )
+                )
+            ) is None:
+                return Response(
+                    content="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)
+            .join(
+                DatasetExampleRevision,
+                DatasetExample.id == DatasetExampleRevision.dataset_example_id,
+            )
+            .join(
+                subquery,
+                (subquery.c.max_id == DatasetExampleRevision.id),
+            )
+            .filter(DatasetExample.dataset_id == resolved_dataset_id)
+            .filter(DatasetExampleRevision.revision_kind != "DELETE")
+            .order_by(DatasetExample.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(),
+            }
+            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,
+            }
+        }
+    )