letta-client 1.0.0a6__py3-none-any.whl → 1.0.0a8__py3-none-any.whl

letta_client/resources/identities/properties.py

@@ -0,0 +1,174 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Iterable
+
+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.identity_property_param import IdentityPropertyParam
+
+__all__ = ["PropertiesResource", "AsyncPropertiesResource"]
+
+
+class PropertiesResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> PropertiesResourceWithRawResponse:
+        """
+        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/letta-ai/letta-python#accessing-raw-response-data-eg-headers
+        """
+        return PropertiesResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> PropertiesResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/letta-ai/letta-python#with_streaming_response
+        """
+        return PropertiesResourceWithStreamingResponse(self)
+
+    def upsert(
+        self,
+        identity_id: str,
+        *,
+        body: Iterable[IdentityPropertyParam],
+        # 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,
+    ) -> object:
+        """
+        Upsert Identity Properties
+
+        Args:
+          identity_id: The ID of the identity in the format 'identity-<uuid4>'
+
+          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
+        """
+        if not identity_id:
+            raise ValueError(f"Expected a non-empty value for `identity_id` but received {identity_id!r}")
+        return self._put(
+            f"/v1/identities/{identity_id}/properties",
+            body=maybe_transform(body, Iterable[IdentityPropertyParam]),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=object,
+        )
+
+
+class AsyncPropertiesResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncPropertiesResourceWithRawResponse:
+        """
+        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/letta-ai/letta-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncPropertiesResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncPropertiesResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/letta-ai/letta-python#with_streaming_response
+        """
+        return AsyncPropertiesResourceWithStreamingResponse(self)
+
+    async def upsert(
+        self,
+        identity_id: str,
+        *,
+        body: Iterable[IdentityPropertyParam],
+        # 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,
+    ) -> object:
+        """
+        Upsert Identity Properties
+
+        Args:
+          identity_id: The ID of the identity in the format 'identity-<uuid4>'
+
+          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
+        """
+        if not identity_id:
+            raise ValueError(f"Expected a non-empty value for `identity_id` but received {identity_id!r}")
+        return await self._put(
+            f"/v1/identities/{identity_id}/properties",
+            body=await async_maybe_transform(body, Iterable[IdentityPropertyParam]),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=object,
+        )
+
+
+class PropertiesResourceWithRawResponse:
+    def __init__(self, properties: PropertiesResource) -> None:
+        self._properties = properties
+
+        self.upsert = to_raw_response_wrapper(
+            properties.upsert,
+        )
+
+
+class AsyncPropertiesResourceWithRawResponse:
+    def __init__(self, properties: AsyncPropertiesResource) -> None:
+        self._properties = properties
+
+        self.upsert = async_to_raw_response_wrapper(
+            properties.upsert,
+        )
+
+
+class PropertiesResourceWithStreamingResponse:
+    def __init__(self, properties: PropertiesResource) -> None:
+        self._properties = properties
+
+        self.upsert = to_streamed_response_wrapper(
+            properties.upsert,
+        )
+
+
+class AsyncPropertiesResourceWithStreamingResponse:
+    def __init__(self, properties: AsyncPropertiesResource) -> None:
+        self._properties = properties
+
+        self.upsert = async_to_streamed_response_wrapper(
+            properties.upsert,
+        )

letta_client/resources/models/__init__.py

@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .models import (
+    ModelsResource,
+    AsyncModelsResource,
+    ModelsResourceWithRawResponse,
+    AsyncModelsResourceWithRawResponse,
+    ModelsResourceWithStreamingResponse,
+    AsyncModelsResourceWithStreamingResponse,
+)
+from .embeddings import (
+    EmbeddingsResource,
+    AsyncEmbeddingsResource,
+    EmbeddingsResourceWithRawResponse,
+    AsyncEmbeddingsResourceWithRawResponse,
+    EmbeddingsResourceWithStreamingResponse,
+    AsyncEmbeddingsResourceWithStreamingResponse,
+)
+
+__all__ = [
+    "EmbeddingsResource",
+    "AsyncEmbeddingsResource",
+    "EmbeddingsResourceWithRawResponse",
+    "AsyncEmbeddingsResourceWithRawResponse",
+    "EmbeddingsResourceWithStreamingResponse",
+    "AsyncEmbeddingsResourceWithStreamingResponse",
+    "ModelsResource",
+    "AsyncModelsResource",
+    "ModelsResourceWithRawResponse",
+    "AsyncModelsResourceWithRawResponse",
+    "ModelsResourceWithStreamingResponse",
+    "AsyncModelsResourceWithStreamingResponse",
+]

{letta_sdk/resources → letta_client/resources/models}/embeddings.py

@@ -4,18 +4,17 @@ from __future__ import annotations
 
 import httpx
 
-from .._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
-from .._utils import strip_not_given
-from .._compat import cached_property
-from .._resource import SyncAPIResource, AsyncAPIResource
-from .._response import (
+from ..._types import Body, Query, Headers, NotGiven, not_given
+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.embedding_get_total_storage_size_response import EmbeddingGetTotalStorageSizeResponse
+from ..._base_client import make_request_options
+from ...types.models.embedding_list_response import EmbeddingListResponse
 
 __all__ = ["EmbeddingsResource", "AsyncEmbeddingsResource"]
 
@@ -40,37 +39,26 @@ class EmbeddingsResource(SyncAPIResource):
         """
         return EmbeddingsResourceWithStreamingResponse(self)
 
