latitude-sdk 0.1.0b3__tar.gz → 0.1.0b5__tar.gz

{latitude_sdk-0.1.0b3 → latitude_sdk-0.1.0b5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: latitude-sdk
-Version: 0.1.0b3
+Version: 0.1.0b5
 Summary: Latitude SDK for Python
 Project-URL: repository, https://github.com/latitude-dev/latitude-llm/tree/main/packages/sdks/python
 Project-URL: homepage, https://github.com/latitude-dev/latitude-llm/tree/main/packages/sdks/python#readme

{latitude_sdk-0.1.0b3 → latitude_sdk-0.1.0b5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "latitude-sdk"
-version = "0.1.0-beta.3"
+version = "0.1.0-beta.5"
 description = "Latitude SDK for Python"
 authors = [{ name = "Latitude Data SL", email = "hello@latitude.so" }]
 maintainers = [{ name = "Latitude Data SL", email = "hello@latitude.so" }]
@@ -22,6 +22,7 @@ dev = [
     "pytest-asyncio>=0.24.0",
     "pytest-xdist>=3.6.1",
     "pytest>=8.3.4",
+    "respx>=0.22.0",
     "pyright>=1.1.391",
     "ruff>=0.8.3",
     "sh>=1.14.3",

{latitude_sdk-0.1.0b3 → latitude_sdk-0.1.0b5}/src/latitude_sdk/client/client.py

@@ -16,7 +16,7 @@ from latitude_sdk.sdk.errors import (
 from latitude_sdk.sdk.types import LogSources
 from latitude_sdk.util import Model
 
-RETRIABLE_STATUSES = [429, 500, 502, 503, 504]
+RETRIABLE_STATUSES = [408, 409, 429, 500, 502, 503, 504]
 
 ClientEvent = httpx_sse.ServerSentEvent
 

{latitude_sdk-0.1.0b3 → latitude_sdk-0.1.0b5}/src/latitude_sdk/env/env.py

@@ -1,7 +1,7 @@
 from latitude_sdk.util import Model, get_env
 
 DEFAULT_GATEWAY_HOSTNAME = "gateway.latitude.so"
-DEFAULT_GATEWAY_PORT = 8787
+DEFAULT_GATEWAY_PORT = 443
 DEFAULT_GATEWAY_SSL = True
 
 

{latitude_sdk-0.1.0b3 → latitude_sdk-0.1.0b5}/src/latitude_sdk/sdk/errors.py

@@ -57,3 +57,13 @@ class ApiError(Exception):
             return f"Unexpected API Error: {status} {message}"
 
         return message
+
+    def __eq__(self, other: object) -> bool:
+        return (
+            isinstance(other, ApiError)
+            and self.status == other.status
+            and self.code == other.code
+            and self.message == other.message
+            and self.response == other.response
+            and self.db_ref == other.db_ref
+        )

{latitude_sdk-0.1.0b3 → latitude_sdk-0.1.0b5}/src/latitude_sdk/sdk/logs.py

@@ -1,4 +1,4 @@
-from typing import List, Optional
+from typing import Iterable, Optional
 
 from latitude_sdk.client import Client, CreateLogRequestBody, CreateLogRequestParams, RequestHandler
 from latitude_sdk.sdk.errors import ApiError, ApiErrorCodes
@@ -45,7 +45,7 @@ class Logs:
 
         return LogOptions(project_id=project_id, version_uuid=version_uuid)
 
-    async def create(self, path: str, messages: List[Message], options: CreateLogOptions) -> CreateLogResult:
+    async def create(self, path: str, messages: Iterable[Message], options: CreateLogOptions) -> CreateLogResult:
         log_options = self._ensure_options(options)
         options = CreateLogOptions(**{**dict(options), **dict(log_options)})
 
@@ -59,7 +59,7 @@ class Logs:
             ),
             body=CreateLogRequestBody(
                 path=path,
-                messages=messages,
+                messages=list(messages),
                 response=options.response,
             ),
         ) as response:

{latitude_sdk-0.1.0b3 → latitude_sdk-0.1.0b5}/src/latitude_sdk/sdk/prompts.py

@@ -1,4 +1,4 @@
-from typing import Any, AsyncGenerator, Dict, List, Optional
+from typing import Any, AsyncGenerator, Dict, Iterable, List, Optional
 
 from latitude_sdk.client import (
     ChatPromptRequestBody,
@@ -119,7 +119,7 @@ class Prompts:
                 elif type == str(ChainEvents.Error):
                     event = ChainEventError.model_validate_json(stream_event.data)
                     raise ApiError(
-                        status=500,
+                        status=400,
                         code=ApiErrorCodes.AIRunError,
                         message=event.error.message,
                         response=stream_event.data,
@@ -130,7 +130,7 @@ class Prompts:
                         status=500,
                         code=ApiErrorCodes.InternalServerError,
                         message=f"Unknown latitude event: {type}",
-                        response=f"Unknown latitude event: {type}",
+                        response=stream_event.data,
                     )
 
             elif stream_event.event == str(StreamEvents.Provider):
@@ -142,7 +142,7 @@ class Prompts:
                     status=500,
                     code=ApiErrorCodes.InternalServerError,
                     message=f"Unknown stream event: {stream_event.event}",
-                    response=f"Unknown stream event: {stream_event.event}",
+                    response=stream_event.data,
                 )
 
             if callbacks.on_event:
@@ -247,7 +247,9 @@ class Prompts:
 
             return None
 
-    async def chat(self, uuid: str, messages: List[Message], options: ChatPromptOptions) -> Optional[ChatPromptResult]:
+    async def chat(
+        self, uuid: str, messages: Iterable[Message], options: ChatPromptOptions
+    ) -> Optional[ChatPromptResult]:
         try:
             async with self._client.request(
                 handler=RequestHandler.ChatPrompt,
@@ -255,7 +257,7 @@ class Prompts:
                     conversation_uuid=uuid,
                 ),
                 body=ChatPromptRequestBody(
-                    messages=messages,
+                    messages=list(messages),
                     stream=options.stream,
                 ),
             ) as response:

{latitude_sdk-0.1.0b3 → latitude_sdk-0.1.0b5}/src/latitude_sdk/sdk/types.py

@@ -1,5 +1,5 @@
 from datetime import datetime
-from typing import Any, Dict, List, Optional, Protocol, Union, runtime_checkable
+from typing import Any, Dict, List, Literal, Optional, Protocol, Union, runtime_checkable
 
 from latitude_sdk.sdk.errors import ApiError
 from latitude_sdk.util import Field, Model, StrEnum
@@ -37,32 +37,32 @@ class ContentType(StrEnum):
 
 
 class TextContent(Model):
-    type: ContentType = ContentType.Text
+    type: Literal[ContentType.Text] = ContentType.Text
     text: str
 
 
 class ImageContent(Model):
-    type: ContentType = ContentType.Image
+    type: Literal[ContentType.Image] = ContentType.Image
     image: str
 
 
 class FileContent(Model):
-    type: ContentType = ContentType.File
+    type: Literal[ContentType.File] = 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]
+    type: Literal[ContentType.ToolCall] = ContentType.ToolCall
+    id: str = Field(alias=str("toolCallId"))
+    name: str = Field(alias=str("toolName"))
+    arguments: Dict[str, Any] = Field(alias=str("args"))
 
 
 class ToolResultContent(Model):
