gcore 0.1.0__py3-none-any.whl

gcore/resources/cloud/regions.py

@@ -0,0 +1,328 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+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, 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.cloud import region_get_params, region_list_params
+from ..._base_client import AsyncPaginator, make_request_options
+from ...types.cloud.region import Region
+
+__all__ = ["RegionsResource", "AsyncRegionsResource"]
+
+
+class RegionsResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> RegionsResourceWithRawResponse:
+        """
+        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 RegionsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> RegionsResourceWithStreamingResponse:
+        """
+        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 RegionsResourceWithStreamingResponse(self)
+
+    def list(
+        self,
+        *,
+        limit: int | NotGiven = NOT_GIVEN,
+        offset: int | NotGiven = NOT_GIVEN,
+        order_by: Literal["created_at.asc", "created_at.desc", "display_name.asc", "display_name.desc"]
+        | NotGiven = NOT_GIVEN,
+        product: Literal["containers", "inference"] | NotGiven = NOT_GIVEN,
+        show_volume_types: 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[Region]:
+        """List regions
+
+        Args:
+          limit: Limit the number of returned regions.
+
+        Falls back to default of 100 if not
+              specified. Limited by max limit value of 1000
+
+          offset: Offset value is used to exclude the first set of records from the result
+
+          order_by: Order by field and direction.
+
+          product: If defined then return only regions that support given product.
+
+          show_volume_types: If true, null `available_volume_type` is replaced with a list of available
+              volume types.
+
+          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(
+            "/cloud/v1/regions",
+            page=SyncOffsetPage[Region],
+            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,
+                        "product": product,
+                        "show_volume_types": show_volume_types,
+                    },
+                    region_list_params.RegionListParams,
+                ),
+            ),
+            model=Region,
+        )
+
+    def get(
+        self,
+        *,
+        region_id: int | None = None,
+        show_volume_types: 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,
+    ) -> Region:
+        """
+        Get region
+
+        Args:
+          region_id: Region ID
+
+          show_volume_types: If true, null `available_volume_type` is replaced with a list of available
+              volume types.
+
+          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
+        """
+        if region_id is None:
+            region_id = self._client._get_cloud_region_id_path_param()
+        return self._get(
+            f"/cloud/v1/regions/{region_id}",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform({"show_volume_types": show_volume_types}, region_get_params.RegionGetParams),
+            ),
+            cast_to=Region,
+        )
+
+
+class AsyncRegionsResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncRegionsResourceWithRawResponse:
+        """
+        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 AsyncRegionsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncRegionsResourceWithStreamingResponse:
+        """
+        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 AsyncRegionsResourceWithStreamingResponse(self)
+
+    def list(
+        self,
+        *,
+        limit: int | NotGiven = NOT_GIVEN,
+        offset: int | NotGiven = NOT_GIVEN,
+        order_by: Literal["created_at.asc", "created_at.desc", "display_name.asc", "display_name.desc"]
+        | NotGiven = NOT_GIVEN,
+        product: Literal["containers", "inference"] | NotGiven = NOT_GIVEN,
+        show_volume_types: 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[Region, AsyncOffsetPage[Region]]:
+        """List regions
+
+        Args:
+          limit: Limit the number of returned regions.
+
+        Falls back to default of 100 if not
+              specified. Limited by max limit value of 1000
+
+          offset: Offset value is used to exclude the first set of records from the result
+
+          order_by: Order by field and direction.
+
+          product: If defined then return only regions that support given product.
+
+          show_volume_types: If true, null `available_volume_type` is replaced with a list of available
+              volume types.
+
+          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(
+            "/cloud/v1/regions",
+            page=AsyncOffsetPage[Region],
+            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,
+                        "product": product,
+                        "show_volume_types": show_volume_types,
+                    },
+                    region_list_params.RegionListParams,
+                ),
+            ),
+            model=Region,
+        )
+
+    async def get(
+        self,
+        *,
+        region_id: int | None = None,
+        show_volume_types: 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,
+    ) -> Region:
+        """
+        Get region
+
+        Args:
+          region_id: Region ID
+
+          show_volume_types: If true, null `available_volume_type` is replaced with a list of available
+              volume types.
+
+          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
+        """
+        if region_id is None:
+            region_id = self._client._get_cloud_region_id_path_param()
+        return await self._get(
+            f"/cloud/v1/regions/{region_id}",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform(
+                    {"show_volume_types": show_volume_types}, region_get_params.RegionGetParams
+                ),
+            ),
+            cast_to=Region,
+        )
+
+
+class RegionsResourceWithRawResponse:
+    def __init__(self, regions: RegionsResource) -> None:
+        self._regions = regions
+
+        self.list = to_raw_response_wrapper(
+            regions.list,
+        )
+        self.get = to_raw_response_wrapper(
+            regions.get,
+        )
+
+
+class AsyncRegionsResourceWithRawResponse:
+    def __init__(self, regions: AsyncRegionsResource) -> None:
+        self._regions = regions
+
+        self.list = async_to_raw_response_wrapper(
+            regions.list,
+        )
+        self.get = async_to_raw_response_wrapper(
+            regions.get,
+        )
+
+
+class RegionsResourceWithStreamingResponse:
+    def __init__(self, regions: RegionsResource) -> None:
+        self._regions = regions
+
+        self.list = to_streamed_response_wrapper(
+            regions.list,
+        )
+        self.get = to_streamed_response_wrapper(
+            regions.get,
+        )
+
+
+class AsyncRegionsResourceWithStreamingResponse:
+    def __init__(self, regions: AsyncRegionsResource) -> None:
+        self._regions = regions
+
+        self.list = async_to_streamed_response_wrapper(
+            regions.list,
+        )
+        self.get = async_to_streamed_response_wrapper(
+            regions.get,
+        )

