evermemos 0.3.9__py3-none-any.whl → 0.3.11__py3-none-any.whl

evermemos/resources/v0/status/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.v0.status import request_get_params
+from ....types.v0.status.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: which 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/v0/status/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: which 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/v0/status/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/v0/status/status.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__ = ["StatusResource", "AsyncStatusResource"]
+
+
+class StatusResource(SyncAPIResource):
+    @cached_property
+    def request(self) -> RequestResource:
+        return RequestResource(self._client)
+
+    @cached_property
+    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 StatusResourceWithRawResponse(self)
+
+    @cached_property
+    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 StatusResourceWithStreamingResponse(self)
+
+
+class AsyncStatusResource(AsyncAPIResource):
+    @cached_property
+    def request(self) -> AsyncRequestResource:
+        return AsyncRequestResource(self._client)
+
+    @cached_property
+    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 AsyncStatusResourceWithRawResponse(self)
+
+    @cached_property
+    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 AsyncStatusResourceWithStreamingResponse(self)
+
+
+class StatusResourceWithRawResponse:
+    def __init__(self, status: StatusResource) -> None:
+        self._status = status
+
+    @cached_property
+    def request(self) -> RequestResourceWithRawResponse:
+        return RequestResourceWithRawResponse(self._status.request)
+
+
+class AsyncStatusResourceWithRawResponse:
+    def __init__(self, status: AsyncStatusResource) -> None:
+        self._status = status
+
+    @cached_property
+    def request(self) -> AsyncRequestResourceWithRawResponse:
+        return AsyncRequestResourceWithRawResponse(self._status.request)
+
+
+class StatusResourceWithStreamingResponse:
+    def __init__(self, status: StatusResource) -> None:
+        self._status = status
+
+    @cached_property
+    def request(self) -> RequestResourceWithStreamingResponse:
+        return RequestResourceWithStreamingResponse(self._status.request)
+
+
+class AsyncStatusResourceWithStreamingResponse:
+    def __init__(self, status: AsyncStatusResource) -> None:
+        self._status = status
+
+    @cached_property
+    def request(self) -> AsyncRequestResourceWithStreamingResponse:
+        return AsyncRequestResourceWithStreamingResponse(self._status.request)

evermemos/resources/{v1/v1.py → v0/v0.py}

@@ -4,6 +4,14 @@ from __future__ import annotations
 
 from ..._compat import cached_property
 from ..._resource import SyncAPIResource, AsyncAPIResource
