arize-phoenix 7.12.3__py3-none-any.whl → 8.0.0__py3-none-any.whl

phoenix/server/api/types/GenerativeProvider.py

@@ -13,7 +13,7 @@ class GenerativeProviderKey(Enum):
     OPENAI = "OpenAI"
     ANTHROPIC = "Anthropic"
     AZURE_OPENAI = "Azure OpenAI"
-    GEMINI = "Google AI Studio"
+    GOOGLE = "Google AI Studio"
 
 
 @strawberry.type
@@ -25,21 +25,21 @@ class GenerativeProvider:
         GenerativeProviderKey.AZURE_OPENAI: [],
         GenerativeProviderKey.ANTHROPIC: ["claude"],
         GenerativeProviderKey.OPENAI: ["gpt", "o1"],
-        GenerativeProviderKey.GEMINI: ["gemini"],
+        GenerativeProviderKey.GOOGLE: ["gemini"],
     }
 
     attribute_provider_to_generative_provider_map: ClassVar[dict[str, GenerativeProviderKey]] = {
         OpenInferenceLLMProviderValues.OPENAI.value: GenerativeProviderKey.OPENAI,
         OpenInferenceLLMProviderValues.ANTHROPIC.value: GenerativeProviderKey.ANTHROPIC,
         OpenInferenceLLMProviderValues.AZURE.value: GenerativeProviderKey.AZURE_OPENAI,
-        OpenInferenceLLMProviderValues.GOOGLE.value: GenerativeProviderKey.GEMINI,
+        OpenInferenceLLMProviderValues.GOOGLE.value: GenerativeProviderKey.GOOGLE,
     }
 
     model_provider_to_api_key_env_var_map: ClassVar[dict[GenerativeProviderKey, str]] = {
         GenerativeProviderKey.AZURE_OPENAI: "AZURE_OPENAI_API_KEY",
         GenerativeProviderKey.ANTHROPIC: "ANTHROPIC_API_KEY",
         GenerativeProviderKey.OPENAI: "OPENAI_API_KEY",
-        GenerativeProviderKey.GEMINI: "GEMINI_API_KEY",
+        GenerativeProviderKey.GOOGLE: "GEMINI_API_KEY",
     }
 
     @strawberry.field

phoenix/server/api/types/Identifier.py

@@ -0,0 +1,15 @@
+from typing import NewType
+
+import strawberry
+
+from phoenix.db.types.identifier import Identifier as IdentifierModel
+
+
+def parse_value(value: str) -> str:
+    return IdentifierModel.model_validate(value).root
+
+
+Identifier = strawberry.scalar(
+    NewType("Identifier", str),
+    parse_value=parse_value,
+)

phoenix/server/api/types/Project.py

@@ -5,7 +5,7 @@ from typing import Any, ClassVar, Optional
 import strawberry
 from aioitertools.itertools import islice
 from openinference.semconv.trace import SpanAttributes
-from sqlalchemy import and_, desc, distinct, func, or_, select
+from sqlalchemy import desc, distinct, func, or_, select
 from sqlalchemy.orm import contains_eager
 from sqlalchemy.sql.elements import ColumnElement
 from sqlalchemy.sql.expression import tuple_
@@ -190,12 +190,10 @@ class Project(Node):
             .options(contains_eager(models.Span.trace).load_only(models.Trace.trace_id))
         )
         if time_range:
-            stmt = stmt.where(
-                and_(
-                    time_range.start <= models.Span.start_time,
-                    models.Span.start_time < time_range.end,
-                )
-            )
+            if time_range.start:
+                stmt = stmt.where(time_range.start <= models.Span.start_time)
+            if time_range.end:
+                stmt = stmt.where(models.Span.start_time < time_range.end)
         if root_spans_only:
             # A root span is any span whose parent span is missing in the
             # database, even if its `parent_span_id` may not be NULL.

phoenix/server/api/types/Prompt.py

