arize-phoenix 3.25.0__py3-none-any.whl → 4.0.0__py3-none-any.whl

phoenix/core/traces.py

@@ -1,96 +0,0 @@
-import weakref
-from collections import defaultdict
-from queue import SimpleQueue
-from threading import RLock, Thread
-from types import MethodType
-from typing import DefaultDict, Iterator, Optional, Tuple, Union
-
-from typing_extensions import assert_never
-
-import phoenix.trace.v1 as pb
-from phoenix.config import DEFAULT_PROJECT_NAME
-from phoenix.core.project import (
-    END_OF_QUEUE,
-    Project,
-    _ProjectName,
-)
-from phoenix.trace.schemas import Span
-
-_SpanItem = Tuple[Span, _ProjectName]
-_EvalItem = Tuple[pb.Evaluation, _ProjectName]
-
-
-class Traces:
-    def __init__(self) -> None:
-        self._span_queue: "SimpleQueue[Optional[_SpanItem]]" = SimpleQueue()
-        self._eval_queue: "SimpleQueue[Optional[_EvalItem]]" = SimpleQueue()
-        # Putting `None` as the sentinel value for queue termination.
-        weakref.finalize(self, self._span_queue.put, END_OF_QUEUE)
-        weakref.finalize(self, self._eval_queue.put, END_OF_QUEUE)
-        self._lock = RLock()
-        self._projects: DefaultDict[_ProjectName, "Project"] = defaultdict(
-            Project,
-            {DEFAULT_PROJECT_NAME: Project()},
-        )
-        self._start_consumers()
-
-    def get_project(self, project_name: str) -> Optional["Project"]:
-        with self._lock:
-            return self._projects.get(project_name)
-
-    def get_projects(self) -> Iterator[Tuple[int, str, "Project"]]:
-        with self._lock:
-            for project_id, (project_name, project) in enumerate(self._projects.items()):
-                if project.is_archived:
-                    continue
-                yield project_id, project_name, project
-
-    def archive_project(self, id: int) -> Optional["Project"]:
-        if id == 0:
-            raise ValueError("Cannot archive the default project")
-        with self._lock:
-            for project_id, _, project in self.get_projects():
-                if id == project_id:
-                    project.archive()
-                    return project
-        return None
-
-    def put(
-        self,
-        item: Union[Span, pb.Evaluation],
-        project_name: Optional[str] = None,
-    ) -> None:
-        if not project_name:
-            project_name = DEFAULT_PROJECT_NAME
-        if isinstance(item, Span):
-            self._span_queue.put((item, project_name))
-        elif isinstance(item, pb.Evaluation):
-            self._eval_queue.put((item, project_name))
-        else:
-            assert_never(item)
-
-    def _start_consumers(self) -> None:
-        Thread(
-            target=MethodType(self.__class__._consume_spans, weakref.proxy(self)),
-            args=(self._span_queue,),
-            daemon=True,
-        ).start()
-        Thread(
-            target=MethodType(self.__class__._consume_evals, weakref.proxy(self)),
-            args=(self._eval_queue,),
-            daemon=True,
-        ).start()
-
-    def _consume_spans(self, queue: "SimpleQueue[Optional[_SpanItem]]") -> None:
-        while (item := queue.get()) is not END_OF_QUEUE:
-            span, project_name = item
-            with self._lock:
-                project = self._projects[project_name]
-            project.add_span(span)
-
-    def _consume_evals(self, queue: "SimpleQueue[Optional[_EvalItem]]") -> None:
-        while (item := queue.get()) is not END_OF_QUEUE:
-            pb_eval, project_name = item
-            with self._lock:
-                project = self._projects[project_name]
-            project.add_eval(pb_eval)

phoenix/datasets/dataset.py

@@ -1,214 +0,0 @@
-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}")

phoenix/datasets/fixtures.py

@@ -1,24 +0,0 @@
-from phoenix.inferences.fixtures import (
-    ExampleInferences as _ExampleInferences,
-)
-from phoenix.inferences.fixtures import (
-    load_example as _load_example,
-)
-from phoenix.utilities.deprecation import deprecated, deprecated_class
-
-
-@deprecated_class(
-    (
-        "The phoenix.datasets.fixtures.ExampleDatasets is deprecated, "
-        "use phoenix.inferences.fixtures.ExampleInferences instead."
-    )
-)
-class ExampleDatasets(_ExampleInferences):
-    pass
-
-
-@deprecated(
-    "The phoenix.datasets.fixtures module is deprecated, use phoenix.inferences.fixtures instead."
-)
-def load_example(use_case: str) -> None:
-    _load_example(use_case)

