arize-phoenix 4.12.1rc1__py3-none-any.whl → 4.14.1__py3-none-any.whl

phoenix/trace/dsl/filter.py

@@ -5,8 +5,8 @@ import typing
 from dataclasses import dataclass, field
 from difflib import SequenceMatcher
 from itertools import chain
-from random import randint
 from types import MappingProxyType
+from uuid import uuid4
 
 import sqlalchemy
 from sqlalchemy.orm import Mapped, aliased
@@ -22,11 +22,14 @@ _VALID_EVAL_ATTRIBUTES: typing.Tuple[str, ...] = tuple(
 )
 
 
-EvalAttribute: TypeAlias = typing.Literal["label", "score"]
-EvalExpression: TypeAlias = str
-EvalName: TypeAlias = str
+AnnotationType: TypeAlias = typing.Literal["annotations", "evals"]
+AnnotationAttribute: TypeAlias = typing.Literal["label", "score"]
+AnnotationExpression: TypeAlias = str
+AnnotationName: TypeAlias = str
 
-EVAL_EXPRESSION_PATTERN = re.compile(r"""\b(evals\[(".*?"|'.*?')\][.](label|score))\b""")
+EVAL_EXPRESSION_PATTERN = re.compile(
+    r"""\b((annotations|evals)\[(".*?"|'.*?')\][.](label|score))\b"""
+)
 
 
 @dataclass(frozen=True)
@@ -46,9 +49,10 @@ class AliasedAnnotationRelation:
 
     def __post_init__(self) -> None:
         table_alias = f"span_annotation_{self.index}"
-        alias_id = f"{randint(0, 10**6):06d}"  # prevent conflicts with user-defined attributes
+        alias_id = uuid4().hex
         label_attribute_alias = f"{table_alias}_label_{alias_id}"
         score_attribute_alias = f"{table_alias}_score_{alias_id}"
+
         table = aliased(models.SpanAnnotation, name=table_alias)
         object.__setattr__(self, "_label_attribute_alias", label_attribute_alias)
         object.__setattr__(self, "_score_attribute_alias", score_attribute_alias)
@@ -67,7 +71,7 @@ class AliasedAnnotationRelation:
         yield self._label_attribute_alias, self.table.label
         yield self._score_attribute_alias, self.table.score
 
-    def attribute_alias(self, attribute: EvalAttribute) -> str:
+    def attribute_alias(self, attribute: AnnotationAttribute) -> str:
         """
         Returns an alias for the given attribute (i.e., column).
         """
@@ -579,7 +583,7 @@ def _validate_expression(
             _is_subscript(node, "metadata") or _is_subscript(node, "attributes")
         ) and _get_attribute_keys_list(node) is not None:
             continue