@@ -0,0 +1,134 @@
+# Part of the Phoenix PromptHub feature set
+from datetime import datetime
+from typing import Optional
+
+import strawberry
+from sqlalchemy import func, select
+from strawberry import UNSET
+from strawberry.relay import Connection, GlobalID, Node, NodeID
+from strawberry.types import Info
+
+from phoenix.db import models
+from phoenix.server.api.context import Context
+from phoenix.server.api.exceptions import NotFound
+from phoenix.server.api.types.Identifier import Identifier
+from phoenix.server.api.types.node import from_global_id_with_expected_type
+from phoenix.server.api.types.pagination import (
+    ConnectionArgs,
+    CursorString,
+    connection_from_list,
+)
+
+from .PromptVersion import (
+    PromptVersion,
+    to_gql_prompt_version,
+)
+from .PromptVersionTag import PromptVersionTag, to_gql_prompt_version_tag
+
+
+@strawberry.type
+class Prompt(Node):
+    id_attr: NodeID[int]
+    source_prompt_id: Optional[GlobalID]
+    name: Identifier
+    description: Optional[str]
+    created_at: datetime
+
+    @strawberry.field
+    async def version(
+        self, info: Info[Context, None], version_id: Optional[GlobalID] = None
+    ) -> PromptVersion:
+        async with info.context.db() as session:
+            if version_id:
+                v_id = from_global_id_with_expected_type(version_id, PromptVersion.__name__)
+                version = await session.scalar(
+                    select(models.PromptVersion).where(
+                        models.PromptVersion.id == v_id,
+                        models.PromptVersion.prompt_id == self.id_attr,
+                    )
+                )
+                if not version:
+                    raise NotFound(f"Prompt version not found: {version_id}")
+            else:
+                stmt = (
+                    select(models.PromptVersion)
+                    .where(models.PromptVersion.prompt_id == self.id_attr)
+                    .order_by(models.PromptVersion.id.desc())
+                    .limit(1)
+                )
+                version = await session.scalar(stmt)
+                if not version:
+                    raise NotFound("This prompt has no associated versions")
+            return to_gql_prompt_version(version)
+
+    @strawberry.field
+    async def version_tags(self, info: Info[Context, None]) -> list[PromptVersionTag]:
+        async with info.context.db() as session:
+            stmt = select(models.PromptVersionTag).where(
+                models.PromptVersionTag.prompt_id == self.id_attr
+            )
+            return [
+                to_gql_prompt_version_tag(tag) async for tag in await session.stream_scalars(stmt)
+            ]
+
+    @strawberry.field
+    async def prompt_versions(
+        self,
+        info: Info[Context, None],
+        first: Optional[int] = 50,
+        last: Optional[int] = UNSET,
+        after: Optional[CursorString] = UNSET,
+        before: Optional[CursorString] = UNSET,
+    ) -> Connection[PromptVersion]:
+        args = ConnectionArgs(
+            first=first,
+            after=after if isinstance(after, CursorString) else None,
+            last=last,
+            before=before if isinstance(before, CursorString) else None,
+        )
+        row_number = func.row_number().over(order_by=models.PromptVersion.id).label("row_number")
+        stmt = (
+            select(models.PromptVersion, row_number)
+            .where(models.PromptVersion.prompt_id == self.id_attr)
+            .order_by(models.PromptVersion.id.desc())
+        )
+        async with info.context.db() as session:
+            data = [
+                to_gql_prompt_version(prompt_version, sequence_number)
+                async for prompt_version, sequence_number in await session.stream(stmt)
+            ]
+            return connection_from_list(data=data, args=args)
+
+    @strawberry.field
+    async def source_prompt(self, info: Info[Context, None]) -> Optional["Prompt"]:
+        if not self.source_prompt_id:
+            return None
+
+        source_prompt_id = from_global_id_with_expected_type(
+            global_id=self.source_prompt_id, expected_type_name=Prompt.__name__
+        )
+
+        async with info.context.db() as session:
+            source_prompt = await session.scalar(
+                select(models.Prompt).where(models.Prompt.id == source_prompt_id)
+            )
+            if not source_prompt:
+                raise NotFound(f"Source prompt not found: {self.source_prompt_id}")
+            return to_gql_prompt_from_orm(source_prompt)
+
+
+def to_gql_prompt_from_orm(orm_model: "models.Prompt") -> Prompt:
+    if not orm_model.source_prompt_id:
+        source_prompt_gid = None
+    else:
+        source_prompt_gid = GlobalID(
+            Prompt.__name__,
+            str(orm_model.source_prompt_id),
+        )
+    return Prompt(
+        id_attr=orm_model.id,
+        source_prompt_id=source_prompt_gid,
+        name=Identifier(orm_model.name.root),
+        description=orm_model.description,
+        created_at=orm_model.created_at,
+    )

phoenix/server/api/types/PromptLabel.py

