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

letta_sdk/resources/health.py

@@ -1,135 +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 .._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.health_check_response import HealthCheckResponse
-
-__all__ = ["HealthResource", "AsyncHealthResource"]
-
-
-class HealthResource(SyncAPIResource):
-    @cached_property
-    def with_raw_response(self) -> HealthResourceWithRawResponse:
-        """
-        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 HealthResourceWithRawResponse(self)
-
-    @cached_property
-    def with_streaming_response(self) -> HealthResourceWithStreamingResponse:
-        """
-        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 HealthResourceWithStreamingResponse(self)
-
-    def check(
-        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,
-    ) -> HealthCheckResponse:
-        """Check Health"""
-        return self._get(
-            "/v1/health/",
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=HealthCheckResponse,
-        )
-
-
-class AsyncHealthResource(AsyncAPIResource):
-    @cached_property
-    def with_raw_response(self) -> AsyncHealthResourceWithRawResponse:
-        """
-        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 AsyncHealthResourceWithRawResponse(self)
-
-    @cached_property
-    def with_streaming_response(self) -> AsyncHealthResourceWithStreamingResponse:
-        """
-        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 AsyncHealthResourceWithStreamingResponse(self)
-
-    async def check(
-        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,
-    ) -> HealthCheckResponse:
-        """Check Health"""
-        return await self._get(
-            "/v1/health/",
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=HealthCheckResponse,
-        )
-
-
-class HealthResourceWithRawResponse:
-    def __init__(self, health: HealthResource) -> None:
-        self._health = health
-
-        self.check = to_raw_response_wrapper(
-            health.check,
-        )
-
-
-class AsyncHealthResourceWithRawResponse:
-    def __init__(self, health: AsyncHealthResource) -> None:
-        self._health = health
-
-        self.check = async_to_raw_response_wrapper(
-            health.check,
-        )
-
-
-class HealthResourceWithStreamingResponse:
-    def __init__(self, health: HealthResource) -> None:
-        self._health = health
-
-        self.check = to_streamed_response_wrapper(
-            health.check,
-        )
-
-
-class AsyncHealthResourceWithStreamingResponse:
-    def __init__(self, health: AsyncHealthResource) -> None:
-        self._health = health
-
-        self.check = async_to_streamed_response_wrapper(
-            health.check,
-        )

letta_sdk/resources/messages/messages.py

@@ -1,102 +0,0 @@
-# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-from __future__ import annotations
-
-from .batches import (
-    BatchesResource,
-    AsyncBatchesResource,
-    BatchesResourceWithRawResponse,
-    AsyncBatchesResourceWithRawResponse,
-    BatchesResourceWithStreamingResponse,
-    AsyncBatchesResourceWithStreamingResponse,
-)
-from ..._compat import cached_property
-from ..._resource import SyncAPIResource, AsyncAPIResource
-
-__all__ = ["MessagesResource", "AsyncMessagesResource"]
-
-
-class MessagesResource(SyncAPIResource):
-    @cached_property
-    def batches(self) -> BatchesResource:
-        return BatchesResource(self._client)
-
-    @cached_property
-    def with_raw_response(self) -> MessagesResourceWithRawResponse:
-        """
-        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 MessagesResourceWithRawResponse(self)
-
-    @cached_property
-    def with_streaming_response(self) -> MessagesResourceWithStreamingResponse:
-        """
-        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 MessagesResourceWithStreamingResponse(self)
-
-
-class AsyncMessagesResource(AsyncAPIResource):
-    @cached_property
-    def batches(self) -> AsyncBatchesResource:
-        return AsyncBatchesResource(self._client)
-
-    @cached_property
-    def with_raw_response(self) -> AsyncMessagesResourceWithRawResponse:
-        """
-        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 AsyncMessagesResourceWithRawResponse(self)
-
-    @cached_property
-    def with_streaming_response(self) -> AsyncMessagesResourceWithStreamingResponse:
-        """
-        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 AsyncMessagesResourceWithStreamingResponse(self)
-
-
-class MessagesResourceWithRawResponse:
-    def __init__(self, messages: MessagesResource) -> None:
-        self._messages = messages
-
-    @cached_property
-    def batches(self) -> BatchesResourceWithRawResponse:
-        return BatchesResourceWithRawResponse(self._messages.batches)
-
-
-class AsyncMessagesResourceWithRawResponse:
-    def __init__(self, messages: AsyncMessagesResource) -> None:
-        self._messages = messages
-
-    @cached_property
-    def batches(self) -> AsyncBatchesResourceWithRawResponse:
-        return AsyncBatchesResourceWithRawResponse(self._messages.batches)
-
-
-class MessagesResourceWithStreamingResponse:
-    def __init__(self, messages: MessagesResource) -> None:
-        self._messages = messages
-
-    @cached_property
-    def batches(self) -> BatchesResourceWithStreamingResponse:
-        return BatchesResourceWithStreamingResponse(self._messages.batches)
-
-
-class AsyncMessagesResourceWithStreamingResponse:
-    def __init__(self, messages: AsyncMessagesResource) -> None:
-        self._messages = messages
-
-    @cached_property
-    def batches(self) -> AsyncBatchesResourceWithStreamingResponse:
-        return AsyncBatchesResourceWithStreamingResponse(self._messages.batches)

