[Container Registry] ACR list_repositories pageable

sdk/containerregistry/azure-containerregistry/azure/containerregistry/_container_registry_client.py

@@ -4,12 +4,20 @@
 # Licensed under the MIT License.
 # ------------------------------------
 from typing import TYPE_CHECKING
-
+from azure.core.exceptions import (
+    ClientAuthenticationError,
+    ResourceNotFoundError,
+    ResourceExistsError,
+    HttpResponseError,
+    map_error,
+)
 from azure.core.paging import ItemPaged
 from azure.core.tracing.decorator import distributed_trace
 
 from ._base_client import ContainerRegistryBaseClient
 from ._container_repository_client import ContainerRepositoryClient
+from ._generated.models import AcrErrors
+from ._helpers import _parse_next_link
 from ._models import DeletedRepositoryResult
 
 if TYPE_CHECKING:
@@ -61,9 +69,96 @@ def list_repositories(self, **kwargs):
         :returns: ~azure.core.paging.ItemPaged[str]
         :raises: None
         """
-        return self._client.container_registry.get_repositories(
-            last=kwargs.pop("last", None), n=kwargs.pop("max", None), **kwargs
-        )
+        n = kwargs.pop("results_per_page", None)
+        last = kwargs.pop("last", None)
+
+        cls = kwargs.pop("cls", None)  # type: ClsType["_models.Repositories"]
+        error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError}
+        error_map.update(kwargs.pop("error_map", {}))
+        accept = "application/json"
+
+        def prepare_request(next_link=None):
+            # Construct headers
+            header_parameters = {}  # type: Dict[str, Any]
+            header_parameters["Accept"] = self._client._serialize.header(  # pylint: disable=protected-access
+                "accept", accept, "str"
+            )
+
+            if not next_link:
+                # Construct URL
+                url = "/acr/v1/_catalog"
+                path_format_arguments = {
+                    "url": self._client._serialize.url(  # pylint: disable=protected-access
+                        "self._config.url",
+                        self._client._config.url,  # pylint: disable=protected-access
+                        "str",
+                        skip_quote=True,
+                    ),
+                }
+                url = self._client._client.format_url(url, **path_format_arguments)  # pylint: disable=protected-access
+                # Construct parameters
+                query_parameters = {}  # type: Dict[str, Any]
+                if last is not None:
+                    query_parameters["last"] = self._client._serialize.query(  # pylint: disable=protected-access
+                        "last", last, "str"
+                    )
+                if n is not None:
+                    query_parameters["n"] = self._client._serialize.query(  # pylint: disable=protected-access
+                        "n", n, "int"
+                    )
+
+                request = self._client._client.get(  # pylint: disable=protected-access
+                    url, query_parameters, header_parameters
+                )
+            else:
+                url = next_link
+                query_parameters = {}  # type: Dict[str, Any]
+                path_format_arguments = {
+                    "url": self._client._serialize.url(  # pylint: disable=protected-access
+                        "self._config.url",
+                        self._client._config.url,  # pylint: disable=protected-access
+                        "str",
+                        skip_quote=True,
+                    ),
+                }
+                url = self._client._client.format_url(url, **path_format_arguments)  # pylint: disable=protected-access
+                request = self._client._client.get(  # pylint: disable=protected-access
+                    url, query_parameters, header_parameters
+                )
+            return request
+
+        def extract_data(pipeline_response):
+            deserialized = self._client._deserialize(  # pylint: disable=protected-access
+                "Repositories", pipeline_response
+            )
+            list_of_elem = deserialized.repositories
+            if cls:
+                list_of_elem = cls(list_of_elem)
+            link = None
+            if "Link" in pipeline_response.http_response.headers.keys():
+                link = _parse_next_link(pipeline_response.http_response.headers["Link"])
+            elif "link" in pipeline_response.http_response.headers.keys():  # python 2.7 turns this into lowercase
+                link = _parse_next_link(pipeline_response.http_response.headers["link"])
+            return link, iter(list_of_elem)
+
+        def get_next(next_link=None):
+            request = prepare_request(next_link)
+
+            pipeline_response = self._client._client._pipeline.run(  # pylint: disable=protected-access
+                request, stream=False, **kwargs
+            )
+            response = pipeline_response.http_response
+
+            if response.status_code not in [200]:
+                error = self._client._deserialize.failsafe_deserialize(  # pylint: disable=protected-access
+                    AcrErrors, response
+                )
+                map_error(status_code=response.status_code, response=response, error_map=error_map)
+                raise HttpResponseError(response=response, model=error)
+
+            return pipeline_response
+
+        return ItemPaged(get_next, extract_data)
 
     @distributed_trace
     def get_repository_client(self, repository, **kwargs):

sdk/containerregistry/azure-containerregistry/azure/containerregistry/_container_repository_client.py

@@ -5,15 +5,23 @@
 # ------------------------------------
 from typing import TYPE_CHECKING
 
+from azure.core.exceptions import (
+    ClientAuthenticationError,
+    ResourceNotFoundError,
+    ResourceExistsError,
+    HttpResponseError,
+    map_error,
+)
+from azure.core.paging import ItemPaged
 from azure.core.tracing.decorator import distributed_trace
 
 from ._base_client import ContainerRegistryBaseClient
-from ._helpers import _is_tag
+from ._generated.models import AcrErrors
+from ._helpers import _is_tag, _parse_next_link
 from ._models import RepositoryProperties, TagProperties, RegistryArtifactProperties
 
 if TYPE_CHECKING:
     from typing import Any, Dict
-    from azure.core.paging import ItemPaged
     from azure.core.credentials import TokenCredential
     from ._models import ContentPermissions
 
@@ -130,27 +138,112 @@ def list_registry_artifacts(self, **kwargs):
 
         :keyword last: Query parameter for the last item in the previous query
         :type last: str
-        :keyword page_size: Number of items per page
-        :type page_size: int
+        :keyword results_per_page: Number of items per page
+        :type results_per_page: int
         :keyword orderby: Order by query parameter
         :type orderby: :class:~azure.containerregistry.RegistryArtifactOrderBy
         :returns: ~azure.core.paging.ItemPaged[RegistryArtifactProperties]
         :raises: None
         """