@@ -0,0 +1,41 @@
+from typing import Optional
+
+import strawberry
+from sqlalchemy import select
+from strawberry.relay import Node, NodeID
+from strawberry.types import Info
+
+from phoenix.db import models
+from phoenix.server.api.context import Context
+from phoenix.server.api.types.Identifier import Identifier
+from phoenix.server.api.types.Prompt import Prompt, to_gql_prompt_from_orm
+
+
+@strawberry.type
+class PromptLabel(Node):
+    id_attr: NodeID[int]
+    name: Identifier
+    description: Optional[str] = None
+
+    @strawberry.field
+    async def prompts(self, info: Info[Context, None]) -> list[Prompt]:
+        async with info.context.db() as session:
+            statement = (
+                select(models.Prompt)
+                .join(
+                    models.PromptPromptLabel, models.Prompt.id == models.PromptPromptLabel.prompt_id
+                )
+                .where(models.PromptPromptLabel.prompt_label_id == self.id_attr)
+            )
+            return [
+                to_gql_prompt_from_orm(prompt_orm)
+                async for prompt_orm in await session.stream_scalars(statement)
+            ]
+
+
+def to_gql_prompt_label(label_orm: models.PromptLabel) -> PromptLabel:
+    return PromptLabel(
+        id_attr=label_orm.id,
+        name=Identifier(label_orm.name),
+        description=label_orm.description,
+    )

phoenix/server/api/types/PromptVersion.py

@@ -0,0 +1,148 @@
+from datetime import datetime
+from typing import Optional
+
+import strawberry
+from sqlalchemy import select
+from strawberry import Private
+from strawberry.relay import Node, NodeID
+from strawberry.scalars import JSON
+from strawberry.types import Info
+
+from phoenix.db import models
+from phoenix.db.types.model_provider import ModelProvider
+from phoenix.server.api.context import Context
+from phoenix.server.api.helpers.prompts.models import (
+    PromptTemplateFormat,
+    PromptTemplateType,
+    denormalize_response_format,
+    denormalize_tools,
+    get_raw_invocation_parameters,
+)
+from phoenix.server.api.types.PromptVersionTag import PromptVersionTag, to_gql_prompt_version_tag
+from phoenix.server.api.types.PromptVersionTemplate import (
+    PromptTemplate,
+    to_gql_template_from_orm,
+)
+
+from .ResponseFormat import ResponseFormat
+from .ToolDefinition import ToolDefinition
+from .User import User, to_gql_user
+
+
+@strawberry.type
+class PromptVersion(Node):
+    id_attr: NodeID[int]
+    user_id: strawberry.Private[Optional[int]]
+    description: Optional[str]
+    template_type: PromptTemplateType
+    template_format: PromptTemplateFormat
+    template: PromptTemplate
+    invocation_parameters: Optional[JSON] = None
+    tools: list[ToolDefinition]
+    response_format: Optional[ResponseFormat] = None
+    model_name: str
+    model_provider: ModelProvider
+    metadata: JSON
+    created_at: datetime
+    cached_sequence_number: Private[Optional[int]] = None
+
+    @strawberry.field
+    async def tags(self, info: Info[Context, None]) -> list[PromptVersionTag]:
+        async with info.context.db() as session:
+            stmt = select(models.PromptVersionTag).where(
+                models.PromptVersionTag.prompt_version_id == self.id_attr
+            )
+            return [
+                to_gql_prompt_version_tag(tag) async for tag in await session.stream_scalars(stmt)
+            ]
+
+    @strawberry.field
+    async def user(self, info: Info[Context, None]) -> Optional[User]:
+        if self.user_id is None:
+            return None
+        async with info.context.db() as session:
+            user = await session.get(models.User, self.user_id)
+        return to_gql_user(user) if user is not None else None
+
+    @strawberry.field
+    async def previous_version(self, info: Info[Context, None]) -> Optional["PromptVersion"]:
+        async with info.context.db() as session:
+            current_version = await session.get(models.PromptVersion, self.id_attr)
+            if current_version is None:
+                return None
+
+            prompt_id = current_version.prompt_id
+
+            stmt = (
+                select(models.PromptVersion)
+                .where(models.PromptVersion.prompt_id == prompt_id)
+                .where(models.PromptVersion.id < self.id_attr)
+                .order_by(models.PromptVersion.created_at.desc())
+                .limit(1)
+            )
+            previous_version = await session.scalar(stmt)
+
+            if previous_version is not None:
+                return to_gql_prompt_version(prompt_version=previous_version)
+            return None
+
+    @strawberry.field(
+        description="Sequence number (1-based) of prompt versions belonging to the same prompt"
+    )  # type: ignore
+    async def sequence_number(
+        self,
+        info: Info[Context, None],
+    ) -> int:
+        if self.cached_sequence_number is None:
+            seq_num = await info.context.data_loaders.prompt_version_sequence_number.load(
+                self.id_attr
+            )
+            if seq_num is None:
+                raise ValueError(f"invalid prompt version: id={self.id_attr}")
+            self.cached_sequence_number = seq_num
+        return self.cached_sequence_number
+
+
+def to_gql_prompt_version(
+    prompt_version: models.PromptVersion, sequence_number: Optional[int] = None
+) -> PromptVersion:
+    prompt_template_type = PromptTemplateType(prompt_version.template_type)
+    prompt_template = to_gql_template_from_orm(prompt_version)
+    prompt_template_format = PromptTemplateFormat(prompt_version.template_format)
+    tool_choice = None
+    if prompt_version.tools is not None:
+        tool_schemas, tool_choice = denormalize_tools(
+            prompt_version.tools, prompt_version.model_provider
+        )
+        tools = [ToolDefinition(definition=schema) for schema in tool_schemas]
+    else:
+        tools = []
+    response_format = (
+        ResponseFormat(
+            definition=denormalize_response_format(
+                prompt_version.response_format,
+                prompt_version.model_provider,
+            )
+        )
+        if prompt_version.response_format is not None
+        else None
+    )
+    invocation_parameters = get_raw_invocation_parameters(prompt_version.invocation_parameters)
+    if tool_choice is not None:
+        invocation_parameters["tool_choice"] = tool_choice
+    return PromptVersion(
+        id_attr=prompt_version.id,
+        user_id=prompt_version.user_id,
+        description=prompt_version.description,
+        template_type=prompt_template_type,
+        template_format=prompt_template_format,
+        template=prompt_template,
+        invocation_parameters=invocation_parameters,
+        tools=tools,
+        response_format=response_format,
+        model_name=prompt_version.model_name,
+        model_provider=prompt_version.model_provider,
+        metadata=prompt_version.metadata_,
+        created_at=prompt_version.created_at,
+        cached_sequence_number=sequence_number,
+    )

