latitude-sdk 4.0.0b1__tar.gz → 5.0.0b1__tar.gz

{latitude_sdk-4.0.0b1 → latitude_sdk-5.0.0b1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: latitude-sdk
-Version: 4.0.0b1
+Version: 5.0.0b1
 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
@@ -62,7 +62,13 @@ Requires uv `0.5.10` or higher.
 
 ### Running only a specific test
 
-Mark the test with an `only` marker:
+Specify the test inline:
+
+```python
+uv run scripts/test.py <test_path>::<test_case>::<test_name>
+```
+
+Or mark the test with an `only` marker:
 
 ```python
 import pytest
@@ -78,12 +84,6 @@ async def my_test(self):
 uv run scripts/test.py -m only
 ```
 
-Another way is to specify the test in line:
-
-```python
-uv run scripts/test.py <test_path>::<test_case>::<test_name>
-```
-
 ## License
 
 The SDK is licensed under the [MIT License](https://opensource.org/licenses/MIT) - read the [LICENSE](/LICENSE) file for details.

{latitude_sdk-4.0.0b1 → latitude_sdk-5.0.0b1}/README.md

@@ -43,7 +43,13 @@ Requires uv `0.5.10` or higher.
 
 ### Running only a specific test
 
-Mark the test with an `only` marker:
+Specify the test inline:
+
+```python
+uv run scripts/test.py <test_path>::<test_case>::<test_name>
+```
+
+Or mark the test with an `only` marker:
 
 ```python
 import pytest
@@ -59,12 +65,6 @@ async def my_test(self):
 uv run scripts/test.py -m only
 ```
 
-Another way is to specify the test in line:
-
-```python
-uv run scripts/test.py <test_path>::<test_case>::<test_name>
-```
-
 ## License
 
 The SDK is licensed under the [MIT License](https://opensource.org/licenses/MIT) - read the [LICENSE](/LICENSE) file for details.

{latitude_sdk-4.0.0b1 → latitude_sdk-5.0.0b1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "latitude-sdk"
-version = "4.0.0-beta.1"
+version = "5.0.0-beta.1"
 description = "Latitude SDK for Python"
 authors = [{ name = "Latitude Data SL", email = "hello@latitude.so" }]
 maintainers = [{ name = "Latitude Data SL", email = "hello@latitude.so" }]
@@ -27,6 +27,7 @@ dev = [
     "pyright>=1.1.401",
     "ruff>=0.8.3",
     "sh>=1.14.3",
+    "psutil>=7.0.0",
 ]
 
 [tool.pyright]
@@ -35,6 +36,7 @@ typeCheckingMode = "strict"
 reportMissingTypeStubs = false
 reportUnnecessaryIsInstance = false
 reportPrivateUsage = false
+reportPrivateImportUsage = false
 
 [tool.ruff]
 target-version = "py39"

{latitude_sdk-4.0.0b1 → latitude_sdk-5.0.0b1}/scripts/test.py

@@ -4,4 +4,4 @@ from sh import pytest  # type: ignore
 
 files = sys.argv[1:] or ["."]
 
-pytest(*files, _out=sys.stdout)
+pytest("-rs", *files, _out=sys.stdout)

latitude_sdk-5.0.0b1/src/latitude_sdk/__init__.py

@@ -0,0 +1,7 @@
+from .version import version
+
+__version__ = version.pep440
+__version_info__ = version.info
+__version_semver__ = version.semver
+
+from .sdk import *

latitude_sdk-5.0.0b1/src/latitude_sdk/client/client.py

@@ -0,0 +1,147 @@
+import asyncio
+import json
+from contextlib import asynccontextmanager
+from typing import Any, AsyncGenerator, Optional
+
+import httpx
+import httpx_sse
+
+from latitude_sdk.client.payloads import ErrorResponse, RequestBody, RequestHandler, RequestParams
+from latitude_sdk.client.router import Router, RouterOptions
+from latitude_sdk.sdk.errors import ApiError, ApiErrorCodes, ApiErrorDbRef
+from latitude_sdk.sdk.types import LogSources
+from latitude_sdk.util import Model
+from latitude_sdk.version import version
+
+RETRIABLE_STATUSES = [408, 429, 500, 502, 503, 504]
+
+ClientEvent = httpx_sse.ServerSentEvent
+
+
+class ClientResponse(httpx.Response):
+    async def sse(self: httpx.Response) -> AsyncGenerator[ClientEvent, Any]:
+        source = httpx_sse.EventSource(self)
+
+        async for event in source.aiter_sse():
+            yield event
+
+
+httpx.Response.sse = ClientResponse.sse  # pyright: ignore [reportAttributeAccessIssue]
+
+
+class ClientOptions(Model):
+    api_key: str
+    retries: int
+    delay: float
+    timeout: Optional[float]
+    source: LogSources
+    router: RouterOptions
+
+
+class Client:
+    options: ClientOptions
+    router: Router
+
+    def __init__(self, options: ClientOptions):
+        self.options = options
+        self.router = Router(options.router)
+
+    @asynccontextmanager
+    async def request(
+        self,
+        handler: RequestHandler,
+        params: Optional[RequestParams] = None,
+        body: Optional[RequestBody] = None,
+        stream: Optional[bool] = None,
+    ) -> AsyncGenerator[ClientResponse, Any]:
+        client = httpx.AsyncClient(
+            headers={
+                "Authorization": f"Bearer {self.options.api_key}",
+                "X-Latitude-SDK-Version": version.semver,
+                "Content-Type": "application/json",
+                "Accept": "text/event-stream" if stream else "application/json",
+            },
+            timeout=self.options.timeout,
+            follow_redirects=False,
+            max_redirects=0,
+        )
+        response = None
+        attempt = 1
+
+        try:
+            method, url = self.router.resolve(handler, params)
+            content = None
+            if body:
+                content = json.dumps(
+                    {
+                        **json.loads(body.model_dump_json()),
+                        "__internal": {"source": self.options.source},
+                    }
+                )
+
+            while attempt <= self.options.retries:
+                try:
+                    request = client.build_request(method=method, url=url, content=content)
+                    response = await client.send(request=request, stream=stream or False)
+                    response.raise_for_status()
+
+                    yield response  # pyright: ignore [reportReturnType]
+                    break
+
+                except Exception as exception:
+                    if isinstance(exception, ApiError):
+                        raise exception
+
+                    if attempt >= self.options.retries:
+                        raise await self._exception(exception, response) from exception
+
+                    if response and response.status_code in RETRIABLE_STATUSES:
+                        await asyncio.sleep(self.options.delay * (2 ** (attempt - 1)))
+                    else:
+                        raise await self._exception(exception, response) from exception
+
+                finally:
+                    if response:
+                        await response.aclose()
+
+                    attempt += 1
+
+        except Exception as exception:
+            if isinstance(exception, ApiError):
+                raise exception
+
+            raise await self._exception(exception, response) from exception
+
+        finally:
+            await client.aclose()
+
+    async def _exception(self, exception: Exception, response: Optional[httpx.Response] = None) -> ApiError:
+        if not response:
+            return ApiError(
+                status=500,
+                code=ApiErrorCodes.InternalServerError,
+                message=str(exception),
+                response=str(exception),
+            )
+
+        try:
+            if not response.is_stream_consumed:
+                await response.aread()
+
+            error = ErrorResponse.model_validate_json(response.content)
+
+            return ApiError(
+                status=response.status_code,
+                code=error.code,
+                message=error.message,
+                response=response.text,
+                db_ref=ApiErrorDbRef(**dict(error.db_ref)) if error.db_ref else None,
+            )
+
+        except Exception:
+            return ApiError(
+                status=response.status_code,
+                code=ApiErrorCodes.InternalServerError,
+                message=str(exception),
+                response=response.text,
+            )

{latitude_sdk-4.0.0b1 → latitude_sdk-5.0.0b1}/src/latitude_sdk/client/payloads.py

@@ -44,8 +44,8 @@ class RunPromptRequestBody(Model):
     path: str
     parameters: Optional[Dict[str, Any]] = None
     custom_identifier: Optional[str] = Field(default=None, alias=str("customIdentifier"))
-    stream: Optional[bool] = None
     tools: Optional[List[str]] = None
+    stream: Optional[bool] = None
 
 
 class ChatPromptRequestParams(Model):
@@ -54,6 +54,7 @@ class ChatPromptRequestParams(Model):
 
 class ChatPromptRequestBody(Model):
     messages: List[Message]
+    tools: Optional[List[str]] = None
     stream: Optional[bool] = None
 
 
@@ -81,11 +82,10 @@ class AnnotateEvaluationRequestParams(EvaluationRequestParams, Model):
 
 
 class AnnotateEvaluationRequestBody(Model):
-    score: int
-
     class Metadata(Model):
         reason: str
 
+    score: int
     metadata: Optional[Metadata] = None
 
 

{latitude_sdk-4.0.0b1 → latitude_sdk-5.0.0b1}/src/latitude_sdk/sdk/__init__.py

@@ -2,5 +2,6 @@ from .errors import *
 from .evaluations import *
 from .latitude import *
 from .logs import *
+from .projects import *
 from .prompts import *
 from .types import *

{latitude_sdk-4.0.0b1 → latitude_sdk-5.0.0b1}/src/latitude_sdk/sdk/errors.py

@@ -7,6 +7,7 @@ from latitude_sdk.util import Model, StrEnum
 class ApiErrorCodes(StrEnum):
     # LatitudeErrorCodes
     NotFoundError = "NotFoundError"
+    BadRequestError = "BadRequestError"
 
     # RunErrorCodes
     AIRunError = "ai_run_error"

{latitude_sdk-4.0.0b1 → latitude_sdk-5.0.0b1}/src/latitude_sdk/sdk/evaluations.py

@@ -1,5 +1,4 @@
-from datetime import datetime
-from typing import Any, Optional, Union
+from typing import Optional
 
 from latitude_sdk.client import (
     AnnotateEvaluationRequestBody,
@@ -7,24 +6,16 @@ from latitude_sdk.client import (
     Client,
     RequestHandler,
 )
-from latitude_sdk.sdk.types import SdkOptions
-from latitude_sdk.util import Field, Model
+from latitude_sdk.sdk.types import EvaluationResult, SdkOptions
+from latitude_sdk.util import Model
 
 
 class AnnotateEvaluationOptions(Model):
     reason: str
 
 
-class AnnotateEvaluationResult(Model):
-    uuid: str
-    score: int
-    normalized_score: int = Field(alias=str("normalizedScore"))
-    metadata: dict[str, Any]
-    has_passed: bool = Field(alias=str("hasPassed"))
-    created_at: datetime = Field(alias=str("createdAt"))
-    updated_at: datetime = Field(alias=str("updatedAt"))
-    version_uuid: str = Field(alias=str("versionUuid"))
-    error: Optional[Union[str, None]] = None
+class AnnotateEvaluationResult(EvaluationResult, Model):
+    pass
 
 
 class Evaluations:

{latitude_sdk-4.0.0b1 → latitude_sdk-5.0.0b1}/src/latitude_sdk/sdk/latitude.py

@@ -78,6 +78,7 @@ class Latitude:
         )
 
         self.promptl = Promptl(self._options.promptl)
+
         self.projects = Projects(self._client, self._options)
         self.prompts = Prompts(self._client, self.promptl, self._options)
         self.logs = Logs(self._client, self._options)

latitude_sdk-5.0.0b1/src/latitude_sdk/sdk/projects.py

@@ -0,0 +1,35 @@
+from typing import List
+
+from latitude_sdk.client import Client, CreateProjectRequestBody, RequestHandler
+from latitude_sdk.sdk.types import Project, SdkOptions, Version
+from latitude_sdk.util import Adapter as AdapterUtil
+from latitude_sdk.util import Model
+
+_GetAllProjectResults = AdapterUtil[List[Project]](List[Project])
+
+
+class CreateProjectResult(Model):
+    project: Project
+    version: Version
+
+
+class Projects:
+    _options: SdkOptions
+    _client: Client
+
+    def __init__(self, client: Client, options: SdkOptions):
+        self._options = options
+        self._client = client
+
+    async def get_all(self) -> List[Project]:
+        async with self._client.request(
+            handler=RequestHandler.GetAllProjects,
+        ) as response:
+            return _GetAllProjectResults.validate_json(response.content)
+
+    async def create(self, name: str) -> CreateProjectResult:
+        async with self._client.request(
+            handler=RequestHandler.CreateProject,
+            body=CreateProjectRequestBody(name=name),
+        ) as response:
+            return CreateProjectResult.model_validate_json(response.content)

{latitude_sdk-4.0.0b1 → latitude_sdk-5.0.0b1}/src/latitude_sdk/sdk/prompts.py

@@ -1,11 +1,6 @@
-from typing import Any, AsyncGenerator, Callable, List, Optional, Sequence
+from typing import Any, AsyncGenerator, List, Optional, Sequence
 
-from promptl_ai import (
-    Adapter,
-    Message,
-    MessageLike,
-    Promptl,
-)
+from promptl_ai import Adapter, Message, MessageLike, Promptl
 from promptl_ai.bindings.types import _Message
 
 from latitude_sdk.client import (
@@ -30,6 +25,8 @@ from latitude_sdk.sdk.types import (
     OnToolCall,
     OnToolCallDetails,
     Prompt,
+    ProviderEvents,
+    ProviderEventToolCalled,
     Providers,
     SdkOptions,
     StreamCallbacks,
@@ -145,7 +142,7 @@ class Prompts:
         self,
         stream: AsyncGenerator[ClientEvent, Any],
         on_event: Optional[StreamCallbacks.OnEvent],
-        on_tool_call: Optional[Callable[[dict[str, Any]], Any]] = None,
+        tools: Optional[dict[str, OnToolCall]],
     ) -> FinishedResult:
         uuid = None
         conversation: List[Message] = []
@@ -153,6 +150,7 @@ class Prompts:
 
         async for stream_event in stream:
             event = None
+            tool_call = None
 
             if stream_event.event == str(StreamEvents.Latitude):
                 event = _LatitudeEvent.validate_json(stream_event.data)
@@ -174,9 +172,8 @@ class Prompts:
                 event = stream_event.json()
                 event["event"] = StreamEvents.Provider
 
-                # Handle tool calls when received in the stream
-                if on_tool_call and event.get("type") == "tool-call":
-                    await on_tool_call(event)
+                if event.get("type") == str(ProviderEvents.ToolCalled):
+                    tool_call = ProviderEventToolCalled.model_validate_json(stream_event.data)
 
             else:
                 raise ApiError(
@@ -189,6 +186,9 @@ class Prompts:
             if on_event:
                 on_event(event)
 
+            if tool_call:
+                await self._handle_tool_call(tool_call, tools)
+
         if not uuid or not response:
             raise ApiError(
                 status=500,
@@ -197,11 +197,7 @@ class Prompts:
                 response="Stream ended without a chain-complete event. Missing uuid or response.",
             )
 
-        return FinishedResult(
-            uuid=uuid,
-            conversation=conversation,
-            response=response,
-        )
+        return FinishedResult(uuid=uuid, conversation=conversation, response=response)
 
     @staticmethod
     async def _wrap_tool_handler(
@@ -212,66 +208,45 @@ class Prompts:
         try:
             result = await handler(arguments, details)
 
-            return ToolResult(**tool_result, result=result)
+            return ToolResult(**tool_result, result=result, is_error=False)
         except Exception as exception:
             return ToolResult(**tool_result, result=str(exception), is_error=True)
 
     async def _handle_tool_call(
-        self,
-        event: dict[str, Any],
-        tools: dict[str, OnToolCall],
+        self, tool_call: ProviderEventToolCalled, tools: Optional[dict[str, OnToolCall]]
     ) -> None:
-        toolCallId: str = event["toolCallId"]
-        toolName: str = event["toolName"]
-        args: dict[str, Any] = event["args"]
-
-        tool = tools.get(toolName)
-        if not tool:
+        # NOTE: Do not handle tool calls if user specified no tools
+        if not tools:
             return
 
+        tool_handler = tools.get(tool_call.name)
+        if not tool_handler:
+            raise ApiError(
+                status=400,
+                code=ApiErrorCodes.AIRunError,
+                message=f"Tool {tool_call.name} not supplied",
+                response=f"Tool {tool_call.name} not supplied",
+            )
+
         tool_result = await self._wrap_tool_handler(
-            tool,
-            args,
+            tool_handler,
+            tool_call.arguments,
             OnToolCallDetails(
-                id=toolCallId,
-                name=toolName,
-                arguments=args,
+                id=tool_call.id,
+                name=tool_call.name,
+                arguments=tool_call.arguments,
             ),
         )
 
-        try:
-            async with self._client.request(
-                handler=RequestHandler.ToolResults,
-                params=None,
-                body=ToolResultsRequestBody(
-                    tool_call_id=toolCallId,
-                    result=tool_result.result,
-                    is_error=tool_result.is_error,
-                ),
-            ) as _:
-                pass
-        except Exception as exception:
-            if not isinstance(exception, ApiError):
-                exception = ApiError(
-                    status=500,
-                    code=ApiErrorCodes.InternalServerError,
-                    message=str(exception),
-                    response=str(exception),
-                )
-
-            # Add context about which tool failed
-            message = f"Failed to execute tool {toolName}. \nLatitude API returned the following error:\
-                    \n\n{exception.message}"
-
-            raise ApiError(
-                status=exception.status,
-                code=exception.code,
-                message=message,
-                response=exception.response,
-            ) from exception
-
-    def _on_tool_call(self, tools: dict[str, OnToolCall]) -> Callable[[dict[str, Any]], Any]:
-        return lambda event: self._handle_tool_call(event, tools)
+        async with self._client.request(
+            handler=RequestHandler.ToolResults,
+            body=ToolResultsRequestBody(
+                tool_call_id=tool_call.id,
+                result=tool_result.result,
+                is_error=tool_result.is_error,
+            ),
+        ):
+            pass
 
     async def get(self, path: str, options: Optional[GetPromptOptions] = None) -> GetPromptResult:
         options = GetPromptOptions(**{**dict(self._options), **dict(options or {})})
@@ -338,16 +313,13 @@ class Prompts:
                     path=path,
                     parameters=options.parameters,
                     custom_identifier=options.custom_identifier,
-                    stream=options.stream,
                     tools=list(options.tools.keys()) if options.tools and options.stream else None,
+                    stream=options.stream,
                 ),
+                stream=options.stream,
             ) as response:
                 if options.stream:
-                    result = await self._handle_stream(
-                        response.sse(),
-                        options.on_event,
-                        self._on_tool_call(options.tools if options.tools else {}),
-                    )
+                    result = await self._handle_stream(response.sse(), options.on_event, options.tools)
                 else:
                     result = RunPromptResult.model_validate_json(response.content)
 
@@ -373,10 +345,7 @@ class Prompts:
             return None
 
     async def chat(
-        self,
-        uuid: str,
-        messages: Sequence[MessageLike],
-        options: Optional[ChatPromptOptions] = None,
+        self, uuid: str, messages: Sequence[MessageLike], options: Optional[ChatPromptOptions] = None
     ) -> Optional[ChatPromptResult]:
         options = ChatPromptOptions(**{**dict(self._options), **dict(options or {})})
 
@@ -390,15 +359,13 @@ class Prompts:
                 ),
                 body=ChatPromptRequestBody(
                     messages=messages,
+                    tools=list(options.tools.keys()) if options.tools and options.stream else None,
                     stream=options.stream,
                 ),
+                stream=options.stream,
             ) as response:
                 if options.stream:
-                    result = await self._handle_stream(
-                        response.sse(),
-                        options.on_event,
-                        self._on_tool_call(options.tools if options.tools else {}),
-                    )
+                    result = await self._handle_stream(response.sse(), options.on_event, options.tools)
                 else:
                     result = ChatPromptResult.model_validate_json(response.content)
 
@@ -451,10 +418,7 @@ class Prompts:
         )
 
     async def render_chain(
-        self,
-        prompt: Prompt,
-        on_step: OnStep,
-        options: Optional[RenderChainOptions] = None,
+        self, prompt: Prompt, on_step: OnStep, options: Optional[RenderChainOptions] = None
     ) -> RenderChainResult:
         options = RenderChainOptions(**{**dict(self._options), **dict(options or {})})
         adapter = options.adapter or _PROVIDER_TO_ADAPTER.get(prompt.provider or Providers.OpenAI, Adapter.OpenAI)