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

evermemos/resources/v1/stats/__init__.py

@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .stats import (
+    StatsResource,
+    AsyncStatsResource,
+    StatsResourceWithRawResponse,
+    AsyncStatsResourceWithRawResponse,
+    StatsResourceWithStreamingResponse,
+    AsyncStatsResourceWithStreamingResponse,
+)
+from .request import (
+    RequestResource,
+    AsyncRequestResource,
+    RequestResourceWithRawResponse,
+    AsyncRequestResourceWithRawResponse,
+    RequestResourceWithStreamingResponse,
+    AsyncRequestResourceWithStreamingResponse,
+)
+
+__all__ = [
+    "RequestResource",
+    "AsyncRequestResource",
+    "RequestResourceWithRawResponse",
+    "AsyncRequestResourceWithRawResponse",
+    "RequestResourceWithStreamingResponse",
+    "AsyncRequestResourceWithStreamingResponse",
+    "StatsResource",
+    "AsyncStatsResource",
+    "StatsResourceWithRawResponse",
+    "AsyncStatsResourceWithRawResponse",
+    "StatsResourceWithStreamingResponse",
+    "AsyncStatsResourceWithStreamingResponse",
+]

evermemos/resources/v1/stats/request.py

@@ -0,0 +1,175 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+
+import httpx
+
+from ...._types import Body, Query, Headers, NotGiven, not_given
+from ...._utils import maybe_transform, async_maybe_transform
+from ...._compat import cached_property
+from ...._resource import SyncAPIResource, AsyncAPIResource
+from ...._response import (
+    to_raw_response_wrapper,
+    to_streamed_response_wrapper,
+    async_to_raw_response_wrapper,
+    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
+
+__all__ = ["RequestResource", "AsyncRequestResource"]
+
+
+class RequestResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> RequestResourceWithRawResponse:
+        """
+        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 RequestResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> RequestResourceWithStreamingResponse:
+        """
+        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 RequestResourceWithStreamingResponse(self)
+
+    def get(
+        self,
+        *,
+        request_id: Optional[str],
+        # 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,
+    ) -> RequestGetResponse:
+        """
+        Query the processing status of a specific request
+
+        Args:
+          request_id: this id is returned by add_memories api
+
+          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._get(
+            "/api/v1/stats/request",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform({"request_id": request_id}, request_get_params.RequestGetParams),
+            ),
+            cast_to=RequestGetResponse,
+        )
+
+
+class AsyncRequestResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncRequestResourceWithRawResponse:
+        """
+        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 AsyncRequestResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncRequestResourceWithStreamingResponse:
+        """
+        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 AsyncRequestResourceWithStreamingResponse(self)
+
+    async def get(
+        self,
+        *,
+        request_id: Optional[str],
+        # 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,
+    ) -> RequestGetResponse:
+        """
+        Query the processing status of a specific request
+
+        Args:
+          request_id: this id is returned by add_memories api
+
+          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._get(
+            "/api/v1/stats/request",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform({"request_id": request_id}, request_get_params.RequestGetParams),
+            ),
+            cast_to=RequestGetResponse,
+        )
+
+
+class RequestResourceWithRawResponse:
+    def __init__(self, request: RequestResource) -> None:
+        self._request = request
+
+        self.get = to_raw_response_wrapper(
+            request.get,
+        )
+
+
+class AsyncRequestResourceWithRawResponse:
+    def __init__(self, request: AsyncRequestResource) -> None:
+        self._request = request
+
+        self.get = async_to_raw_response_wrapper(
+            request.get,
+        )
+
+
+class RequestResourceWithStreamingResponse:
+    def __init__(self, request: RequestResource) -> None:
+        self._request = request
+
+        self.get = to_streamed_response_wrapper(
+            request.get,
+        )
+
+
+class AsyncRequestResourceWithStreamingResponse:
+    def __init__(self, request: AsyncRequestResource) -> None:
+        self._request = request
+
+        self.get = async_to_streamed_response_wrapper(
+            request.get,
+        )

evermemos/resources/v1/stats/stats.py

