arize-phoenix 11.5.0__tar.gz → 11.6.0__tar.gz

{arize_phoenix-11.5.0 → arize_phoenix-11.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arize-phoenix
-Version: 11.5.0
+Version: 11.6.0
 Summary: AI Observability and Evaluation
 Project-URL: Documentation, https://arize.com/docs/phoenix/
 Project-URL: Issues, https://github.com/Arize-ai/phoenix/issues

{arize_phoenix-11.5.0 → arize_phoenix-11.6.0}/src/phoenix/server/api/queries.py

@@ -335,28 +335,20 @@ class Query:
     async def compare_experiments(
         self,
         info: Info[Context, None],
-        experiment_ids: list[GlobalID],
+        baseline_experiment_id: GlobalID,
+        compare_experiment_ids: list[GlobalID],
         first: Optional[int] = 50,
         after: Optional[CursorString] = UNSET,
         filter_condition: Optional[str] = UNSET,
     ) -> Connection[ExperimentComparison]:
-        # Handle empty experiment_ids gracefully
-        if not experiment_ids:
-            return connection_from_list(
-                data=[],
-                args=ConnectionArgs(
-                    first=first,
-                    after=after if isinstance(after, CursorString) else None,
-                ),
-            )
-
-        experiment_ids_ = [
+        if baseline_experiment_id in compare_experiment_ids:
+            raise BadRequest("Compare experiment IDs cannot contain the baseline experiment ID")
+        if len(set(compare_experiment_ids)) < len(compare_experiment_ids):
+            raise BadRequest("Compare experiment IDs must be unique")
+        experiment_ids = [
             from_global_id_with_expected_type(experiment_id, models.Experiment.__name__)
-            for experiment_id in experiment_ids
+            for experiment_id in (baseline_experiment_id, *compare_experiment_ids)
         ]
-        if len(set(experiment_ids_)) != len(experiment_ids_):
-            raise BadRequest("Experiment IDs must be unique.")
-
         cursor = Cursor.from_string(after) if after else None
         page_size = first or 50
 
@@ -375,7 +367,7 @@ class Query:
                         models.Experiment.dataset_version_id == models.DatasetVersion.id,
                     )
                     .where(
-                        models.Experiment.id.in_(experiment_ids_),
+                        models.Experiment.id.in_(experiment_ids),
                     )
                 )
             ).first()
@@ -385,7 +377,7 @@ class Query:
             num_datasets, dataset_id, version_id, num_resolved_experiment_ids = validation_result
             if num_datasets != 1:
                 raise BadRequest("Experiments must belong to the same dataset.")
-            if num_resolved_experiment_ids != len(experiment_ids_):
+            if num_resolved_experiment_ids != len(experiment_ids):
                 raise NotFound("Unable to resolve one or more experiment IDs.")
 
             revision_ids = (
@@ -425,7 +417,7 @@ class Query:
                 examples_query = update_examples_query_with_filter_condition(
                     query=examples_query,
                     filter_condition=filter_condition,
-                    experiment_ids=experiment_ids_,
+                    experiment_ids=experiment_ids,
                 )
 
             examples = (await session.scalars(examples_query)).all()
@@ -444,17 +436,20 @@ class Query:
                         models.ExperimentRun.dataset_example_id.in_(
                             example.id for example in examples
                         ),
-                        models.ExperimentRun.experiment_id.in_(experiment_ids_),
+                        models.ExperimentRun.experiment_id.in_(experiment_ids),
                     )
                 )
                 .options(joinedload(models.ExperimentRun.trace).load_only(models.Trace.trace_id))
+                .order_by(
+                    models.ExperimentRun.repetition_number.asc()
+                )  # repetitions are not currently implemented, but this ensures that the repetitions will be properly ordered once implemented # noqa: E501
             ):
                 runs[run.dataset_example_id][run.experiment_id].append(run)
 
         cursors_and_nodes = []
         for example in examples:
             run_comparison_items = []
