arize-phoenix 12.7.0__tar.gz → 12.8.0__tar.gz

{arize_phoenix-12.7.0 → arize_phoenix-12.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arize-phoenix
-Version: 12.7.0
+Version: 12.8.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-12.8.0/src/phoenix/server/api/mutations/dataset_label_mutations.py

@@ -0,0 +1,237 @@
+from typing import Optional
+
+import sqlalchemy
+import strawberry
+from sqlalchemy import delete, select
+from sqlalchemy.exc import IntegrityError as PostgreSQLIntegrityError
+from sqlalchemy.orm import joinedload
+from sqlalchemy.sql import tuple_
+from sqlean.dbapi2 import IntegrityError as SQLiteIntegrityError  # type: ignore[import-untyped]
+from strawberry import UNSET
+from strawberry.relay.types import GlobalID
+from strawberry.types import Info
+
+from phoenix.db import models
+from phoenix.server.api.auth import IsLocked, IsNotReadOnly, IsNotViewer
+from phoenix.server.api.context import Context
+from phoenix.server.api.exceptions import BadRequest, Conflict, NotFound
+from phoenix.server.api.queries import Query
+from phoenix.server.api.types.Dataset import Dataset, to_gql_dataset
+from phoenix.server.api.types.DatasetLabel import DatasetLabel, to_gql_dataset_label
+from phoenix.server.api.types.node import from_global_id_with_expected_type
+
+
+@strawberry.input
+class CreateDatasetLabelInput:
+    name: str
+    description: Optional[str] = UNSET
+    color: str
+    dataset_ids: Optional[list[GlobalID]] = UNSET
+
+
+@strawberry.type
+class CreateDatasetLabelMutationPayload:
+    dataset_label: DatasetLabel
+    datasets: list[Dataset]
+
+
+@strawberry.input
+class DeleteDatasetLabelsInput:
+    dataset_label_ids: list[GlobalID]
+
+
+@strawberry.type
+class DeleteDatasetLabelsMutationPayload:
+    dataset_labels: list[DatasetLabel]
+
+
+@strawberry.input
+class SetDatasetLabelsInput:
+    dataset_id: GlobalID
+    dataset_label_ids: list[GlobalID]
+
+
+@strawberry.type
+class SetDatasetLabelsMutationPayload:
+    query: Query
+    dataset: Dataset
+
+
+@strawberry.type
+class DatasetLabelMutationMixin:
+    @strawberry.mutation(permission_classes=[IsNotReadOnly, IsNotViewer, IsLocked])  # type: ignore
+    async def create_dataset_label(
+        self,
+        info: Info[Context, None],
+        input: CreateDatasetLabelInput,
+    ) -> CreateDatasetLabelMutationPayload:
+        name = input.name
+        description = input.description
+        color = input.color
+        dataset_rowids: dict[
+            int, None
+        ] = {}  # use dictionary to de-duplicate while preserving order
+        if input.dataset_ids:
+            for dataset_id in input.dataset_ids:
+                try:
+                    dataset_rowid = from_global_id_with_expected_type(dataset_id, Dataset.__name__)
+                except ValueError:
+                    raise BadRequest(f"Invalid dataset ID: {dataset_id}")
+                dataset_rowids[dataset_rowid] = None
+
+        async with info.context.db() as session:
+            dataset_label_orm = models.DatasetLabel(name=name, description=description, color=color)
+            session.add(dataset_label_orm)
+            try:
+                await session.flush()
+            except (PostgreSQLIntegrityError, SQLiteIntegrityError):
+                raise Conflict(f"A dataset label named '{name}' already exists")
+            except sqlalchemy.exc.StatementError as error:
+                raise BadRequest(str(error.orig))
+
+            datasets_by_id: dict[int, models.Dataset] = {}
+            if dataset_rowids:
+                datasets_by_id = {
+                    dataset.id: dataset
+                    for dataset in await session.scalars(
+                        select(models.Dataset).where(models.Dataset.id.in_(dataset_rowids.keys()))
+                    )
+                }
+                if len(datasets_by_id) < len(dataset_rowids):
+                    raise NotFound("One or more datasets not found")
+                session.add_all(
+                    [
+                        models.DatasetsDatasetLabel(
+                            dataset_id=dataset_rowid,
+                            dataset_label_id=dataset_label_orm.id,
+                        )
+                        for dataset_rowid in dataset_rowids
+                    ]
+                )
+                await session.commit()
+
+        return CreateDatasetLabelMutationPayload(
+            dataset_label=to_gql_dataset_label(dataset_label_orm),
+            datasets=[
+                to_gql_dataset(datasets_by_id[dataset_rowid]) for dataset_rowid in dataset_rowids
+            ],
+        )
+
+    @strawberry.mutation(permission_classes=[IsNotReadOnly, IsNotViewer, IsLocked])  # type: ignore
+    async def delete_dataset_labels(
+        self, info: Info[Context, None], input: DeleteDatasetLabelsInput
+    ) -> DeleteDatasetLabelsMutationPayload:
+        dataset_label_row_ids: dict[int, None] = {}
+        for dataset_label_node_id in input.dataset_label_ids:
+            try:
+                dataset_label_row_id = from_global_id_with_expected_type(
+                    dataset_label_node_id, DatasetLabel.__name__
+                )
+            except ValueError:
+                raise BadRequest(f"Unknown dataset label: {dataset_label_node_id}")
+            dataset_label_row_ids[dataset_label_row_id] = None
+        async with info.context.db() as session:
+            stmt = (
+                delete(models.DatasetLabel)
+                .where(models.DatasetLabel.id.in_(dataset_label_row_ids.keys()))
+                .returning(models.DatasetLabel)
+            )
+            deleted_dataset_labels = (await session.scalars(stmt)).all()
+            if len(deleted_dataset_labels) < len(dataset_label_row_ids):
+                await session.rollback()
+                raise NotFound("Could not find one or more dataset labels with given IDs")
+        deleted_dataset_labels_by_id = {
+            dataset_label.id: dataset_label for dataset_label in deleted_dataset_labels
+        }
+        return DeleteDatasetLabelsMutationPayload(
+            dataset_labels=[
+                to_gql_dataset_label(deleted_dataset_labels_by_id[dataset_label_row_id])
+                for dataset_label_row_id in dataset_label_row_ids
+            ]
+        )
+
+    @strawberry.mutation(permission_classes=[IsNotReadOnly, IsNotViewer, IsLocked])  # type: ignore
+    async def set_dataset_labels(
+        self, info: Info[Context, None], input: SetDatasetLabelsInput
+    ) -> SetDatasetLabelsMutationPayload:
+        try:
+            dataset_id = from_global_id_with_expected_type(input.dataset_id, Dataset.__name__)
+        except ValueError:
+            raise BadRequest(f"Invalid dataset ID: {input.dataset_id}")
+
+        dataset_label_ids: dict[
+            int, None
+        ] = {}  # use dictionary to de-duplicate while preserving order
+        for dataset_label_gid in input.dataset_label_ids:
+            try:
+                dataset_label_id = from_global_id_with_expected_type(
+                    dataset_label_gid, DatasetLabel.__name__
+                )
+            except ValueError:
+                raise BadRequest(f"Invalid dataset label ID: {dataset_label_gid}")
+            dataset_label_ids[dataset_label_id] = None
+
+        async with info.context.db() as session:
+            dataset = await session.scalar(
+                select(models.Dataset)
+                .where(models.Dataset.id == dataset_id)
+                .options(joinedload(models.Dataset.datasets_dataset_labels))
+            )
+
+            if not dataset:
+                raise NotFound(f"Dataset with ID {input.dataset_id} not found")
+
+            existing_label_ids = (
+                await session.scalars(
+                    select(models.DatasetLabel.id).where(
+                        models.DatasetLabel.id.in_(dataset_label_ids.keys())
+                    )
+                )
+            ).all()
+            if len(existing_label_ids) != len(dataset_label_ids):
+                raise NotFound("One or more dataset labels not found")
+
+            previously_applied_dataset_label_ids = {
+                dataset_dataset_label.dataset_label_id
+                for dataset_dataset_label in dataset.datasets_dataset_labels
+            }
+
+            datasets_dataset_labels_to_add = [
+                models.DatasetsDatasetLabel(
+                    dataset_id=dataset_id,
+                    dataset_label_id=dataset_label_id,
+                )
+                for dataset_label_id in dataset_label_ids
+                if dataset_label_id not in previously_applied_dataset_label_ids
+            ]
+            if datasets_dataset_labels_to_add:
+                session.add_all(datasets_dataset_labels_to_add)
+                await session.flush()
+
+            datasets_dataset_labels_to_delete = [
+                dataset_dataset_label
+                for dataset_dataset_label in dataset.datasets_dataset_labels
+                if dataset_dataset_label.dataset_label_id not in dataset_label_ids
+            ]
+            if datasets_dataset_labels_to_delete:
+                await session.execute(
+                    delete(models.DatasetsDatasetLabel).where(
+                        tuple_(
+                            models.DatasetsDatasetLabel.dataset_id,
+                            models.DatasetsDatasetLabel.dataset_label_id,
+                        ).in_(
+                            [
+                                (
+                                    datasets_dataset_labels.dataset_id,
+                                    datasets_dataset_labels.dataset_label_id,
+                                )
+                                for datasets_dataset_labels in datasets_dataset_labels_to_delete
+                            ]
+                        )
+                    )
+                )
+
+        return SetDatasetLabelsMutationPayload(
+            dataset=to_gql_dataset(dataset),
+            query=Query(),
+        )

{arize_phoenix-12.7.0 → arize_phoenix-12.8.0}/src/phoenix/server/api/queries.py

@@ -188,7 +188,17 @@ class Query:
     async def generative_models(
         self,
         info: Info[Context, None],
-    ) -> list[GenerativeModel]:
+        first: Optional[int] = 50,
+        last: Optional[int] = UNSET,
+        after: Optional[CursorString] = UNSET,
+        before: Optional[CursorString] = UNSET,
+    ) -> Connection[GenerativeModel]:
+        args = ConnectionArgs(
+            first=first,
+            after=after if isinstance(after, CursorString) else None,
+            last=last,
+            before=before if isinstance(before, CursorString) else None,
+        )
         async with info.context.db() as session:
             result = await session.scalars(
                 select(models.GenerativeModel)
@@ -200,8 +210,8 @@ class Query:
                 )
                 .options(joinedload(models.GenerativeModel.token_prices))
             )