letta_sdk/resources/projects.py

@@ -1,189 +0,0 @@
-# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-from __future__ import annotations
-
-from typing import Union
-
-import httpx
-
-from ..types import project_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 .._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.project_list_response import ProjectListResponse
-
-__all__ = ["ProjectsResource", "AsyncProjectsResource"]
-
-
-class ProjectsResource(SyncAPIResource):
-    @cached_property
-    def with_raw_response(self) -> ProjectsResourceWithRawResponse:
-        """
-        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 ProjectsResourceWithRawResponse(self)
-
-    @cached_property
-    def with_streaming_response(self) -> ProjectsResourceWithStreamingResponse:
-        """
-        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 ProjectsResourceWithStreamingResponse(self)
-
-    def list(
-        self,
-        *,
-        limit: str | Omit = omit,
-        name: str | Omit = omit,
-        offset: Union[str, float] | 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,
-    ) -> ProjectListResponse:
-        """
-        List all projects
-
-        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
-        """
-        return self._get(
-            "/v1/projects",
-            options=make_request_options(
-                extra_headers=extra_headers,
-                extra_query=extra_query,
-                extra_body=extra_body,
-                timeout=timeout,
-                query=maybe_transform(
-                    {
-                        "limit": limit,
-                        "name": name,
-                        "offset": offset,
-                    },
-                    project_list_params.ProjectListParams,
-                ),
-            ),
-            cast_to=ProjectListResponse,
-        )
-
-
-class AsyncProjectsResource(AsyncAPIResource):
-    @cached_property
-    def with_raw_response(self) -> AsyncProjectsResourceWithRawResponse:
-        """
-        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 AsyncProjectsResourceWithRawResponse(self)
-
-    @cached_property
-    def with_streaming_response(self) -> AsyncProjectsResourceWithStreamingResponse:
-        """
-        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 AsyncProjectsResourceWithStreamingResponse(self)
-
-    async def list(
-        self,
-        *,
-        limit: str | Omit = omit,
-        name: str | Omit = omit,
-        offset: Union[str, float] | 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,
-    ) -> ProjectListResponse:
-        """
-        List all projects
-
-        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
-        """
-        return await self._get(
-            "/v1/projects",
-            options=make_request_options(
-                extra_headers=extra_headers,
-                extra_query=extra_query,
-                extra_body=extra_body,
-                timeout=timeout,
-                query=await async_maybe_transform(
-                    {
-                        "limit": limit,
-                        "name": name,
-                        "offset": offset,
-                    },
-                    project_list_params.ProjectListParams,
-                ),
-            ),
-            cast_to=ProjectListResponse,
-        )
-
-
-class ProjectsResourceWithRawResponse:
-    def __init__(self, projects: ProjectsResource) -> None:
-        self._projects = projects
-
-        self.list = to_raw_response_wrapper(
-            projects.list,
-        )
-
-
-class AsyncProjectsResourceWithRawResponse:
-    def __init__(self, projects: AsyncProjectsResource) -> None:
-        self._projects = projects
-
-        self.list = async_to_raw_response_wrapper(
-            projects.list,
-        )
-
-
-class ProjectsResourceWithStreamingResponse:
-    def __init__(self, projects: ProjectsResource) -> None:
-        self._projects = projects
-
-        self.list = to_streamed_response_wrapper(
-            projects.list,
-        )
-
-
-class AsyncProjectsResourceWithStreamingResponse:
-    def __init__(self, projects: AsyncProjectsResource) -> None:
-        self._projects = projects
-
-        self.list = async_to_streamed_response_wrapper(
-            projects.list,
-        )