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

phoenix/server/api/types/ExperimentRun.py

@@ -1,91 +0,0 @@
-from datetime import datetime
-from typing import Optional
-
-import strawberry
-from sqlalchemy import select
-from strawberry import UNSET
-from strawberry.relay import Connection, GlobalID, Node, NodeID
-from strawberry.scalars import JSON
-from strawberry.types import Info
-
-from phoenix.db import models
-from phoenix.server.api.context import Context
-from phoenix.server.api.types.ExperimentRunAnnotation import (
-    ExperimentRunAnnotation,
-    to_gql_experiment_run_annotation,
-)
-from phoenix.server.api.types.pagination import (
-    ConnectionArgs,
-    CursorString,
-    connection_from_list,
-)
-from phoenix.server.api.types.Trace import Trace
-
-
-@strawberry.type
-class ExperimentRun(Node):
-    id_attr: NodeID[int]
-    experiment_id: GlobalID
-    trace_id: Optional[str]
-    output: Optional[JSON]
-    start_time: datetime
-    end_time: datetime
-    error: Optional[str]
-
-    @strawberry.field
-    async def annotations(
-        self,
-        info: Info[Context, None],
-        first: Optional[int] = 50,
-        last: Optional[int] = UNSET,
-        after: Optional[CursorString] = UNSET,
-        before: Optional[CursorString] = UNSET,
-    ) -> Connection[ExperimentRunAnnotation]:
-        args = ConnectionArgs(
-            first=first,
-            after=after if isinstance(after, CursorString) else None,
-            last=last,
-            before=before if isinstance(before, CursorString) else None,
-        )
-        run_id = self.id_attr
-        async with info.context.db() as session:
-            annotations = (
-                await session.scalars(
-                    select(models.ExperimentRunAnnotation)
-                    .where(models.ExperimentRunAnnotation.experiment_run_id == run_id)
-                    .order_by(models.ExperimentRunAnnotation.id.desc())
-                )
-            ).all()
-        return connection_from_list(
-            [to_gql_experiment_run_annotation(annotation) for annotation in annotations], args
-        )
-
-    @strawberry.field
-    async def trace(self, info: Info) -> Optional[Trace]:
-        if not self.trace_id:
-            return None
-        dataloader = info.context.data_loaders.trace_row_ids
-        if (trace := await dataloader.load(self.trace_id)) is None:
-            return None
-        trace_rowid, project_rowid = trace
-        return Trace(id_attr=trace_rowid, trace_id=self.trace_id, project_rowid=project_rowid)
-
-
-def to_gql_experiment_run(run: models.ExperimentRun) -> ExperimentRun:
-    """
-    Converts an ORM experiment run to a GraphQL ExperimentRun.
-    """
-
-    from phoenix.server.api.types.Experiment import Experiment
-
-    return ExperimentRun(
-        id_attr=run.id,
-        experiment_id=GlobalID(Experiment.__name__, str(run.experiment_id)),
-        trace_id=trace_id
-        if (trace := run.trace) and (trace_id := trace.trace_id) is not None
-        else None,
-        output=run.output.get("result"),
-        start_time=run.start_time,
-        end_time=run.end_time,
-        error=run.error,
-    )

phoenix/server/api/types/ExperimentRunAnnotation.py

@@ -1,57 +0,0 @@
-from datetime import datetime
-from typing import Optional
-
-import strawberry
-from strawberry import Info
-from strawberry.relay import Node, NodeID
-from strawberry.scalars import JSON
-
-from phoenix.db import models
-from phoenix.server.api.types.AnnotatorKind import AnnotatorKind
-from phoenix.server.api.types.Trace import Trace
-
-
-@strawberry.type
-class ExperimentRunAnnotation(Node):
-    id_attr: NodeID[int]
-    name: str
-    annotator_kind: AnnotatorKind
-    label: Optional[str]
-    score: Optional[float]
-    explanation: Optional[str]
-    error: Optional[str]
-    metadata: JSON
-    start_time: datetime
-    end_time: datetime
-    trace_id: Optional[str]
-
-    @strawberry.field
-    async def trace(self, info: Info) -> Optional[Trace]:
-        if not self.trace_id:
-            return None
-        dataloader = info.context.data_loaders.trace_row_ids
-        if (trace := await dataloader.load(self.trace_id)) is None:
-            return None
-        trace_row_id, project_row_id = trace
-        return Trace(id_attr=trace_row_id, trace_id=self.trace_id, project_rowid=project_row_id)
-
-
-def to_gql_experiment_run_annotation(
-    annotation: models.ExperimentRunAnnotation,
-) -> ExperimentRunAnnotation:
-    """
-    Converts an ORM experiment run annotation to a GraphQL ExperimentRunAnnotation.
-    """
-    return ExperimentRunAnnotation(
-        id_attr=annotation.id,
-        name=annotation.name,
-        annotator_kind=AnnotatorKind(annotation.annotator_kind),
-        label=annotation.label,
-        score=annotation.score,
-        explanation=annotation.explanation,
-        error=annotation.error,
-        metadata=annotation.metadata_,
-        start_time=annotation.start_time,
-        end_time=annotation.end_time,
-        trace_id=annotation.trace_id,
-    )

