arize-phoenix 5.6.0__py3-none-any.whl → 5.7.0__py3-none-any.whl

phoenix/server/api/types/ChatCompletionSubscriptionPayload.py

@@ -0,0 +1,44 @@
+from typing import Optional
+
+import strawberry
+from strawberry.relay import GlobalID
+
+from .Experiment import Experiment
+from .Span import Span
+
+
+@strawberry.interface
+class ChatCompletionSubscriptionPayload:
+    dataset_example_id: Optional[GlobalID] = None
+
+
+@strawberry.type
+class TextChunk(ChatCompletionSubscriptionPayload):
+    content: str
+
+
+@strawberry.type
+class FunctionCallChunk(ChatCompletionSubscriptionPayload):
+    name: str
+    arguments: str
+
+
+@strawberry.type
+class ToolCallChunk(ChatCompletionSubscriptionPayload):
+    id: str
+    function: FunctionCallChunk
+
+
+@strawberry.type
+class FinishedChatCompletion(ChatCompletionSubscriptionPayload):
+    span: Span
+
+
+@strawberry.type
+class ChatCompletionSubscriptionError(ChatCompletionSubscriptionPayload):
+    message: str
+
+
+@strawberry.type
+class ChatCompletionOverDatasetSubscriptionResult(ChatCompletionSubscriptionPayload):
+    experiment: Experiment

phoenix/server/api/types/GenerativeProvider.py

@@ -5,12 +5,36 @@ import strawberry
 
 @strawberry.enum
 class GenerativeProviderKey(Enum):
-    OPENAI = "OPENAI"
-    ANTHROPIC = "ANTHROPIC"
-    AZURE_OPENAI = "AZURE_OPENAI"
+    OPENAI = "OpenAI"
+    ANTHROPIC = "Anthropic"
+    AZURE_OPENAI = "Azure OpenAI"
 
 
 @strawberry.type
 class GenerativeProvider:
     name: str
     key: GenerativeProviderKey
+
+    @strawberry.field
+    async def dependencies(self) -> list[str]:
+        from phoenix.server.api.helpers.playground_registry import (
+            PLAYGROUND_CLIENT_REGISTRY,
+            PROVIDER_DEFAULT,
+        )
+
+        default_client = PLAYGROUND_CLIENT_REGISTRY.get_client(self.key, PROVIDER_DEFAULT)
+        if default_client:
+            return default_client.dependencies()
+        return []
+
+    @strawberry.field
+    async def dependencies_installed(self) -> bool:
+        from phoenix.server.api.helpers.playground_registry import (
+            PLAYGROUND_CLIENT_REGISTRY,
+            PROVIDER_DEFAULT,
+        )
+
+        default_client = PLAYGROUND_CLIENT_REGISTRY.get_client(self.key, PROVIDER_DEFAULT)
+        if default_client:
+            return default_client.dependencies_are_installed()
+        return False

phoenix/server/api/types/Span.py

@@ -20,10 +20,12 @@ from phoenix.server.api.helpers.dataset_helpers import (
     get_dataset_example_input,
     get_dataset_example_output,
 )
+from phoenix.server.api.input_types.InvocationParameters import InvocationParameter
 from phoenix.server.api.input_types.SpanAnnotationSort import (
     SpanAnnotationColumn,
     SpanAnnotationSort,
 )
+from phoenix.server.api.types.GenerativeProvider import GenerativeProviderKey
 from phoenix.server.api.types.SortDir import SortDir
 from phoenix.server.api.types.SpanAnnotation import to_gql_span_annotation
 from phoenix.trace.attributes import get_attribute_value
@@ -291,6 +293,41 @@ class Span(Node):
         examples = await info.context.data_loaders.span_dataset_examples.load(self.id_attr)
         return bool(examples)
 
