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

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,
@@ -12,6 +20,14 @@ from .memories.memories import (
     MemoriesResourceWithStreamingResponse,
     AsyncMemoriesResourceWithStreamingResponse,
 )
+from .global_user_profile.global_user_profile import (
+    GlobalUserProfileResource,
+    AsyncGlobalUserProfileResource,
+    GlobalUserProfileResourceWithRawResponse,
+    AsyncGlobalUserProfileResourceWithRawResponse,
+    GlobalUserProfileResourceWithStreamingResponse,
+    AsyncGlobalUserProfileResourceWithStreamingResponse,
+)
 
 __all__ = ["V1Resource", "AsyncV1Resource"]
 
@@ -21,6 +37,14 @@ class V1Resource(SyncAPIResource):
     def memories(self) -> MemoriesResource:
         return MemoriesResource(self._client)
 
+    @cached_property
+    def global_user_profile(self) -> GlobalUserProfileResource:
+        return GlobalUserProfileResource(self._client)
+
+    @cached_property
+    def stats(self) -> StatsResource:
+        return StatsResource(self._client)
+
     @cached_property
     def with_raw_response(self) -> V1ResourceWithRawResponse:
         """
@@ -46,6 +70,14 @@ class AsyncV1Resource(AsyncAPIResource):
     def memories(self) -> AsyncMemoriesResource:
         return AsyncMemoriesResource(self._client)
 
+    @cached_property
+    def global_user_profile(self) -> AsyncGlobalUserProfileResource:
+        return AsyncGlobalUserProfileResource(self._client)
+
+    @cached_property
+    def stats(self) -> AsyncStatsResource:
+        return AsyncStatsResource(self._client)
+
     @cached_property
     def with_raw_response(self) -> AsyncV1ResourceWithRawResponse:
         """
@@ -74,6 +106,14 @@ class V1ResourceWithRawResponse:
     def memories(self) -> MemoriesResourceWithRawResponse:
         return MemoriesResourceWithRawResponse(self._v1.memories)
 
+    @cached_property
+    def global_user_profile(self) -> GlobalUserProfileResourceWithRawResponse:
+        return GlobalUserProfileResourceWithRawResponse(self._v1.global_user_profile)
+
+    @cached_property
+    def stats(self) -> StatsResourceWithRawResponse:
+        return StatsResourceWithRawResponse(self._v1.stats)
+
 
 class AsyncV1ResourceWithRawResponse:
     def __init__(self, v1: AsyncV1Resource) -> None:
@@ -83,6 +123,14 @@ class AsyncV1ResourceWithRawResponse:
     def memories(self) -> AsyncMemoriesResourceWithRawResponse:
         return AsyncMemoriesResourceWithRawResponse(self._v1.memories)
 
+    @cached_property
+    def global_user_profile(self) -> AsyncGlobalUserProfileResourceWithRawResponse:
+        return AsyncGlobalUserProfileResourceWithRawResponse(self._v1.global_user_profile)
+
+    @cached_property
+    def stats(self) -> AsyncStatsResourceWithRawResponse:
+        return AsyncStatsResourceWithRawResponse(self._v1.stats)
+
 
 class V1ResourceWithStreamingResponse:
     def __init__(self, v1: V1Resource) -> None:
@@ -92,6 +140,14 @@ class V1ResourceWithStreamingResponse:
     def memories(self) -> MemoriesResourceWithStreamingResponse:
         return MemoriesResourceWithStreamingResponse(self._v1.memories)
 
+    @cached_property
+    def global_user_profile(self) -> GlobalUserProfileResourceWithStreamingResponse:
+        return GlobalUserProfileResourceWithStreamingResponse(self._v1.global_user_profile)
+
+    @cached_property
+    def stats(self) -> StatsResourceWithStreamingResponse:
+        return StatsResourceWithStreamingResponse(self._v1.stats)
+
 
 class AsyncV1ResourceWithStreamingResponse:
     def __init__(self, v1: AsyncV1Resource) -> None:
