arize-phoenix 4.4.4rc6__py3-none-any.whl → 4.5.0__py3-none-any.whl

phoenix/server/app.py

@@ -33,6 +33,7 @@ from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoin
 from starlette.requests import Request
 from starlette.responses import FileResponse, PlainTextResponse, Response
 from starlette.routing import Mount, Route
+from starlette.schemas import SchemaGenerator
 from starlette.staticfiles import StaticFiles
 from starlette.templating import Jinja2Templates
 from starlette.types import Scope, StatefulLifespan
@@ -56,30 +57,19 @@ from phoenix.exceptions import PhoenixMigrationError
 from phoenix.pointcloud.umap_parameters import UMAPParameters
 from phoenix.server.api.context import Context, DataLoaders
 from phoenix.server.api.dataloaders import (
-    AverageExperimentRunLatencyDataLoader,
     CacheForDataLoaders,
-    DatasetExampleRevisionsDataLoader,
-    DatasetExampleSpansDataLoader,
     DocumentEvaluationsDataLoader,
     DocumentEvaluationSummaryDataLoader,
     DocumentRetrievalMetricsDataLoader,
     EvaluationSummaryDataLoader,
-    ExperimentAnnotationSummaryDataLoader,
-    ExperimentErrorRatesDataLoader,
-    ExperimentRunCountsDataLoader,
-    ExperimentSequenceNumberDataLoader,
     LatencyMsQuantileDataLoader,
     MinStartOrMaxEndTimeDataLoader,
-    ProjectByNameDataLoader,
     RecordCountDataLoader,
     SpanDescendantsDataLoader,
     SpanEvaluationsDataLoader,
-    SpanProjectsDataLoader,
     TokenCountDataLoader,
     TraceEvaluationsDataLoader,
-    TraceRowIdsDataLoader,
 )
-from phoenix.server.api.openapi.schema import OPENAPI_SCHEMA_GENERATOR
 from phoenix.server.api.routers.v1 import V1_ROUTES
 from phoenix.server.api.schema import schema
 from phoenix.server.grpc_server import GrpcServer
@@ -94,6 +84,10 @@ logger = logging.getLogger(__name__)
 
 templates = Jinja2Templates(directory=SERVER_DIR / "templates")
 
+schemas = SchemaGenerator(
+    {"openapi": "3.0.0", "info": {"title": "ArizePhoenix API", "version": "1.0"}}
+)
+
 
 class AppConfig(NamedTuple):
     has_inferences: bool
@@ -132,7 +126,6 @@ class Static(StaticFiles):
                     "n_neighbors": self._app_config.n_neighbors,
                     "n_samples": self._app_config.n_samples,
                     "basename": request.scope.get("root_path", ""),
-                    "platform_version": phoenix.__version__,
                     "request": request,
                 },
             )
@@ -192,9 +185,6 @@ class GraphQLWithContext(GraphQL):  # type: ignore
             export_path=self.export_path,
             streaming_last_updated_at=self.streaming_last_updated_at,
             data_loaders=DataLoaders(
-                average_experiment_run_latency=AverageExperimentRunLatencyDataLoader(self.db),
-                dataset_example_revisions=DatasetExampleRevisionsDataLoader(self.db),
-                dataset_example_spans=DatasetExampleSpansDataLoader(self.db),
                 document_evaluation_summaries=DocumentEvaluationSummaryDataLoader(
                     self.db,
                     cache_map=self.cache_for_dataloaders.document_evaluation_summary
@@ -209,10 +199,6 @@ class GraphQLWithContext(GraphQL):  # type: ignore
                     if self.cache_for_dataloaders
                     else None,
                 ),
-                experiment_annotation_summaries=ExperimentAnnotationSummaryDataLoader(self.db),
-                experiment_error_rates=ExperimentErrorRatesDataLoader(self.db),
-                experiment_run_counts=ExperimentRunCountsDataLoader(self.db),
-                experiment_sequence_number=ExperimentSequenceNumberDataLoader(self.db),
                 latency_ms_quantile=LatencyMsQuantileDataLoader(
                     self.db,
                     cache_map=self.cache_for_dataloaders.latency_ms_quantile
@@ -233,7 +219,6 @@ class GraphQLWithContext(GraphQL):  # type: ignore
                 ),
                 span_descendants=SpanDescendantsDataLoader(self.db),
                 span_evaluations=SpanEvaluationsDataLoader(self.db),
-                span_projects=SpanProjectsDataLoader(self.db),
                 token_counts=TokenCountDataLoader(
                     self.db,
                     cache_map=self.cache_for_dataloaders.token_count
@@ -241,8 +226,6 @@ class GraphQLWithContext(GraphQL):  # type: ignore
                     else None,
                 ),
                 trace_evaluations=TraceEvaluationsDataLoader(self.db),
-                trace_row_ids=TraceRowIdsDataLoader(self.db),
-                project_by_name=ProjectByNameDataLoader(self.db),
             ),
             cache_for_dataloaders=self.cache_for_dataloaders,
             read_only=self.read_only,
