@autorest/python 6.12.4 → 6.13.1

package/autorest/codegen/models/__init__.py

@@ -133,9 +133,9 @@ TYPE_TO_OBJECT = {
     "binary": BinaryType,
     "any": AnyType,
     "datetime": DatetimeType,
-    "time": TimeType,
+    "plainTime": TimeType,
     "duration": DurationType,
-    "date": DateType,
+    "plainDate": DateType,
     "bytes": ByteArraySchema,
     "boolean": BooleanType,
     "combined": CombinedType,

package/autorest/codegen/models/base_builder.py

@@ -4,7 +4,17 @@
 # license information.
 # --------------------------------------------------------------------------
 import logging
-from typing import List, Dict, Any, Generic, TypeVar, Optional, Union, TYPE_CHECKING
+from typing import (
+    List,
+    Dict,
+    Any,
+    Generic,
+    TypeVar,
+    Optional,
+    Union,
+    TYPE_CHECKING,
+    cast,
+)
 from abc import abstractmethod
 
 from .base import BaseModel
@@ -28,11 +38,16 @@ if TYPE_CHECKING:
     from .operation import Operation
     from .request_builder import RequestBuilder
 
+
+OverloadListType = TypeVar(
+    "OverloadListType", bound=Union[List["Operation"], List["RequestBuilder"]]
+)
+
 _LOGGER = logging.getLogger(__name__)
 
 
 class BaseBuilder(
-    Generic[ParameterListType], BaseModel
+    Generic[ParameterListType, OverloadListType], BaseModel
 ):  # pylint: disable=too-many-instance-attributes
     """Base class for Operations and Request Builders"""
 
@@ -44,16 +59,14 @@ class BaseBuilder(
         name: str,
         parameters: ParameterListType,
         *,
-        overloads=None,
+        overloads: Optional[OverloadListType] = None,
     ) -> None:
         super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.client = client
         self.name = name
         self._description: str = yaml_data.get("description", "")
         self.parameters = parameters
-        self.overloads: Union[List["Operation"], List["RequestBuilder"]] = (
-            overloads or []
-        )
+        self.overloads = overloads or cast(OverloadListType, [])
         self._summary: str = yaml_data.get("summary", "")
         self.want_tracing: bool = yaml_data.get("wantTracing", True)
         self.group_name: str = yaml_data[

package/autorest/codegen/models/code_model.py

@@ -11,7 +11,6 @@ from .model_type import ModelType
 from .combined_type import CombinedType
 from .client import Client
 from .request_builder import RequestBuilder, OverloadedRequestBuilder
-from .constant_type import ConstantType
 
 
 def _is_legacy(options) -> bool:
@@ -279,25 +278,6 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
 
     @property
     def need_typing_extensions(self) -> bool:
-        if self.options["models_mode"] and any(
-            isinstance(p.type, ConstantType)
-            and (p.optional or self.options["models_mode"] == "dpg")
-            for model in self.model_types
-            for p in model.properties
-        ):
-            return True
-        if any(
-            isinstance(parameter.type, ConstantType)
-            for client in self.clients
-            for og in client.operation_groups
-            for op in og.operations
-            for parameter in op.parameters.method
-        ):
-            return True
-        if any(
-            isinstance(parameter.type, ConstantType)
-            for client in self.clients
-            for parameter in client.config.parameters.kwargs_to_pop
-        ):
+        if self.options["models_mode"] == "dpg":
             return True
         return False

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/operation.py

@@ -14,6 +14,7 @@ from typing import (
     Generic,
     TypeVar,
     cast,
+    Sequence,
 )
 
 from .request_builder_parameter import RequestBuilderParameter
@@ -54,7 +55,7 @@ def is_internal(target: Optional[BaseType]) -> bool:
 
 
 class OperationBase(  # pylint: disable=too-many-public-methods
-    Generic[ResponseType], BaseBuilder[ParameterList]
+    Generic[ResponseType], BaseBuilder[ParameterList, List["Operation"]]
 ):
     def __init__(
         self,
@@ -490,7 +491,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods
             ) from exc
 
     @property
-    def success_status_codes(self) -> List[Union[str, int]]:
+    def success_status_codes(self) -> Sequence[Union[str, int]]:
         """The list of all successfull status code."""
         return sorted(
             [code for response in self.responses for code in response.status_codes]

package/autorest/codegen/models/property.py

@@ -3,7 +3,7 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import Any, Dict, Optional, TYPE_CHECKING, List
+from typing import Any, Dict, Optional, TYPE_CHECKING, List, cast
 
 from .base import BaseModel
 from .constant_type import ConstantType
@@ -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:
@@ -96,6 +99,17 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
     def is_enum_discriminator(self) -> bool:
         return self.is_discriminator and self.type.type == "enum"
 
+    @property
+    def is_base_discriminator(self) -> bool:
+        """If this discriminator is on the base model for polymorphic inheritance"""
+        if self.is_enum_discriminator:
+            return self.is_polymorphic and self.client_default_value is None
+        return (
+            self.is_discriminator
+            and self.is_polymorphic
+            and cast(ConstantType, self.type).value is None
+        )
+
     def type_annotation(self, *, is_operation_file: bool = False) -> str:
         types_type_annotation = self.type.type_annotation(
             is_operation_file=is_operation_file
@@ -103,17 +117,13 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
         if self.is_multipart_file_input:
             # we only support FileType or list of FileType
             types_type_annotation = types_type_annotation.replace("bytes", "FileType")
-        if self.is_enum_discriminator:
-            # here we are the enum discriminator property on the base model
-            return "Literal[None]"
+        if self.is_base_discriminator:
+            return "str"
         if self.optional and self.client_default_value is None:
             return f"Optional[{types_type_annotation}]"
         return types_type_annotation
 
     def get_declaration(self, value: Any = None) -> Any:
-        if self.is_enum_discriminator:
-            # here we are the enum discriminator property on the base model
-            return None
         return self.type.get_declaration(value)
 
     def get_json_template_representation(

package/autorest/codegen/models/request_builder.py

@@ -33,7 +33,7 @@ ParameterListType = TypeVar(
 )
 
 
-class RequestBuilderBase(BaseBuilder[ParameterListType]):
+class RequestBuilderBase(BaseBuilder[ParameterListType, List["RequestBuilder"]]):
     def __init__(
         self,
         yaml_data: Dict[str, Any],

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,6 +197,17 @@ class MsrestModelSerializer(_ModelSerializer):
 
 
 class DpgModelSerializer(_ModelSerializer):
+    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)
         file_import.add_submodule_import(
@@ -238,6 +249,7 @@ class DpgModelSerializer(_ModelSerializer):
                 if not any(
                     p.client_name == pp.client_name
                     and p.type_annotation() == pp.type_annotation()
+                    and not p.is_base_discriminator
                     for pp in parent_properties
                 )
             ]
@@ -277,7 +289,7 @@ class DpgModelSerializer(_ModelSerializer):
     def initialize_properties(self, model: ModelType) -> List[str]:
         init_args = []
         for prop in self.get_properties_to_declare(model):
-            if prop.constant or prop.is_discriminator:
+            if prop.constant and not prop.is_base_discriminator:
                 init_args.append(
                     f"self.{prop.client_name}: {prop.type_annotation()} = "
                     f"{prop.get_declaration()}"
@@ -289,5 +301,30 @@ class DpgModelSerializer(_ModelSerializer):
         return [
             p
             for p in model.properties
-            if not p.is_discriminator and not p.constant and p.visibility != ["read"]
+            if p.is_base_discriminator
+            or not p.is_discriminator
+            and not p.constant
+            and p.visibility != ["read"]
         ]
+
+    @staticmethod
+    def properties_to_pass_to_super(model: ModelType) -> str:
+        properties_to_pass_to_super = ["*args"]
+        for parent in model.parents:
+            for prop in model.properties:
+                if (
+                    prop.client_name
+                    in [
+                        prop.client_name
+                        for prop in parent.properties
+                        if prop.is_base_discriminator
+                    ]
+                    and prop.is_discriminator
+                    and not prop.constant
+                    and not prop.readonly
+                ):
+                    properties_to_pass_to_super.append(
+                        f"{prop.client_name}={prop.get_declaration()}"
+                    )
+        properties_to_pass_to_super.append("**kwargs")
+        return ", ".join(properties_to_pass_to_super)

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

@@ -5,7 +5,6 @@
 # license information.
 # --------------------------------------------------------------------------
 # pylint: disable=protected-access, arguments-differ, signature-differs, broad-except
-# pyright: reportGeneralTypeIssues=false
 
 import calendar
 import decimal
@@ -16,9 +15,11 @@ 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
+from typing_extensions import Self
 import isodate
 from {{ code_model.core_library }}.exceptions import DeserializationError
 from {{ code_model.core_library }}{{ ".utils" if code_model.options["unbranded"] else "" }} import CaseInsensitiveEnumMeta
@@ -35,6 +36,7 @@ _LOGGER = logging.getLogger(__name__)
 __all__ = ["SdkJSONEncoder", "Model", "rest_field", "rest_discriminator"]
 
 TZ_UTC = timezone.utc
+_T = typing.TypeVar("_T")
 
 
 def _timedelta_as_isostr(td: timedelta) -> str:
@@ -242,7 +244,7 @@ def _deserialize_date(attr: typing.Union[str, date]) -> date:
     # This must NOT use defaultmonth/defaultday. Using None ensure this raises an exception.
     if isinstance(attr, date):
         return attr
-    return isodate.parse_date(attr, defaultmonth=None, defaultday=None)
+    return isodate.parse_date(attr, defaultmonth=None, defaultday=None)  # type: ignore
 
 
 def _deserialize_time(attr: typing.Union[str, time]) -> time:
@@ -383,8 +385,12 @@ class _MyMutableMapping(MutableMapping[str, typing.Any]):  # pylint: disable=uns
         except KeyError:
             return default
 
-    @typing.overload  # type: ignore
-    def pop(self, key: str) -> typing.Any:  # pylint: disable=no-member
+    @typing.overload
+    def pop(self, key: str) -> typing.Any:
+        ...
+
+    @typing.overload
+    def pop(self, key: str, default: _T) -> _T:
         ...
 
     @typing.overload
@@ -405,8 +411,8 @@ class _MyMutableMapping(MutableMapping[str, typing.Any]):  # pylint: disable=uns
     def update(self, *args: typing.Any, **kwargs: typing.Any) -> None:
         self._data.update(*args, **kwargs)
 
-    @typing.overload  # type: ignore
-    def setdefault(self, key: str) -> typing.Any:
+    @typing.overload
+    def setdefault(self, key: str, default: None = None) -> None:
         ...
 
     @typing.overload
@@ -446,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)
@@ -512,7 +520,7 @@ class Model(_MyMutableMapping):
     def copy(self) -> "Model":
         return Model(self.__dict__)
 
-    def __new__(cls, *args: typing.Any, **kwargs: typing.Any) -> "Model":  # pylint: disable=unused-argument
+    def __new__(cls, *args: typing.Any, **kwargs: typing.Any) -> Self:  # pylint: disable=unused-argument
         # we know the last three classes in mro are going to be 'Model', 'dict', and 'object'
         mros = cls.__mro__[:-3][::-1]  # ignore model, dict, and object parents, and reverse the mro order
         attr_to_rest_field: typing.Dict[str, _RestField] = {  # map attribute name to rest_field property
@@ -554,7 +562,7 @@ class Model(_MyMutableMapping):
         exist_discriminators.append(discriminator)
         mapped_cls = cls.__mapping__.get(
             data.get(discriminator), cls
-        )  # pylint: disable=no-member
+        )  # pyright: ignore # pylint: disable=no-member
         if mapped_cls == cls:
             return cls(data)
         return mapped_cls._deserialize(data, exist_discriminators)  # pylint: disable=protected-access
@@ -571,7 +579,7 @@ class Model(_MyMutableMapping):
         if exclude_readonly:
             readonly_props = [p._rest_name for p in self._attr_to_rest_field.values() if _is_readonly(p)]
         for k, v in self.items():
-            if exclude_readonly and k in readonly_props:  # pyright: ignore[reportUnboundVariable]
+            if exclude_readonly and k in readonly_props:  # pyright: ignore
                 continue
             is_multipart_file_input = False
             try:
@@ -630,22 +638,22 @@ def _get_deserialize_callable_from_annotation(  # pylint: disable=R0911, R0915,
                     return obj
                 return _deserialize(model_deserializer, obj)
 
-            return functools.partial(_deserialize_model, annotation)
+            return functools.partial(_deserialize_model, annotation)  # pyright: ignore
     except Exception:
         pass
 
     # is it a literal?
     try:
-        if annotation.__origin__ is typing.Literal:
+        if annotation.__origin__ is typing.Literal:  # pyright: ignore
             return None
     except AttributeError:
         pass
 
     # is it optional?
     try:
-        if any(a for a in annotation.__args__ if a == type(None)):
+        if any(a for a in annotation.__args__ if a == type(None)):  # pyright: ignore
             if_obj_deserializer = _get_deserialize_callable_from_annotation(
-                next(a for a in annotation.__args__ if a != type(None)), module, rf
+                next(a for a in annotation.__args__ if a != type(None)), module, rf  # pyright: ignore
             )
 
             def _deserialize_with_optional(if_obj_deserializer: typing.Optional[typing.Callable], obj):
@@ -658,7 +666,13 @@ def _get_deserialize_callable_from_annotation(  # pylint: disable=R0911, R0915,
         pass
 
     if getattr(annotation, "__origin__", None) is typing.Union:
-        deserializers = [_get_deserialize_callable_from_annotation(arg, module, rf) for arg in annotation.__args__]
+        # 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 sorted(
+            annotation.__args__, key=lambda x: hasattr(x, "__name__") and x.__name__ == "str"  # pyright: ignore
+        )
+        ]
 
         def _deserialize_with_union(deserializers, obj):
             for deserializer in deserializers:
@@ -671,8 +685,10 @@ def _get_deserialize_callable_from_annotation(  # pylint: disable=R0911, R0915,
         return functools.partial(_deserialize_with_union, deserializers)
 
     try:
-        if annotation._name == "Dict":
-            value_deserializer = _get_deserialize_callable_from_annotation(annotation.__args__[1], module, rf)
+        if annotation._name == "Dict":  # pyright: ignore
+            value_deserializer = _get_deserialize_callable_from_annotation(
+                annotation.__args__[1], module, rf  # pyright: ignore
+            )
 
             def _deserialize_dict(
                 value_deserializer: typing.Optional[typing.Callable],
@@ -692,8 +708,8 @@ def _get_deserialize_callable_from_annotation(  # pylint: disable=R0911, R0915,
     except (AttributeError, IndexError):
         pass
     try:
-        if annotation._name in ["List", "Set", "Tuple", "Sequence"]:
-            if len(annotation.__args__) > 1:
+        if annotation._name in ["List", "Set", "Tuple", "Sequence"]:  # pyright: ignore
+            if len(annotation.__args__) > 1:  # pyright: ignore
 
                 def _deserialize_multiple_sequence(
                     entry_deserializers: typing.List[typing.Optional[typing.Callable]],
@@ -707,10 +723,12 @@ def _get_deserialize_callable_from_annotation(  # pylint: disable=R0911, R0915,
                     )
 
                 entry_deserializers = [
-                    _get_deserialize_callable_from_annotation(dt, module, rf) for dt in annotation.__args__
+                    _get_deserialize_callable_from_annotation(dt, module, rf) for dt in annotation.__args__  # pyright: ignore
                 ]
                 return functools.partial(_deserialize_multiple_sequence, entry_deserializers)
-            deserializer = _get_deserialize_callable_from_annotation(annotation.__args__[0], module, rf)
+            deserializer = _get_deserialize_callable_from_annotation(
+                annotation.__args__[0], module, rf  # pyright: ignore
+            )
 
             def _deserialize_sequence(
                 deserializer: typing.Optional[typing.Callable],
@@ -802,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 '' }}
-        super().__init__(*args, **kwargs)
-    {% 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/packaging_templates/setup.py.jinja2

@@ -96,6 +96,9 @@ setup(
         {% else %}
         "azure-core<2.0.0,>=1.30.0",
         {% endif %}
+        {% if code_model.need_typing_extensions %}
+        "typing-extensions>=4.6.0",
+        {% endif %}
     ],
     {% if package_mode %}
     python_requires=">=3.8",

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

@@ -170,13 +170,6 @@ class RawDeserializer:
         return None
 
 
-try:
-    basestring  # type: ignore
-    unicode_str = unicode  # type: ignore
-except NameError:
-    basestring = str
-    unicode_str = str
-
 _LOGGER = logging.getLogger(__name__)
 
 try:
@@ -547,7 +540,7 @@ class Serializer(object):
         "multiple": lambda x, y: x % y != 0,
     }
 
-    def __init__(self, classes: Optional[Mapping[str, Type[ModelType]]]=None):
+    def __init__(self, classes: Optional[Mapping[str, type]]=None):
         self.serialize_type = {
             "iso-8601": Serializer.serialize_iso,
             "rfc-1123": Serializer.serialize_rfc,
@@ -563,7 +556,7 @@ class Serializer(object):
             "[]": self.serialize_iter,
             "{}": self.serialize_dict,
         }
-        self.dependencies: Dict[str, Type[ModelType]] = dict(classes) if classes else {}
+        self.dependencies: Dict[str, type] = dict(classes) if classes else {}
         self.key_transformer = full_restapi_key_transformer
         self.client_side_validation = True
 
@@ -651,7 +644,7 @@ class Serializer(object):
                         else:  # That's a basic type
                             # Integrate namespace if necessary
                             local_node = _create_xml_node(xml_name, xml_prefix, xml_ns)
-                            local_node.text = unicode_str(new_attr)
+                            local_node.text = str(new_attr)
                             serialized.append(local_node)  # type: ignore
                     else:  # JSON
                         for k in reversed(keys):  # type: ignore
@@ -1000,7 +993,7 @@ class Serializer(object):
             return self.serialize_basic(attr, self.basic_types[obj_type], **kwargs)
         if obj_type is _long_type:
             return self.serialize_long(attr)
-        if obj_type is unicode_str:
+        if obj_type is str:
             return self.serialize_unicode(attr)
         if obj_type is datetime.datetime:
             return self.serialize_iso(attr)
@@ -1376,7 +1369,7 @@ class Deserializer(object):
 
     valid_date = re.compile(r"\d{4}[-]\d{2}[-]\d{2}T\d{2}:\d{2}:\d{2}" r"\.?\d*Z?[-+]?[\d{2}]?:?[\d{2}]?")
 
-    def __init__(self, classes: Optional[Mapping[str, Type[ModelType]]]=None):
+    def __init__(self, classes: Optional[Mapping[str, type]]=None):
         self.deserialize_type = {
             "iso-8601": Deserializer.deserialize_iso,
             "rfc-1123": Deserializer.deserialize_rfc,
@@ -1396,7 +1389,7 @@ class Deserializer(object):
             "duration": (isodate.Duration, datetime.timedelta),
             "iso-8601": (datetime.datetime),
         }
-        self.dependencies: Dict[str, Type[ModelType]] = dict(classes) if classes else {}
+        self.dependencies: Dict[str, type] = dict(classes) if classes else {}
         self.key_extractors = [rest_key_extractor, xml_key_extractor]
         # Additional properties only works if the "rest_key_extractor" is used to
         # extract the keys. Making it to work whatever the key extractor is too much
@@ -1449,7 +1442,7 @@ class Deserializer(object):
 
         response, class_name = self._classify_target(target_obj, data)
 
-        if isinstance(response, basestring):
+        if isinstance(response, str):
             return self.deserialize_data(data, response)
         elif isinstance(response, type) and issubclass(response, Enum):
             return self.deserialize_enum(data, response)
@@ -1520,14 +1513,14 @@ class Deserializer(object):
         if target is None:
             return None, None
 
-        if isinstance(target, basestring):
+        if isinstance(target, str):
             try:
                 target = self.dependencies[target]
             except KeyError:
                 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
@@ -1583,7 +1576,7 @@ class Deserializer(object):
         if hasattr(raw_data, "_content_consumed"):
             return RawDeserializer.deserialize_from_http_generics(raw_data.text, raw_data.headers)
 
-        if isinstance(raw_data, (basestring, bytes)) or hasattr(raw_data, "read"):
+        if isinstance(raw_data, (str, bytes)) or hasattr(raw_data, "read"):
             return RawDeserializer.deserialize_from_text(raw_data, content_type)  # type: ignore
         return raw_data
 
@@ -1705,7 +1698,7 @@ class Deserializer(object):
         if isinstance(attr, ET.Element):
             # Do no recurse on XML, just return the tree as-is
             return attr
-        if isinstance(attr, basestring):
+        if isinstance(attr, str):
             return self.deserialize_basic(attr, "str")
         obj_type = type(attr)
         if obj_type in self.basic_types:
@@ -1762,7 +1755,7 @@ class Deserializer(object):
         if data_type == "bool":
             if attr in [True, False, 1, 0]:
                 return bool(attr)
-            elif isinstance(attr, basestring):
+            elif isinstance(attr, str):
                 if attr.lower() in ["true", "1"]:
                     return True
                 elif attr.lower() in ["false", "0"]:

package/autorest/m4reformatter/__init__.py

@@ -240,6 +240,10 @@ def update_primitive(  # pylint: disable=too-many-return-statements
         base = _update_type_base("bytes", yaml_data)
         base["encode"] = yaml_data["format"]
         return base
+    if type_group == "date":
+        return _update_type_base("plainDate", yaml_data)
+    if type_group == "time":
+        return _update_type_base("plainTime", yaml_data)
     return _update_type_base(type_group, yaml_data)
 
 

package/package.json

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