arize-phoenix 11.23.1__py3-none-any.whl → 12.28.1__py3-none-any.whl

phoenix/server/api/helpers/playground_spans.py

@@ -222,6 +222,7 @@ def get_db_experiment_run(
     *,
     experiment_id: int,
     example_id: int,
+    repetition_number: int,
 ) -> models.ExperimentRun:
     return models.ExperimentRun(
         experiment_id=experiment_id,
@@ -230,7 +231,7 @@ def get_db_experiment_run(
         output=models.ExperimentRunOutput(
             task_output=get_dataset_example_output(db_span),
         ),
-        repetition_number=1,
+        repetition_number=repetition_number,
         start_time=db_span.start_time,
         end_time=db_span.end_time,
         error=db_span.status_message or None,

phoenix/server/api/helpers/playground_users.py

@@ -0,0 +1,26 @@
+from typing import (
+    Optional,
+)
+
+from starlette.requests import Request
+from strawberry import Info
+
+from phoenix.server.api.context import Context
+from phoenix.server.bearer_auth import PhoenixUser
+
+
+def get_user(info: Info[Context, None]) -> Optional[int]:
+    user_id: Optional[int] = None
+    try:
+        assert isinstance(request := info.context.request, Request)
+
+        if "user" in request.scope and isinstance((user := info.context.user), PhoenixUser):
+            user_id = int(user.identity)
+    except AssertionError:
+        # Request is not available, try to obtain user identify
+        # this will also throw an assertion error if auth is not available
+        # the finally block will continue execution returning None
+        if info.context.user.is_authenticated:
+            user_id = int(info.context.user.identity)
+    finally:
+        return user_id

phoenix/server/api/helpers/prompts/conversions/google.py

@@ -0,0 +1,103 @@
+from typing import TYPE_CHECKING, Any, Literal, Union
+
+from typing_extensions import NotRequired, TypedDict, assert_never
+
+if TYPE_CHECKING:
+    from phoenix.server.api.helpers.prompts.models import (
+        PromptToolChoiceNone,
+        PromptToolChoiceOneOrMore,
+        PromptToolChoiceSpecificFunctionTool,
+        PromptToolChoiceZeroOrMore,
+    )
+
+
+class GoogleFunctionCallingConfig(TypedDict, total=False):
+    """
+    Based on https://github.com/googleapis/python-genai/blob/97cc7e4eafbee4fa4035e7420170ab6a2c9da7fb/google/genai/types.py#L4245
+    """
+
+    mode: NotRequired[Literal["auto", "any", "none"]]
+    allowed_function_names: NotRequired[list[str]]
+
+
+class GoogleToolChoice(TypedDict):
+    """
+    Based on https://github.com/googleapis/python-genai/blob/97cc7e4eafbee4fa4035e7420170ab6a2c9da7fb/google/genai/types.py#L4341
+    """
+
+    function_calling_config: GoogleFunctionCallingConfig
+
+
+class GoogleToolChoiceConversion:
+    @staticmethod
+    def to_google(
+        obj: Union[
+            "PromptToolChoiceNone",
+            "PromptToolChoiceZeroOrMore",
+            "PromptToolChoiceOneOrMore",
+            "PromptToolChoiceSpecificFunctionTool",
+        ],
+    ) -> GoogleToolChoice:
+        if obj.type == "none":
+            return {"function_calling_config": {"mode": "none"}}
+        if obj.type == "zero_or_more":
+            return {"function_calling_config": {"mode": "auto"}}
+        if obj.type == "one_or_more":
+            return {"function_calling_config": {"mode": "any"}}
+        if obj.type == "specific_function":
+            return {
+                "function_calling_config": {
+                    "mode": "any",
+                    "allowed_function_names": [obj.function_name],
+                }
+            }
+        assert_never(obj)
+
+    @staticmethod
+    def from_google(
+        obj: Any,
+    ) -> Union[
+        "PromptToolChoiceNone",
+        "PromptToolChoiceZeroOrMore",
+        "PromptToolChoiceOneOrMore",
+        "PromptToolChoiceSpecificFunctionTool",
+    ]:
+        from google.genai.types import ToolConfig
+
+        from phoenix.server.api.helpers.prompts.models import (
+            PromptToolChoiceNone,
+            PromptToolChoiceOneOrMore,
+            PromptToolChoiceSpecificFunctionTool,
+            PromptToolChoiceZeroOrMore,
+        )
+
+        tool_config = ToolConfig.model_validate(obj)
+        if (function_calling_config := tool_config.function_calling_config) is None:
+            raise ValueError("function_calling_config is required")
+        # normalize mode to lowercase since Google's API is case-insensitive
+        # https://github.com/googleapis/python-genai/blob/97cc7e4eafbee4fa4035e7420170ab6a2c9da7fb/google/genai/types.py#L645
+        normalized_mode = (
+            function_calling_config.mode.value.lower()
+            if function_calling_config.mode is not None
+            else None
+        )
+        allowed_function_names = function_calling_config.allowed_function_names
+
+        if allowed_function_names:
+            if len(allowed_function_names) != 1:
+                raise ValueError("Only one allowed function name is currently supported")
+            if normalized_mode != "any":
+                raise ValueError("allowed function names only supported in 'any' mode")
+            return PromptToolChoiceSpecificFunctionTool(
+                type="specific_function",
+                function_name=allowed_function_names[0],
+            )
+
+        if normalized_mode == "none":
+            return PromptToolChoiceNone(type="none")
+        if normalized_mode == "auto" or normalized_mode is None:
+            return PromptToolChoiceZeroOrMore(type="zero_or_more")
+        if normalized_mode == "any":
+            return PromptToolChoiceOneOrMore(type="one_or_more")
+
+        raise ValueError(f"Unsupported Google tool choice mode: {normalized_mode}")

phoenix/server/api/helpers/prompts/models.py

@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 from enum import Enum
 from typing import Any, Literal, Mapping, Optional, Union
 
@@ -10,6 +8,7 @@ from phoenix.db.types.db_models import UNDEFINED, DBBaseModel
 from phoenix.db.types.model_provider import ModelProvider
 from phoenix.server.api.helpers.prompts.conversions.anthropic import AnthropicToolChoiceConversion
 from phoenix.server.api.helpers.prompts.conversions.aws import AwsToolChoiceConversion
+from phoenix.server.api.helpers.prompts.conversions.google import GoogleToolChoiceConversion
 from phoenix.server.api.helpers.prompts.conversions.openai import OpenAIToolChoiceConversion
 
 JSONSerializable = Union[None, bool, int, float, str, dict[str, Any], list[Any]]
@@ -127,11 +126,6 @@ class PromptTemplateRootModel(RootModel[PromptTemplate]):
     root: PromptTemplate
 
 
-class PromptToolFunction(DBBaseModel):
-    type: Literal["function"]
-    function: PromptToolFunctionDefinition
-
-
 class PromptToolFunctionDefinition(DBBaseModel):
     name: str
     description: str = UNDEFINED
@@ -139,14 +133,12 @@ class PromptToolFunctionDefinition(DBBaseModel):
     strict: bool = UNDEFINED
 
 
-PromptTool: TypeAlias = Annotated[Union[PromptToolFunction], Field(..., discriminator="type")]
+class PromptToolFunction(DBBaseModel):
+    type: Literal["function"]
+    function: PromptToolFunctionDefinition
 
 
-class PromptTools(DBBaseModel):
-    type: Literal["tools"]
-    tools: Annotated[list[PromptTool], Field(..., min_length=1)]
-    tool_choice: PromptToolChoice = UNDEFINED
-    disable_parallel_tool_calls: bool = UNDEFINED
+PromptTool: TypeAlias = Annotated[Union[PromptToolFunction], Field(..., discriminator="type")]
 
 
 class PromptToolChoiceNone(DBBaseModel):
@@ -177,6 +169,13 @@ PromptToolChoice: TypeAlias = Annotated[
 ]
 
 
+class PromptTools(DBBaseModel):
+    type: Literal["tools"]
+    tools: Annotated[list[PromptTool], Field(..., min_length=1)]
+    tool_choice: PromptToolChoice = UNDEFINED
+    disable_parallel_tool_calls: bool = UNDEFINED
+
+
 class PromptOpenAIJSONSchema(DBBaseModel):
     """
     Based on https://github.com/openai/openai-python/blob/d16e6edde5a155626910b5758a0b939bfedb9ced/src/openai/types/shared/response_format_json_schema.py#L13
@@ -200,11 +199,6 @@ class PromptOpenAIResponseFormatJSONSchema(DBBaseModel):
     type: Literal["json_schema"]
 
 
-class PromptResponseFormatJSONSchema(DBBaseModel):
-    type: Literal["json_schema"]
-    json_schema: PromptResponseFormatJSONSchemaDefinition
-
-
 class PromptResponseFormatJSONSchemaDefinition(DBBaseModel):
     name: str
     description: str = UNDEFINED
@@ -212,6 +206,11 @@ class PromptResponseFormatJSONSchemaDefinition(DBBaseModel):
     strict: bool = UNDEFINED
 
 
+class PromptResponseFormatJSONSchema(DBBaseModel):
+    type: Literal["json_schema"]
+    json_schema: PromptResponseFormatJSONSchemaDefinition
+
+
 PromptResponseFormat: TypeAlias = Annotated[
     Union[PromptResponseFormatJSONSchema], Field(..., discriminator="type")
 ]
@@ -321,6 +320,16 @@ class BedrockToolDefinition(DBBaseModel):
     toolSpec: dict[str, Any]
 
 
+class GeminiToolDefinition(DBBaseModel):
+    """
+    Based on https://github.com/googleapis/python-genai/blob/c0b175a0ca20286db419390031a2239938d0c0b7/google/genai/types.py#L2792
+    """
+
+    name: str
+    description: str = UNDEFINED
+    parameters: dict[str, Any]
+
+
 class PromptOpenAIInvocationParametersContent(DBBaseModel):
     temperature: float = UNDEFINED
     max_tokens: int = UNDEFINED
@@ -329,7 +338,7 @@ class PromptOpenAIInvocationParametersContent(DBBaseModel):
     presence_penalty: float = UNDEFINED
     top_p: float = UNDEFINED
     seed: int = UNDEFINED
-    reasoning_effort: Literal["minimal", "low", "medium", "high"] = UNDEFINED
+    reasoning_effort: Literal["none", "minimal", "low", "medium", "high", "xhigh"] = UNDEFINED
 
 
 class PromptOpenAIInvocationParameters(DBBaseModel):
@@ -565,6 +574,9 @@ def normalize_tools(
     elif model_provider is ModelProvider.ANTHROPIC:
         anthropic_tools = [AnthropicToolDefinition.model_validate(schema) for schema in schemas]
         tools = [_anthropic_to_prompt_tool(anthropic_tool) for anthropic_tool in anthropic_tools]
+    elif model_provider is ModelProvider.GOOGLE:
+        gemini_tools = [GeminiToolDefinition.model_validate(schema) for schema in schemas]
+        tools = [_gemini_to_prompt_tool(gemini_tool) for gemini_tool in gemini_tools]
     else:
         raise ValueError(f"Unsupported model provider: {model_provider}")
     ans = PromptTools(type="tools", tools=tools)
@@ -587,6 +599,8 @@ def normalize_tools(
             ans.tool_choice = choice
             if disable_parallel_tool_calls is not None:
                 ans.disable_parallel_tool_calls = disable_parallel_tool_calls
+        elif model_provider is ModelProvider.GOOGLE:
+            ans.tool_choice = GoogleToolChoiceConversion.from_google(tool_choice)
     return ans
 
 
@@ -614,6 +628,10 @@ def denormalize_tools(
         denormalized_tools = [_prompt_to_anthropic_tool(tool) for tool in tools.tools]
         if tools.tool_choice and tools.tool_choice.type != "none":
             tool_choice = AnthropicToolChoiceConversion.to_anthropic(tools.tool_choice)
+    elif model_provider is ModelProvider.GOOGLE:
+        denormalized_tools = [_prompt_to_gemini_tool(tool) for tool in tools.tools]
+        if tools.tool_choice:
+            tool_choice = GoogleToolChoiceConversion.to_google(tools.tool_choice)
     else:
         raise ValueError(f"Unsupported model provider: {model_provider}")
     return [tool.model_dump() for tool in denormalized_tools], tool_choice
@@ -703,3 +721,27 @@ def _prompt_to_bedrock_tool(
             },
         }
     )
+
+
+def _gemini_to_prompt_tool(
+    tool: GeminiToolDefinition,
+) -> PromptToolFunction:
+    return PromptToolFunction(
+        type="function",
+        function=PromptToolFunctionDefinition(
+            name=tool.name,
+            description=tool.description,
+            parameters=tool.parameters,
+        ),
+    )
+
+
+def _prompt_to_gemini_tool(
+    tool: PromptToolFunction,
+) -> GeminiToolDefinition:
+    function = tool.function
+    return GeminiToolDefinition(
+        name=function.name,
+        description=function.description,
+        parameters=function.parameters,
+    )

phoenix/server/api/input_types/{SpanAnnotationFilter.py → AnnotationFilter.py}

@@ -1,8 +1,9 @@
-from typing import Optional
+from typing import Optional, Union
 
 import strawberry
 from strawberry import UNSET
 from strawberry.relay import GlobalID
+from typing_extensions import TypeAlias
 
 from phoenix.db import models
 from phoenix.server.api.exceptions import BadRequest
@@ -11,7 +12,7 @@ from phoenix.server.api.types.node import from_global_id_with_expected_type
 
 
 @strawberry.input
-class SpanAnnotationFilterCondition:
+class AnnotationFilterCondition:
     names: Optional[list[str]] = UNSET
     sources: Optional[list[AnnotationSource]] = UNSET
     user_ids: Optional[list[Optional[GlobalID]]] = UNSET
@@ -26,42 +27,49 @@ class SpanAnnotationFilterCondition:
 
 
 @strawberry.input
-class SpanAnnotationFilter:
-    include: Optional[SpanAnnotationFilterCondition] = UNSET
-    exclude: Optional[SpanAnnotationFilterCondition] = UNSET
+class AnnotationFilter:
+    include: Optional[AnnotationFilterCondition] = UNSET
+    exclude: Optional[AnnotationFilterCondition] = UNSET
 
     def __post_init__(self) -> None:
         if self.include is UNSET and self.exclude is UNSET:
             raise BadRequest("include and exclude cannot both be unset")
 
 
-def satisfies_filter(span_annotation: models.SpanAnnotation, filter: SpanAnnotationFilter) -> bool:
+_Annotation: TypeAlias = Union[
+    models.SpanAnnotation,
+    models.TraceAnnotation,
+    models.ProjectSessionAnnotation,
+]
+
+
+def satisfies_filter(annotation: _Annotation, filter: AnnotationFilter) -> bool:
     """
-    Returns true if the span annotation satisfies the filter and false otherwise.
+    Returns true if the annotation satisfies the filter and false otherwise.
     """
-    span_annotation_source = AnnotationSource(span_annotation.source)
+    annotation_source = AnnotationSource(annotation.source)
     if include := filter.include:
-        if include.names and span_annotation.name not in include.names:
+        if include.names and annotation.name not in include.names:
             return False
-        if include.sources and span_annotation_source not in include.sources:
+        if include.sources and annotation_source not in include.sources:
             return False
         if include.user_ids:
             user_rowids = [
                 from_global_id_with_expected_type(user_id, "User") if user_id is not None else None
                 for user_id in include.user_ids
             ]
-            if span_annotation.user_id not in user_rowids:
+            if annotation.user_id not in user_rowids:
                 return False
     if exclude := filter.exclude:
-        if exclude.names and span_annotation.name in exclude.names:
+        if exclude.names and annotation.name in exclude.names:
             return False
-        if exclude.sources and span_annotation_source in exclude.sources:
+        if exclude.sources and annotation_source in exclude.sources:
             return False
         if exclude.user_ids:
             user_rowids = [
                 from_global_id_with_expected_type(user_id, "User") if user_id is not None else None
                 for user_id in exclude.user_ids
             ]
-            if span_annotation.user_id in user_rowids:
+            if annotation.user_id in user_rowids:
                 return False
     return True

phoenix/server/api/input_types/ChatCompletionInput.py

@@ -26,6 +26,7 @@ class ChatCompletionInput:
     credentials: Optional[list[GenerativeCredentialInput]] = UNSET
     template: Optional[PromptTemplateOptions] = UNSET
     prompt_name: Optional[Identifier] = None
+    repetitions: int
 
 
 @strawberry.input
@@ -36,8 +37,10 @@ class ChatCompletionOverDatasetInput:
     tools: Optional[list[JSON]] = UNSET
     credentials: Optional[list[GenerativeCredentialInput]] = UNSET
     template_format: PromptTemplateFormat = PromptTemplateFormat.MUSTACHE
+    repetitions: int
     dataset_id: GlobalID
     dataset_version_id: Optional[GlobalID] = None
+    split_ids: Optional[list[GlobalID]] = None
     experiment_name: Optional[str] = None
     experiment_description: Optional[str] = None
     experiment_metadata: Optional[JSON] = strawberry.field(default_factory=dict)

phoenix/server/api/input_types/CreateProjectSessionAnnotationInput.py

@@ -0,0 +1,37 @@
+from typing import Optional
+
+import strawberry
+from strawberry.relay import GlobalID
+from strawberry.scalars import JSON
+
+from phoenix.server.api.exceptions import BadRequest
+from phoenix.server.api.types.AnnotationSource import AnnotationSource
+from phoenix.server.api.types.AnnotatorKind import AnnotatorKind
+
+
+@strawberry.input
+class CreateProjectSessionAnnotationInput:
+    project_session_id: GlobalID
+    name: str
+    annotator_kind: AnnotatorKind = AnnotatorKind.HUMAN
+    label: Optional[str] = None
+    score: Optional[float] = None
+    explanation: Optional[str] = None
+    metadata: JSON = strawberry.field(default_factory=dict)
+    source: AnnotationSource = AnnotationSource.APP
+    identifier: Optional[str] = strawberry.UNSET
+
+    def __post_init__(self) -> None:
+        self.name = self.name.strip()
+        if isinstance(self.label, str):
+            self.label = self.label.strip()
+        if not self.label:
+            self.label = None
+        if isinstance(self.explanation, str):
+            self.explanation = self.explanation.strip()
+        if not self.explanation:
+            self.explanation = None
+        if isinstance(self.identifier, str):
+            self.identifier = self.identifier.strip()
+        if self.score is None and not self.label and not self.explanation:
+            raise BadRequest("At least one of score, label, or explanation must be not null/empty.")

phoenix/server/api/input_types/DatasetFilter.py

@@ -1,6 +1,8 @@
 from enum import Enum
+from typing import Optional
 
 import strawberry
+from strawberry import UNSET
 
 
 @strawberry.enum
@@ -10,5 +12,6 @@ class DatasetFilterColumn(Enum):
 
 @strawberry.input(description="A filter for datasets")
 class DatasetFilter:
-    col: DatasetFilterColumn
-    value: str
+    col: Optional[DatasetFilterColumn] = None
+    value: Optional[str] = None
+    filter_labels: Optional[list[str]] = UNSET