-            for experiment_id in experiment_ids_:
+            for experiment_id in experiment_ids:
                 run_comparison_items.append(
                     RunComparisonItem(
                         experiment_id=GlobalID(Experiment.__name__, str(experiment_id)),
@@ -479,7 +474,7 @@ class Query:
 
         return connection_from_cursors_and_nodes(
             cursors_and_nodes=cursors_and_nodes,
-            has_previous_page=False,
+            has_previous_page=False,  # set to false since we are only doing forward pagination (https://relay.dev/graphql/connections.htm#sec-undefined.PageInfo.Fields) # noqa: E501
             has_next_page=has_next_page,
         )
 
@@ -989,13 +984,14 @@ class Query:
             #     stats = cast(Iterable[tuple[str, int]], await session.execute(stmt))
             # stats = _consolidate_sqlite_db_table_stats(stats)
         elif info.context.db.dialect is SupportedSQLDialect.POSTGRESQL:
-            stmt = text(f"""\
+            nspname = getenv(ENV_PHOENIX_SQL_DATABASE_SCHEMA) or "public"
+            stmt = text("""\
                 SELECT c.relname, pg_total_relation_size(c.oid)
                 FROM pg_class as c
                 INNER JOIN pg_namespace as n ON n.oid = c.relnamespace
                 WHERE c.relkind = 'r'
-                AND n.nspname = '{getenv(ENV_PHOENIX_SQL_DATABASE_SCHEMA) or "public"}';
-            """)
+                AND n.nspname = :nspname;
+            """).bindparams(nspname=nspname)
             try:
                 async with info.context.db() as session:
                     stats = cast(Iterable[tuple[str, int]], await session.execute(stmt))

{arize_phoenix-11.5.0 → arize_phoenix-11.6.0}/src/phoenix/server/api/routers/v1/spans.py

@@ -602,7 +602,7 @@ async def span_search_otlpv1(
             models.Trace.trace_id,
         )
         .join(models.Trace, onclause=models.Trace.id == models.Span.trace_rowid)
-        .join(models.Project, onclause=models.Project.id == project_id)
+        .where(models.Trace.project_rowid == project_id)
         .order_by(*order_by)
     )
 
@@ -737,7 +737,7 @@ async def span_search(
             models.Trace.trace_id,
         )
         .join(models.Trace, onclause=models.Trace.id == models.Span.trace_rowid)
-        .join(models.Project, onclause=models.Project.id == project_id)
+        .where(models.Trace.project_rowid == project_id)
         .order_by(*order_by)
     )
 

{arize_phoenix-11.5.0 → arize_phoenix-11.6.0}/src/phoenix/server/api/types/Span.py

@@ -19,7 +19,6 @@ from typing_extensions import Annotated, TypeAlias
 import phoenix.trace.schemas as trace_schema
 from phoenix.db import models
 from phoenix.server.api.context import Context
-from phoenix.server.api.dataloaders import types as dataloader_types
 from phoenix.server.api.helpers.dataset_helpers import (
     get_dataset_example_input,
     get_dataset_example_output,
@@ -829,104 +828,6 @@ class Span(Node):
             for entry in entries
         ]
 
