arize-phoenix 4.26.0__tar.gz → 4.28.1__tar.gz

{arize_phoenix-4.26.0 → arize_phoenix-4.28.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: arize-phoenix
-Version: 4.26.0
+Version: 4.28.1
 Summary: AI Observability and Evaluation
 Project-URL: Documentation, https://docs.arize.com/phoenix/
 Project-URL: Issues, https://github.com/Arize-ai/phoenix/issues
@@ -45,8 +45,7 @@ Requires-Dist: pydantic!=2.0.*,<3,>=1.0
 Requires-Dist: pyjwt
 Requires-Dist: python-multipart
 Requires-Dist: scikit-learn
-Requires-Dist: scipy!=1.14.1; platform_system == 'Darwin'
-Requires-Dist: scipy; platform_system != 'Darwin'
+Requires-Dist: scipy
 Requires-Dist: sqlalchemy[asyncio]<3,>=2.0.4
 Requires-Dist: sqlean-py>=3.45.1
 Requires-Dist: starlette

{arize_phoenix-4.26.0 → arize_phoenix-4.28.1}/pyproject.toml

@@ -36,8 +36,7 @@ dependencies = [
   "typing-extensions>=4.5; python_version<'3.12'",
   # A minimum version of typing-extensions==4.6.0 is needed to avoid this issue on Python 3.12: https://github.com/Azure/azure-sdk-for-python/issues/33442#issuecomment-1847886784
   "typing-extensions>=4.6; python_version>='3.12'",
-  "scipy!=1.14.1; platform_system == 'Darwin'",  # MacOS installation issue: https://github.com/scipy/scipy/issues/21424
-  "scipy; platform_system != 'Darwin'",
+  "scipy",
   "wrapt",
   "protobuf>=3.20, <6.0",
   "grpcio",

{arize_phoenix-4.26.0 → arize_phoenix-4.28.1}/src/phoenix/auth.py

@@ -39,7 +39,10 @@ def validate_password_format(password: str) -> None:
         raise ValueError("Password cannot contain whitespace characters")
     if not password.isascii():
         raise ValueError("Password can contain only ASCII characters")
+    if not len(password) >= MIN_PASSWORD_LENGTH:
+        raise ValueError(f"Password must be at least {MIN_PASSWORD_LENGTH} characters long")
 
 
 EMAIL_PATTERN = re.compile(r"^[^@\s]+@[^@\s]+[.][^@\s]+\Z")
 NUM_ITERATIONS = 10_000
+MIN_PASSWORD_LENGTH = 4

{arize_phoenix-4.26.0 → arize_phoenix-4.28.1}/src/phoenix/inferences/fixtures.py

@@ -422,7 +422,7 @@ def get_inferences(
     Downloads primary and reference inferences for a fixture if they are not found
     locally.
     """
-    fixture = _get_fixture_by_name(fixture_name=fixture_name)
+    fixture = get_fixture_by_name(fixture_name=fixture_name)
     if no_internet:
         paths = {role: INFERENCES_DIR / path for role, path in fixture.paths()}
     else:
@@ -436,9 +436,11 @@ def get_inferences(
     if fixture.reference_file_name is not None:
         reference_inferences = Inferences(
             read_parquet(paths[InferencesRole.REFERENCE]),
-            fixture.reference_schema
-            if fixture.reference_schema is not None
-            else fixture.primary_schema,
+            (
+                fixture.reference_schema
+                if fixture.reference_schema is not None
+                else fixture.primary_schema
+            ),
             "training",
         )
     corpus_inferences = None
@@ -451,10 +453,14 @@ def get_inferences(
     return primary_inferences, reference_inferences, corpus_inferences
 
 
-def _get_fixture_by_name(fixture_name: str) -> Fixture:
+def get_fixture_by_name(fixture_name: str) -> Fixture:
     """
-    Returns the fixture whose name matches the input name. Raises a ValueError
-    if the input fixture name does not match any known fixture names.
+    Returns the fixture whose name matches the input name.
+
+    Raises
+    ------
+    ValueError
+        if the input fixture name does not match any known fixture names.
     """
     if fixture_name not in NAME_TO_FIXTURE:
         valid_fixture_names = ", ".join(NAME_TO_FIXTURE.keys())
@@ -496,7 +502,7 @@ def load_example(use_case: str) -> ExampleInferences:
             reference).
 
     """
-    fixture = _get_fixture_by_name(use_case)
+    fixture = get_fixture_by_name(use_case)
     primary_inferences, reference_inferences, corpus_inferences = get_inferences(use_case)
     print(f"📥 Loaded {use_case} example datasets.")
     print("ℹ️ About this use-case:")

{arize_phoenix-4.26.0 → arize_phoenix-4.28.1}/src/phoenix/server/api/context.py

@@ -2,6 +2,7 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, Optional
 
+from starlette.responses import Response as StarletteResponse
 from strawberry.fastapi import BaseContext
 
 from phoenix.core.model_schema import Model
@@ -77,7 +78,7 @@ class Context(BaseContext):
     secret: Optional[str] = None
 
     def get_secret(self) -> str:
-        """A type safe way to get the application secret. Throws an error if the secret is not set.
+        """A type-safe way to get the application secret. Throws an error if the secret is not set.
 
         Returns:
             str: the phoenix secret
@@ -88,3 +89,11 @@ class Context(BaseContext):
                 " Please set the PHOENIX_SECRET environment variable and re-deploy the application."
             )
         return self.secret
+
+    def get_response(self) -> StarletteResponse:
+        """
+        A type-safe way to get the response object. Throws an error if the response is not set.
+        """
+        if (response := self.response) is None:
+            raise ValueError("no response is set")
+        return response

{arize_phoenix-4.26.0 → arize_phoenix-4.28.1}/src/phoenix/server/api/mutations/__init__.py

@@ -1,6 +1,7 @@
 import strawberry
 
 from phoenix.server.api.mutations.api_key_mutations import ApiKeyMutationMixin
+from phoenix.server.api.mutations.auth_mutations import AuthMutationMixin
 from phoenix.server.api.mutations.dataset_mutations import DatasetMutationMixin
 from phoenix.server.api.mutations.experiment_mutations import ExperimentMutationMixin
 from phoenix.server.api.mutations.export_events_mutations import ExportEventsMutationMixin
@@ -12,13 +13,14 @@ from phoenix.server.api.mutations.user_mutations import UserMutationMixin
 
 @strawberry.type
 class Mutation(
-    ProjectMutationMixin,
+    ApiKeyMutationMixin,
+    AuthMutationMixin,
     DatasetMutationMixin,
     ExperimentMutationMixin,
     ExportEventsMutationMixin,
+    ProjectMutationMixin,
     SpanAnnotationMutationMixin,
     TraceAnnotationMutationMixin,
-    ApiKeyMutationMixin,
     UserMutationMixin,
 ):
     pass

arize_phoenix-4.28.1/src/phoenix/server/api/mutations/auth_mutations.py

@@ -0,0 +1,63 @@
+import asyncio
+from datetime import timedelta
+
+import strawberry
+from sqlalchemy import select
+from strawberry.types import Info
+
+from phoenix.auth import is_valid_password
+from phoenix.db import models
+from phoenix.server.api.context import Context
+from phoenix.server.api.mutations.auth import HasSecret
+
+PHOENIX_ACCESS_TOKEN_COOKIE_NAME = "phoenix-access-token"
+PHOENIX_ACCESS_TOKEN_COOKIE_MAX_AGE_IN_SECONDS = int(timedelta(days=31).total_seconds())
+
+
+@strawberry.input
+class LoginMutationInput:
+    email: str
+    password: str
+
+
+@strawberry.type
+class AuthMutationMixin:
+    @strawberry.mutation(permission_classes=[HasSecret])  # type: ignore
+    async def login(
+        self,
+        info: Info[Context, None],
+        input: LoginMutationInput,
+    ) -> None:
+        async with info.context.db() as session:
+            if (
+                user := await session.scalar(
+                    select(models.User).where(models.User.email == input.email)
+                )
+            ) is None or (password_hash := user.password_hash) is None:
+                raise ValueError
+        secret = info.context.get_secret()
+        loop = asyncio.get_running_loop()
+        if not await loop.run_in_executor(
+            executor=None,
+            func=lambda: is_valid_password(
+                password=input.password, salt=secret, password_hash=password_hash
+            ),
+        ):
+            raise ValueError
+        response = info.context.get_response()
+        response.set_cookie(
+            key=PHOENIX_ACCESS_TOKEN_COOKIE_NAME,
+            value="token",  # todo: compute access token
+            secure=True,
+            httponly=True,
+            samesite="strict",
+            max_age=PHOENIX_ACCESS_TOKEN_COOKIE_MAX_AGE_IN_SECONDS,
+        )
+
+    @strawberry.mutation(permission_classes=[HasSecret])  # type: ignore
+    async def logout(
+        self,
+        info: Info[Context, None],
+    ) -> None:
+        response = info.context.get_response()
+        response.delete_cookie(key=PHOENIX_ACCESS_TOKEN_COOKIE_NAME)

{arize_phoenix-4.26.0 → arize_phoenix-4.28.1}/src/phoenix/server/api/routers/v1/experiments.py

@@ -1,6 +1,6 @@
 from datetime import datetime
 from random import getrandbits
-from typing import Any, Dict, Optional
+from typing import Any, Dict, List, Optional
 
 from fastapi import APIRouter, HTTPException
 from pydantic import Field
@@ -252,3 +252,57 @@ async def get_experiment(request: Request, experiment_id: str) -> GetExperimentR
             updated_at=experiment.updated_at,
         )
     )