-    type: ContentType = ContentType.ToolResult
-    tool_call_id: str = Field(alias=str("toolCallId"))
-    tool_name: str = Field(alias=str("toolName"))
+    type: Literal[ContentType.ToolResult] = ContentType.ToolResult
+    id: str = Field(alias=str("toolCallId"))
+    name: str = Field(alias=str("toolName"))
     result: str
     is_error: Optional[bool] = Field(default=None, alias=str("isError"))
 
@@ -85,30 +85,23 @@ class MessageRole(StrEnum):
 
 
 class SystemMessage(Model):
-    role: MessageRole = MessageRole.System
+    role: Literal[MessageRole.System] = MessageRole.System
     content: Union[str, List[TextContent]]
 
 
 class UserMessage(Model):
-    role: MessageRole = MessageRole.User
+    role: Literal[MessageRole.User] = MessageRole.User
     content: Union[str, List[Union[TextContent, ImageContent, FileContent]]]
     name: Optional[str] = None
 
 
-class ToolCall(Model):
-    id: str
-    name: str
-    arguments: Dict[str, Any]
-
-
 class AssistantMessage(Model):
-    role: MessageRole = MessageRole.Assistant
+    role: Literal[MessageRole.Assistant] = MessageRole.Assistant
     content: Union[str, List[Union[TextContent, ToolCallContent]]]