+    @strawberry.field(description="Invocation parameters for the span")  # type: ignore
+    async def invocation_parameters(self, info: Info[Context, None]) -> list[InvocationParameter]:
+        from phoenix.server.api.helpers.playground_clients import OpenAIStreamingClient
+        from phoenix.server.api.helpers.playground_registry import PLAYGROUND_CLIENT_REGISTRY
+
+        db_span = self.db_span
+        attributes = db_span.attributes
+        llm_provider: GenerativeProviderKey = (
+            get_attribute_value(attributes, SpanAttributes.LLM_PROVIDER)
+            or GenerativeProviderKey.OPENAI
+        )
+        llm_model = get_attribute_value(attributes, SpanAttributes.LLM_MODEL_NAME)
+        invocation_parameters = get_attribute_value(
+            attributes, SpanAttributes.LLM_INVOCATION_PARAMETERS
+        )
+        if invocation_parameters is None:
+            return []
+        invocation_parameters = json.loads(invocation_parameters)
+        # find the client class for the provider, if there is no client class or provider,
+        # return openai as default
+        client_class = PLAYGROUND_CLIENT_REGISTRY.get_client(llm_provider, llm_model)
+        if not client_class:
+            client_class = OpenAIStreamingClient
+        supported_invocation_parameters = client_class.supported_invocation_parameters()
+        # filter supported invocation parameters down to those whose canonical_name is in the
+        # invocation_parameters keys
+        return [
+            ip
+            for ip in supported_invocation_parameters
+            if (
+                ip.canonical_name in invocation_parameters
+                or ip.invocation_name in invocation_parameters
+            )
+        ]
+
 
 def to_gql_span(span: models.Span) -> Span:
     events: list[SpanEvent] = list(map(SpanEvent.from_dict, span.events))

phoenix/server/api/types/TemplateLanguage.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+import strawberry
+
+
+@strawberry.enum
+class TemplateLanguage(Enum):
+    MUSTACHE = "MUSTACHE"
+    F_STRING = "F_STRING"

phoenix/server/app.py

@@ -1,7 +1,9 @@
 import asyncio
 import contextlib
+import importlib
 import json
 import logging
+import os
 from collections.abc import AsyncIterator, Awaitable, Callable, Iterable, Sequence
 from contextlib import AbstractAsyncContextManager, AsyncExitStack
 from dataclasses import dataclass, field
@@ -40,7 +42,6 @@ from starlette.types import Scope, StatefulLifespan
 from starlette.websockets import WebSocket
 from strawberry.extensions import SchemaExtension
 from strawberry.fastapi import GraphQLRouter
-from strawberry.schema import BaseSchema
 from strawberry.subscriptions import GRAPHQL_TRANSPORT_WS_PROTOCOL
 from typing_extensions import TypeAlias
 
@@ -51,6 +52,8 @@ from phoenix.config import (
     SERVER_DIR,
     OAuth2ClientConfig,
     get_env_csrf_trusted_origins,
+    get_env_fastapi_middleware_paths,
+    get_env_gql_extension_paths,
     get_env_host,
     get_env_port,
     server_instrumentation_is_enabled,
@@ -98,7 +101,7 @@ from phoenix.server.api.routers import (
     oauth2_router,
 )
 from phoenix.server.api.routers.v1 import REST_API_VERSION
-from phoenix.server.api.schema import schema
+from phoenix.server.api.schema import build_graphql_schema
 from phoenix.server.bearer_auth import BearerTokenAuthBackend, is_authenticated
 from phoenix.server.dml_event import DmlEvent
 from phoenix.server.dml_event_handler import DmlEventHandler
@@ -150,6 +153,28 @@ ProjectName: TypeAlias = str
 _Callback: TypeAlias = Callable[[], Union[None, Awaitable[None]]]
 
 
+def import_object_from_file(file_path: str, object_name: str) -> Any:
+    """Import an object (class or function) from a Python file."""
+    try:
+        if not os.path.isfile(file_path):
+            raise FileNotFoundError(f"File '{file_path}' does not exist.")
+        module_name = f"custom_module_{hash(file_path)}"
+        spec = importlib.util.spec_from_file_location(module_name, file_path)
+        if spec is None:
+            raise ImportError(f"Could not load spec for '{file_path}'")
+        module = importlib.util.module_from_spec(spec)
+        loader = spec.loader
+        if loader is None:
+            raise ImportError(f"No loader found for '{file_path}'")
+        loader.exec_module(module)
+        try:
+            return getattr(module, object_name)
+        except AttributeError:
+            raise ImportError(f"Module '{file_path}' does not have an object '{object_name}'.")
+    except Exception as e:
+        raise ImportError(f"Could not import '{object_name}' from '{file_path}': {e}")
+
+
 class OAuth2Idp(TypedDict):
     name: str
     displayName: str
@@ -166,6 +191,7 @@ class AppConfig(NamedTuple):
     web_manifest_path: Path
     authentication_enabled: bool
     """ Whether authentication is enabled """
+    websockets_enabled: bool
     oauth2_idps: Sequence[OAuth2Idp]
 
 
@@ -216,6 +242,7 @@ class Static(StaticFiles):
                     "manifest": self._web_manifest,
                     "authentication_enabled": self._app_config.authentication_enabled,
                     "oauth2_idps": self._app_config.oauth2_idps,
+                    "websockets_enabled": self._app_config.websockets_enabled,
                 },
             )
         except Exception as e:
