gcore 0.9.0__py3-none-any.whl → 0.11.0__py3-none-any.whl

gcore/resources/{cloud/inference/models.py → dns/zones/dnssec.py}

@@ -2,12 +2,10 @@
 
 from __future__ import annotations
 
-from typing_extensions import Literal
-
 import httpx
 
 from ...._types import NOT_GIVEN, Body, Query, Headers, NotGiven
-from ...._utils import maybe_transform
+from ...._utils import maybe_transform, async_maybe_transform
 from ...._compat import cached_property
 from ...._resource import SyncAPIResource, AsyncAPIResource
 from ...._response import (
@@ -16,59 +14,50 @@ from ...._response import (
     async_to_raw_response_wrapper,
     async_to_streamed_response_wrapper,
 )
-from ....pagination import SyncOffsetPage, AsyncOffsetPage
-from ...._base_client import AsyncPaginator, make_request_options
-from ....types.cloud.inference import model_list_params
-from ....types.cloud.inference.inference_model import InferenceModel
+from ...._base_client import make_request_options
+from ....types.dns.zones import dnssec_update_params
+from ....types.dns.zones.dnssec_get_response import DnssecGetResponse
+from ....types.dns.zones.dnssec_update_response import DnssecUpdateResponse
 
-__all__ = ["ModelsResource", "AsyncModelsResource"]
+__all__ = ["DnssecResource", "AsyncDnssecResource"]
 
 
-class ModelsResource(SyncAPIResource):
+class DnssecResource(SyncAPIResource):
     @cached_property
-    def with_raw_response(self) -> ModelsResourceWithRawResponse:
+    def with_raw_response(self) -> DnssecResourceWithRawResponse:
         """
         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/G-Core/gcore-python#accessing-raw-response-data-eg-headers
         """
-        return ModelsResourceWithRawResponse(self)
+        return DnssecResourceWithRawResponse(self)
 
     @cached_property
-    def with_streaming_response(self) -> ModelsResourceWithStreamingResponse:
+    def with_streaming_response(self) -> DnssecResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
         For more information, see https://www.github.com/G-Core/gcore-python#with_streaming_response
         """
-        return ModelsResourceWithStreamingResponse(self)
+        return DnssecResourceWithStreamingResponse(self)
 
-    def list(
+    def update(
         self,
+        name: str,
         *,
-        limit: int | NotGiven = NOT_GIVEN,
-        offset: int | NotGiven = NOT_GIVEN,
-        order_by: Literal["name.asc", "name.desc"] | NotGiven = NOT_GIVEN,
+        enabled: bool | NotGiven = NOT_GIVEN,
         # 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,
-    ) -> SyncOffsetPage[InferenceModel]:
-        """List models from catalog
+    ) -> DnssecUpdateResponse:
+        """
+        Enable or disable DNSSEC for a DNS zone.
 
         Args:
-          limit: Optional.
-
-        Limit the number of returned items
-
-          offset: Optional. Offset value is used to exclude the first set of records from the
-              result
-
-          order_by: Order instances by transmitted fields and directions
-
           extra_headers: Send extra headers
 
           extra_query: Add additional query parameters to the request
@@ -77,29 +66,20 @@ class ModelsResource(SyncAPIResource):
 
           timeout: Override the client-level default timeout for this request, in seconds
         """
