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

phoenix/experiments/utils.py

@@ -1,9 +0,0 @@
-from phoenix.config import get_web_base_url
-
-
-def get_experiment_url(*, dataset_id: str, experiment_id: str) -> str:
-    return f"{get_web_base_url()}datasets/{dataset_id}/compare?experimentId={experiment_id}"
-
-
-def get_dataset_experiments_url(*, dataset_id: str) -> str:
-    return f"{get_web_base_url()}datasets/{dataset_id}/experiments"

phoenix/server/api/dataloaders/average_experiment_run_latency.py

@@ -1,54 +0,0 @@
-from typing import (
-    AsyncContextManager,
-    Callable,
-    List,
-)
-
-from sqlalchemy import func, select
-from sqlalchemy.ext.asyncio import AsyncSession
-from strawberry.dataloader import DataLoader
-from typing_extensions import TypeAlias
-
-from phoenix.db import models
-
-ExperimentID: TypeAlias = int
-RunLatency: TypeAlias = float
-Key: TypeAlias = ExperimentID
-Result: TypeAlias = RunLatency
-
-
-class AverageExperimentRunLatencyDataLoader(DataLoader[Key, Result]):
-    def __init__(
-        self,
-        db: Callable[[], AsyncContextManager[AsyncSession]],
-    ) -> None:
-        super().__init__(load_fn=self._load_fn)
-        self._db = db
-
-    async def _load_fn(self, keys: List[Key]) -> List[Result]:
-        experiment_ids = keys
-        async with self._db() as session:
-            avg_latencies = {
-                experiment_id: avg_latency
-                async for experiment_id, avg_latency in await session.stream(
-                    select(
-                        models.ExperimentRun.experiment_id,
-                        func.avg(
-                            func.extract(
-                                "epoch",
-                                models.ExperimentRun.end_time,
-                            )
-                            - func.extract(
-                                "epoch",
-                                models.ExperimentRun.start_time,
-                            )
-                        ),
-                    )
-                    .where(models.ExperimentRun.experiment_id.in_(set(experiment_ids)))
-                    .group_by(models.ExperimentRun.experiment_id)
-                )
-            }
-        return [
-            avg_latencies.get(experiment_id, ValueError(f"Unknown experiment: {experiment_id}"))
-            for experiment_id in experiment_ids
-        ]

phoenix/server/api/dataloaders/dataset_example_revisions.py

