@autorest/python 6.2.4 → 6.2.6

package/autorest/codegen/models/base.py

@@ -87,7 +87,6 @@ class BaseType(BaseModel, ABC):
         return ", ".join(attrs_list)
 
     @property
-    @abstractmethod
     def serialization_type(self) -> str:
         """The tag recognized by 'msrest' as a serialization/deserialization.
 
@@ -100,6 +99,11 @@ class BaseType(BaseModel, ABC):
         If dict: '{str}'
         """
         ...
+        raise NotImplementedError()
+
+    @property
+    def msrest_deserialization_key(self) -> str:
+        return self.serialization_type
 
     @property
     def client_default_value(self) -> Any:

package/autorest/codegen/models/client.py

@@ -74,7 +74,9 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
             ]
             self.format_lro_operations()
 
-    def _build_request_builders(self):
+    def _build_request_builders(
+        self,
+    ) -> List[Union[RequestBuilder, OverloadedRequestBuilder]]:
         request_builders: List[Union[RequestBuilder, OverloadedRequestBuilder]] = []
         for og_group in self.yaml_data["operationGroups"]:
             for operation_yaml in og_group["operations"]:
@@ -285,23 +287,9 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
             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
-            ):
-                # this means we have hidden models. In that case, we import directly from the models
-                # file, not the module, bc we don't expose the hidden models in the models module
-
-                # Also in this case, we're in version tolerant, so python3 only is true
-                file_import.add_submodule_import(
-                    f"{path_to_models}models",
-                    self.code_model.models_filename,
-                    ImportType.LOCAL,
-                    alias="models",
-                )
-            else:
-                file_import.add_submodule_import(
-                    path_to_models, "models", ImportType.LOCAL
-                )
+            file_import.add_submodule_import(
+                path_to_models, "models", ImportType.LOCAL, alias="_models"
+            )
         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
@@ -411,7 +399,11 @@ class Config(_ClientConfigBase[ConfigGlobalParameterList]):
                 and gp not in self.parameters.kwargs_to_pop
             ):
                 continue
-            file_import.merge(gp.imports(async_mode=async_mode))
+            file_import.merge(
+                gp.imports(
+                    async_mode=async_mode, relative_path=".." if async_mode else "."
+                )
+            )
         return file_import
 
     def imports_for_multiapi(self, async_mode: bool) -> FileImport:
@@ -423,7 +415,11 @@ class Config(_ClientConfigBase[ConfigGlobalParameterList]):
                 and gp.client_name == "api_version"
             ):
                 continue
-            file_import.merge(gp.imports_for_multiapi(async_mode=async_mode))
+            file_import.merge(
+                gp.imports_for_multiapi(
+                    async_mode=async_mode, relative_path=".." if async_mode else "."
+                )
+            )
         return file_import
 
     @classmethod

package/autorest/codegen/models/combined_type.py