+from .status.status import (
+    StatusResource,
+    AsyncStatusResource,
+    StatusResourceWithRawResponse,
+    AsyncStatusResourceWithRawResponse,
+    StatusResourceWithStreamingResponse,
+    AsyncStatusResourceWithStreamingResponse,
+)
 from .memories.memories import (
     MemoriesResource,
     AsyncMemoriesResource,
@@ -13,90 +21,114 @@ from .memories.memories import (
     AsyncMemoriesResourceWithStreamingResponse,
 )
 
-__all__ = ["V1Resource", "AsyncV1Resource"]
+__all__ = ["V0Resource", "AsyncV0Resource"]
 
 
-class V1Resource(SyncAPIResource):
+class V0Resource(SyncAPIResource):
     @cached_property
     def memories(self) -> MemoriesResource:
         return MemoriesResource(self._client)
 
     @cached_property
-    def with_raw_response(self) -> V1ResourceWithRawResponse:
+    def status(self) -> StatusResource:
+        return StatusResource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> V0ResourceWithRawResponse:
         """
         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 V1ResourceWithRawResponse(self)
+        return V0ResourceWithRawResponse(self)
 
     @cached_property
-    def with_streaming_response(self) -> V1ResourceWithStreamingResponse:
+    def with_streaming_response(self) -> V0ResourceWithStreamingResponse:
         """
         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 V1ResourceWithStreamingResponse(self)
+        return V0ResourceWithStreamingResponse(self)
 
 
-class AsyncV1Resource(AsyncAPIResource):
+class AsyncV0Resource(AsyncAPIResource):
     @cached_property
     def memories(self) -> AsyncMemoriesResource:
         return AsyncMemoriesResource(self._client)
 
     @cached_property
-    def with_raw_response(self) -> AsyncV1ResourceWithRawResponse:
+    def status(self) -> AsyncStatusResource:
+        return AsyncStatusResource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> AsyncV0ResourceWithRawResponse:
         """
         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 AsyncV1ResourceWithRawResponse(self)
+        return AsyncV0ResourceWithRawResponse(self)
 
     @cached_property
-    def with_streaming_response(self) -> AsyncV1ResourceWithStreamingResponse:
+    def with_streaming_response(self) -> AsyncV0ResourceWithStreamingResponse:
         """
         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 AsyncV1ResourceWithStreamingResponse(self)
+        return AsyncV0ResourceWithStreamingResponse(self)
 
 
-class V1ResourceWithRawResponse:
-    def __init__(self, v1: V1Resource) -> None:
-        self._v1 = v1
+class V0ResourceWithRawResponse:
+    def __init__(self, v0: V0Resource) -> None:
+        self._v0 = v0
 
     @cached_property
     def memories(self) -> MemoriesResourceWithRawResponse:
-        return MemoriesResourceWithRawResponse(self._v1.memories)
+        return MemoriesResourceWithRawResponse(self._v0.memories)
+
+    @cached_property
+    def status(self) -> StatusResourceWithRawResponse:
+        return StatusResourceWithRawResponse(self._v0.status)
 
 
-class AsyncV1ResourceWithRawResponse:
-    def __init__(self, v1: AsyncV1Resource) -> None:
-        self._v1 = v1
+class AsyncV0ResourceWithRawResponse:
+    def __init__(self, v0: AsyncV0Resource) -> None:
+        self._v0 = v0
 
     @cached_property
     def memories(self) -> AsyncMemoriesResourceWithRawResponse:
-        return AsyncMemoriesResourceWithRawResponse(self._v1.memories)
+        return AsyncMemoriesResourceWithRawResponse(self._v0.memories)
+
+    @cached_property
+    def status(self) -> AsyncStatusResourceWithRawResponse:
+        return AsyncStatusResourceWithRawResponse(self._v0.status)
 
 
-class V1ResourceWithStreamingResponse:
-    def __init__(self, v1: V1Resource) -> None:
-        self._v1 = v1
+class V0ResourceWithStreamingResponse:
+    def __init__(self, v0: V0Resource) -> None:
+        self._v0 = v0
 
     @cached_property
     def memories(self) -> MemoriesResourceWithStreamingResponse:
-        return MemoriesResourceWithStreamingResponse(self._v1.memories)
+        return MemoriesResourceWithStreamingResponse(self._v0.memories)
+
+    @cached_property
+    def status(self) -> StatusResourceWithStreamingResponse:
+        return StatusResourceWithStreamingResponse(self._v0.status)
 
 
-class AsyncV1ResourceWithStreamingResponse:
-    def __init__(self, v1: AsyncV1Resource) -> None:
-        self._v1 = v1
+class AsyncV0ResourceWithStreamingResponse:
+    def __init__(self, v0: AsyncV0Resource) -> None:
+        self._v0 = v0
 
     @cached_property
     def memories(self) -> AsyncMemoriesResourceWithStreamingResponse:
-        return AsyncMemoriesResourceWithStreamingResponse(self._v1.memories)
+        return AsyncMemoriesResourceWithStreamingResponse(self._v0.memories)
+
+    @cached_property
+    def status(self) -> AsyncStatusResourceWithStreamingResponse:
+        return AsyncStatusResourceWithStreamingResponse(self._v0.status)

evermemos/types/{v1 → v0}/__init__.py

@@ -4,11 +4,9 @@ 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_add_params import MemoryAddParams as MemoryAddParams
+from .memory_add_response import MemoryAddResponse as MemoryAddResponse
 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_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/v0/memories/conversation_meta_create_params.py

@@ -0,0 +1,144 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, Optional
+from typing_extensions import Required, TypedDict
+
+from ...._types import SequenceNotStr
+
+__all__ = [
+    "ConversationMetaCreateParams",
+    "LlmCustomSetting",
+    "LlmCustomSettingBoundary",
+    "LlmCustomSettingExtraction",
+    "UserDetails",
+]
+
+
+class ConversationMetaCreateParams(TypedDict, total=False):
+    created_at: Required[str]
+    """Conversation creation time (ISO 8601 format with Timezone is required)"""
+
+    default_timezone: Optional[str]
+    """Default timezone"""
+
+    description: Optional[str]
+    """Conversation description"""
+
+    group_id: Optional[str]
+    """Group unique identifier.
+
+    When null/not provided, represents default settings for this scene.
+    """
+
+    llm_custom_setting: Optional[LlmCustomSetting]
+    """LLM custom settings for algorithm control.
+
+    **Only for global config (group_id=null), not allowed for group config (group_id
+    provided).**
+
+    Allows configuring different LLM providers/models for different tasks like
+    boundary detection and memory extraction.
+    """
+
+    name: Optional[str]
+    """Group/conversation name.
+
+    **Required for group config (group_id provided), not allowed for global config
+    (group_id=null).**
+    """
+
+    scene: Optional[str]
+    """Scene identifier.
+
+    **Required for global config (group_id=null), not allowed for group config
+    (group_id provided).**
+
+    Enum values from ScenarioType:
+
+    - group_chat: work/group chat scenario, suitable for group conversations such as
+      multi-person collaboration and project discussions
+    - assistant: assistant scenario, suitable for one-on-one AI assistant
+      conversations
+    """
+
+    scene_desc: Optional[Dict[str, object]]
+    """Scene description object.
+
+    **Required for global config (group_id=null), not allowed for group config
+    (group_id provided).**
+
+    Can include fields like description, type, etc.
+    """
+
+    tags: Optional[SequenceNotStr[str]]
+    """Tag list"""
+
+    user_details: Optional[Dict[str, UserDetails]]
+    """Participant details, key is user ID, value is user detail object"""
+
+
+class LlmCustomSettingBoundary(TypedDict, total=False):
+    """LLM config for boundary detection (fast, cheap model recommended)"""
+
+    model: Required[str]
+    """Model name"""
+
+    provider: Required[str]
+    """LLM provider name"""
+
+    extra: Optional[Dict[str, object]]
+    """Additional provider-specific configuration"""
+
+
+class LlmCustomSettingExtraction(TypedDict, total=False):
+    """LLM config for memory extraction (high quality model recommended)"""
+
+    model: Required[str]
+    """Model name"""
+
+    provider: Required[str]
+    """LLM provider name"""
+
+    extra: Optional[Dict[str, object]]
+    """Additional provider-specific configuration"""
+
+
+class LlmCustomSetting(TypedDict, total=False):
+    """LLM custom settings for algorithm control.
+
+    **Only for global config (group_id=null),
+    not allowed for group config (group_id provided).**
+
+    Allows configuring different LLM providers/models for different tasks like boundary detection and memory extraction.
+    """
+
+    boundary: Optional[LlmCustomSettingBoundary]
+    """LLM config for boundary detection (fast, cheap model recommended)"""
+
+    extra: Optional[Dict[str, object]]
+    """Additional task-specific LLM configurations"""
+
+    extraction: Optional[LlmCustomSettingExtraction]
+    """LLM config for memory extraction (high quality model recommended)"""
+
+
+class UserDetails(TypedDict, total=False):
+    custom_role: Optional[str]
+    """User's job/position role (e.g. developer, designer, manager)"""
+
+    extra: Optional[Dict[str, object]]
+    """Additional information"""
+
+    full_name: Optional[str]
+    """User full name"""
+
+    role: Optional[str]
+    """
+    User type role, used to identify if this user is a human or AI. Enum values from
+    MessageSenderRole:
+
+    - user: Human user
+    - assistant: AI assistant/bot
+    """