@@ -1,100 +0,0 @@
-from typing import (
-    AsyncContextManager,
-    Callable,
-    List,
-    Optional,
-    Tuple,
-    Union,
-)
-
-from sqlalchemy import Integer, case, func, literal, or_, select, union
-from sqlalchemy.ext.asyncio import AsyncSession
-from strawberry.dataloader import DataLoader
-from typing_extensions import TypeAlias
-
-from phoenix.db import models
-from phoenix.server.api.types.DatasetExampleRevision import DatasetExampleRevision
-
-ExampleID: TypeAlias = int
-VersionID: TypeAlias = Optional[int]
-Key: TypeAlias = Tuple[ExampleID, Optional[VersionID]]
-Result: TypeAlias = DatasetExampleRevision
-
-
-class DatasetExampleRevisionsDataLoader(DataLoader[Key, Result]):
-    def __init__(self, db: Callable[[], AsyncContextManager[AsyncSession]]) -> None:
-        super().__init__(load_fn=self._load_fn)
-        self._db = db
-
-    async def _load_fn(self, keys: List[Key]) -> List[Union[Result, ValueError]]:
-        # sqlalchemy has limited SQLite support for VALUES, so use UNION ALL instead.
-        # For details, see https://github.com/sqlalchemy/sqlalchemy/issues/7228
-        keys_subquery = union(
-            *(
-                select(
-                    literal(example_id, Integer).label("example_id"),
-                    literal(version_id, Integer).label("version_id"),
-                )
-                for example_id, version_id in keys
-            )
-        ).subquery()
-        revision_ids = (
-            select(
-                keys_subquery.c.example_id,
-                keys_subquery.c.version_id,
-                func.max(models.DatasetExampleRevision.id).label("revision_id"),
-            )
-            .select_from(keys_subquery)
-            .join(
-                models.DatasetExampleRevision,
-                onclause=keys_subquery.c.example_id
-                == models.DatasetExampleRevision.dataset_example_id,
-            )
-            .where(
-                or_(
-                    keys_subquery.c.version_id.is_(None),
-                    models.DatasetExampleRevision.dataset_version_id <= keys_subquery.c.version_id,
-                )
-            )
-            .group_by(keys_subquery.c.example_id, keys_subquery.c.version_id)
-        ).subquery()
-        query = (
-            select(
-                revision_ids.c.example_id,
-                revision_ids.c.version_id,
-                case(
-                    (
-                        or_(
-                            revision_ids.c.version_id.is_(None),
-                            models.DatasetVersion.id.is_not(None),
-                        ),
-                        True,
-                    ),
-                    else_=False,
-                ).label("is_valid_version"),  # check that non-null versions exist
-                models.DatasetExampleRevision,
-            )
-            .select_from(revision_ids)
-            .join(
-                models.DatasetExampleRevision,
-                onclause=revision_ids.c.revision_id == models.DatasetExampleRevision.id,
-            )
-            .join(
-                models.DatasetVersion,
-                onclause=revision_ids.c.version_id == models.DatasetVersion.id,
-                isouter=True,  # keep rows where the version id is null
-            )
-            .where(models.DatasetExampleRevision.revision_kind != "DELETE")
-        )
-        async with self._db() as session:
-            results = {
-                (example_id, version_id): DatasetExampleRevision.from_orm_revision(revision)
-                async for (
-                    example_id,
-                    version_id,
-                    is_valid_version,
-                    revision,
-                ) in await session.stream(query)
-                if is_valid_version
-            }
-        return [results.get(key, ValueError("Could not find revision.")) for key in keys]

phoenix/server/api/dataloaders/dataset_example_spans.py

@@ -1,43 +0,0 @@
-from typing import (
-    AsyncContextManager,
-    Callable,
-    List,
-    Optional,
-)
-
-from sqlalchemy import select
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy.orm import joinedload
-from strawberry.dataloader import DataLoader
-from typing_extensions import TypeAlias
-
-from phoenix.db import models
-
-ExampleID: TypeAlias = int
-Key: TypeAlias = ExampleID
-Result: TypeAlias = Optional[models.Span]
-
-
-class DatasetExampleSpansDataLoader(DataLoader[Key, Result]):
-    def __init__(self, db: Callable[[], AsyncContextManager[AsyncSession]]) -> None:
-        super().__init__(load_fn=self._load_fn)
-        self._db = db
-
-    async def _load_fn(self, keys: List[Key]) -> List[Result]:
-        example_ids = keys
-        async with self._db() as session:
-            spans = {
-                example_id: span
-                async for example_id, span in await session.stream(
-                    select(models.DatasetExample.id, models.Span)
-                    .select_from(models.DatasetExample)
-                    .join(models.Span, models.DatasetExample.span_rowid == models.Span.id)
-                    .where(models.DatasetExample.id.in_(example_ids))
-                    .options(
-                        joinedload(models.Span.trace, innerjoin=True).load_only(
-                            models.Trace.trace_id
-                        )
-                    )
-                )
-            }
-        return [spans.get(example_id) for example_id in example_ids]

phoenix/server/api/dataloaders/experiment_annotation_summaries.py