@@ -41,7 +41,7 @@ class CombinedType(BaseType):
         If list: '[str]'
         If dict: '{str}'
         """
-        ...
+        raise ValueError("Shouldn't get serialization type of a combinedtype")
 
     @property
     def client_default_value(self) -> Any:

package/autorest/codegen/models/imports.py

@@ -69,7 +69,7 @@ class ImportModel:
         except AttributeError:
             return False
 
-    def __hash__(self):
+    def __hash__(self) -> int:
         retval: int = 0
         for attr in dir(self):
             if attr[0] != "_":
@@ -88,7 +88,7 @@ class TypeDefinition:
 
 
 class FileImport:
-    def __init__(self, imports: List[ImportModel] = None) -> None:
+    def __init__(self, imports: Optional[List[ImportModel]] = None) -> None:
         self.imports = imports or []
         # has sync and async type definitions
         self.type_definitions: Dict[str, TypeDefinition] = {}

package/autorest/codegen/models/model_type.py

@@ -81,6 +81,10 @@ class ModelType(
             return f"{'' if self.is_public else '_models.'}_models.{self.name}"
         return "object"
 
+    @property
+    def msrest_deserialization_key(self) -> str:
+        return self.name
+
     @property
     def is_polymorphic(self) -> bool:
         return any(p.is_polymorphic for p in self.properties)

package/autorest/codegen/models/operation_group.py

@@ -48,11 +48,16 @@ class OperationGroup(BaseModel):
 
     def imports_for_multiapi(self, async_mode: bool) -> FileImport:
         file_import = FileImport()
+        relative_path = ".." if async_mode else "."
         for operation in self.operations:
             file_import.merge(
-                operation.imports_for_multiapi(
-                    async_mode, relative_path=".." if async_mode else "."
-                )
+                operation.imports_for_multiapi(async_mode, relative_path=relative_path)
+            )
+        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"
             )
         return file_import
 
@@ -84,8 +89,10 @@ class OperationGroup(BaseModel):
             )
         # for multiapi
         if (
-            self.code_model.model_types or self.code_model.enums
-        ) and self.code_model.options["models_mode"] == "msrest":
+            (self.code_model.public_model_types)
+            and self.code_model.options["models_mode"] == "msrest"
+            and not self.is_mixin
+        ):
             file_import.add_submodule_import(
                 relative_path, "models", ImportType.LOCAL, alias="_models"
             )

package/autorest/codegen/models/property.py

@@ -83,6 +83,10 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
     def serialization_type(self) -> str:
         return self.type.serialization_type
 
+    @property
+    def msrest_deserialization_key(self) -> str:
+        return self.type.msrest_deserialization_key
+
     def type_annotation(self, *, is_operation_file: bool = False) -> str:
         if self.optional and self.client_default_value is None:
             return f"Optional[{self.type.type_annotation(is_operation_file=is_operation_file)}]"

package/autorest/codegen/models/request_builder.py

@@ -71,10 +71,18 @@ class RequestBuilderBase(BaseBuilder[ParameterListType]):
 
     def imports(self) -> FileImport:
         file_import = FileImport()
+        relative_path = ".."
+        if (
+            not self.code_model.options["builders_visibility"] == "embedded"
+            and self.group_name
+        ):
+            relative_path = "..." if self.group_name else ".."
         if self.abstract:
             return file_import
         for parameter in self.parameters.method:
-            file_import.merge(parameter.imports(async_mode=False))
+            file_import.merge(
+                parameter.imports(async_mode=False, relative_path=relative_path)
+            )
 
         file_import.add_submodule_import(
             "azure.core.rest",
@@ -83,12 +91,6 @@ class RequestBuilderBase(BaseBuilder[ParameterListType]):
         )
 
         if self.parameters.path:
-            relative_path = ".."
-            if (
-                not self.code_model.options["builders_visibility"] == "embedded"
-                and self.group_name
-            ):
-                relative_path = "..." if self.group_name else ".."
             file_import.add_submodule_import(
                 f"{relative_path}_vendor", "_format_url_section", ImportType.LOCAL
             )

package/autorest/codegen/serializers/builder_serializer.py

@@ -9,7 +9,6 @@ from abc import abstractmethod
 from collections import defaultdict
 from typing import Any, Generic, List, Type, TypeVar, Dict, Union, Optional, cast
 
-
 from ..models import (
     Operation,
     PagingOperation,
@@ -967,11 +966,10 @@ class _OperationSerializer(
                 retval.append(
                     f"deserialized = self._deserialize('{response.serialization_type}', pipeline_response)"
                 )
-            elif self.code_model.options["models_mode"] == "dpg" and isinstance(
-                response.type, ModelType
-            ):
+            elif self.code_model.options["models_mode"] == "dpg":
                 retval.append(
-                    f"deserialized = _deserialize({response.serialization_type}, response.json())"
+                    f"deserialized = _deserialize({response.type.type_annotation(is_operation_file=True)}"
+                    ", response.json())"
                 )
             else:
                 deserialized_value = (
@@ -1290,7 +1288,9 @@ class _PagingOperationSerializer(
         elif self.code_model.options["models_mode"]:
             cont_token_property = f"deserialized.{continuation_token_name} or None"
         else:
-            cont_token_property = f'deserialized.get("{continuation_token_name}", None)'
+            cont_token_property = (
+                f'deserialized.get("{continuation_token_name}") or None'
+            )
         list_type = "AsyncList" if self.async_mode else "iter"
         retval.append(f"    return {cont_token_property}, {list_type}(list_of_elem)")
         return retval

package/autorest/codegen/serializers/client_serializer.py

@@ -116,15 +116,28 @@ class ClientSerializer:
 
     def serializers_and_operation_groups_properties(self) -> List[str]:
         retval = []
-        if self.client.code_model.model_types:
-            client_models_value = (
-                "{k: v for k, v in models.__dict__.items() if isinstance(v, type)}"
-            )
-        else:
-            client_models_value = "{}  # type: Dict[str, Any]"
+
+        def _get_client_models_value(models_dict_name: str) -> str:
+            if self.client.code_model.model_types:
+                return f"{{k: v for k, v in {models_dict_name}.__dict__.items() if isinstance(v, type)}}"
+            return "{}  # type: Dict[str, Any]"
+
         is_msrest_model = self.client.code_model.options["models_mode"] == "msrest"
         if is_msrest_model:
-            retval.append(f"client_models = {client_models_value}")
+            add_private_models = len(self.client.code_model.model_types) != len(
+                self.client.code_model.public_model_types
+            )
+            model_dict_name = (
+                f"_models.{self.client.code_model.models_filename}"
+                if add_private_models
+                else "_models"
+            )
+            retval.append(
+                f"client_models = {_get_client_models_value(model_dict_name)}"
+            )
+            if add_private_models and self.client.code_model.model_types:
+                update_dict = f"{{k: v for k, v in _models.__dict__.items() if isinstance(v, type)}}"
+                retval.append(f"client_models.update({update_dict})")
         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})")

package/autorest/codegen/serializers/model_serializer.py

@@ -195,7 +195,10 @@ class MsrestModelSerializer(_ModelSerializer):
             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}}},'
+        return (
+            f'"{prop.client_name}": {{"key": "{attribute_key}",'
+            f' "type": "{prop.msrest_deserialization_key}"{xml_metadata}}},'
+        )
 
 
 class DpgModelSerializer(_ModelSerializer):

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

@@ -17,6 +17,7 @@ from datetime import datetime, date, time, timedelta
 from azure.core.utils._utils import _FixedOffset
 from collections.abc import MutableMapping
 from azure.core.exceptions import DeserializationError
+from azure.core import CaseInsensitiveEnumMeta
 import copy
 
 _LOGGER = logging.getLogger(__name__)
@@ -121,9 +122,11 @@ try:
 except ImportError:
     TZ_UTC = _FixedOffset(0)  # type: ignore
 
+
 def _serialize_bytes(o) -> str:
     return base64.b64encode(o).decode()
 
+
 def _serialize_datetime(o):
     if hasattr(o, "year") and hasattr(o, "hour"):
         # astimezone() fails for naive times in Python 2.7, so make make sure o is aware (tzinfo is set)
@@ -136,12 +139,14 @@ def _serialize_datetime(o):
     # Next try datetime.date or datetime.time
     return o.isoformat()
 
+
 def _is_readonly(p):
     try:
         return p._readonly
     except AttributeError:
         return False
 
+
 class AzureJSONEncoder(JSONEncoder):
     """A JSON encoder that's capable of serializing datetime objects and bytes."""
 
