arize-phoenix 4.12.0rc1__tar.gz → 4.12.1rc1__tar.gz

{arize_phoenix-4.12.0rc1 → arize_phoenix-4.12.1rc1}/PKG-INFO

@@ -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 → arize_phoenix-4.12.1rc1}/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,!=2.0.*,<3,", # exclude 2.0.* since it does not support the `json_encoders` configuration setting
 ]
 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]]
@@ -283,11 +289,11 @@ dependencies = [
 
 [tool.hatch.envs.publish.scripts]
 testpypi = [
-  "check-wheel-contents dist/",
+  #"check-wheel-contents dist/",
   "twine upload  --verbose --repository testpypi dist/*",
 ]
 pypi = [
-  "check-wheel-contents dist/",
+  #"check-wheel-contents dist/",
   "twine upload --verbose dist/*",
 ]
 
@@ -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.12.0rc1 → arize_phoenix-4.12.1rc1}/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
@@ -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]

arize_phoenix-4.12.1rc1/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.12.1rc1/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.12.1rc1/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.12.1rc1/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 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 .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_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,
+        )
+    )