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

evermemos/resources/v1/global_user_profile/custom.py

@@ -1,185 +0,0 @@
-# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-from __future__ import annotations
-
-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.global_user_profile import custom_upsert_params
-from ....types.v1.global_user_profile.custom_upsert_response import CustomUpsertResponse
-
-__all__ = ["CustomResource", "AsyncCustomResource"]
-
-
-class CustomResource(SyncAPIResource):
-    @cached_property
-    def with_raw_response(self) -> CustomResourceWithRawResponse:
-        """
-        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 CustomResourceWithRawResponse(self)
-
-    @cached_property
-    def with_streaming_response(self) -> CustomResourceWithStreamingResponse:
-        """
-        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 CustomResourceWithStreamingResponse(self)
-
-    def upsert(
-        self,
-        *,
-        custom_profile_data: custom_upsert_params.CustomProfileData,
-        user_id: 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,
-    ) -> CustomUpsertResponse:
-        """
-        Upsert custom profile data for a user
-
-        Args:
-          custom_profile_data: Custom profile data to upsert
-
-          user_id: User ID
-
-          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/global-user-profile/custom",
-            body=maybe_transform(
-                {
-                    "custom_profile_data": custom_profile_data,
-                    "user_id": user_id,
-                },
-                custom_upsert_params.CustomUpsertParams,
-            ),
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=CustomUpsertResponse,
-        )
-
-
-class AsyncCustomResource(AsyncAPIResource):
-    @cached_property
-    def with_raw_response(self) -> AsyncCustomResourceWithRawResponse:
-        """
-        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 AsyncCustomResourceWithRawResponse(self)
-
-    @cached_property
-    def with_streaming_response(self) -> AsyncCustomResourceWithStreamingResponse:
-        """
-        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 AsyncCustomResourceWithStreamingResponse(self)
-
-    async def upsert(
-        self,
-        *,
-        custom_profile_data: custom_upsert_params.CustomProfileData,
-        user_id: 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,
-    ) -> CustomUpsertResponse:
-        """
-        Upsert custom profile data for a user
-
-        Args:
-          custom_profile_data: Custom profile data to upsert
-
-          user_id: User ID
-
-          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/global-user-profile/custom",
-            body=await async_maybe_transform(
-                {
-                    "custom_profile_data": custom_profile_data,
-                    "user_id": user_id,
-                },
-                custom_upsert_params.CustomUpsertParams,
-            ),
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=CustomUpsertResponse,
-        )
-
-
-class CustomResourceWithRawResponse:
-    def __init__(self, custom: CustomResource) -> None:
-        self._custom = custom
-
-        self.upsert = to_raw_response_wrapper(
-            custom.upsert,
-        )
-
-
-class AsyncCustomResourceWithRawResponse:
-    def __init__(self, custom: AsyncCustomResource) -> None:
-        self._custom = custom
-
-        self.upsert = async_to_raw_response_wrapper(
-            custom.upsert,
-        )
-
-
-class CustomResourceWithStreamingResponse:
-    def __init__(self, custom: CustomResource) -> None:
-        self._custom = custom
-
-        self.upsert = to_streamed_response_wrapper(
-            custom.upsert,
-        )
-
-
-class AsyncCustomResourceWithStreamingResponse:
-    def __init__(self, custom: AsyncCustomResource) -> None:
-        self._custom = custom
-
-        self.upsert = async_to_streamed_response_wrapper(
-            custom.upsert,
-        )

evermemos/resources/v1/global_user_profile/global_user_profile.py

@@ -1,102 +0,0 @@
-# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-from __future__ import annotations
-
-from .custom import (
-    CustomResource,
-    AsyncCustomResource,
-    CustomResourceWithRawResponse,
-    AsyncCustomResourceWithRawResponse,
-    CustomResourceWithStreamingResponse,
-    AsyncCustomResourceWithStreamingResponse,
-)
-from ...._compat import cached_property
-from ...._resource import SyncAPIResource, AsyncAPIResource
-
-__all__ = ["GlobalUserProfileResource", "AsyncGlobalUserProfileResource"]
-
-
-class GlobalUserProfileResource(SyncAPIResource):
-    @cached_property
-    def custom(self) -> CustomResource:
-        return CustomResource(self._client)
-
-    @cached_property
-    def with_raw_response(self) -> GlobalUserProfileResourceWithRawResponse:
-        """
-        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 GlobalUserProfileResourceWithRawResponse(self)
-
-    @cached_property
-    def with_streaming_response(self) -> GlobalUserProfileResourceWithStreamingResponse:
-        """
-        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 GlobalUserProfileResourceWithStreamingResponse(self)
-
-
-class AsyncGlobalUserProfileResource(AsyncAPIResource):
-    @cached_property
-    def custom(self) -> AsyncCustomResource:
-        return AsyncCustomResource(self._client)
-
-    @cached_property
-    def with_raw_response(self) -> AsyncGlobalUserProfileResourceWithRawResponse:
-        """
-        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 AsyncGlobalUserProfileResourceWithRawResponse(self)
-
-    @cached_property
-    def with_streaming_response(self) -> AsyncGlobalUserProfileResourceWithStreamingResponse:
-        """
-        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 AsyncGlobalUserProfileResourceWithStreamingResponse(self)
-
-
-class GlobalUserProfileResourceWithRawResponse:
-    def __init__(self, global_user_profile: GlobalUserProfileResource) -> None:
-        self._global_user_profile = global_user_profile
-
-    @cached_property
-    def custom(self) -> CustomResourceWithRawResponse:
-        return CustomResourceWithRawResponse(self._global_user_profile.custom)
-
-
-class AsyncGlobalUserProfileResourceWithRawResponse:
-    def __init__(self, global_user_profile: AsyncGlobalUserProfileResource) -> None:
-        self._global_user_profile = global_user_profile
-
-    @cached_property
-    def custom(self) -> AsyncCustomResourceWithRawResponse:
-        return AsyncCustomResourceWithRawResponse(self._global_user_profile.custom)
-
-
-class GlobalUserProfileResourceWithStreamingResponse:
-    def __init__(self, global_user_profile: GlobalUserProfileResource) -> None:
-        self._global_user_profile = global_user_profile
-
-    @cached_property
-    def custom(self) -> CustomResourceWithStreamingResponse:
-        return CustomResourceWithStreamingResponse(self._global_user_profile.custom)
-
-
-class AsyncGlobalUserProfileResourceWithStreamingResponse:
-    def __init__(self, global_user_profile: AsyncGlobalUserProfileResource) -> None:
-        self._global_user_profile = global_user_profile
-
-    @cached_property
-    def custom(self) -> AsyncCustomResourceWithStreamingResponse:
-        return AsyncCustomResourceWithStreamingResponse(self._global_user_profile.custom)

evermemos/resources/v1/stats/__init__.py

@@ -1,33 +0,0 @@
-# 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

@@ -1,175 +0,0 @@
-# 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: Request ID (recommended)
-
-          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: Request ID (recommended)
-
-          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

@@ -1,102 +0,0 @@
-# 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/types/v1/global_user_profile/custom_upsert_params.py

@@ -1,24 +0,0 @@
-# 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

@@ -1,23 +0,0 @@
-# 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/stats/request_get_params.py

@@ -1,13 +0,0 @@
-# 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

@@ -1,26 +0,0 @@
-# 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"""