Dont generate maxpagesize

ChangeLog.md

@@ -1,5 +1,21 @@
 # Release History
 
+### 2022-06-24 - 6.0.0
+
+| Library                                                                 | Min Version |
+| ----------------------------------------------------------------------- | ----------- |
+| `@autorest/core`                                                        | `3.8.1`     |
+| `@autorest/modelerfour`                                                 | `4.23.5`    |
+| `azure-core` dep of generated code                                      | `1.24.0`    |
+| `isodate` dep of generated code                                         | `0.6.1`     |
+| `msrest` dep of generated code (If generating legacy code)              | `0.7.1`     |
+| `azure-mgmt-core` dep of generated code (If generating mgmt plane code) | `1.3.0`     |
+
+**Breaking Changes**
+
+- Don't generate paging variables `maxpagesize` for DPG generations. Users should pass in `maxpagesize` to the `by_page` method of their
+pager  #1320
+
 ### 2022-06-17 - 6.0.0-rc.1
 
 | Library                                                                 | Min Version |

autorest/preprocess/__init__.py

@@ -12,6 +12,16 @@
 from .. import YamlUpdatePlugin
 
 
+def _remove_paging_maxpagesize(yaml_data: Dict[str, Any]) -> None:
+    # we don't expose maxpagesize for version tolerant generation
+    # users should be passing this into `by_page`
+    yaml_data["parameters"] = [
+        p
+        for p in yaml_data.get("parameters", [])
+        if p["restApiName"].lower() not in ["maxpagesize", "$maxpagesize"]
+    ]
+
+
 def update_description(
     description: Optional[str], default_description: str = ""
 ) -> str:
@@ -85,6 +95,10 @@ def update_paging_response(yaml_data: Dict[str, Any]) -> None:
 class PreProcessPlugin(YamlUpdatePlugin):
     """Add Python naming information."""
 
+    @property
+    def version_tolerant(self) -> bool:
+        return bool(self._autorestapi.get_boolean_value("version-tolerant", True))
+
     def get_operation_updater(
         self, yaml_data: Dict[str, Any]
     ) -> Callable[[Dict[str, Any]], None]:
@@ -167,15 +181,18 @@ def update_paging_operation(self, yaml_data: Dict[str, Any]) -> None:
             if yaml_data.get("nextOperation")
             else yaml_data["responses"][0]
         )
-        # if we're in version tolerant, hide the paging model
-        if self._autorestapi.get_boolean_value("version-tolerant"):
+        if self.version_tolerant:
+            # if we're in version tolerant, hide the paging model
             returned_response_object["type"]["isPublic"] = False
+            _remove_paging_maxpagesize(yaml_data)
         item_type = next(
             p["type"]["elementType"]
             for p in returned_response_object["type"]["properties"]
             if p["restApiName"] == (yaml_data.get("itemName") or "value")
         )
         if yaml_data.get("nextOperation"):
+            if self.version_tolerant:
+                _remove_paging_maxpagesize(yaml_data["nextOperation"])
             yaml_data["nextOperation"]["groupName"] = pad_reserved_words(
                 yaml_data["nextOperation"]["groupName"], PadType.OPERATION_GROUP
             )

package.json

@@ -27,7 +27,7 @@
         "@autorest/system-requirements": "~1.0.0"
     },
     "devDependencies": {
-        "@microsoft.azure/autorest.testserver": "^3.3.30"
+        "@microsoft.azure/autorest.testserver": "^3.3.31"
     },
     "files": [
         "autorest/**/*.py",

test/azure/legacy/AcceptanceTests/test_zzz.py

@@ -41,6 +41,7 @@ def test_ensure_coverage(self):
         # Add tests that wont be supported due to the nature of Python here
         not_supported = {
             "LROPatchInlineCompleteIgnoreHeaders": 1,
+            "PagingDontSendMaxPageSize": 1,  # we're still sending maxpagesize in legacy
         }
 
         # Please add missing features or failing tests here

test/azure/legacy/Expected/AcceptanceTests/CustomPollerPager/custompollerpager/aio/operations/_paging_operations.py

@@ -53,6 +53,7 @@
     build_next_fragment_request,
     build_next_fragment_with_grouping_request,
     build_next_operation_with_query_params_request,
+    build_page_with_max_page_size_request,
     build_replace_api_version_request,
 )
 
@@ -564,6 +565,74 @@ async def get_next(next_link=None):
 
     duplicate_params.metadata = {"url": "/paging/multiple/duplicateParams/1"}  # type: ignore
 
