arize-phoenix 3.19.3rc1__tar.gz → 3.20.0__tar.gz

{arize_phoenix-3.19.3rc1 → arize_phoenix-3.20.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: arize-phoenix
-Version: 3.19.3rc1
+Version: 3.20.0
 Summary: AI Observability and Evaluation
 Project-URL: Documentation, https://docs.arize.com/phoenix/
 Project-URL: Issues, https://github.com/Arize-ai/phoenix/issues

{arize_phoenix-3.19.3rc1/examples/manually-instrumented-chatbot → arize_phoenix-3.20.0/examples/manually-instrumented-chatbot/chat-service}/chat/app.py

@@ -19,7 +19,8 @@ from opentelemetry.sdk.trace.export import (
 
 from chat.types import Message, MessagesPayload, MessagesResponse
 
-endpoint = "http://127.0.0.1:6006/v1/traces"
+COLLECTOR_HOST = os.getenv("COLLECTOR_HOST", "localhost")
+endpoint = f"http://{COLLECTOR_HOST}:6006/v1/traces"
 tracer_provider = trace_sdk.TracerProvider()
 tracer_provider.add_span_processor(SimpleSpanProcessor(OTLPSpanExporter(endpoint)))
 trace_api.set_tracer_provider(tracer_provider)

arize_phoenix-3.20.0/examples/manually-instrumented-chatbot/frontend/Dockerfile

@@ -0,0 +1,15 @@
+FROM python:3.11-slim as builder
+WORKDIR /app
+COPY requirements.txt /app/
+RUN pip install uv
+RUN uv venv
+ENV PATH="/app/.venv/bin:$PATH"
+RUN uv pip sync requirements.txt
+
+FROM gcr.io/distroless/python3-debian12
+WORKDIR /app
+COPY --from=builder /app/.venv/lib/python3.11/site-packages/ /app/site-packages/
+ENV PYTHONPATH="/app/site-packages:$PYTHONPATH"
+COPY frontend/ /app/frontend/
+EXPOSE 8501
+CMD ["-m", "streamlit", "run", "frontend/app.py", "--server.port=8501", "--server.address=0.0.0.0"]

arize_phoenix-3.20.0/examples/manually-instrumented-chatbot/frontend/Makefile

@@ -0,0 +1,20 @@
+server:
+	streamlit run app.py
+
+format:
+	ruff check --fix . && ruff format .
+
+typecheck:
+	pyright .
+
+types:
+	datamodel-codegen  --input schema.json --input-file-type openapi --output frontend/request_types.py --enum-field-as-literal all
+
+requirements:
+	uv pip compile pyproject.toml > requirements.txt
+
+docker-build:
+	docker build -t frontend .
+
+docker-run:
+	docker run -p 8501:8501 -it frontend

arize_phoenix-3.20.0/examples/manually-instrumented-chatbot/frontend/pyproject.toml

@@ -0,0 +1,24 @@
+[project]
+name = "frontend"
+version = "0.1.0"
+dependencies = [
+  "streamlit",
+  "httpx",
+  "pydantic",
+]
+requires-python = ">=3.8"
+
+[project.optional-dependencies]
+dev = [
+  "pyright",
+  "ruff",
+  "datamodel-code-generator",
+]
+
+[tool.ruff]
+exclude = [
+  "frontend/request_types.py",
+]
+
+[tool.ruff.lint]
+extend-select = ["I"]

arize_phoenix-3.20.0/examples/manually-instrumented-chatbot/frontend/requirements.txt

@@ -0,0 +1,123 @@
+# This file was autogenerated by uv via the following command:
+#    uv pip compile pyproject.toml
+altair==5.3.0
+    # via streamlit
+annotated-types==0.6.0
+    # via pydantic
+anyio==4.3.0
+    # via httpx
+attrs==23.2.0
+    # via
+    #   jsonschema
+    #   referencing
+blinker==1.7.0
+    # via streamlit
+cachetools==5.3.3
+    # via streamlit
+certifi==2024.2.2
+    # via
+    #   httpcore
+    #   httpx
+    #   requests
+charset-normalizer==3.3.2
+    # via requests
+click==8.1.7
+    # via streamlit
+gitdb==4.0.11
+    # via gitpython
+gitpython==3.1.43
+    # via streamlit
+h11==0.14.0
+    # via httpcore
+httpcore==1.0.5
+    # via httpx
+httpx==0.27.0
+idna==3.6
+    # via
+    #   anyio
+    #   httpx
+    #   requests
+jinja2==3.1.3
+    # via
+    #   altair
+    #   pydeck
+jsonschema==4.21.1
+    # via altair
+jsonschema-specifications==2023.12.1
+    # via jsonschema
+markdown-it-py==3.0.0
+    # via rich
+markupsafe==2.1.5
+    # via jinja2
+mdurl==0.1.2
+    # via markdown-it-py
+numpy==1.26.4
+    # via
+    #   altair
+    #   pandas
+    #   pyarrow
+    #   pydeck
+    #   streamlit
+packaging==24.0
+    # via
+    #   altair
+    #   streamlit
+pandas==2.2.1
+    # via
+    #   altair
+    #   streamlit
+pillow==10.3.0
+    # via streamlit
+protobuf==4.25.3
+    # via streamlit
+pyarrow==15.0.2
+    # via streamlit
+pydantic==2.6.4
+pydantic-core==2.16.3
+    # via pydantic
+pydeck==0.8.0
+    # via streamlit
+pygments==2.17.2
+    # via rich
+python-dateutil==2.9.0.post0
+    # via pandas
+pytz==2024.1
+    # via pandas
+referencing==0.34.0
+    # via
+    #   jsonschema
+    #   jsonschema-specifications
+requests==2.31.0
+    # via streamlit
+rich==13.7.1
+    # via streamlit
+rpds-py==0.18.0
+    # via
+    #   jsonschema
+    #   referencing
+six==1.16.0
+    # via python-dateutil
+smmap==5.0.1
+    # via gitdb
+sniffio==1.3.1
+    # via
+    #   anyio
+    #   httpx
+streamlit==1.33.0
+tenacity==8.2.3
+    # via streamlit
+toml==0.10.2
+    # via streamlit
+toolz==0.12.1
+    # via altair
+tornado==6.4
+    # via streamlit
+typing-extensions==4.11.0
+    # via
+    #   pydantic
+    #   pydantic-core
+    #   streamlit
+tzdata==2024.1
+    # via pandas
+urllib3==2.2.1
+    # via requests

arize_phoenix-3.20.0/examples/manually-instrumented-chatbot/frontend/schema.json

@@ -0,0 +1,149 @@
+{
+    "openapi": "3.1.0",
+    "info": {
+        "title": "Chat Service Schema",
+        "description": "API schema for chat-service",
+        "version": "1.0.0"
+    },
+    "paths": {
+        "/messages/": {
+            "post": {
+                "summary": "Messages",
+                "operationId": "messages_messages__post",
+                "requestBody": {
+                    "content": {
+                        "application/json": {
+                            "schema": {
+                                "$ref": "#/components/schemas/MessagesPayload"
+                            }
+                        }
+                    },
+                    "required": true
+                },
+                "responses": {
+                    "200": {
+                        "description": "Successful Response",
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "$ref": "#/components/schemas/MessagesResponse"
+                                }
+                            }
+                        }
+                    },
+                    "422": {
+                        "description": "Validation Error",
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "$ref": "#/components/schemas/HTTPValidationError"
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    },
+    "components": {
+        "schemas": {
+            "HTTPValidationError": {
+                "properties": {
+                    "detail": {
+                        "items": {
+                            "$ref": "#/components/schemas/ValidationError"
+                        },
+                        "type": "array",
+                        "title": "Detail"
+                    }
+                },
+                "type": "object",
+                "title": "HTTPValidationError"
+            },
+            "Message": {
+                "properties": {
+                    "role": {
+                        "type": "string",
+                        "enum": [
+                            "system",
+                            "assistant",
+                            "user"
+                        ],
+                        "title": "Role"
+                    },
+                    "content": {
+                        "type": "string",
+                        "title": "Content"
+                    }
+                },
+                "type": "object",
+                "required": [
+                    "role",
+                    "content"
+                ],
+                "title": "Message"
+            },
+            "MessagesPayload": {
+                "properties": {
+                    "messages": {
+                        "items": {
+                            "$ref": "#/components/schemas/Message"
+                        },
+                        "type": "array",
+                        "title": "Messages"
+                    }
+                },
+                "type": "object",
+                "required": [
+                    "messages"
+                ],
+                "title": "MessagesPayload"
+            },
+            "MessagesResponse": {
+                "properties": {
+                    "message": {
+                        "$ref": "#/components/schemas/Message"
+                    }
+                },
+                "type": "object",
+                "required": [
+                    "message"
+                ],
+                "title": "MessagesResponse"
+            },
+            "ValidationError": {
+                "properties": {
+                    "loc": {
+                        "items": {
+                            "anyOf": [
+                                {
+                                    "type": "string"
+                                },
+                                {
+                                    "type": "integer"
+                                }
+                            ]
+                        },
+                        "type": "array",
+                        "title": "Location"
+                    },
+                    "msg": {
+                        "type": "string",
+                        "title": "Message"
+                    },
+                    "type": {
+                        "type": "string",
+                        "title": "Error Type"
+                    }
+                },
+                "type": "object",
+                "required": [
+                    "loc",
+                    "msg",
+                    "type"
+                ],
+                "title": "ValidationError"
+            }
+        }
+    }
+}

{arize_phoenix-3.19.3rc1 → arize_phoenix-3.20.0}/pyproject.toml

@@ -296,6 +296,7 @@ exclude = [
   "sdist/",
   "tests/",
   "tutorials/",
+  "examples/manually-instrumented-chatbot/"
 ]
 
 [[tool.mypy.overrides]]

{arize_phoenix-3.19.3rc1 → arize_phoenix-3.20.0}/src/phoenix/__init__.py

@@ -5,8 +5,10 @@ from types import ModuleType
 from typing import Any, Optional
 
 from .datasets.dataset import Dataset
-from .datasets.fixtures import ExampleDatasets, load_example
-from .datasets.schema import EmbeddingColumnNames, RetrievalEmbeddingColumnNames, Schema
+from .datasets.fixtures import ExampleDatasets
+from .inferences.fixtures import ExampleInferences, load_example
+from .inferences.inferences import Inferences
+from .inferences.schema import EmbeddingColumnNames, RetrievalEmbeddingColumnNames, Schema
 from .session.client import Client
 from .session.evaluation import log_evaluations
 from .session.session import NotebookEnvironment, Session, active_session, close_app, launch_app
@@ -33,11 +35,13 @@ Here are just a few of the things that phoenix does well:
 __all__ = [
     "__version__",
     "Dataset",
+    "ExampleDatasets",
+    "Inferences",
     "EmbeddingColumnNames",
     "RetrievalEmbeddingColumnNames",
     "Schema",
     "load_example",
-    "ExampleDatasets",
+    "ExampleInferences",
     "active_session",
     "close_app",
     "launch_app",

{arize_phoenix-3.19.3rc1 → arize_phoenix-3.20.0}/src/phoenix/core/model.py

@@ -1,13 +1,13 @@
 from typing import List, Optional, Union
 
-from phoenix.datasets.dataset import Dataset
-from phoenix.datasets.schema import EmbeddingColumnNames, EmbeddingFeatures
+from phoenix.inferences.inferences import Inferences
+from phoenix.inferences.schema import EmbeddingColumnNames, EmbeddingFeatures
 
 from .embedding_dimension import EmbeddingDimension
 
 
 def _get_embedding_dimensions(
-    primary_dataset: Dataset, reference_dataset: Optional[Dataset]
+    primary_dataset: Inferences, reference_dataset: Optional[Inferences]
 ) -> List[EmbeddingDimension]:
     embedding_dimensions: List[EmbeddingDimension] = []
     embedding_features: EmbeddingFeatures = {}
@@ -58,8 +58,8 @@ def _get_embedding_dimensions(
 def _check_embedding_vector_lengths_match_across_datasets(
     embedding_feature_name: str,
     embedding_column_names: EmbeddingColumnNames,
-    primary_dataset: Dataset,
-    reference_dataset: Dataset,
+    primary_dataset: Inferences,
+    reference_dataset: Inferences,
 ) -> None:
     """
     Ensure that for each embedding feature, the vector lengths match across the primary
@@ -86,7 +86,9 @@ def _check_embedding_vector_lengths_match_across_datasets(
         )
 
 
-def _get_column_vector_length(dataset: Dataset, embedding_vector_column_name: str) -> Optional[int]:
+def _get_column_vector_length(
+    dataset: Inferences, embedding_vector_column_name: str
+) -> Optional[int]:
     """
     Because a dataset has already been constructed, we can assume that the lengths
     of the vectors for any given embedding feature in the dataset are the same.

{arize_phoenix-3.19.3rc1 → arize_phoenix-3.20.0}/src/phoenix/core/model_schema_adapter.py

@@ -6,18 +6,18 @@ import pandas as pd
 from pandas.api.types import is_object_dtype
 from typing_extensions import TypeAlias, TypeGuard
 
-from phoenix import Dataset, EmbeddingColumnNames
+from phoenix import EmbeddingColumnNames, Inferences
 from phoenix.core.model import _get_embedding_dimensions
 from phoenix.core.model_schema import Embedding, Model, RetrievalEmbedding, Schema
-from phoenix.datasets.schema import RetrievalEmbeddingColumnNames
-from phoenix.datasets.schema import Schema as DatasetSchema
+from phoenix.inferences.schema import RetrievalEmbeddingColumnNames
+from phoenix.inferences.schema import Schema as DatasetSchema
 
 DatasetName: TypeAlias = str
 ColumnName: TypeAlias = str
 DisplayName: TypeAlias = str
 
 
-def create_model_from_datasets(*datasets: Optional[Dataset]) -> Model:
+def create_model_from_datasets(*datasets: Optional[Inferences]) -> Model:
     # TODO: move this validation into model_schema.Model.
     if len(datasets) > 1 and datasets[0] is not None:
         # Check that for each embedding dimension all vectors
@@ -132,8 +132,8 @@ def create_model_from_datasets(*datasets: Optional[Dataset]) -> Model:
     )
 
 
-def _is_dataset(obj: Optional[Dataset]) -> TypeGuard[Dataset]:
-    return type(obj) is Dataset
+def _is_dataset(obj: Optional[Inferences]) -> TypeGuard[Inferences]:
+    return type(obj) is Inferences
 
 
 def _take_first_str(iterator: Iterable[str]) -> str:

arize_phoenix-3.20.0/src/phoenix/datasets/dataset.py

@@ -0,0 +1,214 @@
+import re
+from dataclasses import dataclass, replace
+from enum import Enum
+from itertools import groupby
+from typing import Dict
+
+from pandas import DataFrame
+
+from phoenix.inferences.inferences import Inferences
+from phoenix.inferences.schema import EmbeddingColumnNames, RetrievalEmbeddingColumnNames, Schema
+from phoenix.utilities.deprecation import deprecated, deprecated_class
+
+
+@deprecated_class("phoenix.Dataset is deprecated, use phoenix.Inference instead.")
+class Dataset(Inferences):
+    @classmethod
+    @deprecated("Dataset.from_open_inference is deprecated and will be removed.")
+    def from_open_inference(cls, dataframe: DataFrame) -> "Dataset":
+        schema = Schema()
+        column_renaming: Dict[str, str] = {}
+        for group_name, group in groupby(
+            sorted(
+                map(_parse_open_inference_column_name, dataframe.columns),
+                key=lambda column: column.name,
+            ),
+            key=lambda column: column.name,
+        ):
+            open_inference_columns = list(group)
+            if group_name == "":
+                column_names_by_category = {
+                    column.category: column.full_name for column in open_inference_columns
+                }
+                schema = replace(
+                    schema,
+                    prediction_id_column_name=column_names_by_category.get(
+                        OpenInferenceCategory.id
+                    ),
+                    timestamp_column_name=column_names_by_category.get(
+                        OpenInferenceCategory.timestamp
+                    ),
+                )
+                continue
+            column_names_by_specifier = {
+                column.specifier: column.full_name for column in open_inference_columns
+            }
+            if group_name == "response":
+                response_vector_column_name = column_names_by_specifier.get(
+                    OpenInferenceSpecifier.embedding
+                )
+                if response_vector_column_name is not None:
+                    column_renaming[response_vector_column_name] = "response"
+                    schema = replace(
+                        schema,
+                        response_column_names=EmbeddingColumnNames(
+                            vector_column_name=column_renaming[response_vector_column_name],
+                            raw_data_column_name=column_names_by_specifier.get(
+                                OpenInferenceSpecifier.default
+                            ),
+                        ),
+                    )
+                else:
+                    response_text_column_name = column_names_by_specifier.get(
+                        OpenInferenceSpecifier.default
+                    )
+                    if response_text_column_name is None:
+                        raise ValueError(
+                            "invalid OpenInference format: missing text column for response"
+                        )
+                    column_renaming[response_text_column_name] = "response"
+                    schema = replace(
+                        schema,
+                        response_column_names=column_renaming[response_text_column_name],
+                    )
+            elif group_name == "prompt":
+                prompt_vector_column_name = column_names_by_specifier.get(
+                    OpenInferenceSpecifier.embedding
+                )
+                if prompt_vector_column_name is None:
+                    raise ValueError(
+                        "invalid OpenInference format: missing embedding vector column for prompt"
+                    )
+                column_renaming[prompt_vector_column_name] = "prompt"
+                schema = replace(
+                    schema,
+                    prompt_column_names=RetrievalEmbeddingColumnNames(
+                        vector_column_name=column_renaming[prompt_vector_column_name],
+                        raw_data_column_name=column_names_by_specifier.get(
+                            OpenInferenceSpecifier.default
+                        ),
+                        context_retrieval_ids_column_name=column_names_by_specifier.get(
+                            OpenInferenceSpecifier.retrieved_document_ids
+                        ),
+                        context_retrieval_scores_column_name=column_names_by_specifier.get(
+                            OpenInferenceSpecifier.retrieved_document_scores
+                        ),
+                    ),
+                )
+            elif OpenInferenceSpecifier.embedding in column_names_by_specifier:
+                vector_column_name = column_names_by_specifier[OpenInferenceSpecifier.embedding]
+                column_renaming[vector_column_name] = group_name
+                embedding_feature_column_names = schema.embedding_feature_column_names or {}
+                embedding_feature_column_names.update(
+                    {
+                        group_name: EmbeddingColumnNames(
+                            vector_column_name=column_renaming[vector_column_name],
+                            raw_data_column_name=column_names_by_specifier.get(
+                                OpenInferenceSpecifier.raw_data
+                            ),
+                            link_to_data_column_name=column_names_by_specifier.get(
+                                OpenInferenceSpecifier.link_to_data
+                            ),
+                        )
+                    }
+                )
+                schema = replace(
+                    schema,
+                    embedding_feature_column_names=embedding_feature_column_names,
+                )
+            elif len(open_inference_columns) == 1:
+                open_inference_column = open_inference_columns[0]
+                raw_column_name = open_inference_column.full_name
+                column_renaming[raw_column_name] = open_inference_column.name
+                if open_inference_column.category is OpenInferenceCategory.feature:
+                    schema = replace(
+                        schema,
+                        feature_column_names=(
+                            (schema.feature_column_names or []) + [column_renaming[raw_column_name]]
+                        ),
+                    )
+                elif open_inference_column.category is OpenInferenceCategory.tag:
+                    schema = replace(
+                        schema,
+                        tag_column_names=(
+                            (schema.tag_column_names or []) + [column_renaming[raw_column_name]]
+                        ),
+                    )
+                elif open_inference_column.category is OpenInferenceCategory.prediction:
+                    if open_inference_column.specifier is OpenInferenceSpecifier.score:
+                        schema = replace(
+                            schema,
+                            prediction_score_column_name=column_renaming[raw_column_name],
+                        )
+                    if open_inference_column.specifier is OpenInferenceSpecifier.label:
+                        schema = replace(
+                            schema,
+                            prediction_label_column_name=column_renaming[raw_column_name],
+                        )
+                elif open_inference_column.category is OpenInferenceCategory.actual:
+                    if open_inference_column.specifier is OpenInferenceSpecifier.score:
+                        schema = replace(
+                            schema,
+                            actual_score_column_name=column_renaming[raw_column_name],
+                        )
+                    if open_inference_column.specifier is OpenInferenceSpecifier.label:
+                        schema = replace(
+                            schema,
+                            actual_label_column_name=column_renaming[raw_column_name],
+                        )
+            else:
+                raise ValueError(f"invalid OpenInference format: duplicated name `{group_name}`")
+
+        return cls(
+            dataframe.rename(
+                column_renaming,
+                axis=1,
+                copy=False,
+            ),
+            schema,
+        )
+
+
+class OpenInferenceCategory(Enum):
+    id = "id"
+    timestamp = "timestamp"
+    feature = "feature"
+    tag = "tag"
+    prediction = "prediction"
+    actual = "actual"
+
+
+class OpenInferenceSpecifier(Enum):
+    default = ""
+    score = "score"
+    label = "label"
+    embedding = "embedding"
+    raw_data = "raw_data"
+    link_to_data = "link_to_data"
+    retrieved_document_ids = "retrieved_document_ids"
+    retrieved_document_scores = "retrieved_document_scores"
+
+
+@dataclass(frozen=True)
+class _OpenInferenceColumnName:
+    full_name: str
+    category: OpenInferenceCategory
+    data_type: str
+    specifier: OpenInferenceSpecifier = OpenInferenceSpecifier.default
+    name: str = ""
+
+
+def _parse_open_inference_column_name(column_name: str) -> _OpenInferenceColumnName:
+    pattern = (
+        r"^:(?P<category>\w+)\.(?P<data_type>\[\w+\]|\w+)(\.(?P<specifier>\w+))?:(?P<name>.*)?$"
+    )
+    if match := re.match(pattern, column_name):
+        extract = match.groupdict(default="")
+        return _OpenInferenceColumnName(
+            full_name=column_name,
+            category=OpenInferenceCategory(extract.get("category", "").lower()),
+            data_type=extract.get("data_type", "").lower(),
+            specifier=OpenInferenceSpecifier(extract.get("specifier", "").lower()),
+            name=extract.get("name", ""),
+        )
+    raise ValueError(f"Invalid format for column name: {column_name}")