@@ -289,11 +272,7 @@ def _lifespan(
 ) -> StatefulLifespan[Starlette]:
     @contextlib.asynccontextmanager
     async def lifespan(_: Starlette) -> AsyncIterator[Dict[str, Any]]:
-        async with bulk_inserter as (
-            queue_span,
-            queue_evaluation,
-            enqueue_operation,
-        ), GrpcServer(
+        async with bulk_inserter as (queue_span, queue_evaluation), GrpcServer(
             queue_span,
             disabled=read_only,
             tracer_provider=tracer_provider,
@@ -302,7 +281,6 @@ def _lifespan(
             yield {
                 "queue_span_for_bulk_insert": queue_span,
                 "queue_evaluation_for_bulk_insert": queue_evaluation,
-                "enqueue_operation": enqueue_operation,
             }
         for clean_up in clean_ups:
             clean_up()
@@ -315,63 +293,15 @@ async def check_healthz(_: Request) -> PlainTextResponse:
 
 
 async def openapi_schema(request: Request) -> Response:
-    return OPENAPI_SCHEMA_GENERATOR.OpenAPIResponse(request=request)
+    return schemas.OpenAPIResponse(request=request)
 
 
 async def api_docs(request: Request) -> Response:
     return get_swagger_ui_html(openapi_url="/schema", title="arize-phoenix API")
 
 
-class SessionFactory:
-    def __init__(
-        self,
-        session_factory: Callable[[], AsyncContextManager[AsyncSession]],
-        dialect: str,
-    ):
-        self.session_factory = session_factory
-        self.dialect = SupportedSQLDialect(dialect)
-
-    def __call__(self) -> AsyncContextManager[AsyncSession]:
-        return self.session_factory()
-
-
-def create_engine_and_run_migrations(
-    database_url: str,
-) -> AsyncEngine:
-    try:
-        return create_engine(database_url)
-    except PhoenixMigrationError as e:
-        msg = (
-            "\n\n⚠️⚠️ Phoenix failed to migrate the database to the latest version. ⚠️⚠️\n\n"
-            "The database may be in a dirty state. To resolve this, the Alembic CLI can be used\n"
-            "from the `src/phoenix/db` directory inside the Phoenix project root. From here,\n"
-            "revert any partial migrations and run `alembic stamp` to reset the migration state,\n"
-            "then try starting Phoenix again.\n\n"
-            "If issues persist, please reach out for support in the Arize community Slack:\n"
-            "https://arize-ai.slack.com\n\n"
-            "You can also refer to the Alembic documentation for more information:\n"
-            "https://alembic.sqlalchemy.org/en/latest/tutorial.html\n\n"
-            ""
-        )
-        raise PhoenixMigrationError(msg) from e
-
-
-def instrument_engine_if_enabled(engine: AsyncEngine) -> List[Callable[[], None]]:
-    instrumentation_cleanups = []
-    if server_instrumentation_is_enabled():
-        from opentelemetry.instrumentation.sqlalchemy import SQLAlchemyInstrumentor
-
-        tracer_provider = initialize_opentelemetry_tracer_provider()
-        SQLAlchemyInstrumentor().instrument(
-            engine=engine.sync_engine,
-            tracer_provider=tracer_provider,
-        )
-        instrumentation_cleanups.append(SQLAlchemyInstrumentor().uninstrument)
-    return instrumentation_cleanups
-
-
 def create_app(
-    db: SessionFactory,
+    database_url: str,
     export_path: Path,
     model: Model,
     umap_params: UMAPParameters,
@@ -381,10 +311,8 @@ def create_app(
     enable_prometheus: bool = False,
     initial_spans: Optional[Iterable[Union[Span, Tuple[Span, str]]]] = None,
     initial_evaluations: Optional[Iterable[pb.Evaluation]] = None,
-    serve_ui: bool = True,
-    clean_up_callbacks: List[Callable[[], None]] = [],
 ) -> Starlette:
-    clean_ups: List[Callable[[], None]] = clean_up_callbacks  # To be called at app shutdown.
+    clean_ups: List[Callable[[], None]] = []  # To be called at app shutdown.
     initial_batch_of_spans: Iterable[Tuple[Span, str]] = (
         ()
         if initial_spans is None
@@ -394,10 +322,28 @@ def create_app(
         )
     )
     initial_batch_of_evaluations = () if initial_evaluations is None else initial_evaluations
+    try:
+        engine = create_engine(database_url)
+    except PhoenixMigrationError as e:
+        msg = (
+            "\n\n⚠️⚠️ Phoenix failed to migrate the database to the latest version. ⚠️⚠️\n\n"
+            "The database may be in a dirty state. To resolve this, the Alembic CLI can be used\n"
+            "from the `src/phoenix/db` directory inside the Phoenix project root. From here,\n"
+            "revert any partial migrations and run `alembic stamp` to reset the migration state,\n"
+            "then try starting Phoenix again.\n\n"
+            "If issues persist, please reach out for support in the Arize community Slack:\n"
+            "https://arize-ai.slack.com\n\n"
+            "You can also refer to the Alembic documentation for more information:\n"
+            "https://alembic.sqlalchemy.org/en/latest/tutorial.html\n\n"
+            ""
+        )
+        raise PhoenixMigrationError(msg) from e
     cache_for_dataloaders = (
-        CacheForDataLoaders() if db.dialect is SupportedSQLDialect.SQLITE else None
+        CacheForDataLoaders()
+        if SupportedSQLDialect(engine.dialect.name) is SupportedSQLDialect.SQLITE
+        else None
     )
-
+    db = _db(engine)
     bulk_inserter = BulkInserter(
         db,
         enable_prometheus=enable_prometheus,
@@ -408,9 +354,16 @@ def create_app(
     tracer_provider = None
     strawberry_extensions = schema.get_extensions()
     if server_instrumentation_is_enabled():
+        from opentelemetry.instrumentation.sqlalchemy import SQLAlchemyInstrumentor
         from opentelemetry.trace import TracerProvider
         from strawberry.extensions.tracing import OpenTelemetryExtension
 
+        tracer_provider = initialize_opentelemetry_tracer_provider()
+        SQLAlchemyInstrumentor().instrument(
+            engine=engine.sync_engine,
+            tracer_provider=tracer_provider,
+        )
+        clean_ups.append(SQLAlchemyInstrumentor().uninstrument)
         if TYPE_CHECKING:
             # Type-check the class before monkey-patching its private attribute.
             assert OpenTelemetryExtension._tracer
@@ -424,7 +377,6 @@ def create_app(
                 self._tracer = cast(TracerProvider, tracer_provider).get_tracer("strawberry")
 
         strawberry_extensions.append(_OpenTelemetryExtension)
-
     graphql = GraphQLWithContext(
         db=db,
         schema=strawberry.Schema(
@@ -481,27 +433,21 @@ def create_app(
                 "/graphql",
                 graphql,
             ),
-        ]
-        + (
-            [
-                Mount(
-                    "/",
-                    app=Static(
-                        directory=SERVER_DIR / "static",
-                        app_config=AppConfig(
-                            has_inferences=model.is_empty is not True,
-                            has_corpus=corpus is not None,
-                            min_dist=umap_params.min_dist,
-                            n_neighbors=umap_params.n_neighbors,
-                            n_samples=umap_params.n_samples,
-                        ),
+            Mount(
+                "/",
+                app=Static(
+                    directory=SERVER_DIR / "static",
+                    app_config=AppConfig(
+                        has_inferences=model.is_empty is not True,
+                        has_corpus=corpus is not None,
+                        min_dist=umap_params.min_dist,
+                        n_neighbors=umap_params.n_neighbors,
+                        n_samples=umap_params.n_samples,
                     ),
-                    name="static",
                 ),
-            ]
-            if serve_ui
-            else []
-        ),
+                name="static",
+            ),
+        ],
     )
     app.state.read_only = read_only
     app.state.db = db

phoenix/server/main.py

@@ -22,9 +22,9 @@ from phoenix.config import (
     get_pids_path,
     get_working_dir,
 )
-from phoenix.core.model_schema_adapter import create_model_from_inferences
+from phoenix.core.model_schema_adapter import create_model_from_datasets
 from phoenix.db import get_printable_db_url
-from phoenix.inferences.fixtures import FIXTURES, get_inferences
+from phoenix.inferences.fixtures import FIXTURES, get_datasets
 from phoenix.inferences.inferences import EMPTY_INFERENCES, Inferences
 from phoenix.pointcloud.umap_parameters import (
     DEFAULT_MIN_DIST,
@@ -32,22 +32,14 @@ from phoenix.pointcloud.umap_parameters import (
     DEFAULT_N_SAMPLES,
     UMAPParameters,
 )
-from phoenix.server.app import (
-    SessionFactory,
-    _db,
-    create_app,
-    create_engine_and_run_migrations,
-    instrument_engine_if_enabled,
-)
+from phoenix.server.app import create_app
 from phoenix.settings import Settings
 from phoenix.trace.fixtures import (
     TRACES_FIXTURES,
     download_traces_fixture,
-    get_dataset_fixtures,
     get_evals_from_fixture,
     get_trace_fixture_by_name,
     reset_fixture_span_ids_and_timestamps,
-    send_dataset_fixtures,
 )
 from phoenix.trace.otel import decode_otlp_span, encode_span_to_otlp
 from phoenix.trace.schemas import Span
@@ -107,14 +99,14 @@ def _get_pid_file() -> Path:
 DEFAULT_UMAP_PARAMS_STR = f"{DEFAULT_MIN_DIST},{DEFAULT_N_NEIGHBORS},{DEFAULT_N_SAMPLES}"
 
 if __name__ == "__main__":
-    primary_inferences_name: str
-    reference_inferences_name: Optional[str]
+    primary_dataset_name: str
+    reference_dataset_name: Optional[str]
     trace_dataset_name: Optional[str] = None
     simulate_streaming: Optional[bool] = None
 
-    primary_inferences: Inferences = EMPTY_INFERENCES
-    reference_inferences: Optional[Inferences] = None
-    corpus_inferences: Optional[Inferences] = None
+    primary_dataset: Inferences = EMPTY_INFERENCES
+    reference_dataset: Optional[Inferences] = None
+    corpus_dataset: Optional[Inferences] = None
 
     # Initialize the settings for the Server
     Settings.log_migrations = True
@@ -158,34 +150,34 @@ if __name__ == "__main__":
     )
     export_path = Path(args.export_path) if args.export_path else EXPORT_DIR
     if args.command == "datasets":
-        primary_inferences_name = args.primary
-        reference_inferences_name = args.reference
-        corpus_inferences_name = args.corpus
-        primary_inferences = Inferences.from_name(primary_inferences_name)
-        reference_inferences = (
-            Inferences.from_name(reference_inferences_name)
-            if reference_inferences_name is not None
+        primary_dataset_name = args.primary
+        reference_dataset_name = args.reference
+        corpus_dataset_name = args.corpus
+        primary_dataset = Inferences.from_name(primary_dataset_name)
+        reference_dataset = (
+            Inferences.from_name(reference_dataset_name)
+            if reference_dataset_name is not None
             else None
         )
-        corpus_inferences = (
-            None if corpus_inferences_name is None else Inferences.from_name(corpus_inferences_name)
+        corpus_dataset = (
+            None if corpus_dataset_name is None else Inferences.from_name(corpus_dataset_name)
         )
     elif args.command == "fixture":
         fixture_name = args.fixture
         primary_only = args.primary_only
-        primary_inferences, reference_inferences, corpus_inferences = get_inferences(
+        primary_dataset, reference_dataset, corpus_dataset = get_datasets(
             fixture_name,
             args.no_internet,
         )
         if primary_only:
-            reference_inferences_name = None
-            reference_inferences = None
+            reference_dataset_name = None
+            reference_dataset = None
     elif args.command == "trace-fixture":
         trace_dataset_name = args.fixture
         simulate_streaming = args.simulate_streaming
     elif args.command == "demo":
         fixture_name = args.fixture
-        primary_inferences, reference_inferences, corpus_inferences = get_inferences(
+        primary_dataset, reference_dataset, corpus_dataset = get_datasets(
             fixture_name,
             args.no_internet,
         )
@@ -205,11 +197,9 @@ if __name__ == "__main__":
 
     port = args.port or get_env_port()
     host_root_path = get_env_host_root_path()
-    read_only = args.read_only
-
-    model = create_model_from_inferences(
-        primary_inferences,
-        reference_inferences,
+    model = create_model_from_datasets(
+        primary_dataset,
+        reference_dataset,
     )
 
     fixture_spans: List[Span] = []
@@ -226,19 +216,13 @@ if __name__ == "__main__":
             ),
             get_evals_from_fixture(trace_dataset_name),
         )
-        dataset_fixtures = list(get_dataset_fixtures(trace_dataset_name))
-        if not read_only:
-            Thread(
-                target=send_dataset_fixtures,
-                args=(f"http://{host}:{port}", dataset_fixtures),
-            ).start()
     umap_params_list = args.umap_params.split(",")
     umap_params = UMAPParameters(
         min_dist=float(umap_params_list[0]),
         n_neighbors=int(umap_params_list[1]),
         n_samples=int(umap_params_list[2]),
     )
-
+    read_only = args.read_only
     logger.info(f"Server umap params: {umap_params}")
     if enable_prometheus := get_env_enable_prometheus():
         from phoenix.server.prometheus import start_prometheus
@@ -246,23 +230,17 @@ if __name__ == "__main__":
         start_prometheus()
 
     working_dir = get_working_dir().resolve()
-    engine = create_engine_and_run_migrations(db_connection_str)
-    instrumentation_cleanups = instrument_engine_if_enabled(engine)
-    factory = SessionFactory(session_factory=_db(engine), dialect=engine.dialect.name)
     app = create_app(
-        db=factory,
+        database_url=db_connection_str,
         export_path=export_path,
         model=model,
         umap_params=umap_params,
-        corpus=None
-        if corpus_inferences is None
-        else create_model_from_inferences(corpus_inferences),
+        corpus=None if corpus_dataset is None else create_model_from_datasets(corpus_dataset),
         debug=args.debug,
         read_only=read_only,
         enable_prometheus=enable_prometheus,
         initial_spans=fixture_spans,
         initial_evaluations=fixture_evals,
-        clean_up_callbacks=instrumentation_cleanups,
     )
     server = Server(config=Config(app, host=host, port=port, root_path=host_root_path))  # type: ignore
     Thread(target=_write_pid_file_when_ready, args=(server,), daemon=True).start()

phoenix/server/openapi/docs.py

@@ -43,9 +43,6 @@ def get_swagger_ui_html(
     <div id="swagger-ui">
     </div>
     <script src="{swagger_js_url}"></script>
-    <style type="text/css">
-    div[id^="operations-private"]{{display:none}} #operations-tag-private{{display:none}}
-    </style>
     <!-- `SwaggerUIBundle` is now available on the page -->
     <script>
     const ui = SwaggerUIBundle({{