evermemos 0.3.8__py3-none-any.whl → 0.3.10__py3-none-any.whl

evermemos/resources/v1/memories/memories.py

@@ -2,14 +2,14 @@
 
 from __future__ import annotations
 
-from typing import Iterable, Optional
+from typing import Optional
 
 import httpx
 
 from ...._types import Body, Omit, Query, Headers, NotGiven, SequenceNotStr, omit, not_given
 from ...._utils import maybe_transform, async_maybe_transform
 from ...._compat import cached_property
-from ....types.v1 import memory_load_params, memory_create_params, memory_delete_params
+from ....types.v1 import memory_add_params, memory_delete_params
 from ...._resource import SyncAPIResource, AsyncAPIResource
 from ...._response import (
     to_raw_response_wrapper,
@@ -26,9 +26,8 @@ from .conversation_meta import (
     ConversationMetaResourceWithStreamingResponse,
     AsyncConversationMetaResourceWithStreamingResponse,
 )
+from ....types.v1.memory_add_response import MemoryAddResponse
 from ....types.v1.memory_get_response import MemoryGetResponse
-from ....types.v1.memory_load_response import MemoryLoadResponse
-from ....types.v1.memory_create_response import MemoryCreateResponse
 from ....types.v1.memory_delete_response import MemoryDeleteResponse
 from ....types.v1.memory_search_response import MemorySearchResponse
 
@@ -59,7 +58,62 @@ class MemoriesResource(SyncAPIResource):
         """
         return MemoriesResourceWithStreamingResponse(self)
 
-    def create(
+    def delete(
+        self,
+        *,
+        id: Optional[str] | Omit = omit,
+        event_id: Optional[str] | Omit = omit,
+        group_id: Optional[str] | Omit = omit,
+        memory_id: Optional[str] | Omit = omit,
+        user_id: Optional[str] | 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,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> MemoryDeleteResponse:
+        """
+        Delete memory records based on combined filter criteria
+
+        Args:
+          id: Alias for memory_id (backward compatibility)
+
+          event_id: Alias for memory_id (backward compatibility)
+
+          group_id: Group ID (filter condition)
+
+          memory_id: Memory id (filter condition)
+
+          user_id: User ID (filter condition)
+
+          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._delete(
+            "/api/v1/memories",
+            body=maybe_transform(
+                {
+                    "id": id,
+                    "event_id": event_id,
+                    "group_id": group_id,
+                    "memory_id": memory_id,
+                    "user_id": user_id,
+                },
+                memory_delete_params.MemoryDeleteParams,
+            ),
+            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,
@@ -78,7 +132,7 @@ class MemoriesResource(SyncAPIResource):
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = not_given,
-    ) -> MemoryCreateResponse:
+    ) -> MemoryAddResponse:
         """
         Store a single message into memory.
 
@@ -133,59 +187,12 @@ class MemoriesResource(SyncAPIResource):
                     "role": role,
                     "sender_name": sender_name,
                 },
-                memory_create_params.MemoryCreateParams,
-            ),
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=MemoryCreateResponse,
-        )
-
-    def delete(
-        self,
-        *,
-        group_id: Optional[str] | Omit = omit,
-        memory_id: Optional[str] | Omit = omit,
-        user_id: Optional[str] | 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,
-        extra_query: Query | None = None,
-        extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = not_given,
-    ) -> MemoryDeleteResponse:
-        """
-        Delete memory records based on combined filter criteria
-
-        Args:
-          group_id: Group ID (filter condition)
-
-          memory_id: Memory id (filter condition)
-
-          user_id: User ID (filter condition)
-
-          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._delete(
-            "/api/v1/memories",
-            body=maybe_transform(
-                {
-                    "group_id": group_id,
-                    "memory_id": memory_id,
-                    "user_id": user_id,
-                },
-                memory_delete_params.MemoryDeleteParams,
+                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(
@@ -207,55 +214,6 @@ class MemoriesResource(SyncAPIResource):
             cast_to=MemoryGetResponse,
         )
 
-    def load(
-        self,
-        *,
-        conversation_meta: memory_load_params.ConversationMeta,
-        conversation_list: Optional[Iterable[memory_load_params.ConversationList]] | Omit = omit,
-        version: Optional[str] | 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,
-        extra_query: Query | None = None,
-        extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = not_given,
-    ) -> MemoryLoadResponse:
-        """Import conversation metadata and message list in one request.
-
-        Messages are
-        queued for processing.
-
-        Args:
-          conversation_meta: Conversation metadata for batch import.
-
-          conversation_list: Message list.
-
-          version: Format version.
-
-          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(
-            "/api/v1/memories/import",
-            body=maybe_transform(
-                {
-                    "conversation_meta": conversation_meta,
-                    "conversation_list": conversation_list,
-                    "version": version,
-                },
-                memory_load_params.MemoryLoadParams,
-            ),
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=MemoryLoadResponse,
-        )
-
     def search(
         self,
         *,
@@ -303,7 +261,62 @@ class AsyncMemoriesResource(AsyncAPIResource):
         """
         return AsyncMemoriesResourceWithStreamingResponse(self)
 
-    async def create(
+    async def delete(
+        self,
+        *,
+        id: Optional[str] | Omit = omit,
+        event_id: Optional[str] | Omit = omit,
+        group_id: Optional[str] | Omit = omit,
+        memory_id: Optional[str] | Omit = omit,
+        user_id: Optional[str] | 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,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> MemoryDeleteResponse:
+        """
+        Delete memory records based on combined filter criteria
+
+        Args:
+          id: Alias for memory_id (backward compatibility)
+
+          event_id: Alias for memory_id (backward compatibility)
+
+          group_id: Group ID (filter condition)
+
+          memory_id: Memory id (filter condition)
+
+          user_id: User ID (filter condition)
+
+          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._delete(
+            "/api/v1/memories",
+            body=await async_maybe_transform(
+                {
+                    "id": id,
+                    "event_id": event_id,
+                    "group_id": group_id,
+                    "memory_id": memory_id,
+                    "user_id": user_id,
+                },
+                memory_delete_params.MemoryDeleteParams,
+            ),
+            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,
@@ -322,7 +335,7 @@ class AsyncMemoriesResource(AsyncAPIResource):
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = not_given,
-    ) -> MemoryCreateResponse:
+    ) -> MemoryAddResponse:
         """
         Store a single message into memory.
 
@@ -377,59 +390,12 @@ class AsyncMemoriesResource(AsyncAPIResource):
                     "role": role,
                     "sender_name": sender_name,
                 },
-                memory_create_params.MemoryCreateParams,
-            ),
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=MemoryCreateResponse,
-        )
-
-    async def delete(
-        self,
-        *,
-        group_id: Optional[str] | Omit = omit,
-        memory_id: Optional[str] | Omit = omit,
-        user_id: Optional[str] | 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,
-        extra_query: Query | None = None,
-        extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = not_given,
-    ) -> MemoryDeleteResponse:
-        """
-        Delete memory records based on combined filter criteria
-
-        Args:
-          group_id: Group ID (filter condition)
-
-          memory_id: Memory id (filter condition)
-
-          user_id: User ID (filter condition)
-
-          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._delete(
-            "/api/v1/memories",
-            body=await async_maybe_transform(
-                {
-                    "group_id": group_id,
-                    "memory_id": memory_id,
-                    "user_id": user_id,
-                },
-                memory_delete_params.MemoryDeleteParams,
+                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(
@@ -451,55 +417,6 @@ class AsyncMemoriesResource(AsyncAPIResource):
             cast_to=MemoryGetResponse,
         )
 
-    async def load(
-        self,
-        *,
-        conversation_meta: memory_load_params.ConversationMeta,
-        conversation_list: Optional[Iterable[memory_load_params.ConversationList]] | Omit = omit,
-        version: Optional[str] | 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,
-        extra_query: Query | None = None,
-        extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = not_given,
-    ) -> MemoryLoadResponse:
-        """Import conversation metadata and message list in one request.
-
-        Messages are
-        queued for processing.
-
-        Args:
-          conversation_meta: Conversation metadata for batch import.
-
-          conversation_list: Message list.
-
-          version: Format version.
-
-          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(
-            "/api/v1/memories/import",
-            body=await async_maybe_transform(
-                {
-                    "conversation_meta": conversation_meta,
-                    "conversation_list": conversation_list,
-                    "version": version,
-                },
-                memory_load_params.MemoryLoadParams,
-            ),
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=MemoryLoadResponse,
-        )
-
     async def search(
         self,
         *,
@@ -527,18 +444,15 @@ class MemoriesResourceWithRawResponse:
     def __init__(self, memories: MemoriesResource) -> None:
         self._memories = memories
 
-        self.create = to_raw_response_wrapper(
-            memories.create,
-        )
         self.delete = to_raw_response_wrapper(
             memories.delete,
         )
+        self.add = to_raw_response_wrapper(
+            memories.add,
+        )
         self.get = to_raw_response_wrapper(
             memories.get,
         )
-        self.load = to_raw_response_wrapper(
-            memories.load,
-        )
         self.search = to_raw_response_wrapper(
             memories.search,
         )
@@ -552,18 +466,15 @@ class AsyncMemoriesResourceWithRawResponse:
     def __init__(self, memories: AsyncMemoriesResource) -> None:
         self._memories = memories
 
-        self.create = async_to_raw_response_wrapper(
-            memories.create,
-        )
         self.delete = async_to_raw_response_wrapper(
             memories.delete,
         )
+        self.add = async_to_raw_response_wrapper(
+            memories.add,
+        )
         self.get = async_to_raw_response_wrapper(
             memories.get,
         )
-        self.load = async_to_raw_response_wrapper(
-            memories.load,
-        )
         self.search = async_to_raw_response_wrapper(
             memories.search,
         )
@@ -577,18 +488,15 @@ class MemoriesResourceWithStreamingResponse:
     def __init__(self, memories: MemoriesResource) -> None:
         self._memories = memories
 
-        self.create = to_streamed_response_wrapper(
-            memories.create,
-        )
         self.delete = to_streamed_response_wrapper(
             memories.delete,
         )
+        self.add = to_streamed_response_wrapper(
+            memories.add,
+        )
         self.get = to_streamed_response_wrapper(
             memories.get,
         )
-        self.load = to_streamed_response_wrapper(
-            memories.load,
-        )
         self.search = to_streamed_response_wrapper(
             memories.search,
         )
@@ -602,18 +510,15 @@ class AsyncMemoriesResourceWithStreamingResponse:
     def __init__(self, memories: AsyncMemoriesResource) -> None:
         self._memories = memories
 
-        self.create = async_to_streamed_response_wrapper(
-            memories.create,
-        )
         self.delete = async_to_streamed_response_wrapper(
             memories.delete,
         )
+        self.add = async_to_streamed_response_wrapper(
+            memories.add,
+        )
         self.get = async_to_streamed_response_wrapper(
             memories.get,
         )
-        self.load = async_to_streamed_response_wrapper(
-            memories.load,
-        )
         self.search = async_to_streamed_response_wrapper(
             memories.search,
         )

evermemos/resources/v1/{stats → status}/__init__.py

@@ -1,12 +1,12 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-from .stats import (
-    StatsResource,
-    AsyncStatsResource,
-    StatsResourceWithRawResponse,
-    AsyncStatsResourceWithRawResponse,
-    StatsResourceWithStreamingResponse,
-    AsyncStatsResourceWithStreamingResponse,
+from .status import (
+    StatusResource,
+    AsyncStatusResource,
+    StatusResourceWithRawResponse,
+    AsyncStatusResourceWithRawResponse,
+    StatusResourceWithStreamingResponse,
+    AsyncStatusResourceWithStreamingResponse,
 )
 from .request import (
     RequestResource,
@@ -24,10 +24,10 @@ __all__ = [
     "AsyncRequestResourceWithRawResponse",
     "RequestResourceWithStreamingResponse",
     "AsyncRequestResourceWithStreamingResponse",
-    "StatsResource",
-    "AsyncStatsResource",
-    "StatsResourceWithRawResponse",
-    "AsyncStatsResourceWithRawResponse",
-    "StatsResourceWithStreamingResponse",
-    "AsyncStatsResourceWithStreamingResponse",
+    "StatusResource",
+    "AsyncStatusResource",
+    "StatusResourceWithRawResponse",
+    "AsyncStatusResourceWithRawResponse",
+    "StatusResourceWithStreamingResponse",
+    "AsyncStatusResourceWithStreamingResponse",
 ]

evermemos/resources/v1/{stats → status}/request.py

@@ -17,8 +17,8 @@ from ...._response import (
     async_to_streamed_response_wrapper,
 )
 from ...._base_client import make_request_options
-from ....types.v1.stats import request_get_params
-from ....types.v1.stats.request_get_response import RequestGetResponse
+from ....types.v1.status import request_get_params
+from ....types.v1.status.request_get_response import RequestGetResponse
 
 __all__ = ["RequestResource", "AsyncRequestResource"]
 
@@ -58,7 +58,7 @@ class RequestResource(SyncAPIResource):
         Query the processing status of a specific request
 
         Args:
-          request_id: this id is returned by add_memories api
+          request_id: which is returned by add_memories api
 
           extra_headers: Send extra headers
 
@@ -69,7 +69,7 @@ class RequestResource(SyncAPIResource):
           timeout: Override the client-level default timeout for this request, in seconds
         """
         return self._get(
-            "/api/v1/stats/request",
+            "/api/v1/status/request",
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,
@@ -116,7 +116,7 @@ class AsyncRequestResource(AsyncAPIResource):
         Query the processing status of a specific request
 
         Args:
-          request_id: this id is returned by add_memories api
+          request_id: which is returned by add_memories api
 
           extra_headers: Send extra headers
 
@@ -127,7 +127,7 @@ class AsyncRequestResource(AsyncAPIResource):
           timeout: Override the client-level default timeout for this request, in seconds
         """
         return await self._get(
-            "/api/v1/stats/request",
+            "/api/v1/status/request",
             options=make_request_options(
                 extra_headers=extra_headers,
                 extra_query=extra_query,

evermemos/resources/v1/{stats/stats.py → status/status.py}

@@ -13,90 +13,90 @@ from .request import (
 from ...._compat import cached_property
 from ...._resource import SyncAPIResource, AsyncAPIResource
 
-__all__ = ["StatsResource", "AsyncStatsResource"]
+__all__ = ["StatusResource", "AsyncStatusResource"]
 
 
-class StatsResource(SyncAPIResource):
+class StatusResource(SyncAPIResource):
     @cached_property
     def request(self) -> RequestResource:
         return RequestResource(self._client)
 
     @cached_property
-    def with_raw_response(self) -> StatsResourceWithRawResponse:
+    def with_raw_response(self) -> StatusResourceWithRawResponse:
         """
         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/evermemos/evermemos-python#accessing-raw-response-data-eg-headers
         """
-        return StatsResourceWithRawResponse(self)
+        return StatusResourceWithRawResponse(self)
 
     @cached_property
-    def with_streaming_response(self) -> StatsResourceWithStreamingResponse:
+    def with_streaming_response(self) -> StatusResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
         For more information, see https://www.github.com/evermemos/evermemos-python#with_streaming_response
         """
-        return StatsResourceWithStreamingResponse(self)
+        return StatusResourceWithStreamingResponse(self)
 
 
-class AsyncStatsResource(AsyncAPIResource):
+class AsyncStatusResource(AsyncAPIResource):
     @cached_property
     def request(self) -> AsyncRequestResource:
         return AsyncRequestResource(self._client)
 
     @cached_property
-    def with_raw_response(self) -> AsyncStatsResourceWithRawResponse:
+    def with_raw_response(self) -> AsyncStatusResourceWithRawResponse:
         """
         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/evermemos/evermemos-python#accessing-raw-response-data-eg-headers
         """
-        return AsyncStatsResourceWithRawResponse(self)
+        return AsyncStatusResourceWithRawResponse(self)
 
     @cached_property
-    def with_streaming_response(self) -> AsyncStatsResourceWithStreamingResponse:
+    def with_streaming_response(self) -> AsyncStatusResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
         For more information, see https://www.github.com/evermemos/evermemos-python#with_streaming_response
         """
-        return AsyncStatsResourceWithStreamingResponse(self)
+        return AsyncStatusResourceWithStreamingResponse(self)
 
 
-class StatsResourceWithRawResponse:
-    def __init__(self, stats: StatsResource) -> None:
-        self._stats = stats
+class StatusResourceWithRawResponse:
+    def __init__(self, status: StatusResource) -> None:
+        self._status = status
 
     @cached_property
     def request(self) -> RequestResourceWithRawResponse:
-        return RequestResourceWithRawResponse(self._stats.request)
+        return RequestResourceWithRawResponse(self._status.request)
 
 
-class AsyncStatsResourceWithRawResponse:
-    def __init__(self, stats: AsyncStatsResource) -> None:
-        self._stats = stats
+class AsyncStatusResourceWithRawResponse:
+    def __init__(self, status: AsyncStatusResource) -> None:
+        self._status = status
 
     @cached_property
     def request(self) -> AsyncRequestResourceWithRawResponse:
-        return AsyncRequestResourceWithRawResponse(self._stats.request)
+        return AsyncRequestResourceWithRawResponse(self._status.request)
 
 
-class StatsResourceWithStreamingResponse:
-    def __init__(self, stats: StatsResource) -> None:
-        self._stats = stats
+class StatusResourceWithStreamingResponse:
+    def __init__(self, status: StatusResource) -> None:
+        self._status = status
 
     @cached_property
     def request(self) -> RequestResourceWithStreamingResponse:
-        return RequestResourceWithStreamingResponse(self._stats.request)
+        return RequestResourceWithStreamingResponse(self._status.request)
 
 
-class AsyncStatsResourceWithStreamingResponse:
-    def __init__(self, stats: AsyncStatsResource) -> None:
-        self._stats = stats
+class AsyncStatusResourceWithStreamingResponse:
+    def __init__(self, status: AsyncStatusResource) -> None:
+        self._status = status
 
     @cached_property
     def request(self) -> AsyncRequestResourceWithStreamingResponse:
-        return AsyncRequestResourceWithStreamingResponse(self._stats.request)
+        return AsyncRequestResourceWithStreamingResponse(self._status.request)