+
+
+class ListExperimentsResponseBody(ResponseBody[List[Experiment]]):
+    pass
+
+
+@router.get(
+    "/datasets/{dataset_id}/experiments",
+    operation_id="listExperiments",
+    summary="List experiments by dataset",
+    response_description="Experiments retrieved successfully",
+)
+async def list_experiments(
+    request: Request,
+    dataset_id: str,
+) -> ListExperimentsResponseBody:
+    dataset_gid = GlobalID.from_id(dataset_id)
+    try:
+        dataset_rowid = from_global_id_with_expected_type(dataset_gid, "Dataset")
+    except ValueError:
+        raise HTTPException(
+            detail=f"Dataset with ID {dataset_gid} does not exist",
+            status_code=HTTP_404_NOT_FOUND,
+        )
+    async with request.app.state.db() as session:
+        query = (
+            select(models.Experiment)
+            .where(models.Experiment.dataset_id == dataset_rowid)
+            .order_by(models.Experiment.id.desc())
+        )
+
+        result = await session.execute(query)
+        experiments = result.scalars().all()
+
+        if not experiments:
+            return ListExperimentsResponseBody(data=[])
+
+        data = [
+            Experiment(
+                id=str(GlobalID("Experiment", str(experiment.id))),
+                dataset_id=str(GlobalID("Dataset", str(experiment.dataset_id))),
+                dataset_version_id=str(
+                    GlobalID("DatasetVersion", str(experiment.dataset_version_id))
+                ),
+                repetitions=experiment.repetitions,
+                metadata=experiment.metadata_,
+                project_name=None,
+                created_at=experiment.created_at,
+                updated_at=experiment.updated_at,
+            )
+            for experiment in experiments
+        ]
+
+        return ListExperimentsResponseBody(data=data)