-
-        return [to_gql_generative_model(model) for model in result.unique()]
+            data = [to_gql_generative_model(model) for model in result.unique()]
+        return connection_from_list(data=data, args=args)
 
     @strawberry.field
     async def playground_models(self, input: Optional[ModelsInput] = None) -> list[PlaygroundModel]:
@@ -1191,7 +1201,9 @@ class Query:
             before=before if isinstance(before, CursorString) else None,
         )
         async with info.context.db() as session:
-            dataset_labels = await session.scalars(select(models.DatasetLabel))
+            dataset_labels = await session.scalars(
+                select(models.DatasetLabel).order_by(models.DatasetLabel.name.asc())
+            )
         data = [to_gql_dataset_label(dataset_label) for dataset_label in dataset_labels]
         return connection_from_list(data=data, args=args)
 

{arize_phoenix-12.7.0 → arize_phoenix-12.8.0}/src/phoenix/server/cost_tracking/model_cost_manifest.json

@@ -784,7 +784,7 @@
           "token_type": "output"
         },
         {
-          "base_rate": 7.5e-8,
+          "base_rate": 3e-8,
           "is_prompt": true,
           "token_type": "cache_read"
         },
@@ -1027,7 +1027,7 @@
           "token_type": "output"
         },
         {
-          "base_rate": 3.125e-7,
+          "base_rate": 1.25e-7,
           "is_prompt": true,
           "token_type": "cache_read"
         }

