arize-phoenix 2.0.0__py3-none-any.whl → 2.2.0rc0__py3-none-any.whl

phoenix/experimental/evals/utils/__init__.py

@@ -1,6 +1,6 @@
 import json
 from io import BytesIO
-from typing import List, Optional, Tuple
+from typing import Any, Dict, List, Optional, Tuple
 from urllib.error import HTTPError
 from urllib.request import urlopen
 from zipfile import ZipFile
@@ -14,10 +14,11 @@ from phoenix.utilities.logging import printif
 # This is useful for debugging as well as to just treat the output as a non-parsable category
 NOT_PARSABLE = "NOT_PARSABLE"
 
-# argument keys in the default openai function call,
+# values in the default openai function call,
 # defined here only to prevent typos
 _RESPONSE = "response"
 _EXPLANATION = "explanation"
+_FUNCTION_NAME = "record_response"
 
 
 def download_benchmark_dataset(task: str, dataset_name: str) -> pd.DataFrame:
@@ -108,3 +109,64 @@ def parse_openai_function_call(raw_output: str) -> Tuple[str, Optional[str]]:
         unrailed_label = raw_output
         explanation = None
     return unrailed_label, explanation
+
+
+def openai_function_call_kwargs(rails: List[str], provide_explanation: bool) -> Dict[str, Any]:
+    """
+    Returns keyword arguments needed to invoke an OpenAI model with function
+    calling for classification.
+
+    Args:
+        rails (List[str]): The rails to snap the output to.
+
+        provide_explanation (bool): Whether to provide an explanation.
+
+    Returns:
+        Dict[str, Any]: A dictionary containing function call arguments.
+    """
+    openai_function = _default_openai_function(rails, provide_explanation)
+    return {
+        "functions": [openai_function],
+        "function_call": {"name": openai_function["name"]},
+    }
+
+
+def _default_openai_function(
+    rails: List[str],
+    with_explanation: bool = False,
+) -> Dict[str, Any]:
+    """
+    Returns a default OpenAI function call for classification.
+
+    Args:
+        rails (List[str]): A list of rails to snap the output to.
+
+        with_explanation (bool, optional): Whether to include an explanation.
+
+    Returns:
+        Dict[str, Any]: A JSON schema object advertising a function to record
+        the result of the LLM's classification.
+    """
+    properties = {
+        **(
+            {
+                _EXPLANATION: {
+                    "type": "string",
+                    "description": "Explanation of the reasoning for your response.",
+                },
+            }
+            if with_explanation
+            else {}
+        ),
+        _RESPONSE: {"type": "string", "description": "Your response.", "enum": rails},
+    }
+    required = [*([_EXPLANATION] if with_explanation else []), _RESPONSE]
+    return {
+        "name": _FUNCTION_NAME,
+        "description": "A function to record your response.",
+        "parameters": {
+            "type": "object",
+            "properties": properties,
+            "required": required,
+        },
+    }

phoenix/server/api/schema.py

@@ -202,6 +202,30 @@ class Query:
             clustered_events=clustered_events,
         )
 
+    @strawberry.field
+    def streaming_last_updated_at(
+        self,
+        info: Info[Context, None],
+    ) -> Optional[datetime]:
+        last_updated_at: Optional[datetime] = None
+        if (traces := info.context.traces) is not None and (
+            traces_last_updated_at := traces.last_updated_at
+        ) is not None:
+            last_updated_at = (
+                traces_last_updated_at
+                if last_updated_at is None
+                else max(last_updated_at, traces_last_updated_at)
+            )
+        if (evals := info.context.evals) is not None and (
+            evals_last_updated_at := evals.last_updated_at
+        ) is not None:
+            last_updated_at = (
+                evals_last_updated_at
+                if last_updated_at is None
+                else max(last_updated_at, evals_last_updated_at)
+            )
+        return last_updated_at
+
     @strawberry.field
     def spans(
         self,

phoenix/server/app.py

@@ -28,6 +28,7 @@ from phoenix.server.api.context import Context
 from phoenix.server.api.schema import schema
 from phoenix.server.evaluation_handler import EvaluationHandler
 from phoenix.server.span_handler import SpanHandler
+from phoenix.server.trace_handler import TraceHandler
 
 logger = logging.getLogger(__name__)
 
@@ -185,11 +186,11 @@ def create_app(
             else [
                 Route(
                     "/v1/spans",
-                    type(
-                        "SpanEndpoint",
-                        (SpanHandler,),
-                        {"queue": traces},
-                    ),
+                    type("SpanEndpoint", (SpanHandler,), {"queue": traces}),
+                ),
+                Route(
+                    "/v1/traces",
+                    type("TraceEndpoint", (TraceHandler,), {"queue": traces}),
                 ),
             ]
         )

phoenix/server/main.py

@@ -29,6 +29,7 @@ from phoenix.trace.fixtures import (
     _get_trace_fixture_by_name,
     get_evals_from_fixture,
 )
+from phoenix.trace.otel import encode
 from phoenix.trace.span_json_decoder import json_string_to_span
 
 logger = logging.getLogger(__name__)
@@ -148,13 +149,11 @@ if __name__ == "__main__":
     traces = Traces()
     evals = Evals()
     if trace_dataset_name is not None:
-        fixture_spans = map(
-            json_string_to_span,
-            _download_traces_fixture(
-                _get_trace_fixture_by_name(
-                    trace_dataset_name,
-                ),
-            ),
+        fixture_spans = (
+            encode(json_string_to_span(json_span))
+            for json_span in _download_traces_fixture(
+                _get_trace_fixture_by_name(trace_dataset_name)
+            )
         )
         Thread(
             target=_load_items,

phoenix/server/span_handler.py

@@ -1,18 +1,18 @@
 import gzip
 from typing import Protocol
 
+import opentelemetry.proto.trace.v1.trace_pb2 as otlp
 from starlette.endpoints import HTTPEndpoint
 from starlette.requests import Request
 from starlette.responses import Response
 
-import phoenix.trace.v1 as pb
+from phoenix.trace.otel import encode
 from phoenix.trace.schemas import Span
 from phoenix.trace.span_json_decoder import json_to_span
-from phoenix.trace.v1.utils import encode
 
 
 class SupportsPutSpan(Protocol):
-    def put(self, span: pb.Span) -> None:
+    def put(self, span: otlp.Span) -> None:
         ...
 
 
@@ -27,13 +27,13 @@ class SpanHandler(HTTPEndpoint):
                 content_encoding = request.headers.get("content-encoding")
                 if content_encoding == "gzip":
                     body = gzip.decompress(body)
-                pb_span = pb.Span()
-                pb_span.ParseFromString(body)
+                otlp_span = otlp.Span()
+                otlp_span.ParseFromString(body)
             else:
                 span = json_to_span(await request.json())
                 assert isinstance(span, Span)
-                pb_span = encode(span)
+                otlp_span = encode(span)
         except Exception:
             return Response(status_code=422)
-        self.queue.put(pb_span)
+        self.queue.put(otlp_span)
         return Response()