@@ -1,85 +0,0 @@
-from collections import defaultdict
-from dataclasses import dataclass
-from typing import (
-    AsyncContextManager,
-    Callable,
-    DefaultDict,
-    List,
-    Optional,
-)
-
-from sqlalchemy import func, select
-from sqlalchemy.ext.asyncio import AsyncSession
-from strawberry.dataloader import AbstractCache, DataLoader
-from typing_extensions import TypeAlias
-
-from phoenix.db import models
-
-
-@dataclass
-class ExperimentAnnotationSummary:
-    annotation_name: str
-    min_score: float
-    max_score: float
-    mean_score: float
-    count: int
-    error_count: int
-
-
-ExperimentID: TypeAlias = int
-Key: TypeAlias = ExperimentID
-Result: TypeAlias = List[ExperimentAnnotationSummary]
-
-
-class ExperimentAnnotationSummaryDataLoader(DataLoader[Key, Result]):
-    def __init__(
-        self,
-        db: Callable[[], AsyncContextManager[AsyncSession]],
-        cache_map: Optional[AbstractCache[Key, Result]] = None,
-    ) -> None:
-        super().__init__(load_fn=self._load_fn)
-        self._db = db
-
-    async def _load_fn(self, keys: List[Key]) -> List[Result]:
-        experiment_ids = keys
-        summaries: DefaultDict[ExperimentID, Result] = defaultdict(list)
-        async with self._db() as session:
-            async for (
-                experiment_id,
-                annotation_name,
-                min_score,
-                max_score,
-                mean_score,
-                count,
-                error_count,
-            ) in await session.stream(
-                select(
-                    models.ExperimentRun.experiment_id,
-                    models.ExperimentRunAnnotation.name,
-                    func.min(models.ExperimentRunAnnotation.score),
-                    func.max(models.ExperimentRunAnnotation.score),
-                    func.avg(models.ExperimentRunAnnotation.score),
-                    func.count(),
-                    func.count(models.ExperimentRunAnnotation.error),
-                )
-                .join(
-                    models.ExperimentRun,
-                    models.ExperimentRunAnnotation.experiment_run_id == models.ExperimentRun.id,
-                )
-                .where(models.ExperimentRun.experiment_id.in_(experiment_ids))
-                .group_by(models.ExperimentRun.experiment_id, models.ExperimentRunAnnotation.name)
-            ):
-                summaries[experiment_id].append(
-                    ExperimentAnnotationSummary(
-                        annotation_name=annotation_name,
-                        min_score=min_score,
-                        max_score=max_score,
-                        mean_score=mean_score,
-                        count=count,
-                        error_count=error_count,
-                    )
-                )
-        return [
-            sorted(summaries[experiment_id], key=lambda summary: summary.annotation_name)
-            for experiment_id in experiment_ids
-        ]

phoenix/server/api/dataloaders/experiment_error_rates.py

@@ -1,43 +0,0 @@
-from typing import (
-    AsyncContextManager,
-    Callable,
-    List,
-    Optional,
-)
-
-from sqlalchemy import func, select
-from sqlalchemy.ext.asyncio import AsyncSession
-from strawberry.dataloader import DataLoader
-from typing_extensions import TypeAlias
-
-from phoenix.db import models
-
-ExperimentID: TypeAlias = int
-ErrorRate: TypeAlias = float
-Key: TypeAlias = ExperimentID
-Result: TypeAlias = Optional[ErrorRate]
-
-
-class ExperimentErrorRatesDataLoader(DataLoader[Key, Result]):
-    def __init__(
-        self,
-        db: Callable[[], AsyncContextManager[AsyncSession]],
-    ) -> None:
-        super().__init__(load_fn=self._load_fn)
-        self._db = db
-
-    async def _load_fn(self, keys: List[Key]) -> List[Result]:
-        experiment_ids = keys
-        async with self._db() as session:
-            error_rates = {
-                experiment_id: error_rate
-                async for experiment_id, error_rate in await session.stream(
-                    select(
-                        models.ExperimentRun.experiment_id,
-                        func.count(models.ExperimentRun.error) / func.count(),
-                    )
-                    .group_by(models.ExperimentRun.experiment_id)
-                    .where(models.ExperimentRun.experiment_id.in_(experiment_ids))
-                )
-            }
-        return [error_rates.get(experiment_id) for experiment_id in experiment_ids]

