latitude-sdk 3.0.2__tar.gz → 4.0.0b1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: latitude-sdk
-Version: 3.0.2
+Version: 4.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
@@ -46,7 +46,7 @@ await sdk.prompts.run("joke-teller", RunPromptOptions(
 ))
 ```
 
-Find more [examples](https://github.com/latitude-dev/latitude-llm/tree/main/examples/sdks/python).
+Find more [examples](https://docs.latitude.so/examples/sdk).
 
 ## Development
 
@@ -60,7 +60,9 @@ Requires uv `0.5.10` or higher.
 - Build package: `uv build`
 - Publish package: `uv publish`
 
-## Run only one test
+### Running only a specific test
+
+Mark the test with an `only` marker:
 
 ```python
 import pytest
@@ -70,13 +72,13 @@ async def my_test(self):
     # ... your code
 ```
 
-And then run the tests with the marker `only`:
+...and then run the tests with the marker `only`:
 
 ```sh
 uv run scripts/test.py -m only
 ```
 
-Other way is all in line:
+Another way is to specify the test in line:
 
 ```python
 uv run scripts/test.py <test_path>::<test_case>::<test_name>
@@ -84,4 +86,4 @@ uv run scripts/test.py <test_path>::<test_case>::<test_name>
 
 ## License
 
