arize-phoenix 3.16.1__py3-none-any.whl → 7.7.0__py3-none-any.whl

phoenix/server/api/types/GenerativeProvider.py

@@ -0,0 +1,85 @@
+from enum import Enum
+from typing import Any, ClassVar, Optional, Union
+
+import strawberry
+from openinference.semconv.trace import OpenInferenceLLMProviderValues, SpanAttributes
+
+from phoenix.trace.attributes import get_attribute_value
+
+
+@strawberry.enum
+class GenerativeProviderKey(Enum):
+    OPENAI = "OpenAI"
+    ANTHROPIC = "Anthropic"
+    AZURE_OPENAI = "Azure OpenAI"
+    GEMINI = "Google AI Studio"
+
+
+@strawberry.type
+class GenerativeProvider:
+    name: str
+    key: GenerativeProviderKey
+
+    model_provider_to_model_prefix_map: ClassVar[dict[GenerativeProviderKey, list[str]]] = {
+        GenerativeProviderKey.AZURE_OPENAI: [],
+        GenerativeProviderKey.ANTHROPIC: ["claude"],
+        GenerativeProviderKey.OPENAI: ["gpt", "o1"],
+        GenerativeProviderKey.GEMINI: ["gemini"],
+    }
+
+    attribute_provider_to_generative_provider_map: ClassVar[dict[str, GenerativeProviderKey]] = {
+        OpenInferenceLLMProviderValues.OPENAI.value: GenerativeProviderKey.OPENAI,
+        OpenInferenceLLMProviderValues.ANTHROPIC.value: GenerativeProviderKey.ANTHROPIC,
+        OpenInferenceLLMProviderValues.AZURE.value: GenerativeProviderKey.AZURE_OPENAI,
+        OpenInferenceLLMProviderValues.GOOGLE.value: GenerativeProviderKey.GEMINI,
+    }
+
+    @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 [dependency.name for dependency in 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
+
+    @classmethod
+    def _infer_model_provider_from_model_name(
+        cls,
+        model_name: str,
+    ) -> Union[GenerativeProviderKey, None]:
+        for provider, prefixes in cls.model_provider_to_model_prefix_map.items():
+            if any(prefix.lower() in model_name.lower() for prefix in prefixes):
+                return provider
+        return None
+
+    @classmethod
+    def get_model_provider_from_attributes(
+        cls,
+        attributes: dict[str, Any],
+    ) -> Union[GenerativeProviderKey, None]:
+        llm_provider: Optional[str] = get_attribute_value(attributes, SpanAttributes.LLM_PROVIDER)
+
+        if isinstance(llm_provider, str) and (
+            provider := cls.attribute_provider_to_generative_provider_map.get(llm_provider)
+        ):
+            return provider
+        llm_model = get_attribute_value(attributes, SpanAttributes.LLM_MODEL_NAME)
+        if isinstance(llm_model, str):
+            return cls._infer_model_provider_from_model_name(llm_model)
+        return None

phoenix/server/api/types/Inferences.py

@@ -0,0 +1,80 @@
+from collections.abc import Iterable
+from datetime import datetime
+from typing import Optional, Union
+
+import strawberry
+from strawberry import ID, UNSET
+
+import phoenix.core.model_schema as ms
+from phoenix.core.model_schema import FEATURE, TAG, ScalarDimension
+
+from ..input_types.DimensionInput import DimensionInput
+from .Dimension import Dimension, to_gql_dimension
+from .Event import Event, create_event, create_event_id, parse_event_ids_by_inferences_role
+from .InferencesRole import AncillaryInferencesRole, InferencesRole
+
+
+@strawberry.type
+class Inferences:
+    start_time: datetime = strawberry.field(description="The start bookend of the data")
+    end_time: datetime = strawberry.field(description="The end bookend of the data")
+    record_count: int = strawberry.field(description="The record count of the data")
+    inferences: strawberry.Private[ms.Inferences]
+    inferences_role: strawberry.Private[Union[InferencesRole, AncillaryInferencesRole]]
+    model: strawberry.Private[ms.Model]
+
+    # type ignored here to get around the following: https://github.com/strawberry-graphql/strawberry/issues/1929
+    @strawberry.field(description="Returns a human friendly name for the inferences.")  # type: ignore
+    def name(self) -> str:
+        return self.inferences.display_name
+
+    @strawberry.field
+    def events(
+        self,
+        event_ids: list[ID],
+        dimensions: Optional[list[DimensionInput]] = UNSET,
+    ) -> list[Event]:
+        """
+        Returns events for specific event IDs and dimensions. If no input
+        dimensions are provided, returns all features and tags.
+        """
+        if not event_ids:
+            return []
+        row_ids = parse_event_ids_by_inferences_role(event_ids)
+        if len(row_ids) > 1 or self.inferences_role not in row_ids:
+            raise ValueError("eventIds contains IDs from incorrect inferences.")
+        events = self.inferences[row_ids[self.inferences_role]]
+        requested_gql_dimensions = _get_requested_features_and_tags(
+            core_dimensions=self.model.scalar_dimensions,
+            requested_dimension_names=set(dim.name for dim in dimensions)
+            if isinstance(dimensions, list)
+            else None,
+        )
+        return [
+            create_event(
+                event_id=create_event_id(event.id.row_id, self.inferences_role),
+                event=event,
+                dimensions=requested_gql_dimensions,
+                is_document_record=self.inferences_role is AncillaryInferencesRole.corpus,
+            )
+            for event in events
+        ]
+
+
+def _get_requested_features_and_tags(
+    core_dimensions: Iterable[ScalarDimension],
+    requested_dimension_names: Optional[set[str]] = UNSET,
+) -> list[Dimension]:
+    """
+    Returns requested features and tags as a list of strawberry Inferences. If no
+    dimensions are explicitly requested, returns all features and tags.
+    """
+    requested_features_and_tags: list[Dimension] = []
+    for id, dim in enumerate(core_dimensions):
+        is_requested = (
+            not isinstance(requested_dimension_names, set)
+        ) or dim.name in requested_dimension_names
+        is_feature_or_tag = dim.role in (FEATURE, TAG)
+        if is_requested and is_feature_or_tag:
+            requested_features_and_tags.append(to_gql_dimension(id_attr=id, dimension=dim))
+    return requested_features_and_tags

phoenix/server/api/types/InferencesRole.py

@@ -0,0 +1,23 @@
+from enum import Enum
+from typing import Union
+
+import strawberry
+
+from phoenix.core.model_schema import PRIMARY, REFERENCE
+
+
+@strawberry.enum
+class InferencesRole(Enum):
+    primary = PRIMARY
+    reference = REFERENCE
+
+
+class AncillaryInferencesRole(Enum):
+    corpus = "InferencesRole.CORPUS"
+
+
+STR_TO_INFEREENCES_ROLE: dict[str, Union[InferencesRole, AncillaryInferencesRole]] = {
+    str(InferencesRole.primary.value): InferencesRole.primary,
+    str(InferencesRole.reference.value): InferencesRole.reference,
+    str(AncillaryInferencesRole.corpus.value): AncillaryInferencesRole.corpus,
+}

phoenix/server/api/types/LabelFraction.py

@@ -0,0 +1,7 @@
+import strawberry
+
+
+@strawberry.type
+class LabelFraction:
+    label: str
+    fraction: float

phoenix/server/api/types/MimeType.py

@@ -8,8 +8,8 @@ import phoenix.trace.schemas as trace_schemas
 
 @strawberry.enum
 class MimeType(Enum):
-    text = trace_schemas.MimeType.TEXT
-    json = trace_schemas.MimeType.JSON
+    text = trace_schemas.MimeType.TEXT.value
+    json = trace_schemas.MimeType.JSON.value
 
     @classmethod
     def _missing_(cls, v: Any) -> Optional["MimeType"]:

phoenix/server/api/types/Model.py

@@ -1,9 +1,9 @@
 import asyncio
-from typing import List, Optional
+from typing import Optional
 
 import strawberry
-from strawberry.types import Info
-from strawberry.unset import UNSET
+from strawberry import UNSET, Info
+from strawberry.relay import Connection
 from typing_extensions import Annotated
 
 from phoenix.config import get_exported_files
@@ -14,12 +14,12 @@ from ..input_types.DimensionFilter import DimensionFilter
 from ..input_types.Granularity import Granularity
 from ..input_types.PerformanceMetricInput import PerformanceMetricInput
 from ..input_types.TimeRange import TimeRange
-from .Dataset import Dataset
-from .DatasetRole import AncillaryDatasetRole, DatasetRole
 from .Dimension import Dimension, to_gql_dimension
 from .EmbeddingDimension import EmbeddingDimension, to_gql_embedding_dimension
 from .ExportedFile import ExportedFile
-from .pagination import Connection, ConnectionArgs, Cursor, connection_from_list
+from .Inferences import Inferences
+from .InferencesRole import AncillaryInferencesRole, InferencesRole
+from .pagination import ConnectionArgs, CursorString, connection_from_list
 from .TimeSeries import (
     PerformanceTimeSeries,
     ensure_timeseries_parameters,
@@ -35,8 +35,8 @@ class Model:
         info: Info[Context, None],
         first: Optional[int] = 50,
         last: Optional[int] = UNSET,
-        after: Optional[Cursor] = UNSET,
-        before: Optional[Cursor] = UNSET,
+        after: Optional[CursorString] = UNSET,
+        before: Optional[CursorString] = UNSET,
         include: Optional[DimensionFilter] = UNSET,
         exclude: Optional[DimensionFilter] = UNSET,
     ) -> Connection[Dimension]:
@@ -50,52 +50,52 @@ class Model:
             ],
             args=ConnectionArgs(
                 first=first,
-                after=after if isinstance(after, Cursor) else None,
+                after=after if isinstance(after, CursorString) else None,
                 last=last,
-                before=before if isinstance(before, Cursor) else None,
+                before=before if isinstance(before, CursorString) else None,
             ),
         )
 
     @strawberry.field