@@ -170,9 +175,8 @@ class AzureJSONEncoder(JSONEncoder):
             return super(AzureJSONEncoder, self).default(o)
 
 
-_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}]?')
+_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 _deserialize_datetime(attr: typing.Union[str, datetime]) -> datetime:
     """Deserialize ISO-8601 formatted string into Datetime object.
@@ -188,7 +192,7 @@ def _deserialize_datetime(attr: typing.Union[str, datetime]) -> datetime:
     if not match:
         raise ValueError("Invalid datetime string: " + attr)
 
-    check_decimal = attr.split('.')
+    check_decimal = attr.split(".")
     if len(check_decimal) > 1:
         decimal_str = ""
         for digit in check_decimal[1]:
@@ -205,6 +209,7 @@ def _deserialize_datetime(attr: typing.Union[str, datetime]) -> datetime:
         raise OverflowError("Hit max or min date")
     return date_obj
 
+
 def _deserialize_date(attr: typing.Union[str, date]) -> date:
     """Deserialize ISO-8601 formatted string into Date object.
     :param str attr: response string to be deserialized.
@@ -215,6 +220,7 @@ def _deserialize_date(attr: typing.Union[str, date]) -> date:
         return attr
     return isodate.parse_date(attr, defaultmonth=None, defaultday=None)
 
