@autorest/python 6.2.11 → 6.2.12

package/autorest/codegen/models/__init__.py

@@ -9,7 +9,7 @@ from .base import BaseModel
 from .base_builder import BaseBuilder
 from .code_model import CodeModel
 from .client import Client
-from .model_type import ModelType
+from .model_type import ModelType, JSONModelType, DPGModelType, MsrestModelType
 from .dictionary_type import DictionaryType
 from .list_type import ListType
 from .combined_type import CombinedType
@@ -156,7 +156,13 @@ def build_type(yaml_data: Dict[str, Any], code_model: CodeModel) -> BaseType:
         pass
     if yaml_data["type"] == "model":
         # need to special case model to avoid recursion
-        response = ModelType(yaml_data, code_model)
+        if yaml_data["base"] == "json" or not code_model.options["models_mode"]:
+            model_type = JSONModelType
+        elif yaml_data["base"] == "dpg":
+            model_type = DPGModelType  # type: ignore
+        else:
+            model_type = MsrestModelType  # type: ignore
+        response = model_type(yaml_data, code_model)
         code_model.types_map[yaml_id] = response
         response.fill_instance_from_yaml(yaml_data, code_model)
     else:

package/autorest/codegen/models/code_model.py

@@ -190,7 +190,7 @@ class CodeModel:  # pylint: disable=too-many-public-methods
 
     @property
     def public_model_types(self) -> List[ModelType]:
-        return [m for m in self.model_types if m.is_public]
+        return [m for m in self.model_types if m.is_public and not m.base == "json"]
 
     @property
     def enums(self) -> List[EnumType]:

package/autorest/codegen/models/combined_type.py

@@ -79,9 +79,10 @@ class CombinedType(BaseType):
         client_default_value_declaration: Optional[str] = None,
         description: Optional[str] = None,
     ) -> Any:
