@autorest/python 6.2.9 → 6.2.10

package/autorest/_utils.py

@@ -96,6 +96,7 @@ KNOWN_TYPES: Dict[str, Dict[str, Any]] = {
     "string": {"type": "string"},
     "binary": {"type": "binary"},
     "anydict": {"type": "dict", "elementType": {"type": "any"}},
+    "any-object": {"type": "any-object"},
 }
 
 JSON_REGEXP = re.compile(r"^(application|text)/(.+\+)?json$")

package/autorest/codegen/__init__.py

@@ -70,6 +70,12 @@ def _validate_code_model_options(options: Dict[str, Any]) -> None:
             "Can not generate version tolerant with --client-side-validation. "
         )
 
+    if not (options["azure_arm"] or options["version_tolerant"]):
+        _LOGGER.warning(
+            "You are generating with options that would not allow the SDK to be shipped as an official Azure SDK. "
+            "Please read https://aka.ms/azsdk/dpcodegen for more details."
+        )
+
 
 _LOGGER = logging.getLogger(__name__)
 

package/autorest/codegen/models/base.py

@@ -192,3 +192,7 @@ class BaseType(BaseModel, ABC):  # pylint: disable=too-many-public-methods
     def serialization_constraints(self) -> List[str]:
         """Whether there are any serialization constraints when serializing this type."""
         return []
+
+    @property
+    def type_description(self) -> str:
+        return self.type  # type: ignore

package/autorest/codegen/models/combined_type.py

@@ -51,12 +51,8 @@ class CombinedType(BaseType):
         self, *, is_operation_file: bool  # pylint: disable=unused-argument
     ) -> str:
         if len(self.types) == 2:
-            return (
-                f"Is either a {self.types[0].type} type or a {self.types[1].type} type."
-            )
-        return (
-            f"Is one of the following types: {', '.join([t.type for t in self.types])}"
-        )
+            return f"Is either a {self.types[0].type_description} type or a {self.types[1].type_description} type."
+        return f"Is one of the following types: {', '.join([t.type_description for t in self.types])}"
 
     def docstring_text(self, **kwargs: Any) -> str:
         return " or ".join(t.docstring_text(**kwargs) for t in self.types)

package/autorest/codegen/models/parameter.py

@@ -5,7 +5,6 @@
 # --------------------------------------------------------------------------
 import abc
 from enum import Enum, auto
-import re
 
 from typing import (
     Dict,
@@ -22,8 +21,6 @@ from .imports import FileImport, ImportType
 from .base import BaseModel
 from .base import BaseType
 from .constant_type import ConstantType
-from .model_type import ModelType
-from .combined_type import CombinedType
 from .utils import add_to_description
 
 if TYPE_CHECKING:
@@ -254,40 +251,6 @@ class BodyParameter(_BodyParameterBase):
             type=code_model.lookup_type(id(yaml_data["type"])),
         )
 
-    def type_annotation(self, **kwargs: Any) -> str:
-        annotation = super().type_annotation(**kwargs)
-        model_seq = BodyParameter.get_model_seq(self.type)
-        if self.code_model.options["models_mode"] == "dpg" and model_seq >= 0:
-            pattern = re.compile(r"Union\[.*\]")
-            union_content = (
-                annotation[6:-1] if pattern.match(annotation) else annotation
-            )
-            items = union_content.split(", ")
-            items.insert(model_seq + 1, "JSON")
-            annotation = f'Union[{", ".join(items)}]'
-        return annotation
-
-    def docstring_type(self, **kwargs: Any) -> str:
-        docstring = super().docstring_type(**kwargs)
-        model_seq = BodyParameter.get_model_seq(self.type)
-        if self.code_model.options["models_mode"] == "dpg" and model_seq >= 0:
-            items = docstring.split(" or ")
-            items.insert(model_seq + 1, "JSON")
-            docstring = " or ".join(items)
-        return docstring
-
-    @staticmethod
-    def get_model_seq(t: BaseType):
-        if isinstance(t, ModelType):
-            return 0
-        if isinstance(t, CombinedType):
-            sub_num = len(t.types)
-            for i in range(sub_num):
-                sub_seq = BodyParameter.get_model_seq(t.types[i])
-                if sub_seq >= 0:
-                    return i + sub_seq
-        return -1
-
 
 EntryBodyParameterType = TypeVar(
     "EntryBodyParameterType", bound=Union[BodyParameter, "RequestBuilderBodyParameter"]

package/autorest/codegen/models/primitive_types.py

@@ -199,6 +199,10 @@ class AnyObjectType(PrimitiveType):
         file_import.define_mutable_mapping_type()
         return file_import
 
+    @property
+    def type_description(self) -> str:
+        return "JSON"
+
 
 class NumberType(PrimitiveType):  # pylint: disable=abstract-method
     def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:

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

@@ -18,6 +18,7 @@ from azure.core.utils._utils import _FixedOffset
 from collections.abc import MutableMapping
 from azure.core.exceptions import DeserializationError
 from azure.core import CaseInsensitiveEnumMeta
+from azure.core.pipeline import PipelineResponse
 import copy
 
 _LOGGER = logging.getLogger(__name__)
@@ -253,9 +254,11 @@ _DESERIALIZE_MAPPING = {
 
 
 def _get_model(module_name: str, model_name: str):
+    models = {k: v for k, v in sys.modules[module_name].__dict__.items() if isinstance(v, type)}
     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)}