@@ -256,6 +283,28 @@ class HeadersMiddleware(BaseHTTPMiddleware):
         return response
 
 
+def user_fastapi_middlewares() -> list[Middleware]:
+    paths = get_env_fastapi_middleware_paths()
+    middlewares = []
+    for file_path, object_name in paths:
+        middleware_class = import_object_from_file(file_path, object_name)
+        if not issubclass(middleware_class, BaseHTTPMiddleware):
+            raise TypeError(f"{middleware_class} is not a subclass of BaseHTTPMiddleware")
+        middlewares.append(Middleware(middleware_class))
+    return middlewares
+
+
+def user_gql_extensions() -> list[Union[type[SchemaExtension], SchemaExtension]]:
+    paths = get_env_gql_extension_paths()
+    extensions = []
+    for file_path, object_name in paths:
+        extension_class = import_object_from_file(file_path, object_name)
+        if not issubclass(extension_class, SchemaExtension):
+            raise TypeError(f"{extension_class} is not a subclass of SchemaExtension")
+        extensions.append(extension_class)
+    return extensions
+
+
 ProjectRowId: TypeAlias = int
 
 
@@ -463,7 +512,7 @@ async def check_healthz(_: Request) -> PlainTextResponse:
 
 def create_graphql_router(
     *,
-    schema: BaseSchema,
+    graphql_schema: strawberry.Schema,
     db: DbSessionFactory,
     model: Model,
     export_path: Path,
@@ -567,7 +616,7 @@ def create_graphql_router(
         )
 
     return GraphQLRouter(
-        schema,
+        graphql_schema,
         graphql_ide="graphiql",
         context_getter=get_context,
         include_in_schema=False,
@@ -653,6 +702,7 @@ def create_app(
     model: Model,
     authentication_enabled: bool,
     umap_params: UMAPParameters,
+    enable_websockets: bool,
     corpus: Optional[Model] = None,
     debug: bool = False,
     dev: bool = False,
@@ -700,6 +750,7 @@ def create_app(
     )
     last_updated_at = LastUpdatedAt()
     middlewares: list[Middleware] = [Middleware(HeadersMiddleware)]
+    middlewares.extend(user_fastapi_middlewares())
     if origins := get_env_csrf_trusted_origins():
         trusted_hostnames = [h for o in origins if o and (h := urlparse(o).hostname)]
         middlewares.append(Middleware(RequestOriginHostnameValidator, trusted_hostnames))
@@ -733,8 +784,9 @@ def create_app(
         initial_batch_of_evaluations=initial_batch_of_evaluations,
     )
     tracer_provider = None
-    strawberry_extensions: list[Union[type[SchemaExtension], SchemaExtension]] = []
-    strawberry_extensions.extend(schema.get_extensions())
+    graphql_schema_extensions: list[Union[type[SchemaExtension], SchemaExtension]] = []
+    graphql_schema_extensions.extend(user_gql_extensions())
+
     if server_instrumentation_is_enabled():
         tracer_provider = initialize_opentelemetry_tracer_provider()
         from opentelemetry.trace import TracerProvider
@@ -752,16 +804,11 @@ def create_app(
                 # used by OpenInference.
                 self._tracer = cast(TracerProvider, tracer_provider).get_tracer("strawberry")
 
-        strawberry_extensions.append(_OpenTelemetryExtension)
+        graphql_schema_extensions.append(_OpenTelemetryExtension)
 
     graphql_router = create_graphql_router(
         db=db,
-        schema=strawberry.Schema(
-            query=schema.query,
-            mutation=schema.mutation,
-            subscription=schema.subscription,
-            extensions=strawberry_extensions,
-        ),
+        graphql_schema=build_graphql_schema(graphql_schema_extensions),
         model=model,
         corpus=corpus,
         authentication_enabled=authentication_enabled,
@@ -830,6 +877,7 @@ def create_app(
                     authentication_enabled=authentication_enabled,
                     web_manifest_path=web_manifest_path,
                     oauth2_idps=oauth2_idps,
+                    websockets_enabled=enable_websockets,
                 ),
             ),
             name="static",

phoenix/server/main.py

@@ -21,6 +21,7 @@ from phoenix.config import (
     get_env_database_schema,
     get_env_db_logging_level,
     get_env_enable_prometheus,
+    get_env_enable_websockets,
     get_env_grpc_port,
     get_env_host,
     get_env_host_root_path,
@@ -95,6 +96,7 @@ _WELCOME_MESSAGE = Environment(loader=BaseLoader()).from_string("""
 |  🚀 Phoenix Server 🚀
 |  Phoenix UI: {{ ui_path }}
 |  Authentication: {{ auth_enabled }}
+|  Websockets: {{ websockets_enabled }}
 |  Log traces:
 |    - gRPC: {{ grpc_path }}
 |    - HTTP: {{ http_path }}
@@ -162,7 +164,7 @@ def main() -> None:
     parser.add_argument("--debug", action="store_true", help=SUPPRESS)
     parser.add_argument("--dev", action="store_true", help=SUPPRESS)
     parser.add_argument("--no-ui", action="store_true", help=SUPPRESS)
-
+    parser.add_argument("--enable-websockets", type=str, help=SUPPRESS)
     subparsers = parser.add_subparsers(dest="command", required=True, help=SUPPRESS)
 
     serve_parser = subparsers.add_parser("serve")
@@ -348,6 +350,14 @@ def main() -> None:
     corpus_model = (
         None if corpus_inferences is None else create_model_from_inferences(corpus_inferences)
     )
+
+    # Get enable_websockets from environment variable or command line argument
+    enable_websockets = get_env_enable_websockets()
+    if args.enable_websockets is not None:
+        enable_websockets = args.enable_websockets.lower() == "true"
+    if enable_websockets is None:
+        enable_websockets = True
+
     # Print information about the server
     root_path = urljoin(f"http://{host}:{port}", host_root_path)
     msg = _WELCOME_MESSAGE.render(
@@ -358,6 +368,7 @@ def main() -> None:
         storage=get_printable_db_url(db_connection_str),
         schema=get_env_database_schema(),
         auth_enabled=authentication_enabled,
+        websockets_enabled=enable_websockets,
     )
     if sys.platform.startswith("win"):
         msg = codecs.encode(msg, "ascii", errors="ignore").decode("ascii").strip()
@@ -382,10 +393,12 @@ def main() -> None:
             connection_method="STARTTLS",
             validate_certs=get_env_smtp_validate_certs(),
         )
+
     app = create_app(
         db=factory,
         export_path=export_path,
         model=model,
+        enable_websockets=enable_websockets,
         authentication_enabled=authentication_enabled,
         umap_params=umap_params,
         corpus=corpus_model,

phoenix/server/static/.vite/manifest.json

@@ -1,22 +1,22 @@
 {
-  "_components-C70HJiXz.js": {
-    "file": "assets/components-C70HJiXz.js",
+  "_components-Csu8UKOs.js": {
+    "file": "assets/components-Csu8UKOs.js",
     "name": "components",
     "imports": [
       "_vendor-CtqfhlbC.js",
       "_vendor-arizeai-C_3SBz56.js",
-      "_pages-C8-Sl7JI.js",
+      "_pages-UeWaKXNs.js",
       "_vendor-three-DwGkEfCM.js",
       "_vendor-codemirror-wfdk9cjp.js"
     ]
   },
-  "_pages-C8-Sl7JI.js": {
-    "file": "assets/pages-C8-Sl7JI.js",
+  "_pages-UeWaKXNs.js": {
+    "file": "assets/pages-UeWaKXNs.js",
     "name": "pages",
     "imports": [
       "_vendor-CtqfhlbC.js",
       "_vendor-arizeai-C_3SBz56.js",
-      "_components-C70HJiXz.js",
+      "_components-Csu8UKOs.js",
       "_vendor-recharts-BiVnSv90.js",
       "_vendor-codemirror-wfdk9cjp.js"
     ]
@@ -61,15 +61,15 @@
     "name": "vendor-three"
   },
   "index.tsx": {
-    "file": "assets/index-DLe1Oo3l.js",
+    "file": "assets/index-Bk5C9EA7.js",
     "name": "index",
     "src": "index.tsx",
     "isEntry": true,
     "imports": [
       "_vendor-CtqfhlbC.js",
       "_vendor-arizeai-C_3SBz56.js",
-      "_pages-C8-Sl7JI.js",
-      "_components-C70HJiXz.js",
+      "_pages-UeWaKXNs.js",
+      "_components-Csu8UKOs.js",
       "_vendor-three-DwGkEfCM.js",
       "_vendor-recharts-BiVnSv90.js",
       "_vendor-codemirror-wfdk9cjp.js"