arize-phoenix 3.10.0__tar.gz → 3.11.1__tar.gz

{arize_phoenix-3.10.0 → arize_phoenix-3.11.1}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: arize-phoenix
-Version: 3.10.0
-Summary: ML Observability in your notebook
+Version: 3.11.1
+Summary: AI Observability and Evaluation
 Project-URL: Documentation, https://docs.arize.com/phoenix/
 Project-URL: Issues, https://github.com/Arize-ai/phoenix/issues
 Project-URL: Source, https://github.com/Arize-ai/phoenix

{arize_phoenix-3.10.0 → arize_phoenix-3.11.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "arize-phoenix"
-description = "ML Observability in your notebook"
+description = "AI Observability and Evaluation"
 readme = "README.md"
 requires-python = ">=3.8, <3.12"
 license = "Elastic-2.0"

arize_phoenix-3.11.1/src/phoenix/core/traces.py

@@ -0,0 +1,84 @@
+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.core.project import (
+    DEFAULT_PROJECT_NAME,
+    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[str, "Project"]]:
+        with self._lock:
+            projects = tuple(self._projects.items())
+        yield from projects
+
+    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)

{arize_phoenix-3.10.0 → arize_phoenix-3.11.1}/src/phoenix/server/api/types/Project.py

@@ -112,7 +112,7 @@ class Project(Node):
             spans = filter(predicate, spans)
         if sort:
             spans = sort(spans, evals=project)
-        data = list(map(to_gql_span, spans))
+        data = [to_gql_span(span, project) for span in spans]
         return connection_from_list(data=data, args=args)
 
     @strawberry.field(

{arize_phoenix-3.10.0 → arize_phoenix-3.11.1}/src/phoenix/server/api/types/Span.py

@@ -10,7 +10,7 @@ from strawberry import ID, UNSET
 from strawberry.types import Info
 
 import phoenix.trace.schemas as trace_schema
-from phoenix.core.project import DEFAULT_PROJECT_NAME, WrappedSpan
+from phoenix.core.project import DEFAULT_PROJECT_NAME, Project, WrappedSpan
 from phoenix.metrics.retrieval_metrics import RetrievalMetrics
 from phoenix.server.api.context import Context
 from phoenix.server.api.types.DocumentRetrievalMetrics import DocumentRetrievalMetrics
@@ -95,6 +95,7 @@ class SpanEvent:
 
 @strawberry.type
 class Span:
+    project: strawberry.Private[Project]
     name: str
     status_code: SpanStatusCode
     status_message: str
@@ -185,14 +186,10 @@ class Span:
         info: Info[Context, None],
         evaluation_name: Optional[str] = UNSET,
     ) -> List[DocumentRetrievalMetrics]:
-        if (
-            not self.num_documents
-            or not (traces := info.context.traces)
-            or not (project := traces.get_project(DEFAULT_PROJECT_NAME))
-        ):
+        if not self.num_documents:
             return []
         span_id = SpanID(str(self.context.span_id))
-        all_document_evaluation_names = project.get_document_evaluation_names(span_id)
+        all_document_evaluation_names = self.project.get_document_evaluation_names(span_id)
         if not all_document_evaluation_names:
             return []
         if evaluation_name is UNSET:
@@ -203,7 +200,7 @@ class Span:
             evaluation_names = [evaluation_name]
         retrieval_metrics = []
         for name in evaluation_names:
-            evaluation_scores = project.get_document_evaluation_scores(
+            evaluation_scores = self.project.get_document_evaluation_scores(
                 span_id=span_id,
                 evaluation_name=name,
                 num_documents=self.num_documents,
@@ -223,20 +220,20 @@ class Span:
         self,
         info: Info[Context, None],
     ) -> List["Span"]:
-        if (traces := info.context.traces) is None:
-            return []
         return [
-            to_gql_span(span) for span in traces.get_descendant_spans(SpanID(self.context.span_id))
+            to_gql_span(span, self.project)
+            for span in self.project.get_descendant_spans(SpanID(self.context.span_id))
         ]
 
 
-def to_gql_span(span: WrappedSpan) -> "Span":
+def to_gql_span(span: WrappedSpan, project: Project) -> "Span":
     events: List[SpanEvent] = list(map(SpanEvent.from_event, span.events))
     input_value = cast(Optional[str], span.attributes.get(INPUT_VALUE))
     output_value = cast(Optional[str], span.attributes.get(OUTPUT_VALUE))
     retrieval_documents = span.attributes.get(RETRIEVAL_DOCUMENTS)
     num_documents = len(retrieval_documents) if isinstance(retrieval_documents, Sized) else None
     return Span(
+        project=project,
         name=span.name,
         status_code=SpanStatusCode(span.status_code),
         status_message=span.status_message,