phoenix/server/api/types/PromptVersionTag.py

@@ -0,0 +1,27 @@
+from typing import Optional
+
+import strawberry
+from strawberry.relay import GlobalID, Node, NodeID
+
+from phoenix.db import models
+from phoenix.server.api.types.Identifier import Identifier
+
+
+@strawberry.type
+class PromptVersionTag(Node):
+    id_attr: NodeID[int]
+    prompt_version_id: GlobalID
+    name: Identifier
+    description: Optional[str] = None
+
+
+def to_gql_prompt_version_tag(prompt_version_tag: models.PromptVersionTag) -> PromptVersionTag:
+    from phoenix.server.api.types.PromptVersion import PromptVersion
+
+    version_gid = GlobalID(PromptVersion.__name__, str(prompt_version_tag.prompt_version_id))
+    return PromptVersionTag(
+        id_attr=prompt_version_tag.id,
+        prompt_version_id=version_gid,
+        name=Identifier(prompt_version_tag.name.root),
+        description=prompt_version_tag.description,
+    )

phoenix/server/api/types/PromptVersionTemplate.py

@@ -0,0 +1,148 @@
+# Part of the Phoenix PromptHub feature set
+import json
+from typing import Annotated, Union
+
+import strawberry
+from strawberry.scalars import JSON
+from typing_extensions import TypeAlias, assert_never
+
+from phoenix.db.models import PromptVersion as ORMPromptVersion
+from phoenix.server.api.helpers.prompts.models import (
+    PromptChatTemplate as PromptChatTemplateModel,
+)
+from phoenix.server.api.helpers.prompts.models import PromptMessage as PromptMessageModel
+from phoenix.server.api.helpers.prompts.models import (
+    PromptMessageRole,
+    PromptTemplateType,
+    RoleConversion,
+)
+from phoenix.server.api.helpers.prompts.models import (
+    PromptStringTemplate as PromptStringTemplateModel,
+)
+
+
+@strawberry.type
+class TextContentValue:
+    text: str
+
+
+@strawberry.type
+class TextContentPart:
+    text: TextContentValue
+
+
+@strawberry.type
+class ToolCallFunction:
+    name: str
+    arguments: str
+
+
+@strawberry.type
+class ToolCallContentValue:
+    tool_call_id: str
+    tool_call: ToolCallFunction
+
+
+@strawberry.type
+class ToolCallContentPart:
+    tool_call: ToolCallContentValue
+
+
+@strawberry.type
+class ToolResultContentValue:
+    tool_call_id: str
+    result: JSON
+
+
+@strawberry.type
+class ToolResultContentPart:
+    tool_result: ToolResultContentValue
+
+
+ContentPart: TypeAlias = Annotated[
+    Union[TextContentPart, ToolCallContentPart, ToolResultContentPart],
+    strawberry.union("ContentPart"),
+]
+
+
+@strawberry.type
+class PromptMessage:
+    role: PromptMessageRole
+    content: list[ContentPart]
+
+
+@strawberry.experimental.pydantic.type(PromptChatTemplateModel)
+class PromptChatTemplate:
+    messages: list[PromptMessage]
+
+
+def to_gql_prompt_chat_template_from_orm(orm_model: "ORMPromptVersion") -> "PromptChatTemplate":
+    template = PromptChatTemplateModel.model_validate(orm_model.template)
+    messages: list[PromptMessage] = []
+    for msg in template.messages:
+        role = RoleConversion.to_gql(msg.role)
+        if isinstance(msg, PromptMessageModel):
+            if isinstance(msg.content, str):
+                messages.append(
+                    PromptMessage(
+                        role=role,
+                        content=[TextContentPart(text=TextContentValue(text=msg.content))],
+                    )
+                )
+                continue
+            content: list[ContentPart] = []
+            for part in msg.content:
+                if part.type == "text":
+                    content.append(TextContentPart(text=TextContentValue(text=part.text)))
+                elif part.type == "tool_call":
+                    content.append(
+                        ToolCallContentPart(
+                            tool_call=ToolCallContentValue(
+                                tool_call_id=part.tool_call_id,
+                                tool_call=ToolCallFunction(
+                                    name=part.tool_call.name,
+                                    arguments=part.tool_call.arguments,
+                                ),
+                            )
+                        )
+                    )
+                elif part.type == "tool_result":
+                    content.append(
+                        ToolResultContentPart(
+                            tool_result=ToolResultContentValue(
+                                tool_call_id=part.tool_call_id,
+                                result=json.dumps(part.tool_result),
+                            )
+                        )
+                    )
+                else:
+                    assert_never(part)
+            messages.append(PromptMessage(role=role, content=content))
+        else:
+            assert_never(msg)
+    return PromptChatTemplate(messages=messages)
+
+
+@strawberry.experimental.pydantic.type(PromptStringTemplateModel)
+class PromptStringTemplate:
+    template: strawberry.auto
+
+
+def to_gql_prompt_string_template_from_orm(orm_model: "ORMPromptVersion") -> "PromptStringTemplate":
+    model = PromptStringTemplateModel.model_validate(orm_model.template)
+    return PromptStringTemplate(template=model.template)
+
+
+def to_gql_template_from_orm(orm_prompt_version: "ORMPromptVersion") -> "PromptTemplate":
+    template_type = PromptTemplateType(orm_prompt_version.template_type)
+    if template_type is PromptTemplateType.STRING:
+        return to_gql_prompt_string_template_from_orm(orm_prompt_version)
+    elif template_type is PromptTemplateType.CHAT:
+        return to_gql_prompt_chat_template_from_orm(orm_prompt_version)
+    assert_never(template_type)
+
+
+PromptTemplate: TypeAlias = Annotated[
+    Union[PromptStringTemplate, PromptChatTemplate],
+    strawberry.union("PromptTemplate"),
+]