-        elif _is_eval(node) and _get_subscript_key(node) is not None:
+        elif _is_annotation(node) and _get_subscript_key(node) is not None:
             # e.g. `evals["name"]`
             if not (eval_name := _get_subscript_key(node)) or (
                 valid_eval_names is not None and eval_name not in valid_eval_names
@@ -601,7 +605,7 @@ def _validate_expression(
                     else ""
                 )
             continue
-        elif isinstance(node, ast.Attribute) and _is_eval(node.value):
+        elif isinstance(node, ast.Attribute) and _is_annotation(node.value):
             # e.g. `evals["name"].score`
             if (attr := node.attr) not in valid_eval_attributes:
                 source_segment = typing.cast(str, ast.get_source_segment(source, node))
@@ -662,19 +666,19 @@ def _as_attribute(
 ) -> ast.Subscript:
     return ast.Subscript(
         value=ast.Name(id="attributes", ctx=ast.Load()),
-        slice=ast.List(elts=keys, ctx=ast.Load())
+        slice=ast.List(elts=keys, ctx=ast.Load())  # type: ignore[arg-type]
         if sys.version_info >= (3, 9)
-        else ast.Index(value=ast.List(elts=keys, ctx=ast.Load())),
+        else ast.Index(value=ast.List(elts=keys, ctx=ast.Load())),  # type: ignore
         ctx=ast.Load(),
     )
 
 
-def _is_eval(node: typing.Any) -> TypeGuard[ast.Subscript]:
+def _is_annotation(node: typing.Any) -> TypeGuard[ast.Subscript]:
     # e.g. `evals["name"]`
     return (
         isinstance(node, ast.Subscript)
         and isinstance(value := node.value, ast.Name)
-        and value.id == "evals"
+        and value.id in ["evals", "annotations"]
     )
 
 
@@ -817,34 +821,45 @@ def _apply_eval_aliasing(
     span_annotation_0_label_123 == 'correct' or span_annotation_0_score_456 < 0.5
     ```
     """
-    eval_aliases: typing.Dict[EvalName, AliasedAnnotationRelation] = {}
-    for eval_expression, eval_name, eval_attribute in _parse_eval_expressions_and_names(source):
-        if (eval_alias := eval_aliases.get(eval_name)) is None:
-            eval_alias = AliasedAnnotationRelation(index=len(eval_aliases), name=eval_name)
-            eval_aliases[eval_name] = eval_alias
-        alias_name = eval_alias.attribute_alias(eval_attribute)
-        source = source.replace(eval_expression, alias_name)
+    eval_aliases: typing.Dict[AnnotationName, AliasedAnnotationRelation] = {}
+    for (
+        annotation_expression,
+        annotation_type,
+        annotation_name,
+        annotation_attribute,
+    ) in _parse_annotation_expressions_and_names(source):
+        if (eval_alias := eval_aliases.get(annotation_name)) is None:
+            eval_alias = AliasedAnnotationRelation(index=len(eval_aliases), name=annotation_name)
+            eval_aliases[annotation_name] = eval_alias
+        alias_name = eval_alias.attribute_alias(annotation_attribute)
+        source = source.replace(annotation_expression, alias_name)
     return source, tuple(eval_aliases.values())
 
 
-def _parse_eval_expressions_and_names(
+def _parse_annotation_expressions_and_names(
     source: str,
-) -> typing.Iterator[typing.Tuple[EvalExpression, EvalName, EvalAttribute]]:
+) -> typing.Iterator[
+    typing.Tuple[AnnotationExpression, AnnotationType, AnnotationName, AnnotationAttribute]
+]:
     """
     Parses filter conditions for evaluation expressions of the form:
 
     ```
     evals["<eval-name>"].<attribute>
+    annotations["eval-name"].<attribute>
     ```
     """
     for match in EVAL_EXPRESSION_PATTERN.finditer(source):
         (
-            eval_expression,
+            annotation_expression,
+            annotation_type,
             quoted_eval_name,
             evaluation_attribute_name,
         ) = match.groups()
+        annotation_type = typing.cast(AnnotationType, annotation_type)
         yield (
-            eval_expression,
+            annotation_expression,
+            annotation_type,
             quoted_eval_name[1:-1],
-            typing.cast(EvalAttribute, evaluation_attribute_name),
+            typing.cast(AnnotationAttribute, evaluation_attribute_name),
         )

phoenix/version.py

@@ -1 +1 @@
-__version__ = "4.12.1rc1"
+__version__ = "4.14.1"

phoenix/server/api/routers/v1/pydantic_compat.py

@@ -1,78 +0,0 @@
-from datetime import datetime
-from enum import Enum
-from importlib.metadata import PackageNotFoundError, version
-
-from pydantic import BaseModel
-from typing_extensions import assert_never
-
-
-def datetime_encoder(dt: datetime) -> str:
-    """
-    Encodes a `datetime` object to an ISO-formatted timestamp string.
-
-    By default, Pydantic v2 serializes `datetime` objects in a format that
-    cannot be parsed by `datetime.fromisoformat`. Adding this encoder to the
-    `json_encoders` config for a Pydantic model ensures that the serialized
-    `datetime` objects are parseable.
-    """
-    return dt.isoformat()
-
-
-class PydanticMajorVersion(Enum):
-    """
-    The major version of `pydantic`.
-    """
-
-    V1 = "v1"
-    V2 = "v2"
-
-
-def get_pydantic_major_version() -> PydanticMajorVersion:
-    """
-    Returns the major version of `pydantic` or raises an error if `pydantic` is
-    not installed.
-    """
-    try:
-        pydantic_version = version("pydantic")
-    except PackageNotFoundError:
-        raise RuntimeError("Please install pydantic with `pip install pydantic`.")
-    if pydantic_version.startswith("1"):
-        return PydanticMajorVersion.V1
-    elif pydantic_version.startswith("2"):
-        return PydanticMajorVersion.V2
-    raise ValueError(f"Unsupported Pydantic version: {pydantic_version}")
-
-
-if (pydantic_major_version := get_pydantic_major_version()) is PydanticMajorVersion.V1:
-
-    class V1RoutesBaseModel(BaseModel):
-        class Config:
-            json_encoders = {datetime: datetime_encoder}
-
-elif pydantic_major_version is PydanticMajorVersion.V2:
-    from pydantic import ConfigDict
-
-    # `json_encoders` is a configuration setting from Pydantic v1 that was
-    # removed in Pydantic v2.0.* but restored in Pydantic v2.1.0 with a
-    # deprecation warning. At this time, it remains the simplest way to
-    # configure custom JSON serialization for specific data types in a manner
-    # that is consistent between Pydantic v1 and v2.
-    #
-    # For details, see:
-    # - https://github.com/pydantic/pydantic/pull/6811
-    # - https://github.com/pydantic/pydantic/releases/tag/v2.1.0
-    #
-    # The assertion below is added in case a future release of Pydantic v2 fully
-    # removes the `json_encoders` parameter.
-    assert "json_encoders" in ConfigDict.__annotations__, (
-        "If you encounter this error with `pydantic==2.0.*`, "
-        "please upgrade `pydantic` with `pip install -U pydantic>=2.1.0`. "
-        "If you encounter this error with `pydantic>=2.1.0`, "
-        "please upgrade `arize-phoenix` with `pip install -U arize-phoenix`, "
-        "or downgrade `pydantic` to a version that supports the `json_encoders` config setting."
-    )
-
-    class V1RoutesBaseModel(BaseModel):  # type: ignore[no-redef]
-        model_config = ConfigDict({"json_encoders": {datetime: datetime_encoder}})
-else:
-    assert_never(pydantic_major_version)

phoenix/server/api/routers/v1/utils.py

@@ -1,95 +0,0 @@
-from typing import Any, Dict, Generic, List, Optional, TypedDict, Union
-
-from typing_extensions import TypeAlias, TypeVar, assert_never
-
-from .pydantic_compat import V1RoutesBaseModel
-
-StatusCode: TypeAlias = int
-DataType = TypeVar("DataType")
-Responses: TypeAlias = Dict[
-    Union[int, str], Dict[str, Any]
-]  # input type for the `responses` parameter of a fastapi route
-
-
-class StatusCodeWithDescription(TypedDict):
-    """
-    A duck type for a status code with a description detailing under what
-    conditions the status code is raised.
-    """
-
-    status_code: StatusCode
-    description: str
-
-
-class RequestBody(V1RoutesBaseModel, Generic[DataType]):
-    # A generic request type accepted by V1 routes.
-    #
-    # Don't use """ for this docstring or it will be included as a description
-    # in the generated OpenAPI schema.
-    data: DataType
-
-
-class ResponseBody(V1RoutesBaseModel, Generic[DataType]):
-    # A generic response type returned by V1 routes.
-    #
-    # Don't use """ for this docstring or it will be included as a description
-    # in the generated OpenAPI schema.
-
-    data: DataType
-
-
-class PaginatedResponseBody(V1RoutesBaseModel, Generic[DataType]):
-    # A generic paginated response type returned by V1 routes.
-    #
-    # Don't use """ for this docstring or it will be included as a description
-    # in the generated OpenAPI schema.
-
-    data: List[DataType]
-    next_cursor: Optional[str]
-
-
-def add_errors_to_responses(
-    errors: List[Union[StatusCode, StatusCodeWithDescription]],
-    /,
-    *,
-    responses: Optional[Responses] = None,
-) -> Responses:
-    """
-    Creates or updates a patch for an OpenAPI schema's `responses` section to
-    include status codes in the generated OpenAPI schema.
-    """
-    output_responses: Responses = responses or {}
-    for error in errors:
-        status_code: int
-        description: Optional[str] = None
-        if isinstance(error, StatusCode):
-            status_code = error
-        elif isinstance(error, dict):
-            status_code = error["status_code"]
-            description = error["description"]
-        else:
-            assert_never(error)
-        if status_code not in output_responses:
-            output_responses[status_code] = {
-                "content": {"text/plain": {"schema": {"type": "string"}}}
-            }
-        if description:
-            output_responses[status_code]["description"] = description
-    return output_responses
-
-
-def add_text_csv_content_to_responses(
-    status_code: StatusCode, /, *, responses: Optional[Responses] = None
-) -> Responses:
-    """
-    Creates or updates a patch for an OpenAPI schema's `responses` section to
-    ensure that the response for the given status code is marked as text/csv in
-    the generated OpenAPI schema.
-    """
-    output_responses: Responses = responses or {}
-    if status_code not in output_responses:
-        output_responses[status_code] = {}
-    output_responses[status_code]["content"] = {
-        "text/csv": {"schema": {"type": "string", "contentMediaType": "text/csv"}}
-    }
-    return output_responses

phoenix/server/static/assets/index-BEKPzgQs.js

@@ -1,100 +0,0 @@
-import{r as d,j as e,d2 as F,v as s,F as P,R as v,w as E,aN as L,d3 as R,d4 as S,d5 as a,d6 as w,d7 as z,b as A,d8 as j}from"./vendor-CUDAPm8e.js";import{Q as C,j as k,Y as _,S as $,t as I,a4 as O}from"./vendor-arizeai-Do2HOmcL.js";import{aY as D,d as T,R as N,aZ as G,a_ as M}from"./components-C8sm_r1F.js";import{L as B,E as U,h as Y,M as q,a as m,D as J,d as K,b as W,e as H,P as Q,c as V,f as Z,p as X,g as u,i as ee,j as re,k as g,l as ae,m as h,n as f,o as oe,q as te,r as ne,s as se,t as le,A as ie}from"./pages-bN7juCjh.js";import"./vendor-three-DwGkEfCM.js";import"./vendor-codemirror-CrdxOlMs.js";import"./vendor-recharts-PKRvByVe.js";(function(){const n=document.createElement("link").relList;if(n&&n.supports&&n.supports("modulepreload"))return;for(const o of document.querySelectorAll('link[rel="modulepreload"]'))c(o);new MutationObserver(o=>{for(const t of o)if(t.type==="childList")for(const l of t.addedNodes)l.tagName==="LINK"&&l.rel==="modulepreload"&&c(l)}).observe(document,{childList:!0,subtree:!0});function i(o){const t={};return o.integrity&&(t.integrity=o.integrity),o.referrerPolicy&&(t.referrerPolicy=o.referrerPolicy),o.crossOrigin==="use-credentials"?t.credentials="include":o.crossOrigin==="anonymous"?t.credentials="omit":t.credentials="same-origin",t}function c(o){if(o.ep)return;o.ep=!0;const t=i(o);fetch(o.href,t)}})();const x="arize-phoenix-feature-flags",p={__CLEAR__:!1};function ce(){const r=localStorage.getItem(x);if(!r)return p;try{const n=JSON.parse(r);return Object.assign({},p,n)}catch{return p}}const b=d.createContext(null);function de(){const r=v.useContext(b);if(r===null)throw new Error("useFeatureFlags must be used within a FeatureFlagsProvider");return r}function pe(r){const[n,i]=d.useState(ce()),c=o=>{localStorage.setItem(x,JSON.stringify(o)),i(o)};return e(b.Provider,{value:{featureFlags:n,setFeatureFlags:c},children:e(me,{children:r.children})})}function me(r){const{children:n}=r,{featureFlags:i,setFeatureFlags:c}=de(),[o,t]=d.useState(!1);return F("ctrl+shift+f",()=>t(!0)),s(P,{children:[n,e($,{type:"modal",isDismissable:!0,onDismiss:()=>t(!1),children:o&&e(C,{title:"Feature Flags",children:e(k,{height:"size-1000",padding:"size-100",children:Object.keys(i).map(l=>e(_,{isSelected:i[l],onChange:y=>c({...i,[l]:y}),children:l},l))})})})]})}function ue(){return e(L,{styles:r=>E`
-        body {
-          background-color: var(--ac-global-color-grey-75);
-          color: var(--ac-global-text-color-900);
-          font-family: "Roboto";
-          font-size: ${r.typography.sizes.medium.fontSize}px;
-          margin: 0;
-          #root,
-          #root > div[data-overlay-container="true"],
-          #root > div[data-overlay-container="true"] > .ac-theme {
-            height: 100vh;
-          }
-        }
-
-        /* Remove list styling */
-        ul {
-          display: block;
-          list-style-type: none;
-          margin-block-start: none;
-          margin-block-end: 0;
-          padding-inline-start: 0;
-          margin-block-start: 0;
-        }
-
-        /* A reset style for buttons */
-        .button--reset {
-          background: none;
-          border: none;
-          padding: 0;
-        }
-        /* this css class is added to html via modernizr @see modernizr.js */
-        .no-hiddenscroll {
-          /* Works on Firefox */
-          * {
-            scrollbar-width: thin;
-            scrollbar-color: var(--ac-global-color-grey-300)
-              var(--ac-global-color-grey-400);
-          }
-
-          /* Works on Chrome, Edge, and Safari */
-          *::-webkit-scrollbar {
-            width: 14px;
-          }
-
-          *::-webkit-scrollbar-track {
-            background: var(--ac-global-color-grey-100);
-          }
-
-          *::-webkit-scrollbar-thumb {
-            background-color: var(--ac-global-color-grey-75);
-            border-radius: 8px;
-            border: 1px solid var(--ac-global-color-grey-300);
-          }
-        }
-
-        :root {
-          --px-blue-color: ${r.colors.arizeBlue};
-
-          --px-flex-gap-sm: ${r.spacing.margin4}px;
-          --px-flex-gap-sm: ${r.spacing.margin8}px;
-
-          --px-section-background-color: ${r.colors.gray500};
-
-          /* An item is a typically something in a list */
-          --px-item-background-color: ${r.colors.gray800};
-          --px-item-border-color: ${r.colors.gray600};
-
-          --px-spacing-sm: ${r.spacing.padding4}px;
-          --px-spacing-med: ${r.spacing.padding8}px;
-          --px-spacing-lg: ${r.spacing.padding16}px;
-
-          --px-border-radius-med: ${r.borderRadius.medium}px;
-
-          --px-font-size-sm: ${r.typography.sizes.small.fontSize}px;
-          --px-font-size-med: ${r.typography.sizes.medium.fontSize}px;
-          --px-font-size-lg: ${r.typography.sizes.large.fontSize}px;
-
-          --px-gradient-bar-height: 8px;
-
-          --px-nav-collapsed-width: 45px;
-          --px-nav-expanded-width: 200px;
-        }
-
-        .ac-theme--dark {
-          --px-primary-color: #9efcfd;
-          --px-primary-color--transparent: rgb(158, 252, 253, 0.2);
-          --px-reference-color: #baa1f9;
-          --px-reference-color--transparent: #baa1f982;
-          --px-corpus-color: #92969c;
-          --px-corpus-color--transparent: #92969c63;
-        }
-        .ac-theme--light {
-          --px-primary-color: #00add0;
-          --px-primary-color--transparent: rgba(0, 173, 208, 0.2);
-          --px-reference-color: #4500d9;
-          --px-reference-color--transparent: rgba(69, 0, 217, 0.2);
-          --px-corpus-color: #92969c;
-          --px-corpus-color--transparent: #92969c63;
-        }
-      `})}const ge=R(S(s(a,{path:"/",element:e(B,{}),errorElement:e(U,{}),children:[e(a,{index:!0,loader:Y}),s(a,{path:"/model",handle:{crumb:()=>"model"},element:e(q,{}),children:[e(a,{index:!0,element:e(m,{})}),e(a,{element:e(m,{}),children:e(a,{path:"dimensions",children:e(a,{path:":dimensionId",element:e(J,{}),loader:K})})}),e(a,{path:"embeddings",children:e(a,{path:":embeddingDimensionId",element:e(W,{}),loader:H,handle:{crumb:r=>r.embedding.name}})})]}),s(a,{path:"/projects",handle:{crumb:()=>"projects"},element:e(Q,{}),children:[e(a,{index:!0,element:e(V,{})}),s(a,{path:":projectId",element:e(Z,{}),loader:X,handle:{crumb:r=>r.project.name},children:[e(a,{index:!0,element:e(u,{})}),e(a,{element:e(u,{}),children:e(a,{path:"traces/:traceId",element:e(ee,{})})})]})]}),s(a,{path:"/datasets",handle:{crumb:()=>"datasets"},children:[e(a,{index:!0,element:e(re,{})}),s(a,{path:":datasetId",loader:g,handle:{crumb:r=>r.dataset.name},children:[s(a,{element:e(ae,{}),loader:g,children:[e(a,{index:!0,element:e(h,{}),loader:f}),e(a,{path:"experiments",element:e(h,{}),loader:f}),e(a,{path:"examples",element:e(oe,{}),loader:te,children:e(a,{path:":exampleId",element:e(ne,{})})})]}),e(a,{path:"compare",handle:{crumb:()=>"compare"},loader:se,element:e(le,{})})]})]}),e(a,{path:"/apis",element:e(ie,{}),handle:{crumb:()=>"APIs"}})]})),{basename:window.Config.basename});function he(){return e(w,{router:ge})}function fe(){return e(D,{children:e(xe,{})})}function xe(){const{theme:r}=T();return e(O,{theme:r,children:e(z,{theme:I,children:s(A.RelayEnvironmentProvider,{environment:N,children:[e(ue,{}),e(pe,{children:e(G,{children:e(d.Suspense,{children:e(M,{children:e(he,{})})})})})]})})})}const be=document.getElementById("root"),ye=j.createRoot(be);ye.render(e(fe,{}));