-    tool_calls: Optional[List[ToolCall]] = Field(default=None, alias=str("toolCalls"))
 
 
 class ToolMessage(Model):
-    role: MessageRole = MessageRole.Tool
+    role: Literal[MessageRole.Tool] = MessageRole.Tool
     content: List[ToolResultContent]
 
 
@@ -121,20 +114,26 @@ class ModelUsage(Model):
     total_tokens: int = Field(alias=str("totalTokens"))
 
 
+class ToolCall(Model):
+    id: str
+    name: str
+    arguments: Dict[str, Any]
+
+
 class StreamTypes(StrEnum):
     Text = "text"
     Object = "object"
 
 
 class ChainTextResponse(Model):
-    type: StreamTypes = StreamTypes.Text
+    type: Literal[StreamTypes.Text] = Field(default=StreamTypes.Text, alias=str("streamType"))
     text: str
     tool_calls: Optional[List[ToolCall]] = Field(default=None, alias=str("toolCalls"))
     usage: ModelUsage
 
 
 class ChainObjectResponse(Model):
-    type: StreamTypes = StreamTypes.Object
+    type: Literal[StreamTypes.Object] = Field(default=StreamTypes.Object, alias=str("streamType"))
     object: Any
     usage: ModelUsage
 
@@ -165,34 +164,34 @@ class ChainEvents(StrEnum):
 
 
 class ChainEventStep(Model):
-    event: StreamEvents = StreamEvents.Latitude
-    type: ChainEvents = ChainEvents.Step
-    config: Dict[str, Any]
+    event: Literal[StreamEvents.Latitude] = StreamEvents.Latitude
+    type: Literal[ChainEvents.Step] = ChainEvents.Step
+    uuid: Optional[str] = None
     is_last_step: bool = Field(alias=str("isLastStep"))
+    config: Dict[str, Any]
     messages: List[Message]
-    uuid: Optional[str] = None
 
 
 class ChainEventStepCompleted(Model):
-    event: StreamEvents = StreamEvents.Latitude
-    type: ChainEvents = ChainEvents.StepCompleted
-    response: ChainResponse
+    event: Literal[StreamEvents.Latitude] = StreamEvents.Latitude
+    type: Literal[ChainEvents.StepCompleted] = ChainEvents.StepCompleted
     uuid: Optional[str] = None
+    response: ChainResponse
 
 
 class ChainEventCompleted(Model):
-    event: StreamEvents = StreamEvents.Latitude
-    type: ChainEvents = ChainEvents.Completed
+    event: Literal[StreamEvents.Latitude] = StreamEvents.Latitude
+    type: Literal[ChainEvents.Completed] = ChainEvents.Completed
+    uuid: Optional[str] = None
     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
+    event: Literal[StreamEvents.Latitude] = StreamEvents.Latitude
+    type: Literal[ChainEvents.Error] = ChainEvents.Error
     error: ChainError
 
 
@@ -203,7 +202,7 @@ LatitudeEvent = ChainEvent
 
 
 class FinishedEvent(Model):
-    event: StreamEvents = StreamEvents.Finished
+    event: Literal[StreamEvents.Finished] = StreamEvents.Finished
     uuid: str
     conversation: List[Message]
     response: ChainResponse

latitude_sdk-0.1.0b5/tests/evaluations/create_result_test.py