@@ -100,3 +156,11 @@ class AsyncV1ResourceWithStreamingResponse:
     @cached_property
     def memories(self) -> AsyncMemoriesResourceWithStreamingResponse:
         return AsyncMemoriesResourceWithStreamingResponse(self._v1.memories)
+
+    @cached_property
+    def global_user_profile(self) -> AsyncGlobalUserProfileResourceWithStreamingResponse:
+        return AsyncGlobalUserProfileResourceWithStreamingResponse(self._v1.global_user_profile)
+
+    @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,6 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .custom_upsert_params import CustomUpsertParams as CustomUpsertParams
+from .custom_upsert_response import CustomUpsertResponse as CustomUpsertResponse

evermemos/types/v1/global_user_profile/custom_upsert_params.py

@@ -0,0 +1,24 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Required, TypedDict
+
+from ...._types import SequenceNotStr
+
+__all__ = ["CustomUpsertParams", "CustomProfileData"]
+
+
+class CustomUpsertParams(TypedDict, total=False):
+    custom_profile_data: Required[CustomProfileData]
+    """Custom profile data to upsert"""
+
+    user_id: Required[str]
+    """User ID"""
+
+
+class CustomProfileData(TypedDict, total=False):
+    """Custom profile data to upsert"""
+
+    initial_profile: Required[SequenceNotStr[str]]
+    """List of profile sentences describing the user"""

evermemos/types/v1/global_user_profile/custom_upsert_response.py

