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

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

@@ -2,13 +2,12 @@
 
 from __future__ import annotations
 
-from typing import Dict, Union
-from typing_extensions import Literal
+from typing import Dict, List, Union
 
 import httpx
 
-from ..types import memory_list_params, memory_create_params
-from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+from ..types import memory_add_params, memory_update_params
+from .._types import NOT_GIVEN, Body, Query, Headers, NoneType, NotGiven
 from .._utils import maybe_transform, async_maybe_transform
 from .._compat import cached_property
 from .._resource import SyncAPIResource, AsyncAPIResource
@@ -19,57 +18,72 @@ 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
 
-__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,
+        custom_id: 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
+          content: The content to extract and process into a memory. This can be a URL to a
+              website, a PDF, an image, or a video.
+
+              Plaintext: Any plaintext format
+
+              URL: A URL to a website, PDF, image, or video
 
-          metadata: Optional metadata for the memory
+              We automatically detect the content type from the url's response format.
 
-          user_id: Optional end user ID this memory belongs to
+          container_tags: Optional tags this memory should be containerized by. This can be an ID for your
+              user, a project ID, or any other identifier you wish to use to group memories.
+
+          custom_id: Optional custom ID of the memory. This could be an ID from your database that
+              will uniquely identify this memory.
+
+          metadata: Optional metadata for the memory. This is used to store additional information
+              about the memory. You can use this to store any additional information you need
+              about the memory. Metadata can be filtered through. Keys must be strings and are
+              case sensitive. Values can be strings, numbers, or booleans. You cannot nest
+              objects.
 
           extra_headers: Send extra headers
 
@@ -79,52 +93,40 @@ 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,
+                    "custom_id": custom_id,
                     "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(
+    def delete(
         self,
+        id: str,
         *,
-        filters: str | NotGiven = NOT_GIVEN,
-        limit: str | NotGiven = NOT_GIVEN,
-        order: Literal["asc", "desc"] | NotGiven = NOT_GIVEN,
-        page: str | NotGiven = NOT_GIVEN,
-        sort: Literal["createdAt", "updatedAt"] | 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,
-    ) -> MemoryListResponse:
+    ) -> None:
         """
-        Retrieves a paginated list of memories with their metadata and workflow status
+        Delete a memory
 
         Args:
-          filters: Optional filters to apply to the search
-
-          limit: Number of items per page
-
-          order: Sort order
-
-          page: Page number to fetch
-
-          sort: Field to sort by
-
           extra_headers: Send extra headers
 
           extra_query: Add additional query parameters to the request
@@ -133,42 +135,56 @@ class MemoryResource(SyncAPIResource):
 
           timeout: Override the client-level default timeout for this request, in seconds
         """
