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

supermemory/resources/{memory.py → memories.py}

@@ -2,14 +2,14 @@
 
 from __future__ import annotations
 
-from typing import Dict, Union
+from typing import Dict, List, Union, Mapping, cast
 from typing_extensions import Literal
 
 import httpx
 
-from ..types import memory_list_params, memory_create_params
-from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven
-from .._utils import maybe_transform, async_maybe_transform
+from ..types import memory_add_params, memory_list_params, memory_update_params, memory_upload_file_params
+from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven, FileTypes
+from .._utils import extract_files, maybe_transform, deepcopy_minimal, async_maybe_transform
 from .._compat import cached_property
 from .._resource import SyncAPIResource, AsyncAPIResource
 from .._response import (
@@ -19,58 +19,54 @@ from .._response import (
     async_to_streamed_response_wrapper,
 )
 from .._base_client import make_request_options
+from ..types.memory_add_response import MemoryAddResponse
 from ..types.memory_get_response import MemoryGetResponse
 from ..types.memory_list_response import MemoryListResponse
-from ..types.memory_create_response import MemoryCreateResponse
 from ..types.memory_delete_response import MemoryDeleteResponse
+from ..types.memory_update_response import MemoryUpdateResponse
+from ..types.memory_upload_file_response import MemoryUploadFileResponse
 
-__all__ = ["MemoryResource", "AsyncMemoryResource"]
+__all__ = ["MemoriesResource", "AsyncMemoriesResource"]
 
 
-class MemoryResource(SyncAPIResource):
+class MemoriesResource(SyncAPIResource):
     @cached_property
-    def with_raw_response(self) -> MemoryResourceWithRawResponse:
+    def with_raw_response(self) -> MemoriesResourceWithRawResponse:
         """
         This property can be used as a prefix for any HTTP method call to return
         the raw response object instead of the parsed content.
 
         For more information, see https://www.github.com/supermemoryai/python-sdk#accessing-raw-response-data-eg-headers
         """
-        return MemoryResourceWithRawResponse(self)
+        return MemoriesResourceWithRawResponse(self)
 
     @cached_property
-    def with_streaming_response(self) -> MemoryResourceWithStreamingResponse:
+    def with_streaming_response(self) -> MemoriesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
         For more information, see https://www.github.com/supermemoryai/python-sdk#with_streaming_response
         """
-        return MemoryResourceWithStreamingResponse(self)
+        return MemoriesResourceWithStreamingResponse(self)
 
-    def create(
+    def update(
         self,
+        id: str,
         *,
         content: str,
-        id: str | NotGiven = NOT_GIVEN,
+        container_tags: List[str] | NotGiven = NOT_GIVEN,
         metadata: Dict[str, Union[str, float, bool]] | NotGiven = NOT_GIVEN,
-        user_id: str | NotGiven = NOT_GIVEN,
         # 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,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> MemoryCreateResponse:
+    ) -> MemoryUpdateResponse:
         """
-        Add a new memory with content and metadata
+        Update a memory with any content type (text, url, file, etc.) and metadata
 
         Args:
-          content: Content of the memory
-
-          metadata: Optional metadata for the memory
-
-          user_id: Optional end user ID this memory belongs to
-
           extra_headers: Send extra headers
 
           extra_query: Add additional query parameters to the request
@@ -79,21 +75,22 @@ class MemoryResource(SyncAPIResource):
 
           timeout: Override the client-level default timeout for this request, in seconds
         """
-        return self._post(
-            "/add",
+        if not id:
+            raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
+        return self._patch(
+            f"/v3/memories/{id}",
             body=maybe_transform(
                 {
                     "content": content,
-                    "id": id,
+                    "container_tags": container_tags,
                     "metadata": metadata,
-                    "user_id": user_id,
                 },
-                memory_create_params.MemoryCreateParams,
+                memory_update_params.MemoryUpdateParams,
             ),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
-            cast_to=MemoryCreateResponse,
+            cast_to=MemoryUpdateResponse,
         )
 
     def list(
@@ -134,7 +131,7 @@ class MemoryResource(SyncAPIResource):
           timeout: Override the client-level default timeout for this request, in seconds
         """
         return self._get(
-            "/memories",
+            "/v3/memories",
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,
@@ -180,13 +177,54 @@ class MemoryResource(SyncAPIResource):
         if not id:
             raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
         return self._delete(
-            f"/delete/{id}",
+            f"/v3/memories/{id}",
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
             cast_to=MemoryDeleteResponse,
         )
 
+    def add(
+        self,
+        *,
+        content: str,
+        container_tags: List[str] | NotGiven = NOT_GIVEN,
+        metadata: Dict[str, Union[str, float, bool]] | NotGiven = NOT_GIVEN,
+        # 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,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> MemoryAddResponse:
+        """
+        Add a memory with any content type (text, url, file, etc.) and metadata
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return self._post(
+            "/v3/memories",
+            body=maybe_transform(
+                {
+                    "content": content,
+                    "container_tags": container_tags,
+                    "metadata": metadata,
+                },
+                memory_add_params.MemoryAddParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=MemoryAddResponse,
+        )
+
     def get(
         self,
         id: str,
@@ -213,58 +251,91 @@ class MemoryResource(SyncAPIResource):
         if not id:
             raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
         return self._get(
-            f"/memory/{id}",
+            f"/v3/memories/{id}",
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
             cast_to=MemoryGetResponse,
         )
 
+    def upload_file(
+        self,
+        *,
+        file: FileTypes,
+        # 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,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> MemoryUploadFileResponse:
+        """
+        Upload a file to be processed
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        body = deepcopy_minimal({"file": file})
+        files = extract_files(cast(Mapping[str, object], body), paths=[["file"]])
+        # It should be noted that the actual Content-Type header that will be
+        # sent to the server will contain a `boundary` parameter, e.g.
+        # multipart/form-data; boundary=---abc--
+        extra_headers = {"Content-Type": "multipart/form-data", **(extra_headers or {})}
+        return self._post(
+            "/v3/memories/file",
+            body=maybe_transform(body, memory_upload_file_params.MemoryUploadFileParams),
+            files=files,
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=MemoryUploadFileResponse,
+        )
+
 
-class AsyncMemoryResource(AsyncAPIResource):
+class AsyncMemoriesResource(AsyncAPIResource):
     @cached_property
-    def with_raw_response(self) -> AsyncMemoryResourceWithRawResponse:
+    def with_raw_response(self) -> AsyncMemoriesResourceWithRawResponse:
         """
         This property can be used as a prefix for any HTTP method call to return
         the raw response object instead of the parsed content.
 
         For more information, see https://www.github.com/supermemoryai/python-sdk#accessing-raw-response-data-eg-headers
         """
-        return AsyncMemoryResourceWithRawResponse(self)
+        return AsyncMemoriesResourceWithRawResponse(self)
 
     @cached_property
-    def with_streaming_response(self) -> AsyncMemoryResourceWithStreamingResponse:
+    def with_streaming_response(self) -> AsyncMemoriesResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
         For more information, see https://www.github.com/supermemoryai/python-sdk#with_streaming_response
         """
-        return AsyncMemoryResourceWithStreamingResponse(self)
+        return AsyncMemoriesResourceWithStreamingResponse(self)
 
-    async def create(
+    async def update(
         self,
+        id: str,
         *,
         content: str,
-        id: str | NotGiven = NOT_GIVEN,
+        container_tags: List[str] | NotGiven = NOT_GIVEN,
         metadata: Dict[str, Union[str, float, bool]] | NotGiven = NOT_GIVEN,
-        user_id: str | NotGiven = NOT_GIVEN,
         # 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,
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> MemoryCreateResponse:
+    ) -> MemoryUpdateResponse:
         """
-        Add a new memory with content and metadata
+        Update a memory with any content type (text, url, file, etc.) and metadata
 
         Args:
-          content: Content of the memory
-
-          metadata: Optional metadata for the memory
-
-          user_id: Optional end user ID this memory belongs to
-
           extra_headers: Send extra headers
 
           extra_query: Add additional query parameters to the request
@@ -273,21 +344,22 @@ class AsyncMemoryResource(AsyncAPIResource):
 
           timeout: Override the client-level default timeout for this request, in seconds
         """
-        return await self._post(
-            "/add",
+        if not id:
+            raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
+        return await self._patch(
+            f"/v3/memories/{id}",
             body=await async_maybe_transform(
                 {
                     "content": content,
-                    "id": id,
+                    "container_tags": container_tags,
                     "metadata": metadata,
-                    "user_id": user_id,
                 },
-                memory_create_params.MemoryCreateParams,
+                memory_update_params.MemoryUpdateParams,
             ),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
-            cast_to=MemoryCreateResponse,
+            cast_to=MemoryUpdateResponse,
         )
 
     async def list(
@@ -328,7 +400,7 @@ class AsyncMemoryResource(AsyncAPIResource):
           timeout: Override the client-level default timeout for this request, in seconds
         """
         return await self._get(
-            "/memories",
+            "/v3/memories",
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,
@@ -374,13 +446,54 @@ class AsyncMemoryResource(AsyncAPIResource):
         if not id:
             raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
         return await self._delete(
-            f"/delete/{id}",
+            f"/v3/memories/{id}",
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
             cast_to=MemoryDeleteResponse,
         )
 
+    async def add(
+        self,
+        *,
+        content: str,
+        container_tags: List[str] | NotGiven = NOT_GIVEN,
+        metadata: Dict[str, Union[str, float, bool]] | NotGiven = NOT_GIVEN,
+        # 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,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> MemoryAddResponse:
+        """
+        Add a memory with any content type (text, url, file, etc.) and metadata
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return await self._post(
+            "/v3/memories",
+            body=await async_maybe_transform(
+                {
+                    "content": content,
+                    "container_tags": container_tags,
+                    "metadata": metadata,
+                },
+                memory_add_params.MemoryAddParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=MemoryAddResponse,
+        )
+
     async def get(
         self,
         id: str,
@@ -407,81 +520,144 @@ class AsyncMemoryResource(AsyncAPIResource):
         if not id:
             raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
         return await self._get(
-            f"/memory/{id}",
+            f"/v3/memories/{id}",
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
             cast_to=MemoryGetResponse,
         )
 
+    async def upload_file(
+        self,
+        *,
+        file: FileTypes,
+        # 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,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> MemoryUploadFileResponse:
+        """
+        Upload a file to be processed
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        body = deepcopy_minimal({"file": file})
+        files = extract_files(cast(Mapping[str, object], body), paths=[["file"]])
+        # It should be noted that the actual Content-Type header that will be
+        # sent to the server will contain a `boundary` parameter, e.g.
+        # multipart/form-data; boundary=---abc--
+        extra_headers = {"Content-Type": "multipart/form-data", **(extra_headers or {})}
+        return await self._post(
+            "/v3/memories/file",
+            body=await async_maybe_transform(body, memory_upload_file_params.MemoryUploadFileParams),
+            files=files,
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=MemoryUploadFileResponse,
+        )
+
 
-class MemoryResourceWithRawResponse:
-    def __init__(self, memory: MemoryResource) -> None:
-        self._memory = memory
+class MemoriesResourceWithRawResponse:
+    def __init__(self, memories: MemoriesResource) -> None:
+        self._memories = memories
 
-        self.create = to_raw_response_wrapper(
-            memory.create,
+        self.update = to_raw_response_wrapper(
+            memories.update,
         )
         self.list = to_raw_response_wrapper(
-            memory.list,
+            memories.list,
         )
         self.delete = to_raw_response_wrapper(
-            memory.delete,
+            memories.delete,
+        )
+        self.add = to_raw_response_wrapper(
+            memories.add,
         )
         self.get = to_raw_response_wrapper(
-            memory.get,
+            memories.get,
+        )
+        self.upload_file = to_raw_response_wrapper(
+            memories.upload_file,
         )
 
 
-class AsyncMemoryResourceWithRawResponse:
-    def __init__(self, memory: AsyncMemoryResource) -> None:
-        self._memory = memory
+class AsyncMemoriesResourceWithRawResponse:
+    def __init__(self, memories: AsyncMemoriesResource) -> None:
+        self._memories = memories
 
-        self.create = async_to_raw_response_wrapper(
-            memory.create,
+        self.update = async_to_raw_response_wrapper(
+            memories.update,
         )
         self.list = async_to_raw_response_wrapper(
-            memory.list,
+            memories.list,
         )
         self.delete = async_to_raw_response_wrapper(
-            memory.delete,
+            memories.delete,
+        )
+        self.add = async_to_raw_response_wrapper(
+            memories.add,
         )
         self.get = async_to_raw_response_wrapper(
-            memory.get,
+            memories.get,
+        )
+        self.upload_file = async_to_raw_response_wrapper(
+            memories.upload_file,
         )
 
 
-class MemoryResourceWithStreamingResponse:
-    def __init__(self, memory: MemoryResource) -> None:
-        self._memory = memory
+class MemoriesResourceWithStreamingResponse:
+    def __init__(self, memories: MemoriesResource) -> None:
+        self._memories = memories
 
-        self.create = to_streamed_response_wrapper(
-            memory.create,
+        self.update = to_streamed_response_wrapper(
+            memories.update,
         )
         self.list = to_streamed_response_wrapper(
-            memory.list,
+            memories.list,
         )
         self.delete = to_streamed_response_wrapper(
-            memory.delete,
+            memories.delete,
+        )
+        self.add = to_streamed_response_wrapper(
+            memories.add,
         )
         self.get = to_streamed_response_wrapper(
-            memory.get,
+            memories.get,
+        )
+        self.upload_file = to_streamed_response_wrapper(
+            memories.upload_file,
         )
 
 
-class AsyncMemoryResourceWithStreamingResponse:
-    def __init__(self, memory: AsyncMemoryResource) -> None:
-        self._memory = memory
+class AsyncMemoriesResourceWithStreamingResponse:
+    def __init__(self, memories: AsyncMemoriesResource) -> None:
+        self._memories = memories
 
-        self.create = async_to_streamed_response_wrapper(
-            memory.create,
+        self.update = async_to_streamed_response_wrapper(
+            memories.update,
         )
         self.list = async_to_streamed_response_wrapper(
-            memory.list,
+            memories.list,
         )
         self.delete = async_to_streamed_response_wrapper(
-            memory.delete,
+            memories.delete,
+        )
+        self.add = async_to_streamed_response_wrapper(
+            memories.add,
         )
         self.get = async_to_streamed_response_wrapper(
-            memory.get,
+            memories.get,
+        )
+        self.upload_file = async_to_streamed_response_wrapper(
+            memories.upload_file,
         )