supermemory 0.1.0a1__py3-none-any.whl → 3.0.0a2__py3-none-any.whl

supermemory/__init__.py

@@ -1,5 +1,7 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
+import typing as _t
+
 from . import types
 from ._types import NOT_GIVEN, Omit, NoneType, NotGiven, Transport, ProxiesTypes
 from ._utils import file_from_path
@@ -34,7 +36,7 @@ from ._exceptions import (
     UnprocessableEntityError,
     APIResponseValidationError,
 )
-from ._base_client import DefaultHttpxClient, DefaultAsyncHttpxClient
+from ._base_client import DefaultHttpxClient, DefaultAioHttpClient, DefaultAsyncHttpxClient
 from ._utils._logs import setup_logging as _setup_logging
 
 __all__ = [
@@ -76,8 +78,12 @@ __all__ = [
     "DEFAULT_CONNECTION_LIMITS",
     "DefaultHttpxClient",
     "DefaultAsyncHttpxClient",
+    "DefaultAioHttpClient",
 ]
 
+if not _t.TYPE_CHECKING:
+    from ._utils._resources_proxy import resources as resources
+
 _setup_logging()
 
 # Update the __module__ attribute for exported symbols so that

supermemory/_base_client.py

@@ -960,6 +960,9 @@ class SyncAPIClient(BaseClient[httpx.Client, Stream[Any]]):
             if self.custom_auth is not None:
                 kwargs["auth"] = self.custom_auth
 
+            if options.follow_redirects is not None:
+                kwargs["follow_redirects"] = options.follow_redirects
+
             log.debug("Sending HTTP Request: %s %s", request.method, request.url)
 
             response = None
@@ -1068,7 +1071,14 @@ class SyncAPIClient(BaseClient[httpx.Client, Stream[Any]]):
     ) -> ResponseT:
         origin = get_origin(cast_to) or cast_to
 
-        if inspect.isclass(origin) and issubclass(origin, BaseAPIResponse):
+        if (
+            inspect.isclass(origin)
+            and issubclass(origin, BaseAPIResponse)
+            # we only want to actually return the custom BaseAPIResponse class if we're
+            # returning the raw response, or if we're not streaming SSE, as if we're streaming
+            # SSE then `cast_to` doesn't actively reflect the type we need to parse into
+            and (not stream or bool(response.request.headers.get(RAW_RESPONSE_HEADER)))
+        ):
             if not issubclass(origin, APIResponse):
                 raise TypeError(f"API Response types must subclass {APIResponse}; Received {origin}")
 
@@ -1279,6 +1289,24 @@ class _DefaultAsyncHttpxClient(httpx.AsyncClient):
         super().__init__(**kwargs)
 
 
+try:
+    import httpx_aiohttp
+except ImportError:
+
+    class _DefaultAioHttpClient(httpx.AsyncClient):
+        def __init__(self, **_kwargs: Any) -> None:
+            raise RuntimeError("To use the aiohttp client you must have installed the package with the `aiohttp` extra")
+else:
+
+    class _DefaultAioHttpClient(httpx_aiohttp.HttpxAiohttpClient):  # type: ignore
+        def __init__(self, **kwargs: Any) -> None:
+            kwargs.setdefault("timeout", DEFAULT_TIMEOUT)
+            kwargs.setdefault("limits", DEFAULT_CONNECTION_LIMITS)
+            kwargs.setdefault("follow_redirects", True)
+
+            super().__init__(**kwargs)
+
+
 if TYPE_CHECKING:
     DefaultAsyncHttpxClient = httpx.AsyncClient
     """An alias to `httpx.AsyncClient` that provides the same defaults that this SDK
@@ -1287,8 +1315,12 @@ if TYPE_CHECKING:
     This is useful because overriding the `http_client` with your own instance of
     `httpx.AsyncClient` will result in httpx's defaults being used, not ours.
     """
+
+    DefaultAioHttpClient = httpx.AsyncClient
+    """An alias to `httpx.AsyncClient` that changes the default HTTP transport to `aiohttp`."""
 else:
     DefaultAsyncHttpxClient = _DefaultAsyncHttpxClient
+    DefaultAioHttpClient = _DefaultAioHttpClient
 
 
 class AsyncHttpxClientWrapper(DefaultAsyncHttpxClient):
@@ -1460,6 +1492,9 @@ class AsyncAPIClient(BaseClient[httpx.AsyncClient, AsyncStream[Any]]):
             if self.custom_auth is not None:
                 kwargs["auth"] = self.custom_auth
 