gcore/resources/cloud/registries/__init__.py

@@ -0,0 +1,75 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .tags import (
+    TagsResource,
+    AsyncTagsResource,
+    TagsResourceWithRawResponse,
+    AsyncTagsResourceWithRawResponse,
+    TagsResourceWithStreamingResponse,
+    AsyncTagsResourceWithStreamingResponse,
+)
+from .users import (
+    UsersResource,
+    AsyncUsersResource,
+    UsersResourceWithRawResponse,
+    AsyncUsersResourceWithRawResponse,
+    UsersResourceWithStreamingResponse,
+    AsyncUsersResourceWithStreamingResponse,
+)
+from .artifacts import (
+    ArtifactsResource,
+    AsyncArtifactsResource,
+    ArtifactsResourceWithRawResponse,
+    AsyncArtifactsResourceWithRawResponse,
+    ArtifactsResourceWithStreamingResponse,
+    AsyncArtifactsResourceWithStreamingResponse,
+)
+from .registries import (
+    RegistriesResource,
+    AsyncRegistriesResource,
+    RegistriesResourceWithRawResponse,
+    AsyncRegistriesResourceWithRawResponse,
+    RegistriesResourceWithStreamingResponse,
+    AsyncRegistriesResourceWithStreamingResponse,
+)
+from .repositories import (
+    RepositoriesResource,
+    AsyncRepositoriesResource,
+    RepositoriesResourceWithRawResponse,
+    AsyncRepositoriesResourceWithRawResponse,
+    RepositoriesResourceWithStreamingResponse,
+    AsyncRepositoriesResourceWithStreamingResponse,
+)
+
+__all__ = [
+    "RepositoriesResource",
+    "AsyncRepositoriesResource",
+    "RepositoriesResourceWithRawResponse",
+    "AsyncRepositoriesResourceWithRawResponse",
+    "RepositoriesResourceWithStreamingResponse",
+    "AsyncRepositoriesResourceWithStreamingResponse",
+    "ArtifactsResource",
+    "AsyncArtifactsResource",
+    "ArtifactsResourceWithRawResponse",
+    "AsyncArtifactsResourceWithRawResponse",
+    "ArtifactsResourceWithStreamingResponse",
+    "AsyncArtifactsResourceWithStreamingResponse",
+    "TagsResource",
+    "AsyncTagsResource",
+    "TagsResourceWithRawResponse",
+    "AsyncTagsResourceWithRawResponse",
+    "TagsResourceWithStreamingResponse",
+    "AsyncTagsResourceWithStreamingResponse",
+    "UsersResource",
+    "AsyncUsersResource",
+    "UsersResourceWithRawResponse",
+    "AsyncUsersResourceWithRawResponse",
+    "UsersResourceWithStreamingResponse",
+    "AsyncUsersResourceWithStreamingResponse",
+    "RegistriesResource",
+    "AsyncRegistriesResource",
+    "RegistriesResourceWithRawResponse",
+    "AsyncRegistriesResourceWithRawResponse",
+    "RegistriesResourceWithStreamingResponse",
+    "AsyncRegistriesResourceWithStreamingResponse",
+]

gcore/resources/cloud/registries/artifacts.py