phoenix/server/api/types/Inferences.py

@@ -1,80 +0,0 @@
-from datetime import datetime
-from typing import Iterable, List, Optional, Set, Union
-
-import strawberry
-from strawberry.scalars import ID
-from strawberry.unset import 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

@@ -1,23 +0,0 @@
-from enum import Enum
-from typing import Dict, 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/utilities/json.py

@@ -1,61 +0,0 @@
-import dataclasses
-import datetime
-from enum import Enum
-from pathlib import Path
-from typing import Any, Mapping, Sequence, Union, get_args, get_origin
-
-import numpy as np
-
-
-def jsonify(obj: Any) -> Any:
-    """
-    Coerce object to be json serializable.
-    """
-    if isinstance(obj, Enum):
-        return jsonify(obj.value)
-    if isinstance(obj, (str, int, float, bool)) or obj is None:
-        return obj
-    if isinstance(obj, (list, set, frozenset, Sequence)):
-        return [jsonify(v) for v in obj]
-    if isinstance(obj, (dict, Mapping)):
-        return {jsonify(k): jsonify(v) for k, v in obj.items()}
-    if dataclasses.is_dataclass(obj):
-        return {
-            k: jsonify(v)
-            for field in dataclasses.fields(obj)
-            if not (
-                (v := getattr(obj, (k := field.name))) is None
-                and get_origin(field) is Union
-                and type(None) in get_args(field)
-            )
-        }
-    if isinstance(obj, (datetime.date, datetime.datetime, datetime.time)):
-        return obj.isoformat()
-    if isinstance(obj, datetime.timedelta):
-        return obj.total_seconds()
-    if isinstance(obj, Path):
-        return str(obj)
-    if isinstance(obj, BaseException):
-        return str(obj)
-    if isinstance(obj, np.ndarray):
-        return [jsonify(v) for v in obj]
-    if hasattr(obj, "__float__"):
-        return float(obj)
-    if hasattr(obj, "model_dump") and callable(obj.model_dump):
-        # pydantic v2
-        try:
-            assert isinstance(d := obj.model_dump(), dict)
-        except BaseException:
-            pass
-        else:
-            return jsonify(d)
-    if hasattr(obj, "dict") and callable(obj.dict):
-        # pydantic v1
-        try:
-            assert isinstance(d := obj.dict(), dict)
-        except BaseException:
-            pass
-        else:
-            return jsonify(d)
-    cls = obj.__class__
-    return f"<{cls.__module__}.{cls.__name__} object>"

phoenix/utilities/re.py

@@ -1,50 +0,0 @@
-from logging import getLogger
-from re import compile, split
-from typing import Dict, List
-from urllib.parse import unquote
-
-_logger = getLogger(__name__)
-
-# Optional whitespace
-_OWS = r"[ \t]*"
-# A key contains printable US-ASCII characters except: SP and "(),/:;<=>?@[\]{}
-_KEY_FORMAT = r"[\x21\x23-\x27\x2a\x2b\x2d\x2e\x30-\x39\x41-\x5a\x5e-\x7a\x7c\x7e]+"
-# A value contains a URL-encoded UTF-8 string. The encoded form can contain any
-# printable US-ASCII characters (0x20-0x7f) other than SP, DEL, and ",;/
-_VALUE_FORMAT = r"[\x21\x23-\x2b\x2d-\x3a\x3c-\x5b\x5d-\x7e]*"
-# A key-value is key=value, with optional whitespace surrounding key and value
-_KEY_VALUE_FORMAT = rf"{_OWS}{_KEY_FORMAT}{_OWS}={_OWS}{_VALUE_FORMAT}{_OWS}"
-
-_HEADER_PATTERN = compile(_KEY_VALUE_FORMAT)
-_DELIMITER_PATTERN = compile(r"[ \t]*,[ \t]*")
-
-
-def parse_env_headers(s: str) -> Dict[str, str]:
-    """
-    Parse ``s``, which is a ``str`` instance containing HTTP headers encoded
-    for use in ENV variables per the W3C Baggage HTTP header format at
-    https://www.w3.org/TR/baggage/#baggage-http-header-format, except that
-    additional semi-colon delimited metadata is not supported.
-
-    src: https://github.com/open-telemetry/opentelemetry-python/blob/2d5cd58f33bd8a16f45f30be620a96699bc14297/opentelemetry-api/src/opentelemetry/util/re.py#L52
-    """
-    headers: Dict[str, str] = {}
-    headers_list: List[str] = split(_DELIMITER_PATTERN, s)
-    for header in headers_list:
-        if not header:  # empty string
-            continue
-        match = _HEADER_PATTERN.fullmatch(header.strip())
-        if not match:
-            _logger.warning(
-                "Header format invalid! Header values in environment variables must be "
-                "URL encoded: %s",
-                header,
-            )
-            continue
-        # value may contain any number of `=`
-        name, value = match.string.split("=", 1)
-        name = unquote(name).strip().lower()
-        value = unquote(value).strip()
-        headers[name] = value
-
-    return headers