@autorest/python 6.13.0 → 6.13.1

package/autorest/codegen/models/combined_type.py

@@ -29,6 +29,7 @@ class CombinedType(BaseType):
         super().__init__(yaml_data, code_model)
         self.types = types  # the types that this type is combining
         self.name = yaml_data.get("name")
+        self._is_union_of_literals = all(i.type == "constant" for i in self.types)
 
     @property
     def serialization_type(self) -> str:
@@ -73,7 +74,20 @@ class CombinedType(BaseType):
 
         Special case for enum, for instance: Union[str, "EnumName"]
         """
-        inside_types = [type.type_annotation(**kwargs) for type in self.types]
+        # remove duplicates
+        inside_types = list(
+            dict.fromkeys([type.type_annotation(**kwargs) for type in self.types])
+        )
+        if len(inside_types) == 1:
+            return inside_types[0]
+        if self._is_union_of_literals:
+            parsed_values = []
+            for entry in inside_types:
+                match = re.search(r"Literal\[(.*)\]", entry)
+                if match is not None:
+                    parsed_values.append(match.group(1))
+            join_string = ", ".join(parsed_values)
+            return f"Literal[{join_string}]"
 
         # If the inside types has been a Union, peel first and then re-union
         pattern = re.compile(r"Union\[.*\]")
@@ -116,7 +130,8 @@ class CombinedType(BaseType):
             return file_import
         for type in self.types:
             file_import.merge(type.imports(**kwargs))
-        file_import.add_submodule_import("typing", "Union", ImportType.STDLIB)
+        if not self._is_union_of_literals:
+            file_import.add_submodule_import("typing", "Union", ImportType.STDLIB)
         return file_import
 
     @classmethod

package/autorest/codegen/models/model_type.py

@@ -76,6 +76,22 @@ class ModelType(  # pylint: disable=abstract-method
         self.snake_case_name: str = self.yaml_data["snakeCaseName"]
         self.page_result_model: bool = self.yaml_data.get("pageResultModel", False)
 
+    @property
+    def flattened_property(self) -> Optional[Property]:
+        try:
+            return next(p for p in self.properties if p.flatten)
+        except StopIteration:
+            return None
+
+    @property
+    def flattened_items(self) -> List[str]:
+        return [
+            item.client_name
+            for prop in self.properties
+            if isinstance(prop.type, ModelType) and prop.flatten
+            for item in prop.type.properties
+        ]
+
     @property
     def is_form_data(self) -> bool:
         return any(p.is_multipart_file_input for p in self.properties)
@@ -360,3 +376,9 @@ class DPGModelType(GeneratedModelType):
     @property
     def instance_check_template(self) -> str:
         return "isinstance({}, _model_base.Model)"
+
+    def imports(self, **kwargs: Any) -> FileImport:
+        file_import = super().imports(**kwargs)
+        if self.flattened_property:
+            file_import.add_submodule_import("typing", "Any", ImportType.STDLIB)
+        return file_import

package/autorest/codegen/models/property.py

@@ -40,6 +40,9 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
         self.is_multipart_file_input: bool = yaml_data.get(
             "isMultipartFileInput", False
         )
+        self.flatten = self.yaml_data.get("flatten", False) and not getattr(
+            self.type, "flattened_property", False
+        )
 
     @property
     def pylint_disable(self) -> str:

package/autorest/codegen/serializers/model_serializer.py

@@ -60,8 +60,8 @@ class _ModelSerializer(BaseSerializer, ABC):
     def variable_documentation_string(prop: Property) -> List[str]:
         return _documentation_string(prop, "ivar", "vartype")
 
-    def super_call(self, model: ModelType):
-        return f"super().__init__({self.properties_to_pass_to_super(model)})"
+    def super_call(self, model: ModelType) -> List[str]:
+        return [f"super().__init__({self.properties_to_pass_to_super(model)})"]
 
     @staticmethod
     def initialize_discriminator_property(model: ModelType, prop: Property) -> str:
@@ -197,8 +197,16 @@ class MsrestModelSerializer(_ModelSerializer):
 
 
 class DpgModelSerializer(_ModelSerializer):
-    def super_call(self, model: ModelType):
-        return f"super().__init__({self.properties_to_pass_to_super(model)})"
+    def super_call(self, model: ModelType) -> List[str]:
+        super_call = f"super().__init__({self.properties_to_pass_to_super(model)})"
+        if model.flattened_property:
+            return [
+                "_flattened_input = {k: kwargs.pop(k) for k in kwargs.keys() & self.__flattened_items}",
+                super_call,
+                "for k, v in _flattened_input.items():",
+                "    setattr(self, k, v)",
+            ]
+        return [super_call]
 
     def imports(self) -> FileImport:
         file_import = FileImport(self.code_model)

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

@@ -15,6 +15,7 @@ import base64
 import re
 import copy
 import typing
+import enum
 import email.utils
 from datetime import datetime, date, time, timedelta, timezone
 from json import JSONEncoder
@@ -451,6 +452,8 @@ def _serialize(o, format: typing.Optional[str] = None):  # pylint: disable=too-m
         return _serialize_bytes(o, format)
     if isinstance(o, decimal.Decimal):
         return float(o)
+    if isinstance(o, enum.Enum):
+        return o.value
     try:
         # First try datetime.datetime
         return _serialize_datetime(o, format)
@@ -663,8 +666,12 @@ def _get_deserialize_callable_from_annotation(  # pylint: disable=R0911, R0915,
         pass
 
     if getattr(annotation, "__origin__", None) is typing.Union:
+        # initial ordering is we make `string` the last deserialization option, because it is often them most generic
         deserializers = [
-            _get_deserialize_callable_from_annotation(arg, module, rf) for arg in annotation.__args__  # pyright: ignore
+            _get_deserialize_callable_from_annotation(arg, module, rf)
+            for arg in sorted(
+            annotation.__args__, key=lambda x: hasattr(x, "__name__") and x.__name__ == "str"  # pyright: ignore
+        )
         ]
 
         def _deserialize_with_union(deserializers, obj):
@@ -813,6 +820,10 @@ class _RestField:
         self._format = format
         self._is_multipart_file_input = is_multipart_file_input
 
+    @property
+    def _class_type(self) -> typing.Any:
+        return getattr(self._type, "args", [None])[0]
+
     @property
     def _rest_name(self) -> str:
         if self._rest_name_input is None:

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

@@ -39,6 +39,10 @@
         {% endif %}
     {% endfor %}
 
+    {% if code_model.options["models_mode"] == "dpg" and model.flattened_property %}
+    __flattened_items = ["{{ model.flattened_items|join('\", \"') }}"]
+    {% endif %}
+
     {% if not model.internal and serializer.init_line(model) %}
     @overload
     def __init__(
@@ -60,8 +64,27 @@
     {% set initialize_properties = serializer.initialize_properties(model) %}
     {% if not model.internal and serializer.init_line(model) or initialize_properties %}
     def __init__(self, *args: Any, **kwargs: Any) -> None:{{ '# pylint: disable=useless-super-delegation' if not initialize_properties else '' }}
-        {{ serializer.super_call(model) }}
-    {% for initialize_property in initialize_properties %}
+        {% for line in serializer.super_call(model) %}
+        {{ line }}
+        {% endfor %}
+        {% for initialize_property in initialize_properties %}
         {{ initialize_property }}
-    {% endfor %}
-    {% endif %}
+        {% endfor %}
+        {% if code_model.options["models_mode"] == "dpg" and model.flattened_property %}
+        {% set flattened_property_attr = model.flattened_property.client_name %}
+
+    def __getattr__(self, name: str) -> Any:
+        if name in self.__flattened_items:
+            if self.{{ flattened_property_attr }} is None: return None
+            return getattr(self.{{ flattened_property_attr }}, name)
+        raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{name}'")
+
+    def __setattr__(self, key: str, value: Any) -> None:
+        if key in self.__flattened_items:
+            if self.{{ flattened_property_attr }} is None:
+                self.{{ flattened_property_attr }} = self._attr_to_rest_field["{{ flattened_property_attr }}"]._class_type()
+            setattr(self.properties, key, value)
+        else:
+            super().__setattr__(key, value)
+        {% endif %} 
+    {% endif %} 

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

@@ -83,7 +83,9 @@
         {% endfor %}
     {% endif %}
         """
-        {{ serializer.super_call(model) }}
+    {% for line in serializer.super_call(model) %}
+        {{ line }}
+    {% endfor %}
     {% for initialize_property in initialize_properties %}
         {{ initialize_property }}
     {% endfor %}

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

@@ -1520,7 +1520,7 @@ class Deserializer(object):
                 return target, target
 
         try:
-            target = target._classify(data, self.dependencies)
+            target = target._classify(data, self.dependencies)  # type: ignore
         except AttributeError:
             pass  # Target is not a Model, no classify
         return target, target.__class__.__name__  # type: ignore

package/package.json

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