+    models.update({k: v for k, v in module.__dict__.items() if isinstance(v, type)})
+    model_name = model_name.split(".")[-1]
     if model_name not in models:
         return model_name
     return models[model_name]
@@ -485,7 +488,7 @@ def _get_deserialize_callable_from_annotation(
                 def _deserialize_with_union(union_annotation: typing._GenericAlias, obj):
                     for t in union_annotation.__args__:
                         try:
-                            return _deserialize(t, obj)
+                            return _deserialize(t, obj, module)
                         except DeserializationError:
                             pass
                     raise DeserializationError()
@@ -532,7 +535,7 @@ def _get_deserialize_callable_from_annotation(
                     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, module): _deserialize(value_deserializer, v, module) for k, v in obj.items()
                     }
 
                 return functools.partial(
@@ -552,7 +555,7 @@ def _get_deserialize_callable_from_annotation(
                         if obj is None:
                             return obj
                         return type(obj)(
-                            _deserialize(deserializer, entry) for entry, deserializer in zip(obj, entry_deserializers)
+                            _deserialize(deserializer, entry, module) for entry, deserializer in zip(obj, entry_deserializers)
                         )
 
                     entry_deserializers = [
@@ -567,7 +570,7 @@ def _get_deserialize_callable_from_annotation(
                 ):
                     if obj is None:
                         return obj
-                    return type(obj)(_deserialize(deserializer, entry) for entry in obj)
+                    return type(obj)(_deserialize(deserializer, entry, module) for entry in obj)
 
                 return functools.partial(_deserialize_sequence, deserializer)
         except (TypeError, IndexError, AttributeError, SyntaxError):
@@ -606,8 +609,10 @@ def _deserialize_with_callable(deserializer: typing.Optional[typing.Callable[[ty
         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, "")
+def _deserialize(deserializer: typing.Optional[typing.Callable[[typing.Any], typing.Any]], value: typing.Any, module: str = ""):
+    if isinstance(value, PipelineResponse):
+        value = value.http_response.json()
+    deserializer = _get_deserialize_callable_from_annotation(deserializer, module)
     return _deserialize_with_callable(deserializer, value)
 
 class _RestField:

package/autorest/preprocess/__init__.py

@@ -20,7 +20,11 @@ from .. import YamlUpdatePlugin, YamlUpdatePluginAutorest
 from .._utils import parse_args, get_body_type_for_description, JSON_REGEXP, KNOWN_TYPES
 
 
-def add_body_param_type(code_model: Dict[str, Any], body_parameter: Dict[str, Any]):
+def add_body_param_type(
+    code_model: Dict[str, Any],
+    body_parameter: Dict[str, Any],
+    models_mode: Optional[str],
+):
     if (
         body_parameter
         and body_parameter["type"]["type"] in ("model", "dict", "list")
@@ -30,10 +34,13 @@ def add_body_param_type(code_model: Dict[str, Any], body_parameter: Dict[str, An
         and not body_parameter["type"].get("xmlMetadata")
         and not any(t for t in ["flattened", "groupedBy"] if body_parameter.get(t))
     ):
+        origin_type = body_parameter["type"]["type"]
         body_parameter["type"] = {
             "type": "combined",
             "types": [body_parameter["type"], KNOWN_TYPES["binary"]],
         }
+        if origin_type == "model" and models_mode == "dpg":
+            body_parameter["type"]["types"].insert(1, KNOWN_TYPES["any-object"])
         code_model["types"].append(body_parameter["type"])
 
 
@@ -203,6 +210,12 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
     def version_tolerant(self) -> bool:
         return self.options.get("version-tolerant", True)
 
+    @property
+    def models_mode(self) -> Optional[str]:
+        return self.options.get(
+            "models-mode", "dpg" if self.options.get("cadl_file") else None
+        )
+
     def get_operation_updater(
         self, yaml_data: Dict[str, Any]
     ) -> Callable[[Dict[str, Any], Dict[str, Any]], None]:
@@ -244,7 +257,7 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
             response["discriminator"] = "operation"
         if body_parameter and not is_overload:
             # if we have a JSON body, we add a binary overload
-            add_body_param_type(code_model, body_parameter)
+            add_body_param_type(code_model, body_parameter, self.models_mode)
             add_overloads_for_body_param(yaml_data)
 
     def _update_lro_operation_helper(self, yaml_data: Dict[str, Any]) -> None:
@@ -375,6 +388,7 @@ class PreProcessPluginAutorest(YamlUpdatePluginAutorest, PreProcessPlugin):
         options = {
             "version-tolerant": self._autorestapi.get_boolean_value("version-tolerant"),
             "azure-arm": self._autorestapi.get_boolean_value("azure-arm"),
+            "models-mode": self._autorestapi.get_value("models-mode"),
         }
         return {k: v for k, v in options.items() if v is not None}
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autorest/python",
-  "version": "6.2.9",
+  "version": "6.2.10",
   "description": "The Python extension for generators in AutoRest.",
   "repository": {
     "type": "git",