-        return self._get(
-            "/memories",
+        if not id:
+            raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return self._delete(
+            f"/v3/memories/{id}",
             options=make_request_options(
-                extra_headers=extra_headers,
-                extra_query=extra_query,
-                extra_body=extra_body,
-                timeout=timeout,
-                query=maybe_transform(
-                    {
-                        "filters": filters,
-                        "limit": limit,
-                        "order": order,
-                        "page": page,
-                        "sort": sort,
-                    },
-                    memory_list_params.MemoryListParams,
-                ),
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
-            cast_to=MemoryListResponse,
+            cast_to=NoneType,
         )
 
-    def delete(
+    def add(
         self,
-        id: str,
         *,
+        content: str,
+        container_tags: List[str] | NotGiven = NOT_GIVEN,
+        custom_id: 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,
-    ) -> MemoryDeleteResponse:
+    ) -> MemoryAddResponse:
         """
-        Delete a memory
+        Add a memory with any content type (text, url, file, etc.) and metadata
 
         Args:
+          content: The content to extract and process into a memory. This can be a URL to a
+              website, a PDF, an image, or a video.
+
+              Plaintext: Any plaintext format
+
+              URL: A URL to a website, PDF, image, or video
+
+              We automatically detect the content type from the url's response format.
+
+          container_tags: Optional tags this memory should be containerized by. This can be an ID for your
+              user, a project ID, or any other identifier you wish to use to group memories.
+
+          custom_id: Optional custom ID of the memory. This could be an ID from your database that
+              will uniquely identify this memory.
+
+          metadata: Optional metadata for the memory. This is used to store additional information
+              about the memory. You can use this to store any additional information you need
+              about the memory. Metadata can be filtered through. Keys must be strings and are
+              case sensitive. Values can be strings, numbers, or booleans. You cannot nest
+              objects.
+
           extra_headers: Send extra headers
 
           extra_query: Add additional query parameters to the request
@@ -177,14 +193,21 @@ class MemoryResource(SyncAPIResource):
 
           timeout: Override the client-level default timeout for this request, in seconds
         """
-        if not id:
-            raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
-        return self._delete(
-            f"/delete/{id}",
+        return self._post(
+            "/v3/memories",
+            body=maybe_transform(
+                {
+                    "content": content,
+                    "container_tags": container_tags,
+                    "custom_id": custom_id,
+                    "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=MemoryDeleteResponse,
+            cast_to=MemoryAddResponse,
         )
 
     def get(
@@ -213,7 +236,7 @@ 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
             ),
@@ -221,49 +244,65 @@ class MemoryResource(SyncAPIResource):
         )
 
 
-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,
+        custom_id: 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
+          content: The content to extract and process into a memory. This can be a URL to a
+              website, a PDF, an image, or a video.
+
+              Plaintext: Any plaintext format
+
+              URL: A URL to a website, PDF, image, or video
+
+              We automatically detect the content type from the url's response format.
 
-          metadata: Optional metadata for the memory
+          container_tags: Optional tags this memory should be containerized by. This can be an ID for your
+              user, a project ID, or any other identifier you wish to use to group memories.
 
-          user_id: Optional end user ID this memory belongs to
+          custom_id: Optional custom ID of the memory. This could be an ID from your database that
+              will uniquely identify this memory.
+
+          metadata: Optional metadata for the memory. This is used to store additional information
+              about the memory. You can use this to store any additional information you need
+              about the memory. Metadata can be filtered through. Keys must be strings and are
+              case sensitive. Values can be strings, numbers, or booleans. You cannot nest
+              objects.
 
           extra_headers: Send extra headers
 
@@ -273,52 +312,40 @@ 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,
+                    "custom_id": custom_id,
                     "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(
+    async def delete(
         self,
+        id: str,
         *,
-        filters: str | NotGiven = NOT_GIVEN,
-        limit: str | NotGiven = NOT_GIVEN,
-        order: Literal["asc", "desc"] | NotGiven = NOT_GIVEN,
-        page: str | NotGiven = NOT_GIVEN,
-        sort: Literal["createdAt", "updatedAt"] | 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,
-    ) -> MemoryListResponse:
+    ) -> None:
         """
-        Retrieves a paginated list of memories with their metadata and workflow status
+        Delete a memory
 
         Args:
-          filters: Optional filters to apply to the search
-
-          limit: Number of items per page
-
-          order: Sort order
-
-          page: Page number to fetch
-
-          sort: Field to sort by
-
           extra_headers: Send extra headers
 
           extra_query: Add additional query parameters to the request
@@ -327,42 +354,56 @@ class AsyncMemoryResource(AsyncAPIResource):
 
           timeout: Override the client-level default timeout for this request, in seconds
         """
-        return await self._get(
-            "/memories",
+        if not id:
+            raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return await self._delete(
+            f"/v3/memories/{id}",
             options=make_request_options(
-                extra_headers=extra_headers,
-                extra_query=extra_query,
-                extra_body=extra_body,
-                timeout=timeout,
-                query=await async_maybe_transform(
-                    {
-                        "filters": filters,
-                        "limit": limit,
-                        "order": order,
-                        "page": page,
-                        "sort": sort,
-                    },
-                    memory_list_params.MemoryListParams,
-                ),
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
-            cast_to=MemoryListResponse,
+            cast_to=NoneType,
         )
 
-    async def delete(
+    async def add(
         self,
-        id: str,
         *,
+        content: str,
+        container_tags: List[str] | NotGiven = NOT_GIVEN,
+        custom_id: 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,
-    ) -> MemoryDeleteResponse:
+    ) -> MemoryAddResponse:
         """
-        Delete a memory
+        Add a memory with any content type (text, url, file, etc.) and metadata
 
         Args:
+          content: The content to extract and process into a memory. This can be a URL to a
+              website, a PDF, an image, or a video.
+
+              Plaintext: Any plaintext format
+
+              URL: A URL to a website, PDF, image, or video
+
+              We automatically detect the content type from the url's response format.
+
+          container_tags: Optional tags this memory should be containerized by. This can be an ID for your
+              user, a project ID, or any other identifier you wish to use to group memories.
+
+          custom_id: Optional custom ID of the memory. This could be an ID from your database that
+              will uniquely identify this memory.
+
+          metadata: Optional metadata for the memory. This is used to store additional information
+              about the memory. You can use this to store any additional information you need
+              about the memory. Metadata can be filtered through. Keys must be strings and are
+              case sensitive. Values can be strings, numbers, or booleans. You cannot nest
+              objects.
+
           extra_headers: Send extra headers
 
           extra_query: Add additional query parameters to the request
@@ -371,14 +412,21 @@ class AsyncMemoryResource(AsyncAPIResource):
 
           timeout: Override the client-level default timeout for this request, in seconds
         """
-        if not id:
-            raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
-        return await self._delete(
-            f"/delete/{id}",
+        return await self._post(
+            "/v3/memories",
+            body=await async_maybe_transform(
+                {
+                    "content": content,
+                    "container_tags": container_tags,
+                    "custom_id": custom_id,
+                    "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=MemoryDeleteResponse,
+            cast_to=MemoryAddResponse,
         )
 
     async def get(
@@ -407,7 +455,7 @@ 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
             ),
@@ -415,73 +463,73 @@ class AsyncMemoryResource(AsyncAPIResource):
         )
 
 
-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.list = to_raw_response_wrapper(
-            memory.list,
+        self.update = to_raw_response_wrapper(
+            memories.update,
         )
         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,
         )
 
 
-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.list = async_to_raw_response_wrapper(
-            memory.list,
+        self.update = async_to_raw_response_wrapper(
+            memories.update,
         )
         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,
         )
 
 
-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.list = to_streamed_response_wrapper(
-            memory.list,
+        self.update = to_streamed_response_wrapper(
+            memories.update,
         )
         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,
         )
 
 
-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.list = async_to_streamed_response_wrapper(
-            memory.list,
+        self.update = async_to_streamed_response_wrapper(
+            memories.update,
         )
         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,
         )