raccoonai 0.1.0a8__py3-none-any.whl → 0.1.0a10__py3-none-any.whl

raccoonai/_base_client.py

@@ -9,7 +9,6 @@ import asyncio
 import inspect
 import logging
 import platform
-import warnings
 import email.utils
 from types import TracebackType
 from random import random
@@ -36,7 +35,7 @@ import anyio
 import httpx
 import distro
 import pydantic
-from httpx import URL, Limits
+from httpx import URL
 from pydantic import PrivateAttr
 
 from . import _exceptions
@@ -51,13 +50,10 @@ from ._types import (
     Timeout,
     NotGiven,
     ResponseT,
-    Transport,
     AnyMapping,
     PostParser,
-    ProxiesTypes,
     RequestFiles,
     HttpxSendArgs,
-    AsyncTransport,
     RequestOptions,
     HttpxRequestFiles,
     ModelBuilderProtocol,
@@ -337,9 +333,6 @@ class BaseClient(Generic[_HttpxClientT, _DefaultStreamT]):
     _base_url: URL
     max_retries: int
     timeout: Union[float, Timeout, None]
-    _limits: httpx.Limits
-    _proxies: ProxiesTypes | None
-    _transport: Transport | AsyncTransport | None
     _strict_response_validation: bool
     _idempotency_header: str | None
     _default_stream_cls: type[_DefaultStreamT] | None = None
@@ -352,9 +345,6 @@ class BaseClient(Generic[_HttpxClientT, _DefaultStreamT]):
         _strict_response_validation: bool,
         max_retries: int = DEFAULT_MAX_RETRIES,
         timeout: float | Timeout | None = DEFAULT_TIMEOUT,
-        limits: httpx.Limits,
-        transport: Transport | AsyncTransport | None,
-        proxies: ProxiesTypes | None,
         custom_headers: Mapping[str, str] | None = None,
         custom_query: Mapping[str, object] | None = None,
     ) -> None:
@@ -362,9 +352,6 @@ class BaseClient(Generic[_HttpxClientT, _DefaultStreamT]):
         self._base_url = self._enforce_trailing_slash(URL(base_url))
         self.max_retries = max_retries
         self.timeout = timeout
-        self._limits = limits
-        self._proxies = proxies
-        self._transport = transport
         self._custom_headers = custom_headers or {}
         self._custom_query = custom_query or {}
         self._strict_response_validation = _strict_response_validation
@@ -800,46 +787,11 @@ class SyncAPIClient(BaseClient[httpx.Client, Stream[Any]]):
         base_url: str | URL,
         max_retries: int = DEFAULT_MAX_RETRIES,
         timeout: float | Timeout | None | NotGiven = NOT_GIVEN,
-        transport: Transport | None = None,
-        proxies: ProxiesTypes | None = None,
-        limits: Limits | None = None,
         http_client: httpx.Client | None = None,
         custom_headers: Mapping[str, str] | None = None,
         custom_query: Mapping[str, object] | None = None,
         _strict_response_validation: bool,
     ) -> None:
-        kwargs: dict[str, Any] = {}
-        if limits is not None:
-            warnings.warn(
-                "The `connection_pool_limits` argument is deprecated. The `http_client` argument should be passed instead",
-                category=DeprecationWarning,
-                stacklevel=3,
-            )
-            if http_client is not None:
-                raise ValueError("The `http_client` argument is mutually exclusive with `connection_pool_limits`")
-        else:
-            limits = DEFAULT_CONNECTION_LIMITS
-
-        if transport is not None:
-            kwargs["transport"] = transport
-            warnings.warn(
-                "The `transport` argument is deprecated. The `http_client` argument should be passed instead",
-                category=DeprecationWarning,
-                stacklevel=3,
-            )
-            if http_client is not None:
-                raise ValueError("The `http_client` argument is mutually exclusive with `transport`")
-
-        if proxies is not None:
-            kwargs["proxies"] = proxies
-            warnings.warn(
-                "The `proxies` argument is deprecated. The `http_client` argument should be passed instead",
-                category=DeprecationWarning,
-                stacklevel=3,
-            )
-            if http_client is not None:
-                raise ValueError("The `http_client` argument is mutually exclusive with `proxies`")
-
         if not is_given(timeout):
             # if the user passed in a custom http client with a non-default
             # timeout set then we use that timeout.
