latitude-sdk 0.1.0b1__py3-none-any.whl

latitude_sdk/sdk/prompts.py

@@ -0,0 +1,297 @@
+from typing import Any, AsyncGenerator, Dict, List, Optional
+
+from latitude_sdk.client import (
+    ChatPromptRequestBody,
+    ChatPromptRequestParams,
+    Client,
+    ClientEvent,
+    GetOrCreatePromptRequestBody,
+    GetOrCreatePromptRequestParams,
+    GetPromptRequestParams,
+    RequestHandler,
+    RunPromptRequestBody,
+    RunPromptRequestParams,
+)
+from latitude_sdk.sdk.errors import ApiError, ApiErrorCodes
+from latitude_sdk.sdk.types import (
+    ChainEventCompleted,
+    ChainEventError,
+    ChainEvents,
+    ChainEventStep,
+    ChainEventStepCompleted,
+    FinishedEvent,
+    Message,
+    Prompt,
+    SdkOptions,
+    StreamCallbacks,
+    StreamEvents,
+)
+from latitude_sdk.util import Model
+
+
+class PromptOptions(Model):
+    project_id: Optional[int] = None
+    version_uuid: Optional[str] = None
+
+
+class GetPromptOptions(PromptOptions, Model):
+    pass
+
+
+class GetPromptResult(Prompt, Model):
+    pass
+
+
+class GetOrCreatePromptOptions(PromptOptions, Model):
+    prompt: Optional[str] = None
+
+
+class GetOrCreatePromptResult(Prompt, Model):
+    pass
+
+
+class RunPromptOptions(StreamCallbacks, PromptOptions, Model):
+    custom_identifier: Optional[str] = None
+    parameters: Optional[Dict[str, Any]] = None
+    stream: Optional[bool] = None
+
+
+class RunPromptResult(FinishedEvent, Model):
+    pass
+
+
+class ChatPromptOptions(StreamCallbacks, Model):
+    stream: Optional[bool] = None
+
+
+class ChatPromptResult(FinishedEvent, Model):
+    pass
+
+
+class Prompts:
+    _options: SdkOptions
+    _client: Client
+
+    def __init__(self, client: Client, options: SdkOptions):
+        self._options = options
+        self._client = client
+
+    def _ensure_options(self, options: PromptOptions) -> PromptOptions:
+        project_id = options.project_id or self._options.project_id
+        if not project_id:
+            raise ApiError(
+                status=404,
+                code=ApiErrorCodes.NotFoundError,
+                message="Project ID is required",
+                response="Project ID is required",
+            )
+
+        version_uuid = options.version_uuid or self._options.version_uuid
+
+        return PromptOptions(project_id=project_id, version_uuid=version_uuid)
+
+    async def _handle_stream(
+        self, stream: AsyncGenerator[ClientEvent, Any], callbacks: StreamCallbacks
+    ) -> FinishedEvent:
+        uuid = None
+        conversation: List[Message] = []
+        response = None
+
+        async for stream_event in stream:
+            event = None
+
+            if stream_event.event == str(StreamEvents.Latitude):
+                type = stream_event.json().get("type")
+
+                if type == str(ChainEvents.Step):
+                    event = ChainEventStep.model_validate_json(stream_event.data)
+                    conversation.extend(event.messages)
+
+                elif type == str(ChainEvents.StepCompleted):
+                    event = ChainEventStepCompleted.model_validate_json(stream_event.data)
+
+                elif type == str(ChainEvents.Completed):
+                    event = ChainEventCompleted.model_validate_json(stream_event.data)
+                    uuid = event.uuid
+                    conversation.extend(event.messages or [])
+                    response = event.response
+
+                elif type == str(ChainEvents.Error):
+                    event = ChainEventError.model_validate_json(stream_event.data)
+                    raise ApiError(
+                        status=500,
+                        code=ApiErrorCodes.AIRunError,
+                        message=event.error.message,
+                        response=stream_event.data,
+                    )
+
+                else:
+                    raise ApiError(
+                        status=500,
+                        code=ApiErrorCodes.InternalServerError,
+                        message=f"Unknown latitude event: {type}",
+                        response=f"Unknown latitude event: {type}",
+                    )
+
+            elif stream_event.event == str(StreamEvents.Provider):
+                event = stream_event.json()
+                event["event"] = StreamEvents.Provider
+
+            else:
+                raise ApiError(
+                    status=500,
+                    code=ApiErrorCodes.InternalServerError,
+                    message=f"Unknown stream event: {stream_event.event}",
+                    response=f"Unknown stream event: {stream_event.event}",
+                )
+
+            if callbacks.on_event:
+                callbacks.on_event(event)
+
+        if not uuid or not response:
+            raise ApiError(
+                status=500,
+                code=ApiErrorCodes.InternalServerError,
+                message="Stream ended without a chain-complete event. Missing uuid or response.",
+                response="Stream ended without a chain-complete event. Missing uuid or response.",
+            )
+
+        # NOTE: FinishedEvent not in on_event
+        return FinishedEvent(uuid=uuid, conversation=conversation, response=response)
+
+    async def get(self, path: str, options: GetPromptOptions) -> GetPromptResult:
+        prompt_options = self._ensure_options(options)
+        options = GetPromptOptions(**{**dict(options), **dict(prompt_options)})
+
+        assert options.project_id is not None
+
+        async with self._client.request(
+            handler=RequestHandler.GetPrompt,
+            params=GetPromptRequestParams(
+                project_id=options.project_id,
+                version_uuid=options.version_uuid,
+                path=path,
+            ),
+        ) as response:
+            return GetPromptResult.model_validate_json(response.content)
+
+    async def get_or_create(self, path: str, options: GetOrCreatePromptOptions) -> GetOrCreatePromptResult:
+        prompt_options = self._ensure_options(options)
+        options = GetOrCreatePromptOptions(**{**dict(options), **dict(prompt_options)})
+
+        assert options.project_id is not None
+
+        async with self._client.request(
+            handler=RequestHandler.GetOrCreatePrompt,
+            params=GetOrCreatePromptRequestParams(
+                project_id=options.project_id,
+                version_uuid=options.version_uuid,
+            ),
+            body=GetOrCreatePromptRequestBody(
+                path=path,
+                prompt=options.prompt,
+            ),
+        ) as response:
+            return GetOrCreatePromptResult.model_validate_json(response.content)
+
+    async def run(self, path: str, options: RunPromptOptions) -> Optional[RunPromptResult]:
+        try:
+            prompt_options = self._ensure_options(options)
+            options = RunPromptOptions(**{**dict(options), **dict(prompt_options)})
+
+            assert options.project_id is not None
+
+            async with self._client.request(
+                handler=RequestHandler.RunPrompt,
+                params=RunPromptRequestParams(
+                    project_id=options.project_id,
+                    version_uuid=options.version_uuid,
+                ),
+                body=RunPromptRequestBody(
+                    path=path,
+                    parameters=options.parameters,
+                    custom_identifier=options.custom_identifier,
+                    stream=options.stream,
+                ),
+            ) as response:
+                if options.stream:
+                    result = await self._handle_stream(
+                        response.sse(),
+                        callbacks=StreamCallbacks(
+                            on_event=options.on_event,
+                            on_finished=options.on_finished,
+                            on_error=options.on_error,
+                        ),
+                    )
+                else:
+                    result = RunPromptResult.model_validate_json(response.content)
+
+                if options.on_finished:
+                    options.on_finished(FinishedEvent(**dict(result)))
+
+                return RunPromptResult(**dict(result))
+
+        except Exception as exception:
+            if not isinstance(exception, ApiError):
+                exception = ApiError(
+                    status=500,
+                    code=ApiErrorCodes.InternalServerError,
+                    message=str(exception),
+                    response=str(exception),
+                )
+
+            if not options.on_error:
+                raise exception
+
+            options.on_error(exception)
+
+            return None
+
+    async def chat(self, uuid: str, messages: List[Message], options: ChatPromptOptions) -> Optional[ChatPromptResult]:
+        try:
+            async with self._client.request(
+                handler=RequestHandler.ChatPrompt,
+                params=ChatPromptRequestParams(
+                    conversation_uuid=uuid,
+                ),
+                body=ChatPromptRequestBody(
+                    messages=messages,
+                    stream=options.stream,
+                ),
+            ) as response:
+                if options.stream:
+                    result = await self._handle_stream(
+                        response.sse(),
+                        callbacks=StreamCallbacks(
+                            on_event=options.on_event,
+                            on_finished=options.on_finished,
+                            on_error=options.on_error,
+                        ),
+                    )
+                else:
+                    result = ChatPromptResult.model_validate_json(response.content)
+
+                if options.on_finished:
+                    options.on_finished(FinishedEvent(**dict(result)))
+
+                return ChatPromptResult(**dict(result))
+
+        except Exception as exception:
+            if not isinstance(exception, ApiError):
+                exception = ApiError(
+                    status=500,
+                    code=ApiErrorCodes.InternalServerError,
+                    message=str(exception),
+                    response=str(exception),
+                )
+
+            if not options.on_error:
+                raise exception
+
+            options.on_error(exception)
+
+            return None
+
+    # TODO: render - needs PromptL in Python
+
+    # TODO: render_chain - needs PromptL in Python

