gcore 0.3.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

gcore/__init__.py

@@ -26,7 +26,7 @@ from ._exceptions import (
     UnprocessableEntityError,
     APIResponseValidationError,
 )
-from ._base_client import DefaultHttpxClient, DefaultAsyncHttpxClient
+from ._base_client import DefaultHttpxClient, DefaultAioHttpClient, DefaultAsyncHttpxClient
 from ._utils._logs import setup_logging as _setup_logging
 
 __all__ = [
@@ -68,6 +68,7 @@ __all__ = [
     "DEFAULT_CONNECTION_LIMITS",
     "DefaultHttpxClient",
     "DefaultAsyncHttpxClient",
+    "DefaultAioHttpClient",
 ]
 
 if not _t.TYPE_CHECKING:

gcore/_base_client.py

@@ -529,6 +529,15 @@ class BaseClient(Generic[_HttpxClientT, _DefaultStreamT]):
             # work around https://github.com/encode/httpx/discussions/2880
             kwargs["extensions"] = {"sni_hostname": prepared_url.host.replace("_", "-")}
 
+        is_body_allowed = options.method.lower() != "get"
+
+        if is_body_allowed:
+            kwargs["json"] = json_data if is_given(json_data) else None
+            kwargs["files"] = files
+        else:
+            headers.pop("Content-Type", None)
+            kwargs.pop("data", None)
+
         # TODO: report this error to httpx
         return self._client.build_request(  # pyright: ignore[reportUnknownMemberType]
             headers=headers,
@@ -540,8 +549,6 @@ class BaseClient(Generic[_HttpxClientT, _DefaultStreamT]):
             # so that passing a `TypedDict` doesn't cause an error.
             # https://github.com/microsoft/pyright/issues/3526#event-6715453066
             params=self.qs.stringify(cast(Mapping[str, Any], params)) if params else None,
-            json=json_data if is_given(json_data) else None,
-            files=files,
             **kwargs,
         )
 
@@ -1289,6 +1296,24 @@ class _DefaultAsyncHttpxClient(httpx.AsyncClient):
         super().__init__(**kwargs)
 
 
+try:
+    import httpx_aiohttp
+except ImportError:
+
+    class _DefaultAioHttpClient(httpx.AsyncClient):
+        def __init__(self, **_kwargs: Any) -> None:
+            raise RuntimeError("To use the aiohttp client you must have installed the package with the `aiohttp` extra")
+else:
+
+    class _DefaultAioHttpClient(httpx_aiohttp.HttpxAiohttpClient):  # type: ignore
+        def __init__(self, **kwargs: Any) -> None:
+            kwargs.setdefault("timeout", DEFAULT_TIMEOUT)
+            kwargs.setdefault("limits", DEFAULT_CONNECTION_LIMITS)
+            kwargs.setdefault("follow_redirects", True)
+
+            super().__init__(**kwargs)
+
+
 if TYPE_CHECKING:
     DefaultAsyncHttpxClient = httpx.AsyncClient
     """An alias to `httpx.AsyncClient` that provides the same defaults that this SDK
@@ -1297,8 +1322,12 @@ if TYPE_CHECKING:
     This is useful because overriding the `http_client` with your own instance of
     `httpx.AsyncClient` will result in httpx's defaults being used, not ours.
     """
+
+    DefaultAioHttpClient = httpx.AsyncClient
+    """An alias to `httpx.AsyncClient` that changes the default HTTP transport to `aiohttp`."""
 else:
     DefaultAsyncHttpxClient = _DefaultAsyncHttpxClient
+    DefaultAioHttpClient = _DefaultAioHttpClient
 
 
 class AsyncHttpxClientWrapper(DefaultAsyncHttpxClient):

gcore/_client.py

@@ -28,8 +28,10 @@ from ._base_client import (
     SyncAPIClient,
     AsyncAPIClient,
 )
+from .resources.iam import iam
 from .resources.waap import waap
 from .resources.cloud import cloud
+from .resources.fastedge import fastedge
 
 __all__ = ["Timeout", "Transport", "ProxiesTypes", "RequestOptions", "Gcore", "AsyncGcore", "Client", "AsyncClient"]
 
@@ -37,6 +39,8 @@ __all__ = ["Timeout", "Transport", "ProxiesTypes", "RequestOptions", "Gcore", "A
 class Gcore(SyncAPIClient):
     cloud: cloud.CloudResource
     waap: waap.WaapResource
+    iam: iam.IamResource
+    fastedge: fastedge.FastedgeResource
     with_raw_response: GcoreWithRawResponse
     with_streaming_response: GcoreWithStreamedResponse
 
@@ -117,6 +121,8 @@ class Gcore(SyncAPIClient):
 
         self.cloud = cloud.CloudResource(self)
         self.waap = waap.WaapResource(self)
+        self.iam = iam.IamResource(self)
+        self.fastedge = fastedge.FastedgeResource(self)
         self.with_raw_response = GcoreWithRawResponse(self)
         self.with_streaming_response = GcoreWithStreamedResponse(self)
 
@@ -252,6 +258,8 @@ class Gcore(SyncAPIClient):
 class AsyncGcore(AsyncAPIClient):
     cloud: cloud.AsyncCloudResource
     waap: waap.AsyncWaapResource
+    iam: iam.AsyncIamResource
+    fastedge: fastedge.AsyncFastedgeResource
     with_raw_response: AsyncGcoreWithRawResponse
     with_streaming_response: AsyncGcoreWithStreamedResponse
 
@@ -332,6 +340,8 @@ class AsyncGcore(AsyncAPIClient):
 
         self.cloud = cloud.AsyncCloudResource(self)
         self.waap = waap.AsyncWaapResource(self)
+        self.iam = iam.AsyncIamResource(self)
+        self.fastedge = fastedge.AsyncFastedgeResource(self)
         self.with_raw_response = AsyncGcoreWithRawResponse(self)
         self.with_streaming_response = AsyncGcoreWithStreamedResponse(self)
 
@@ -468,24 +478,32 @@ class GcoreWithRawResponse:
     def __init__(self, client: Gcore) -> None:
         self.cloud = cloud.CloudResourceWithRawResponse(client.cloud)
         self.waap = waap.WaapResourceWithRawResponse(client.waap)
+        self.iam = iam.IamResourceWithRawResponse(client.iam)
+        self.fastedge = fastedge.FastedgeResourceWithRawResponse(client.fastedge)
 
 
 class AsyncGcoreWithRawResponse:
     def __init__(self, client: AsyncGcore) -> None:
         self.cloud = cloud.AsyncCloudResourceWithRawResponse(client.cloud)
         self.waap = waap.AsyncWaapResourceWithRawResponse(client.waap)
+        self.iam = iam.AsyncIamResourceWithRawResponse(client.iam)
+        self.fastedge = fastedge.AsyncFastedgeResourceWithRawResponse(client.fastedge)
 
 
 class GcoreWithStreamedResponse:
     def __init__(self, client: Gcore) -> None:
         self.cloud = cloud.CloudResourceWithStreamingResponse(client.cloud)
         self.waap = waap.WaapResourceWithStreamingResponse(client.waap)
+        self.iam = iam.IamResourceWithStreamingResponse(client.iam)
+        self.fastedge = fastedge.FastedgeResourceWithStreamingResponse(client.fastedge)
 
 
 class AsyncGcoreWithStreamedResponse:
     def __init__(self, client: AsyncGcore) -> None:
         self.cloud = cloud.AsyncCloudResourceWithStreamingResponse(client.cloud)
         self.waap = waap.AsyncWaapResourceWithStreamingResponse(client.waap)
+        self.iam = iam.AsyncIamResourceWithStreamingResponse(client.iam)
+        self.fastedge = fastedge.AsyncFastedgeResourceWithStreamingResponse(client.fastedge)
 
 
 Client = Gcore

gcore/_constants.py

@@ -5,8 +5,8 @@ import httpx
 RAW_RESPONSE_HEADER = "X-Stainless-Raw-Response"
 OVERRIDE_CAST_TO_HEADER = "____stainless_override_cast_to"
 
-# default timeout is 1 minute
-DEFAULT_TIMEOUT = httpx.Timeout(timeout=60, connect=5.0)
+# default timeout is 2 minutes
+DEFAULT_TIMEOUT = httpx.Timeout(timeout=120, connect=5.0)
 DEFAULT_MAX_RETRIES = 2
 DEFAULT_CONNECTION_LIMITS = httpx.Limits(max_connections=100, max_keepalive_connections=20)
 

gcore/_models.py

@@ -2,9 +2,10 @@ from __future__ import annotations
 
 import os
 import inspect
-from typing import TYPE_CHECKING, Any, Type, Union, Generic, TypeVar, Callable, cast
+from typing import TYPE_CHECKING, Any, Type, Union, Generic, TypeVar, Callable, Optional, cast
 from datetime import date, datetime
 from typing_extensions import (
+    List,
     Unpack,
     Literal,
     ClassVar,
@@ -366,7 +367,7 @@ def _construct_field(value: object, field: FieldInfo, key: str) -> object:
     if type_ is None:
         raise RuntimeError(f"Unexpected field type is None for {key}")
 
-    return construct_type(value=value, type_=type_)
+    return construct_type(value=value, type_=type_, metadata=getattr(field, "metadata", None))
 
 
 def is_basemodel(type_: type) -> bool:
@@ -420,7 +421,7 @@ def construct_type_unchecked(*, value: object, type_: type[_T]) -> _T:
     return cast(_T, construct_type(value=value, type_=type_))
 
 
-def construct_type(*, value: object, type_: object) -> object:
+def construct_type(*, value: object, type_: object, metadata: Optional[List[Any]] = None) -> object:
     """Loose coercion to the expected type with construction of nested values.
 
     If the given value does not match the expected type then it is returned as-is.
@@ -438,8 +439,10 @@ def construct_type(*, value: object, type_: object) -> object:
         type_ = type_.__value__  # type: ignore[unreachable]
 
     # unwrap `Annotated[T, ...]` -> `T`
-    if is_annotated_type(type_):
-        meta: tuple[Any, ...] = get_args(type_)[1:]
+    if metadata is not None:
+        meta: tuple[Any, ...] = tuple(metadata)
+    elif is_annotated_type(type_):
+        meta = get_args(type_)[1:]
         type_ = extract_type_arg(type_, 0)
     else:
         meta = tuple()

gcore/_version.py

@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "gcore"
-__version__ = "0.3.0"  # x-release-please-version
+__version__ = "0.5.0"  # x-release-please-version

gcore/pagination.py

@@ -5,7 +5,18 @@ from typing_extensions import override
 
 from ._base_client import BasePage, PageInfo, BaseSyncPage, BaseAsyncPage
 
-__all__ = ["SyncOffsetPage", "AsyncOffsetPage"]
+__all__ = [
+    "SyncOffsetPage",
+    "AsyncOffsetPage",
+    "SyncOffsetPageIam",
+    "AsyncOffsetPageIam",
+    "SyncOffsetPageFastedgeApps",
+    "AsyncOffsetPageFastedgeApps",
+    "SyncOffsetPageFastedgeTemplates",
+    "AsyncOffsetPageFastedgeTemplates",
+    "SyncOffsetPageFastedgeAppLogs",
+    "AsyncOffsetPageFastedgeAppLogs",
+]
 
 _T = TypeVar("_T")
 
@@ -68,3 +79,243 @@ class AsyncOffsetPage(BaseAsyncPage[_T], BasePage[_T], Generic[_T]):
             return PageInfo(params={"offset": current_count})
 
         return None
+
+
+class SyncOffsetPageIam(BaseSyncPage[_T], BasePage[_T], Generic[_T]):
+    result: List[_T]
+    count: Optional[int] = None
+
+    @override
+    def _get_page_items(self) -> List[_T]:
+        result = self.result
+        if not result:
+            return []
+        return result
+
+    @override
+    def next_page_info(self) -> Optional[PageInfo]:
+        offset = self._options.params.get("offset") or 0
+        if not isinstance(offset, int):
+            raise ValueError(f'Expected "offset" param to be an integer but got {offset}')
+
+        length = len(self._get_page_items())
+        current_count = offset + length
+
+        count = self.count
+        if count is None:
+            return None
+
+        if current_count < count:
+            return PageInfo(params={"offset": current_count})
+
+        return None
+
+
+class AsyncOffsetPageIam(BaseAsyncPage[_T], BasePage[_T], Generic[_T]):
+    result: List[_T]
+    count: Optional[int] = None
+
+    @override
+    def _get_page_items(self) -> List[_T]:
+        result = self.result
+        if not result:
+            return []
+        return result
+
+    @override
+    def next_page_info(self) -> Optional[PageInfo]:
+        offset = self._options.params.get("offset") or 0
+        if not isinstance(offset, int):
+            raise ValueError(f'Expected "offset" param to be an integer but got {offset}')
+
+        length = len(self._get_page_items())
+        current_count = offset + length
+
+        count = self.count
+        if count is None:
+            return None
+
+        if current_count < count:
+            return PageInfo(params={"offset": current_count})
+
+        return None
+
+
+class SyncOffsetPageFastedgeApps(BaseSyncPage[_T], BasePage[_T], Generic[_T]):
+    apps: List[_T]
+    count: Optional[int] = None
+
+    @override
+    def _get_page_items(self) -> List[_T]:
+        apps = self.apps
+        if not apps:
+            return []
+        return apps
+
+    @override
+    def next_page_info(self) -> Optional[PageInfo]:
+        offset = self._options.params.get("offset") or 0
+        if not isinstance(offset, int):
+            raise ValueError(f'Expected "offset" param to be an integer but got {offset}')
+
+        length = len(self._get_page_items())
+        current_count = offset + length
+
+        count = self.count
+        if count is None:
+            return None
+
+        if current_count < count:
+            return PageInfo(params={"offset": current_count})
+
+        return None
+
+
+class AsyncOffsetPageFastedgeApps(BaseAsyncPage[_T], BasePage[_T], Generic[_T]):
+    apps: List[_T]
+    count: Optional[int] = None
+
+    @override
+    def _get_page_items(self) -> List[_T]:
+        apps = self.apps
+        if not apps:
+            return []
+        return apps
+
+    @override
+    def next_page_info(self) -> Optional[PageInfo]:
+        offset = self._options.params.get("offset") or 0
+        if not isinstance(offset, int):
+            raise ValueError(f'Expected "offset" param to be an integer but got {offset}')
+
+        length = len(self._get_page_items())
+        current_count = offset + length
+
+        count = self.count
+        if count is None:
+            return None
+
+        if current_count < count:
+            return PageInfo(params={"offset": current_count})
+
+        return None
+
+
+class SyncOffsetPageFastedgeTemplates(BaseSyncPage[_T], BasePage[_T], Generic[_T]):
+    templates: List[_T]
+    count: Optional[int] = None
+
+    @override
+    def _get_page_items(self) -> List[_T]:
+        templates = self.templates
+        if not templates:
+            return []
+        return templates
+
+    @override
+    def next_page_info(self) -> Optional[PageInfo]:
+        offset = self._options.params.get("offset") or 0
+        if not isinstance(offset, int):
+            raise ValueError(f'Expected "offset" param to be an integer but got {offset}')
+
+        length = len(self._get_page_items())
+        current_count = offset + length
+
+        count = self.count
+        if count is None:
+            return None
+
+        if current_count < count:
+            return PageInfo(params={"offset": current_count})
+
+        return None
+
+
+class AsyncOffsetPageFastedgeTemplates(BaseAsyncPage[_T], BasePage[_T], Generic[_T]):
+    templates: List[_T]
+    count: Optional[int] = None
+
+    @override
+    def _get_page_items(self) -> List[_T]:
+        templates = self.templates
+        if not templates:
+            return []
+        return templates
+
+    @override
+    def next_page_info(self) -> Optional[PageInfo]:
+        offset = self._options.params.get("offset") or 0
+        if not isinstance(offset, int):
+            raise ValueError(f'Expected "offset" param to be an integer but got {offset}')
+
+        length = len(self._get_page_items())
+        current_count = offset + length
+
+        count = self.count
+        if count is None:
+            return None
+
+        if current_count < count:
+            return PageInfo(params={"offset": current_count})
+
+        return None
+
+
+class SyncOffsetPageFastedgeAppLogs(BaseSyncPage[_T], BasePage[_T], Generic[_T]):
+    logs: List[_T]
+    total_count: Optional[int] = None
+
+    @override
+    def _get_page_items(self) -> List[_T]:
+        logs = self.logs
+        if not logs:
+            return []
+        return logs
+
+    @override
+    def next_page_info(self) -> Optional[PageInfo]:
+        offset = self._options.params.get("offset") or 0
+        if not isinstance(offset, int):
+            raise ValueError(f'Expected "offset" param to be an integer but got {offset}')
+
+        length = len(self._get_page_items())
+        current_count = offset + length
+
+        total_count = self.total_count
+        if total_count is None:
+            return None
+
+        if current_count < total_count:
+            return PageInfo(params={"offset": current_count})
+
+        return None
+
+
+class AsyncOffsetPageFastedgeAppLogs(BaseAsyncPage[_T], BasePage[_T], Generic[_T]):
+    logs: List[_T]
+    total_count: Optional[int] = None
+
+    @override
+    def _get_page_items(self) -> List[_T]:
+        logs = self.logs
+        if not logs:
+            return []
+        return logs
+
+    @override
+    def next_page_info(self) -> Optional[PageInfo]:
+        offset = self._options.params.get("offset") or 0
+        if not isinstance(offset, int):
+            raise ValueError(f'Expected "offset" param to be an integer but got {offset}')
+
+        length = len(self._get_page_items())
+        current_count = offset + length
+
+        total_count = self.total_count
+        if total_count is None:
+            return None
+
+        if current_count < total_count:
+            return PageInfo(params={"offset": current_count})
+
+        return None

gcore/resources/__init__.py

@@ -1,5 +1,13 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
+from .iam import (
+    IamResource,
+    AsyncIamResource,
+    IamResourceWithRawResponse,
+    AsyncIamResourceWithRawResponse,
+    IamResourceWithStreamingResponse,
+    AsyncIamResourceWithStreamingResponse,
+)
 from .waap import (
     WaapResource,
     AsyncWaapResource,
@@ -16,6 +24,14 @@ from .cloud import (
     CloudResourceWithStreamingResponse,
     AsyncCloudResourceWithStreamingResponse,
 )
+from .fastedge import (
+    FastedgeResource,
+    AsyncFastedgeResource,
+    FastedgeResourceWithRawResponse,
+    AsyncFastedgeResourceWithRawResponse,
+    FastedgeResourceWithStreamingResponse,
+    AsyncFastedgeResourceWithStreamingResponse,
+)
 
 __all__ = [
     "CloudResource",
@@ -30,4 +46,16 @@ __all__ = [
     "AsyncWaapResourceWithRawResponse",
     "WaapResourceWithStreamingResponse",
     "AsyncWaapResourceWithStreamingResponse",
+    "IamResource",
+    "AsyncIamResource",
+    "IamResourceWithRawResponse",
+    "AsyncIamResourceWithRawResponse",
+    "IamResourceWithStreamingResponse",
+    "AsyncIamResourceWithStreamingResponse",
+    "FastedgeResource",
+    "AsyncFastedgeResource",
+    "FastedgeResourceWithRawResponse",
+    "AsyncFastedgeResourceWithRawResponse",
+    "FastedgeResourceWithStreamingResponse",
+    "AsyncFastedgeResourceWithStreamingResponse",
 ]