gcore 0.1.0__py3-none-any.whl

gcore/resources/waap/__init__.py

@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .waap import (
+    WaapResource,
+    AsyncWaapResource,
+    WaapResourceWithRawResponse,
+    AsyncWaapResourceWithRawResponse,
+    WaapResourceWithStreamingResponse,
+    AsyncWaapResourceWithStreamingResponse,
+)
+from .domains import (
+    DomainsResource,
+    AsyncDomainsResource,
+    DomainsResourceWithRawResponse,
+    AsyncDomainsResourceWithRawResponse,
+    DomainsResourceWithStreamingResponse,
+    AsyncDomainsResourceWithStreamingResponse,
+)
+
+__all__ = [
+    "DomainsResource",
+    "AsyncDomainsResource",
+    "DomainsResourceWithRawResponse",
+    "AsyncDomainsResourceWithRawResponse",
+    "DomainsResourceWithStreamingResponse",
+    "AsyncDomainsResourceWithStreamingResponse",
+    "WaapResource",
+    "AsyncWaapResource",
+    "WaapResourceWithRawResponse",
+    "AsyncWaapResourceWithRawResponse",
+    "WaapResourceWithStreamingResponse",
+    "AsyncWaapResourceWithStreamingResponse",
+]

gcore/resources/waap/domains/__init__.py

@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .domains import (
+    DomainsResource,
+    AsyncDomainsResource,
+    DomainsResourceWithRawResponse,
+    AsyncDomainsResourceWithRawResponse,
+    DomainsResourceWithStreamingResponse,
+    AsyncDomainsResourceWithStreamingResponse,
+)
+from .settings import (
+    SettingsResource,
+    AsyncSettingsResource,
+    SettingsResourceWithRawResponse,
+    AsyncSettingsResourceWithRawResponse,
+    SettingsResourceWithStreamingResponse,
+    AsyncSettingsResourceWithStreamingResponse,
+)
+
+__all__ = [
+    "SettingsResource",
+    "AsyncSettingsResource",
+    "SettingsResourceWithRawResponse",
+    "AsyncSettingsResourceWithRawResponse",
+    "SettingsResourceWithStreamingResponse",
+    "AsyncSettingsResourceWithStreamingResponse",
+    "DomainsResource",
+    "AsyncDomainsResource",
+    "DomainsResourceWithRawResponse",
+    "AsyncDomainsResourceWithRawResponse",
+    "DomainsResourceWithStreamingResponse",
+    "AsyncDomainsResourceWithStreamingResponse",
+]

gcore/resources/waap/domains/domains.py