phoenix/server/api/dataloaders/experiment_run_counts.py

@@ -1,42 +0,0 @@
-from typing import (
-    AsyncContextManager,
-    Callable,
-    List,
-)
-
-from sqlalchemy import func, select
-from sqlalchemy.ext.asyncio import AsyncSession
-from strawberry.dataloader import DataLoader
-from typing_extensions import TypeAlias
-
-from phoenix.db import models
-
-ExperimentID: TypeAlias = int
-RunCount: TypeAlias = int
-Key: TypeAlias = ExperimentID
-Result: TypeAlias = RunCount
-
-
-class ExperimentRunCountsDataLoader(DataLoader[Key, Result]):
-    def __init__(
-        self,
-        db: Callable[[], AsyncContextManager[AsyncSession]],
-    ) -> None:
-        super().__init__(load_fn=self._load_fn)
-        self._db = db
-
-    async def _load_fn(self, keys: List[Key]) -> List[Result]:
-        experiment_ids = keys
-        async with self._db() as session:
-            run_counts = {
-                experiment_id: run_count
-                async for experiment_id, run_count in await session.stream(
-                    select(models.ExperimentRun.experiment_id, func.count())
-                    .where(models.ExperimentRun.experiment_id.in_(set(experiment_ids)))
-                    .group_by(models.ExperimentRun.experiment_id)
-                )
-            }
-        return [
-            run_counts.get(experiment_id, ValueError(f"Unknown experiment: {experiment_id}"))
-            for experiment_id in experiment_ids
-        ]

phoenix/server/api/dataloaders/experiment_sequence_number.py

@@ -1,49 +0,0 @@
-from typing import (
-    AsyncContextManager,
-    Callable,
-    List,
-    Optional,
-)
-
-from sqlalchemy import distinct, func, select
-from sqlalchemy.ext.asyncio import AsyncSession
-from strawberry.dataloader import DataLoader
-from typing_extensions import TypeAlias
-
-from phoenix.db import models
-
-ExperimentId: TypeAlias = int
-Key: TypeAlias = ExperimentId
-Result: TypeAlias = Optional[int]
-
-
-class ExperimentSequenceNumberDataLoader(DataLoader[Key, Result]):
-    def __init__(self, db: Callable[[], AsyncContextManager[AsyncSession]]) -> None:
-        super().__init__(load_fn=self._load_fn)
-        self._db = db
-
-    async def _load_fn(self, keys: List[Key]) -> List[Result]:
-        experiment_ids = keys
-        dataset_ids = (
-            select(distinct(models.Experiment.dataset_id))
-            .where(models.Experiment.id.in_(experiment_ids))
-            .scalar_subquery()
-        )
-        row_number = (
-            func.row_number().over(
-                partition_by=models.Experiment.dataset_id,
-                order_by=models.Experiment.id,
-            )
-        ).label("row_number")
-        subq = (
-            select(models.Experiment.id, row_number)
-            .where(models.Experiment.dataset_id.in_(dataset_ids))
-            .subquery()
-        )
-        stmt = select(subq).where(subq.c.id.in_(experiment_ids))
-        async with self._db() as session:
-            result = {
-                experiment_id: sequence_number
-                async for experiment_id, sequence_number in await session.stream(stmt)
-            }
-        return [result.get(experiment_id) for experiment_id in experiment_ids]

phoenix/server/api/dataloaders/project_by_name.py

