samsara-api 4.1.1__py3-none-any.whl → 4.3.0__py3-none-any.whl

samsara/core/http_sse/__init__.py

@@ -0,0 +1,42 @@
+# This file was auto-generated by Fern from our API Definition.
+
+# isort: skip_file
+
+import typing
+from importlib import import_module
+
+if typing.TYPE_CHECKING:
+    from ._api import EventSource, aconnect_sse, connect_sse
+    from ._exceptions import SSEError
+    from ._models import ServerSentEvent
+_dynamic_imports: typing.Dict[str, str] = {
+    "EventSource": "._api",
+    "SSEError": "._exceptions",
+    "ServerSentEvent": "._models",
+    "aconnect_sse": "._api",
+    "connect_sse": "._api",
+}
+
+
+def __getattr__(attr_name: str) -> typing.Any:
+    module_name = _dynamic_imports.get(attr_name)
+    if module_name is None:
+        raise AttributeError(f"No {attr_name} found in _dynamic_imports for module name -> {__name__}")
+    try:
+        module = import_module(module_name, __package__)
+        if module_name == f".{attr_name}":
+            return module
+        else:
+            return getattr(module, attr_name)
+    except ImportError as e:
+        raise ImportError(f"Failed to import {attr_name} from {module_name}: {e}") from e
+    except AttributeError as e:
+        raise AttributeError(f"Failed to get {attr_name} from {module_name}: {e}") from e
+
+
+def __dir__():
+    lazy_attrs = list(_dynamic_imports.keys())
+    return sorted(lazy_attrs)
+
+
+__all__ = ["EventSource", "SSEError", "ServerSentEvent", "aconnect_sse", "connect_sse"]

samsara/core/http_sse/_api.py

@@ -0,0 +1,112 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import re
+from contextlib import asynccontextmanager, contextmanager
+from typing import Any, AsyncGenerator, AsyncIterator, Iterator, cast
+
+import httpx
+from ._decoders import SSEDecoder
+from ._exceptions import SSEError
+from ._models import ServerSentEvent
+
+
+class EventSource:
+    def __init__(self, response: httpx.Response) -> None:
+        self._response = response
+
+    def _check_content_type(self) -> None:
+        content_type = self._response.headers.get("content-type", "").partition(";")[0]
+        if "text/event-stream" not in content_type:
+            raise SSEError(
+                f"Expected response header Content-Type to contain 'text/event-stream', got {content_type!r}"
+            )
+
+    def _get_charset(self) -> str:
+        """Extract charset from Content-Type header, fallback to UTF-8."""
+        content_type = self._response.headers.get("content-type", "")
+
+        # Parse charset parameter using regex
+        charset_match = re.search(r"charset=([^;\s]+)", content_type, re.IGNORECASE)
+        if charset_match:
+            charset = charset_match.group(1).strip("\"'")
+            # Validate that it's a known encoding
+            try:
+                # Test if the charset is valid by trying to encode/decode
+                "test".encode(charset).decode(charset)
+                return charset
+            except (LookupError, UnicodeError):
+                # If charset is invalid, fall back to UTF-8
+                pass
+
+        # Default to UTF-8 if no charset specified or invalid charset
+        return "utf-8"
+
+    @property
+    def response(self) -> httpx.Response:
+        return self._response
+
+    def iter_sse(self) -> Iterator[ServerSentEvent]:
+        self._check_content_type()
+        decoder = SSEDecoder()
+        charset = self._get_charset()
+
+        buffer = ""
+        for chunk in self._response.iter_bytes():
+            # Decode chunk using detected charset
+            text_chunk = chunk.decode(charset, errors="replace")
+            buffer += text_chunk
+
+            # Process complete lines
+            while "\n" in buffer:
+                line, buffer = buffer.split("\n", 1)
+                line = line.rstrip("\r")
+                sse = decoder.decode(line)
+                # when we reach a "\n\n" => line = ''
+                # => decoder will attempt to return an SSE Event
+                if sse is not None:
+                    yield sse
+
+        # Process any remaining data in buffer
+        if buffer.strip():
+            line = buffer.rstrip("\r")
+            sse = decoder.decode(line)
+            if sse is not None:
+                yield sse
+
+    async def aiter_sse(self) -> AsyncGenerator[ServerSentEvent, None]:
+        self._check_content_type()
+        decoder = SSEDecoder()
+        lines = cast(AsyncGenerator[str, None], self._response.aiter_lines())
+        try:
+            async for line in lines:
+                line = line.rstrip("\n")
+                sse = decoder.decode(line)
+                if sse is not None:
+                    yield sse
+        finally:
+            await lines.aclose()
+
+
+@contextmanager
+def connect_sse(client: httpx.Client, method: str, url: str, **kwargs: Any) -> Iterator[EventSource]:
+    headers = kwargs.pop("headers", {})
+    headers["Accept"] = "text/event-stream"
+    headers["Cache-Control"] = "no-store"
+
+    with client.stream(method, url, headers=headers, **kwargs) as response:
+        yield EventSource(response)
+
+
+@asynccontextmanager
+async def aconnect_sse(
+    client: httpx.AsyncClient,
+    method: str,
+    url: str,
+    **kwargs: Any,
+) -> AsyncIterator[EventSource]:
+    headers = kwargs.pop("headers", {})
+    headers["Accept"] = "text/event-stream"
+    headers["Cache-Control"] = "no-store"
+
+    async with client.stream(method, url, headers=headers, **kwargs) as response:
+        yield EventSource(response)