arize_phoenix-12.8.0/src/phoenix/server/static/.vite/manifest.json

@@ -0,0 +1,93 @@
+{
+  "_components-Bem6_7MW.js": {
+    "file": "assets/components-Bem6_7MW.js",
+    "name": "components",
+    "imports": [
+      "_vendor-D-csRHGZ.js",
+      "_pages-CEJgMVKU.js",
+      "_vendor-arizeai-BJLCG_Gc.js",
+      "_vendor-codemirror-Cr963DyP.js",
+      "_vendor-three-BtCyLs1w.js"
+    ]
+  },
+  "_pages-CEJgMVKU.js": {
+    "file": "assets/pages-CEJgMVKU.js",
+    "name": "pages",
+    "imports": [
+      "_vendor-D-csRHGZ.js",
+      "_components-Bem6_7MW.js",
+      "_vendor-arizeai-BJLCG_Gc.js",
+      "_vendor-codemirror-Cr963DyP.js",
+      "_vendor-recharts-DgmPLgIp.js"
+    ]
+  },
+  "_vendor-BGzfc4EU.css": {
+    "file": "assets/vendor-BGzfc4EU.css",
+    "src": "_vendor-BGzfc4EU.css"
+  },
+  "_vendor-D-csRHGZ.js": {
+    "file": "assets/vendor-D-csRHGZ.js",
+    "name": "vendor",
+    "imports": [
+      "_vendor-three-BtCyLs1w.js"
+    ],
+    "css": [
+      "assets/vendor-BGzfc4EU.css"
+    ]
+  },
+  "_vendor-arizeai-BJLCG_Gc.js": {
+    "file": "assets/vendor-arizeai-BJLCG_Gc.js",
+    "name": "vendor-arizeai",
+    "imports": [
+      "_vendor-D-csRHGZ.js"
+    ]
+  },
+  "_vendor-codemirror-Cr963DyP.js": {
+    "file": "assets/vendor-codemirror-Cr963DyP.js",
+    "name": "vendor-codemirror",
+    "imports": [
+      "_vendor-D-csRHGZ.js",
+      "_vendor-shiki-wYOt1s7u.js"
+    ],
+    "dynamicImports": [
+      "_vendor-shiki-wYOt1s7u.js",
+      "_vendor-shiki-wYOt1s7u.js",
+      "_vendor-shiki-wYOt1s7u.js"
+    ]
+  },
+  "_vendor-recharts-DgmPLgIp.js": {
+    "file": "assets/vendor-recharts-DgmPLgIp.js",
+    "name": "vendor-recharts",
+    "imports": [
+      "_vendor-D-csRHGZ.js"
+    ]
+  },
+  "_vendor-shiki-wYOt1s7u.js": {
+    "file": "assets/vendor-shiki-wYOt1s7u.js",
+    "name": "vendor-shiki",
+    "isDynamicEntry": true,
+    "imports": [
+      "_vendor-D-csRHGZ.js"
+    ]
+  },
+  "_vendor-three-BtCyLs1w.js": {
+    "file": "assets/vendor-three-BtCyLs1w.js",
+    "name": "vendor-three"
+  },
+  "index.tsx": {
+    "file": "assets/index-NdiXbuNL.js",
+    "name": "index",
+    "src": "index.tsx",
+    "isEntry": true,
+    "imports": [
+      "_vendor-D-csRHGZ.js",
+      "_vendor-arizeai-BJLCG_Gc.js",
+      "_pages-CEJgMVKU.js",
+      "_components-Bem6_7MW.js",
+      "_vendor-three-BtCyLs1w.js",
+      "_vendor-codemirror-Cr963DyP.js",
+      "_vendor-shiki-wYOt1s7u.js",
+      "_vendor-recharts-DgmPLgIp.js"
+    ]
+  }
+}