@autorest/python 6.1.6 → 6.1.7

package/autorest/codegen/__init__.py

@@ -44,9 +44,9 @@ def _validate_code_model_options(options: Dict[str, Any]) -> None:
             "or 'embedded'"
         )
 
-    if options["models_mode"] not in ["msrest", "none"]:
+    if options["models_mode"] not in ["msrest", "dpg", "none"]:
         raise ValueError(
-            "--models-mode can only be 'msrest' or 'none'. "
+            "--models-mode can only be 'msrest', 'dpg' or 'none'. "
             "Pass in 'msrest' if you want msrest models, or "
             "'none' if you don't want any."
         )
@@ -179,6 +179,8 @@ class CodeGenerator(Plugin):
         models_mode_default = (
             "none" if low_level_client or version_tolerant else "msrest"
         )
+        if self.options.get("cadl_file") is not None:
+            models_mode_default = "dpg"
 
         options: Dict[str, Any] = {
             "azure_arm": azure_arm,

package/autorest/codegen/models/__init__.py

@@ -158,7 +158,7 @@ def build_type(yaml_data: Dict[str, Any], code_model: CodeModel) -> BaseType:
         code_model.types_map[yaml_id] = response
         response.fill_instance_from_yaml(yaml_data, code_model)
     else:
-        object_type = yaml_data.get("type", None)
+        object_type = yaml_data.get("type")
         if object_type is None:
             _LOGGER.warning(
                 'Unrecognized definition type "%s" is found, falling back it as "string"! ',

package/autorest/codegen/models/client.py

@@ -108,7 +108,6 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
             f"{self.code_model.client.name}Configuration",
             ImportType.LOCAL,
         )
-
         file_import.add_msrest_import(
             self.code_model,
             ".." if async_mode else ".",
@@ -148,7 +147,10 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
                 ImportType.LOCAL,
             )
 
-        if self.code_model.model_types and self.code_model.options["models_mode"]:
+        if (
+            self.code_model.model_types
+            and self.code_model.options["models_mode"] == "msrest"
+        ):
             path_to_models = ".." if async_mode else "."
             if len(self.code_model.model_types) != len(
                 self.code_model.public_model_types
@@ -167,7 +169,7 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
                 file_import.add_submodule_import(
                     path_to_models, "models", ImportType.LOCAL
                 )
-        else:
+        elif self.code_model.options["models_mode"] == "msrest":
             # in this case, we have client_models = {} in the service client, which needs a type annotation
             # this import will always be commented, so will always add it to the typing section
             file_import.add_submodule_import(

package/autorest/codegen/models/combined_type.py

@@ -4,7 +4,7 @@
 # license information.
 # --------------------------------------------------------------------------
 from typing import Any, Dict, List, Optional, TYPE_CHECKING
-
+import re
 from autorest.codegen.models.imports import FileImport, ImportType
 from .base_type import BaseType
 
@@ -67,9 +67,11 @@ class CombinedType(BaseType):
         Special case for enum, for instance: Union[str, "EnumName"]
         """
         kwargs["is_operation_file"] = True
-        return (
-            f'Union[{", ".join(type.type_annotation(**kwargs) for type in self.types)}]'
-        )
+        inside_types = [type.type_annotation(**kwargs) for type in self.types]
+
+        # If the inside types has been a Union, peel first and then re-union
+        pattern = re.compile(r"Union\[.*\]")
+        return f'Union[{", ".join(map(lambda x: x[6: -1] if pattern.match(x) else x, inside_types))}]'
 
     def get_json_template_representation(
         self,

package/autorest/codegen/models/enum_type.py

@@ -107,10 +107,12 @@ class EnumType(BaseType):
         :rtype: str
         """
         if self.code_model.options["models_mode"]:
-            return (
-                f"Union[{self.value_type.type_annotation(**kwargs)},"
-                f' "_models.{self.name}"]'
-            )
+            model_name = f"_models.{self.name}"
+            # we don't need quoted annotation in operation files, and need it in model folder files.
+            if not kwargs.get("is_operation_file", False):
+                model_name = f'"{model_name}"'
+
+            return f"Union[{self.value_type.type_annotation(**kwargs)}, {model_name}]"
         return self.value_type.type_annotation(**kwargs)
 
     def get_declaration(self, value: Any) -> str:

package/autorest/codegen/models/model_type.py

@@ -8,6 +8,7 @@ from typing import Any, Dict, List, Optional, TYPE_CHECKING, cast
 
 from autorest.codegen.models.utils import add_to_pylint_disable
 from .base_type import BaseType
+from .constant_type import ConstantType
 from .property import Property
 from .imports import FileImport, ImportType, TypingSection
 
@@ -32,7 +33,9 @@ def _get_properties(type: "ModelType", properties: List[Property]) -> List[Prope
     return properties
 
 
-class ModelType(BaseType):  # pylint: disable=too-many-instance-attributes
+class ModelType(
+    BaseType
+):  # pylint: disable=too-many-instance-attributes, too-many-public-methods
     """Represents a class ready to be serialized in Python.
 
     :param str name: The name of the class.
@@ -71,14 +74,16 @@ class ModelType(BaseType):  # pylint: disable=too-many-instance-attributes
 
     @property
     def serialization_type(self) -> str:
-        if self.code_model.options["models_mode"]:
-            return (
-                self.name
-                if self.is_public
-                else f"{self.code_model.models_filename}.{self.name}"
-            )
+        if self.code_model.options["models_mode"] == "msrest":
+            return f"{'' if self.is_public else (self.code_model.models_filename + '.')}{self.name}"
+        if self.code_model.options["models_mode"] == "dpg":
+            return f"{'' if self.is_public else '_models.'}_models.{self.name}"
         return "object"
 
+    @property
+    def is_polymorphic(self) -> bool:
+        return any(p.is_polymorphic for p in self.properties)
+
     def type_annotation(self, **kwargs: Any) -> str:
         if self.code_model.options["models_mode"]:
             is_operation_file = kwargs.pop("is_operation_file", False)
@@ -229,10 +234,26 @@ class ModelType(BaseType):  # pylint: disable=too-many-instance-attributes
         except StopIteration:
             return None
 
+    @property
+    def discriminator_property(self) -> Optional[Property]:
+        try:
+            return next(
+                p
+                for p in self.properties
+                if p.is_discriminator
+                and isinstance(p.type, ConstantType)
+                and p.type.value == self.discriminator_value
+            )
+        except StopIteration:
+            return None
+
     @property
     def instance_check_template(self) -> str:
-        if self.code_model.options["models_mode"]:
+        models_mode = self.code_model.options["models_mode"]
+        if models_mode == "msrest":
             return "isinstance({}, msrest.Model)"
+        if models_mode == "dpg":
+            return "isinstance({}, _model_base.Model)"
         return "isinstance({}, MutableMapping)"
 
     @property
@@ -257,7 +278,7 @@ class ModelType(BaseType):  # pylint: disable=too-many-instance-attributes
             file_import.add_submodule_import(
                 relative_path, "models", ImportType.LOCAL, alias="_models"
             )
-        if self.code_model.options["models_mode"]:
+        if self.code_model.options["models_mode"] == "msrest":
             return file_import
         file_import.add_submodule_import(
             "typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL

package/autorest/codegen/models/operation.py

@@ -154,6 +154,14 @@ class OperationBase(  # pylint: disable=too-many-public-methods
         retval = self._response_docstring_helper("docstring_text", **kwargs)
         if not self.code_model.options["version_tolerant"]:
             retval += " or the result of cls(response)"
+        if self.code_model.options["models_mode"] == "dpg" and any(
+            isinstance(r.type, ModelType) for r in self.responses
+        ):
+            r = next(r for r in self.responses if isinstance(r.type, ModelType))
+            type_name = getattr(r, "item_type", getattr(r, "type")).docstring_text(
+                **kwargs
+            )
+            retval += f". The {type_name} is compatible with MutableMapping"
         return retval
 
     def response_docstring_type(self, **kwargs) -> str:
@@ -461,6 +469,19 @@ class Operation(OperationBase[Response]):
             and not self.code_model.options["models_mode"]
         ):
             file_import.add_submodule_import("typing", "cast", ImportType.STDLIB)
+        if self.code_model.options["models_mode"] == "dpg":
+            relative_path = "..." if async_mode else ".."
+            if self.parameters.has_body:
+                file_import.add_submodule_import(
+                    f"{relative_path}_model_base", "AzureJSONEncoder", ImportType.LOCAL
+                )
+                file_import.add_import("json", ImportType.STDLIB)
+            if self.default_error_deserialization or any(
+                [r.type for r in self.responses]
+            ):
+                file_import.add_submodule_import(
+                    f"{relative_path}_model_base", "_deserialize", ImportType.LOCAL
+                )
 
         return file_import
 

package/autorest/codegen/models/operation_group.py

@@ -80,13 +80,12 @@ class OperationGroup(BaseModel):
                 operation.imports(async_mode, relative_path=relative_path)
             )
         # for multiapi
-        if not self.code_model.options["version_tolerant"]:
-            if (
-                self.code_model.model_types or self.code_model.enums
-            ) and self.code_model.options["models_mode"]:
-                file_import.add_submodule_import(
-                    relative_path, "models", ImportType.LOCAL, alias="_models"
-                )
+        if (
+            self.code_model.model_types or self.code_model.enums
+        ) and self.code_model.options["models_mode"] == "msrest":
+            file_import.add_submodule_import(
+                relative_path, "models", ImportType.LOCAL, alias="_models"
+            )
         if self.code_model.need_mixin_abc:
             file_import.add_submodule_import(".._vendor", "MixinABC", ImportType.LOCAL)
         if self.has_abstract_operations:

package/autorest/codegen/models/parameter.py

@@ -5,6 +5,7 @@
 # --------------------------------------------------------------------------
 import abc
 from enum import Enum, auto
+import re
 
 from typing import (
     Dict,
@@ -21,6 +22,8 @@ from .imports import FileImport, ImportType
 from .base_model import BaseModel
 from .base_type import BaseType
 from .constant_type import ConstantType
+from .model_type import ModelType
+from .combined_type import CombinedType
 from .utils import add_to_description
 
 if TYPE_CHECKING:
@@ -235,6 +238,40 @@ class BodyParameter(_BodyParameterBase):
             type=code_model.lookup_type(id(yaml_data["type"])),
         )
 
+    def type_annotation(self, **kwargs: Any) -> str:
+        annotation = super().type_annotation(**kwargs)
+        model_seq = BodyParameter.get_model_seq(self.type)
+        if self.code_model.options["models_mode"] == "dpg" and model_seq >= 0:
+            pattern = re.compile(r"Union\[.*\]")
+            union_content = (
+                annotation[6:-1] if pattern.match(annotation) else annotation
+            )
+            items = union_content.split(", ")
+            items.insert(model_seq + 1, "JSON")
+            annotation = f'Union[{", ".join(items)}]'
+        return annotation
+
+    def docstring_type(self, **kwargs: Any) -> str:
+        docstring = super().docstring_type(**kwargs)
+        model_seq = BodyParameter.get_model_seq(self.type)
+        if self.code_model.options["models_mode"] == "dpg" and model_seq >= 0:
+            items = docstring.split(" or ")
+            items.insert(model_seq + 1, "JSON")
+            docstring = " or ".join(items)
+        return docstring
+
+    @staticmethod
+    def get_model_seq(t: BaseType):
+        if isinstance(t, ModelType):
+            return 0
+        if isinstance(t, CombinedType):
+            sub_num = len(t.types)
+            for i in range(sub_num):
+                sub_seq = BodyParameter.get_model_seq(t.types[i])
+                if sub_seq >= 0:
+                    return i + sub_seq
+        return -1
+
 
 EntryBodyParameterType = TypeVar(
     "EntryBodyParameterType", bound=Union[BodyParameter, "RequestBuilderBodyParameter"]

package/autorest/codegen/models/property.py

@@ -29,6 +29,7 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
         self.type = type
         self.optional: bool = self.yaml_data["optional"]
         self.readonly: bool = self.yaml_data.get("readonly", False)
+        self.is_polymorphic: bool = self.yaml_data.get("isPolymorphic", False)
         self.is_discriminator: bool = yaml_data.get("isDiscriminator", False)
         self.client_default_value = yaml_data.get("clientDefaultValue", None)
         if self.client_default_value is None:
@@ -45,7 +46,7 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
     def description(self, *, is_operation_file: bool) -> str:
         from .model_type import ModelType
 
-        description = self.yaml_data["description"]
+        description = self.yaml_data.get("description", "")
         if not (self.optional or self.client_default_value):
             description = add_to_description(description, "Required.")
         # don't want model type documentation as part of property doc
@@ -124,20 +125,6 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
         retval.update(self.type.validation or {})
         return retval or None
 
-    @property
-    def attribute_map(self) -> str:
-        if self.flattened_names:
-            attribute_key = ".".join(
-                n.replace(".", "\\\\.") for n in self.flattened_names
-            )
-        else:
-            attribute_key = self.rest_api_name.replace(".", "\\\\.")
-        if self.type.xml_serialization_ctxt:
-            xml_metadata = f", 'xml': {{{self.type.xml_serialization_ctxt}}}"
-        else:
-            xml_metadata = ""
-        return f'"{self.client_name}": {{"key": "{attribute_key}", "type": "{self.serialization_type}"{xml_metadata}}},'
-
     def imports(self) -> FileImport:
         from .model_type import ModelType
 
@@ -152,6 +139,12 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
                 TypingSection.TYPING,
                 alias="_models",
             )
+        if self.code_model.options["models_mode"] == "dpg":
+            file_import.add_submodule_import(
+                ".._model_base",
+                "rest_discriminator" if self.is_discriminator else "rest_field",
+                ImportType.LOCAL,
+            )
         return file_import
 
     @classmethod

package/autorest/codegen/models/request_builder_parameter.py

@@ -24,8 +24,10 @@ class RequestBuilderBodyParameter(BodyParameter):
 
     def __init__(self, *args, **kwargs) -> None:
         super().__init__(*args, **kwargs)
-        if isinstance(self.type, (BinaryType, StringType)) or any(
-            "xml" in ct for ct in self.content_types
+        if (
+            isinstance(self.type, (BinaryType, StringType))
+            or any("xml" in ct for ct in self.content_types)
+            or self.code_model.options["models_mode"] == "dpg"
         ):
             self.client_name = "content"
         else:

package/autorest/codegen/serializers/__init__.py

@@ -16,7 +16,7 @@ from ..models import TokenCredentialType
 from .enum_serializer import EnumSerializer
 from .general_serializer import GeneralSerializer
 from .model_init_serializer import ModelInitSerializer
-from .model_serializer import ModelSerializer
+from .model_serializer import DpgModelSerializer, MsrestModelSerializer
 from .operations_init_serializer import OperationsInitSerializer
 from .operation_groups_serializer import OperationGroupsSerializer
 from .metadata_serializer import MetadataSerializer
@@ -215,10 +215,15 @@ class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
     ) -> None:
         # Write the models folder
         models_path = namespace_path / Path("models")
+        serializer = (
+            DpgModelSerializer
+            if self.code_model.options["models_mode"] == "dpg"
+            else MsrestModelSerializer
+        )
         if self.code_model.model_types:
             self.write_file(
                 models_path / Path(f"{self.code_model.models_filename}.py"),
-                ModelSerializer(code_model=self.code_model, env=env).serialize(),
+                serializer(code_model=self.code_model, env=env).serialize(),
             )
         if self.code_model.enums:
             self.write_file(
@@ -427,6 +432,11 @@ class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
                 namespace_path / Path("_serialization.py"),
                 general_serializer.serialize_serialization_file(),
             )
+        if self.code_model.options["models_mode"] == "dpg":
+            self.write_file(
+                namespace_path / Path("_model_base.py"),
+                general_serializer.serialize_model_base_file(),
+            )
 
         if any(og for og in self.code_model.operation_groups if og.need_validation):
             self.write_file(

package/autorest/codegen/serializers/builder_serializer.py

@@ -674,7 +674,7 @@ class _OperationSerializer(
         ser_ctxt_name = "serialization_ctxt"
         if xml_serialization_ctxt and self.code_model.options["models_mode"]:
             retval.append(f'{ser_ctxt_name} = {{"xml": {{{xml_serialization_ctxt}}}}}')
-        if self.code_model.options["models_mode"]:
+        if self.code_model.options["models_mode"] == "msrest":
             is_xml_cmd = ", is_xml=True" if send_xml else ""
             serialization_ctxt_cmd = (
                 f", {ser_ctxt_name}={ser_ctxt_name}" if xml_serialization_ctxt else ""
@@ -683,6 +683,8 @@ class _OperationSerializer(
                 f"_{body_kwarg_name} = self._serialize.body({body_param.client_name}, "
                 f"'{body_param.type.serialization_type}'{is_xml_cmd}{serialization_ctxt_cmd})"
             )
+        elif self.code_model.options["models_mode"] == "dpg":
+            create_body_call = f"_{body_kwarg_name} = json.dumps({body_param.client_name}, cls=AzureJSONEncoder)"
         else:
             create_body_call = f"_{body_kwarg_name} = {body_param.client_name}"
         if body_param.optional:
@@ -747,10 +749,12 @@ class _OperationSerializer(
                 0
             ].parameters.body_parameter.default_content_type
             retval.append(f'content_type = content_type or "{default_content_type}"')
-        for overload in builder.overloads:
-            retval.append(
-                f"_{overload.request_builder.parameters.body_parameter.client_name} = None"
-            )
+        client_names = [
+            overload.request_builder.parameters.body_parameter.client_name
+            for overload in builder.overloads
+        ]
+        for v in sorted(set(client_names), key=client_names.index):
+            retval.append(f"_{v} = None")
         try:
             # if there is a binary overload, we do a binary check first.
             binary_overload = cast(
@@ -959,10 +963,16 @@ class _OperationSerializer(
                 )
             )
         elif response.type:
-            if self.code_model.options["models_mode"]:
+            if self.code_model.options["models_mode"] == "msrest":
                 retval.append(
                     f"deserialized = self._deserialize('{response.serialization_type}', pipeline_response)"
                 )
+            elif self.code_model.options["models_mode"] == "dpg" and isinstance(
+                response.type, ModelType
+            ):
+                retval.append(
+                    f"deserialized = _deserialize({response.serialization_type}, response.json())"
+                )
             else:
                 deserialized_value = (
                     "ET.fromstring(response.text())"
@@ -987,10 +997,15 @@ class _OperationSerializer(
             builder.default_error_deserialization
             and self.code_model.options["models_mode"]
         ):
-            retval.append(
-                f"    error = self._deserialize.failsafe_deserialize({builder.default_error_deserialization}, "
-                "pipeline_response)"
-            )
+            if self.code_model.options["models_mode"] == "dpg":
+                retval.append(
+                    f"    error = _deserialize({builder.default_error_deserialization},  response.json())"
+                )
+            else:
+                retval.append(
+                    f"    error = self._deserialize.failsafe_deserialize({builder.default_error_deserialization}, "
+                    "pipeline_response)"
+                )
             error_model = ", model=error"
         retval.append(
             "    raise HttpResponseError(response=response{}{})".format(
@@ -1065,11 +1080,14 @@ class _OperationSerializer(
                 retval.append("    304: ResourceNotModifiedError,")
             for excep in builder.non_default_errors:
                 error_model_str = ""
-                if (
-                    isinstance(excep.type, ModelType)
-                    and self.code_model.options["models_mode"]
-                ):
-                    error_model_str = f", model=self._deserialize(_models.{excep.type.serialization_type}, response)"
+                if isinstance(excep.type, ModelType):
+                    if self.code_model.options["models_mode"] == "msrest":
+                        error_model_str = (
+                            f", model=self._deserialize("
+                            f"_models.{excep.type.serialization_type}, response)"
+                        )
+                    elif self.code_model.options["models_mode"] == "dpg":
+                        error_model_str = f", model=_deserialize(_models.{excep.type.name}, response.json())"
                 error_format_str = (
                     ", error_format=ARMErrorFormat"
                     if self.code_model.options["azure_arm"]
@@ -1238,11 +1256,15 @@ class _PagingOperationSerializer(
             f"{'async ' if self.async_mode else ''}def extract_data(pipeline_response):"
         ]
         response = builder.responses[0]
-        deserialized = (
-            f'self._deserialize("{response.serialization_type}", pipeline_response)'
-            if self.code_model.options["models_mode"]
-            else "pipeline_response.http_response.json()"
-        )
+        deserialized = "pipeline_response.http_response.json()"
+        if self.code_model.options["models_mode"] == "msrest":
+            deserialized = (
+                f'self._deserialize("{response.serialization_type}", pipeline_response)'
+            )
+        elif self.code_model.options["models_mode"] == "dpg":
+            deserialized = (
+                f"_deserialize({response.serialization_type}, pipeline_response)"
+            )
         retval.append(f"    deserialized = {deserialized}")
         item_name = builder.item_name
         list_of_elem = (

package/autorest/codegen/serializers/client_serializer.py

@@ -125,11 +125,10 @@ class ClientSerializer:
             )
         else:
             client_models_value = "{}  # type: Dict[str, Any]"
-        if self.code_model.options["models_mode"]:
+        is_msrest_model = self.code_model.options["models_mode"] == "msrest"
+        if is_msrest_model:
             retval.append(f"client_models = {client_models_value}")
-        client_models_str = (
-            "client_models" if self.code_model.options["models_mode"] else ""
-        )
+        client_models_str = "client_models" if is_msrest_model else ""
         retval.append(f"self._serialize = Serializer({client_models_str})")
         retval.append(f"self._deserialize = Deserializer({client_models_str})")
         if not self.code_model.options["client_side_validation"]:

package/autorest/codegen/serializers/general_serializer.py

@@ -121,6 +121,10 @@ class GeneralSerializer:
         template = self.env.get_template("serialization.py.jinja2")
         return template.render(code_model=self.code_model)
 
+    def serialize_model_base_file(self) -> str:
+        template = self.env.get_template("model_base.py.jinja2")
+        return template.render(code_model=self.code_model)
+
     def serialize_validation_file(self) -> str:
         template = self.env.get_template("validation.py.jinja2")
         return template.render(code_model=self.code_model)