samsara/core/http_sse/_decoders.py

@@ -0,0 +1,61 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from typing import List, Optional
+
+from ._models import ServerSentEvent
+
+
+class SSEDecoder:
+    def __init__(self) -> None:
+        self._event = ""
+        self._data: List[str] = []
+        self._last_event_id = ""
+        self._retry: Optional[int] = None
+
+    def decode(self, line: str) -> Optional[ServerSentEvent]:
+        # See: https://html.spec.whatwg.org/multipage/server-sent-events.html#event-stream-interpretation  # noqa: E501
+
+        if not line:
+            if not self._event and not self._data and not self._last_event_id and self._retry is None:
+                return None
+
+            sse = ServerSentEvent(
+                event=self._event,
+                data="\n".join(self._data),
+                id=self._last_event_id,
+                retry=self._retry,
+            )
+
+            # NOTE: as per the SSE spec, do not reset last_event_id.
+            self._event = ""
+            self._data = []
+            self._retry = None
+
+            return sse
+
+        if line.startswith(":"):
+            return None
+
+        fieldname, _, value = line.partition(":")
+
+        if value.startswith(" "):
+            value = value[1:]
+
+        if fieldname == "event":
+            self._event = value
+        elif fieldname == "data":
+            self._data.append(value)
+        elif fieldname == "id":
+            if "\0" in value:
+                pass
+            else:
+                self._last_event_id = value
+        elif fieldname == "retry":
+            try:
+                self._retry = int(value)
+            except (TypeError, ValueError):
+                pass
+        else:
+            pass  # Field is ignored.
+
+        return None

samsara/core/http_sse/_exceptions.py

@@ -0,0 +1,7 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import httpx
+
+
+class SSEError(httpx.TransportError):
+    pass

samsara/core/http_sse/_models.py

@@ -0,0 +1,17 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import json
+from dataclasses import dataclass
+from typing import Any, Optional
+
+
+@dataclass(frozen=True)
+class ServerSentEvent:
+    event: str = "message"
+    data: str = ""
+    id: str = ""
+    retry: Optional[int] = None
+
+    def json(self) -> Any:
+        """Parse the data field as JSON."""
+        return json.loads(self.data)

samsara/core/pagination.py

@@ -5,10 +5,10 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import AsyncIterator, Awaitable, Callable, Generic, Iterator, List, Optional, TypeVar
 
-from .http_response import BaseHttpResponse
-
 # Generic to represent the underlying type of the results within a page
 T = TypeVar("T")
+# Generic to represent the type of the API response
+R = TypeVar("R")
 
 
 # SDKs implement a Page ABC per-pagination request, the endpoint then returns a pager that wraps this type
@@ -23,11 +23,11 @@ T = TypeVar("T")
 
 
 @dataclass(frozen=True)
-class SyncPager(Generic[T]):
-    get_next: Optional[Callable[[], Optional[SyncPager[T]]]]
+class SyncPager(Generic[T, R]):
+    get_next: Optional[Callable[[], Optional[SyncPager[T, R]]]]
     has_next: bool
     items: Optional[List[T]]