@@ -860,12 +812,9 @@ class SyncAPIClient(BaseClient[httpx.Client, Stream[Any]]):
 
         super().__init__(
             version=version,
-            limits=limits,
             # cast to a valid type because mypy doesn't understand our type narrowing
             timeout=cast(Timeout, timeout),
-            proxies=proxies,
             base_url=base_url,
-            transport=transport,
             max_retries=max_retries,
             custom_query=custom_query,
             custom_headers=custom_headers,
@@ -875,9 +824,6 @@ class SyncAPIClient(BaseClient[httpx.Client, Stream[Any]]):
             base_url=base_url,
             # cast to a valid type because mypy doesn't understand our type narrowing
             timeout=cast(Timeout, timeout),
-            limits=limits,
-            follow_redirects=True,
-            **kwargs,  # type: ignore
         )
 
     def is_closed(self) -> bool:
@@ -1372,45 +1318,10 @@ class AsyncAPIClient(BaseClient[httpx.AsyncClient, AsyncStream[Any]]):
         _strict_response_validation: bool,
         max_retries: int = DEFAULT_MAX_RETRIES,
         timeout: float | Timeout | None | NotGiven = NOT_GIVEN,
-        transport: AsyncTransport | None = None,
-        proxies: ProxiesTypes | None = None,
-        limits: Limits | None = None,
         http_client: httpx.AsyncClient | None = None,
         custom_headers: Mapping[str, str] | None = None,
         custom_query: Mapping[str, object] | None = None,
     ) -> None:
-        kwargs: dict[str, Any] = {}
-        if limits is not None:
-            warnings.warn(
-                "The `connection_pool_limits` argument is deprecated. The `http_client` argument should be passed instead",
-                category=DeprecationWarning,
-                stacklevel=3,
-            )
-            if http_client is not None:
-                raise ValueError("The `http_client` argument is mutually exclusive with `connection_pool_limits`")
-        else:
-            limits = DEFAULT_CONNECTION_LIMITS
-
-        if transport is not None:
-            kwargs["transport"] = transport
-            warnings.warn(
-                "The `transport` argument is deprecated. The `http_client` argument should be passed instead",
-                category=DeprecationWarning,
-                stacklevel=3,
-            )
-            if http_client is not None:
-                raise ValueError("The `http_client` argument is mutually exclusive with `transport`")
-
-        if proxies is not None:
-            kwargs["proxies"] = proxies
-            warnings.warn(
-                "The `proxies` argument is deprecated. The `http_client` argument should be passed instead",
-                category=DeprecationWarning,
-                stacklevel=3,
-            )
-            if http_client is not None:
-                raise ValueError("The `http_client` argument is mutually exclusive with `proxies`")
-
         if not is_given(timeout):
             # if the user passed in a custom http client with a non-default
             # timeout set then we use that timeout.
@@ -1432,11 +1343,8 @@ class AsyncAPIClient(BaseClient[httpx.AsyncClient, AsyncStream[Any]]):
         super().__init__(
             version=version,
             base_url=base_url,
-            limits=limits,
             # cast to a valid type because mypy doesn't understand our type narrowing
             timeout=cast(Timeout, timeout),
-            proxies=proxies,
-            transport=transport,
             max_retries=max_retries,
             custom_query=custom_query,
             custom_headers=custom_headers,
@@ -1446,9 +1354,6 @@ class AsyncAPIClient(BaseClient[httpx.AsyncClient, AsyncStream[Any]]):
             base_url=base_url,
             # cast to a valid type because mypy doesn't understand our type narrowing
             timeout=cast(Timeout, timeout),
-            limits=limits,
-            follow_redirects=True,
-            **kwargs,  # type: ignore
         )
 
     def is_closed(self) -> bool:

raccoonai/_client.py

@@ -24,7 +24,6 @@ from ._utils import (
     get_async_library,
 )
 from ._version import __version__