@@ -0,0 +1,277 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import httpx
+
+from ...._types import NOT_GIVEN, Body, Query, Headers, NoneType, NotGiven
+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.cloud.registries.registry_artifact_list import RegistryArtifactList
+
+__all__ = ["ArtifactsResource", "AsyncArtifactsResource"]
+
+
+class ArtifactsResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> ArtifactsResourceWithRawResponse:
+        """
+        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 ArtifactsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> ArtifactsResourceWithStreamingResponse:
+        """
+        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 ArtifactsResourceWithStreamingResponse(self)
+
+    def list(
+        self,
+        repository_name: str,
+        *,
+        project_id: int | None = None,
+        region_id: int | None = None,
+        registry_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,
+    ) -> RegistryArtifactList:
+        """
+        List artifacts
+
+        Args:
+          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
+        """
+        if project_id is None:
+            project_id = self._client._get_cloud_project_id_path_param()
+        if region_id is None:
+            region_id = self._client._get_cloud_region_id_path_param()
+        if not repository_name:
+            raise ValueError(f"Expected a non-empty value for `repository_name` but received {repository_name!r}")
+        return self._get(
+            f"/cloud/v1/registries/{project_id}/{region_id}/{registry_id}/repositories/{repository_name}/artifacts",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=RegistryArtifactList,
+        )
+
+    def delete(
+        self,
+        digest: str,
+        *,
+        project_id: int | None = None,
+        region_id: int | None = None,
+        registry_id: int,
+        repository_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.
+        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 artifact
+
+        Args:
+          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
+        """
+        if project_id is None:
+            project_id = self._client._get_cloud_project_id_path_param()
+        if region_id is None:
+            region_id = self._client._get_cloud_region_id_path_param()
+        if not repository_name:
+            raise ValueError(f"Expected a non-empty value for `repository_name` but received {repository_name!r}")
+        if not digest:
+            raise ValueError(f"Expected a non-empty value for `digest` but received {digest!r}")
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return self._delete(
+            f"/cloud/v1/registries/{project_id}/{region_id}/{registry_id}/repositories/{repository_name}/artifacts/{digest}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=NoneType,
+        )
+
+
+class AsyncArtifactsResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncArtifactsResourceWithRawResponse:
+        """
+        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 AsyncArtifactsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncArtifactsResourceWithStreamingResponse:
+        """
+        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 AsyncArtifactsResourceWithStreamingResponse(self)
+
+    async def list(
+        self,
+        repository_name: str,
+        *,
+        project_id: int | None = None,
+        region_id: int | None = None,
+        registry_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,
+    ) -> RegistryArtifactList:
+        """
+        List artifacts
+
+        Args:
+          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
+        """
+        if project_id is None:
+            project_id = self._client._get_cloud_project_id_path_param()
+        if region_id is None:
+            region_id = self._client._get_cloud_region_id_path_param()
+        if not repository_name:
+            raise ValueError(f"Expected a non-empty value for `repository_name` but received {repository_name!r}")
+        return await self._get(
+            f"/cloud/v1/registries/{project_id}/{region_id}/{registry_id}/repositories/{repository_name}/artifacts",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=RegistryArtifactList,
+        )
+
+    async def delete(
+        self,
+        digest: str,
+        *,
+        project_id: int | None = None,
+        region_id: int | None = None,
+        registry_id: int,
+        repository_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.
+        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 artifact
+
+        Args:
+          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
+        """
+        if project_id is None:
+            project_id = self._client._get_cloud_project_id_path_param()
+        if region_id is None:
+            region_id = self._client._get_cloud_region_id_path_param()
+        if not repository_name:
+            raise ValueError(f"Expected a non-empty value for `repository_name` but received {repository_name!r}")
+        if not digest:
+            raise ValueError(f"Expected a non-empty value for `digest` but received {digest!r}")
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return await self._delete(
+            f"/cloud/v1/registries/{project_id}/{region_id}/{registry_id}/repositories/{repository_name}/artifacts/{digest}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=NoneType,
+        )
+
+
+class ArtifactsResourceWithRawResponse:
+    def __init__(self, artifacts: ArtifactsResource) -> None:
+        self._artifacts = artifacts
+
+        self.list = to_raw_response_wrapper(
+            artifacts.list,
+        )
+        self.delete = to_raw_response_wrapper(
+            artifacts.delete,
+        )
+
+
+class AsyncArtifactsResourceWithRawResponse:
+    def __init__(self, artifacts: AsyncArtifactsResource) -> None:
+        self._artifacts = artifacts
+
+        self.list = async_to_raw_response_wrapper(
+            artifacts.list,
+        )
+        self.delete = async_to_raw_response_wrapper(
+            artifacts.delete,
+        )
+
+
+class ArtifactsResourceWithStreamingResponse:
+    def __init__(self, artifacts: ArtifactsResource) -> None:
+        self._artifacts = artifacts
+
+        self.list = to_streamed_response_wrapper(
+            artifacts.list,
+        )
+        self.delete = to_streamed_response_wrapper(
+            artifacts.delete,
+        )
+
+
+class AsyncArtifactsResourceWithStreamingResponse:
+    def __init__(self, artifacts: AsyncArtifactsResource) -> None:
+        self._artifacts = artifacts
+
+        self.list = async_to_streamed_response_wrapper(
+            artifacts.list,
+        )
+        self.delete = async_to_streamed_response_wrapper(
+            artifacts.delete,
+        )