@@ -1,31 +0,0 @@
-from collections import defaultdict
-from typing import AsyncContextManager, Callable, DefaultDict, List, Optional
-
-from sqlalchemy import select
-from sqlalchemy.ext.asyncio import AsyncSession
-from strawberry.dataloader import DataLoader
-from typing_extensions import TypeAlias
-
-from phoenix.db import models
-
-ProjectName: TypeAlias = str
-Key: TypeAlias = ProjectName
-Result: TypeAlias = Optional[models.Project]
-
-
-class ProjectByNameDataLoader(DataLoader[Key, Result]):
-    def __init__(self, db: Callable[[], AsyncContextManager[AsyncSession]]) -> None:
-        super().__init__(load_fn=self._load_fn)
-        self._db = db
-
-    async def _load_fn(self, keys: List[Key]) -> List[Result]:
-        project_names = list(set(keys))
-        projects_by_name: DefaultDict[Key, Result] = defaultdict(None)
-        async with self._db() as session:
-            data = await session.stream_scalars(
-                select(models.Project).where(models.Project.name.in_(project_names))
-            )
-            async for project in data:
-                projects_by_name[project.name] = project
-
-        return [projects_by_name[project_name] for project_name in project_names]

phoenix/server/api/dataloaders/span_projects.py

@@ -1,33 +0,0 @@
-from typing import AsyncContextManager, Callable, List, Union
-
-from sqlalchemy import select
-from sqlalchemy.ext.asyncio import AsyncSession
-from strawberry.dataloader import DataLoader
-from typing_extensions import TypeAlias
-
-from phoenix.db import models
-
-SpanID: TypeAlias = int
-Key: TypeAlias = SpanID
-Result: TypeAlias = models.Project
-
-
-class SpanProjectsDataLoader(DataLoader[Key, Result]):
-    def __init__(self, db: Callable[[], AsyncContextManager[AsyncSession]]) -> None:
-        super().__init__(load_fn=self._load_fn)
-        self._db = db
-
-    async def _load_fn(self, keys: List[Key]) -> List[Union[Result, ValueError]]:
-        span_ids = list(set(keys))
-        async with self._db() as session:
-            projects = {
-                span_id: project
-                async for span_id, project in await session.stream(
-                    select(models.Span.id, models.Project)
-                    .select_from(models.Span)
-                    .join(models.Trace, models.Span.trace_rowid == models.Trace.id)
-                    .join(models.Project, models.Trace.project_rowid == models.Project.id)
-                    .where(models.Span.id.in_(span_ids))
-                )
-            }
-        return [projects.get(span_id) or ValueError("Invalid span ID") for span_id in span_ids]

phoenix/server/api/dataloaders/trace_row_ids.py

@@ -1,39 +0,0 @@
-from typing import (
-    AsyncContextManager,
-    Callable,
-    List,
-    Optional,
-    Tuple,
-)
-
-from sqlalchemy import select
-from sqlalchemy.ext.asyncio import AsyncSession
-from strawberry.dataloader import DataLoader
-from typing_extensions import TypeAlias
-
-from phoenix.db import models
-
-TraceId: TypeAlias = str
-Key: TypeAlias = TraceId
-TraceRowId: TypeAlias = int
-ProjectRowId: TypeAlias = int
-Result: TypeAlias = Optional[Tuple[TraceRowId, ProjectRowId]]
-
-
-class TraceRowIdsDataLoader(DataLoader[Key, Result]):
-    def __init__(self, db: Callable[[], AsyncContextManager[AsyncSession]]) -> None:
-        super().__init__(load_fn=self._load_fn)
-        self._db = db
-
-    async def _load_fn(self, keys: List[Key]) -> List[Result]:
-        stmt = select(
-            models.Trace.trace_id,
-            models.Trace.id,
-            models.Trace.project_rowid,
-        ).where(models.Trace.trace_id.in_(keys))
-        async with self._db() as session:
-            result = {
-                trace_id: (id_, project_rowid)
-                async for trace_id, id_, project_rowid in await session.stream(stmt)
-            }
-        return list(map(result.get, keys))