phoenix/server/api/types/ResponseFormat.py

@@ -0,0 +1,9 @@
+import strawberry
+from strawberry.scalars import JSON
+
+
+@strawberry.type
+class ResponseFormat:
+    """A JSON schema definition used to guide an LLM's output"""
+
+    definition: JSON

phoenix/server/api/types/ToolDefinition.py

@@ -0,0 +1,9 @@
+import strawberry
+from strawberry.scalars import JSON
+
+
+@strawberry.type
+class ToolDefinition:
+    """The definition of a tool that a generative tool can invoke."""
+
+    definition: JSON

phoenix/server/app.py

@@ -86,6 +86,7 @@ from phoenix.server.api.dataloaders import (
     LatencyMsQuantileDataLoader,
     MinStartOrMaxEndTimeDataLoader,
     ProjectByNameDataLoader,
+    PromptVersionSequenceNumberDataLoader,
     RecordCountDataLoader,
     SessionIODataLoader,
     SessionNumTracesDataLoader,
@@ -611,6 +612,7 @@ def create_graphql_router(
                         else None
                     ),
                 ),
+                prompt_version_sequence_number=PromptVersionSequenceNumberDataLoader(db),
                 record_counts=RecordCountDataLoader(
                     db,
                     cache_map=cache_for_dataloaders.record_count if cache_for_dataloaders else None,
@@ -914,6 +916,7 @@ def create_app(
             ),
             name="static",
         )
+    app.state.authentication_enabled = authentication_enabled
     app.state.read_only = read_only
     app.state.export_path = export_path
     app.state.password_reset_token_expiry = password_reset_token_expiry