+    @distributed_trace
+    def page_with_max_page_size(self, maxpagesize: str = "5", **kwargs: Any) -> AsyncIterable["_models.Product"]:
+        """Paging with max page size. We don't want to.
+
+        :param maxpagesize: Max page size query param. Don't send. Known values are "5" and None.
+         Default value is "5".
+        :type maxpagesize: str
+        :keyword callable cls: A custom type or function that will be passed the direct response
+        :return: An iterator like instance of either Product or the result of cls(response)
+        :rtype: ~azure.core.async_paging.AsyncItemPaged[~custompollerpager.models.Product]
+        :raises ~azure.core.exceptions.HttpResponseError:
+        """
+        _headers = kwargs.pop("headers", {}) or {}
+        _params = kwargs.pop("params", {}) or {}
+
+        cls = kwargs.pop("cls", None)  # type: ClsType[_models.ProductResult]
+
+        error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError}
+        error_map.update(kwargs.pop("error_map", {}) or {})
+
+        def prepare_request(next_link=None):
+            if not next_link:
+
+                request = build_page_with_max_page_size_request(
+                    maxpagesize=maxpagesize,
+                    template_url=self.page_with_max_page_size.metadata["url"],
+                    headers=_headers,
+                    params=_params,
+                )
+                request = _convert_request(request)
+                request.url = self._client.format_url(request.url)  # type: ignore
+
+            else:
+                # make call to next link with the client's api-version
+                _parsed_next_link = urlparse(next_link)
+                _next_request_params = case_insensitive_dict(parse_qs(_parsed_next_link.query))
+                _next_request_params["api-version"] = self._config.api_version
+                request = HttpRequest("GET", urljoin(next_link, _parsed_next_link.path), params=_next_request_params)
+                request = _convert_request(request)
+                request.url = self._client.format_url(request.url)  # type: ignore
+                request.method = "GET"
+            return request
+
+        async def extract_data(pipeline_response):
+            deserialized = self._deserialize("ProductResult", pipeline_response)
+            list_of_elem = deserialized.values
+            if cls:
+                list_of_elem = cls(list_of_elem)
+            return deserialized.next_link or None, AsyncList(list_of_elem)
+
+        async def get_next(next_link=None):
+            request = prepare_request(next_link)
+
+            pipeline_response = await self._client._pipeline.run(  # type: ignore # pylint: disable=protected-access
+                request, stream=False, **kwargs
+            )
+            response = pipeline_response.http_response
+
+            if response.status_code not in [200]:
+                map_error(status_code=response.status_code, response=response, error_map=error_map)
+                raise HttpResponseError(response=response, error_format=ARMErrorFormat)
+
+            return pipeline_response
+
+        return AsyncItemPaged(get_next, extract_data)
+
+    page_with_max_page_size.metadata = {"url": "/paging/maxPageSize"}  # type: ignore
+
     @distributed_trace
     def get_odata_multiple_pages(
         self,

test/azure/legacy/Expected/AcceptanceTests/CustomPollerPager/custompollerpager/operations/_paging_operations.py

@@ -174,6 +174,25 @@ def build_duplicate_params_request(*, filter: Optional[str] = None, **kwargs: An
     return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs)
 
 
+def build_page_with_max_page_size_request(*, maxpagesize: str = "5", **kwargs: Any) -> HttpRequest:
+    _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
+    _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+
+    accept = _headers.pop("Accept", "application/json")
+
+    # Construct URL
+    _url = kwargs.pop("template_url", "/paging/maxPageSize")
+
+    # Construct parameters
+    if maxpagesize is not None:
+        _params["$maxpagesize"] = _SERIALIZER.query("maxpagesize", maxpagesize, "str")
+
+    # Construct headers
+    _headers["Accept"] = _SERIALIZER.header("accept", accept, "str")
+
+    return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs)
+
+
 def build_get_odata_multiple_pages_request(
     *, client_request_id: Optional[str] = None, maxresults: Optional[int] = None, timeout: int = 30, **kwargs: Any
 ) -> HttpRequest:
@@ -974,6 +993,74 @@ def get_next(next_link=None):
 
     duplicate_params.metadata = {"url": "/paging/multiple/duplicateParams/1"}  # type: ignore
 