+
 def _deserialize_time(attr: typing.Union[str, time]) -> time:
     """Deserialize ISO-8601 formatted string into time object.
 
@@ -225,18 +231,31 @@ def _deserialize_time(attr: typing.Union[str, time]) -> time:
         return attr
     return isodate.parse_time(attr)
 
+
 def deserialize_bytes(attr):
+    if isinstance(attr, (bytes, bytearray)):
+        return attr
     return bytes(base64.b64decode(attr))
 
+
+def deserialize_duration(attr):
+    if isinstance(attr, timedelta):
+        return attr
+    return isodate.parse_duration(attr)
+
+
 _DESERIALIZE_MAPPING = {
     datetime: _deserialize_datetime,
     date: _deserialize_date,
     time: _deserialize_time,
     bytes: deserialize_bytes,
+    timedelta: deserialize_duration,
+    typing.Any: lambda x: x,
 }
 
+
 def _get_model(module_name: str, model_name: str):
-    module_end = module_name.rsplit('.', 1)[0]
+    module_end = module_name.rsplit(".", 1)[0]
     module = sys.modules[module_end]
     models = {k: v for k, v in module.__dict__.items() if isinstance(v, type)}
     if model_name not in models:
@@ -244,10 +263,11 @@ def _get_model(module_name: str, model_name: str):
         return model_name
     return models[model_name]
 
+
 _UNSET = object()
 
-class _MyMutableMapping(MutableMapping):
 
+class _MyMutableMapping(MutableMapping):
     def __init__(self, data: typing.Dict[str, typing.Any]) -> None:
         self._data = copy.deepcopy(data)
 
@@ -332,9 +352,11 @@ class _MyMutableMapping(MutableMapping):
     def __repr__(self) -> str:
         return str(self._data)
 
+
 def _is_model(obj: typing.Any) -> bool:
     return getattr(obj, "_is_model", False)
 
+
 def _serialize(o):
     if isinstance(o, (bytes, bytearray)):
         return _serialize_bytes(o)
@@ -351,7 +373,10 @@ def _serialize(o):
         pass
     return o
 
-def _get_rest_field(attr_to_rest_field: typing.Dict[str, "_RestField"], rest_name: str) -> typing.Optional["_RestField"]:
+
+def _get_rest_field(
+    attr_to_rest_field: typing.Dict[str, "_RestField"], rest_name: str
+) -> typing.Optional["_RestField"]:
     try:
         return next(rf for rf in attr_to_rest_field.values() if rf._rest_name == rest_name)
     except StopIteration:
@@ -361,8 +386,10 @@ def _get_rest_field(attr_to_rest_field: typing.Dict[str, "_RestField"], rest_nam
 def _create_value(rest_field: typing.Optional["_RestField"], value: typing.Any) -> typing.Any:
     return _deserialize(rest_field._type, value) if (rest_field and rest_field._is_model) else _serialize(value)
 
+
 class Model(_MyMutableMapping):
     _is_model = True
+
     def __init__(self, *args, **kwargs):
         class_name = self.__class__.__name__
         if len(args) > 1:
@@ -373,20 +400,15 @@ class Model(_MyMutableMapping):
             if rest_field._default is not _UNSET
         }
         if args:
-            dict_to_pass.update({
-                k: _create_value(_get_rest_field(self._attr_to_rest_field, k), v)
-                for k, v in args[0].items()
-            })
+            dict_to_pass.update(
+                {k: _create_value(_get_rest_field(self._attr_to_rest_field, k), v) for k, v in args[0].items()}
+            )
         else:
             non_attr_kwargs = [k for k in kwargs if k not in self._attr_to_rest_field]
             if non_attr_kwargs:
                 # actual type errors only throw the first wrong keyword arg they see, so following that.
-                raise TypeError(
-                    f"{class_name}.__init__() got an unexpected keyword argument '{non_attr_kwargs[0]}'"
-                )
-            dict_to_pass.update({
-                self._attr_to_rest_field[k]._rest_name: _serialize(v) for k, v in kwargs.items()
-            })
+                raise TypeError(f"{class_name}.__init__() got an unexpected keyword argument '{non_attr_kwargs[0]}'")
+            dict_to_pass.update({self._attr_to_rest_field[k]._rest_name: _serialize(v) for k, v in kwargs.items()})
         super().__init__(dict_to_pass)
 
     def copy(self):
@@ -394,15 +416,14 @@ class Model(_MyMutableMapping):
 
     def __new__(cls, *args: typing.Any, **kwargs: typing.Any):
         # 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
-            k: v
-            for mro_class in mros
-            for k, v in mro_class.__dict__.items() if k[0] != "_" and hasattr(v, "_type")
+        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
+            k: v for mro_class in mros for k, v in mro_class.__dict__.items() if k[0] != "_" and hasattr(v, "_type")
         }
         annotations = {
             k: v
-            for mro_class in mros if hasattr(mro_class, '__annotations__') 
+            for mro_class in mros
+            if hasattr(mro_class, "__annotations__")
             for k, v in mro_class.__annotations__.items()
         }
         for attr, rest_field in attr_to_rest_field.items():
@@ -411,18 +432,15 @@ class Model(_MyMutableMapping):
                 rest_field._type = rest_field._get_deserialize_callable_from_annotation(annotations.get(attr, None))
             if not rest_field._rest_name_input:
                 rest_field._rest_name_input = attr
-        cls._attr_to_rest_field: typing.Dict[str, _RestField] = {
-            k: v
-            for k, v in attr_to_rest_field.items()
-        }
+        cls._attr_to_rest_field: typing.Dict[str, _RestField] = {k: v for k, v in attr_to_rest_field.items()}
 
         return super().__new__(cls)
 
     def __init_subclass__(cls, discriminator=None):
         for base in cls.__bases__:
-            if hasattr(base, '__mapping__'):
+            if hasattr(base, "__mapping__"):
                 base.__mapping__[discriminator or cls.__name__] = cls
-    
+
     @classmethod
     def _get_discriminator(cls) -> typing.Optional[str]:
         for v in cls.__dict__.values():
@@ -432,81 +450,29 @@ class Model(_MyMutableMapping):
 
     @classmethod
     def _deserialize(cls, data):
-        if not hasattr(cls, '__mapping__'):
+        if not hasattr(cls, "__mapping__"):
             return cls(data)
         discriminator = cls._get_discriminator()
-        mapped_cls = cls.__mapping__.get(data.get(discriminator),cls)
+        mapped_cls = cls.__mapping__.get(data.get(discriminator), cls)
         if mapped_cls == cls:
             return cls(data)
         return mapped_cls._deserialize(data)
 
 
-def _deserialize(deserializer: typing.Optional[typing.Callable[[typing.Any], typing.Any]], value: typing.Any):
-    try:
-        if value is None:
-            return None
-        if isinstance(deserializer, type) and issubclass(deserializer, Model):
-            return deserializer._deserialize(value)
-        return deserializer(value) if deserializer else value
-    except Exception as e:
-        raise DeserializationError() from e
-
-class _RestField:
-    def __init__(
-        self,
-        *,
-        name: typing.Optional[str] = None,
-        type: typing.Optional[typing.Callable] = None,
-        is_discriminator: bool = False,
-        readonly: bool = False,
-        default: typing.Any = _UNSET,
-    ):
-        self._type = type
-        self._rest_name_input = name
-        self._module: typing.Optional[str] = None
-        self._is_discriminator = is_discriminator
-        self._readonly = readonly
-        self._is_model = False
-        self._default = default
-
-    @property
-    def _rest_name(self) -> str:
-        if self._rest_name_input is None:
-            raise ValueError("Rest name was never set")
-        return self._rest_name_input
-
-    def __get__(self, obj: Model, type=None):
-        # by this point, type and rest_name will have a value bc we default
-        # them in __new__ of the Model class
-        item = obj.get(self._rest_name)
-        if item is None:
-            return item
-        return _deserialize(self._type, _serialize(item))
-
-    def __set__(self, obj: Model, value) -> None:
-        if value is None:
-            # we want to wipe out entries if users set attr to None
-            try:
-                obj.__delitem__(self._rest_name)
-            except KeyError:
-                pass
-            return
-        if self._is_model and not _is_model(value):
-            obj.__setitem__(self._rest_name, _deserialize(self._type, value))
-        obj.__setitem__(self._rest_name, _serialize(value))
-
-    def _get_deserialize_callable_from_annotation(self, annotation: typing.Any) -> typing.Optional[typing.Callable[[typing.Any], typing.Any]]:
+def _get_deserialize_callable_from_annotation(
+        annotation: typing.Any, module: str,
+    ) -> typing.Optional[typing.Callable[[typing.Any], typing.Any]]:
         if not annotation or annotation in [int, float]:
             return None
 
         try:
-            if _is_model(_get_model(self._module, annotation)):
-                self._is_model = True
+            if _is_model(_get_model(module, annotation)):
                 def _deserialize_model(model_deserializer: typing.Optional[typing.Callable], obj):
                     if _is_model(obj):
                         return obj
                     return _deserialize(model_deserializer, obj)
-                return functools.partial(_deserialize_model, _get_model(self._module, annotation))
+
+                return functools.partial(_deserialize_model, _get_model(module, annotation))
         except Exception:
             pass
 
@@ -517,49 +483,61 @@ class _RestField:
         except AttributeError:
             pass
 
+        if isinstance(annotation, typing._GenericAlias):  # pylint: disable=protected-access
+            if annotation.__origin__ is typing.Union:
+                def _deserialize_with_union(union_annotation: typing._GenericAlias, obj):
+                    for t in union_annotation.__args__:
+                        try:
+                            return _deserialize(t, obj)
+                        except DeserializationError:
+                            pass
+                    raise DeserializationError()
+                return functools.partial(_deserialize_with_union, annotation)
+                        
         # is it optional?
         try:
             # right now, assuming we don't have unions, since we're getting rid of the only
             # union we used to have in msrest models, which was union of str and enum
             if any(a for a in annotation.__args__ if a == type(None)):
 
-                if_obj_deserializer = self._get_deserialize_callable_from_annotation(
-                    next(a for  a in annotation.__args__ if a != type(None)),
+                if_obj_deserializer = _get_deserialize_callable_from_annotation(
+                    next(a for a in annotation.__args__ if a != type(None)), module
                 )
+
                 def _deserialize_with_optional(if_obj_deserializer: typing.Optional[typing.Callable], obj):
                     if obj is None:
                         return obj
-                    return _deserialize(if_obj_deserializer, obj)
+                    return _deserialize_with_callable(if_obj_deserializer, obj)
 
                 return functools.partial(_deserialize_with_optional, if_obj_deserializer)
         except (AttributeError):
             pass
 
-
         # is it a forward ref / in quotes?
         if isinstance(annotation, str) or type(annotation) == typing.ForwardRef:
             try:
                 model_name = annotation.__forward_arg__  # type: ignore
             except AttributeError:
                 model_name = annotation
-            if self._module is not None:
-                annotation = _get_model(self._module, model_name)
+            if module is not None:
+                annotation = _get_model(module, model_name)
 
         try:
             if annotation._name == "Dict":
-                key_deserializer = self._get_deserialize_callable_from_annotation(annotation.__args__[0])
-                value_deserializer = self._get_deserialize_callable_from_annotation(annotation.__args__[1])
+                key_deserializer = _get_deserialize_callable_from_annotation(annotation.__args__[0], module)
+                value_deserializer = _get_deserialize_callable_from_annotation(annotation.__args__[1], module)
+
                 def _deserialize_dict(
                     key_deserializer: typing.Optional[typing.Callable],
                     value_deserializer: typing.Optional[typing.Callable],
-                    obj: typing.Dict[typing.Any, typing.Any]
+                    obj: typing.Dict[typing.Any, typing.Any],
                 ):
                     if obj is None:
                         return obj
                     return {
-                        _deserialize(key_deserializer, k): _deserialize(value_deserializer, v)
-                        for k, v in obj.items()
+                        _deserialize(key_deserializer, k): _deserialize(value_deserializer, v) for k, v in obj.items()
                     }
+
                 return functools.partial(
                     _deserialize_dict,
                     key_deserializer,
@@ -570,38 +548,31 @@ class _RestField:
         try:
             if annotation._name in ["List", "Set", "Tuple", "Sequence"]:
                 if len(annotation.__args__) > 1:
+
                     def _deserialize_multiple_sequence(
-                        entry_deserializers: typing.List[typing.Optional[typing.Callable]],
-                        obj
+                        entry_deserializers: typing.List[typing.Optional[typing.Callable]], obj
                     ):
                         if obj is None:
                             return obj
                         return type(obj)(
-                            _deserialize(deserializer, entry)
-                            for entry, deserializer in zip(obj, entry_deserializers)
+                            _deserialize(deserializer, entry) for entry, deserializer in zip(obj, entry_deserializers)
                         )
+
                     entry_deserializers = [
-                        self._get_deserialize_callable_from_annotation(dt)
-                        for dt in annotation.__args__
+                        _get_deserialize_callable_from_annotation(dt, module) for dt in annotation.__args__
                     ]
-                    return functools.partial(
-                        _deserialize_multiple_sequence,
-                        entry_deserializers
-                    )
-                deserializer = self._get_deserialize_callable_from_annotation(annotation.__args__[0])
+                    return functools.partial(_deserialize_multiple_sequence, entry_deserializers)
+                deserializer = _get_deserialize_callable_from_annotation(annotation.__args__[0], module)
+
                 def _deserialize_sequence(
                     deserializer: typing.Optional[typing.Callable],
                     obj,
                 ):
                     if obj is None:
                         return obj
-                    return type(obj)(
-                        _deserialize(deserializer, entry) for entry in obj
-                    )
-                return functools.partial(
-                    _deserialize_sequence,
-                    deserializer
-                )
+                    return type(obj)(_deserialize(deserializer, entry) for entry in obj)
+
+                return functools.partial(_deserialize_sequence, deserializer)
         except (TypeError, IndexError, AttributeError, SyntaxError):
             pass
 
@@ -613,15 +584,84 @@ class _RestField:
             if obj is None:
                 return obj
             try:
-                return _deserialize(annotation, obj)
+                return _deserialize_with_callable(annotation, obj)
             except Exception:
                 pass
-            return _deserialize(deserializer_from_mapping, obj)
-        return functools.partial(
-            _deserialize_default,
-            annotation,
-            _DESERIALIZE_MAPPING.get(annotation)
-        )
+            return _deserialize_with_callable(deserializer_from_mapping, obj)
+
+        return functools.partial(_deserialize_default, annotation, _DESERIALIZE_MAPPING.get(annotation))
+
+
+def _deserialize_with_callable(deserializer: typing.Optional[typing.Callable[[typing.Any], typing.Any]], value: typing.Any):
+    try:
+        if value is None:
+            return None
+        if isinstance(deserializer, CaseInsensitiveEnumMeta):
+            try:
+                return deserializer(value)
+            except ValueError:
+                # for unknown value, return raw value
+                return value
+        if isinstance(deserializer, type) and issubclass(deserializer, Model):
+            return deserializer._deserialize(value)
+        return deserializer(value) if deserializer else value
+    except Exception as e:
+        raise DeserializationError() from e
+
+
+def _deserialize(deserializer: typing.Optional[typing.Callable[[typing.Any], typing.Any]], value: typing.Any):
+    deserializer = _get_deserialize_callable_from_annotation(deserializer, "")
+    return _deserialize_with_callable(deserializer, value)
+
+class _RestField:
+    def __init__(
+        self,
+        *,
+        name: typing.Optional[str] = None,
+        type: typing.Optional[typing.Callable] = None,
+        is_discriminator: bool = False,
+        readonly: bool = False,
+        default: typing.Any = _UNSET,
+    ):
+        self._type = type
+        self._rest_name_input = name
+        self._module: typing.Optional[str] = None
+        self._is_discriminator = is_discriminator
+        self._readonly = readonly
+        self._is_model = False
+        self._default = default
+
+    @property
+    def _rest_name(self) -> str:
+        if self._rest_name_input is None:
+            raise ValueError("Rest name was never set")
+        return self._rest_name_input
+
+    def __get__(self, obj: Model, type=None):
+        # by this point, type and rest_name will have a value bc we default
+        # them in __new__ of the Model class
+        item = obj.get(self._rest_name)
+        if item is None:
+            return item
+        return _deserialize(self._type, _serialize(item))
+
+    def __set__(self, obj: Model, value) -> None:
+        if value is None:
+            # we want to wipe out entries if users set attr to None
+            try:
+                obj.__delitem__(self._rest_name)
+            except KeyError:
+                pass
+            return
+        if self._is_model and not _is_model(value):
+            obj.__setitem__(self._rest_name, _deserialize(self._type, value))
+        obj.__setitem__(self._rest_name, _serialize(value))
+
+    def _get_deserialize_callable_from_annotation(
+        self, annotation: typing.Any
+    ) -> typing.Optional[typing.Callable[[typing.Any], typing.Any]]:
+        return _get_deserialize_callable_from_annotation(annotation, self._module)
+
 
 def rest_field(
     *,
@@ -632,5 +672,8 @@ def rest_field(
 ) -> typing.Any:
     return _RestField(name=name, type=type, readonly=readonly, default=default)
 
-def rest_discriminator(*, name: typing.Optional[str] = None, type: typing.Optional[typing.Callable] = None) -> typing.Any:
+
+def rest_discriminator(
+    *, name: typing.Optional[str] = None, type: typing.Optional[typing.Callable] = None
+) -> typing.Any:
     return _RestField(name=name, type=type, is_discriminator=True)

package/autorest/codegen/templates/packaging_templates/setup.py.jinja2

@@ -58,6 +58,7 @@ setup(
         "Programming Language :: Python :: 3.8",
         "Programming Language :: Python :: 3.9",
         "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
         "License :: OSI Approved :: MIT License",
     ],
     zip_safe=False,

package/autorest/jsonrpc/__init__.py

@@ -114,7 +114,9 @@ class AutorestAPI(ABC):
     def message(self, channel: Channel, text: str) -> None:
         """Send a log message to autorest."""
 
-    def get_boolean_value(self, key: str, default: bool = None) -> Optional[bool]:
+    def get_boolean_value(
+        self, key: str, default: Optional[bool] = None
+    ) -> Optional[bool]:
         """Check if value is present on the line, and interpret it as bool if it was.
 
         If value is not not on the line, return the "default".

