@autorest/python 6.4.3 → 6.4.5

package/autorest/_utils.py

@@ -24,7 +24,6 @@ def to_snake_case(name: str) -> str:
             and len(name) - next_non_upper_case_char_location > 1
             and name[next_non_upper_case_char_location].isalpha()
         ):
-
             return (
                 prefix
                 + match_str[: len(match_str) - 1]

package/autorest/codegen/__init__.py

@@ -17,7 +17,6 @@ from ._utils import DEFAULT_HEADER_TEXT
 
 
 def _validate_code_model_options(options: Dict[str, Any]) -> None:
-
     if options["builders_visibility"] not in ["public", "hidden", "embedded"]:
         raise ValueError(
             "The value of --builders-visibility must be either 'public', 'hidden', "

package/autorest/codegen/models/model_type.py

@@ -163,7 +163,6 @@ class ModelType(  # pylint: disable=abstract-method
         )
 
     def get_polymorphic_subtypes(self, polymorphic_subtypes: List["ModelType"]) -> None:
-
         is_polymorphic_subtype = (
             self.discriminator_value and not self.discriminated_subtypes
         )

package/autorest/codegen/models/paging_operation.py

@@ -84,17 +84,28 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
         if not rest_api_name:
             # That's an ok scenario, it just means no next page possible
             return None
-        if self.code_model.options["models_mode"]:
+        if self.code_model.options["models_mode"] == "msrest":
             return self._get_attr_name(rest_api_name)
         return rest_api_name
 
     @property
     def item_name(self) -> str:
         rest_api_name = self.yaml_data["itemName"]
-        if self.code_model.options["models_mode"]:
+        if self.code_model.options["models_mode"] == "msrest":
+            # we don't use the paging model for dpg
             return self._get_attr_name(rest_api_name)
         return rest_api_name
 
+    @property
+    def item_type(self) -> ModelType:
+        try:
+            item_type_yaml = self.yaml_data["itemType"]
+        except KeyError as e:
+            raise ValueError(
+                "Only call this for DPG paging model deserialization"
+            ) from e
+        return cast(ModelType, self.code_model.types_map[id(item_type_yaml)])
+
     @property
     def operation_type(self) -> str:
         return "paging"
@@ -144,6 +155,8 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
             file_import.add_submodule_import(
                 "azure.core.utils", "case_insensitive_dict", ImportType.AZURECORE
             )
+        if self.code_model.options["models_mode"] == "dpg":
+            file_import.merge(self.item_type.imports(**kwargs))
         return file_import
 
 

package/autorest/codegen/models/parameter_list.py

@@ -118,9 +118,9 @@ class _ParameterListBase(
 
     @staticmethod
     @abstractmethod
-    def body_parameter_creator() -> Callable[
-        [Dict[str, Any], "CodeModel"], BodyParameterType
-    ]:
+    def body_parameter_creator() -> (
+        Callable[[Dict[str, Any], "CodeModel"], BodyParameterType]
+    ):
         """Callable for creating body parameters"""
 
     @property
@@ -317,9 +317,11 @@ class _ParameterList(
         return Parameter.from_yaml
 
     @staticmethod
-    def body_parameter_creator() -> Callable[
-        [Dict[str, Any], "CodeModel"], Union[MultipartBodyParameter, BodyParameter]
-    ]:
+    def body_parameter_creator() -> (
+        Callable[
+            [Dict[str, Any], "CodeModel"], Union[MultipartBodyParameter, BodyParameter]
+        ]
+    ):
         return get_body_parameter
 
     @property
@@ -345,15 +347,15 @@ class _RequestBuilderParameterList(
     """_RequestBuilderParameterList is base parameter list for RequestBuilder classes"""
 
     @staticmethod
-    def parameter_creator() -> Callable[
-        [Dict[str, Any], "CodeModel"], RequestBuilderParameter
-    ]:
+    def parameter_creator() -> (
+        Callable[[Dict[str, Any], "CodeModel"], RequestBuilderParameter]
+    ):
         return RequestBuilderParameter.from_yaml
 
     @staticmethod
-    def body_parameter_creator() -> Callable[
-        [Dict[str, Any], "CodeModel"], RequestBuilderBodyParameterType
-    ]:
+    def body_parameter_creator() -> (
+        Callable[[Dict[str, Any], "CodeModel"], RequestBuilderBodyParameterType]
+    ):
         return get_request_body_parameter
 
     @property
@@ -422,9 +424,9 @@ class _ClientGlobalParameterList(  # pylint: disable=abstract-method
     """Base parameter list for client and config classes"""
 
     @staticmethod
-    def body_parameter_creator() -> Callable[
-        [Dict[str, Any], "CodeModel"], BodyParameter
-    ]:
+    def body_parameter_creator() -> (
+        Callable[[Dict[str, Any], "CodeModel"], BodyParameter]
+    ):
         return BodyParameter.from_yaml
 
     @property

package/autorest/codegen/models/request_builder.py

@@ -121,9 +121,9 @@ class RequestBuilderBase(BaseBuilder[ParameterListType]):
 
     @staticmethod
     @abstractmethod
-    def parameter_list_type() -> Callable[
-        [Dict[str, Any], "CodeModel"], ParameterListType
-    ]:
+    def parameter_list_type() -> (
+        Callable[[Dict[str, Any], "CodeModel"], ParameterListType]
+    ):
         ...
 
     @classmethod
@@ -178,9 +178,9 @@ class RequestBuilderBase(BaseBuilder[ParameterListType]):
 
 class RequestBuilder(RequestBuilderBase[RequestBuilderParameterList]):
     @staticmethod
-    def parameter_list_type() -> Callable[
-        [Dict[str, Any], "CodeModel"], RequestBuilderParameterList
-    ]:
+    def parameter_list_type() -> (
+        Callable[[Dict[str, Any], "CodeModel"], RequestBuilderParameterList]
+    ):
         return RequestBuilderParameterList.from_yaml
 
 
@@ -188,9 +188,9 @@ class OverloadedRequestBuilder(
     RequestBuilderBase[OverloadedRequestBuilderParameterList]
 ):
     @staticmethod
-    def parameter_list_type() -> Callable[
-        [Dict[str, Any], "CodeModel"], OverloadedRequestBuilderParameterList
-    ]:
+    def parameter_list_type() -> (
+        Callable[[Dict[str, Any], "CodeModel"], OverloadedRequestBuilderParameterList]
+    ):
         return OverloadedRequestBuilderParameterList.from_yaml
 
 

package/autorest/codegen/serializers/builder_serializer.py

@@ -1066,13 +1066,14 @@ class _OperationSerializer(
                 deserialize_code.append(f"    deserialized = {deserialized_value}")
                 deserialize_code.append("else:")
                 deserialize_code.append("    deserialized = None")
-        if builder.expose_stream_keyword:
-            retval.append("if _stream:")
-            retval.append("    deserialized = response.iter_bytes()")
-            retval.append("else:")
-            retval.extend([f"    {dc}" for dc in deserialize_code])
-        else:
-            retval.extend(deserialize_code)
+        if len(deserialize_code) > 0:
+            if builder.expose_stream_keyword:
+                retval.append("if _stream:")
+                retval.append("    deserialized = response.iter_bytes()")
+                retval.append("else:")
+                retval.extend([f"    {dc}" for dc in deserialize_code])
+            else:
+                retval.extend(deserialize_code)
         return retval
 
     def handle_error_response(self, builder: OperationType) -> List[str]:
@@ -1384,32 +1385,32 @@ class _PagingOperationSerializer(
             deserialized = f"self._deserialize(\n    {deserialize_type}, pipeline_response{pylint_disable}\n)"
             retval.append(f"    deserialized = {deserialized}")
         elif self.code_model.options["models_mode"] == "dpg":
-            pylint_disable = (
-                "  # pylint: disable=protected-access\n"
-                if isinstance(response.type, ModelType) and not response.type.is_public
-                else ""
-            )
-            deserialized = f"_deserialize({response.serialization_type}{pylint_disable}, pipeline_response)"
-            retval.append(
-                f"    deserialized: {response.serialization_type} = ({pylint_disable}"
-            )
-            retval.append(f"        {deserialized})")
+            # we don't want to generate paging models for DPG
+            retval.append(f"    deserialized = {deserialized}")
         else:
             retval.append(f"    deserialized = {deserialized}")
         item_name = builder.item_name
-        list_of_elem = (
+        access = (
             f".{item_name}"
-            if self.code_model.options["models_mode"]
+            if self.code_model.options["models_mode"] == "msrest"
             else f'["{item_name}"]'
         )
-        retval.append(f"    list_of_elem = deserialized{list_of_elem}")
+        list_of_elem_deserialized = ""
+        if self.code_model.options["models_mode"] == "dpg":
+            item_type = builder.item_type.type_annotation(is_operation_file=True)
+            list_of_elem_deserialized = (
+                f"_deserialize({item_type}, deserialized{access})"
+            )
+        else:
+            list_of_elem_deserialized = f"deserialized{access}"
+        retval.append(f"    list_of_elem = {list_of_elem_deserialized}")
         retval.append("    if cls:")
         retval.append("        list_of_elem = cls(list_of_elem) # type: ignore")
 
         continuation_token_name = builder.continuation_token_name
         if not continuation_token_name:
             cont_token_property = "None"
-        elif self.code_model.options["models_mode"]:
+        elif self.code_model.options["models_mode"] == "msrest":
             cont_token_property = f"deserialized.{continuation_token_name} or None"
         else:
             cont_token_property = (

package/autorest/codegen/serializers/general_serializer.py

@@ -83,7 +83,6 @@ class GeneralSerializer:
         )
 
     def serialize_service_client_file(self, clients: List[Client]) -> str:
-
         template = self.env.get_template("client_container.py.jinja2")
 
         imports = FileImport()

package/autorest/codegen/templates/serialization.py.jinja2

@@ -631,7 +631,7 @@ class Serializer(object):
                         if xml_desc.get("attr", False):
                             if xml_ns:
                                 ET.register_namespace(xml_prefix, xml_ns)
-                                xml_name = "{}{}".format(xml_ns, xml_name)
+                                xml_name = "{% raw %}{{{}}}{}{% endraw %}".format(xml_ns, xml_name)
                             serialized.set(xml_name, new_attr)  # type: ignore
                             continue
                         if xml_desc.get("text", False):
@@ -1273,7 +1273,7 @@ def _extract_name_from_internal_type(internal_type):
     xml_name = internal_type_xml_map.get("name", internal_type.__name__)
     xml_ns = internal_type_xml_map.get("ns", None)
     if xml_ns:
-        xml_name = "{}{}".format(xml_ns, xml_name)
+        xml_name = "{% raw %}{{{}}}{}{% endraw %}".format(xml_ns, xml_name)
     return xml_name
 
 
@@ -1297,7 +1297,7 @@ def xml_key_extractor(attr, attr_desc, data):
     # Integrate namespace if necessary
     xml_ns = xml_desc.get("ns", internal_type_xml_map.get("ns", None))
     if xml_ns:
-        xml_name = "{}{}".format(xml_ns, xml_name)
+        xml_name = "{% raw %}{{{}}}{}{% endraw %}".format(xml_ns, xml_name)
 
     # If it's an attribute, that's simple
     if xml_desc.get("attr", False):

package/autorest/jsonrpc/server.py

@@ -37,7 +37,6 @@ def Process(plugin_name: str, session_id: str) -> bool:
     from .stdstream import StdStreamAutorestAPI
 
     with contextlib.closing(StdStreamAutorestAPI(session_id)) as stdstream_connection:
-
         _LOGGER.debug(
             "Autorest called process with plugin_name '%s' and session_id: '%s'",
             plugin_name,

package/autorest/m4reformatter/__init__.py

@@ -595,6 +595,19 @@ class M4Reformatter(
         operation["continuationTokenName"] = yaml_data["extensions"][
             "x-ms-pageable"
         ].get("nextLinkName")
+        returned_response_object = (
+            operation["nextOperation"]["responses"][0]
+            if operation.get("nextOperation")
+            else operation["responses"][0]
+        )
+        if self.version_tolerant:
+            # if we're in version tolerant, hide the paging model
+            returned_response_object["type"]["isPublic"] = False
+        operation["itemType"] = next(
+            p["type"]
+            for p in returned_response_object["type"]["properties"]
+            if p["restApiName"] == operation["itemName"]
+        )
         if yaml_data["language"]["default"]["paging"].get("nextLinkOperation"):
             operation["nextOperation"] = self.update_operation(
                 group_name=group_name,

package/autorest/preprocess/__init__.py

@@ -356,26 +356,17 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
         code_model: Dict[str, Any],
         yaml_data: Dict[str, Any],
         is_overload: bool = False,
+        item_type: Optional[Dict[str, Any]] = None,
     ) -> None:
         self.update_operation(code_model, yaml_data, is_overload=is_overload)
         if not yaml_data.get("pagerSync"):
             yaml_data["pagerSync"] = "azure.core.paging.ItemPaged"
         if not yaml_data.get("pagerAsync"):
             yaml_data["pagerAsync"] = "azure.core.async_paging.AsyncItemPaged"
-        returned_response_object = (
-            yaml_data["nextOperation"]["responses"][0]
-            if yaml_data.get("nextOperation")
-            else yaml_data["responses"][0]
-        )
         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")
-        )
+        item_type = item_type or yaml_data["itemType"]["elementType"]
         if yaml_data.get("nextOperation"):
             if self.version_tolerant:
                 _remove_paging_maxpagesize(yaml_data["nextOperation"])
@@ -392,7 +383,9 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
             update_paging_response(response)
             response["itemType"] = item_type
         for overload in yaml_data.get("overloads", []):
-            self.update_paging_operation(code_model, overload, is_overload=True)
+            self.update_paging_operation(
+                code_model, overload, is_overload=True, item_type=item_type
+            )
 
     def update_operation_groups(
         self, code_model: Dict[str, Any], client: Dict[str, Any]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autorest/python",
-  "version": "6.4.3",
+  "version": "6.4.5",
   "description": "The Python extension for generators in AutoRest.",
   "main": "index.js",
   "repository": {