@@ -0,0 +1,59 @@
+from typing import List, cast
+
+import httpx
+
+from latitude_sdk import CreateEvaluationResultOptions, CreateEvaluationResultResult
+from tests.utils import TestCase, fixtures
+
+
+class TestCreateEvaluationResult(TestCase):
+    async def test_success(self):
+        conversation_uuid = "conversation-uuid"
+        evaluation_uuid = "evaluation-uuid"
+        options = CreateEvaluationResultOptions(result=True, reason="Because Yes")
+        endpoint = f"/conversations/{conversation_uuid}/evaluations/{evaluation_uuid}/evaluation-results"
+        endpoint_mock = self.gateway_mock.post(endpoint).mock(
+            return_value=httpx.Response(200, json=fixtures.EVALUATION_RESULT_RESPONSE)
+        )
+
+        result = await self.sdk.evaluations.create_result(conversation_uuid, evaluation_uuid, options)
+        request, _ = endpoint_mock.calls.last
+
+        self.assert_requested(
+            request,
+            method="POST",
+            endpoint=endpoint,
+            body={
+                "result": options.result,
+                "reason": options.reason,
+            },
+        )
+        self.assertEqual(endpoint_mock.call_count, 1)
+        self.assertEqual(result, CreateEvaluationResultResult(**dict(fixtures.EVALUATION_RESULT)))
+
+    async def test_fails(self):
+        conversation_uuid = "conversation-uuid"
+        evaluation_uuid = "evaluation-uuid"
+        options = CreateEvaluationResultOptions(result=True, reason="Because Yes")
+        endpoint = f"/conversations/{conversation_uuid}/evaluations/{evaluation_uuid}/evaluation-results"
+        endpoint_mock = self.gateway_mock.post(endpoint).mock(
+            return_value=httpx.Response(500, json=fixtures.ERROR_RESPONSE)
+        )
+
+        with self.assertRaisesRegex(type(fixtures.ERROR), fixtures.ERROR.message):
+            await self.sdk.evaluations.create_result(conversation_uuid, evaluation_uuid, options)
+        requests = cast(List[httpx.Request], [request for request, _ in endpoint_mock.calls])  # type: ignore
+
+        [
+            self.assert_requested(
+                request,
+                method="POST",
+                endpoint=endpoint,
+                body={
+                    "result": options.result,
+                    "reason": options.reason,
+                },
+            )
+            for request in requests
+        ]
+        self.assertEqual(endpoint_mock.call_count, self.internal_options.retries)

latitude_sdk-0.1.0b5/tests/evaluations/trigger_test.py

@@ -0,0 +1,53 @@
+from typing import List, cast
+
+import httpx
+
+from latitude_sdk import TriggerEvaluationOptions, TriggerEvaluationResult
+from tests.utils import TestCase, fixtures
+
+
+class TestTriggerEvaluation(TestCase):
+    async def test_success(self):
+        conversation_uuid = "conversation-uuid"
+        options = TriggerEvaluationOptions(evaluation_uuids=["evaluation-uuid-1", "evaluation-uuid-2"])
+        endpoint = f"/conversations/{conversation_uuid}/evaluate"
+        endpoint_mock = self.gateway_mock.post(endpoint).mock(
+            return_value=httpx.Response(200, json=fixtures.EVALUATIONS_RESPONSE)
+        )
+
+        result = await self.sdk.evaluations.trigger(conversation_uuid, options)
+        request, _ = endpoint_mock.calls.last
+
+        self.assert_requested(
+            request,
+            method="POST",
+            endpoint=endpoint,
+            body={
+                "evaluationUuids": options.evaluation_uuids,
+            },
+        )
+        self.assertEqual(endpoint_mock.call_count, 1)
+        self.assertEqual(result, TriggerEvaluationResult(evaluations=fixtures.EVALUATIONS))
+
+    async def test_fails(self):
+        conversation_uuid = "conversation-uuid"
+        options = TriggerEvaluationOptions()
+        endpoint = f"/conversations/{conversation_uuid}/evaluate"
+        endpoint_mock = self.gateway_mock.post(endpoint).mock(
+            return_value=httpx.Response(500, json=fixtures.ERROR_RESPONSE)
+        )
+
+        with self.assertRaisesRegex(type(fixtures.ERROR), fixtures.ERROR.message):
+            await self.sdk.evaluations.trigger(conversation_uuid, options)
+        requests = cast(List[httpx.Request], [request for request, _ in endpoint_mock.calls])  # type: ignore
+
+        [
+            self.assert_requested(
+                request,
+                method="POST",
+                endpoint=endpoint,
+                body={},
+            )
+            for request in requests
+        ]
+        self.assertEqual(endpoint_mock.call_count, self.internal_options.retries)

latitude_sdk-0.1.0b5/tests/logs/create_test.py