-    def primary_dataset(self, info: Info[Context, None]) -> Dataset:
-        dataset = info.context.model[PRIMARY]
-        start, stop = dataset.time_range
-        return Dataset(
+    def primary_inferences(self, info: Info[Context, None]) -> Inferences:
+        inferences = info.context.model[PRIMARY]
+        start, stop = inferences.time_range
+        return Inferences(
             start_time=start,
             end_time=stop,
-            record_count=len(dataset),
-            dataset=dataset,
-            dataset_role=DatasetRole.primary,
+            record_count=len(inferences),
+            inferences=inferences,
+            inferences_role=InferencesRole.primary,
             model=info.context.model,
         )
 
     @strawberry.field
-    def reference_dataset(self, info: Info[Context, None]) -> Optional[Dataset]:
-        if (dataset := info.context.model[REFERENCE]).empty:
+    def reference_inferences(self, info: Info[Context, None]) -> Optional[Inferences]:
+        if (inferences := info.context.model[REFERENCE]).empty:
             return None
-        start, stop = dataset.time_range
-        return Dataset(
+        start, stop = inferences.time_range
+        return Inferences(
             start_time=start,
             end_time=stop,
-            record_count=len(dataset),
-            dataset=dataset,
-            dataset_role=DatasetRole.reference,
+            record_count=len(inferences),
+            inferences=inferences,
+            inferences_role=InferencesRole.reference,
             model=info.context.model,
         )
 
     @strawberry.field
-    def corpus_dataset(self, info: Info[Context, None]) -> Optional[Dataset]:
+    def corpus_inferences(self, info: Info[Context, None]) -> Optional[Inferences]:
         if info.context.corpus is None:
             return None
-        if (dataset := info.context.corpus[PRIMARY]).empty:
+        if (inferences := info.context.corpus[PRIMARY]).empty:
             return None
-        start, stop = dataset.time_range
-        return Dataset(
+        start, stop = inferences.time_range
+        return Inferences(
             start_time=start,
             end_time=stop,
-            record_count=len(dataset),
-            dataset=dataset,
-            dataset_role=AncillaryDatasetRole.corpus,
+            record_count=len(inferences),
+            inferences=inferences,
+            inferences_role=AncillaryInferencesRole.corpus,
             model=info.context.corpus,
         )
 
@@ -105,8 +105,8 @@ class Model:
         info: Info[Context, None],
         first: Optional[int] = 50,
         last: Optional[int] = UNSET,
-        after: Optional[Cursor] = UNSET,
-        before: Optional[Cursor] = UNSET,
+        after: Optional[CursorString] = UNSET,
+        before: Optional[CursorString] = UNSET,
     ) -> Connection[EmbeddingDimension]:
         """
         A non-trivial implementation should efficiently fetch only
@@ -123,9 +123,9 @@ class Model:
             ],
             args=ConnectionArgs(
                 first=first,
-                after=after if isinstance(after, Cursor) else None,
+                after=after if isinstance(after, CursorString) else None,
                 last=last,
-                before=before if isinstance(before, Cursor) else None,
+                before=before if isinstance(before, CursorString) else None,
             ),
         )
 
@@ -135,7 +135,7 @@ class Model:
     async def exported_files(
         self,
         info: Info[Context, None],
-    ) -> List[ExportedFile]:
+    ) -> list[ExportedFile]:
         loop = asyncio.get_running_loop()
         return [
             ExportedFile(file_name=path.stem)
@@ -156,24 +156,24 @@ class Model:
         info: Info[Context, None],
         metric: PerformanceMetricInput,
         time_range: Optional[TimeRange] = UNSET,
-        dataset_role: Annotated[
-            Optional[DatasetRole],
+        inferences_role: Annotated[
+            Optional[InferencesRole],
             strawberry.argument(
-                description="The dataset (primary or reference) to query",
+                description="The inferences (primary or reference) to query",
             ),
-        ] = DatasetRole.primary,
+        ] = InferencesRole.primary,
     ) -> Optional[float]:
-        if not isinstance(dataset_role, DatasetRole):
-            dataset_role = DatasetRole.primary
+        if not isinstance(inferences_role, InferencesRole):
+            inferences_role = InferencesRole.primary
         model = info.context.model
-        dataset = model[dataset_role.value]
+        inferences = model[inferences_role.value]
         time_range, granularity = ensure_timeseries_parameters(
-            dataset,
+            inferences,
             time_range,
         )
         metric_instance = metric.metric_instance(model)
         data = get_timeseries_data(
-            dataset,
+            inferences,
             metric_instance,
             time_range,
             granularity,
@@ -194,26 +194,26 @@ class Model:
         metric: PerformanceMetricInput,
         time_range: TimeRange,
         granularity: Granularity,
-        dataset_role: Annotated[
-            Optional[DatasetRole],
+        inferences_role: Annotated[
+            Optional[InferencesRole],
             strawberry.argument(
-                description="The dataset (primary or reference) to query",
+                description="The inferences (primary or reference) to query",
             ),
-        ] = DatasetRole.primary,
+        ] = InferencesRole.primary,
     ) -> PerformanceTimeSeries:
-        if not isinstance(dataset_role, DatasetRole):
-            dataset_role = DatasetRole.primary
+        if not isinstance(inferences_role, InferencesRole):
+            inferences_role = InferencesRole.primary
         model = info.context.model
-        dataset = model[dataset_role.value]
+        inferences = model[inferences_role.value]
         time_range, granularity = ensure_timeseries_parameters(
-            dataset,
+            inferences,
             time_range,
             granularity,
         )
         metric_instance = metric.metric_instance(model)
         return PerformanceTimeSeries(
             data=get_timeseries_data(
-                dataset,
+                inferences,
                 metric_instance,
                 time_range,
                 granularity,

phoenix/server/api/types/PerformanceMetric.py

@@ -1,5 +1,5 @@
-from enum import Enum
-from functools import partial
+from enum import Enum, auto
+from typing import Callable, Mapping, cast
 
 import strawberry
 
@@ -8,6 +8,9 @@ from phoenix.metrics.wrappers import SkEval
 
 @strawberry.enum
 class PerformanceMetric(Enum):
-    # To become enum values, functions need to be wrapped in partial.
-    # See https://stackoverflow.com/a/40339397
-    accuracyScore = partial(SkEval.accuracy_score)  # type: ignore
+    accuracyScore = auto()
+
+
+PERFORMANCE_METRIC_FUNCTIONS: Mapping[PerformanceMetric, Callable[..., float]] = {
+    PerformanceMetric.accuracyScore: cast(Callable[..., float], SkEval.accuracy_score),
+}