{arize_phoenix-4.26.0 → arize_phoenix-4.28.1}/src/phoenix/server/api/routers/v1/utils.py

@@ -1,6 +1,6 @@
-from typing import Any, Dict, Generic, List, Optional, TypedDict, Union
+from typing import Any, Dict, Generic, List, Optional, TypedDict, TypeVar, Union
 
-from typing_extensions import TypeAlias, TypeVar, assert_never
+from typing_extensions import TypeAlias, assert_never
 
 from .pydantic_compat import V1RoutesBaseModel
 

{arize_phoenix-4.26.0 → arize_phoenix-4.28.1}/src/phoenix/server/app.py

@@ -2,6 +2,7 @@ import asyncio
 import contextlib
 import json
 import logging
+from datetime import datetime, timedelta, timezone
 from functools import cached_property
 from pathlib import Path
 from types import MethodType
@@ -10,12 +11,14 @@ from typing import (
     Any,
     AsyncContextManager,
     AsyncIterator,
+    Awaitable,
     Callable,
     Dict,
     Iterable,
     List,
     NamedTuple,
     Optional,
+    Set,
     Tuple,
     Union,
     cast,
@@ -26,11 +29,8 @@ from fastapi import APIRouter, FastAPI
 from fastapi.middleware.gzip import GZipMiddleware
 from fastapi.responses import FileResponse
 from fastapi.utils import is_body_allowed_for_status_code
-from sqlalchemy.ext.asyncio import (
-    AsyncEngine,
-    AsyncSession,
-    async_sessionmaker,
-)
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession, async_sessionmaker
 from starlette.datastructures import State as StarletteState
 from starlette.exceptions import HTTPException
 from starlette.middleware import Middleware
@@ -46,12 +46,9 @@ from typing_extensions import TypeAlias
 
 import phoenix
 import phoenix.trace.v1 as pb
-from phoenix.config import (
-    DEFAULT_PROJECT_NAME,
-    SERVER_DIR,
-    server_instrumentation_is_enabled,
-)
+from phoenix.config import DEFAULT_PROJECT_NAME, SERVER_DIR, server_instrumentation_is_enabled
 from phoenix.core.model_schema import Model
+from phoenix.db import models
 from phoenix.db.bulk_inserter import BulkInserter
 from phoenix.db.engines import create_engine
 from phoenix.db.helpers import SupportedSQLDialect
@@ -82,7 +79,6 @@ from phoenix.server.api.dataloaders import (
     TokenCountDataLoader,
     TraceRowIdsDataLoader,
 )
-from phoenix.server.api.routers.auth import router as auth_router
 from phoenix.server.api.routers.v1 import REST_API_VERSION
 from phoenix.server.api.routers.v1 import router as v1_router
 from phoenix.server.api.schema import schema
@@ -93,9 +89,17 @@ from phoenix.server.telemetry import initialize_opentelemetry_tracer_provider
 from phoenix.server.types import (
     CanGetLastUpdatedAt,
     CanPutItem,
+    DaemonTask,
     DbSessionFactory,
     LastUpdatedAt,
 )
+from phoenix.trace.fixtures import (
+    get_evals_from_fixture,
+    get_trace_fixture_by_name,
+    load_example_traces,
+    reset_fixture_span_ids_and_timestamps,
+)
+from phoenix.trace.otel import decode_otlp_span, encode_span_to_otlp
 from phoenix.trace.schemas import Span
 from phoenix.utilities.client import PHOENIX_SERVER_VERSION_HEADER
 
@@ -103,12 +107,23 @@ if TYPE_CHECKING:
     from opentelemetry.trace import TracerProvider
 
 logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
 logger.addHandler(logging.NullHandler())
 
 router = APIRouter(include_in_schema=False)
 
 templates = Jinja2Templates(directory=SERVER_DIR / "templates")
 
+"""
+Threshold (in minutes) to determine if database is booted up for the first time.
+
+Used to assess whether the `default` project was created recently.
+If so, demo data is automatically ingested upon initial boot up to populate the database.
+"""
+NEW_DB_AGE_THRESHOLD_MINUTES = 2
+
+ProjectName: TypeAlias = str
+
 
 class AppConfig(NamedTuple):
     has_inferences: bool
@@ -226,9 +241,99 @@ def _db(engine: AsyncEngine) -> Callable[[], AsyncContextManager[AsyncSession]]:
     return factory
 
 
+class Scaffolder(DaemonTask):
+    def __init__(
+        self,
+        db: DbSessionFactory,
+        queue_span: Callable[[Span, ProjectName], Awaitable[None]],
+        queue_evaluation: Callable[[pb.Evaluation], Awaitable[None]],
+        tracing_fixture_names: Set[str] = set(),
+        force_fixture_ingestion: bool = False,
+    ) -> None:
+        super().__init__()
+        self._db = db
+        self._queue_span = queue_span
+        self._queue_evaluation = queue_evaluation
+        self._tracing_fixtures = set(
+            get_trace_fixture_by_name(name) for name in tracing_fixture_names
+        )
+        self._force_fixture_ingestion = force_fixture_ingestion
+
+    async def __aenter__(self) -> None:
+        await self.start()
+
+    async def __aexit__(self, *args: Any, **kwargs: Any) -> None:
+        await self.stop()
+
+    async def _run(self) -> None:
+        """
+        Main entry point for Scaffolder.
+        Determines whether to load fixtures and handles them.
+        """
+        if await self._should_load_fixtures():
+            logger.info("Loading trace fixtures.")
+            await self._handle_tracing_fixtures()
+            logger.info("Finished loading fixtures.")
+        else:
+            logger.info("DB is not new, avoid loading demo fixtures.")
+
+    async def _should_load_fixtures(self) -> bool:
+        if self._force_fixture_ingestion:
+            return True
+
+        async with self._db() as session:
+            created_at = await session.scalar(
+                select(models.Project.created_at).where(models.Project.name == "default")
+            )
+        if created_at is None:
+            return False
+
+        is_new_db = datetime.now(timezone.utc) - created_at < timedelta(
+            minutes=NEW_DB_AGE_THRESHOLD_MINUTES
+        )
+        return is_new_db
+
+    async def _handle_tracing_fixtures(self) -> None:
+        """
+        Main handler for processing trace fixtures. Process each fixture by
+        loading its trace dataframe, gettting and processings its
+        spans and evals, and queuing.
+        """
+        loop = asyncio.get_running_loop()
+        for fixture in self._tracing_fixtures:
+            try:
+                trace_ds = await loop.run_in_executor(None, load_example_traces, fixture.name)
+
+                fixture_spans, fixture_evals = await loop.run_in_executor(
+                    None,
+                    reset_fixture_span_ids_and_timestamps,
+                    (
+                        # Apply `encode` here because legacy jsonl files contains UUIDs as strings.
+                        # `encode` removes the hyphens in the UUIDs.
+                        decode_otlp_span(encode_span_to_otlp(span))
+                        for span in trace_ds.to_spans()
+                    ),
+                    get_evals_from_fixture(fixture.name),
+                )
+
+                project_name = fixture.project_name or fixture.name
+                logger.info(f"Loading '{project_name}' fixtures...")
+                for span in fixture_spans:
+                    await self._queue_span(span, project_name)
+                for evaluation in fixture_evals:
+                    await self._queue_evaluation(evaluation)
+
+            except FileNotFoundError:
+                logger.warning(f"Fixture file not found for '{fixture.name}'")
+            except ValueError as e:
+                logger.error(f"Error processing fixture '{fixture.name}': {e}")
+            except Exception as e:
+                logger.error(f"Unexpected error processing fixture '{fixture.name}': {e}")
+
+
 def _lifespan(
     *,
-    dialect: SupportedSQLDialect,
+    db: DbSessionFactory,
     bulk_inserter: BulkInserter,
     dml_event_handler: DmlEventHandler,
     tracer_provider: Optional["TracerProvider"] = None,
@@ -236,11 +341,13 @@ def _lifespan(
     startup_callbacks: Iterable[Callable[[], None]] = (),
     shutdown_callbacks: Iterable[Callable[[], None]] = (),
     read_only: bool = False,
+    tracing_fixture_names: Set[str] = set(),
+    force_fixture_ingestion: bool = False,
 ) -> StatefulLifespan[FastAPI]:
     @contextlib.asynccontextmanager
     async def lifespan(_: FastAPI) -> AsyncIterator[Dict[str, Any]]:
         global DB_MUTEX
-        DB_MUTEX = asyncio.Lock() if dialect is SupportedSQLDialect.SQLITE else None
+        DB_MUTEX = asyncio.Lock() if db.dialect is SupportedSQLDialect.SQLITE else None
         async with bulk_inserter as (
             enqueue,
             queue_span,
@@ -251,7 +358,13 @@ def _lifespan(
             disabled=read_only,
             tracer_provider=tracer_provider,
             enable_prometheus=enable_prometheus,
-        ), dml_event_handler:
+        ), dml_event_handler, Scaffolder(
+            db=db,
+            queue_span=queue_span,
+            queue_evaluation=queue_evaluation,
+            tracing_fixture_names=tracing_fixture_names,
+            force_fixture_ingestion=force_fixture_ingestion,
+        ):
             for callback in startup_callbacks:
                 callback()
             yield {
@@ -317,17 +430,19 @@ def create_graphql_router(
                 dataset_example_spans=DatasetExampleSpansDataLoader(db),
                 document_evaluation_summaries=DocumentEvaluationSummaryDataLoader(
                     db,
-                    cache_map=cache_for_dataloaders.document_evaluation_summary
-                    if cache_for_dataloaders
-                    else None,
+                    cache_map=(
+                        cache_for_dataloaders.document_evaluation_summary
+                        if cache_for_dataloaders
+                        else None
+                    ),
                 ),
                 document_evaluations=DocumentEvaluationsDataLoader(db),
                 document_retrieval_metrics=DocumentRetrievalMetricsDataLoader(db),
                 annotation_summaries=AnnotationSummaryDataLoader(
                     db,
-                    cache_map=cache_for_dataloaders.annotation_summary
-                    if cache_for_dataloaders
-                    else None,
+                    cache_map=(
+                        cache_for_dataloaders.annotation_summary if cache_for_dataloaders else None
+                    ),
                 ),
                 experiment_annotation_summaries=ExperimentAnnotationSummaryDataLoader(db),
                 experiment_error_rates=ExperimentErrorRatesDataLoader(db),
@@ -335,15 +450,17 @@ def create_graphql_router(
                 experiment_sequence_number=ExperimentSequenceNumberDataLoader(db),
                 latency_ms_quantile=LatencyMsQuantileDataLoader(
                     db,
-                    cache_map=cache_for_dataloaders.latency_ms_quantile
-                    if cache_for_dataloaders
-                    else None,
+                    cache_map=(
+                        cache_for_dataloaders.latency_ms_quantile if cache_for_dataloaders else None
+                    ),
                 ),
                 min_start_or_max_end_times=MinStartOrMaxEndTimeDataLoader(
                     db,
-                    cache_map=cache_for_dataloaders.min_start_or_max_end_time
-                    if cache_for_dataloaders
-                    else None,
+                    cache_map=(
+                        cache_for_dataloaders.min_start_or_max_end_time
+                        if cache_for_dataloaders
+                        else None
+                    ),
                 ),
                 record_counts=RecordCountDataLoader(
                     db,
@@ -438,6 +555,8 @@ def create_app(
     startup_callbacks: Iterable[Callable[[], None]] = (),
     shutdown_callbacks: Iterable[Callable[[], None]] = (),
     secret: Optional[str] = None,
+    tracing_fixture_names: Set[str] = set(),
+    force_fixture_ingestion: bool = False,
 ) -> FastAPI:
     startup_callbacks_list: List[Callable[[], None]] = list(startup_callbacks)
     shutdown_callbacks_list: List[Callable[[], None]] = list(shutdown_callbacks)
@@ -510,11 +629,12 @@ def create_app(
         prometheus_middlewares = [Middleware(PrometheusMiddleware)]
     else:
         prometheus_middlewares = []
+
     app = FastAPI(
         title="Arize-Phoenix REST API",
         version=REST_API_VERSION,
         lifespan=_lifespan(
-            dialect=db.dialect,
+            db=db,
             read_only=read_only,
             bulk_inserter=bulk_inserter,
             dml_event_handler=dml_event_handler,
@@ -522,6 +642,8 @@ def create_app(
             enable_prometheus=enable_prometheus,
             shutdown_callbacks=shutdown_callbacks_list,
             startup_callbacks=startup_callbacks_list,
+            tracing_fixture_names=tracing_fixture_names,
+            force_fixture_ingestion=force_fixture_ingestion,
         ),
         middleware=[
             Middleware(HeadersMiddleware),
@@ -539,8 +661,6 @@ def create_app(
     app.include_router(router)
     app.include_router(graphql_router)
     app.add_middleware(GZipMiddleware)
-    if authentication_enabled:
-        app.include_router(auth_router)
     if serve_ui:
         app.mount(
             "/",