-        """Template of what this schema would look like as JSON input"""
-        raise ValueError(
-            "You shouldn't get a JSON template representation of multiple types"
+        return self.types[0].get_json_template_representation(
+            optional=optional,
+            client_default_value_declaration=client_default_value_declaration,
+            description=description,
         )
 
     def get_polymorphic_subtypes(self, polymorphic_subtypes: List["ModelType"]) -> None:

package/autorest/codegen/models/model_type.py

@@ -5,13 +5,20 @@
 # --------------------------------------------------------------------------
 from collections import OrderedDict
 from typing import Any, Dict, List, Optional, TYPE_CHECKING, cast
-
+import sys
 from autorest.codegen.models.utils import add_to_pylint_disable
 from .base import BaseType
 from .constant_type import ConstantType
 from .property import Property
 from .imports import FileImport, ImportType, TypingSection
 
+
+if sys.version_info >= (3, 8):
+    from typing import Literal  # pylint: disable=no-name-in-module, ungrouped-imports
+else:
+    from typing_extensions import Literal  # type: ignore  # pylint: disable=ungrouped-imports
+
+
 if TYPE_CHECKING:
     from .code_model import CodeModel
 
@@ -33,7 +40,7 @@ def _get_properties(type: "ModelType", properties: List[Property]) -> List[Prope
     return properties
 
 
-class ModelType(
+class ModelType(  # pylint: disable=abstract-method
     BaseType
 ):  # pylint: disable=too-many-instance-attributes, too-many-public-methods
     """Represents a class ready to be serialized in Python.
@@ -44,6 +51,8 @@ class ModelType(
     :type properties: dict(str, str)
     """
 
+    base: Literal["msrest", "dpg", "json"]
+
     def __init__(
         self,
         yaml_data: Dict[str, Any],
@@ -72,15 +81,6 @@ class ModelType(
     def is_xml(self) -> bool:
         return self.yaml_data.get("isXml", False)
 
-    @property
-    def serialization_type(self) -> str:
-        if self.code_model.options["models_mode"] == "msrest":
-            private_model_path = f"_models.{self.code_model.models_filename}."
-            return f"{'' if self.is_public else private_model_path}{self.name}"
-        if self.code_model.options["models_mode"] == "dpg":
-            return f"{'' if self.is_public else '_models.'}_models.{self.name}"
-        return "object"
-
     @property
     def msrest_deserialization_key(self) -> str:
         return self.name
@@ -89,28 +89,9 @@ class ModelType(
     def is_polymorphic(self) -> bool:
         return any(p.is_polymorphic for p in self.properties)
 
-    def type_annotation(self, **kwargs: Any) -> str:
-        if self.code_model.options["models_mode"]:
-            is_operation_file = kwargs.pop("is_operation_file", False)
-            retval = f"_models.{self.name}"
-            if not self.is_public:
-                retval = f"{self.code_model.models_filename}.{retval}"
-            return retval if is_operation_file else f'"{retval}"'
-        return "ET.Element" if self.is_xml else "JSON"
-
-    def docstring_type(self, **kwargs: Any) -> str:
-        if self.code_model.options["models_mode"]:
-            return f"~{self.code_model.namespace}.models.{self.name}"
-        return "ET.Element" if self.is_xml else "JSON"
-
     def description(self, *, is_operation_file: bool = False) -> str:
         return "" if is_operation_file else self.yaml_data.get("description", self.name)
 
-    def docstring_text(self, **kwargs: Any) -> str:
-        if self.code_model.options["models_mode"]:
-            return self.name
-        return "XML Element" if self.is_xml else "JSON object"
-
     def get_declaration(self, value: Any) -> str:
         return f"{self.name}()"
 
@@ -252,15 +233,6 @@ class ModelType(
         except StopIteration:
             return None
 
-    @property
-    def instance_check_template(self) -> str:
-        models_mode = self.code_model.options["models_mode"]
-        if models_mode == "msrest":
-            return "isinstance({}, msrest.Model)"
-        if models_mode == "dpg":
-            return "isinstance({}, _model_base.Model)"
-        return "isinstance({}, MutableMapping)"
-
     @property
     def pylint_disable(self) -> str:
         retval: str = ""
@@ -277,20 +249,87 @@ class ModelType(
 
     def imports(self, **kwargs: Any) -> FileImport:
         file_import = FileImport()
-        relative_path = kwargs.pop("relative_path", None)
-        if self.code_model.options["models_mode"] and relative_path:
-            # add import for models in operations file
-            file_import.add_submodule_import(
-                relative_path, "models", ImportType.LOCAL, alias="_models"
-            )
-        if self.code_model.options["models_mode"] == "msrest":
-            return file_import
         file_import.add_submodule_import(
             "typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL
         )
+        return file_import
+
+
+class JSONModelType(ModelType):
+    base = "json"
+
+    def type_annotation(self, **kwargs: Any) -> str:
+        return "ET.Element" if self.is_xml else "JSON"
+
+    @property
+    def serialization_type(self) -> str:
+        return "object"
+
+    def docstring_type(self, **kwargs: Any) -> str:
+        return "ET.Element" if self.is_xml else "JSON"
+
+    def docstring_text(self, **kwargs: Any) -> str:
+        return "XML Element" if self.is_xml else "JSON object"
+
+    @property
+    def instance_check_template(self) -> str:
+        return "isinstance({}, MutableMapping)"
+
+    def imports(self, **kwargs: Any) -> FileImport:
+        file_import = super().imports(**kwargs)
         file_import.define_mutable_mapping_type()
         if self.is_xml:
             file_import.add_submodule_import(
                 "xml.etree", "ElementTree", ImportType.STDLIB, alias="ET"
             )
         return file_import
+
+
+class GeneratedModelType(ModelType):  # pylint: disable=abstract-method
+    def type_annotation(self, **kwargs: Any) -> str:
+        is_operation_file = kwargs.pop("is_operation_file", False)
+        retval = f"_models.{self.name}"
+        if not self.is_public:
+            retval = f"{self.code_model.models_filename}.{retval}"
+        return retval if is_operation_file else f'"{retval}"'
+
+    def docstring_type(self, **kwargs: Any) -> str:
+        return f"~{self.code_model.namespace}.models.{self.name}"
+
+    def docstring_text(self, **kwargs: Any) -> str:
+        return self.name
+
+    def imports(self, **kwargs: Any) -> FileImport:
+        file_import = super().imports(**kwargs)
+        relative_path = kwargs.pop("relative_path", None)
+        if relative_path:
+            # add import for models in operations file
+            file_import.add_submodule_import(
+                relative_path, "models", ImportType.LOCAL, alias="_models"
+            )
+        return file_import
+
+
+class MsrestModelType(GeneratedModelType):
+    base = "msrest"
+
+    @property
+    def serialization_type(self) -> str:
+        private_model_path = f"_models.{self.code_model.models_filename}."
+        return f"{'' if self.is_public else private_model_path}{self.name}"
+
+    @property
+    def instance_check_template(self) -> str:
+        return "isinstance({}, msrest.Model)"
+
+
+class DPGModelType(GeneratedModelType):
+    base = "dpg"
+
+    @property
+    def serialization_type(self) -> str:
+        return f"{'' if self.is_public else '_models.'}_models.{self.name}"
+
+    @property
+    def instance_check_template(self) -> str:
+        return "isinstance({}, _model_base.Model)"

package/autorest/codegen/serializers/builder_serializer.py

@@ -314,9 +314,6 @@ class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-
 
     def _json_input_example_template(self, builder: BuilderType) -> List[str]:
         template: List[str] = []
-        if self.code_model.options["models_mode"]:
-            # No input template if we have models
-            return template
         if (
             not builder.parameters.has_body
             or builder.parameters.body_parameter.flattened
@@ -331,6 +328,15 @@ class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-
         if not isinstance(body_param.type, (ListType, DictionaryType, ModelType)):
             return template
 
+        if (
+            isinstance(body_param.type, (ListType, DictionaryType))
+            and self.code_model.options["models_mode"]
+        ):
+            return template
+
+        if isinstance(body_param.type, ModelType) and body_param.type.base != "json":
+            return template
+
         polymorphic_subtypes: List[ModelType] = []
         body_param.type.get_polymorphic_subtypes(polymorphic_subtypes)
         if polymorphic_subtypes:

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

@@ -4,9 +4,9 @@
 
 {{ imports }}
 {% for model in code_model.model_types %}
-{% if code_model.options["models_mode"] == "dpg" %}
+{% if model.base == "dpg" %}
 {% include "model_dpg.py.jinja2" %}
-{% else %}
+{% elif model.base == "msrest" %}
 {% include "model_msrest.py.jinja2" %}
 {% endif %}
 {% endfor %}

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

@@ -65,8 +65,8 @@
         {% for param_signature in serializer.init_line(model) %}
         {{ param_signature }}
         {% endfor %}
-        **kwargs
-    ):
+        **kwargs: Any
+    ) -> None:
         """
     {% if model.properties %}
         {% for p in model.properties %}

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

@@ -38,7 +38,20 @@ import logging
 import re
 import sys
 import codecs
-from typing import Optional, Union, AnyStr, IO, Mapping
+from typing import (
+    Dict,
+    Any,
+    cast,
+    Optional,
+    Union,
+    AnyStr,
+    IO,
+    Mapping,
+    Callable,
+    TypeVar,
+    MutableMapping,
+    Type
+)
 
 try:
     from urllib import quote  # type: ignore
@@ -48,12 +61,13 @@ import xml.etree.ElementTree as ET
 
 import isodate  # type: ignore
 
-from typing import Dict, Any, cast
-
 from azure.core.exceptions import DeserializationError, SerializationError, raise_with_traceback
 
 _BOM = codecs.BOM_UTF8.decode(encoding="utf-8")
 
+ModelType = TypeVar("ModelType", bound="Model")
+JSON = MutableMapping[str, Any]
+
 
 class RawDeserializer:
 
@@ -277,8 +291,8 @@ class Model(object):
     _attribute_map: Dict[str, Dict[str, Any]] = {}
     _validation: Dict[str, Dict[str, Any]] = {}
 
-    def __init__(self, **kwargs):
-        self.additional_properties = {}
+    def __init__(self, **kwargs: Any) -> None:
+        self.additional_properties: Dict[str, Any] = {}
         for k in kwargs:
             if k not in self._attribute_map:
                 _LOGGER.warning("%s is not a known attribute of class %s and will be ignored", k, self.__class__)
@@ -287,25 +301,25 @@ class Model(object):
             else:
                 setattr(self, k, kwargs[k])
 
-    def __eq__(self, other):
+    def __eq__(self, other: Any) -> bool:
         """Compare objects by comparing all attributes."""
         if isinstance(other, self.__class__):
             return self.__dict__ == other.__dict__
         return False
 
-    def __ne__(self, other):
+    def __ne__(self, other: Any) -> bool:
         """Compare objects by comparing all attributes."""
         return not self.__eq__(other)
 
-    def __str__(self):
+    def __str__(self) -> str:
         return str(self.__dict__)
 
     @classmethod
-    def enable_additional_properties_sending(cls):
+    def enable_additional_properties_sending(cls) -> None:
         cls._attribute_map["additional_properties"] = {"key": "", "type": "{object}"}
 
     @classmethod
-    def is_xml_model(cls):
+    def is_xml_model(cls) -> bool:
         try:
             cls._xml_map  # type: ignore
         except AttributeError:
@@ -322,7 +336,7 @@ class Model(object):
 
         return _create_xml_node(xml_map.get("name", cls.__name__), xml_map.get("prefix", None), xml_map.get("ns", None))
 
-    def serialize(self, keep_readonly=False, **kwargs):
+    def serialize(self, keep_readonly: bool = False, **kwargs: Any) -> JSON:
         """Return the JSON that would be sent to azure from this model.
 
         This is an alias to `as_dict(full_restapi_key_transformer, keep_readonly=False)`.
@@ -336,7 +350,14 @@ class Model(object):
         serializer = Serializer(self._infer_class_models())
         return serializer._serialize(self, keep_readonly=keep_readonly, **kwargs)
 
-    def as_dict(self, keep_readonly=True, key_transformer=attribute_transformer, **kwargs):
+    def as_dict(
+        self,
+        keep_readonly: bool = True,
+        key_transformer: Callable[
+            [str, Dict[str, Any], Any], Any
+        ] = attribute_transformer,
+        **kwargs: Any
+    ) -> JSON:
         """Return a dict that can be JSONify using json.dump.
 
         Advanced usage might optionally use a callback as parameter:
@@ -384,7 +405,7 @@ class Model(object):
         return client_models
 
     @classmethod
-    def deserialize(cls, data, content_type=None):
+    def deserialize(cls: Type[ModelType], data: Any, content_type: Optional[str] = None) -> ModelType:
         """Parse a str using the RestAPI syntax and return a model.
 
         :param str data: A str using RestAPI structure. JSON by default.
@@ -396,7 +417,12 @@ class Model(object):
         return deserializer(cls.__name__, data, content_type=content_type)
 
     @classmethod
-    def from_dict(cls, data, key_extractors=None, content_type=None):
+    def from_dict(
+        cls: Type[ModelType],
+        data: Any,
+        key_extractors: Optional[Callable[[str, Dict[str, Any], Any], Any]] = None,
+        content_type: Optional[str] = None,
+    ) -> ModelType:
         """Parse a dict using given key extractor return a model.
 
         By default consider key
@@ -409,7 +435,7 @@ class Model(object):
         :raises: DeserializationError if something went wrong
         """
         deserializer = Deserializer(cls._infer_class_models())
-        deserializer.key_extractors = (
+        deserializer.key_extractors = (  # type: ignore
             [
                 attribute_key_case_insensitive_extractor,
                 rest_key_case_insensitive_extractor,

package/autorest/m4reformatter/__init__.py

@@ -143,6 +143,7 @@ def create_model(yaml_data: Dict[str, Any]) -> Dict[str, Any]:
     base["name"] = yaml_data["language"]["default"]["name"]
     base["description"] = yaml_data["language"]["default"]["description"]
     base["isXml"] = "xml" in yaml_data.get("serializationFormats", [])
+    base["base"] = "msrest"
     return base
 
 

package/autorest/preprocess/__init__.py

@@ -23,7 +23,6 @@ from .._utils import parse_args, get_body_type_for_description, JSON_REGEXP, KNO
 def add_body_param_type(
     code_model: Dict[str, Any],
     body_parameter: Dict[str, Any],
-    models_mode: Optional[str],
 ):
     if (
         body_parameter
@@ -35,11 +34,12 @@ def add_body_param_type(
         and not any(t for t in ["flattened", "groupedBy"] if body_parameter.get(t))
     ):
         origin_type = body_parameter["type"]["type"]
+        is_dpg_model = body_parameter["type"].get("base") == "dpg"
         body_parameter["type"] = {
             "type": "combined",
             "types": [body_parameter["type"], KNOWN_TYPES["binary"]],
         }
-        if origin_type == "model" and models_mode == "dpg":
+        if origin_type == "model" and is_dpg_model:
             body_parameter["type"]["types"].insert(1, KNOWN_TYPES["any-object"])
         code_model["types"].append(body_parameter["type"])
 
@@ -257,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, self.models_mode)
+            add_body_param_type(code_model, body_parameter)
             add_overloads_for_body_param(yaml_data)
 
     def _update_lro_operation_helper(self, yaml_data: Dict[str, Any]) -> None:

package/package.json

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