@@ -0,0 +1,23 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, Optional
+
+from ...._models import BaseModel
+
+__all__ = ["CustomUpsertResponse"]
+
+
+class CustomUpsertResponse(BaseModel):
+    """Upsert custom profile response
+
+    Response for upsert custom profile API.
+    """
+
+    success: bool
+    """Whether the operation was successful"""
+
+    data: Optional[Dict[str, object]] = None
+    """Created/updated profile data"""
+
+    message: Optional[str] = None
+    """Message"""

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,18 @@ 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.
+    """
 
     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_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
 
@@ -161,7 +237,12 @@ class ResultMemoryForesightModel(BaseModel):
 
 
 ResultMemory: TypeAlias = Union[
-    ResultMemoryProfileModel, ResultMemoryEpisodicMemoryModel, ResultMemoryEventLogModel, ResultMemoryForesightModel
+    ResultMemoryProfileModel,
+    ResultMemoryGlobalUserProfileModel,
+    ResultMemoryCombinedProfileModel,
+    ResultMemoryEpisodicMemoryModel,
+    ResultMemoryEventLogModel,
+    ResultMemoryForesightModel,
 ]
 
 
@@ -177,7 +258,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.

evermemos/types/v1/memory_load_params.py

@@ -0,0 +1,83 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, Union, Iterable, Optional
+from typing_extensions import Required, TypedDict
+
+from ..._types import SequenceNotStr
+
+__all__ = ["MemoryLoadParams", "ConversationMeta", "ConversationList"]
+
+
+class MemoryLoadParams(TypedDict, total=False):
+    conversation_meta: Required[ConversationMeta]
+    """Conversation metadata for batch import."""
+
+    conversation_list: Optional[Iterable[ConversationList]]
+    """Message list."""
+
+    version: Optional[str]
+    """Format version."""
+
+
+class ConversationMeta(TypedDict, total=False):
+    """Conversation metadata for batch import."""
+
+    group_id: Required[str]
+    """Conversation group ID (unique)."""
+
+    created_at: Optional[str]
+    """Conversation creation time (ISO 8601)."""
+
+    default_timezone: Optional[str]
+    """Default timezone."""
+
+    description: Optional[str]
+    """Conversation description."""
+
+    name: Optional[str]
+    """Conversation name."""
+
+    scene: Optional[str]
+    """Scene type (e.g., assistant, group_chat)."""
+
+    scene_desc: Optional[Dict[str, object]]
+    """Scene description object."""
+
+    tags: Optional[SequenceNotStr[str]]
+    """Tags for the conversation."""
+
+    user_details: Optional[Dict[str, object]]
+    """User details map keyed by user ID."""
+
+
+class ConversationList(TypedDict, total=False):
+    """Message item for batch import."""
+
+    content: Optional[str]
+    """Message content."""
+
+    create_time: Union[str, int, None]
+    """Creation time (ISO 8601 or timestamp)."""
+
+    extra: Optional[Dict[str, object]]
+    """Additional data."""
+
+    message_id: Optional[str]
+    """Message ID."""
+
+    refer_list: Optional[Iterable[Dict[str, object]]]
+    """Referenced messages."""
+
+    role: Optional[str]
+    """Role (e.g., user, assistant)."""
+
+    sender: Optional[str]
+    """Sender ID."""
+
+    sender_name: Optional[str]
+    """Sender name."""
+
+    type: Optional[str]
+    """Message type (e.g., text, image)."""

evermemos/types/v1/memory_load_response.py

@@ -0,0 +1,26 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+
+from ..._models import BaseModel
+
+__all__ = ["MemoryLoadResponse"]
+
+
+class MemoryLoadResponse(BaseModel):
+    """Batch import response."""
+
+    imported_meta: Optional[bool] = None
+    """Whether conversation metadata was imported."""
+
+    message: Optional[str] = None
+    """Status message."""
+
+    request_id: Optional[str] = None
+    """Request ID of the last imported message."""
+
+    status: Optional[str] = None
+    """Queue status."""
+
+    total_count: Optional[int] = None
+    """Total number of messages."""

evermemos/types/v1/stats/__init__.py

@@ -0,0 +1,6 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .request_get_params import RequestGetParams as RequestGetParams
+from .request_get_response import RequestGetResponse as RequestGetResponse

evermemos/types/v1/stats/request_get_params.py

@@ -0,0 +1,13 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+from typing_extensions import Required, TypedDict
+
+__all__ = ["RequestGetParams"]
+
+
+class RequestGetParams(TypedDict, total=False):
+    request_id: Required[Optional[str]]
+    """Request ID (recommended)"""

evermemos/types/v1/stats/request_get_response.py

@@ -0,0 +1,26 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, Optional
+
+from ...._models import BaseModel
+
+__all__ = ["RequestGetResponse"]
+
+
+class RequestGetResponse(BaseModel):
+    """Request status response
+
+    Contains detailed status information of the request.
+    """
+
+    success: bool
+    """Whether the query was successful"""
+
+    data: Optional[Dict[str, object]] = None
+    """Request status data"""
+
+    found: Optional[bool] = None
+    """Whether the request status was found"""
+
+    message: Optional[str] = None
+    """Message"""

{evermemos-0.3.6.dist-info → evermemos-0.3.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: evermemos
-Version: 0.3.6
+Version: 0.3.7
 Summary: The official Python library for the EverMemOS API
 Project-URL: Homepage, https://github.com/evermemos/evermemos-python
 Project-URL: Repository, https://github.com/evermemos/evermemos-python
@@ -68,10 +68,10 @@ client = EverMemOS(
 )
 
 memory = client.v1.memories.create(
-    content="I prefer morning meetings, usually around 9am works best for me.",
+    content="Let's discuss the technical solution for the new feature today",
     create_time="2025-01-15T10:00:00+00:00",
     message_id="msg_001",
-    sender="user_alice",
+    sender="user_001",
 )
 print(memory.message)
 ```
@@ -97,10 +97,10 @@ client = AsyncEverMemOS(
 
 async def main() -> None:
     memory = await client.v1.memories.create(
-        content="I prefer morning meetings, usually around 9am works best for me.",
+        content="Let's discuss the technical solution for the new feature today",
         create_time="2025-01-15T10:00:00+00:00",
         message_id="msg_001",
-        sender="user_alice",
+        sender="user_001",
     )
     print(memory.message)
 
@@ -136,10 +136,10 @@ async def main() -> None:
         http_client=DefaultAioHttpClient(),
     ) as client:
         memory = await client.v1.memories.create(
-            content="I prefer morning meetings, usually around 9am works best for me.",
+            content="Let's discuss the technical solution for the new feature today",
             create_time="2025-01-15T10:00:00+00:00",
             message_id="msg_001",
-            sender="user_alice",
+            sender="user_001",
         )
         print(memory.message)
 
@@ -156,6 +156,34 @@ Nested request parameters are [TypedDicts](https://docs.python.org/3/library/typ
 
 Typed requests and responses provide autocomplete and documentation within your editor. If you would like to see type errors in VS Code to help catch bugs earlier, set `python.analysis.typeCheckingMode` to `basic`.
 
+## Nested params
+
+Nested parameters are dictionaries, typed using `TypedDict`, for example:
+
+```python
+from evermemos import EverMemOS
+
+client = EverMemOS()
+
+response = client.v1.memories.load(
+    conversation_meta={
+        "group_id": "chat_user_001_assistant",
+        "created_at": "2025-06-26T00:00:00Z",
+        "default_timezone": "UTC",
+        "description": "Conversation between user and assistant",
+        "name": "User Support Chat",
+        "scene": "assistant",
+        "scene_desc": {"description": "bar"},
+        "tags": ["support"],
+        "user_details": {
+            "user_001": "bar",
+            "robot_001": "bar",
+        },
+    },
+)
+print(response.conversation_meta)
+```
+
 ## Handling errors
 
 When the library is unable to connect to the API (for example, due to network connection problems or a timeout), a subclass of `evermemos.APIConnectionError` is raised.
@@ -173,10 +201,10 @@ client = EverMemOS()
 
 try:
     client.v1.memories.create(
-        content="I prefer morning meetings, usually around 9am works best for me.",
+        content="Let's discuss the technical solution for the new feature today",
         create_time="2025-01-15T10:00:00+00:00",
         message_id="msg_001",
-        sender="user_alice",
+        sender="user_001",
     )
 except evermemos.APIConnectionError as e:
     print("The server could not be reached")
@@ -221,10 +249,10 @@ client = EverMemOS(
 
 # Or, configure per-request:
 client.with_options(max_retries=5).v1.memories.create(
-    content="I prefer morning meetings, usually around 9am works best for me.",
+    content="Let's discuss the technical solution for the new feature today",
     create_time="2025-01-15T10:00:00+00:00",
     message_id="msg_001",
-    sender="user_alice",
+    sender="user_001",
 )
 ```
 
@@ -249,10 +277,10 @@ client = EverMemOS(
 
 # Override per-request:
 client.with_options(timeout=5.0).v1.memories.create(
-    content="I prefer morning meetings, usually around 9am works best for me.",
+    content="Let's discuss the technical solution for the new feature today",
     create_time="2025-01-15T10:00:00+00:00",
     message_id="msg_001",
-    sender="user_alice",
+    sender="user_001",
 )
 ```
 
@@ -295,10 +323,10 @@ from evermemos import EverMemOS
 
 client = EverMemOS()
 response = client.v1.memories.with_raw_response.create(
-    content="I prefer morning meetings, usually around 9am works best for me.",
+    content="Let's discuss the technical solution for the new feature today",
     create_time="2025-01-15T10:00:00+00:00",
     message_id="msg_001",
-    sender="user_alice",
+    sender="user_001",
 )
 print(response.headers.get('X-My-Header'))
 
@@ -318,10 +346,10 @@ To stream the response body, use `.with_streaming_response` instead, which requi
 
 ```python
 with client.v1.memories.with_streaming_response.create(
-    content="I prefer morning meetings, usually around 9am works best for me.",
+    content="Let's discuss the technical solution for the new feature today",
     create_time="2025-01-15T10:00:00+00:00",
     message_id="msg_001",
-    sender="user_alice",
+    sender="user_001",
 ) as response:
     print(response.headers.get("X-My-Header"))