@@ -0,0 +1,113 @@
+import json
+from typing import List, cast
+
+import httpx
+
+from latitude_sdk import CreateLogOptions, CreateLogResult
+from tests.utils import TestCase, fixtures
+
+
+class TestCreateLog(TestCase):
+    async def test_success_global_options(self):
+        path = "prompt-path"
+        messages = self.create_conversation(4)
+        options = CreateLogOptions(response="response")
+        endpoint = f"/projects/{self.project_id}/versions/{self.version_uuid}/documents/logs"
+        endpoint_mock = self.gateway_mock.post(endpoint).mock(
+            return_value=httpx.Response(200, json=fixtures.LOG_RESPONSE)
+        )
+
+        result = await self.sdk.logs.create(path, messages, options)
+        request, _ = endpoint_mock.calls.last
+
+        self.assert_requested(
+            request,
+            method="POST",
+            endpoint=endpoint,
+            body={
+                "path": path,
+                "messages": [json.loads(message.model_dump_json()) for message in messages],
+                "response": options.response,
+            },
+        )
+        self.assertEqual(endpoint_mock.call_count, 1)
+        self.assertEqual(result, CreateLogResult(**dict(fixtures.LOG)))
+
+    async def test_success_overrides_options(self):
+        path = "prompt-path"
+        messages = self.create_conversation(4)
+        options = CreateLogOptions(project_id=21, version_uuid="version-uuid", response="response")
+        endpoint = f"/projects/{options.project_id}/versions/{options.version_uuid}/documents/logs"
+        endpoint_mock = self.gateway_mock.post(endpoint).mock(
+            return_value=httpx.Response(200, json=fixtures.LOG_RESPONSE)
+        )
+
+        result = await self.sdk.logs.create(path, messages, options)
+        request, _ = endpoint_mock.calls.last
+
+        self.assert_requested(
+            request,
+            method="POST",
+            endpoint=endpoint,
+            body={
+                "path": path,
+                "messages": [json.loads(message.model_dump_json()) for message in messages],
+                "response": options.response,
+            },
+        )
+        self.assertEqual(endpoint_mock.call_count, 1)
+        self.assertEqual(result, CreateLogResult(**dict(fixtures.LOG)))
+
+    async def test_success_default_version_uuid(self):
+        self.sdk._options.version_uuid = None  # pyright: ignore [reportPrivateUsage]
+        path = "prompt-path"
+        messages = self.create_conversation(4)
+        options = CreateLogOptions(response="response")
+        endpoint = f"/projects/{self.project_id}/versions/live/documents/logs"
+        endpoint_mock = self.gateway_mock.post(endpoint).mock(
+            return_value=httpx.Response(200, json=fixtures.LOG_RESPONSE)
+        )
+
+        result = await self.sdk.logs.create(path, messages, options)
+        request, _ = endpoint_mock.calls.last
+
+        self.assert_requested(
+            request,
+            method="POST",
+            endpoint=endpoint,
+            body={
+                "path": path,
+                "messages": [json.loads(message.model_dump_json()) for message in messages],
+                "response": options.response,
+            },
+        )
+        self.assertEqual(endpoint_mock.call_count, 1)
+        self.assertEqual(result, CreateLogResult(**dict(fixtures.LOG)))
+
+    async def test_fails(self):
+        path = "prompt-path"
+        messages = self.create_conversation(4)
+        options = CreateLogOptions(response="response")
+        endpoint = f"/projects/{self.project_id}/versions/{self.version_uuid}/documents/logs"
+        endpoint_mock = self.gateway_mock.post(endpoint).mock(
+            return_value=httpx.Response(500, json=fixtures.ERROR_RESPONSE)
+        )
+
+        with self.assertRaisesRegex(type(fixtures.ERROR), fixtures.ERROR.message):
+            await self.sdk.logs.create(path, messages, options)
+        requests = cast(List[httpx.Request], [request for request, _ in endpoint_mock.calls])  # type: ignore
+
+        [
+            self.assert_requested(
+                request,
+                method="POST",
+                endpoint=endpoint,
+                body={
+                    "path": path,
+                    "messages": [json.loads(message.model_dump_json()) for message in messages],
+                    "response": options.response,
+                },
+            )
+            for request in requests
+        ]
+        self.assertEqual(endpoint_mock.call_count, self.internal_options.retries)