@@ -0,0 +1,515 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Iterable
+from typing_extensions import Literal
+
+import httpx
+
+from .settings import (
+    SettingsResource,
+    AsyncSettingsResource,
+    SettingsResourceWithRawResponse,
+    AsyncSettingsResourceWithRawResponse,
+    SettingsResourceWithStreamingResponse,
+    AsyncSettingsResourceWithStreamingResponse,
+)
+from ...._types import NOT_GIVEN, Body, Query, Headers, NoneType, NotGiven
+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 ....pagination import SyncOffsetPage, AsyncOffsetPage
+from ....types.waap import WaapDomainStatus, domain_list_params, domain_update_params
+from ...._base_client import AsyncPaginator, make_request_options
+from ....types.waap.waap_domain_status import WaapDomainStatus
+from ....types.waap.waap_summary_domain import WaapSummaryDomain
+from ....types.waap.waap_detailed_domain import WaapDetailedDomain
+
+__all__ = ["DomainsResource", "AsyncDomainsResource"]
+
+
+class DomainsResource(SyncAPIResource):
+    @cached_property
+    def settings(self) -> SettingsResource:
+        return SettingsResource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> DomainsResourceWithRawResponse:
+        """
+        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 DomainsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> DomainsResourceWithStreamingResponse:
+        """
+        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 DomainsResourceWithStreamingResponse(self)
+
+    def update(
+        self,
+        domain_id: int,
+        *,
+        status: Literal["active", "monitor"] | 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,
+    ) -> None:
+        """
+        Update Domain
+
+        Args:
+          domain_id: The domain ID
+
+          status: Domain statuses that can be used when updating a domain
+
+          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
+        """
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return self._patch(
+            f"/waap/v1/domains/{domain_id}",
+            body=maybe_transform({"status": status}, domain_update_params.DomainUpdateParams),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=NoneType,
+        )
+
+    def list(
+        self,
+        *,
+        ids: Iterable[int] | NotGiven = NOT_GIVEN,
+        limit: int | NotGiven = NOT_GIVEN,
+        name: str | NotGiven = NOT_GIVEN,
+        offset: int | NotGiven = NOT_GIVEN,
+        ordering: Literal["id", "name", "status", "created_at", "-id", "-name", "-status", "-created_at"]
+        | NotGiven = NOT_GIVEN,
+        status: WaapDomainStatus | 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[WaapSummaryDomain]:
+        """
+        Retrieve a list of domains associated with the client
+
+        Args:
+          ids: Filter domains based on their IDs
+
+          limit: Number of items to return
+
+          name: Filter domains based on the domain name. Supports '\\**' as a wildcard character
+
+          offset: Number of items to skip
+
+          ordering: Sort the response by given field.
+
+          status: The different statuses a domain can have
+
+          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_api_list(
+            "/waap/v1/domains",
+            page=SyncOffsetPage[WaapSummaryDomain],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "ids": ids,
+                        "limit": limit,
+                        "name": name,
+                        "offset": offset,
+                        "ordering": ordering,
+                        "status": status,
+                    },
+                    domain_list_params.DomainListParams,
+                ),
+            ),
+            model=WaapSummaryDomain,
+        )
+
+    def delete(
+        self,
+        domain_id: int,
+        *,
+        # 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:
+        """Delete an inactive domain by ID.
+
+        Only domains with status 'bypass' can be
+        deleted.
+
+        Args:
+          domain_id: The domain ID
+
+          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
+        """
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return self._delete(
+            f"/waap/v1/domains/{domain_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=NoneType,
+        )
+
+    def get(
+        self,
+        domain_id: int,
+        *,
+        # 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,
+    ) -> WaapDetailedDomain:
+        """
+        Retrieve detailed information about a specific domain
+
+        Args:
+          domain_id: The domain ID
+
+          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(
+            f"/waap/v1/domains/{domain_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=WaapDetailedDomain,
+        )
+
+
+class AsyncDomainsResource(AsyncAPIResource):
+    @cached_property
+    def settings(self) -> AsyncSettingsResource:
+        return AsyncSettingsResource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> AsyncDomainsResourceWithRawResponse:
+        """
+        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 AsyncDomainsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncDomainsResourceWithStreamingResponse:
+        """
+        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 AsyncDomainsResourceWithStreamingResponse(self)
+
+    async def update(
+        self,
+        domain_id: int,
+        *,
+        status: Literal["active", "monitor"] | 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,
+    ) -> None:
+        """
+        Update Domain
+
+        Args:
+          domain_id: The domain ID
+
+          status: Domain statuses that can be used when updating a domain
+
+          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
+        """
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return await self._patch(
+            f"/waap/v1/domains/{domain_id}",
+            body=await async_maybe_transform({"status": status}, domain_update_params.DomainUpdateParams),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=NoneType,
+        )
+
+    def list(
+        self,
+        *,
+        ids: Iterable[int] | NotGiven = NOT_GIVEN,
+        limit: int | NotGiven = NOT_GIVEN,
+        name: str | NotGiven = NOT_GIVEN,
+        offset: int | NotGiven = NOT_GIVEN,
+        ordering: Literal["id", "name", "status", "created_at", "-id", "-name", "-status", "-created_at"]
+        | NotGiven = NOT_GIVEN,
+        status: WaapDomainStatus | 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[WaapSummaryDomain, AsyncOffsetPage[WaapSummaryDomain]]:
+        """
+        Retrieve a list of domains associated with the client
+
+        Args:
+          ids: Filter domains based on their IDs
+
+          limit: Number of items to return
+
+          name: Filter domains based on the domain name. Supports '\\**' as a wildcard character
+
+          offset: Number of items to skip
+
+          ordering: Sort the response by given field.
+
+          status: The different statuses a domain can have
+
+          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_api_list(
+            "/waap/v1/domains",
+            page=AsyncOffsetPage[WaapSummaryDomain],
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "ids": ids,
+                        "limit": limit,
+                        "name": name,
+                        "offset": offset,
+                        "ordering": ordering,
+                        "status": status,
+                    },
+                    domain_list_params.DomainListParams,
+                ),
+            ),
+            model=WaapSummaryDomain,
+        )
+
+    async def delete(
+        self,
+        domain_id: int,
+        *,
+        # 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:
+        """Delete an inactive domain by ID.
+
+        Only domains with status 'bypass' can be
+        deleted.
+
+        Args:
+          domain_id: The domain ID
+
+          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
+        """
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return await self._delete(
+            f"/waap/v1/domains/{domain_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=NoneType,
+        )
+
+    async def get(
+        self,
+        domain_id: int,
+        *,
+        # 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,
+    ) -> WaapDetailedDomain:
+        """
+        Retrieve detailed information about a specific domain
+
+        Args:
+          domain_id: The domain ID
+
+          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(
+            f"/waap/v1/domains/{domain_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=WaapDetailedDomain,
+        )
+
+
+class DomainsResourceWithRawResponse:
+    def __init__(self, domains: DomainsResource) -> None:
+        self._domains = domains
+
+        self.update = to_raw_response_wrapper(
+            domains.update,
+        )
+        self.list = to_raw_response_wrapper(
+            domains.list,
+        )
+        self.delete = to_raw_response_wrapper(
+            domains.delete,
+        )
+        self.get = to_raw_response_wrapper(
+            domains.get,
+        )
+
+    @cached_property
+    def settings(self) -> SettingsResourceWithRawResponse:
+        return SettingsResourceWithRawResponse(self._domains.settings)
+
+
+class AsyncDomainsResourceWithRawResponse:
+    def __init__(self, domains: AsyncDomainsResource) -> None:
+        self._domains = domains
+
+        self.update = async_to_raw_response_wrapper(
+            domains.update,
+        )
+        self.list = async_to_raw_response_wrapper(
+            domains.list,
+        )
+        self.delete = async_to_raw_response_wrapper(
+            domains.delete,
+        )
+        self.get = async_to_raw_response_wrapper(
+            domains.get,
+        )
+
+    @cached_property
+    def settings(self) -> AsyncSettingsResourceWithRawResponse:
+        return AsyncSettingsResourceWithRawResponse(self._domains.settings)
+
+
+class DomainsResourceWithStreamingResponse:
+    def __init__(self, domains: DomainsResource) -> None:
+        self._domains = domains
+
+        self.update = to_streamed_response_wrapper(
+            domains.update,
+        )
+        self.list = to_streamed_response_wrapper(
+            domains.list,
+        )
+        self.delete = to_streamed_response_wrapper(
+            domains.delete,
+        )
+        self.get = to_streamed_response_wrapper(
+            domains.get,
+        )
+
+    @cached_property
+    def settings(self) -> SettingsResourceWithStreamingResponse:
+        return SettingsResourceWithStreamingResponse(self._domains.settings)
+
+
+class AsyncDomainsResourceWithStreamingResponse:
+    def __init__(self, domains: AsyncDomainsResource) -> None:
+        self._domains = domains
+
+        self.update = async_to_streamed_response_wrapper(
+            domains.update,
+        )
+        self.list = async_to_streamed_response_wrapper(
+            domains.list,
+        )
+        self.delete = async_to_streamed_response_wrapper(
+            domains.delete,
+        )
+        self.get = async_to_streamed_response_wrapper(
+            domains.get,
+        )
+
+    @cached_property
+    def settings(self) -> AsyncSettingsResourceWithStreamingResponse:
+        return AsyncSettingsResourceWithStreamingResponse(self._domains.settings)