diff --git a/ChangeLog.md b/ChangeLog.md index cefcfd9c19c..54754bbecdc 100644 --- a/ChangeLog.md +++ b/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 | diff --git a/autorest/preprocess/__init__.py b/autorest/preprocess/__init__.py index a73cdd751c8..a1ca0fb3bed 100644 --- a/autorest/preprocess/__init__.py +++ b/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 ) diff --git a/package.json b/package.json index da96aef454d..b40063b095d 100644 --- a/package.json +++ b/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", diff --git a/test/azure/legacy/AcceptanceTests/test_zzz.py b/test/azure/legacy/AcceptanceTests/test_zzz.py index 76900bb6cf8..fe7465b4e32 100644 --- a/test/azure/legacy/AcceptanceTests/test_zzz.py +++ b/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 diff --git a/test/azure/legacy/Expected/AcceptanceTests/CustomPollerPager/custompollerpager/aio/operations/_paging_operations.py b/test/azure/legacy/Expected/AcceptanceTests/CustomPollerPager/custompollerpager/aio/operations/_paging_operations.py index 9def3c95f30..a6c67cfa2fc 100644 --- a/test/azure/legacy/Expected/AcceptanceTests/CustomPollerPager/custompollerpager/aio/operations/_paging_operations.py +++ b/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, diff --git a/test/azure/legacy/Expected/AcceptanceTests/CustomPollerPager/custompollerpager/operations/_paging_operations.py b/test/azure/legacy/Expected/AcceptanceTests/CustomPollerPager/custompollerpager/operations/_paging_operations.py index 01bc882c82b..4c555728e08 100644 --- a/test/azure/legacy/Expected/AcceptanceTests/CustomPollerPager/custompollerpager/operations/_paging_operations.py +++ b/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, diff --git a/test/azure/legacy/Expected/AcceptanceTests/Paging/paging/aio/operations/_paging_operations.py b/test/azure/legacy/Expected/AcceptanceTests/Paging/paging/aio/operations/_paging_operations.py index a833f096b33..a8b10ec7ca1 100644 --- a/test/azure/legacy/Expected/AcceptanceTests/Paging/paging/aio/operations/_paging_operations.py +++ b/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, diff --git a/test/azure/legacy/Expected/AcceptanceTests/Paging/paging/operations/_paging_operations.py b/test/azure/legacy/Expected/AcceptanceTests/Paging/paging/operations/_paging_operations.py index 188312508eb..fa38f9b4b80 100644 --- a/test/azure/legacy/Expected/AcceptanceTests/Paging/paging/operations/_paging_operations.py +++ b/test/azure/legacy/Expected/AcceptanceTests/Paging/paging/operations/_paging_operations.py @@ -172,6 +172,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: @@ -971,6 +990,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[~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 + + 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) + + 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, diff --git a/test/azure/version-tolerant/AcceptanceTests/asynctests/test_paging.py b/test/azure/version-tolerant/AcceptanceTests/asynctests/test_paging.py index cc34b41860a..b89ef028668 100644 --- a/test/azure/version-tolerant/AcceptanceTests/asynctests/test_paging.py +++ b/test/azure/version-tolerant/AcceptanceTests/asynctests/test_paging.py @@ -235,6 +235,10 @@ async def test_duplicate_params(client): assert pages[0]["properties"]["id"] == 1 assert pages[0]["properties"]["name"] == "Product" +@pytest.mark.asyncio +async def test_dont_send_maxpagesize(client): + [p async for p in client.paging.page_with_max_page_size()] + @pytest.mark.asyncio async def test_append_api_version(client): pages = [p async for p in client.paging.append_api_version()] diff --git a/test/azure/version-tolerant/AcceptanceTests/test_paging.py b/test/azure/version-tolerant/AcceptanceTests/test_paging.py index 601a2c80fa8..bf626893db9 100644 --- a/test/azure/version-tolerant/AcceptanceTests/test_paging.py +++ b/test/azure/version-tolerant/AcceptanceTests/test_paging.py @@ -171,6 +171,9 @@ def test_duplicate_params(client): assert pages[0]["properties"]["id"] == 1 assert pages[0]["properties"]["name"] == "Product" +def test_dont_send_maxpagesize(client): + list(client.paging.page_with_max_page_size()) + def test_append_api_version(client): pages = list(client.paging.append_api_version()) assert len(pages) == 1 diff --git a/test/azure/version-tolerant/Expected/AcceptanceTests/CustomPollerPagerVersionTolerant/custompollerpagerversiontolerant/aio/operations/_operations.py b/test/azure/version-tolerant/Expected/AcceptanceTests/CustomPollerPagerVersionTolerant/custompollerpagerversiontolerant/aio/operations/_operations.py index 163474cd428..2aae62d7260 100644 --- a/test/azure/version-tolerant/Expected/AcceptanceTests/CustomPollerPagerVersionTolerant/custompollerpagerversiontolerant/aio/operations/_operations.py +++ b/test/azure/version-tolerant/Expected/AcceptanceTests/CustomPollerPagerVersionTolerant/custompollerpagerversiontolerant/aio/operations/_operations.py @@ -52,6 +52,7 @@ build_paging_next_fragment_request, build_paging_next_fragment_with_grouping_request, build_paging_next_operation_with_query_params_request, + build_paging_page_with_max_page_size_request, build_paging_replace_api_version_request, ) @@ -600,6 +601,75 @@ async def get_next(next_link=None): return AsyncItemPaged(get_next, extract_data) + @distributed_trace + def page_with_max_page_size(self, **kwargs: Any) -> AsyncIterable[JSON]: + """Paging with max page size. We don't want to. + + :return: An iterator like instance of JSON object + :rtype: ~azure.core.async_paging.AsyncItemPaged[JSON] + :raises ~azure.core.exceptions.HttpResponseError: + + Example: + .. code-block:: python + + # response body for status code(s): 200 + response == { + "properties": { + "id": 0, # Optional. + "name": "str" # Optional. + } + } + """ + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls = kwargs.pop("cls", None) # type: ClsType[JSON] + + 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_paging_page_with_max_page_size_request( + headers=_headers, + params=_params, + ) + 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.url = self._client.format_url(request.url) # type: ignore + + return request + + async def extract_data(pipeline_response): + deserialized = pipeline_response.http_response.json() + list_of_elem = deserialized["values"] + if cls: + list_of_elem = cls(list_of_elem) + return deserialized.get("nextLink", 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) + @distributed_trace def get_odata_multiple_pages( self, diff --git a/test/azure/version-tolerant/Expected/AcceptanceTests/CustomPollerPagerVersionTolerant/custompollerpagerversiontolerant/operations/_operations.py b/test/azure/version-tolerant/Expected/AcceptanceTests/CustomPollerPagerVersionTolerant/custompollerpagerversiontolerant/operations/_operations.py index c8c735ed34d..1251aac919f 100644 --- a/test/azure/version-tolerant/Expected/AcceptanceTests/CustomPollerPagerVersionTolerant/custompollerpagerversiontolerant/operations/_operations.py +++ b/test/azure/version-tolerant/Expected/AcceptanceTests/CustomPollerPagerVersionTolerant/custompollerpagerversiontolerant/operations/_operations.py @@ -179,6 +179,20 @@ def build_paging_duplicate_params_request(*, filter: Optional[str] = None, **kwa return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) +def build_paging_page_with_max_page_size_request(**kwargs: Any) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = "/paging/maxPageSize" + + # Construct headers + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, headers=_headers, **kwargs) + + def build_paging_get_odata_multiple_pages_request( *, client_request_id: Optional[str] = None, maxresults: Optional[int] = None, timeout: int = 30, **kwargs: Any ) -> HttpRequest: @@ -1013,6 +1027,75 @@ def get_next(next_link=None): return ItemPaged(get_next, extract_data) + @distributed_trace + def page_with_max_page_size(self, **kwargs: Any) -> Iterable[JSON]: + """Paging with max page size. We don't want to. + + :return: An iterator like instance of JSON object + :rtype: ~azure.core.paging.ItemPaged[JSON] + :raises ~azure.core.exceptions.HttpResponseError: + + Example: + .. code-block:: python + + # response body for status code(s): 200 + response == { + "properties": { + "id": 0, # Optional. + "name": "str" # Optional. + } + } + """ + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls = kwargs.pop("cls", None) # type: ClsType[JSON] + + 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_paging_page_with_max_page_size_request( + headers=_headers, + params=_params, + ) + 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.url = self._client.format_url(request.url) # type: ignore + + return request + + def extract_data(pipeline_response): + deserialized = pipeline_response.http_response.json() + list_of_elem = deserialized["values"] + if cls: + list_of_elem = cls(list_of_elem) + return deserialized.get("nextLink", 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) + @distributed_trace def get_odata_multiple_pages( self, diff --git a/test/azure/version-tolerant/Expected/AcceptanceTests/PagingVersionTolerant/pagingversiontolerant/aio/operations/_operations.py b/test/azure/version-tolerant/Expected/AcceptanceTests/PagingVersionTolerant/pagingversiontolerant/aio/operations/_operations.py index 6547a7d08b0..fce2453f027 100644 --- a/test/azure/version-tolerant/Expected/AcceptanceTests/PagingVersionTolerant/pagingversiontolerant/aio/operations/_operations.py +++ b/test/azure/version-tolerant/Expected/AcceptanceTests/PagingVersionTolerant/pagingversiontolerant/aio/operations/_operations.py @@ -50,6 +50,7 @@ build_paging_next_fragment_request, build_paging_next_fragment_with_grouping_request, build_paging_next_operation_with_query_params_request, + build_paging_page_with_max_page_size_request, build_paging_replace_api_version_request, ) @@ -598,6 +599,75 @@ async def get_next(next_link=None): return AsyncItemPaged(get_next, extract_data) + @distributed_trace + def page_with_max_page_size(self, **kwargs: Any) -> AsyncIterable[JSON]: + """Paging with max page size. We don't want to. + + :return: An iterator like instance of JSON object + :rtype: ~azure.core.async_paging.AsyncItemPaged[JSON] + :raises ~azure.core.exceptions.HttpResponseError: + + Example: + .. code-block:: python + + # response body for status code(s): 200 + response == { + "properties": { + "id": 0, # Optional. + "name": "str" # Optional. + } + } + """ + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls = kwargs.pop("cls", None) # type: ClsType[JSON] + + 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_paging_page_with_max_page_size_request( + headers=_headers, + params=_params, + ) + 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.url = self._client.format_url(request.url) # type: ignore + + return request + + async def extract_data(pipeline_response): + deserialized = pipeline_response.http_response.json() + list_of_elem = deserialized["values"] + if cls: + list_of_elem = cls(list_of_elem) + return deserialized.get("nextLink", 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) + @distributed_trace def get_odata_multiple_pages( self, diff --git a/test/azure/version-tolerant/Expected/AcceptanceTests/PagingVersionTolerant/pagingversiontolerant/operations/_operations.py b/test/azure/version-tolerant/Expected/AcceptanceTests/PagingVersionTolerant/pagingversiontolerant/operations/_operations.py index 0b5b9fb08d2..590780f9b33 100644 --- a/test/azure/version-tolerant/Expected/AcceptanceTests/PagingVersionTolerant/pagingversiontolerant/operations/_operations.py +++ b/test/azure/version-tolerant/Expected/AcceptanceTests/PagingVersionTolerant/pagingversiontolerant/operations/_operations.py @@ -177,6 +177,20 @@ def build_paging_duplicate_params_request(*, filter: Optional[str] = None, **kwa return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) +def build_paging_page_with_max_page_size_request(**kwargs: Any) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = "/paging/maxPageSize" + + # Construct headers + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, headers=_headers, **kwargs) + + def build_paging_get_odata_multiple_pages_request( *, client_request_id: Optional[str] = None, maxresults: Optional[int] = None, timeout: int = 30, **kwargs: Any ) -> HttpRequest: @@ -1011,6 +1025,75 @@ def get_next(next_link=None): return ItemPaged(get_next, extract_data) + @distributed_trace + def page_with_max_page_size(self, **kwargs: Any) -> Iterable[JSON]: + """Paging with max page size. We don't want to. + + :return: An iterator like instance of JSON object + :rtype: ~azure.core.paging.ItemPaged[JSON] + :raises ~azure.core.exceptions.HttpResponseError: + + Example: + .. code-block:: python + + # response body for status code(s): 200 + response == { + "properties": { + "id": 0, # Optional. + "name": "str" # Optional. + } + } + """ + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls = kwargs.pop("cls", None) # type: ClsType[JSON] + + 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_paging_page_with_max_page_size_request( + headers=_headers, + params=_params, + ) + 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.url = self._client.format_url(request.url) # type: ignore + + return request + + def extract_data(pipeline_response): + deserialized = pipeline_response.http_response.json() + list_of_elem = deserialized["values"] + if cls: + list_of_elem = cls(list_of_elem) + return deserialized.get("nextLink", 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) + + return pipeline_response + + return ItemPaged(get_next, extract_data) + @distributed_trace def get_odata_multiple_pages( self,