-        return self._get_api_list(
-            "/cloud/v3/inference/models",
-            page=SyncOffsetPage[InferenceModel],
+        if not name:
+            raise ValueError(f"Expected a non-empty value for `name` but received {name!r}")
+        return self._patch(
+            f"/dns/v2/zones/{name}/dnssec",
+            body=maybe_transform({"enabled": enabled}, dnssec_update_params.DnssecUpdateParams),
             options=make_request_options(
-                extra_headers=extra_headers,
-                extra_query=extra_query,
-                extra_body=extra_body,
-                timeout=timeout,
-                query=maybe_transform(
-                    {
-                        "limit": limit,
-                        "offset": offset,
-                        "order_by": order_by,
-                    },
-                    model_list_params.ModelListParams,
-                ),
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
-            model=InferenceModel,
+            cast_to=DnssecUpdateResponse,
         )
 
     def get(
         self,
-        model_id: str,
+        name: 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.
@@ -107,13 +87,11 @@ class ModelsResource(SyncAPIResource):
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> InferenceModel:
+    ) -> DnssecGetResponse:
         """
-        Get model from catalog
+        Get DNSSEC DS for a DNS zone.
 
         Args:
-          model_id: Model ID
-
           extra_headers: Send extra headers
 
           extra_query: Add additional query parameters to the request
@@ -122,62 +100,53 @@ class ModelsResource(SyncAPIResource):
 
           timeout: Override the client-level default timeout for this request, in seconds
         """
-        if not model_id:
-            raise ValueError(f"Expected a non-empty value for `model_id` but received {model_id!r}")
+        if not name:
+            raise ValueError(f"Expected a non-empty value for `name` but received {name!r}")
         return self._get(
-            f"/cloud/v3/inference/models/{model_id}",
+            f"/dns/v2/zones/{name}/dnssec",
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
-            cast_to=InferenceModel,
+            cast_to=DnssecGetResponse,
         )
 
 
-class AsyncModelsResource(AsyncAPIResource):
+class AsyncDnssecResource(AsyncAPIResource):
     @cached_property
-    def with_raw_response(self) -> AsyncModelsResourceWithRawResponse:
+    def with_raw_response(self) -> AsyncDnssecResourceWithRawResponse:
         """
         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/G-Core/gcore-python#accessing-raw-response-data-eg-headers
         """
-        return AsyncModelsResourceWithRawResponse(self)
+        return AsyncDnssecResourceWithRawResponse(self)
 
     @cached_property
-    def with_streaming_response(self) -> AsyncModelsResourceWithStreamingResponse:
+    def with_streaming_response(self) -> AsyncDnssecResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
         For more information, see https://www.github.com/G-Core/gcore-python#with_streaming_response
         """
-        return AsyncModelsResourceWithStreamingResponse(self)
+        return AsyncDnssecResourceWithStreamingResponse(self)
 
-    def list(
+    async def update(
         self,
+        name: str,
         *,
-        limit: int | NotGiven = NOT_GIVEN,
-        offset: int | NotGiven = NOT_GIVEN,
-        order_by: Literal["name.asc", "name.desc"] | NotGiven = NOT_GIVEN,
+        enabled: bool | NotGiven = NOT_GIVEN,
         # 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,
-    ) -> AsyncPaginator[InferenceModel, AsyncOffsetPage[InferenceModel]]:
-        """List models from catalog
+    ) -> DnssecUpdateResponse:
+        """
+        Enable or disable DNSSEC for a DNS zone.
 
         Args:
-          limit: Optional.
-
-        Limit the number of returned items
-
-          offset: Optional. Offset value is used to exclude the first set of records from the
-              result
-
-          order_by: Order instances by transmitted fields and directions
-
           extra_headers: Send extra headers
 
           extra_query: Add additional query parameters to the request
@@ -186,29 +155,20 @@ class AsyncModelsResource(AsyncAPIResource):
 
           timeout: Override the client-level default timeout for this request, in seconds
         """
-        return self._get_api_list(
-            "/cloud/v3/inference/models",
-            page=AsyncOffsetPage[InferenceModel],
+        if not name:
+            raise ValueError(f"Expected a non-empty value for `name` but received {name!r}")
+        return await self._patch(
+            f"/dns/v2/zones/{name}/dnssec",
+            body=await async_maybe_transform({"enabled": enabled}, dnssec_update_params.DnssecUpdateParams),
             options=make_request_options(
-                extra_headers=extra_headers,
-                extra_query=extra_query,
-                extra_body=extra_body,
-                timeout=timeout,
-                query=maybe_transform(
-                    {
-                        "limit": limit,
-                        "offset": offset,
-                        "order_by": order_by,
-                    },
-                    model_list_params.ModelListParams,
-                ),
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
-            model=InferenceModel,
+            cast_to=DnssecUpdateResponse,
         )
 
     async def get(
         self,
-        model_id: str,
+        name: 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.
@@ -216,13 +176,11 @@ class AsyncModelsResource(AsyncAPIResource):
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> InferenceModel:
+    ) -> DnssecGetResponse:
         """
-        Get model from catalog
+        Get DNSSEC DS for a DNS zone.
 
         Args:
-          model_id: Model ID
-
           extra_headers: Send extra headers
 
           extra_query: Add additional query parameters to the request
@@ -231,60 +189,60 @@ class AsyncModelsResource(AsyncAPIResource):
 
           timeout: Override the client-level default timeout for this request, in seconds
         """
-        if not model_id:
-            raise ValueError(f"Expected a non-empty value for `model_id` but received {model_id!r}")
+        if not name:
+            raise ValueError(f"Expected a non-empty value for `name` but received {name!r}")
         return await self._get(
-            f"/cloud/v3/inference/models/{model_id}",
+            f"/dns/v2/zones/{name}/dnssec",
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
-            cast_to=InferenceModel,
+            cast_to=DnssecGetResponse,
         )
 
 
-class ModelsResourceWithRawResponse:
-    def __init__(self, models: ModelsResource) -> None:
-        self._models = models
+class DnssecResourceWithRawResponse:
+    def __init__(self, dnssec: DnssecResource) -> None:
+        self._dnssec = dnssec
 
-        self.list = to_raw_response_wrapper(
-            models.list,
+        self.update = to_raw_response_wrapper(
+            dnssec.update,
         )
         self.get = to_raw_response_wrapper(
-            models.get,
+            dnssec.get,
         )
 
 
-class AsyncModelsResourceWithRawResponse:
-    def __init__(self, models: AsyncModelsResource) -> None:
-        self._models = models
+class AsyncDnssecResourceWithRawResponse:
+    def __init__(self, dnssec: AsyncDnssecResource) -> None:
+        self._dnssec = dnssec
 
-        self.list = async_to_raw_response_wrapper(
-            models.list,
+        self.update = async_to_raw_response_wrapper(
+            dnssec.update,
         )
         self.get = async_to_raw_response_wrapper(
-            models.get,
+            dnssec.get,
         )
 
 
-class ModelsResourceWithStreamingResponse:
-    def __init__(self, models: ModelsResource) -> None:
-        self._models = models
+class DnssecResourceWithStreamingResponse:
+    def __init__(self, dnssec: DnssecResource) -> None:
+        self._dnssec = dnssec
 
-        self.list = to_streamed_response_wrapper(
-            models.list,
+        self.update = to_streamed_response_wrapper(
+            dnssec.update,
         )
         self.get = to_streamed_response_wrapper(
-            models.get,
+            dnssec.get,
         )
 
 
-class AsyncModelsResourceWithStreamingResponse:
-    def __init__(self, models: AsyncModelsResource) -> None:
-        self._models = models
+class AsyncDnssecResourceWithStreamingResponse:
+    def __init__(self, dnssec: AsyncDnssecResource) -> None:
+        self._dnssec = dnssec
 
-        self.list = async_to_streamed_response_wrapper(
-            models.list,
+        self.update = async_to_streamed_response_wrapper(
+            dnssec.update,
         )
         self.get = async_to_streamed_response_wrapper(
-            models.get,
+            dnssec.get,
         )