@autorest/python 6.13.11 → 6.13.12

package/autorest/codegen/models/client.py

@@ -350,9 +350,7 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
         elif self.code_model.options["models_mode"] == "msrest":
             # in this case, we have client_models = {} in the service client, which needs a type annotation
             # this import will always be commented, so will always add it to the typing section
-            file_import.add_submodule_import(
-                "typing", "Dict", ImportType.STDLIB, TypingSection.TYPING
-            )
+            file_import.add_submodule_import("typing", "Dict", ImportType.STDLIB)
         file_import.add_submodule_import("copy", "deepcopy", ImportType.STDLIB)
         return file_import
 

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

@@ -605,6 +605,56 @@ class Model(_MyMutableMapping):
             }
         return v.as_dict(exclude_readonly=exclude_readonly) if hasattr(v, "as_dict") else v
 
+def _deserialize_model(model_deserializer: typing.Optional[typing.Callable], obj):
+    if _is_model(obj):
+        return obj
+    return _deserialize(model_deserializer, obj)
+
+def _deserialize_with_optional(if_obj_deserializer: typing.Optional[typing.Callable], obj):
+    if obj is None:
+        return obj
+    return _deserialize_with_callable(if_obj_deserializer, obj)
+
+def _deserialize_with_union(deserializers, obj):
+    for deserializer in deserializers:
+        try:
+            return _deserialize(deserializer, obj)
+        except DeserializationError:
+            pass
+    raise DeserializationError()
+
+def _deserialize_dict(
+    value_deserializer: typing.Optional[typing.Callable],
+    module: typing.Optional[str],
+    obj: typing.Dict[typing.Any, typing.Any],
+):
+    if obj is None:
+        return obj
+    return {
+        k: _deserialize(value_deserializer, v, module)
+        for k, v in obj.items()
+    }
+
+def _deserialize_multiple_sequence(
+    entry_deserializers: typing.List[typing.Optional[typing.Callable]],
+    module: typing.Optional[str],
+    obj,
+):
+    if obj is None:
+        return obj
+    return type(obj)(
+        _deserialize(deserializer, entry, module)
+        for entry, deserializer in zip(obj, entry_deserializers)
+    )
+
+def _deserialize_sequence(
+    deserializer: typing.Optional[typing.Callable],
+    module: typing.Optional[str],
+    obj,
+):
+    if obj is None:
+        return obj
+    return type(obj)(_deserialize(deserializer, entry, module) for entry in obj)
 
 def _get_deserialize_callable_from_annotation(  # pylint: disable=R0911, R0915, R0912
     annotation: typing.Any,
@@ -633,11 +683,6 @@ def _get_deserialize_callable_from_annotation(  # pylint: disable=R0911, R0915,
             if rf:
                 rf._is_model = True
 
-            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, annotation)  # pyright: ignore
     except Exception:
         pass
@@ -656,11 +701,6 @@ def _get_deserialize_callable_from_annotation(  # pylint: disable=R0911, R0915,
                 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):
-                if obj is None:
-                    return obj
-                return _deserialize_with_callable(if_obj_deserializer, obj)
-
             return functools.partial(_deserialize_with_optional, if_obj_deserializer)
     except AttributeError:
         pass
@@ -674,14 +714,6 @@ def _get_deserialize_callable_from_annotation(  # pylint: disable=R0911, R0915,
         )
         ]
 
-        def _deserialize_with_union(deserializers, obj):
-            for deserializer in deserializers:
-                try:
-                    return _deserialize(deserializer, obj)
-                except DeserializationError:
-                    pass
-            raise DeserializationError()
-
         return functools.partial(_deserialize_with_union, deserializers)
 
     try:
@@ -690,20 +722,11 @@ def _get_deserialize_callable_from_annotation(  # pylint: disable=R0911, R0915,
                 annotation.__args__[1], module, rf  # pyright: ignore
             )
 
-            def _deserialize_dict(
-                value_deserializer: typing.Optional[typing.Callable],
-                obj: typing.Dict[typing.Any, typing.Any],
-            ):
-                if obj is None:
-                    return obj
-                return {
-                    k: _deserialize(value_deserializer, v, module)
-                    for k, v in obj.items()
-                }
-
+            
             return functools.partial(
                 _deserialize_dict,
                 value_deserializer,
+                module,
             )
     except (AttributeError, IndexError):
         pass
@@ -711,34 +734,18 @@ def _get_deserialize_callable_from_annotation(  # pylint: disable=R0911, R0915,
         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]],
-                    obj,
-                ):
-                    if obj is None:
-                        return obj
-                    return type(obj)(
-                        _deserialize(deserializer, entry, module)
-                        for entry, deserializer in zip(obj, entry_deserializers)
-                    )
 
                 entry_deserializers = [
                     _get_deserialize_callable_from_annotation(dt, module, rf) for dt in annotation.__args__  # pyright: ignore
                 ]
-                return functools.partial(_deserialize_multiple_sequence, entry_deserializers)
+                return functools.partial(_deserialize_multiple_sequence, entry_deserializers, module)
             deserializer = _get_deserialize_callable_from_annotation(
                 annotation.__args__[0], module, rf  # pyright: ignore
             )
 
-            def _deserialize_sequence(
-                deserializer: typing.Optional[typing.Callable],
-                obj,
-            ):
-                if obj is None:
-                    return obj
-                return type(obj)(_deserialize(deserializer, entry, module) for entry in obj)
+            
 
-            return functools.partial(_deserialize_sequence, deserializer)
+            return functools.partial(_deserialize_sequence, deserializer, module)
     except (TypeError, IndexError, AttributeError, SyntaxError):
         pass
 

package/autorest/codegen/templates/packaging_templates/dev_requirements.txt.jinja2

@@ -1,4 +1,3 @@
--e ../../../tools/azure-devtools
 -e ../../../tools/azure-sdk-tools
 ../../core/azure-core
 {% if token_credential -%}

package/package.json

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