gcore 0.1.0a1__py3-none-any.whl

gcore/resources/cloud/registries/registries.py

@@ -0,0 +1,688 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import httpx
+
+from .tags import (
+    TagsResource,
+    AsyncTagsResource,
+    TagsResourceWithRawResponse,
+    AsyncTagsResourceWithRawResponse,
+    TagsResourceWithStreamingResponse,
+    AsyncTagsResourceWithStreamingResponse,
+)
+from .users import (
+    UsersResource,
+    AsyncUsersResource,
+    UsersResourceWithRawResponse,
+    AsyncUsersResourceWithRawResponse,
+    UsersResourceWithStreamingResponse,
+    AsyncUsersResourceWithStreamingResponse,
+)
+from ...._types import NOT_GIVEN, Body, Query, Headers, NoneType, NotGiven
+from ...._utils import maybe_transform, async_maybe_transform
+from .artifacts import (
+    ArtifactsResource,
+    AsyncArtifactsResource,
+    ArtifactsResourceWithRawResponse,
+    AsyncArtifactsResourceWithRawResponse,
+    ArtifactsResourceWithStreamingResponse,
+    AsyncArtifactsResourceWithStreamingResponse,
+)
+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 .repositories import (
+    RepositoriesResource,
+    AsyncRepositoriesResource,
+    RepositoriesResourceWithRawResponse,
+    AsyncRepositoriesResourceWithRawResponse,
+    RepositoriesResourceWithStreamingResponse,
+    AsyncRepositoriesResourceWithStreamingResponse,
+)
+from ....types.cloud import registry_create_params, registry_resize_params
+from ...._base_client import make_request_options
+from ....types.cloud.registry import Registry
+from ....types.cloud.registry_list import RegistryList
+
+__all__ = ["RegistriesResource", "AsyncRegistriesResource"]
+
+
+class RegistriesResource(SyncAPIResource):
+    @cached_property
+    def repositories(self) -> RepositoriesResource:
+        return RepositoriesResource(self._client)
+
+    @cached_property
+    def artifacts(self) -> ArtifactsResource:
+        return ArtifactsResource(self._client)
+
+    @cached_property
+    def tags(self) -> TagsResource:
+        return TagsResource(self._client)
+
+    @cached_property
+    def users(self) -> UsersResource:
+        return UsersResource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> RegistriesResourceWithRawResponse:
+        """
+        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 RegistriesResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> RegistriesResourceWithStreamingResponse:
+        """
+        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 RegistriesResourceWithStreamingResponse(self)
+
+    def create(
+        self,
+        *,
+        project_id: int | None = None,
+        region_id: int | None = None,
+        name: str,
+        storage_limit: int | 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,
+    ) -> Registry:
+        """
+        Create a registry
+
+        Args:
+          name: A name for the container registry.
+
+              Should be in lowercase, consisting only of numbers, letters and -,
+
+              with maximum length of 24 characters
+
+          storage_limit: Registry storage limit, GiB
+
+          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()
+        return self._post(
+            f"/cloud/v1/registries/{project_id}/{region_id}",
+            body=maybe_transform(
+                {
+                    "name": name,
+                    "storage_limit": storage_limit,
+                },
+                registry_create_params.RegistryCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=Registry,
+        )
+
+    def list(
+        self,
+        *,
+        project_id: int | None = None,
+        region_id: int | None = None,
+        # 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,
+    ) -> RegistryList:
+        """
+        Get registry list
+
+        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()
+        return self._get(
+            f"/cloud/v1/registries/{project_id}/{region_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=RegistryList,
+        )
+
+    def delete(
+        self,
+        registry_id: int,
+        *,
+        project_id: int | None = None,
+        region_id: int | None = None,
+        # 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 a registry
+
+        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()
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return self._delete(
+            f"/cloud/v1/registries/{project_id}/{region_id}/{registry_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,
+        registry_id: int,
+        *,
+        project_id: int | None = None,
+        region_id: int | None = None,
+        # 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,
+    ) -> Registry:
+        """
+        Get a registry
+
+        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()
+        return self._get(
+            f"/cloud/v1/registries/{project_id}/{region_id}/{registry_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=Registry,
+        )
+
+    def resize(
+        self,
+        registry_id: int,
+        *,
+        project_id: int | None = None,
+        region_id: int | None = None,
+        storage_limit: int | 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,
+    ) -> Registry:
+        """
+        Resize a registry
+
+        Args:
+          storage_limit: Registry storage limit, GiB
+
+          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()
+        return self._patch(
+            f"/cloud/v1/registries/{project_id}/{region_id}/{registry_id}/resize",
+            body=maybe_transform({"storage_limit": storage_limit}, registry_resize_params.RegistryResizeParams),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=Registry,
+        )
+
+
+class AsyncRegistriesResource(AsyncAPIResource):
+    @cached_property
+    def repositories(self) -> AsyncRepositoriesResource:
+        return AsyncRepositoriesResource(self._client)
+
+    @cached_property
+    def artifacts(self) -> AsyncArtifactsResource:
+        return AsyncArtifactsResource(self._client)
+
+    @cached_property
+    def tags(self) -> AsyncTagsResource:
+        return AsyncTagsResource(self._client)
+
+    @cached_property
+    def users(self) -> AsyncUsersResource:
+        return AsyncUsersResource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> AsyncRegistriesResourceWithRawResponse:
+        """
+        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 AsyncRegistriesResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncRegistriesResourceWithStreamingResponse:
+        """
+        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 AsyncRegistriesResourceWithStreamingResponse(self)
+
+    async def create(
+        self,
+        *,
+        project_id: int | None = None,
+        region_id: int | None = None,
+        name: str,
+        storage_limit: int | 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,
+    ) -> Registry:
+        """
+        Create a registry
+
+        Args:
+          name: A name for the container registry.
+
+              Should be in lowercase, consisting only of numbers, letters and -,
+
+              with maximum length of 24 characters
+
+          storage_limit: Registry storage limit, GiB
+
+          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()
+        return await self._post(
+            f"/cloud/v1/registries/{project_id}/{region_id}",
+            body=await async_maybe_transform(
+                {
+                    "name": name,
+                    "storage_limit": storage_limit,
+                },
+                registry_create_params.RegistryCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=Registry,
+        )
+
+    async def list(
+        self,
+        *,
+        project_id: int | None = None,
+        region_id: int | None = None,
+        # 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,
+    ) -> RegistryList:
+        """
+        Get registry list
+
+        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()
+        return await self._get(
+            f"/cloud/v1/registries/{project_id}/{region_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=RegistryList,
+        )
+
+    async def delete(
+        self,
+        registry_id: int,
+        *,
+        project_id: int | None = None,
+        region_id: int | None = None,
+        # 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 a registry
+
+        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()
+        extra_headers = {"Accept": "*/*", **(extra_headers or {})}
+        return await self._delete(
+            f"/cloud/v1/registries/{project_id}/{region_id}/{registry_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,
+        registry_id: int,
+        *,
+        project_id: int | None = None,
+        region_id: int | None = None,
+        # 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,
+    ) -> Registry:
+        """
+        Get a registry
+
+        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()
+        return await self._get(
+            f"/cloud/v1/registries/{project_id}/{region_id}/{registry_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=Registry,
+        )
+
+    async def resize(
+        self,
+        registry_id: int,
+        *,
+        project_id: int | None = None,
+        region_id: int | None = None,
+        storage_limit: int | 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,
+    ) -> Registry:
+        """
+        Resize a registry
+
+        Args:
+          storage_limit: Registry storage limit, GiB
+
+          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()
+        return await self._patch(
+            f"/cloud/v1/registries/{project_id}/{region_id}/{registry_id}/resize",
+            body=await async_maybe_transform(
+                {"storage_limit": storage_limit}, registry_resize_params.RegistryResizeParams
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=Registry,
+        )
+
+
+class RegistriesResourceWithRawResponse:
+    def __init__(self, registries: RegistriesResource) -> None:
+        self._registries = registries
+
+        self.create = to_raw_response_wrapper(
+            registries.create,
+        )
+        self.list = to_raw_response_wrapper(
+            registries.list,
+        )
+        self.delete = to_raw_response_wrapper(
+            registries.delete,
+        )
+        self.get = to_raw_response_wrapper(
+            registries.get,
+        )
+        self.resize = to_raw_response_wrapper(
+            registries.resize,
+        )
+
+    @cached_property
+    def repositories(self) -> RepositoriesResourceWithRawResponse:
+        return RepositoriesResourceWithRawResponse(self._registries.repositories)
+
+    @cached_property
+    def artifacts(self) -> ArtifactsResourceWithRawResponse:
+        return ArtifactsResourceWithRawResponse(self._registries.artifacts)
+
+    @cached_property
+    def tags(self) -> TagsResourceWithRawResponse:
+        return TagsResourceWithRawResponse(self._registries.tags)
+
+    @cached_property
+    def users(self) -> UsersResourceWithRawResponse:
+        return UsersResourceWithRawResponse(self._registries.users)
+
+
+class AsyncRegistriesResourceWithRawResponse:
+    def __init__(self, registries: AsyncRegistriesResource) -> None:
+        self._registries = registries
+
+        self.create = async_to_raw_response_wrapper(
+            registries.create,
+        )
+        self.list = async_to_raw_response_wrapper(
+            registries.list,
+        )
+        self.delete = async_to_raw_response_wrapper(
+            registries.delete,
+        )
+        self.get = async_to_raw_response_wrapper(
+            registries.get,
+        )
+        self.resize = async_to_raw_response_wrapper(
+            registries.resize,
+        )
+
+    @cached_property
+    def repositories(self) -> AsyncRepositoriesResourceWithRawResponse:
+        return AsyncRepositoriesResourceWithRawResponse(self._registries.repositories)
+
+    @cached_property
+    def artifacts(self) -> AsyncArtifactsResourceWithRawResponse:
+        return AsyncArtifactsResourceWithRawResponse(self._registries.artifacts)
+
+    @cached_property
+    def tags(self) -> AsyncTagsResourceWithRawResponse:
+        return AsyncTagsResourceWithRawResponse(self._registries.tags)
+
+    @cached_property
+    def users(self) -> AsyncUsersResourceWithRawResponse:
+        return AsyncUsersResourceWithRawResponse(self._registries.users)
+
+
+class RegistriesResourceWithStreamingResponse:
+    def __init__(self, registries: RegistriesResource) -> None:
+        self._registries = registries
+
+        self.create = to_streamed_response_wrapper(
+            registries.create,
+        )
+        self.list = to_streamed_response_wrapper(
+            registries.list,
+        )
+        self.delete = to_streamed_response_wrapper(
+            registries.delete,
+        )
+        self.get = to_streamed_response_wrapper(
+            registries.get,
+        )
+        self.resize = to_streamed_response_wrapper(
+            registries.resize,
+        )
+
+    @cached_property
+    def repositories(self) -> RepositoriesResourceWithStreamingResponse:
+        return RepositoriesResourceWithStreamingResponse(self._registries.repositories)
+
+    @cached_property
+    def artifacts(self) -> ArtifactsResourceWithStreamingResponse:
+        return ArtifactsResourceWithStreamingResponse(self._registries.artifacts)
+
+    @cached_property
+    def tags(self) -> TagsResourceWithStreamingResponse:
+        return TagsResourceWithStreamingResponse(self._registries.tags)
+
+    @cached_property
+    def users(self) -> UsersResourceWithStreamingResponse:
+        return UsersResourceWithStreamingResponse(self._registries.users)
+
+
+class AsyncRegistriesResourceWithStreamingResponse:
+    def __init__(self, registries: AsyncRegistriesResource) -> None:
+        self._registries = registries
+
+        self.create = async_to_streamed_response_wrapper(
+            registries.create,
+        )
+        self.list = async_to_streamed_response_wrapper(
+            registries.list,
+        )
+        self.delete = async_to_streamed_response_wrapper(
+            registries.delete,
+        )
+        self.get = async_to_streamed_response_wrapper(
+            registries.get,
+        )
+        self.resize = async_to_streamed_response_wrapper(
+            registries.resize,
+        )
+
+    @cached_property
+    def repositories(self) -> AsyncRepositoriesResourceWithStreamingResponse:
+        return AsyncRepositoriesResourceWithStreamingResponse(self._registries.repositories)
+
+    @cached_property
+    def artifacts(self) -> AsyncArtifactsResourceWithStreamingResponse:
+        return AsyncArtifactsResourceWithStreamingResponse(self._registries.artifacts)
+
+    @cached_property
+    def tags(self) -> AsyncTagsResourceWithStreamingResponse:
+        return AsyncTagsResourceWithStreamingResponse(self._registries.tags)
+
+    @cached_property
+    def users(self) -> AsyncUsersResourceWithStreamingResponse:
+        return AsyncUsersResourceWithStreamingResponse(self._registries.users)