arize-phoenix 3.20.0__py3-none-any.whl → 3.22.0__py3-none-any.whl

{arize_phoenix-3.20.0.dist-info → arize_phoenix-3.22.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: arize-phoenix
-Version: 3.20.0
+Version: 3.22.0
 Summary: AI Observability and Evaluation
 Project-URL: Documentation, https://docs.arize.com/phoenix/
 Project-URL: Issues, https://github.com/Arize-ai/phoenix/issues
@@ -371,11 +371,11 @@ train_schema = px.Schema(
 prod_schema = replace(train_schema, actual_label_column_name=None)
 
 # Define your production and training datasets.
-prod_ds = px.Dataset(prod_df, prod_schema)
-train_ds = px.Dataset(train_df, train_schema)
+prod_inf = px.Inferences(prod_df, prod_schema)
+train_inf = px.Inferences(train_df, train_schema)
 
 # Launch Phoenix.
-session = px.launch_app(prod_ds, train_ds)
+session = px.launch_app(prod_inf, train_inf)
 
 # View the Phoenix UI in the browser
 session.url
@@ -439,11 +439,11 @@ schema = px.Schema(
 )
 
 # Define your production and training datasets.
-prod_ds = px.Dataset(dataframe=prod_df, schema=schema, name="production")
-train_ds = px.Dataset(dataframe=train_df, schema=schema, name="training")
+prod_inf = px.Inferences(dataframe=prod_df, schema=schema, name="production")
+train_inf = px.Inferences(dataframe=train_df, schema=schema, name="training")
 
 # Launch Phoenix for analysis
-session = px.launch_app(primary=prod_ds, reference=train_ds)
+session = px.launch_app(primary=prod_inf, reference=train_inf)
 ```
 
 ## Deploying Phoenix

{arize_phoenix-3.20.0.dist-info → arize_phoenix-3.22.0.dist-info}/RECORD

@@ -4,7 +4,7 @@ phoenix/datetime_utils.py,sha256=D955QLrkgrrSdUM6NyqbCeAu2SMsjhR5rHVQEsVUdng,277
 phoenix/exceptions.py,sha256=X5k9ipUDfwSCwZB-H5zFJLas86Gf9tAx0W4l5TZxp5k,108
 phoenix/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 phoenix/services.py,sha256=f6AeyKTuOpy9RCcTCjVH3gx5nYZhbTMFOuv1WSUOB5o,4992
-phoenix/version.py,sha256=DNPbd4WuQqCYzqFbwX6xZ3s1zlvJvZpjnQsxReyYsNI,23
+phoenix/version.py,sha256=x3T39dw3H8eGDej-Y0jaguyUerrE7bTqWl_cTqwt5aM,23
 phoenix/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 phoenix/core/embedding_dimension.py,sha256=zKGbcvwOXgLf-yrJBpQyKtd-LEOPRKHnUToyAU8Owis,87
 phoenix/core/model.py,sha256=SBO8BZg_CeQuH5LrSgzlQfqMModzirkQePdhnbLw7dE,4756
@@ -42,7 +42,7 @@ phoenix/experimental/evals/utils/threads.py,sha256=ksI-egarPnlxit0qKKjtjZ2L82qGL
 phoenix/inferences/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 phoenix/inferences/errors.py,sha256=cGp9vxnw4SewFoWBV3ZGMkhE0Kh73lPIv3Ppz_H_RoA,8261
 phoenix/inferences/fixtures.py,sha256=bEfvBixW56jje2Mrt4TH88V3N6K84XJX1HNFBZTh8PQ,20711
-phoenix/inferences/inferences.py,sha256=3NnRhpOHDSsOuL9jtoVojIsZhj4KH7TKCfoQvRdsdbs,21427
+phoenix/inferences/inferences.py,sha256=6vtHq0exSQqy3IVGqvbgOPKfYMbgFgwmNG5YyZDsNuI,30694
 phoenix/inferences/schema.py,sha256=UYej9IJ6pFeNW3fq721kJy16ONso_xVDm78Q68G4hl4,6643
 phoenix/inferences/validation.py,sha256=dZ9lCFUV0EY7HCkQkQBrs-GLAEIZdpOqUxwD5l4dp88,8294
 phoenix/metrics/README.md,sha256=5gekqTU-5gGdMwvcfNp2Wlu8p1ul9kGY_jq0XXQusoI,1964
@@ -60,7 +60,7 @@ phoenix/pointcloud/projectors.py,sha256=zO_RrtDYSv2rqVOfIP2_9Cv11Dc8EmcZR94xhFcB
 phoenix/pointcloud/umap_parameters.py,sha256=lJsEOrbSuSiqI7g4Yt6xj7kgYxEqoep4ZHWLr6VWBqw,1760
 phoenix/server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 phoenix/server/app.py,sha256=eUw5tygCYmsQ5TAJTM_ZwRKkxDD3-bMJSH-H9YpF0eA,7246
-phoenix/server/main.py,sha256=IeokApNdReuozzVSrko82Zs2Mrr_YUGu-eVaMSDQFs4,9746
+phoenix/server/main.py,sha256=Su68-BSyN3wQm8od2TvT6iMOL84IvZdwtDCzsbMBmTk,9752
 phoenix/server/prometheus.py,sha256=YQXwXZt3kxXN5JqGKDMH_jI9r4IL23xn6c8Bdrvg15A,2368
 phoenix/server/thread_server.py,sha256=dP6cm6Cf08jNhDA1TRlVZpziu1YgtPDmaeIJMm725eI,2154
 phoenix/server/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -138,10 +138,10 @@ phoenix/server/static/modernizr.js,sha256=mvK-XtkNqjOral-QvzoqsyOMECXIMu5BQwSVN_
 phoenix/server/templates/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 phoenix/server/templates/index.html,sha256=lO2wGA5XsftPg03rw_VcyaYf_4vegtlWbIT5ms4fA_c,1982
 phoenix/session/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-phoenix/session/client.py,sha256=EMhzmsqquZbuuH0NX137npYLVJWEKI5OieeCBsVGh3A,7933
+phoenix/session/client.py,sha256=cYLRxV6YfCcWgZdJaStACVIhaN9j5p8S72tCKrT0RZ4,9612
 phoenix/session/data_extractor.py,sha256=0Kf-2mKY_YbYoD2fZkAYpKdFgsXrC3OKQ5d2iZsGgAI,1947
 phoenix/session/evaluation.py,sha256=mR5HeBDmoS9oCb-X-2lpLCyMRoOgBufofbsjyEqCpMg,5390
-phoenix/session/session.py,sha256=a16_RnH1xb-KcUZVg4dy4jrX-ip5wMd-r9b5U2drn0g,24952
+phoenix/session/session.py,sha256=P75qklh2HMgCCNiBghN3gjwRJiLIWzg1OshGt-fnzdM,24983
 phoenix/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 phoenix/storage/span_store/__init__.py,sha256=ib-1BWPX4zMfIxS_qC-intyZciGMBJkAOcpb06d3jgQ,586
 phoenix/storage/span_store/text_file.py,sha256=Fzpl_UDVN6_Qa8kpjhDkjdO7xb_I3g-UuTseenkV42c,2853
@@ -178,8 +178,8 @@ phoenix/utilities/error_handling.py,sha256=7b5rpGFj9EWZ8yrZK1IHvxB89suWk3lggDayU
 phoenix/utilities/logging.py,sha256=lDXd6EGaamBNcQxL4vP1au9-i_SXe0OraUDiJOcszSw,222
 phoenix/utilities/project.py,sha256=qWsvKnG1oKhOFUowXf9qiOL2ia7jaFe_ijFFHEt8GJo,431
 phoenix/utilities/span_store.py,sha256=13UK0rE4wQd70yl___WsDRnH0ru-xErng9_Ml7zfEwE,978
-arize_phoenix-3.20.0.dist-info/METADATA,sha256=-NmzwEN-NsVMdo1Y97NBPLBoKAm7CChZWqDrpXHaFh8,29302
-arize_phoenix-3.20.0.dist-info/WHEEL,sha256=as-1oFTWSeWBgyzh0O_qF439xqBe6AbBgt4MfYe5zwY,87
-arize_phoenix-3.20.0.dist-info/licenses/IP_NOTICE,sha256=JBqyyCYYxGDfzQ0TtsQgjts41IJoa-hiwDrBjCb9gHM,469
-arize_phoenix-3.20.0.dist-info/licenses/LICENSE,sha256=HFkW9REuMOkvKRACuwLPT0hRydHb3zNg-fdFt94td18,3794
-arize_phoenix-3.20.0.dist-info/RECORD,,
+arize_phoenix-3.22.0.dist-info/METADATA,sha256=6Oog16HhrzCNfA5cS3JhS1OceuPvqiHL76Vzgz6hblE,29322
+arize_phoenix-3.22.0.dist-info/WHEEL,sha256=K0BPUNF1N3kQ9olb8aVEtkObePEjdr2JOLT1N83EVws,87
+arize_phoenix-3.22.0.dist-info/licenses/IP_NOTICE,sha256=JBqyyCYYxGDfzQ0TtsQgjts41IJoa-hiwDrBjCb9gHM,469
+arize_phoenix-3.22.0.dist-info/licenses/LICENSE,sha256=HFkW9REuMOkvKRACuwLPT0hRydHb3zNg-fdFt94td18,3794
+arize_phoenix-3.22.0.dist-info/RECORD,,

{arize_phoenix-3.20.0.dist-info → arize_phoenix-3.22.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.22.5
+Generator: hatchling 1.24.0
 Root-Is-Purelib: true
 Tag: py3-none-any

phoenix/inferences/inferences.py

@@ -1,7 +1,10 @@
 import logging
+import re
 import uuid
 from copy import deepcopy
-from dataclasses import fields, replace
+from dataclasses import dataclass, fields, replace
+from enum import Enum
+from itertools import groupby
 from typing import Any, Dict, List, Optional, Set, Tuple, Union
 
 import numpy as np
@@ -14,6 +17,7 @@ from typing_extensions import TypeAlias
 
 from phoenix.config import DATASET_DIR, GENERATED_DATASET_NAME_PREFIX
 from phoenix.datetime_utils import normalize_timestamps
+from phoenix.utilities.deprecation import deprecated
 
 from . import errors as err
 from .schema import (
@@ -22,6 +26,7 @@ from .schema import (
     SINGLE_COLUMN_SCHEMA_FIELD_NAMES,
     EmbeddingColumnNames,
     EmbeddingFeatures,
+    RetrievalEmbeddingColumnNames,
     Schema,
     SchemaFieldName,
     SchemaFieldValue,
@@ -133,6 +138,206 @@ class Inferences:
         with open(directory / self._schema_file_name, "w+") as schema_file:
             schema_file.write(schema_json_data)
 
+    @classmethod
+    @deprecated("Inferences.from_open_inference is deprecated and will be removed.")
+    def from_open_inference(cls, dataframe: DataFrame) -> "Inferences":
+        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}")
+
 
 def _parse_dataframe_and_schema(dataframe: DataFrame, schema: Schema) -> Tuple[DataFrame, Schema]:
     """
@@ -522,4 +727,4 @@ def _add_prediction_id(num_rows: int) -> List[str]:
 
 
 # A dataset with no data. Useful for stubs
-EMPTY_DATASET = Inferences(pd.DataFrame(), schema=Schema())
+EMPTY_INFERENCES = Inferences(pd.DataFrame(), schema=Schema())

phoenix/server/main.py

@@ -20,7 +20,7 @@ from phoenix.config import (
 from phoenix.core.model_schema_adapter import create_model_from_datasets
 from phoenix.core.traces import Traces
 from phoenix.inferences.fixtures import FIXTURES, get_datasets
-from phoenix.inferences.inferences import EMPTY_DATASET, Inferences
+from phoenix.inferences.inferences import EMPTY_INFERENCES, Inferences
 from phoenix.pointcloud.umap_parameters import (
     DEFAULT_MIN_DIST,
     DEFAULT_N_NEIGHBORS,
@@ -114,7 +114,7 @@ if __name__ == "__main__":
     trace_dataset_name: Optional[str] = None
     simulate_streaming: Optional[bool] = None
 
-    primary_dataset: Inferences = EMPTY_DATASET
+    primary_dataset: Inferences = EMPTY_INFERENCES
     reference_dataset: Optional[Inferences] = None
     corpus_dataset: Optional[Inferences] = None
 

phoenix/session/client.py

@@ -1,3 +1,4 @@
+import gzip
 import logging
 import weakref
 from datetime import datetime
@@ -7,6 +8,10 @@ from urllib.parse import urljoin
 
 import pandas as pd
 import pyarrow as pa
+from opentelemetry.proto.collector.trace.v1.trace_service_pb2 import ExportTraceServiceRequest
+from opentelemetry.proto.common.v1.common_pb2 import AnyValue, KeyValue
+from opentelemetry.proto.resource.v1.resource_pb2 import Resource
+from opentelemetry.proto.trace.v1.trace_pb2 import ResourceSpans, ScopeSpans
 from pyarrow import ArrowInvalid
 from requests import Session
 
@@ -18,8 +23,9 @@ from phoenix.config import (
     get_env_project_name,
 )
 from phoenix.session.data_extractor import TraceDataExtractor
-from phoenix.trace import Evaluations
+from phoenix.trace import Evaluations, TraceDataset
 from phoenix.trace.dsl import SpanQuery
+from phoenix.trace.otel import encode
 
 logger = logging.getLogger(__name__)
 
@@ -193,6 +199,39 @@ class Client(TraceDataExtractor):
                 headers=headers,
             ).raise_for_status()
 
+    def log_traces(self, trace_dataset: TraceDataset, project_name: Optional[str] = None) -> None:
+        project_name = project_name or get_env_project_name()
+        spans = trace_dataset.to_spans()
+        otlp_spans = [
+            ExportTraceServiceRequest(
+                resource_spans=[
+                    ResourceSpans(
+                        resource=Resource(
+                            attributes=[
+                                KeyValue(
+                                    key="openinference.project.name",
+                                    value=AnyValue(string_value=project_name),
+                                )
+                            ]
+                        ),
+                        scope_spans=[ScopeSpans(spans=[encode(span)])],
+                    )
+                ],
+            )
+            for span in spans
+        ]
+        for otlp_span in otlp_spans:
+            serialized = otlp_span.SerializeToString()
+            data = gzip.compress(serialized)
+            self._session.post(
+                urljoin(self._base_url, "/v1/traces"),
+                data=data,
+                headers={
+                    "content-type": "application/x-protobuf",
+                    "content-encoding": "gzip",
+                },
+            ).raise_for_status()
+
 
 def _to_iso_format(value: Optional[datetime]) -> Optional[str]:
     return value.isoformat() if value else None

phoenix/session/session.py

@@ -36,7 +36,7 @@ from phoenix.config import (
 )
 from phoenix.core.model_schema_adapter import create_model_from_datasets
 from phoenix.core.traces import Traces
-from phoenix.inferences.inferences import EMPTY_DATASET, Inferences
+from phoenix.inferences.inferences import EMPTY_INFERENCES, Inferences
 from phoenix.pointcloud.umap_parameters import get_umap_parameters
 from phoenix.server.app import create_app
 from phoenix.server.thread_server import ThreadServer
@@ -473,17 +473,17 @@ def launch_app(
     Examples
     --------
     >>> import phoenix as px
-    >>> # construct a dataset to analyze
-    >>> dataset = px.Dataset(...)
-    >>> session = px.launch_app(dataset)
+    >>> # construct an inference set to analyze
+    >>> inferences = px.Inferences(...)
+    >>> session = px.launch_app(inferences)
     """
     global _session
 
-    # Stopgap solution to allow the app to run without a primary dataset
+    # Stopgap solution to allow the app to run without a primary inferences
     if primary is None:
-        # Dummy dataset
-        # TODO: pass through the lack of a primary dataset to the app
-        primary = EMPTY_DATASET
+        # Dummy inferences
+        # TODO: pass through the lack of a primary inferences to the app
+        primary = EMPTY_INFERENCES
 
     if _session is not None and _session.active:
         logger.warning(

phoenix/version.py

@@ -1 +1 @@
-__version__ = "3.20.0"
+__version__ = "3.22.0"