phoenix/datasets/schema.py

@@ -1,31 +0,0 @@
-from phoenix.inferences.schema import (
-    EmbeddingColumnNames as _EmbeddingColumnNames,
-)
-from phoenix.inferences.schema import (
-    RetrievalEmbeddingColumnNames as _RetrievalEmbeddingColumnNames,
-)
-from phoenix.inferences.schema import (
-    Schema as _Schema,
-)
-from phoenix.utilities.deprecation import deprecated_class
-
-
-@deprecated_class(
-    "The phoenix.datasets.fixtures module is deprecated, use phoenix.inferences.fixtures instead."
-)
-class EmbeddingColumnNames(_EmbeddingColumnNames):
-    pass
-
-
-@deprecated_class(
-    "The phoenix.datasets.fixtures module is deprecated, use phoenix.inferences.fixtures instead."
-)
-class RetrievalEmbeddingColumnNames(_RetrievalEmbeddingColumnNames):
-    pass
-
-
-@deprecated_class(
-    "The phoenix.datasets.fixtures module is deprecated, use phoenix.inferences.fixtures instead."
-)
-class Schema(_Schema):
-    pass

phoenix/experimental/evals/__init__.py

@@ -1,73 +0,0 @@
-import logging
-
-from .evaluators import (
-    HallucinationEvaluator,
-    LLMEvaluator,
-    QAEvaluator,
-    RelevanceEvaluator,
-    SummarizationEvaluator,
-    ToxicityEvaluator,
-)
-from .functions import llm_classify, llm_generate, run_evals, run_relevance_eval
-from .models import BedrockModel, LiteLLMModel, OpenAIModel, VertexAIModel
-from .retrievals import compute_precisions_at_k
-from .templates import (
-    CODE_READABILITY_PROMPT_RAILS_MAP,
-    CODE_READABILITY_PROMPT_TEMPLATE,
-    HALLUCINATION_PROMPT_RAILS_MAP,
-    HALLUCINATION_PROMPT_TEMPLATE,
-    HUMAN_VS_AI_PROMPT_RAILS_MAP,
-    HUMAN_VS_AI_PROMPT_TEMPLATE,
-    QA_PROMPT_RAILS_MAP,
-    QA_PROMPT_TEMPLATE,
-    RAG_RELEVANCY_PROMPT_RAILS_MAP,
-    RAG_RELEVANCY_PROMPT_TEMPLATE,
-    TOXICITY_PROMPT_RAILS_MAP,
-    TOXICITY_PROMPT_TEMPLATE,
-    ClassificationTemplate,
-    PromptTemplate,
-)
-from .utils import NOT_PARSABLE, download_benchmark_dataset
-
-logger = logging.getLogger(__name__)
-
-__all__ = [
-    "compute_precisions_at_k",
-    "download_benchmark_dataset",
-    "llm_classify",
-    "llm_generate",
-    "OpenAIModel",
-    "VertexAIModel",
-    "BedrockModel",
-    "LiteLLMModel",
-    "PromptTemplate",
-    "ClassificationTemplate",
-    "CODE_READABILITY_PROMPT_RAILS_MAP",
-    "CODE_READABILITY_PROMPT_TEMPLATE",
-    "HALLUCINATION_PROMPT_RAILS_MAP",
-    "HALLUCINATION_PROMPT_TEMPLATE",
-    "RAG_RELEVANCY_PROMPT_RAILS_MAP",
-    "RAG_RELEVANCY_PROMPT_TEMPLATE",
-    "TOXICITY_PROMPT_RAILS_MAP",
-    "TOXICITY_PROMPT_TEMPLATE",
-    "HUMAN_VS_AI_PROMPT_RAILS_MAP",
-    "HUMAN_VS_AI_PROMPT_TEMPLATE",
-    "QA_PROMPT_RAILS_MAP",
-    "QA_PROMPT_TEMPLATE",
-    "NOT_PARSABLE",
-    "run_relevance_eval",
-    "run_evals",
-    "LLMEvaluator",
-    "HallucinationEvaluator",
-    "QAEvaluator",
-    "RelevanceEvaluator",
-    "SummarizationEvaluator",
-    "ToxicityEvaluator",
-]
-
-
-logger.warning(
-    "Evals are moving out of experimental. "
-    "Install the evals extra with `pip install arize-phoenix[evals]` and import `phoenix.evals`. "
-    "For more info, see the [migration guide](https://github.com/Arize-ai/phoenix/blob/main/MIGRATION.md)."
-)