-    def get_total_storage_size(
+    def list(
         self,
         *,
-        storage_unit: 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,
-    ) -> EmbeddingGetTotalStorageSizeResponse:
+    ) -> EmbeddingListResponse:
         """
-        Get the total size of all embeddings in the database for a user in the storage
-        unit given.
-
-        Args:
-          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
+        List available embedding models using the asynchronous implementation for
+        improved performance
         """
-        extra_headers = {**strip_not_given({"storage-unit": storage_unit}), **(extra_headers or {})}
         return self._get(
-            "/v1/embeddings/total_storage_size",
+            "/v1/models/embedding",
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
-            cast_to=float,
+            cast_to=EmbeddingListResponse,
         )
 
 
@@ -94,37 +82,26 @@ class AsyncEmbeddingsResource(AsyncAPIResource):
         """
         return AsyncEmbeddingsResourceWithStreamingResponse(self)
 
-    async def get_total_storage_size(
+    async def list(
         self,
         *,
-        storage_unit: 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,
-    ) -> EmbeddingGetTotalStorageSizeResponse:
+    ) -> EmbeddingListResponse:
         """
-        Get the total size of all embeddings in the database for a user in the storage
-        unit given.
-
-        Args:
-          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
+        List available embedding models using the asynchronous implementation for
+        improved performance
         """
-        extra_headers = {**strip_not_given({"storage-unit": storage_unit}), **(extra_headers or {})}
         return await self._get(
-            "/v1/embeddings/total_storage_size",
+            "/v1/models/embedding",
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
-            cast_to=float,
+            cast_to=EmbeddingListResponse,
         )
 
 
@@ -132,8 +109,8 @@ class EmbeddingsResourceWithRawResponse:
     def __init__(self, embeddings: EmbeddingsResource) -> None:
         self._embeddings = embeddings
 
-        self.get_total_storage_size = to_raw_response_wrapper(
-            embeddings.get_total_storage_size,
+        self.list = to_raw_response_wrapper(
+            embeddings.list,
         )
 
 
@@ -141,8 +118,8 @@ class AsyncEmbeddingsResourceWithRawResponse:
     def __init__(self, embeddings: AsyncEmbeddingsResource) -> None:
         self._embeddings = embeddings
 
-        self.get_total_storage_size = async_to_raw_response_wrapper(
-            embeddings.get_total_storage_size,
+        self.list = async_to_raw_response_wrapper(
+            embeddings.list,
         )
 
 
@@ -150,8 +127,8 @@ class EmbeddingsResourceWithStreamingResponse:
     def __init__(self, embeddings: EmbeddingsResource) -> None:
         self._embeddings = embeddings
 
-        self.get_total_storage_size = to_streamed_response_wrapper(
-            embeddings.get_total_storage_size,
+        self.list = to_streamed_response_wrapper(
+            embeddings.list,
         )
 
 
@@ -159,6 +136,6 @@ class AsyncEmbeddingsResourceWithStreamingResponse:
     def __init__(self, embeddings: AsyncEmbeddingsResource) -> None:
         self._embeddings = embeddings
 
-        self.get_total_storage_size = async_to_streamed_response_wrapper(
-            embeddings.get_total_storage_size,
+        self.list = async_to_streamed_response_wrapper(
+            embeddings.list,
         )

{letta_sdk/resources → letta_client/resources/models}/models.py

@@ -6,27 +6,38 @@ from typing import List, Optional
 
 import httpx
 
-from ..types import ProviderType, model_list_params
-from .._types import Body, Omit, Query, Headers, NoneType, NotGiven, omit, not_given
-from .._utils import maybe_transform, async_maybe_transform
-from .._compat import cached_property
-from .._resource import SyncAPIResource, AsyncAPIResource
-from .._response import (
+from ...types import ProviderType, model_list_params
+from ..._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
+from ..._utils import maybe_transform, async_maybe_transform
+from ..._compat import cached_property
+from .embeddings import (
+    EmbeddingsResource,
+    AsyncEmbeddingsResource,
+    EmbeddingsResourceWithRawResponse,
+    AsyncEmbeddingsResourceWithRawResponse,
+    EmbeddingsResourceWithStreamingResponse,
+    AsyncEmbeddingsResourceWithStreamingResponse,
+)
+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.provider_type import ProviderType
-from ..types.provider_category import ProviderCategory
-from ..types.model_list_response import ModelListResponse
-from ..types.model_list_embedding_response import ModelListEmbeddingResponse
+from ..._base_client import make_request_options
+from ...types.provider_type import ProviderType
+from ...types.provider_category import ProviderCategory
+from ...types.model_list_response import ModelListResponse
 
 __all__ = ["ModelsResource", "AsyncModelsResource"]
 
 
 class ModelsResource(SyncAPIResource):
+    @cached_property
+    def embeddings(self) -> EmbeddingsResource:
+        return EmbeddingsResource(self._client)
+
     @cached_property
     def with_raw_response(self) -> ModelsResourceWithRawResponse:
         """