-    response: Optional[BaseHttpResponse]
+    response: R
 
     # Here we type ignore the iterator to avoid a mypy error
     # caused by the type conflict with Pydanitc's __iter__ method
@@ -37,8 +37,8 @@ class SyncPager(Generic[T]):
             if page.items is not None:
                 yield from page.items
 
-    def iter_pages(self) -> Iterator[SyncPager[T]]:
-        page: Optional[SyncPager[T]] = self
+    def iter_pages(self) -> Iterator[SyncPager[T, R]]:
+        page: Optional[SyncPager[T, R]] = self
         while page is not None:
             yield page
 
@@ -49,16 +49,16 @@ class SyncPager(Generic[T]):
             if page is None or page.items is None or len(page.items) == 0:
                 return
 
-    def next_page(self) -> Optional[SyncPager[T]]:
+    def next_page(self) -> Optional[SyncPager[T, R]]:
         return self.get_next() if self.get_next is not None else None
 
 
 @dataclass(frozen=True)
-class AsyncPager(Generic[T]):
-    get_next: Optional[Callable[[], Awaitable[Optional[AsyncPager[T]]]]]
+class AsyncPager(Generic[T, R]):
+    get_next: Optional[Callable[[], Awaitable[Optional[AsyncPager[T, R]]]]]
     has_next: bool
     items: Optional[List[T]]
-    response: Optional[BaseHttpResponse]
+    response: R
 
     async def __aiter__(self) -> AsyncIterator[T]:
         async for page in self.iter_pages():
@@ -66,8 +66,8 @@ class AsyncPager(Generic[T]):
                 for item in page.items:
                     yield item
 
-    async def iter_pages(self) -> AsyncIterator[AsyncPager[T]]:
-        page: Optional[AsyncPager[T]] = self
+    async def iter_pages(self) -> AsyncIterator[AsyncPager[T, R]]:
+        page: Optional[AsyncPager[T, R]] = self
         while page is not None:
             yield page
 
@@ -78,5 +78,5 @@ class AsyncPager(Generic[T]):
             if page is None or page.items is None or len(page.items) == 0:
                 return
 
-    async def next_page(self) -> Optional[AsyncPager[T]]:
+    async def next_page(self) -> Optional[AsyncPager[T, R]]:
         return await self.get_next() if self.get_next is not None else None

samsara/core/pydantic_utilities.py

@@ -220,7 +220,9 @@ def universal_root_validator(
 ) -> Callable[[AnyCallable], AnyCallable]:
     def decorator(func: AnyCallable) -> AnyCallable:
         if IS_PYDANTIC_V2:
-            return cast(AnyCallable, pydantic.model_validator(mode="before" if pre else "after")(func))  # type: ignore[attr-defined]
+            # In Pydantic v2, for RootModel we always use "before" mode
+            # The custom validators transform the input value before the model is created
+            return cast(AnyCallable, pydantic.model_validator(mode="before")(func))  # type: ignore[attr-defined]
         return cast(AnyCallable, pydantic.root_validator(pre=pre)(func))  # type: ignore[call-overload]
 
     return decorator

samsara/documents/client.py

@@ -66,9 +66,7 @@ class DocumentsClient:
         client = Samsara(
             token="YOUR_TOKEN",
         )
-        client.documents.get_document_types(
-            after="after",
-        )
+        client.documents.get_document_types()
         """
         _response = self._raw_client.get_document_types(after=after, request_options=request_options)
         return _response.data
@@ -128,9 +126,6 @@ class DocumentsClient:
         client.documents.get_documents(
             start_time="startTime",
             end_time="endTime",
-            after="after",
-            document_type_id="documentTypeId",
-            query_by="queryBy",
         )
         """
         _response = self._raw_client.get_documents(
@@ -430,9 +425,7 @@ class AsyncDocumentsClient:
 
 
         async def main() -> None:
-            await client.documents.get_document_types(
-                after="after",
-            )
+            await client.documents.get_document_types()
 
 
         asyncio.run(main())
@@ -500,9 +493,6 @@ class AsyncDocumentsClient:
             await client.documents.get_documents(
                 start_time="startTime",
                 end_time="endTime",
-                after="after",
-                document_type_id="documentTypeId",
-                query_by="queryBy",
             )