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

gcore/resources/waap/organizations.py

@@ -0,0 +1,217 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+from typing_extensions import Literal
+
+import httpx
+
+from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+from ..._utils import 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 organization_list_params
+from ..._base_client import AsyncPaginator, make_request_options
+from ...types.waap.waap_organization import WaapOrganization
+
+__all__ = ["OrganizationsResource", "AsyncOrganizationsResource"]
+
+
+class OrganizationsResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> OrganizationsResourceWithRawResponse:
+        """
+        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 OrganizationsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> OrganizationsResourceWithStreamingResponse:
+        """
+        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 OrganizationsResourceWithStreamingResponse(self)
+
+    def list(
+        self,
+        *,
+        limit: int | NotGiven = NOT_GIVEN,
+        name: str | NotGiven = NOT_GIVEN,
+        offset: int | NotGiven = NOT_GIVEN,
+        ordering: Optional[Literal["name", "id", "-name", "-id"]] | 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[WaapOrganization]:
+        """
+        This endpoint retrieves a list of network organizations that own IP ranges as
+        identified by the Whois service.It supports pagination, filtering based on
+        various parameters, and ordering of results.
+
+        Args:
+          limit: Number of items to return
+
+          name: Filter organizations by their name. Supports '\\**' as a wildcard character.
+
+          offset: Number of items to skip
+
+          ordering: Determine the field to order results by
+
+          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/organizations",
+            page=SyncOffsetPage[WaapOrganization],
+            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,
+                        "ordering": ordering,
+                    },
+                    organization_list_params.OrganizationListParams,
+                ),
+            ),
+            model=WaapOrganization,
+        )
+
+
+class AsyncOrganizationsResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncOrganizationsResourceWithRawResponse:
+        """
+        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 AsyncOrganizationsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncOrganizationsResourceWithStreamingResponse:
+        """
+        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 AsyncOrganizationsResourceWithStreamingResponse(self)
+
+    def list(
+        self,
+        *,
+        limit: int | NotGiven = NOT_GIVEN,
+        name: str | NotGiven = NOT_GIVEN,
+        offset: int | NotGiven = NOT_GIVEN,
+        ordering: Optional[Literal["name", "id", "-name", "-id"]] | 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[WaapOrganization, AsyncOffsetPage[WaapOrganization]]:
+        """
+        This endpoint retrieves a list of network organizations that own IP ranges as
+        identified by the Whois service.It supports pagination, filtering based on
+        various parameters, and ordering of results.
+
+        Args:
+          limit: Number of items to return
+
+          name: Filter organizations by their name. Supports '\\**' as a wildcard character.
+
+          offset: Number of items to skip
+
+          ordering: Determine the field to order results by
+
+          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/organizations",
+            page=AsyncOffsetPage[WaapOrganization],
+            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,
+                        "ordering": ordering,
+                    },
+                    organization_list_params.OrganizationListParams,
+                ),
+            ),
+            model=WaapOrganization,
+        )
+
+
+class OrganizationsResourceWithRawResponse:
+    def __init__(self, organizations: OrganizationsResource) -> None:
+        self._organizations = organizations
+
+        self.list = to_raw_response_wrapper(
+            organizations.list,
+        )
+
+
+class AsyncOrganizationsResourceWithRawResponse:
+    def __init__(self, organizations: AsyncOrganizationsResource) -> None:
+        self._organizations = organizations
+
+        self.list = async_to_raw_response_wrapper(
+            organizations.list,
+        )
+
+
+class OrganizationsResourceWithStreamingResponse:
+    def __init__(self, organizations: OrganizationsResource) -> None:
+        self._organizations = organizations
+
+        self.list = to_streamed_response_wrapper(
+            organizations.list,
+        )
+
+
+class AsyncOrganizationsResourceWithStreamingResponse:
+    def __init__(self, organizations: AsyncOrganizationsResource) -> None:
+        self._organizations = organizations
+
+        self.list = async_to_streamed_response_wrapper(
+            organizations.list,
+        )

gcore/resources/waap/statistics.py