@@ -91,49 +102,12 @@ class ModelsResource(SyncAPIResource):
             cast_to=ModelListResponse,
         )
 
-    def list_embedding(
-        self,
-        *,
-        # 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,
-    ) -> ModelListEmbeddingResponse:
-        """
-        List available embedding models using the asynchronous implementation for
-        improved performance
-        """
-        return self._get(
-            "/v1/models/embedding",
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=ModelListEmbeddingResponse,
-        )
-
-    def list_embeddings(
-        self,
-        *,
-        # 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,
-    ) -> None:
-        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
-        return self._get(
-            "/v1/models/embeddings",
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=NoneType,
-        )
-
 
 class AsyncModelsResource(AsyncAPIResource):
+    @cached_property
+    def embeddings(self) -> AsyncEmbeddingsResource:
+        return AsyncEmbeddingsResource(self._client)
+
     @cached_property
     def with_raw_response(self) -> AsyncModelsResourceWithRawResponse:
         """
@@ -198,47 +172,6 @@ class AsyncModelsResource(AsyncAPIResource):
             cast_to=ModelListResponse,
         )
 
-    async def list_embedding(
-        self,
-        *,
-        # 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,
-    ) -> ModelListEmbeddingResponse:
-        """
-        List available embedding models using the asynchronous implementation for
-        improved performance
-        """
-        return await self._get(
-            "/v1/models/embedding",
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=ModelListEmbeddingResponse,
-        )
-
-    async def list_embeddings(
-        self,
-        *,
-        # 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,
-    ) -> None:
-        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
-        return await self._get(
-            "/v1/models/embeddings",
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=NoneType,
-        )
-
 
 class ModelsResourceWithRawResponse:
     def __init__(self, models: ModelsResource) -> None:
@@ -247,12 +180,10 @@ class ModelsResourceWithRawResponse:
         self.list = to_raw_response_wrapper(
             models.list,
         )
-        self.list_embedding = to_raw_response_wrapper(
-            models.list_embedding,
-        )
-        self.list_embeddings = to_raw_response_wrapper(
-            models.list_embeddings,
-        )
+
+    @cached_property
+    def embeddings(self) -> EmbeddingsResourceWithRawResponse:
+        return EmbeddingsResourceWithRawResponse(self._models.embeddings)
 
 
 class AsyncModelsResourceWithRawResponse:
@@ -262,12 +193,10 @@ class AsyncModelsResourceWithRawResponse:
         self.list = async_to_raw_response_wrapper(
             models.list,
         )
-        self.list_embedding = async_to_raw_response_wrapper(
-            models.list_embedding,
-        )
-        self.list_embeddings = async_to_raw_response_wrapper(
-            models.list_embeddings,
-        )
+
+    @cached_property
+    def embeddings(self) -> AsyncEmbeddingsResourceWithRawResponse:
+        return AsyncEmbeddingsResourceWithRawResponse(self._models.embeddings)
 
 
 class ModelsResourceWithStreamingResponse:
@@ -277,12 +206,10 @@ class ModelsResourceWithStreamingResponse:
         self.list = to_streamed_response_wrapper(
             models.list,
         )
-        self.list_embedding = to_streamed_response_wrapper(
-            models.list_embedding,
-        )
-        self.list_embeddings = to_streamed_response_wrapper(
-            models.list_embeddings,
-        )
+
+    @cached_property
+    def embeddings(self) -> EmbeddingsResourceWithStreamingResponse:
+        return EmbeddingsResourceWithStreamingResponse(self._models.embeddings)
 
 
 class AsyncModelsResourceWithStreamingResponse:
@@ -292,9 +219,7 @@ class AsyncModelsResourceWithStreamingResponse:
         self.list = async_to_streamed_response_wrapper(
             models.list,
         )
-        self.list_embedding = async_to_streamed_response_wrapper(
-            models.list_embedding,
-        )
-        self.list_embeddings = async_to_streamed_response_wrapper(
-            models.list_embeddings,
-        )
+
+    @cached_property
+    def embeddings(self) -> AsyncEmbeddingsResourceWithStreamingResponse:
+        return AsyncEmbeddingsResourceWithStreamingResponse(self._models.embeddings)

letta_client/resources/runs/__init__.py

@@ -0,0 +1,61 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .runs import (
+    RunsResource,
+    AsyncRunsResource,
+    RunsResourceWithRawResponse,
+    AsyncRunsResourceWithRawResponse,
+    RunsResourceWithStreamingResponse,
+    AsyncRunsResourceWithStreamingResponse,
+)
+from .steps import (
+    StepsResource,
+    AsyncStepsResource,
+    StepsResourceWithRawResponse,
+    AsyncStepsResourceWithRawResponse,
+    StepsResourceWithStreamingResponse,
+    AsyncStepsResourceWithStreamingResponse,
+)
+from .usage import (
+    UsageResource,
+    AsyncUsageResource,
+    UsageResourceWithRawResponse,
+    AsyncUsageResourceWithRawResponse,
+    UsageResourceWithStreamingResponse,
+    AsyncUsageResourceWithStreamingResponse,
+)
+from .messages import (
+    MessagesResource,
+    AsyncMessagesResource,
+    MessagesResourceWithRawResponse,
+    AsyncMessagesResourceWithRawResponse,
+    MessagesResourceWithStreamingResponse,
+    AsyncMessagesResourceWithStreamingResponse,
+)
+
+__all__ = [
+    "MessagesResource",
+    "AsyncMessagesResource",
+    "MessagesResourceWithRawResponse",
+    "AsyncMessagesResourceWithRawResponse",
+    "MessagesResourceWithStreamingResponse",
+    "AsyncMessagesResourceWithStreamingResponse",
+    "UsageResource",
+    "AsyncUsageResource",
+    "UsageResourceWithRawResponse",
+    "AsyncUsageResourceWithRawResponse",
+    "UsageResourceWithStreamingResponse",
+    "AsyncUsageResourceWithStreamingResponse",
+    "StepsResource",
+    "AsyncStepsResource",
+    "StepsResourceWithRawResponse",
+    "AsyncStepsResourceWithRawResponse",
+    "StepsResourceWithStreamingResponse",
+    "AsyncStepsResourceWithStreamingResponse",
+    "RunsResource",
+    "AsyncRunsResource",
+    "RunsResourceWithRawResponse",
+    "AsyncRunsResourceWithRawResponse",
+    "RunsResourceWithStreamingResponse",
+    "AsyncRunsResourceWithStreamingResponse",
+]