+            if options.follow_redirects is not None:
+                kwargs["follow_redirects"] = options.follow_redirects
+
             log.debug("Sending HTTP Request: %s %s", request.method, request.url)
 
             response = None
@@ -1568,7 +1603,14 @@ class AsyncAPIClient(BaseClient[httpx.AsyncClient, AsyncStream[Any]]):
     ) -> ResponseT:
         origin = get_origin(cast_to) or cast_to
 
-        if inspect.isclass(origin) and issubclass(origin, BaseAPIResponse):
+        if (
+            inspect.isclass(origin)
+            and issubclass(origin, BaseAPIResponse)
+            # we only want to actually return the custom BaseAPIResponse class if we're
+            # returning the raw response, or if we're not streaming SSE, as if we're streaming
+            # SSE then `cast_to` doesn't actively reflect the type we need to parse into
+            and (not stream or bool(response.request.headers.get(RAW_RESPONSE_HEADER)))
+        ):
             if not issubclass(origin, AsyncAPIResponse):
                 raise TypeError(f"API Response types must subclass {AsyncAPIResponse}; Received {origin}")
 

supermemory/_client.py

@@ -21,7 +21,7 @@ from ._types import (
 )
 from ._utils import is_given, get_async_library
 from ._version import __version__
-from .resources import memory, search, settings, connection
+from .resources import memories, settings, connections
 from ._streaming import Stream as Stream, AsyncStream as AsyncStream
 from ._exceptions import APIStatusError, SupermemoryError
 from ._base_client import (
@@ -43,10 +43,9 @@ __all__ = [
 
 
 class Supermemory(SyncAPIClient):
+    memories: memories.MemoriesResource
     settings: settings.SettingsResource
-    memory: memory.MemoryResource
-    search: search.SearchResource
-    connection: connection.ConnectionResource
+    connections: connections.ConnectionsResource
     with_raw_response: SupermemoryWithRawResponse
     with_streaming_response: SupermemoryWithStreamedResponse
 
@@ -91,7 +90,7 @@ class Supermemory(SyncAPIClient):
         if base_url is None:
             base_url = os.environ.get("SUPERMEMORY_BASE_URL")
         if base_url is None:
-            base_url = f"https://v2.api.supermemory.ai"
+            base_url = f"https://api.supermemory.ai/"
 
         super().__init__(
             version=__version__,
@@ -104,10 +103,9 @@ class Supermemory(SyncAPIClient):
             _strict_response_validation=_strict_response_validation,
         )
 
+        self.memories = memories.MemoriesResource(self)
         self.settings = settings.SettingsResource(self)
-        self.memory = memory.MemoryResource(self)
-        self.search = search.SearchResource(self)
-        self.connection = connection.ConnectionResource(self)
+        self.connections = connections.ConnectionsResource(self)
         self.with_raw_response = SupermemoryWithRawResponse(self)
         self.with_streaming_response = SupermemoryWithStreamedResponse(self)
 
@@ -120,7 +118,7 @@ class Supermemory(SyncAPIClient):
     @override
     def auth_headers(self) -> dict[str, str]:
         api_key = self.api_key
-        return {"X-API-Key": api_key}
+        return {"Authorization": f"Bearer {api_key}"}
 
     @property
     @override
@@ -217,10 +215,9 @@ class Supermemory(SyncAPIClient):
 
 
 class AsyncSupermemory(AsyncAPIClient):
+    memories: memories.AsyncMemoriesResource
     settings: settings.AsyncSettingsResource
-    memory: memory.AsyncMemoryResource
-    search: search.AsyncSearchResource
-    connection: connection.AsyncConnectionResource
+    connections: connections.AsyncConnectionsResource
     with_raw_response: AsyncSupermemoryWithRawResponse
     with_streaming_response: AsyncSupermemoryWithStreamedResponse
 
@@ -265,7 +262,7 @@ class AsyncSupermemory(AsyncAPIClient):
         if base_url is None:
             base_url = os.environ.get("SUPERMEMORY_BASE_URL")
         if base_url is None:
-            base_url = f"https://v2.api.supermemory.ai"
+            base_url = f"https://api.supermemory.ai/"
 
         super().__init__(
             version=__version__,
@@ -278,10 +275,9 @@ class AsyncSupermemory(AsyncAPIClient):
             _strict_response_validation=_strict_response_validation,
         )
 
+        self.memories = memories.AsyncMemoriesResource(self)
         self.settings = settings.AsyncSettingsResource(self)
-        self.memory = memory.AsyncMemoryResource(self)
-        self.search = search.AsyncSearchResource(self)
-        self.connection = connection.AsyncConnectionResource(self)
+        self.connections = connections.AsyncConnectionsResource(self)
         self.with_raw_response = AsyncSupermemoryWithRawResponse(self)
         self.with_streaming_response = AsyncSupermemoryWithStreamedResponse(self)
 
@@ -294,7 +290,7 @@ class AsyncSupermemory(AsyncAPIClient):
     @override
     def auth_headers(self) -> dict[str, str]:
         api_key = self.api_key
-        return {"X-API-Key": api_key}
+        return {"Authorization": f"Bearer {api_key}"}
 
     @property
     @override
@@ -392,34 +388,30 @@ class AsyncSupermemory(AsyncAPIClient):
 
 class SupermemoryWithRawResponse:
     def __init__(self, client: Supermemory) -> None:
+        self.memories = memories.MemoriesResourceWithRawResponse(client.memories)
         self.settings = settings.SettingsResourceWithRawResponse(client.settings)
-        self.memory = memory.MemoryResourceWithRawResponse(client.memory)
-        self.search = search.SearchResourceWithRawResponse(client.search)
-        self.connection = connection.ConnectionResourceWithRawResponse(client.connection)
+        self.connections = connections.ConnectionsResourceWithRawResponse(client.connections)
 
 
 class AsyncSupermemoryWithRawResponse:
     def __init__(self, client: AsyncSupermemory) -> None:
+        self.memories = memories.AsyncMemoriesResourceWithRawResponse(client.memories)
         self.settings = settings.AsyncSettingsResourceWithRawResponse(client.settings)
-        self.memory = memory.AsyncMemoryResourceWithRawResponse(client.memory)
-        self.search = search.AsyncSearchResourceWithRawResponse(client.search)
-        self.connection = connection.AsyncConnectionResourceWithRawResponse(client.connection)
+        self.connections = connections.AsyncConnectionsResourceWithRawResponse(client.connections)
 
 
 class SupermemoryWithStreamedResponse:
     def __init__(self, client: Supermemory) -> None:
+        self.memories = memories.MemoriesResourceWithStreamingResponse(client.memories)
         self.settings = settings.SettingsResourceWithStreamingResponse(client.settings)
-        self.memory = memory.MemoryResourceWithStreamingResponse(client.memory)
-        self.search = search.SearchResourceWithStreamingResponse(client.search)
-        self.connection = connection.ConnectionResourceWithStreamingResponse(client.connection)
+        self.connections = connections.ConnectionsResourceWithStreamingResponse(client.connections)
 
 
 class AsyncSupermemoryWithStreamedResponse:
     def __init__(self, client: AsyncSupermemory) -> None:
+        self.memories = memories.AsyncMemoriesResourceWithStreamingResponse(client.memories)
         self.settings = settings.AsyncSettingsResourceWithStreamingResponse(client.settings)
-        self.memory = memory.AsyncMemoryResourceWithStreamingResponse(client.memory)
-        self.search = search.AsyncSearchResourceWithStreamingResponse(client.search)
-        self.connection = connection.AsyncConnectionResourceWithStreamingResponse(client.connection)
+        self.connections = connections.AsyncConnectionsResourceWithStreamingResponse(client.connections)
 
 
 Client = Supermemory

supermemory/_models.py

@@ -737,6 +737,7 @@ class FinalRequestOptionsInput(TypedDict, total=False):
     idempotency_key: str
     json_data: Body
     extra_json: AnyMapping
+    follow_redirects: bool
 
 
 @final
@@ -750,6 +751,7 @@ class FinalRequestOptions(pydantic.BaseModel):
     files: Union[HttpxRequestFiles, None] = None
     idempotency_key: Union[str, None] = None
     post_parser: Union[Callable[[Any], Any], NotGiven] = NotGiven()
+    follow_redirects: Union[bool, None] = None
 
     # It should be noted that we cannot use `json` here as that would override
     # a BaseModel method in an incompatible fashion.

supermemory/_types.py

@@ -100,6 +100,7 @@ class RequestOptions(TypedDict, total=False):
     params: Query
     extra_json: AnyMapping
     idempotency_key: str
+    follow_redirects: bool
 
 
 # Sentinel class used until PEP 0661 is accepted
@@ -215,3 +216,4 @@ class _GenericAlias(Protocol):
 
 class HttpxSendArgs(TypedDict, total=False):
     auth: httpx.Auth
+    follow_redirects: bool

supermemory/_utils/_proxy.py

@@ -46,7 +46,10 @@ class LazyProxy(Generic[T], ABC):
     @property  # type: ignore
     @override
     def __class__(self) -> type:  # pyright: ignore
-        proxied = self.__get_proxied__()
+        try:
+            proxied = self.__get_proxied__()
+        except Exception:
+            return type(self)
         if issubclass(type(proxied), LazyProxy):
             return type(proxied)
         return proxied.__class__

supermemory/_utils/_resources_proxy.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from typing import Any
+from typing_extensions import override
+
+from ._proxy import LazyProxy
+
+
+class ResourcesProxy(LazyProxy[Any]):
+    """A proxy for the `supermemory.resources` module.
+
+    This is used so that we can lazily import `supermemory.resources` only when
+    needed *and* so that users can just import `supermemory` and reference `supermemory.resources`
+    """
+
+    @override
+    def __load__(self) -> Any:
+        import importlib
+
+        mod = importlib.import_module("supermemory.resources")
+        return mod
+
+
+resources = ResourcesProxy().__as_proxied__()

supermemory/_version.py

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

supermemory/resources/__init__.py

@@ -1,20 +1,12 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-from .memory import (
-    MemoryResource,
-    AsyncMemoryResource,
-    MemoryResourceWithRawResponse,
-    AsyncMemoryResourceWithRawResponse,
-    MemoryResourceWithStreamingResponse,
-    AsyncMemoryResourceWithStreamingResponse,
-)
-from .search import (
-    SearchResource,
-    AsyncSearchResource,
-    SearchResourceWithRawResponse,
-    AsyncSearchResourceWithRawResponse,
-    SearchResourceWithStreamingResponse,
-    AsyncSearchResourceWithStreamingResponse,
+from .memories import (
+    MemoriesResource,
+    AsyncMemoriesResource,
+    MemoriesResourceWithRawResponse,
+    AsyncMemoriesResourceWithRawResponse,
+    MemoriesResourceWithStreamingResponse,
+    AsyncMemoriesResourceWithStreamingResponse,
 )
 from .settings import (
     SettingsResource,
@@ -24,38 +16,32 @@ from .settings import (
     SettingsResourceWithStreamingResponse,
     AsyncSettingsResourceWithStreamingResponse,
 )
-from .connection import (
-    ConnectionResource,
-    AsyncConnectionResource,
-    ConnectionResourceWithRawResponse,
-    AsyncConnectionResourceWithRawResponse,
-    ConnectionResourceWithStreamingResponse,
-    AsyncConnectionResourceWithStreamingResponse,
+from .connections import (
+    ConnectionsResource,
+    AsyncConnectionsResource,
+    ConnectionsResourceWithRawResponse,
+    AsyncConnectionsResourceWithRawResponse,
+    ConnectionsResourceWithStreamingResponse,
+    AsyncConnectionsResourceWithStreamingResponse,
 )
 
 __all__ = [
+    "MemoriesResource",
+    "AsyncMemoriesResource",
+    "MemoriesResourceWithRawResponse",
+    "AsyncMemoriesResourceWithRawResponse",
+    "MemoriesResourceWithStreamingResponse",
+    "AsyncMemoriesResourceWithStreamingResponse",
     "SettingsResource",
     "AsyncSettingsResource",
     "SettingsResourceWithRawResponse",
     "AsyncSettingsResourceWithRawResponse",
     "SettingsResourceWithStreamingResponse",
     "AsyncSettingsResourceWithStreamingResponse",
-    "MemoryResource",
-    "AsyncMemoryResource",
-    "MemoryResourceWithRawResponse",
-    "AsyncMemoryResourceWithRawResponse",
-    "MemoryResourceWithStreamingResponse",
-    "AsyncMemoryResourceWithStreamingResponse",
-    "SearchResource",
-    "AsyncSearchResource",
-    "SearchResourceWithRawResponse",
-    "AsyncSearchResourceWithRawResponse",
-    "SearchResourceWithStreamingResponse",
-    "AsyncSearchResourceWithStreamingResponse",
-    "ConnectionResource",
-    "AsyncConnectionResource",
-    "ConnectionResourceWithRawResponse",
-    "AsyncConnectionResourceWithRawResponse",
-    "ConnectionResourceWithStreamingResponse",
-    "AsyncConnectionResourceWithStreamingResponse",
+    "ConnectionsResource",
+    "AsyncConnectionsResource",
+    "ConnectionsResourceWithRawResponse",
+    "AsyncConnectionsResourceWithRawResponse",
+    "ConnectionsResourceWithStreamingResponse",
+    "AsyncConnectionsResourceWithStreamingResponse",
 ]