latitude_sdk/sdk/types.py

@@ -0,0 +1,296 @@
+from datetime import datetime
+from typing import Any, Dict, List, Optional, Protocol, Union, runtime_checkable
+
+from latitude_sdk.sdk.errors import ApiError
+from latitude_sdk.util import Field, Model, StrEnum
+
+
+class DbErrorRef(Model):
+    entity_uuid: str = Field(alias=str("entityUuid"))
+    entity_type: str = Field(alias=str("entityType"))
+
+
+class Providers(StrEnum):
+    OpenAI = "openai"
+    Anthropic = "anthropic"
+    Groq = "groq"
+    Mistral = "mistral"
+    Azure = "azure"
+    Google = "google"
+    Custom = "custom"
+
+
+class Prompt(Model):
+    uuid: str
+    path: str
+    content: str
+    config: Dict[str, Any]
+    provider: Optional[Providers] = None
+
+
+class ContentType(StrEnum):
+    Text = "text"
+    Image = "image"
+    File = "file"
+    ToolCall = "tool-call"
+    ToolResult = "tool-result"
+
+
+class TextContent(Model):
+    type: ContentType = ContentType.Text
+    text: str
+
+
+class ImageContent(Model):
+    type: ContentType = ContentType.Image
+    image: str
+
+
+class FileContent(Model):
+    type: ContentType = ContentType.File
+    file: str
+    mime_type: str = Field(alias=str("mimeType"))
+
+
+class ToolCallContent(Model):
+    type: ContentType = ContentType.ToolCall
+    tool_call_id: str = Field(alias=str("toolCallId"))
+    tool_name: str = Field(alias=str("toolName"))
+    args: Dict[str, Any]
+
+
+class ToolResultContent(Model):
+    type: ContentType = ContentType.ToolResult
+    tool_call_id: str = Field(alias=str("toolCallId"))
+    tool_name: str = Field(alias=str("toolName"))
+    result: str
+    is_error: Optional[bool] = Field(None, alias=str("isError"))
+
+
+MessageContent = Union[
+    str,
+    List[TextContent],
+    List[ImageContent],
+    List[FileContent],
+    List[ToolCallContent],
+    List[ToolResultContent],
+]
+
+
+class MessageRole(StrEnum):
+    System = "system"
+    User = "user"
+    Assistant = "assistant"
+    Tool = "tool"
+
+
+class SystemMessage(Model):
+    role: MessageRole = MessageRole.System
+    content: Union[str, List[TextContent]]
+
+
+class UserMessage(Model):
+    role: MessageRole = MessageRole.User
+    content: Union[str, List[TextContent], List[ImageContent], List[FileContent]]
+    name: Optional[str] = None
+
+
+class ToolCall(Model):
+    id: str
+    name: str
+    arguments: Dict[str, Any]
+
+
+class AssistantMessage(Model):
+    role: MessageRole = MessageRole.Assistant
+    content: Union[str, List[TextContent], List[ToolCallContent]]
+    tool_calls: Optional[List[ToolCall]] = Field(None, alias=str("toolCalls"))
+
+
+class ToolMessage(Model):
+    role: MessageRole = MessageRole.Tool
+    content: List[ToolResultContent]
+
+
+Message = Union[SystemMessage, UserMessage, AssistantMessage, ToolMessage]
+
+
+class ModelUsage(Model):
+    prompt_tokens: int = Field(alias=str("promptTokens"))
+    completion_tokens: int = Field(alias=str("completionTokens"))
+    total_tokens: int = Field(alias=str("totalTokens"))
+
+
+class StreamTypes(StrEnum):
+    Text = "text"
+    Object = "object"
+
+
+class ChainTextResponse(Model):
+    type: StreamTypes = StreamTypes.Text
+    text: str
+    tool_calls: Optional[List[ToolCall]] = Field(None, alias=str("toolCalls"))
+    usage: ModelUsage
+
+
+class ChainObjectResponse(Model):
+    type: StreamTypes = StreamTypes.Object
+    object: Any
+    usage: ModelUsage
+
+
+ChainResponse = Union[ChainTextResponse, ChainObjectResponse]
+
+
+class ChainError(Model):
+    name: str
+    message: str
+    stack: Optional[str] = None
+
+
+class StreamEvents(StrEnum):
+    Latitude = "latitude-event"
+    Provider = "provider-event"
+    Finished = "finished-event"
+
+
+ProviderEvent = Dict[str, Any]
+
+
+class ChainEvents(StrEnum):
+    Step = "chain-step"
+    StepCompleted = "chain-step-complete"
+    Completed = "chain-complete"
+    Error = "chain-error"
+
+
+class ChainEventStep(Model):
+    event: StreamEvents = StreamEvents.Latitude
+    type: ChainEvents = ChainEvents.Step
+    config: Dict[str, Any]
+    is_last_step: bool = Field(alias=str("isLastStep"))
+    messages: List[Message]
+    uuid: Optional[str] = None
+
+
+class ChainEventStepCompleted(Model):
+    event: StreamEvents = StreamEvents.Latitude
+    type: ChainEvents = ChainEvents.StepCompleted
+    response: ChainResponse
+    uuid: Optional[str] = None
+
+
+class ChainEventCompleted(Model):
+    event: StreamEvents = StreamEvents.Latitude
+    type: ChainEvents = ChainEvents.Completed
+    config: Dict[str, Any]
+    messages: Optional[List[Message]] = None
+    object: Optional[Any] = None
+    response: ChainResponse
+    uuid: Optional[str] = None
+
+
+class ChainEventError(Model):
+    event: StreamEvents = StreamEvents.Latitude
+    type: ChainEvents = ChainEvents.Error
+    error: ChainError
+
+
+ChainEvent = Union[ChainEventStep, ChainEventStepCompleted, ChainEventCompleted, ChainEventError]
+
+
+LatitudeEvent = ChainEvent
+
+
+class FinishedEvent(Model):
+    event: StreamEvents = StreamEvents.Finished
+    uuid: str
+    conversation: List[Message]
+    response: ChainResponse
+
+
+StreamEvent = Union[ProviderEvent, LatitudeEvent, FinishedEvent]
+
+
+class LogSources(StrEnum):
+    Api = "api"
+    Playground = "playground"
+    Evaluation = "evaluation"
+    User = "user"
+    SharedPrompt = "shared_prompt"
+
+
+class Log(Model):
+    id: int
+    uuid: str
+    source: Optional[LogSources] = None
+    commit_id: int = Field(alias=str("commitId"))
+    resolved_content: str = Field(alias=str("resolvedContent"))
+    content_hash: str = Field(alias=str("contentHash"))
+    parameters: Dict[str, Any]
+    custom_identifier: Optional[str] = Field(None, alias=str("customIdentifier"))
+    duration: Optional[int] = None
+    created_at: datetime = Field(alias=str("createdAt"))
+    updated_at: datetime = Field(alias=str("updatedAt"))
+
+
+class EvaluationResultType(StrEnum):
+    Boolean = "evaluation_resultable_booleans"
+    Text = "evaluation_resultable_texts"
+    Number = "evaluation_resultable_numbers"
+
+
+class EvaluationResult(Model):
+    id: int
+    uuid: str
+    evaluation_id: int = Field(alias=str("evaluationId"))
+    document_log_id: int = Field(alias=str("documentLogId"))
+    evaluated_provider_log_id: Optional[int] = Field(None, alias=str("evaluatedProviderLogId"))
+    evaluation_provider_log_id: Optional[int] = Field(None, alias=str("evaluationProviderLogId"))
+    resultable_type: Optional[EvaluationResultType] = Field(None, alias=str("resultableType"))
+    resultable_id: Optional[int] = Field(None, alias=str("resultableId"))
+    result: Optional[Union[str, bool, int]] = None
+    source: Optional[LogSources] = None
+    reason: Optional[str] = None
+    created_at: datetime = Field(alias=str("createdAt"))
+    updated_at: datetime = Field(alias=str("updatedAt"))
+
+
+class StreamCallbacks(Model):
+    @runtime_checkable
+    class OnEvent(Protocol):
+        def __call__(self, event: StreamEvent): ...
+
+    on_event: Optional[OnEvent] = None
+
+    @runtime_checkable
+    class OnFinished(Protocol):
+        def __call__(self, event: FinishedEvent): ...
+
+    on_finished: Optional[OnFinished] = None
+
+    @runtime_checkable
+    class OnError(Protocol):
+        def __call__(self, error: ApiError): ...
+
+    on_error: Optional[OnError] = None
+
+
+class SdkOptions(Model):
+    project_id: Optional[int] = None
+    version_uuid: Optional[str] = None
+
+
+class GatewayOptions(Model):
+    host: str
+    port: int
+    ssl: bool
+    api_version: str
+
+    @property
+    def protocol(self) -> str:
+        return "https" if self.ssl else "http"
+
+    @property
+    def base_url(self) -> str:
+        return f"{self.protocol}://{self.host}:{self.port}/api/{self.api_version}"