-from .resources import lam, fleet, extensions
 from ._streaming import Stream as Stream, AsyncStream as AsyncStream
 from ._exceptions import APIStatusError, RaccoonAIError
 from ._base_client import (
@@ -32,7 +31,9 @@ from ._base_client import (
     SyncAPIClient,
     AsyncAPIClient,
 )
+from .resources.lam import lam
 from .resources.tail import tail
+from .resources.fleet import fleet
 
 __all__ = [
     "ENVIRONMENTS",
@@ -57,7 +58,6 @@ class RaccoonAI(SyncAPIClient):
     lam: lam.LamResource
     tail: tail.TailResource
     fleet: fleet.FleetResource
-    extensions: extensions.ExtensionsResource
     with_raw_response: RaccoonAIWithRawResponse
     with_streaming_response: RaccoonAIWithStreamedResponse
 
@@ -142,7 +142,6 @@ class RaccoonAI(SyncAPIClient):
         self.lam = lam.LamResource(self)
         self.tail = tail.TailResource(self)
         self.fleet = fleet.FleetResource(self)
-        self.extensions = extensions.ExtensionsResource(self)
         self.with_raw_response = RaccoonAIWithRawResponse(self)
         self.with_streaming_response = RaccoonAIWithStreamedResponse(self)
 
@@ -257,7 +256,6 @@ class AsyncRaccoonAI(AsyncAPIClient):
     lam: lam.AsyncLamResource
     tail: tail.AsyncTailResource
     fleet: fleet.AsyncFleetResource
-    extensions: extensions.AsyncExtensionsResource
     with_raw_response: AsyncRaccoonAIWithRawResponse
     with_streaming_response: AsyncRaccoonAIWithStreamedResponse
 
@@ -342,7 +340,6 @@ class AsyncRaccoonAI(AsyncAPIClient):
         self.lam = lam.AsyncLamResource(self)
         self.tail = tail.AsyncTailResource(self)
         self.fleet = fleet.AsyncFleetResource(self)
-        self.extensions = extensions.AsyncExtensionsResource(self)
         self.with_raw_response = AsyncRaccoonAIWithRawResponse(self)
         self.with_streaming_response = AsyncRaccoonAIWithStreamedResponse(self)
 
@@ -458,7 +455,6 @@ class RaccoonAIWithRawResponse:
         self.lam = lam.LamResourceWithRawResponse(client.lam)
         self.tail = tail.TailResourceWithRawResponse(client.tail)
         self.fleet = fleet.FleetResourceWithRawResponse(client.fleet)
-        self.extensions = extensions.ExtensionsResourceWithRawResponse(client.extensions)
 
 
 class AsyncRaccoonAIWithRawResponse:
@@ -466,7 +462,6 @@ class AsyncRaccoonAIWithRawResponse:
         self.lam = lam.AsyncLamResourceWithRawResponse(client.lam)
         self.tail = tail.AsyncTailResourceWithRawResponse(client.tail)
         self.fleet = fleet.AsyncFleetResourceWithRawResponse(client.fleet)
-        self.extensions = extensions.AsyncExtensionsResourceWithRawResponse(client.extensions)
 
 
 class RaccoonAIWithStreamedResponse:
@@ -474,7 +469,6 @@ class RaccoonAIWithStreamedResponse:
         self.lam = lam.LamResourceWithStreamingResponse(client.lam)
         self.tail = tail.TailResourceWithStreamingResponse(client.tail)
         self.fleet = fleet.FleetResourceWithStreamingResponse(client.fleet)
-        self.extensions = extensions.ExtensionsResourceWithStreamingResponse(client.extensions)
 
 
 class AsyncRaccoonAIWithStreamedResponse:
@@ -482,7 +476,6 @@ class AsyncRaccoonAIWithStreamedResponse:
         self.lam = lam.AsyncLamResourceWithStreamingResponse(client.lam)
         self.tail = tail.AsyncTailResourceWithStreamingResponse(client.tail)
         self.fleet = fleet.AsyncFleetResourceWithStreamingResponse(client.fleet)
-        self.extensions = extensions.AsyncExtensionsResourceWithStreamingResponse(client.extensions)
 
 
 Client = RaccoonAI

raccoonai/_version.py

@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "raccoonai"
-__version__ = "0.1.0-alpha.8"  # x-release-please-version
+__version__ = "0.1.0-alpha.10"  # x-release-please-version

raccoonai/resources/__init__.py

@@ -24,14 +24,6 @@ from .fleet import (
     FleetResourceWithStreamingResponse,
     AsyncFleetResourceWithStreamingResponse,
 )
-from .extensions import (
-    ExtensionsResource,
-    AsyncExtensionsResource,
-    ExtensionsResourceWithRawResponse,
-    AsyncExtensionsResourceWithRawResponse,
-    ExtensionsResourceWithStreamingResponse,
-    AsyncExtensionsResourceWithStreamingResponse,
-)
 
 __all__ = [
     "LamResource",
@@ -52,10 +44,4 @@ __all__ = [
     "AsyncFleetResourceWithRawResponse",
     "FleetResourceWithStreamingResponse",
     "AsyncFleetResourceWithStreamingResponse",
-    "ExtensionsResource",
-    "AsyncExtensionsResource",
-    "ExtensionsResourceWithRawResponse",
-    "AsyncExtensionsResourceWithRawResponse",
-    "ExtensionsResourceWithStreamingResponse",
-    "AsyncExtensionsResourceWithStreamingResponse",
 ]

raccoonai/resources/fleet/__init__.py

@@ -0,0 +1,47 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .fleet import (
+    FleetResource,
+    AsyncFleetResource,
+    FleetResourceWithRawResponse,
+    AsyncFleetResourceWithRawResponse,
+    FleetResourceWithStreamingResponse,
+    AsyncFleetResourceWithStreamingResponse,
+)
+from .sessions import (
+    SessionsResource,
+    AsyncSessionsResource,
+    SessionsResourceWithRawResponse,
+    AsyncSessionsResourceWithRawResponse,
+    SessionsResourceWithStreamingResponse,
+    AsyncSessionsResourceWithStreamingResponse,
+)
+from .extensions import (
+    ExtensionsResource,
+    AsyncExtensionsResource,
+    ExtensionsResourceWithRawResponse,
+    AsyncExtensionsResourceWithRawResponse,
+    ExtensionsResourceWithStreamingResponse,
+    AsyncExtensionsResourceWithStreamingResponse,
+)
+
+__all__ = [
+    "SessionsResource",
+    "AsyncSessionsResource",
+    "SessionsResourceWithRawResponse",
+    "AsyncSessionsResourceWithRawResponse",
+    "SessionsResourceWithStreamingResponse",
+    "AsyncSessionsResourceWithStreamingResponse",
+    "ExtensionsResource",
+    "AsyncExtensionsResource",
+    "ExtensionsResourceWithRawResponse",
+    "AsyncExtensionsResourceWithRawResponse",
+    "ExtensionsResourceWithStreamingResponse",
+    "AsyncExtensionsResourceWithStreamingResponse",
+    "FleetResource",
+    "AsyncFleetResource",
+    "FleetResourceWithRawResponse",
+    "AsyncFleetResourceWithRawResponse",
+    "FleetResourceWithStreamingResponse",
+    "AsyncFleetResourceWithStreamingResponse",
+]

raccoonai/resources/{extensions.py → fleet/extensions.py}

@@ -6,26 +6,26 @@ from typing import Mapping, cast
 
 import httpx
 
-from ..types import extension_upload_params
-from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven, FileTypes
-from .._utils import (
+from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven, FileTypes
+from ..._utils import (
     extract_files,
     maybe_transform,
     deepcopy_minimal,
     async_maybe_transform,
 )
-from .._compat import cached_property
-from .._resource import SyncAPIResource, AsyncAPIResource
-from .._response import (
+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.extension_all_response import ExtensionAllResponse
-from ..types.extension_get_response import ExtensionGetResponse
-from ..types.extension_upload_response import ExtensionUploadResponse
+from ...types.fleet import extension_upload_params
+from ..._base_client import make_request_options
+from ...types.fleet.extension_all_response import ExtensionAllResponse
+from ...types.fleet.extension_get_response import ExtensionGetResponse
+from ...types.fleet.extension_upload_response import ExtensionUploadResponse
 
 __all__ = ["ExtensionsResource", "AsyncExtensionsResource"]
 

raccoonai/resources/fleet/fleet.py

@@ -0,0 +1,134 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .sessions import (
+    SessionsResource,
+    AsyncSessionsResource,
+    SessionsResourceWithRawResponse,
+    AsyncSessionsResourceWithRawResponse,
+    SessionsResourceWithStreamingResponse,
+    AsyncSessionsResourceWithStreamingResponse,
+)
+from ..._compat import cached_property
+from .extensions import (
+    ExtensionsResource,
+    AsyncExtensionsResource,
+    ExtensionsResourceWithRawResponse,
+    AsyncExtensionsResourceWithRawResponse,
+    ExtensionsResourceWithStreamingResponse,
+    AsyncExtensionsResourceWithStreamingResponse,
+)
+from ..._resource import SyncAPIResource, AsyncAPIResource
+
+__all__ = ["FleetResource", "AsyncFleetResource"]
+
+
+class FleetResource(SyncAPIResource):
+    @cached_property
+    def sessions(self) -> SessionsResource:
+        return SessionsResource(self._client)
+
+    @cached_property
+    def extensions(self) -> ExtensionsResource:
+        return ExtensionsResource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> FleetResourceWithRawResponse:
+        """
+        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/raccoonaihq/raccoonai-python#accessing-raw-response-data-eg-headers
+        """
+        return FleetResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> FleetResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/raccoonaihq/raccoonai-python#with_streaming_response
+        """
+        return FleetResourceWithStreamingResponse(self)
+
+
+class AsyncFleetResource(AsyncAPIResource):
+    @cached_property
+    def sessions(self) -> AsyncSessionsResource:
+        return AsyncSessionsResource(self._client)
+
+    @cached_property
+    def extensions(self) -> AsyncExtensionsResource:
+        return AsyncExtensionsResource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> AsyncFleetResourceWithRawResponse:
+        """
+        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/raccoonaihq/raccoonai-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncFleetResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncFleetResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/raccoonaihq/raccoonai-python#with_streaming_response
+        """
+        return AsyncFleetResourceWithStreamingResponse(self)
+
+
+class FleetResourceWithRawResponse:
+    def __init__(self, fleet: FleetResource) -> None:
+        self._fleet = fleet
+
+    @cached_property
+    def sessions(self) -> SessionsResourceWithRawResponse:
+        return SessionsResourceWithRawResponse(self._fleet.sessions)
+
+    @cached_property
+    def extensions(self) -> ExtensionsResourceWithRawResponse:
+        return ExtensionsResourceWithRawResponse(self._fleet.extensions)
+
+
+class AsyncFleetResourceWithRawResponse:
+    def __init__(self, fleet: AsyncFleetResource) -> None:
+        self._fleet = fleet
+
+    @cached_property
+    def sessions(self) -> AsyncSessionsResourceWithRawResponse:
+        return AsyncSessionsResourceWithRawResponse(self._fleet.sessions)
+
+    @cached_property
+    def extensions(self) -> AsyncExtensionsResourceWithRawResponse:
+        return AsyncExtensionsResourceWithRawResponse(self._fleet.extensions)
+
+
+class FleetResourceWithStreamingResponse:
+    def __init__(self, fleet: FleetResource) -> None:
+        self._fleet = fleet
+
+    @cached_property
+    def sessions(self) -> SessionsResourceWithStreamingResponse:
+        return SessionsResourceWithStreamingResponse(self._fleet.sessions)
+
+    @cached_property
+    def extensions(self) -> ExtensionsResourceWithStreamingResponse:
+        return ExtensionsResourceWithStreamingResponse(self._fleet.extensions)
+
+
+class AsyncFleetResourceWithStreamingResponse:
+    def __init__(self, fleet: AsyncFleetResource) -> None:
+        self._fleet = fleet
+
+    @cached_property
+    def sessions(self) -> AsyncSessionsResourceWithStreamingResponse:
+        return AsyncSessionsResourceWithStreamingResponse(self._fleet.sessions)
+
+    @cached_property
+    def extensions(self) -> AsyncExtensionsResourceWithStreamingResponse:
+        return AsyncExtensionsResourceWithStreamingResponse(self._fleet.extensions)