arize-phoenix 4.10.1__tar.gz → 4.10.2rc1__tar.gz

{arize_phoenix-4.10.1 → arize_phoenix-4.10.2rc1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: arize-phoenix
-Version: 4.10.1
+Version: 4.10.2rc1
 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<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.10.1 → arize_phoenix-4.10.2rc1}/pyproject.toml

@@ -59,7 +59,8 @@ dependencies = [
   "cachetools",
   "python-multipart",  # see https://www.starlette.io/#dependencies
   "arize-phoenix-evals>=0.13.1",
-  "pyyaml", # for OpenAPI
+  "fastapi",
+  "pydantic>=1.0,<3",
 ]
 dynamic = ["version"]
 
@@ -109,7 +110,7 @@ container = [
   "opentelemetry-proto>=1.12.0",
   "opentelemetry-exporter-otlp",
   "opentelemetry-semantic-conventions",
-  "opentelemetry-instrumentation-starlette",
+  "opentelemetry-instrumentation-fastapi",
   "opentelemetry-instrumentation-sqlalchemy",
   "opentelemetry-instrumentation-grpc",
   "py-grpc-prometheus",
@@ -159,8 +160,10 @@ dependencies = [
   "protobuf==3.20",  # version minimum (for tests)
   "responses",
   "tiktoken",
-  "typing-extensions==4.5.0; python_version<'3.12'",
-  "typing-extensions==4.6.0; python_version>='3.12'",
+  "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'",
   "httpx", # For OpenAI testing
   "respx", # For OpenAI testing
   "nest-asyncio", # for executor testing
@@ -187,12 +190,15 @@ dependencies = [
   "opentelemetry-proto>=1.12.0",
   "opentelemetry-exporter-otlp",
   "opentelemetry-semantic-conventions",
-  "opentelemetry-instrumentation-starlette",
+  "opentelemetry-instrumentation-fastapi",
   "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]]
@@ -307,11 +313,12 @@ build = 'strawberry export-schema phoenix.server.api.schema:schema > app/schema.
 
 [tool.hatch.envs.openapi]
 dependencies = [
-  "pyyaml",
+  "pydantic==2.8.2",
+  "fastapi==0.111.0",
 ]
 
 [tool.hatch.envs.openapi.scripts]
-build = 'python -m phoenix.server.api.openapi.main > schemas/openapi.yaml'
+build = "python -m phoenix.server.api.openapi.main > schemas/openapi.json"
 
 [tool.hatch.envs.proto]
 detached = true
@@ -376,6 +383,7 @@ module = [
   "sqlean",
   "grpc.*",
   "py_grpc_prometheus.*",
+  "orjson",  # suppress fastapi internal type errors
 ]
 ignore_missing_imports = true
 

{arize_phoenix-4.10.1 → arize_phoenix-4.10.2rc1}/src/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
@@ -27,6 +25,7 @@ from phoenix.server.api.dataloaders import (
     MinStartOrMaxEndTimeDataLoader,
     ProjectByNameDataLoader,
     RecordCountDataLoader,
+    SpanAnnotationsDataLoader,
     SpanDescendantsDataLoader,
     SpanEvaluationsDataLoader,
     SpanProjectsDataLoader,
@@ -59,15 +58,14 @@ class DataLoaders:
     trace_evaluations: TraceEvaluationsDataLoader
     trace_row_ids: TraceRowIdsDataLoader
     project_by_name: ProjectByNameDataLoader
+    span_annotations: SpanAnnotationsDataLoader
 
 
 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]

{arize_phoenix-4.10.1 → arize_phoenix-4.10.2rc1}/src/phoenix/server/api/dataloaders/__init__.py

@@ -26,6 +26,7 @@ from .latency_ms_quantile import LatencyMsQuantileCache, LatencyMsQuantileDataLo
 from .min_start_or_max_end_times import MinStartOrMaxEndTimeCache, MinStartOrMaxEndTimeDataLoader
 from .project_by_name import ProjectByNameDataLoader
 from .record_counts import RecordCountCache, RecordCountDataLoader
+from .span_annotations import SpanAnnotationsDataLoader
 from .span_descendants import SpanDescendantsDataLoader
 from .span_evaluations import SpanEvaluationsDataLoader
 from .span_projects import SpanProjectsDataLoader
@@ -56,6 +57,7 @@ __all__ = [
     "TraceEvaluationsDataLoader",
     "TraceRowIdsDataLoader",
     "ProjectByNameDataLoader",
+    "SpanAnnotationsDataLoader",
 ]
 
 

arize_phoenix-4.10.2rc1/src/phoenix/server/api/dataloaders/span_annotations.py

@@ -0,0 +1,35 @@
+from collections import defaultdict
+from typing import (
+    AsyncContextManager,
+    Callable,
+    DefaultDict,
+    List,
+)
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+from strawberry.dataloader import DataLoader
+from typing_extensions import TypeAlias
+
+from phoenix.db import models
+from phoenix.server.api.types.SpanAnnotation import SpanAnnotation, to_gql_span_annotation
+
+Key: TypeAlias = int
+Result: TypeAlias = List[SpanAnnotation]
+
+
+class SpanAnnotationsDataLoader(DataLoader[Key, Result]):
+    def __init__(self, db: Callable[[], AsyncContextManager[AsyncSession]]) -> None:
+        super().__init__(load_fn=self._load_fn)
+        self._db = db
+
+    async def _load_fn(self, keys: List[Key]) -> List[Result]:
+        span_annotations_by_id: DefaultDict[Key, Result] = defaultdict(list)
+        msa = models.SpanAnnotation
+        async with self._db() as session:
+            data = await session.stream_scalars(select(msa).where(msa.span_rowid.in_(keys)))
+            async for span_annotation in data:
+                span_annotations_by_id[span_annotation.span_rowid].append(
+                    to_gql_span_annotation(span_annotation)
+                )
+        return [span_annotations_by_id[key] for key in keys]

arize_phoenix-4.10.2rc1/src/phoenix/server/api/openapi/main.py

@@ -0,0 +1,22 @@
+import json
+from argparse import ArgumentParser
+from typing import Optional, Tuple
+
+from .schema import get_openapi_schema
+
+if __name__ == "__main__":
+    parser = ArgumentParser()
+    parser.add_argument(
+        "--compress",
+        action="store_true",
+        help="Whether to output a compressed version of the OpenAPI schema",
+    )
+    args = parser.parse_args()
+
+    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))

arize_phoenix-4.10.2rc1/src/phoenix/server/api/openapi/schema.py

@@ -0,0 +1,16 @@
+from typing import Any, Dict
+
+from fastapi.openapi.utils import get_openapi
+
+from phoenix.server.api.routers.v1 import REST_API_VERSION
+from phoenix.server.api.routers.v1 import router as v1_router
+
+
+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,
+    )

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

