supermemory 3.7.0__py3-none-any.whl → 3.19.0__py3-none-any.whl

supermemory/_client.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import os
-from typing import Any, Dict, Union, Mapping
+from typing import TYPE_CHECKING, Any, Dict, Union, Mapping
 from typing_extensions import Self, override
 
 import httpx
@@ -31,6 +31,7 @@ from ._utils import (
     get_async_library,
     async_maybe_transform,
 )
+from ._compat import cached_property
 from ._version import __version__
 from ._response import (
     to_raw_response_wrapper,
@@ -38,7 +39,6 @@ from ._response import (
     async_to_raw_response_wrapper,
     async_to_streamed_response_wrapper,
 )
-from .resources import search, memories, settings, documents, connections
 from ._streaming import Stream as Stream, AsyncStream as AsyncStream
 from ._exceptions import APIStatusError, SupermemoryError
 from ._base_client import (
@@ -50,6 +50,14 @@ from ._base_client import (
 from .types.add_response import AddResponse
 from .types.profile_response import ProfileResponse
 
+if TYPE_CHECKING:
+    from .resources import search, memories, settings, documents, connections
+    from .resources.search import SearchResource, AsyncSearchResource
+    from .resources.memories import MemoriesResource, AsyncMemoriesResource
+    from .resources.settings import SettingsResource, AsyncSettingsResource
+    from .resources.documents import DocumentsResource, AsyncDocumentsResource
+    from .resources.connections import ConnectionsResource, AsyncConnectionsResource
+
 __all__ = [
     "Timeout",
     "Transport",
@@ -63,14 +71,6 @@ __all__ = [
 
 
 class Supermemory(SyncAPIClient):
-    memories: memories.MemoriesResource
-    documents: documents.DocumentsResource
-    search: search.SearchResource
-    settings: settings.SettingsResource
-    connections: connections.ConnectionsResource
-    with_raw_response: SupermemoryWithRawResponse
-    with_streaming_response: SupermemoryWithStreamedResponse
-
     # client options
     api_key: str
 
@@ -125,13 +125,43 @@ class Supermemory(SyncAPIClient):
             _strict_response_validation=_strict_response_validation,
         )
 
-        self.memories = memories.MemoriesResource(self)
-        self.documents = documents.DocumentsResource(self)
-        self.search = search.SearchResource(self)
-        self.settings = settings.SettingsResource(self)
-        self.connections = connections.ConnectionsResource(self)
-        self.with_raw_response = SupermemoryWithRawResponse(self)
-        self.with_streaming_response = SupermemoryWithStreamedResponse(self)
+    @cached_property
+    def memories(self) -> MemoriesResource:
+        from .resources.memories import MemoriesResource
+
+        return MemoriesResource(self)
+
+    @cached_property
+    def documents(self) -> DocumentsResource:
+        from .resources.documents import DocumentsResource
+
+        return DocumentsResource(self)
+
+    @cached_property
+    def search(self) -> SearchResource:
+        from .resources.search import SearchResource
+
+        return SearchResource(self)
+
+    @cached_property
+    def settings(self) -> SettingsResource:
+        from .resources.settings import SettingsResource
+
+        return SettingsResource(self)
+
+    @cached_property
+    def connections(self) -> ConnectionsResource:
+        from .resources.connections import ConnectionsResource
+
+        return ConnectionsResource(self)
+
+    @cached_property
+    def with_raw_response(self) -> SupermemoryWithRawResponse:
+        return SupermemoryWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> SupermemoryWithStreamedResponse:
+        return SupermemoryWithStreamedResponse(self)
 
     @property
     @override
@@ -265,6 +295,7 @@ class Supermemory(SyncAPIClient):
         *,
         container_tag: str,
         q: str | Omit = omit,
+        threshold: float | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
@@ -281,6 +312,9 @@ class Supermemory(SyncAPIClient):
 
           q: Optional search query to include search results in the response
 
+          threshold: Threshold for search results. Only results with a score above this threshold
+              will be included.
+
           extra_headers: Send extra headers
 
           extra_query: Add additional query parameters to the request
@@ -295,6 +329,7 @@ class Supermemory(SyncAPIClient):
                 {
                     "container_tag": container_tag,
                     "q": q,
+                    "threshold": threshold,
                 },
                 client_profile_params.ClientProfileParams,
             ),
@@ -339,14 +374,6 @@ class Supermemory(SyncAPIClient):
 
 
 class AsyncSupermemory(AsyncAPIClient):
-    memories: memories.AsyncMemoriesResource
-    documents: documents.AsyncDocumentsResource
-    search: search.AsyncSearchResource
-    settings: settings.AsyncSettingsResource
-    connections: connections.AsyncConnectionsResource
-    with_raw_response: AsyncSupermemoryWithRawResponse
-    with_streaming_response: AsyncSupermemoryWithStreamedResponse
-
     # client options
     api_key: str
 
@@ -401,13 +428,43 @@ class AsyncSupermemory(AsyncAPIClient):
             _strict_response_validation=_strict_response_validation,
         )
 
-        self.memories = memories.AsyncMemoriesResource(self)
-        self.documents = documents.AsyncDocumentsResource(self)
-        self.search = search.AsyncSearchResource(self)
-        self.settings = settings.AsyncSettingsResource(self)
-        self.connections = connections.AsyncConnectionsResource(self)
-        self.with_raw_response = AsyncSupermemoryWithRawResponse(self)
-        self.with_streaming_response = AsyncSupermemoryWithStreamedResponse(self)
+    @cached_property
+    def memories(self) -> AsyncMemoriesResource:
+        from .resources.memories import AsyncMemoriesResource
+
+        return AsyncMemoriesResource(self)
+
+    @cached_property
+    def documents(self) -> AsyncDocumentsResource:
+        from .resources.documents import AsyncDocumentsResource
+
+        return AsyncDocumentsResource(self)
+
+    @cached_property
+    def search(self) -> AsyncSearchResource:
+        from .resources.search import AsyncSearchResource
+
+        return AsyncSearchResource(self)
+
+    @cached_property
+    def settings(self) -> AsyncSettingsResource:
+        from .resources.settings import AsyncSettingsResource
+
+        return AsyncSettingsResource(self)
+
+    @cached_property
+    def connections(self) -> AsyncConnectionsResource:
+        from .resources.connections import AsyncConnectionsResource
+
+        return AsyncConnectionsResource(self)
+
+    @cached_property
+    def with_raw_response(self) -> AsyncSupermemoryWithRawResponse:
+        return AsyncSupermemoryWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncSupermemoryWithStreamedResponse:
+        return AsyncSupermemoryWithStreamedResponse(self)
 
     @property
     @override
@@ -541,6 +598,7 @@ class AsyncSupermemory(AsyncAPIClient):
         *,
         container_tag: str,
         q: str | Omit = omit,
+        threshold: float | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
@@ -557,6 +615,9 @@ class AsyncSupermemory(AsyncAPIClient):
 
           q: Optional search query to include search results in the response
 
+          threshold: Threshold for search results. Only results with a score above this threshold
+              will be included.
+
           extra_headers: Send extra headers
 
           extra_query: Add additional query parameters to the request
@@ -571,6 +632,7 @@ class AsyncSupermemory(AsyncAPIClient):
                 {
                     "container_tag": container_tag,
                     "q": q,
+                    "threshold": threshold,
                 },
                 client_profile_params.ClientProfileParams,
             ),
@@ -615,12 +677,10 @@ class AsyncSupermemory(AsyncAPIClient):
 
 
 class SupermemoryWithRawResponse:
+    _client: Supermemory
+
     def __init__(self, client: Supermemory) -> None:
-        self.memories = memories.MemoriesResourceWithRawResponse(client.memories)
-        self.documents = documents.DocumentsResourceWithRawResponse(client.documents)
-        self.search = search.SearchResourceWithRawResponse(client.search)
-        self.settings = settings.SettingsResourceWithRawResponse(client.settings)
-        self.connections = connections.ConnectionsResourceWithRawResponse(client.connections)
+        self._client = client
 
         self.add = to_raw_response_wrapper(
             client.add,
@@ -629,14 +689,42 @@ class SupermemoryWithRawResponse:
             client.profile,
         )
 
+    @cached_property
+    def memories(self) -> memories.MemoriesResourceWithRawResponse:
+        from .resources.memories import MemoriesResourceWithRawResponse
+
+        return MemoriesResourceWithRawResponse(self._client.memories)
+
+    @cached_property
+    def documents(self) -> documents.DocumentsResourceWithRawResponse:
+        from .resources.documents import DocumentsResourceWithRawResponse
+
+        return DocumentsResourceWithRawResponse(self._client.documents)
+
+    @cached_property
+    def search(self) -> search.SearchResourceWithRawResponse:
+        from .resources.search import SearchResourceWithRawResponse
+
+        return SearchResourceWithRawResponse(self._client.search)
+
+    @cached_property
+    def settings(self) -> settings.SettingsResourceWithRawResponse:
+        from .resources.settings import SettingsResourceWithRawResponse
+
+        return SettingsResourceWithRawResponse(self._client.settings)
+
+    @cached_property
+    def connections(self) -> connections.ConnectionsResourceWithRawResponse:
+        from .resources.connections import ConnectionsResourceWithRawResponse
+
+        return ConnectionsResourceWithRawResponse(self._client.connections)
+
 
 class AsyncSupermemoryWithRawResponse:
+    _client: AsyncSupermemory
+
     def __init__(self, client: AsyncSupermemory) -> None:
-        self.memories = memories.AsyncMemoriesResourceWithRawResponse(client.memories)
-        self.documents = documents.AsyncDocumentsResourceWithRawResponse(client.documents)
-        self.search = search.AsyncSearchResourceWithRawResponse(client.search)
-        self.settings = settings.AsyncSettingsResourceWithRawResponse(client.settings)
-        self.connections = connections.AsyncConnectionsResourceWithRawResponse(client.connections)
+        self._client = client
 
         self.add = async_to_raw_response_wrapper(
             client.add,
@@ -645,14 +733,42 @@ class AsyncSupermemoryWithRawResponse:
             client.profile,
         )
 
+    @cached_property
+    def memories(self) -> memories.AsyncMemoriesResourceWithRawResponse:
+        from .resources.memories import AsyncMemoriesResourceWithRawResponse
+
+        return AsyncMemoriesResourceWithRawResponse(self._client.memories)
+
+    @cached_property
+    def documents(self) -> documents.AsyncDocumentsResourceWithRawResponse:
+        from .resources.documents import AsyncDocumentsResourceWithRawResponse
+
+        return AsyncDocumentsResourceWithRawResponse(self._client.documents)
+
+    @cached_property
+    def search(self) -> search.AsyncSearchResourceWithRawResponse:
+        from .resources.search import AsyncSearchResourceWithRawResponse
+
+        return AsyncSearchResourceWithRawResponse(self._client.search)
+
+    @cached_property
+    def settings(self) -> settings.AsyncSettingsResourceWithRawResponse:
+        from .resources.settings import AsyncSettingsResourceWithRawResponse
+
+        return AsyncSettingsResourceWithRawResponse(self._client.settings)
+
+    @cached_property
+    def connections(self) -> connections.AsyncConnectionsResourceWithRawResponse:
+        from .resources.connections import AsyncConnectionsResourceWithRawResponse
+
+        return AsyncConnectionsResourceWithRawResponse(self._client.connections)
+
 
 class SupermemoryWithStreamedResponse:
+    _client: Supermemory
+
     def __init__(self, client: Supermemory) -> None:
-        self.memories = memories.MemoriesResourceWithStreamingResponse(client.memories)
-        self.documents = documents.DocumentsResourceWithStreamingResponse(client.documents)
-        self.search = search.SearchResourceWithStreamingResponse(client.search)
-        self.settings = settings.SettingsResourceWithStreamingResponse(client.settings)
-        self.connections = connections.ConnectionsResourceWithStreamingResponse(client.connections)
+        self._client = client
 
         self.add = to_streamed_response_wrapper(
             client.add,
@@ -661,14 +777,42 @@ class SupermemoryWithStreamedResponse:
             client.profile,
         )
 
+    @cached_property
+    def memories(self) -> memories.MemoriesResourceWithStreamingResponse:
+        from .resources.memories import MemoriesResourceWithStreamingResponse
+
+        return MemoriesResourceWithStreamingResponse(self._client.memories)
+
+    @cached_property
+    def documents(self) -> documents.DocumentsResourceWithStreamingResponse:
+        from .resources.documents import DocumentsResourceWithStreamingResponse
+
+        return DocumentsResourceWithStreamingResponse(self._client.documents)
+
+    @cached_property
+    def search(self) -> search.SearchResourceWithStreamingResponse:
+        from .resources.search import SearchResourceWithStreamingResponse
+
+        return SearchResourceWithStreamingResponse(self._client.search)
+
+    @cached_property
+    def settings(self) -> settings.SettingsResourceWithStreamingResponse:
+        from .resources.settings import SettingsResourceWithStreamingResponse
+
+        return SettingsResourceWithStreamingResponse(self._client.settings)
+
+    @cached_property
+    def connections(self) -> connections.ConnectionsResourceWithStreamingResponse:
+        from .resources.connections import ConnectionsResourceWithStreamingResponse
+
+        return ConnectionsResourceWithStreamingResponse(self._client.connections)
+
 
 class AsyncSupermemoryWithStreamedResponse:
+    _client: AsyncSupermemory
+
     def __init__(self, client: AsyncSupermemory) -> None:
-        self.memories = memories.AsyncMemoriesResourceWithStreamingResponse(client.memories)
-        self.documents = documents.AsyncDocumentsResourceWithStreamingResponse(client.documents)
-        self.search = search.AsyncSearchResourceWithStreamingResponse(client.search)
-        self.settings = settings.AsyncSettingsResourceWithStreamingResponse(client.settings)
-        self.connections = connections.AsyncConnectionsResourceWithStreamingResponse(client.connections)
+        self._client = client
 
         self.add = async_to_streamed_response_wrapper(
             client.add,
@@ -677,6 +821,36 @@ class AsyncSupermemoryWithStreamedResponse:
             client.profile,
         )
 
+    @cached_property
+    def memories(self) -> memories.AsyncMemoriesResourceWithStreamingResponse:
+        from .resources.memories import AsyncMemoriesResourceWithStreamingResponse
+
+        return AsyncMemoriesResourceWithStreamingResponse(self._client.memories)
+
+    @cached_property
+    def documents(self) -> documents.AsyncDocumentsResourceWithStreamingResponse:
+        from .resources.documents import AsyncDocumentsResourceWithStreamingResponse
+
+        return AsyncDocumentsResourceWithStreamingResponse(self._client.documents)
+
+    @cached_property
+    def search(self) -> search.AsyncSearchResourceWithStreamingResponse:
+        from .resources.search import AsyncSearchResourceWithStreamingResponse
+
+        return AsyncSearchResourceWithStreamingResponse(self._client.search)
+
+    @cached_property
+    def settings(self) -> settings.AsyncSettingsResourceWithStreamingResponse:
+        from .resources.settings import AsyncSettingsResourceWithStreamingResponse
+
+        return AsyncSettingsResourceWithStreamingResponse(self._client.settings)
+
+    @cached_property
+    def connections(self) -> connections.AsyncConnectionsResourceWithStreamingResponse:
+        from .resources.connections import AsyncConnectionsResourceWithStreamingResponse
+
+        return AsyncConnectionsResourceWithStreamingResponse(self._client.connections)
+
 
 Client = Supermemory
 

supermemory/_models.py

@@ -3,7 +3,20 @@ from __future__ import annotations
 import os
 import inspect
 import weakref
-from typing import TYPE_CHECKING, Any, Type, Union, Generic, TypeVar, Callable, Optional, cast
+from typing import (
+    IO,
+    TYPE_CHECKING,
+    Any,
+    Type,
+    Union,
+    Generic,
+    TypeVar,
+    Callable,
+    Iterable,
+    Optional,
+    AsyncIterable,
+    cast,
+)
 from datetime import date, datetime
 from typing_extensions import (
     List,
@@ -787,6 +800,7 @@ class FinalRequestOptionsInput(TypedDict, total=False):
     timeout: float | Timeout | None
     files: HttpxRequestFiles | None
     idempotency_key: str
+    content: Union[bytes, bytearray, IO[bytes], Iterable[bytes], AsyncIterable[bytes], None]
     json_data: Body
     extra_json: AnyMapping
     follow_redirects: bool
@@ -805,6 +819,7 @@ class FinalRequestOptions(pydantic.BaseModel):
     post_parser: Union[Callable[[Any], Any], NotGiven] = NotGiven()
     follow_redirects: Union[bool, None] = None
 
+    content: Union[bytes, bytearray, IO[bytes], Iterable[bytes], AsyncIterable[bytes], None] = None
     # It should be noted that we cannot use `json` here as that would override
     # a BaseModel method in an incompatible fashion.
     json_data: Union[Body, None] = None

supermemory/_streaming.py

@@ -54,11 +54,12 @@ class Stream(Generic[_T]):
         process_data = self._client._process_response_data
         iterator = self._iter_events()
 
-        for sse in iterator:
-            yield process_data(data=sse.json(), cast_to=cast_to, response=response)
-
-        # As we might not fully consume the response stream, we need to close it explicitly
-        response.close()
+        try:
+            for sse in iterator:
+                yield process_data(data=sse.json(), cast_to=cast_to, response=response)
+        finally:
+            # Ensure the response is closed even if the consumer doesn't read all data
+            response.close()
 
     def __enter__(self) -> Self:
         return self
@@ -117,11 +118,12 @@ class AsyncStream(Generic[_T]):
         process_data = self._client._process_response_data
         iterator = self._iter_events()
 
-        async for sse in iterator:
-            yield process_data(data=sse.json(), cast_to=cast_to, response=response)
-
-        # As we might not fully consume the response stream, we need to close it explicitly
-        await response.aclose()
+        try:
+            async for sse in iterator:
+                yield process_data(data=sse.json(), cast_to=cast_to, response=response)
+        finally:
+            # Ensure the response is closed even if the consumer doesn't read all data
+            await response.aclose()
 
     async def __aenter__(self) -> Self:
         return self

supermemory/_types.py

@@ -13,9 +13,11 @@ from typing import (
     Mapping,
     TypeVar,
     Callable,
+    Iterable,
     Iterator,
     Optional,
     Sequence,
+    AsyncIterable,
 )
 from typing_extensions import (
     Set,
@@ -56,6 +58,13 @@ if TYPE_CHECKING:
 else:
     Base64FileInput = Union[IO[bytes], PathLike]
     FileContent = Union[IO[bytes], bytes, PathLike]  # PathLike is not subscriptable in Python 3.8.
+
+
+# Used for sending raw binary data / streaming data in request bodies
+# e.g. for file uploads without multipart encoding
+BinaryTypes = Union[bytes, bytearray, IO[bytes], Iterable[bytes]]
+AsyncBinaryTypes = Union[bytes, bytearray, IO[bytes], AsyncIterable[bytes]]
+
 FileTypes = Union[
     # file (or bytes)
     FileContent,
@@ -243,6 +252,9 @@ _T_co = TypeVar("_T_co", covariant=True)
 if TYPE_CHECKING:
     # This works because str.__contains__ does not accept object (either in typeshed or at runtime)
     # https://github.com/hauntsaninja/useful_types/blob/5e9710f3875107d068e7679fd7fec9cfab0eff3b/useful_types/__init__.py#L285
+    #
+    # Note: index() and count() methods are intentionally omitted to allow pyright to properly
+    # infer TypedDict types when dict literals are used in lists assigned to SequenceNotStr.
     class SequenceNotStr(Protocol[_T_co]):
         @overload
         def __getitem__(self, index: SupportsIndex, /) -> _T_co: ...
@@ -251,8 +263,6 @@ if TYPE_CHECKING:
         def __contains__(self, value: object, /) -> bool: ...
         def __len__(self) -> int: ...
         def __iter__(self) -> Iterator[_T_co]: ...
-        def index(self, value: Any, start: int = 0, stop: int = ..., /) -> int: ...
-        def count(self, value: Any, /) -> int: ...
         def __reversed__(self) -> Iterator[_T_co]: ...
 else:
     # just point this to a normal `Sequence` at runtime to avoid having to special case

supermemory/_version.py

@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "supermemory"
-__version__ = "3.7.0"  # x-release-please-version
+__version__ = "3.19.0"  # x-release-please-version