-        # GET /acr/v1/{name}/_manifests
+        name = self.repository
         last = kwargs.pop("last", None)
-        n = kwargs.pop("page_size", None)
+        n = kwargs.pop("results_per_page", None)
         orderby = kwargs.pop("order_by", None)
-        return self._client.container_registry_repository.get_manifests(
-            self.repository,
-            last=last,
-            n=n,
-            orderby=orderby,
-            cls=lambda objs: [
-                RegistryArtifactProperties._from_generated(x) for x in objs  # pylint: disable=protected-access
-            ],
+        cls = kwargs.pop(
+            "cls", lambda objs: [RegistryArtifactProperties._from_generated(x) for x in objs]  # pylint: disable=protected-access
         )
 
+        error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError}
+        error_map.update(kwargs.pop("error_map", {}))
+        accept = "application/json"
+
+        def prepare_request(next_link=None):
+            # Construct headers
+            header_parameters = {}  # type: Dict[str, Any]
+            header_parameters["Accept"] = self._client._serialize.header(  # pylint: disable=protected-access
+                "accept", accept, "str"
+            )
+
+            if not next_link:
+                # Construct URL
+                url = "/acr/v1/{name}/_manifests"
+                path_format_arguments = {
+                    "url": self._client._serialize.url(  # pylint: disable=protected-access
+                        "self._client._config.url",
+                        self._client._config.url,  # pylint: disable=protected-access
+                        "str",
+                        skip_quote=True,
+                    ),
+                    "name": self._client._serialize.url("name", name, "str"),  # pylint: disable=protected-access
+                }
+                url = self._client._client.format_url(url, **path_format_arguments)  # pylint: disable=protected-access
+                # Construct parameters
+                query_parameters = {}  # type: Dict[str, Any]
+                if last is not None:
+                    query_parameters["last"] = self._client._serialize.query(  # pylint: disable=protected-access
+                        "last", last, "str"
+                    )
+                if n is not None:
+                    query_parameters["n"] = self._client._serialize.query(  # pylint: disable=protected-access
+                        "n", n, "int"
+                    )
+                if orderby is not None:
+                    query_parameters["orderby"] = self._client._serialize.query(  # pylint: disable=protected-access
+                        "orderby", orderby, "str"
+                    )
+
+                request = self._client._client.get(  # pylint: disable=protected-access
+                    url, query_parameters, header_parameters
+                )
+            else:
+                url = next_link
+                query_parameters = {}  # type: Dict[str, Any]
+                path_format_arguments = {
+                    "url": self._client._serialize.url(  # pylint: disable=protected-access
+                        "self._client._config.url",
+                        self._client._config.url,  # pylint: disable=protected-access
+                        "str",
+                        skip_quote=True,
+                    ),
+                    "name": self._client._serialize.url("name", name, "str"),  # pylint: disable=protected-access
+                }
+                url = self._client._client.format_url(url, **path_format_arguments)  # pylint: disable=protected-access
+                request = self._client._client.get(  # pylint: disable=protected-access
+                    url, query_parameters, header_parameters
+                )
+            return request
+
+        def extract_data(pipeline_response):
+            deserialized = self._client._deserialize(  # pylint: disable=protected-access
+                "AcrManifests", pipeline_response
+            )
+            list_of_elem = deserialized.manifests
+            if cls:
+                list_of_elem = cls(list_of_elem)
+            link = None
+            if "Link" in pipeline_response.http_response.headers.keys():
+                link = _parse_next_link(pipeline_response.http_response.headers["Link"])
+            return link, iter(list_of_elem)
+
+        def get_next(next_link=None):
+            request = prepare_request(next_link)
+
+            pipeline_response = self._client._client._pipeline.run(  # pylint: disable=protected-access
+                request, stream=False, **kwargs
+            )
+            response = pipeline_response.http_response
+
+            if response.status_code not in [200]:
+                error = self._client._deserialize.failsafe_deserialize(  # pylint: disable=protected-access
+                    AcrErrors, response
+                )
+                map_error(status_code=response.status_code, response=response, error_map=error_map)
+                raise HttpResponseError(response=response, model=error)
+
+            return pipeline_response
+
+        return ItemPaged(get_next, extract_data)
+
     @distributed_trace
     def list_tags(self, **kwargs):
         # type: (...) -> ItemPaged[TagProperties]