@@ -0,0 +1,102 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .request import (
+    RequestResource,
+    AsyncRequestResource,
+    RequestResourceWithRawResponse,
+    AsyncRequestResourceWithRawResponse,
+    RequestResourceWithStreamingResponse,
+    AsyncRequestResourceWithStreamingResponse,
+)
+from ...._compat import cached_property
+from ...._resource import SyncAPIResource, AsyncAPIResource
+
+__all__ = ["StatsResource", "AsyncStatsResource"]
+
+
+class StatsResource(SyncAPIResource):
+    @cached_property
+    def request(self) -> RequestResource:
+        return RequestResource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> StatsResourceWithRawResponse:
+        """
+        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)
+
+    @cached_property
+    def with_streaming_response(self) -> StatsResourceWithStreamingResponse:
+        """
+        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)
+
+
+class AsyncStatsResource(AsyncAPIResource):
+    @cached_property
+    def request(self) -> AsyncRequestResource:
+        return AsyncRequestResource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> AsyncStatsResourceWithRawResponse:
+        """
+        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)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncStatsResourceWithStreamingResponse:
+        """
+        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)
+
+
+class StatsResourceWithRawResponse:
+    def __init__(self, stats: StatsResource) -> None:
+        self._stats = stats
+
+    @cached_property
+    def request(self) -> RequestResourceWithRawResponse:
+        return RequestResourceWithRawResponse(self._stats.request)
+
+
+class AsyncStatsResourceWithRawResponse:
+    def __init__(self, stats: AsyncStatsResource) -> None:
+        self._stats = stats
+
+    @cached_property
+    def request(self) -> AsyncRequestResourceWithRawResponse:
+        return AsyncRequestResourceWithRawResponse(self._stats.request)
+
+
+class StatsResourceWithStreamingResponse:
+    def __init__(self, stats: StatsResource) -> None:
+        self._stats = stats
+
+    @cached_property
+    def request(self) -> RequestResourceWithStreamingResponse:
+        return RequestResourceWithStreamingResponse(self._stats.request)
+
+
+class AsyncStatsResourceWithStreamingResponse:
+    def __init__(self, stats: AsyncStatsResource) -> None:
+        self._stats = stats
+
+    @cached_property
+    def request(self) -> AsyncRequestResourceWithStreamingResponse:
+        return AsyncRequestResourceWithStreamingResponse(self._stats.request)

evermemos/resources/v1/v1.py

@@ -4,6 +4,14 @@ from __future__ import annotations
 
 from ..._compat import cached_property
 from ..._resource import SyncAPIResource, AsyncAPIResource