package/autorest/jsonrpc/localapi.py

@@ -17,7 +17,9 @@ class LocalAutorestAPI(AutorestAPI):
     """A local API that will write on local disk."""
 
     def __init__(
-        self, reachable_files: List[str] = None, output_folder: str = "generated"
+        self,
+        reachable_files: Optional[List[str]] = None,
+        output_folder: str = "generated",
     ) -> None:
         super().__init__()
         if reachable_files is None:

package/autorest/multiapi/models/imports.py

@@ -25,30 +25,34 @@ class TypingSection(str, Enum):
 class FileImport:
     def __init__(
         self,
-        imports: Dict[
-            TypingSection,
+        imports: Optional[
             Dict[
-                ImportType,
+                TypingSection,
                 Dict[
-                    str,
-                    Set[
-                        Optional[
-                            Union[
-                                str,
-                                Tuple[
-                                    str,
+                    ImportType,
+                    Dict[
+                        str,
+                        Set[
+                            Optional[
+                                Union[
                                     str,
-                                ],
-                                Tuple[
-                                    str,
-                                    str,
-                                    Tuple[Tuple[Tuple[int, int], str, Optional[str]]],
-                                ],
+                                    Tuple[
+                                        str,
+                                        str,
+                                    ],
+                                    Tuple[
+                                        str,
+                                        str,
+                                        Tuple[
+                                            Tuple[Tuple[int, int], str, Optional[str]]
+                                        ],
+                                    ],
+                                ]
                             ]
-                        ]
+                        ],
                     ],
                 ],
-            ],
+            ]
         ] = None,
     ) -> None:
         # Basic implementation

package/autorest/preprocess/__init__.py

@@ -9,7 +9,11 @@ import copy
 from typing import Callable, Dict, Any, List, Optional
 
 from .._utils import to_snake_case
-from .helpers import pad_reserved_words, add_redefined_builtin_info
+from .helpers import (
+    pad_reserved_words,
+    add_redefined_builtin_info,
+    pad_builtin_namespaces,
+)
 from .python_mappings import PadType
 
 from .. import YamlUpdatePlugin, YamlUpdatePluginAutorest
@@ -362,6 +366,8 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
             for client in clients:
                 update_client(client)
                 self.update_operation_groups(yaml_data, client)
+        if yaml_data.get("namespace"):
+            yaml_data["namespace"] = pad_builtin_namespaces(yaml_data["namespace"])
 
 
 class PreProcessPluginAutorest(YamlUpdatePluginAutorest, PreProcessPlugin):

package/autorest/preprocess/helpers.py

@@ -3,9 +3,14 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import Any, Dict
 import re
-from .python_mappings import PadType, RESERVED_WORDS, REDEFINED_BUILTINS
+from typing import Any, Dict
+from .python_mappings import (
+    PadType,
+    RESERVED_WORDS,
+    REDEFINED_BUILTINS,
+    BUILTIN_PACKAGES,
+)
 
 
 def pad_reserved_words(name: str, pad_type: PadType):
@@ -26,5 +31,12 @@ def add_redefined_builtin_info(name: str, yaml_data: Dict[str, Any]) -> None:
         yaml_data["pylintDisable"] = "redefined-builtin"
 
 
+def pad_builtin_namespaces(namespace: str) -> str:
+    items = namespace.split(".")
+    if items[0] in BUILTIN_PACKAGES:
+        items[0] = items[0] + "_"
+    return ".".join(items)
+
+
 def pad_special_chars(name: str) -> str:
     return re.sub(r"[^A-z0-9_]", "_", name)

package/autorest/preprocess/python_mappings.py

@@ -174,3 +174,30 @@ REDEFINED_BUILTINS = [  # we don't pad, but we need to do lint ignores
     "max",
     "filter",
 ]
+
+BUILTIN_PACKAGES = [
+    "array",
+    "atexit",
+    "binascii",
+    "builtins",
+    "cmath",
+    "errno",
+    "faulthandler",
+    "fcntl",
+    "gc",
+    "grp",
+    "itertools",
+    "marshal",
+    "math",
+    "posix",
+    "pwd",
+    "pyexpat",
+    "select",
+    "spwd",
+    "sys",
+    "syslog",
+    "time",
+    "unicodedata",
+    "xxsubtype",
+    "zlib",
+]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autorest/python",
-  "version": "6.2.4",
+  "version": "6.2.6",
   "description": "The Python extension for generators in AutoRest.",
   "repository": {
     "type": "git",
@@ -21,7 +21,7 @@
     "@autorest/system-requirements": "~1.0.0"
   },
   "devDependencies": {
-    "@microsoft.azure/autorest.testserver": "^3.3.41",
+    "@microsoft.azure/autorest.testserver": "^3.3.45",
     "typescript": "^4.8.3"
   },
   "files": [

package/setup.py

@@ -38,6 +38,9 @@ setup(
         'Programming Language :: Python :: 3',
         'Programming Language :: Python :: 3.7',
         'Programming Language :: Python :: 3.8',
+        'Programming Language :: Python :: 3.9',
+        'Programming Language :: Python :: 3.10',
+        'Programming Language :: Python :: 3.11',
         'License :: OSI Approved :: MIT License',
     ],
     packages=find_packages(exclude=[