@@ -0,0 +1,225 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List, Union
+from datetime import datetime
+from typing_extensions import Literal
+
+import httpx
+
+from ..._types import NOT_GIVEN, Body, Query, Headers, 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 ...types.waap import statistic_get_usage_series_params
+from ..._base_client import make_request_options
+from ...types.waap.waap_statistics_series import WaapStatisticsSeries
+
+__all__ = ["StatisticsResource", "AsyncStatisticsResource"]
+
+
+class StatisticsResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> StatisticsResourceWithRawResponse:
+        """
+        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 StatisticsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> StatisticsResourceWithStreamingResponse:
+        """
+        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 StatisticsResourceWithStreamingResponse(self)
+
+    def get_usage_series(
+        self,
+        *,
+        from_: Union[str, datetime],
+        granularity: Literal["1h", "1d"],
+        metrics: List[Literal["total_bytes", "total_requests"]],
+        to: Union[str, datetime],
+        # 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,
+    ) -> WaapStatisticsSeries:
+        """Retrieve statistics data as a time series.
+
+        The `from` and `to` parameters are
+        rounded down and up according to the `granularity`. This means that if the
+        `granularity` is set to `1h`, the `from` and `to` parameters will be rounded
+        down and up to the nearest hour, respectively. If the `granularity` is set to
+        `1d`, the `from` and `to` parameters will be rounded down and up to the nearest
+        day, respectively. The response will include explicit 0 values for any missing
+        data points.
+
+        Args:
+          from_: Beginning of the requested time period (ISO 8601 format, UTC)
+
+          granularity: Duration of the time blocks into which the data will be divided.
+
+          metrics: List of metric types to retrieve statistics for.
+
+          to: End of the requested time period (ISO 8601 format, UTC)
+
+          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(
+            "/waap/v1/statistics/series",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "from_": from_,
+                        "granularity": granularity,
+                        "metrics": metrics,
+                        "to": to,
+                    },
+                    statistic_get_usage_series_params.StatisticGetUsageSeriesParams,
+                ),
+            ),
+            cast_to=WaapStatisticsSeries,
+        )
+
+
+class AsyncStatisticsResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncStatisticsResourceWithRawResponse:
+        """
+        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 AsyncStatisticsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncStatisticsResourceWithStreamingResponse:
+        """
+        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 AsyncStatisticsResourceWithStreamingResponse(self)
+
+    async def get_usage_series(
+        self,
+        *,
+        from_: Union[str, datetime],
+        granularity: Literal["1h", "1d"],
+        metrics: List[Literal["total_bytes", "total_requests"]],
+        to: Union[str, datetime],
+        # 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,
+    ) -> WaapStatisticsSeries:
+        """Retrieve statistics data as a time series.
+
+        The `from` and `to` parameters are
+        rounded down and up according to the `granularity`. This means that if the
+        `granularity` is set to `1h`, the `from` and `to` parameters will be rounded
+        down and up to the nearest hour, respectively. If the `granularity` is set to
+        `1d`, the `from` and `to` parameters will be rounded down and up to the nearest
+        day, respectively. The response will include explicit 0 values for any missing
+        data points.
+
+        Args:
+          from_: Beginning of the requested time period (ISO 8601 format, UTC)
+
+          granularity: Duration of the time blocks into which the data will be divided.
+
+          metrics: List of metric types to retrieve statistics for.
+
+          to: End of the requested time period (ISO 8601 format, UTC)
+
+          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(
+            "/waap/v1/statistics/series",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform(
+                    {
+                        "from_": from_,
+                        "granularity": granularity,
+                        "metrics": metrics,
+                        "to": to,
+                    },
+                    statistic_get_usage_series_params.StatisticGetUsageSeriesParams,
+                ),
+            ),
+            cast_to=WaapStatisticsSeries,
+        )
+
+
+class StatisticsResourceWithRawResponse:
+    def __init__(self, statistics: StatisticsResource) -> None:
+        self._statistics = statistics
+
+        self.get_usage_series = to_raw_response_wrapper(
+            statistics.get_usage_series,
+        )
+
+
+class AsyncStatisticsResourceWithRawResponse:
+    def __init__(self, statistics: AsyncStatisticsResource) -> None:
+        self._statistics = statistics
+
+        self.get_usage_series = async_to_raw_response_wrapper(
+            statistics.get_usage_series,
+        )
+
+
+class StatisticsResourceWithStreamingResponse:
+    def __init__(self, statistics: StatisticsResource) -> None:
+        self._statistics = statistics
+
+        self.get_usage_series = to_streamed_response_wrapper(
+            statistics.get_usage_series,
+        )
+
+
+class AsyncStatisticsResourceWithStreamingResponse:
+    def __init__(self, statistics: AsyncStatisticsResource) -> None:
+        self._statistics = statistics
+
+        self.get_usage_series = async_to_streamed_response_wrapper(
+            statistics.get_usage_series,
+        )