+from .stats.stats import (
+    StatsResource,
+    AsyncStatsResource,
+    StatsResourceWithRawResponse,
+    AsyncStatsResourceWithRawResponse,
+    StatsResourceWithStreamingResponse,
+    AsyncStatsResourceWithStreamingResponse,
+)
 from .memories.memories import (
     MemoriesResource,
     AsyncMemoriesResource,
@@ -21,6 +29,10 @@ class V1Resource(SyncAPIResource):
     def memories(self) -> MemoriesResource:
         return MemoriesResource(self._client)
 
+    @cached_property
+    def stats(self) -> StatsResource:
+        return StatsResource(self._client)
+
     @cached_property
     def with_raw_response(self) -> V1ResourceWithRawResponse:
         """
@@ -46,6 +58,10 @@ class AsyncV1Resource(AsyncAPIResource):
     def memories(self) -> AsyncMemoriesResource:
         return AsyncMemoriesResource(self._client)
 
+    @cached_property
+    def stats(self) -> AsyncStatsResource:
+        return AsyncStatsResource(self._client)
+
     @cached_property
     def with_raw_response(self) -> AsyncV1ResourceWithRawResponse:
         """
@@ -74,6 +90,10 @@ class V1ResourceWithRawResponse:
     def memories(self) -> MemoriesResourceWithRawResponse:
         return MemoriesResourceWithRawResponse(self._v1.memories)
 
+    @cached_property
+    def stats(self) -> StatsResourceWithRawResponse:
+        return StatsResourceWithRawResponse(self._v1.stats)
+
 
 class AsyncV1ResourceWithRawResponse:
     def __init__(self, v1: AsyncV1Resource) -> None:
@@ -83,6 +103,10 @@ class AsyncV1ResourceWithRawResponse:
     def memories(self) -> AsyncMemoriesResourceWithRawResponse:
         return AsyncMemoriesResourceWithRawResponse(self._v1.memories)
 
+    @cached_property
+    def stats(self) -> AsyncStatsResourceWithRawResponse:
+        return AsyncStatsResourceWithRawResponse(self._v1.stats)
+
 
 class V1ResourceWithStreamingResponse:
     def __init__(self, v1: V1Resource) -> None:
@@ -92,6 +116,10 @@ class V1ResourceWithStreamingResponse:
     def memories(self) -> MemoriesResourceWithStreamingResponse:
         return MemoriesResourceWithStreamingResponse(self._v1.memories)
 
+    @cached_property
+    def stats(self) -> StatsResourceWithStreamingResponse:
+        return StatsResourceWithStreamingResponse(self._v1.stats)
+
 
 class AsyncV1ResourceWithStreamingResponse:
     def __init__(self, v1: AsyncV1Resource) -> None:
@@ -100,3 +128,7 @@ class AsyncV1ResourceWithStreamingResponse:
     @cached_property
     def memories(self) -> AsyncMemoriesResourceWithStreamingResponse:
         return AsyncMemoriesResourceWithStreamingResponse(self._v1.memories)
+
+    @cached_property
+    def stats(self) -> AsyncStatsResourceWithStreamingResponse:
+        return AsyncStatsResourceWithStreamingResponse(self._v1.stats)

evermemos/types/v1/__init__.py

@@ -4,9 +4,11 @@ from __future__ import annotations
 
 from .metadata import Metadata as Metadata
 from .memory_type import MemoryType as MemoryType
+from .memory_load_params import MemoryLoadParams as MemoryLoadParams
+from .memory_get_response import MemoryGetResponse as MemoryGetResponse
 from .memory_create_params import MemoryCreateParams as MemoryCreateParams
 from .memory_delete_params import MemoryDeleteParams as MemoryDeleteParams
-from .memory_list_response import MemoryListResponse as MemoryListResponse
+from .memory_load_response import MemoryLoadResponse as MemoryLoadResponse
 from .memory_create_response import MemoryCreateResponse as MemoryCreateResponse
 from .memory_delete_response import MemoryDeleteResponse as MemoryDeleteResponse
 from .memory_search_response import MemorySearchResponse as MemorySearchResponse

evermemos/types/v1/global_user_profile/__init__.py

@@ -0,0 +1,3 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations

evermemos/types/v1/memories/conversation_meta_create_params.py

@@ -29,9 +29,6 @@ class ConversationMetaCreateParams(TypedDict, total=False):
     scene_desc: Required[Dict[str, object]]
     """Scene description object, can include fields like description"""
 
-    version: Required[str]
-    """Metadata version number"""
-
     default_timezone: Optional[str]
     """Default timezone"""
 

evermemos/types/v1/memories/conversation_meta_create_response.py

@@ -22,9 +22,6 @@ class Result(BaseModel):
     scene: str
     """Scene identifier"""
 
-    version: str
-    """Metadata version"""
-
     created_at: Optional[str] = None
     """Record creation time"""
 

evermemos/types/v1/memories/conversation_meta_get_response.py

@@ -22,9 +22,6 @@ class Result(BaseModel):
     scene: str
     """Scene identifier"""
 
-    version: str
-    """Metadata version"""
-
     created_at: Optional[str] = None
     """Record creation time"""
 

evermemos/types/v1/memory_create_params.py

@@ -21,10 +21,25 @@ class MemoryCreateParams(TypedDict, total=False):
     """Message unique identifier"""
 
     sender: Required[str]
-    """Sender user ID"""
+    """Sender user ID (required).
+
+    Also used as user_id internally for memory ownership.
+    """
+
+    flush: bool
+    """Force boundary trigger.
+
+    When True, immediately triggers memory extraction instead of waiting for natural
+    boundary detection.
+    """
 
     group_id: Optional[str]
-    """Group ID"""
+    """Group ID.
+
+    If not provided, will automatically generate based on hash(sender) + '\\__group'
+    suffix, representing single-user mode where each user's messages are extracted
+    into separate memory spaces.
+    """
 
     group_name: Optional[str]
     """Group name"""

evermemos/types/v1/memory_create_response.py

@@ -1,39 +1,13 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-from typing import List, Optional
-
 from ..._models import BaseModel
 
-__all__ = ["MemoryCreateResponse", "Result"]
-
-
-class Result(BaseModel):
-    """Memory storage result"""
-
-    count: Optional[int] = None
-    """Number of memories extracted"""
-
-    saved_memories: Optional[List[object]] = None
-    """List of saved memories (fetch via API for details)"""
-
-    status_info: Optional[str] = None
-    """
-    Processing status: 'extracted' (memories created) or 'accumulated' (waiting for
-    boundary)
-    """
+__all__ = ["MemoryCreateResponse"]
 
 
 class MemoryCreateResponse(BaseModel):
-    """Memory storage response
-
-    Response for POST /api/v1/memories endpoint.
-    """
-
-    message: Optional[str] = None
-    """Response message"""
+    message: str
 
-    result: Optional[Result] = None
-    """Memory storage result"""
+    request_id: str
 
-    status: Optional[str] = None
-    """Response status"""
+    status: str

evermemos/types/v1/memory_delete_params.py

@@ -9,11 +9,11 @@ __all__ = ["MemoryDeleteParams"]
 
 
 class MemoryDeleteParams(TypedDict, total=False):
-    event_id: Optional[str]
-    """Memory event_id (filter condition)"""
-
     group_id: Optional[str]
     """Group ID (filter condition)"""
 
+    memory_id: Optional[str]
+    """Memory id (filter condition)"""
+
     user_id: Optional[str]
     """User ID (filter condition)"""

evermemos/types/v1/{memory_list_response.py → memory_get_response.py}

@@ -8,10 +8,14 @@ from .metadata import Metadata
 from ..._models import BaseModel
 
 __all__ = [
-    "MemoryListResponse",
+    "MemoryGetResponse",
     "Result",
     "ResultMemory",
     "ResultMemoryProfileModel",
+    "ResultMemoryGlobalUserProfileModel",
+    "ResultMemoryCombinedProfileModel",
+    "ResultMemoryCombinedProfileModelGlobalProfile",
+    "ResultMemoryCombinedProfileModelProfile",
     "ResultMemoryEpisodicMemoryModel",
     "ResultMemoryEventLogModel",
     "ResultMemoryForesightModel",
@@ -44,6 +48,78 @@ class ResultMemoryProfileModel(BaseModel):
     version: Optional[int] = None
 
 
+class ResultMemoryGlobalUserProfileModel(BaseModel):
+    id: str
+
+    user_id: str
+
+    confidence: Optional[float] = None
+
+    created_at: Optional[datetime] = None
+
+    custom_profile_data: Optional[Dict[str, object]] = None
+
+    memcell_count: Optional[int] = None
+
+    profile_data: Optional[Dict[str, object]] = None
+
+    updated_at: Optional[datetime] = None
+
+
+class ResultMemoryCombinedProfileModelGlobalProfile(BaseModel):
+    id: str
+
+    user_id: str
+
+    confidence: Optional[float] = None
+
+    created_at: Optional[datetime] = None
+
+    custom_profile_data: Optional[Dict[str, object]] = None
+
+    memcell_count: Optional[int] = None
+
+    profile_data: Optional[Dict[str, object]] = None
+
+    updated_at: Optional[datetime] = None
+
+
+class ResultMemoryCombinedProfileModelProfile(BaseModel):
+    id: str
+
+    group_id: str
+
+    user_id: str
+
+    cluster_ids: Optional[List[str]] = None
+
+    confidence: Optional[float] = None
+
+    created_at: Optional[datetime] = None
+
+    last_updated_cluster: Optional[str] = None
+
+    memcell_count: Optional[int] = None
+
+    profile_data: Optional[Dict[str, object]] = None
+
+    scenario: Optional[str] = None
+
+    updated_at: Optional[datetime] = None
+
+    version: Optional[int] = None
+
+
+class ResultMemoryCombinedProfileModel(BaseModel):
+    user_id: str
+
+    global_profile: Optional[ResultMemoryCombinedProfileModelGlobalProfile] = None
+
+    group_id: Optional[str] = None
+
+    profiles: Optional[List[ResultMemoryCombinedProfileModelProfile]] = None
+
+
 class ResultMemoryEpisodicMemoryModel(BaseModel):
     id: str
 
@@ -69,10 +145,12 @@ class ResultMemoryEpisodicMemoryModel(BaseModel):
 
     location: Optional[str] = None
 
-    memcell_event_id_list: Optional[List[str]] = None
-
     metadata: Optional[Metadata] = None
 
+    parent_id: Optional[str] = None
+
+    parent_type: Optional[str] = None
+
     participants: Optional[List[str]] = None
 
     start_time: Optional[datetime] = None
@@ -161,7 +239,12 @@ class ResultMemoryForesightModel(BaseModel):
 
 
 ResultMemory: TypeAlias = Union[
-    ResultMemoryProfileModel, ResultMemoryEpisodicMemoryModel, ResultMemoryEventLogModel, ResultMemoryForesightModel
+    ResultMemoryProfileModel,
+    ResultMemoryGlobalUserProfileModel,
+    ResultMemoryCombinedProfileModel,
+    ResultMemoryEpisodicMemoryModel,
+    ResultMemoryEventLogModel,
+    ResultMemoryForesightModel,
 ]
 
 
@@ -177,7 +260,7 @@ class Result(BaseModel):
     total_count: Optional[int] = None
 
 
-class MemoryListResponse(BaseModel):
+class MemoryGetResponse(BaseModel):
     """Memory fetch API response
 
     Response for GET /api/v1/memories endpoint.