@autorest/python 6.1.5 → 6.1.7

package/autorest/codegen/serializers/builder_serializer.py

@@ -173,6 +173,22 @@ def _get_json_response_template_to_status_codes(
     return retval
 
 
+def _api_version_validation(builder: OperationType) -> str:
+    retval: List[str] = []
+    if builder.added_on:
+        retval.append(f'    method_added_on="{builder.added_on}",')
+    params_added_on = defaultdict(list)
+    for parameter in builder.parameters:
+        if parameter.added_on:
+            params_added_on[parameter.added_on].append(parameter.client_name)
+    if params_added_on:
+        retval.append(f"    params_added_on={dict(params_added_on)},")
+    if retval:
+        retval_str = "\n".join(retval)
+        return f"@api_version_validation(\n{retval_str}\n)"
+    return ""
+
+
 class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-method
     def __init__(self, code_model: CodeModel, async_mode: bool) -> None:
         self.code_model = code_model
@@ -590,8 +606,10 @@ class _OperationSerializer(
 
     def decorators(self, builder: OperationType) -> List[str]:
         """Decorators for the method"""
-        super_decorators = super().decorators(builder)
-        return super_decorators
+        retval = super().decorators(builder)
+        if _api_version_validation(builder):
+            retval.append(_api_version_validation(builder))
+        return retval
 
     def param_description(
         self, builder: OperationType
@@ -656,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 ""
@@ -665,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:
@@ -729,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(
@@ -941,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())"
@@ -969,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(
@@ -1047,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"]
@@ -1138,6 +1174,8 @@ class _PagingOperationSerializer(
             return ["@overload"]
         if self.code_model.options["tracing"] and builder.want_tracing:
             retval.append("@distributed_trace")
+        if _api_version_validation(builder):
+            retval.append(_api_version_validation(builder))
         return retval
 
     def call_next_link_request_builder(self, builder: PagingOperationType) -> List[str]:
@@ -1218,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

@@ -120,3 +120,11 @@ class GeneralSerializer:
     def serialize_serialization_file(self) -> str:
         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)

package/autorest/codegen/serializers/model_serializer.py

@@ -4,9 +4,10 @@
 # license information.
 # --------------------------------------------------------------------------
 from typing import cast, List
+from abc import ABC, abstractmethod
 from jinja2 import Environment
 from ..models import ModelType, CodeModel, Property
-from ..models.imports import FileImport, TypingSection, MsrestImportType
+from ..models.imports import FileImport, TypingSection, MsrestImportType, ImportType
 from .import_serializer import FileImportSerializer
 
 
@@ -26,11 +27,15 @@ def _documentation_string(
     return retval
 
 
-class ModelSerializer:
+class _ModelSerializer(ABC):
     def __init__(self, code_model: CodeModel, env: Environment) -> None:
         self.code_model = code_model
         self.env = env
 
+    @abstractmethod
+    def imports(self) -> FileImport:
+        ...
+
     def serialize(self) -> str:
         # Generate the models
         template = self.env.get_template("model_container.py.jinja2")
@@ -41,46 +46,13 @@ class ModelSerializer:
             serializer=self,
         )
 
-    def imports(self) -> FileImport:
-        file_import = FileImport()
-        file_import.add_msrest_import(
-            self.code_model, "..", MsrestImportType.Module, TypingSection.REGULAR
-        )
-        for model in self.code_model.model_types:
-            file_import.merge(model.imports(is_operation_file=False))
-            init_line_parameters = [
-                p for p in model.properties if not p.readonly and not p.is_discriminator
-            ]
-            for param in init_line_parameters:
-                file_import.merge(param.imports())
-        return file_import
+    @abstractmethod
+    def declare_model(self, model: ModelType) -> str:
+        ...
 
     @staticmethod
-    def get_properties_to_initialize(model: ModelType) -> List[Property]:
-        if model.parents:
-            properties_to_initialize = list(
-                {
-                    p.client_name: p
-                    for bm in model.parents
-                    for p in model.properties
-                    if p not in cast(ModelType, bm).properties
-                    or p.is_discriminator
-                    or p.constant
-                }.values()
-            )
-        else:
-            properties_to_initialize = model.properties
-        return properties_to_initialize
-
-    def declare_model(self, model: ModelType) -> str:
-        basename = (
-            "msrest.serialization.Model"
-            if self.code_model.options["client_side_validation"]
-            else "_serialization.Model"
-        )
-        if model.parents:
-            basename = ", ".join([cast(ModelType, m).name for m in model.parents])
-        return f"class {model.name}({basename}):{model.pylint_disable}"
+    def escape_dot(s: str):
+        return s.replace(".", "\\\\.")
 
     @staticmethod
     def input_documentation_string(prop: Property) -> List[str]:
@@ -94,27 +66,16 @@ class ModelSerializer:
     def super_call(self, model: ModelType):
         return f"super().__init__({self.properties_to_pass_to_super(model)})"
 
-    def initialize_properties(self, model: ModelType) -> List[str]:
-        init_args = []
-        for prop in self.get_properties_to_initialize(model):
-            if prop.is_discriminator:
-                discriminator_value = (
-                    f"'{model.discriminator_value}'"
-                    if model.discriminator_value
-                    else None
-                )
-                if not discriminator_value:
-                    typing = "Optional[str]"
-                else:
-                    typing = "str"
-                init_args.append(
-                    f"self.{prop.client_name} = {discriminator_value}  # type: {typing}"
-                )
-            elif prop.readonly:
-                init_args.append(f"self.{prop.client_name} = None")
-            elif not prop.constant:
-                init_args.append(f"self.{prop.client_name} = {prop.client_name}")
-        return init_args
+    @staticmethod
+    def initialize_discriminator_property(model: ModelType, prop: Property) -> str:
+        discriminator_value = (
+            f"'{model.discriminator_value}'" if model.discriminator_value else None
+        )
+        if not discriminator_value:
+            typing = "Optional[str]"
+        else:
+            typing = "str"
+        return f"self.{prop.client_name} = {discriminator_value}  # type: {typing}"
 
     @staticmethod
     def initialize_standard_property(prop: Property):
@@ -163,3 +124,140 @@ class ModelSerializer:
                     )
         properties_to_pass_to_super.append("**kwargs")
         return ", ".join(properties_to_pass_to_super)
+
+
+class MsrestModelSerializer(_ModelSerializer):
+    def imports(self) -> FileImport:
+        file_import = FileImport()
+        file_import.add_msrest_import(
+            self.code_model, "..", MsrestImportType.Module, TypingSection.REGULAR
+        )
+        for model in self.code_model.model_types:
+            file_import.merge(model.imports(is_operation_file=False))
+            init_line_parameters = [
+                p for p in model.properties if not p.readonly and not p.is_discriminator
+            ]
+            for param in init_line_parameters:
+                file_import.merge(param.imports())
+        return file_import
+
+    def declare_model(self, model: ModelType) -> str:
+        basename = (
+            "msrest.serialization.Model"
+            if self.code_model.options["client_side_validation"]
+            else "_serialization.Model"
+        )
+        if model.parents:
+            basename = ", ".join([cast(ModelType, m).name for m in model.parents])
+        return f"class {model.name}({basename}):{model.pylint_disable}"
+
+    @staticmethod
+    def get_properties_to_initialize(model: ModelType) -> List[Property]:
+        if model.parents:
+            properties_to_initialize = list(
+                {
+                    p.client_name: p
+                    for bm in model.parents
+                    for p in model.properties
+                    if p not in cast(ModelType, bm).properties
+                    or p.is_discriminator
+                    or p.constant
+                }.values()
+            )
+        else:
+            properties_to_initialize = model.properties
+        return properties_to_initialize
+
+    def initialize_properties(self, model: ModelType) -> List[str]:
+        init_args = []
+        for prop in self.get_properties_to_initialize(model):
+            if prop.is_discriminator:
+                init_args.append(self.initialize_discriminator_property(model, prop))
+            elif prop.readonly:
+                init_args.append(f"self.{prop.client_name} = None")
+            elif not prop.constant:
+                init_args.append(f"self.{prop.client_name} = {prop.client_name}")
+        return init_args
+
+    @staticmethod
+    def declare_property(prop: Property) -> str:
+        if prop.flattened_names:
+            attribute_key = ".".join(
+                _ModelSerializer.escape_dot(n) for n in prop.flattened_names
+            )
+        else:
+            attribute_key = _ModelSerializer.escape_dot(prop.rest_api_name)
+        if prop.type.xml_serialization_ctxt:
+            xml_metadata = f", 'xml': {{{prop.type.xml_serialization_ctxt}}}"
+        else:
+            xml_metadata = ""
+        return f'"{prop.client_name}": {{"key": "{attribute_key}", "type": "{prop.serialization_type}"{xml_metadata}}},'
+
+
+class DpgModelSerializer(_ModelSerializer):
+    def imports(self) -> FileImport:
+        file_import = FileImport()
+        file_import.add_submodule_import(
+            "..",
+            "_model_base",
+            ImportType.LOCAL,
+            TypingSection.REGULAR,
+        )
+        file_import.add_submodule_import("typing", "overload", ImportType.STDLIB)
+        file_import.add_submodule_import("typing", "Mapping", ImportType.STDLIB)
+        file_import.add_submodule_import("typing", "Any", ImportType.STDLIB)
+
+        for model in self.code_model.model_types:
+            file_import.merge(model.imports(is_operation_file=False))
+            for param in model.properties:
+                file_import.merge(param.imports())
+        return file_import
+
+    def declare_model(self, model: ModelType) -> str:
+        basename = "_model_base.Model"
+        if model.parents:
+            basename = ", ".join([cast(ModelType, m).name for m in model.parents])
+        if model.discriminator_value:
+            basename += f", discriminator='{model.discriminator_value}'"
+        return f"class {model.name}({basename}):{model.pylint_disable}"
+
+    @staticmethod
+    def get_properties_to_initialize(model: ModelType) -> List[Property]:
+        if model.parents:
+            properties_to_declare = [
+                p
+                for bm in model.parents
+                for p in model.properties
+                if p not in cast(ModelType, bm).properties
+            ]
+
+        else:
+            properties_to_declare = model.properties
+        if any(p for p in properties_to_declare if p.client_name == "_"):
+            raise ValueError("We do not generate anonymous properties")
+        return [
+            p
+            for p in properties_to_declare
+            if (not p.is_discriminator or p.is_polymorphic)
+        ]
+
+    @staticmethod
+    def declare_property(prop: Property) -> List[str]:
+        attribute_key = _ModelSerializer.escape_dot(prop.rest_api_name)
+        args = []
+        if prop.client_name != attribute_key:
+            args.append(f'name="{attribute_key}"')
+        if prop.readonly:
+            args.append("readonly=True")
+        if prop.client_default_value is not None:
+            args.append(f"default={prop.client_default_value_declaration}")
+
+        field = "rest_discriminator" if prop.is_discriminator else "rest_field"
+        ret = [
+            f"{prop.client_name}: {prop.type_annotation()} ="
+            f' {field}({", ".join(args)})'
+        ]
+        comment = prop.description(is_operation_file=False).replace('"', '\\"')
+        if comment:
+            ret.append(f'"""{comment}"""')
+        return ret