@@ -0,0 +1,42 @@
+from fastapi import APIRouter, Depends, HTTPException, Request
+from starlette.status import HTTP_403_FORBIDDEN
+
+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
+
+REST_API_VERSION = "1.0"
+
+
+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)

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

@@ -0,0 +1,157 @@
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+from fastapi import APIRouter, HTTPException, Path, Query
+from pydantic import BaseModel
+from sqlalchemy import and_, func, select
+from starlette.requests import Request
+from starlette.status import HTTP_404_NOT_FOUND
+from strawberry.relay import GlobalID
+
+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 .utils import ResponseBody, add_errors_to_responses
+
+router = APIRouter(tags=["datasets"])
+
+
+class DatasetExample(BaseModel):
+    id: str
+    input: Dict[str, Any]
+    output: Dict[str, Any]
+    metadata: Dict[str, Any]
+    updated_at: datetime
+
+
+class ListDatasetExamplesData(BaseModel):
+    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_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(ORMDataset.id).where(ORMDataset.id == int(dataset_gid.node_id))
+            )
+        ) is None:
+            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(ORMDatasetExampleRevision.id).label("max_id"),
+        ).group_by(ORMDatasetExampleRevision.dataset_example_id)
+
+        if version_gid:
+            if (
+                resolved_version_id := await session.scalar(
+                    select(ORMDatasetVersion.id).where(
+                        and_(
+                            ORMDatasetVersion.dataset_id == resolved_dataset_id,
+                            ORMDatasetVersion.id == int(version_gid.node_id),
+                        )
+                    )
+                )
+            ) is None:
+                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(
+                ORMDatasetExampleRevision.dataset_version_id <= resolved_version_id
+            )
+        else:
+            if (
+                resolved_version_id := await session.scalar(
+                    select(func.max(ORMDatasetVersion.id)).where(
+                        ORMDatasetVersion.dataset_id == resolved_dataset_id
+                    )
+                )
+            ) is None:
+                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(ORMDatasetExample, ORMDatasetExampleRevision)
+            .join(
+                ORMDatasetExampleRevision,
+                ORMDatasetExample.id == ORMDatasetExampleRevision.dataset_example_id,
+            )
+            .join(
+                subquery,
+                (subquery.c.max_id == ORMDatasetExampleRevision.id),
+            )
+            .filter(ORMDatasetExample.dataset_id == resolved_dataset_id)
+            .filter(ORMDatasetExampleRevision.revision_kind != "DELETE")
+            .order_by(ORMDatasetExample.id.asc())
+        )
+        examples = [
+            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 ListDatasetExamplesResponseBody(
+        data=ListDatasetExamplesData(
+            dataset_id=str(GlobalID("Dataset", str(resolved_dataset_id))),
+            version_id=str(GlobalID("DatasetVersion", str(resolved_version_id))),
+            examples=examples,
+        )
+    )