+    @distributed_trace
+    def page_with_max_page_size(self, maxpagesize: str = "5", **kwargs: Any) -> Iterable["_models.Product"]:
+        """Paging with max page size. We don't want to.
+
+        :param maxpagesize: Max page size query param. Don't send. Known values are "5" and None.
+         Default value is "5".
+        :type maxpagesize: str
+        :keyword callable cls: A custom type or function that will be passed the direct response
+        :return: An iterator like instance of either Product or the result of cls(response)
+        :rtype: ~azure.core.paging.ItemPaged[~custompollerpager.models.Product]
+        :raises ~azure.core.exceptions.HttpResponseError:
+        """
+        _headers = kwargs.pop("headers", {}) or {}
+        _params = kwargs.pop("params", {}) or {}
+
+        cls = kwargs.pop("cls", None)  # type: ClsType[_models.ProductResult]
+
+        error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError}
+        error_map.update(kwargs.pop("error_map", {}) or {})
+
+        def prepare_request(next_link=None):
+            if not next_link:
+
+                request = build_page_with_max_page_size_request(
+                    maxpagesize=maxpagesize,
+                    template_url=self.page_with_max_page_size.metadata["url"],
+                    headers=_headers,
+                    params=_params,
+                )
+                request = _convert_request(request)
+                request.url = self._client.format_url(request.url)  # type: ignore
+
+            else:
+                # make call to next link with the client's api-version
+                _parsed_next_link = urlparse(next_link)
+                _next_request_params = case_insensitive_dict(parse_qs(_parsed_next_link.query))
+                _next_request_params["api-version"] = self._config.api_version
+                request = HttpRequest("GET", urljoin(next_link, _parsed_next_link.path), params=_next_request_params)
+                request = _convert_request(request)
+                request.url = self._client.format_url(request.url)  # type: ignore
+                request.method = "GET"
+            return request
+
+        def extract_data(pipeline_response):
+            deserialized = self._deserialize("ProductResult", pipeline_response)
+            list_of_elem = deserialized.values
+            if cls:
+                list_of_elem = cls(list_of_elem)
+            return deserialized.next_link or None, iter(list_of_elem)
+
+        def get_next(next_link=None):
+            request = prepare_request(next_link)
+
+            pipeline_response = self._client._pipeline.run(  # type: ignore # pylint: disable=protected-access
+                request, stream=False, **kwargs
+            )
+            response = pipeline_response.http_response
+
+            if response.status_code not in [200]:
+                map_error(status_code=response.status_code, response=response, error_map=error_map)
+                raise HttpResponseError(response=response, error_format=ARMErrorFormat)
+
+            return pipeline_response
+
+        return ItemPaged(get_next, extract_data)
+
+    page_with_max_page_size.metadata = {"url": "/paging/maxPageSize"}  # type: ignore
+
     @distributed_trace
     def get_odata_multiple_pages(
         self,

test/azure/legacy/Expected/AcceptanceTests/Paging/paging/aio/operations/_paging_operations.py

@@ -51,6 +51,7 @@
     build_next_fragment_request,
     build_next_fragment_with_grouping_request,
     build_next_operation_with_query_params_request,
+    build_page_with_max_page_size_request,
     build_replace_api_version_request,
 )
 
@@ -561,6 +562,74 @@ async def get_next(next_link=None):
 
     duplicate_params.metadata = {"url": "/paging/multiple/duplicateParams/1"}  # type: ignore
 
+    @distributed_trace
+    def page_with_max_page_size(self, maxpagesize: str = "5", **kwargs: Any) -> AsyncIterable["_models.Product"]:
+        """Paging with max page size. We don't want to.
+
+        :param maxpagesize: Max page size query param. Don't send. Known values are "5" and None.
+         Default value is "5".
+        :type maxpagesize: str
+        :keyword callable cls: A custom type or function that will be passed the direct response
+        :return: An iterator like instance of either Product or the result of cls(response)
+        :rtype: ~azure.core.async_paging.AsyncItemPaged[~paging.models.Product]
+        :raises ~azure.core.exceptions.HttpResponseError:
+        """
+        _headers = kwargs.pop("headers", {}) or {}
+        _params = kwargs.pop("params", {}) or {}
+
+        cls = kwargs.pop("cls", None)  # type: ClsType[_models.ProductResult]
+
+        error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError}
+        error_map.update(kwargs.pop("error_map", {}) or {})
+
+        def prepare_request(next_link=None):
+            if not next_link:
+
+                request = build_page_with_max_page_size_request(
+                    maxpagesize=maxpagesize,
+                    template_url=self.page_with_max_page_size.metadata["url"],
+                    headers=_headers,
+                    params=_params,
+                )
+                request = _convert_request(request)
+                request.url = self._client.format_url(request.url)  # type: ignore
+
+            else:
+                # make call to next link with the client's api-version
+                _parsed_next_link = urlparse(next_link)
+                _next_request_params = case_insensitive_dict(parse_qs(_parsed_next_link.query))
+                _next_request_params["api-version"] = self._config.api_version
+                request = HttpRequest("GET", urljoin(next_link, _parsed_next_link.path), params=_next_request_params)
+                request = _convert_request(request)
+                request.url = self._client.format_url(request.url)  # type: ignore
+                request.method = "GET"
+            return request
+
+        async def extract_data(pipeline_response):
+            deserialized = self._deserialize("ProductResult", pipeline_response)
+            list_of_elem = deserialized.values
+            if cls:
+                list_of_elem = cls(list_of_elem)
+            return deserialized.next_link or None, AsyncList(list_of_elem)
+
+        async def get_next(next_link=None):
+            request = prepare_request(next_link)
+
+            pipeline_response = await self._client._pipeline.run(  # type: ignore # pylint: disable=protected-access
+                request, stream=False, **kwargs
+            )
+            response = pipeline_response.http_response
+
+            if response.status_code not in [200]:
+                map_error(status_code=response.status_code, response=response, error_map=error_map)
+                raise HttpResponseError(response=response)
+
+            return pipeline_response
+
+        return AsyncItemPaged(get_next, extract_data)
+
+    page_with_max_page_size.metadata = {"url": "/paging/maxPageSize"}  # type: ignore
+
     @distributed_trace
     def get_odata_multiple_pages(
         self,