gcore/resources/waap/tags.py

@@ -0,0 +1,233 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+from typing_extensions import Literal
+
+import httpx
+
+from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+from ..._utils import 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 tag_list_params
+from ..._base_client import AsyncPaginator, make_request_options
+from ...types.waap.waap_tag import WaapTag
+
+__all__ = ["TagsResource", "AsyncTagsResource"]
+
+
+class TagsResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> TagsResourceWithRawResponse:
+        """
+        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 TagsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> TagsResourceWithStreamingResponse:
+        """
+        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 TagsResourceWithStreamingResponse(self)
+
+    def list(
+        self,
+        *,
+        limit: int | NotGiven = NOT_GIVEN,
+        name: str | NotGiven = NOT_GIVEN,
+        offset: int | NotGiven = NOT_GIVEN,
+        ordering: Optional[Literal["name", "readable_name", "reserved", "-name", "-readable_name", "-reserved"]]
+        | NotGiven = NOT_GIVEN,
+        readable_name: str | NotGiven = NOT_GIVEN,
+        reserved: 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[WaapTag]:
+        """
+        Tags are shortcuts for the rules used in WAAP policies for the creation of more
+        complex WAAP rules
+
+        Args:
+          limit: Number of items to return
+
+          name: Filter tags by their name. Supports '\\**' as a wildcard character.
+
+          offset: Number of items to skip
+
+          ordering: Determine the field to order results by
+
+          readable_name: Filter tags by their readable name. Supports '\\**' as a wildcard character.
+
+          reserved: Filter to include only reserved tags.
+
+          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/tags",
+            page=SyncOffsetPage[WaapTag],
+            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,
+                        "ordering": ordering,
+                        "readable_name": readable_name,
+                        "reserved": reserved,
+                    },
+                    tag_list_params.TagListParams,
+                ),
+            ),
+            model=WaapTag,
+        )
+
+
+class AsyncTagsResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncTagsResourceWithRawResponse:
+        """
+        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 AsyncTagsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncTagsResourceWithStreamingResponse:
+        """
+        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 AsyncTagsResourceWithStreamingResponse(self)
+
+    def list(
+        self,
+        *,
+        limit: int | NotGiven = NOT_GIVEN,
+        name: str | NotGiven = NOT_GIVEN,
+        offset: int | NotGiven = NOT_GIVEN,
+        ordering: Optional[Literal["name", "readable_name", "reserved", "-name", "-readable_name", "-reserved"]]
+        | NotGiven = NOT_GIVEN,
+        readable_name: str | NotGiven = NOT_GIVEN,
+        reserved: 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[WaapTag, AsyncOffsetPage[WaapTag]]:
+        """
+        Tags are shortcuts for the rules used in WAAP policies for the creation of more
+        complex WAAP rules
+
+        Args:
+          limit: Number of items to return
+
+          name: Filter tags by their name. Supports '\\**' as a wildcard character.
+
+          offset: Number of items to skip
+
+          ordering: Determine the field to order results by
+
+          readable_name: Filter tags by their readable name. Supports '\\**' as a wildcard character.
+
+          reserved: Filter to include only reserved tags.
+
+          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/tags",
+            page=AsyncOffsetPage[WaapTag],
+            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,
+                        "ordering": ordering,
+                        "readable_name": readable_name,
+                        "reserved": reserved,
+                    },
+                    tag_list_params.TagListParams,
+                ),
+            ),
+            model=WaapTag,
+        )
+
+
+class TagsResourceWithRawResponse:
+    def __init__(self, tags: TagsResource) -> None:
+        self._tags = tags
+
+        self.list = to_raw_response_wrapper(
+            tags.list,
+        )
+
+
+class AsyncTagsResourceWithRawResponse:
+    def __init__(self, tags: AsyncTagsResource) -> None:
+        self._tags = tags
+
+        self.list = async_to_raw_response_wrapper(
+            tags.list,
+        )
+
+
+class TagsResourceWithStreamingResponse:
+    def __init__(self, tags: TagsResource) -> None:
+        self._tags = tags
+
+        self.list = to_streamed_response_wrapper(
+            tags.list,
+        )
+
+
+class AsyncTagsResourceWithStreamingResponse:
+    def __init__(self, tags: AsyncTagsResource) -> None:
+        self._tags = tags
+
+        self.list = async_to_streamed_response_wrapper(
+            tags.list,
+        )