latitude_sdk/util/__init__.py

@@ -0,0 +1 @@
+from .utils import *

latitude_sdk/util/utils.py

@@ -0,0 +1,87 @@
+import os
+from enum import Enum
+from typing import Any, Callable, List, TypeVar
+
+import pydantic
+from typing_extensions import ParamSpec
+
+T = TypeVar("T", str, bool, int, List[str])
+
+
+def get_env(key: str, default: T) -> T:
+    value = os.getenv(key)
+    if not value:
+        return default
+
+    if isinstance(default, str):
+        return value
+
+    elif isinstance(default, bool):
+        return value.lower() in ["true", "1", "yes", "on"]
+
+    elif isinstance(default, int):
+        return int(value)
+
+    elif isinstance(default, list):
+        return value.split(",")
+
+    raise TypeError(f"Unknown type {type(default)}")
+
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+
+def returns_identity(x: R) -> R:
+    return x
+
+
+def is_like(func: Callable[P, R]) -> Callable[[Callable[..., Any]], Callable[P, R]]:
+    return returns_identity  # type: ignore
+
+
+def returns_like(func: Callable[..., R]) -> Callable[[Callable[P, Any]], Callable[P, R]]:
+    return returns_identity  # type: ignore
+
+
+class StrEnum(str, Enum):
+    def __str__(self) -> str:
+        return str(self.value)
+
+    @classmethod
+    def list(cls) -> List[str]:
+        return [v.value for v in cls]
+
+
+Field = pydantic.Field
+Config = pydantic.ConfigDict
+
+
+class Model(pydantic.BaseModel):
+    model_config = Config(populate_by_name=True, arbitrary_types_allowed=True, strict=True)
+
+    @is_like(pydantic.BaseModel.__iter__)
+    def __iter__(self) -> Any:
+        yield from [(k, v) for k, v in super().__iter__() if v is not None]
+
+    @is_like(pydantic.BaseModel.model_dump)
+    def model_dump(self, *args: Any, **kwargs: Any) -> Any:
+        exclude_none = kwargs.pop("exclude_none", True)
+        return super().model_dump(*args, exclude_none=exclude_none, **kwargs)
+
+    @is_like(pydantic.BaseModel.dict)  # pyright: ignore [reportDeprecated]
+    def dict(self, *args: Any, **kwargs: Any) -> Any:
+        exclude_none = kwargs.pop("exclude_none", True)
+        return super().dict(*args, exclude_none=exclude_none, **kwargs)  # pyright: ignore [reportDeprecated]
+
+    @is_like(pydantic.BaseModel.model_dump_json)
+    def model_dump_json(self, *args: Any, **kwargs: Any) -> Any:
+        exclude_none = kwargs.pop("exclude_none", True)
+        by_alias = kwargs.pop("by_alias", True)
+        return super().model_dump_json(*args, exclude_none=exclude_none, by_alias=by_alias, **kwargs)
+
+    @is_like(pydantic.BaseModel.json)  # pyright: ignore [reportDeprecated]
+    def json(self, *args: Any, **kwargs: Any) -> Any:
+        exclude_none = kwargs.pop("exclude_none", True)
+        by_alias = kwargs.pop("by_alias", True)
+        return super().json(*args, exclude_none=exclude_none, by_alias=by_alias, **kwargs)  # pyright: ignore [reportDeprecated]