-    @strawberry.field
-    async def cumulative_cost_summary(self, info: Info[Context, None]) -> Optional[SpanCostSummary]:
-        max_depth = 0
-        descendant_rowids = await info.context.data_loaders.span_descendants.load(
-            (self.span_rowid, max_depth)
-        )
-        span_costs = await info.context.data_loaders.span_cost_by_span.load_many(
-            (self.span_rowid, *descendant_rowids)
-        )
-        total_cost: Optional[float] = None
-        total_tokens: Optional[float] = None
-        prompt_cost: Optional[float] = None
-        prompt_tokens: Optional[float] = None
-        completion_cost: Optional[float] = None
-        completion_tokens: Optional[float] = None
-        for span_cost in span_costs:
-            if span_cost is None:
-                continue
-            if span_cost.total_cost is not None:
-                total_cost = (total_cost or 0) + span_cost.total_cost
-            if span_cost.total_tokens is not None:
-                total_tokens = (total_tokens or 0) + span_cost.total_tokens
-            if span_cost.prompt_cost is not None:
-                prompt_cost = (prompt_cost or 0) + span_cost.prompt_cost
-            if span_cost.prompt_tokens is not None:
-                prompt_tokens = (prompt_tokens or 0) + span_cost.prompt_tokens
-            if span_cost.completion_cost is not None:
-                completion_cost = (completion_cost or 0) + span_cost.completion_cost
-            if span_cost.completion_tokens is not None:
-                completion_tokens = (completion_tokens or 0) + span_cost.completion_tokens
-        return SpanCostSummary(
-            prompt=CostBreakdown(
-                tokens=prompt_tokens,
-                cost=prompt_cost,
-            ),
-            completion=CostBreakdown(
-                tokens=completion_tokens,
-                cost=completion_cost,
-            ),
-            total=CostBreakdown(
-                tokens=total_tokens,
-                cost=total_cost,
-            ),
-        )
-
-    @strawberry.field
-    async def cumulative_cost_detail_summary_entries(
-        self, info: Info[Context, None]
-    ) -> list[SpanCostDetailSummaryEntry]:
-        max_depth = 0
-        descendant_rowids = await info.context.data_loaders.span_descendants.load(
-            (self.span_rowid, max_depth)
-        )
-        entry_lists = (
-            await info.context.data_loaders.span_cost_detail_summary_entries_by_span.load_many(
-                (self.span_rowid, *descendant_rowids)
-            )
-        )
-
-        TokenType: TypeAlias = str
-        IsPrompt: TypeAlias = bool
-        grouped_entries: dict[
-            IsPrompt, dict[TokenType, list[dataloader_types.SpanCostDetailSummaryEntry]]
-        ] = {}
-
-        for entries in entry_lists:
-            for entry in entries:
-                is_prompt = entry.is_prompt
-                token_type = entry.token_type
-                if is_prompt not in grouped_entries:
-                    grouped_entries[is_prompt] = {}
-                if token_type not in grouped_entries[is_prompt]:
-                    grouped_entries[is_prompt][token_type] = []
-                grouped_entries[is_prompt][token_type].append(entry)
-
-        result: list[SpanCostDetailSummaryEntry] = []
-        for is_prompt in (True, False):
-            entries_by_token_type = grouped_entries[is_prompt]
-            for token_type, entries in sorted(entries_by_token_type.items()):
-                cost: Optional[float] = None
-                tokens: Optional[float] = None
-                for entry in entries:
-                    if entry.value.cost is not None:
-                        cost = (cost or 0) + entry.value.cost
-                    if entry.value.tokens is not None:
-                        tokens = (tokens or 0) + entry.value.tokens
-                result.append(
-                    SpanCostDetailSummaryEntry(
-                        token_type=token_type,
-                        is_prompt=is_prompt,
-                        value=CostBreakdown(
-                            tokens=tokens,
-                            cost=cost,
-                        ),
-                    )
-                )
-        return result
-
 
 def _hide_embedding_vectors(attributes: Mapping[str, Any]) -> Mapping[str, Any]:
     if not (

{arize_phoenix-11.5.0 → arize_phoenix-11.6.0}/src/phoenix/server/app.py

@@ -386,19 +386,16 @@ async def version() -> PlainTextResponse:
     return PlainTextResponse(f"{phoenix_version}")
 
 
-DB_MUTEX: Optional[asyncio.Lock] = None
-
-
 def _db(
-    engine: AsyncEngine, bypass_lock: bool = False
-) -> Callable[[], AbstractAsyncContextManager[AsyncSession]]:
+    engine: AsyncEngine,
+) -> Callable[[Optional[asyncio.Lock]], AbstractAsyncContextManager[AsyncSession]]:
     Session = async_sessionmaker(engine, expire_on_commit=False)
 
     @contextlib.asynccontextmanager
-    async def factory() -> AsyncIterator[AsyncSession]:
+    async def factory(lock: Optional[asyncio.Lock] = None) -> AsyncIterator[AsyncSession]:
         async with contextlib.AsyncExitStack() as stack:
-            if not bypass_lock and DB_MUTEX:
-                await stack.enter_async_context(DB_MUTEX)
+            if lock:
+                await stack.enter_async_context(lock)
             yield await stack.enter_async_context(Session.begin())
 
     return factory
@@ -542,8 +539,7 @@ def _lifespan(
         for callback in startup_callbacks:
             if isinstance((res := callback()), Awaitable):
                 await res
-        global DB_MUTEX
-        DB_MUTEX = asyncio.Lock() if db.dialect is SupportedSQLDialect.SQLITE else None
+        db.lock = asyncio.Lock() if db.dialect is SupportedSQLDialect.SQLITE else None
         async with AsyncExitStack() as stack:
             (
                 enqueue,

{arize_phoenix-11.5.0 → arize_phoenix-11.6.0}/src/phoenix/server/cost_tracking/cost_model_lookup.py

@@ -109,7 +109,7 @@ class CostModelLookup:
             model
             for model in self._models
             if (not model.start_time or model.start_time <= start_time)
-            and model.name_pattern.match(model_name)
+            and model.name_pattern.search(model_name)
         ]
         if not candidates:
             return None