-The SDK is licensed under the [LGPL-3.0 License](https://opensource.org/licenses/LGPL-3.0) - read the [LICENSE](/LICENSE) file for details.
+The SDK is licensed under the [MIT License](https://opensource.org/licenses/MIT) - read the [LICENSE](/LICENSE) file for details.

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

@@ -27,7 +27,7 @@ await sdk.prompts.run("joke-teller", RunPromptOptions(
 ))
 ```
 
-Find more [examples](https://github.com/latitude-dev/latitude-llm/tree/main/examples/sdks/python).
+Find more [examples](https://docs.latitude.so/examples/sdk).
 
 ## Development
 
@@ -41,7 +41,9 @@ Requires uv `0.5.10` or higher.
 - Build package: `uv build`
 - Publish package: `uv publish`
 
-## Run only one test
+### Running only a specific test
+
+Mark the test with an `only` marker:
 
 ```python
 import pytest
@@ -51,13 +53,13 @@ async def my_test(self):
     # ... your code
 ```
 
-And then run the tests with the marker `only`:
+...and then run the tests with the marker `only`:
 
 ```sh
 uv run scripts/test.py -m only
 ```
 
-Other way is all in line:
+Another way is to specify the test in line:
 
 ```python
 uv run scripts/test.py <test_path>::<test_case>::<test_name>
@@ -65,4 +67,4 @@ uv run scripts/test.py <test_path>::<test_case>::<test_name>
 
 ## License
 
-The SDK is licensed under the [LGPL-3.0 License](https://opensource.org/licenses/LGPL-3.0) - read the [LICENSE](/LICENSE) file for details.
+The SDK is licensed under the [MIT License](https://opensource.org/licenses/MIT) - read the [LICENSE](/LICENSE) file for details.

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

@@ -1,6 +1,6 @@
 [project]
 name = "latitude-sdk"
-version = "3.0.2"
+version = "4.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" }]

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

@@ -0,0 +1,276 @@
+import asyncio
+import json
+from contextlib import asynccontextmanager
+from typing import Any, AsyncGenerator, Awaitable, Callable, 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
+
+RETRIABLE_STATUSES = [408, 409, 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,
+    ) -> AsyncGenerator[ClientResponse, Any]:
+        """
+        Main request handler that delegates to streaming or non-streaming methods.
+        """
+        is_streaming = self._is_streaming_request(body)
+
+        if is_streaming:
+            async with self._streaming_request(handler, params, body) as response:
+                yield response
+        else:
+            async with self._non_streaming_request(handler, params, body) as response:
+                yield response
+
+    def _is_streaming_request(self, body: Optional[RequestBody]) -> bool:
+        """Check if this is a streaming request based on the body."""
+        return body is not None and hasattr(body, "stream") and body.stream  # type: ignore
+
+    def _prepare_headers(self, is_streaming: bool) -> dict[str, str]:
+        """Prepare headers for the request."""
+        headers = {
+            "Authorization": f"Bearer {self.options.api_key}",
+            "Content-Type": "application/json",
+        }
+
+        if is_streaming:
+            headers["Accept"] = "text/event-stream"
+
+        return headers
+
+    def _prepare_content(self, body: Optional[RequestBody]) -> Optional[str]:
+        """Prepare request content from body."""
+        if not body:
+            return None
+
+        return json.dumps(
+            {
+                **json.loads(body.model_dump_json()),
+                "__internal": {"source": self.options.source},
+            }
+        )
+
+    @asynccontextmanager
+    async def _streaming_request(
+        self,
+        handler: RequestHandler,
+        params: Optional[RequestParams] = None,
+        body: Optional[RequestBody] = None,
+    ) -> AsyncGenerator[ClientResponse, Any]:
+        """Handle streaming requests with proper resource management."""
+        headers = self._prepare_headers(is_streaming=True)
+        content = self._prepare_content(body)
+        method, url = self.router.resolve(handler, params)
+
+        async with httpx.AsyncClient(
+            headers=headers,
+            timeout=self.options.timeout,
+            follow_redirects=False,
+            max_redirects=0,
+        ) as client:
+            response = await self._execute_with_retry(
+                lambda: client.stream(method=method, url=url, content=content),  # type: ignore
+                is_streaming=True,
+            )
+
+            # For streaming responses, yield the response directly
+            # The caller is responsible for consuming the stream
+            yield response
+
+    @asynccontextmanager
+    async def _non_streaming_request(
+        self,
+        handler: RequestHandler,
+        params: Optional[RequestParams] = None,
+        body: Optional[RequestBody] = None,
+    ) -> AsyncGenerator[ClientResponse, Any]:
+        """Handle non-streaming requests with proper resource management."""
+        headers = self._prepare_headers(is_streaming=False)
+        content = self._prepare_content(body)
+        method, url = self.router.resolve(handler, params)
+
+        async with httpx.AsyncClient(
+            headers=headers,
+            timeout=self.options.timeout,
+            follow_redirects=False,
+            max_redirects=0,
+        ) as client:
+            response = await self._execute_with_retry(
+                lambda: client.request(method=method, url=url, content=content),  # type: ignore
+                is_streaming=False,
+            )
+
+            try:
+                # Pre-read the response text for non-streaming responses
+                # This ensures the response is fully loaded and validates it
+                _ = response.text
+                yield response
+            finally:
+                await response.aclose()
+
+    async def _execute_with_retry(
+        self,
+        request_func: Callable[[], Awaitable[ClientResponse]],
+        is_streaming: bool = False,
+    ) -> ClientResponse:
+        """Execute a request with retry logic."""
+        last_exception = None
+        last_response = None
+
+        for attempt in range(1, self.options.retries + 1):
+            response_cm = None
+            response = None
+
+            try:
+                if is_streaming:
+                    # For streaming, request_func returns a context manager
+                    response_cm = request_func()
+                    response = await response_cm.__aenter__()  # type: ignore
+                    # Store the context manager for proper cleanup
+                    response._stream_cm = response_cm  # pyright: ignore [reportAttributeAccessIssue]
+                else:
+                    response = await request_func()
+
+                response.raise_for_status()  # type: ignore
+                return response  # type: ignore
+
+            except Exception as exception:
+                last_exception = exception
+
+                # For HTTP errors, get the response from the exception
+                if isinstance(exception, httpx.HTTPStatusError):
+                    last_response = exception.response
+                else:
+                    last_response = getattr(exception, "response", None)
+
+                # Don't retry ApiErrors - they're business logic errors
+                if isinstance(exception, ApiError):
+                    raise exception
+
+                # If this is the last attempt, break to raise the exception
+                if attempt >= self.options.retries:
+                    break
+
+                # Check if we should retry based on status code
+                if (
+                    isinstance(exception, httpx.HTTPStatusError)
+                    and exception.response.status_code in RETRIABLE_STATUSES
+                ):
+                    await asyncio.sleep(self._calculate_delay(attempt))
+                    continue
+
+                # For non-retriable errors, don't retry
+                break
+
+        # If we get here, all retries failed
+        raise await self._exception(last_exception, last_response) from last_exception  # type: ignore
+
+    def _calculate_delay(self, attempt: int) -> float:
+        """Calculate exponential backoff delay."""
+        return self.options.delay * (2 ** (attempt - 1))
+
+    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 to safely get response text and content, handling streaming responses
+        response_text = ""
+        response_content = b""
+
+        try:
+            # Check if this is a streaming response
+            content_type = response.headers.get("content-type", "")
+            is_streaming = "text/event-stream" in content_type
+
+            # For streaming responses, try to read content but don't access text
+            if is_streaming:
+                # For streaming responses, we can access content but not text
+                response_content = response.content
+                response_text = ""
+            else:
+                # For non-streaming responses, we can safely access both
+                response_content = response.content
+                response_text = response.text
+        except Exception:
+            # If we can't read the response (e.g., streaming response that hasn't been read),
+            # try to get what we can
+            try:
+                response_content = response.content
+            except Exception:
+                response_content = b""
+            response_text = ""
+
+        try:
+            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-3.0.2 → latitude_sdk-4.0.0b1}/src/latitude_sdk/client/payloads.py

@@ -45,6 +45,7 @@ class RunPromptRequestBody(Model):
     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
 
 
 class ChatPromptRequestParams(Model):
@@ -88,6 +89,16 @@ class AnnotateEvaluationRequestBody(Model):
     metadata: Optional[Metadata] = None
 
 
+class ToolResultsRequestBody(Model):
+    tool_call_id: str = Field(alias=str("toolCallId"))
+    result: Any
+    is_error: Optional[bool] = Field(default=None, alias=str("isError"))
+
+
+class CreateProjectRequestBody(Model):
+    name: str
+
+
 RequestParams = Union[
     GetPromptRequestParams,
     GetAllPromptRequestParams,
@@ -105,6 +116,8 @@ RequestBody = Union[
     ChatPromptRequestBody,
     CreateLogRequestBody,
     AnnotateEvaluationRequestBody,
+    ToolResultsRequestBody,
+    CreateProjectRequestBody,
 ]
 
 
@@ -116,3 +129,6 @@ class RequestHandler(StrEnum):
     ChatPrompt = "CHAT_PROMPT"
     CreateLog = "CREATE_LOG"
     AnnotateEvaluation = "ANNOTATE_EVALUATION"
+    ToolResults = "TOOL_RESULTS"
+    GetAllProjects = "GET_ALL_PROJECTS"
+    CreateProject = "CREATE_PROJECT"

{latitude_sdk-3.0.2 → latitude_sdk-4.0.0b1}/src/latitude_sdk/client/router.py

@@ -27,7 +27,7 @@ class Router:
     def __init__(self, options: RouterOptions):
         self.options = options
 
-    def resolve(self, handler: RequestHandler, params: RequestParams) -> Tuple[str, str]:
+    def resolve(self, handler: RequestHandler, params: Optional[RequestParams] = None) -> Tuple[str, str]:
         if handler == RequestHandler.GetPrompt:
             assert isinstance(params, GetPromptRequestParams)
 
@@ -90,6 +90,15 @@ class Router:
 
             return "POST", self.conversations().annotate(params.conversation_uuid, params.evaluation_uuid)
 
+        elif handler == RequestHandler.ToolResults:
+            return "POST", f"{self.options.gateway.base_url}/tools/results"
+
+        elif handler == RequestHandler.GetAllProjects:
+            return "GET", f"{self.options.gateway.base_url}/projects"
+
+        elif handler == RequestHandler.CreateProject:
+            return "POST", f"{self.options.gateway.base_url}/projects"
+
         raise TypeError(f"Unknown handler: {handler}")
 
     class Conversations(Model):

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

@@ -6,6 +6,7 @@ from latitude_sdk.client import Client, ClientOptions, RouterOptions
 from latitude_sdk.env import env
 from latitude_sdk.sdk.evaluations import Evaluations
 from latitude_sdk.sdk.logs import Logs
+from latitude_sdk.sdk.projects import Projects
 from latitude_sdk.sdk.prompts import Prompts
 from latitude_sdk.sdk.types import GatewayOptions, LogSources, SdkOptions
 from latitude_sdk.util import Model
@@ -49,6 +50,7 @@ class Latitude:
 
     promptl: Promptl
 
+    projects: Projects
     prompts: Prompts
     logs: Logs
     evaluations: Evaluations
@@ -76,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)
         self.evaluations = Evaluations(self._client, self._options)

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

@@ -0,0 +1,41 @@
+import json
+from typing import List
+
+from latitude_sdk.client import Client
+from latitude_sdk.client.payloads import CreateProjectRequestBody, RequestHandler
+from latitude_sdk.sdk.types import Project, SdkOptions, Version
+
+
+class CreateProjectResponse:
+    def __init__(self, project: Project, version: Version):
+        self.project = project
+        self.version = version
+
+
+class Projects:
+    _client: Client
+    _options: SdkOptions
+
+    def __init__(self, client: Client, options: SdkOptions):
+        self._client = client
+        self._options = options
+
+    async def get_all(self) -> List[Project]:
+        async with self._client.request(
+            handler=RequestHandler.GetAllProjects,
+            params=None,
+        ) as response:
+            projects_data = json.loads(response.content)
+            return [Project.model_validate_json(json.dumps(project)) for project in projects_data]
+
+    async def create(self, name: str) -> CreateProjectResponse:
+        async with self._client.request(
+            handler=RequestHandler.CreateProject,
+            params=None,
+            body=CreateProjectRequestBody(name=name),
+        ) as response:
+            response_data = json.loads(response.content)
+            return CreateProjectResponse(
+                project=Project.model_validate_json(json.dumps(response_data["project"])),
+                version=Version.model_validate_json(json.dumps(response_data["version"])),
+            )