@@ -159,20 +252,115 @@ def list_tags(self, **kwargs):
         :param last: Query parameter for the last item in the previous call. Ensuing
             call will return values after last lexically
         :type last: str
-        :param order_by: Query paramter for ordering by time ascending or descending
+        :keyword order_by: Query paramter for ordering by time ascending or descending
+        :type order_by: :class:~azure.containerregistry.TagOrderBy
+        :keyword digest: Digest to filter on
+        :type digest: str
         :returns: ~azure.core.paging.ItemPaged[TagProperties]
         :raises: None
         """
-        return self._client.container_registry_repository.get_tags(
-            self.repository,
-            last=kwargs.pop("last", None),
-            n=kwargs.pop("page_size", None),
-            orderby=kwargs.pop("order_by", None),
-            digest=kwargs.pop("digest", None),
-            cls=lambda objs: [TagProperties._from_generated(o) for o in objs],  # pylint: disable=protected-access
-            **kwargs
+        name = self.repository
+        last = kwargs.pop("last", None)
+        n = kwargs.pop("results_per_page", None)
+        orderby = kwargs.pop("order_by", None)
+        digest = kwargs.pop("digest", None)
+        cls = kwargs.pop(
+            "cls", lambda objs: [TagProperties._from_generated(o) for o in objs]  # pylint: disable=protected-access
         )
 
+        error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError}
+        error_map.update(kwargs.pop("error_map", {}))
+        accept = "application/json"
+
+        def prepare_request(next_link=None):
+            # Construct headers
+            header_parameters = {}  # type: Dict[str, Any]
+            header_parameters["Accept"] = self._client._serialize.header(  # pylint: disable=protected-access
+                "accept", accept, "str"
+            )
+
+            if not next_link:
+                # Construct URL
+                url = "/acr/v1/{name}/_tags"
+                path_format_arguments = {
+                    "url": self._client._serialize.url(  # pylint: disable=protected-access
+                        "self._config.url",
+                        self._client._config.url,  # pylint: disable=protected-access
+                        "str",
+                        skip_quote=True,
+                    ),
+                    "name": self._client._serialize.url("name", name, "str"),  # pylint: disable=protected-access
+                }
+                url = self._client._client.format_url(url, **path_format_arguments)  # pylint: disable=protected-access
+                # Construct parameters
+                query_parameters = {}  # type: Dict[str, Any]
+                if last is not None:
+                    query_parameters["last"] = self._client._serialize.query(  # pylint: disable=protected-access
+                        "last", last, "str"
+                    )
+                if n is not None:
+                    query_parameters["n"] = self._client._serialize.query(  # pylint: disable=protected-access
+                        "n", n, "int"
+                    )
+                if orderby is not None:
+                    query_parameters["orderby"] = self._client._serialize.query(  # pylint: disable=protected-access
+                        "orderby", orderby, "str"
+                    )
+                if digest is not None:
+                    query_parameters["digest"] = self._client._serialize.query(  # pylint: disable=protected-access
+                        "digest", digest, "str"
+                    )
+
+                request = self._client._client.get(  # pylint: disable=protected-access
+                    url, query_parameters, header_parameters
+                )
+            else:
+                url = next_link
+                query_parameters = {}  # type: Dict[str, Any]
+                path_format_arguments = {
+                    "url": self._client._serialize.url(  # pylint: disable=protected-access
+                        "self._client._config.url",
+                        self._client._config.url,  # pylint: disable=protected-access
+                        "str",
+                        skip_quote=True,
+                    ),
+                    "name": self._client._serialize.url("name", name, "str"),  # pylint: disable=protected-access
+                }
+                url = self._client._client.format_url(url, **path_format_arguments)  # pylint: disable=protected-access
+                request = self._client._client.get(  # pylint: disable=protected-access
+                    url, query_parameters, header_parameters
+                )
+            return request
+
+        def extract_data(pipeline_response):
+            deserialized = self._client._deserialize("TagList", pipeline_response)  # pylint: disable=protected-access
+            list_of_elem = deserialized.tags
+            if cls:
+                list_of_elem = cls(list_of_elem)
+            link = None
+            if "Link" in pipeline_response.http_response.headers.keys():
+                link = _parse_next_link(pipeline_response.http_response.headers["Link"])
+            return link, iter(list_of_elem)
+
+        def get_next(next_link=None):
+            request = prepare_request(next_link)
+
+            pipeline_response = self._client._client._pipeline.run(  # pylint: disable=protected-access
+                request, stream=False, **kwargs
+            )
+            response = pipeline_response.http_response
+
+            if response.status_code not in [200]:
+                error = self._client._deserialize.failsafe_deserialize(  # pylint: disable=protected-access
+                    AcrErrors, response
+                )
+                map_error(status_code=response.status_code, response=response, error_map=error_map)
+                raise HttpResponseError(response=response, model=error)
+
+            return pipeline_response
+
+        return ItemPaged(get_next, extract_data)
+
     @distributed_trace
     def set_manifest_properties(self, digest, permissions, **kwargs):
         # type: (str, ContentPermissions) -> None