@autorest/python 6.0.1 → 6.1.2

package/ChangeLog.md

@@ -1,5 +1,62 @@
 # Release History
 
+### 2022-08-16 - 6.1.2
+
+| Library                                                                 | Min Version |
+| ----------------------------------------------------------------------- | ----------- |
+| `@autorest/core`                                                        | `3.8.1`     |
+| `@autorest/modelerfour`                                                 | `4.23.5`    |
+| `azure-core` dep of generated code                                      | `1.24.0`    |
+| `isodate` dep of generated code                                         | `0.6.1`     |
+| `msrest` dep of generated code (If generating legacy code)              | `0.7.1`     |
+| `azure-mgmt-core` dep of generated code (If generating mgmt plane code) | `1.3.0`     |
+
+**Bug Fixes**
+
+- Correctly document polymorphic page responses  #1389
+- Add `__version__` to `__init__.py` for multiapi  #1393
+
+### 2022-07-20 - 6.1.1
+
+| Library                                                                 | Min Version |
+| ----------------------------------------------------------------------- | ----------- |
+| `@autorest/core`                                                        | `3.8.1`     |
+| `@autorest/modelerfour`                                                 | `4.23.5`    |
+| `azure-core` dep of generated code                                      | `1.24.0`    |
+| `isodate` dep of generated code                                         | `0.6.1`     |
+| `msrest` dep of generated code (If generating legacy code)              | `0.7.1`     |
+| `azure-mgmt-core` dep of generated code (If generating mgmt plane code) | `1.3.0`     |
+
+**Other Changes**
+
+- Get skeleton for cadl generation released  #1358
+
+### 2022-07-20 - 6.1.0
+
+| Library                                                                 | Min Version |
+| ----------------------------------------------------------------------- | ----------- |
+| `@autorest/core`                                                        | `3.8.1`     |
+| `@autorest/modelerfour`                                                 | `4.23.5`    |
+| `azure-core` dep of generated code                                      | `1.24.0`    |
+| `isodate` dep of generated code                                         | `0.6.1`     |
+| `msrest` dep of generated code (If generating legacy code)              | `0.7.1`     |
+| `azure-mgmt-core` dep of generated code (If generating mgmt plane code) | `1.3.0`     |
+
+**New Features**
+
+- Add new plugin `MultiClient` and new flag `--multiclientscript` to handle package structure of multi client  #1328
+
+**Bug Fixes**
+
+- Fallback unrecognized type as string to avoid a fatal error. #1341
+- Fix regression in default namespace for SDKs generated without `--namespace` flag  #1354
+
+**Other Changes**
+
+- Generated code no longer supports Python 3.6  #1353
+- Order json input and response template entries by whether they are required or not #1335
+- Reduce extreme amount of `black` logs when running in `--debug` mode to just log errors
+
 ### 2022-06-29 - 6.0.1
 
 | Library                                                                 | Min Version |

package/README.md

@@ -1,4 +1,4 @@
-# Generating with Autorest for Python v5.0.0
+# Generating with Autorest for Python
 
 See [here](https://github.com/Azure/autorest.python/wiki/Generating-with-autorest-for-python-v5.0.0) for Python-specific docs, and [here] for general docs
 
@@ -23,7 +23,7 @@ contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additio
 
 #### Python code gen
 
-```yaml !$(multiapiscript)
+```yaml !$(multiapiscript) && !$(multiclientscript)
 # default values for version tolerant and black
 black: true
 ```
@@ -43,7 +43,7 @@ modelerfour:
 allow-no-input: true
 ```
 
-```yaml !$(multiapiscript)
+```yaml !$(multiapiscript) && !$(multiclientscript)
 pass-thru:
   - model-deduplicator
   - subset-reducer
@@ -161,6 +161,25 @@ scope-postprocess/emitter:
 output-artifact: python-files
 ```
 
+# Multi Client pipeline
+
+```yaml $(multiclientscript)
+pipeline:
+  python/multiclientscript:
+    scope: multiclientscript
+    output-artifact: python-files
+
+  python/multiclientscript/emitter:
+    input: multiclientscript
+    scope: scope-multiclientscript/emitter
+
+scope-multiclientscript/emitter:
+  input-artifact: python-files
+  output-uri-expr: $key
+
+output-artifact: python-files
+```
+
 # Help
 
 ```yaml

package/autorest/__init__.py

@@ -5,6 +5,7 @@
 # --------------------------------------------------------------------------
 import logging
 from pathlib import Path
+import json
 from abc import ABC, abstractmethod
 from typing import Any, Dict, Union
 
@@ -19,21 +20,45 @@ _LOGGER = logging.getLogger(__name__)
 
 
 class ReaderAndWriter:
-    def __init__(self, **kwargs: Any) -> None:
-        pass
+    def __init__(self, *, output_folder: Union[str, Path], **kwargs: Any) -> None:
+        self.output_folder = Path(output_folder)
+        try:
+            with open(
+                Path(self.output_folder) / Path("..") / Path("python.json"), "r"
+            ) as fd:
+                python_json = json.load(fd)
+        except Exception:  # pylint: disable=broad-except
+            python_json = {}
+        self.options = kwargs
+        if python_json:
+            _LOGGER.warning(
+                "Loading python.json file. This behavior will be depreacted"
+            )
+        self.options.update(python_json)
 
     def read_file(self, path: Union[str, Path]) -> str:
         """How does one read a file in cadl?"""
-        raise NotImplementedError("Haven't plugged in Cadl yet")
+        # make path relative to output folder
+        try:
+            with open(self.output_folder / Path(path), "r") as fd:
+                return fd.read()
+        except FileNotFoundError:
+            return ""
 
     def write_file(self, filename: Union[str, Path], file_content: str) -> None:
         """How does writing work in cadl?"""
-        raise NotImplementedError("Haven't plugged in Cadl yet")
+        file_folder = Path(filename).parent
+        if not Path.is_dir(self.output_folder / file_folder):
+            Path.mkdir(self.output_folder / file_folder, parents=True)
+        with open(self.output_folder / Path(filename), "w") as fd:
+            fd.write(file_content)
 
 
 class ReaderAndWriterAutorest(ReaderAndWriter):
-    def __init__(self, *, autorestapi: AutorestAPI) -> None:
-        super().__init__()
+    def __init__(
+        self, *, output_folder: Union[str, Path], autorestapi: AutorestAPI
+    ) -> None:
+        super().__init__(output_folder=output_folder)
         self._autorestapi = autorestapi
 
     def read_file(self, path: Union[str, Path]) -> str:
@@ -49,10 +74,6 @@ class Plugin(ReaderAndWriter, ABC):
     :param autorestapi: An autorest API instance
     """
 
-    def __init__(self, **kwargs: Any) -> None:
-        super().__init__(**kwargs)
-        self.options: Dict[str, Any] = {}
-
     @abstractmethod
     def process(self) -> bool:
         """The plugin process.
@@ -67,8 +88,10 @@ class Plugin(ReaderAndWriter, ABC):
 class PluginAutorest(Plugin, ReaderAndWriterAutorest):
     """For our Autorest plugins, we want to take autorest api as input as options, then pass it to the Plugin"""
 
-    def __init__(self, autorestapi: AutorestAPI) -> None:
-        super().__init__(autorestapi=autorestapi)
+    def __init__(
+        self, autorestapi: AutorestAPI, *, output_folder: Union[str, Path]
+    ) -> None:
+        super().__init__(autorestapi=autorestapi, output_folder=output_folder)
         self.options = self.get_options()
 
     @abstractmethod
@@ -79,15 +102,24 @@ class PluginAutorest(Plugin, ReaderAndWriterAutorest):
 class YamlUpdatePlugin(Plugin):
     """A plugin that update the YAML as input."""
 
+    def get_yaml(self) -> Dict[str, Any]:
+        # cadl file doesn't have to be relative to output folder
+        with open(self.options["cadl_file"], "r") as fd:
+            return yaml.safe_load(fd.read())
+
+    def write_yaml(self, yaml_string: str) -> None:
+        with open(self.options["cadl_file"], "w") as fd:
+            fd.write(yaml_string)
+
     def process(self) -> bool:
         # List the input file, should be only one
-        yaml_data = yaml.safe_load(self.read_file("code-model-v4-no-tags.yaml"))
+        yaml_data = self.get_yaml()
 
         self.update_yaml(yaml_data)
 
         yaml_string = yaml.safe_dump(yaml_data)
 
-        self.write_file("code-model-v4-no-tags.yaml", yaml_string)
+        self.write_yaml(yaml_string)
         return True
 
     @abstractmethod
@@ -103,6 +135,12 @@ class YamlUpdatePlugin(Plugin):
 class YamlUpdatePluginAutorest(  # pylint: disable=abstract-method
     YamlUpdatePlugin, PluginAutorest
 ):
+    def get_yaml(self) -> Dict[str, Any]:
+        return yaml.safe_load(self.read_file("code-model-v4-no-tags.yaml"))
+
+    def write_yaml(self, yaml_string: str) -> None:
+        self.write_file("code-model-v4-no-tags.yaml", yaml_string)
+
     def get_options(self) -> Dict[str, Any]:
         inputs = self._autorestapi.list_inputs()
         _LOGGER.debug("Possible Inputs: %s", inputs)

package/autorest/_utils.py

@@ -0,0 +1,75 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+from typing import Any, Dict
+import re
+import argparse
+
+
+def to_snake_case(name: str) -> str:
+    def replace_upper_characters(m) -> str:
+        match_str = m.group().lower()
+        if m.start() > 0 and name[m.start() - 1] == "_":
+            # we are good if a '_' already exists
+            return match_str
+        # the first letter should not have _
+        prefix = "_" if m.start() > 0 else ""
+
+        # we will add an extra _ if there are multiple upper case chars together
+        next_non_upper_case_char_location = m.start() + len(match_str)
+        if (
+            len(match_str) > 2
+            and len(name) - next_non_upper_case_char_location > 1
+            and name[next_non_upper_case_char_location].isalpha()
+        ):
+
+            return (
+                prefix
+                + match_str[: len(match_str) - 1]
+                + "_"
+                + match_str[len(match_str) - 1]
+            )
+
+        return prefix + match_str
+
+    return re.sub("[A-Z]+", replace_upper_characters, name)
+
+
+def parse_args(need_cadl_file: bool = True):
+    parser = argparse.ArgumentParser(
+        description="Run mypy against target folder. Add a local custom plugin to the path prior to execution. "
+    )
+    parser.add_argument(
+        "--output-folder",
+        dest="output_folder",
+        help="Output folder for generated SDK",
+        required=True,
+    )
+    parser.add_argument(
+        "--cadl-file",
+        dest="cadl_file",
+        help="Serialized cadl file",
+        required=need_cadl_file,
+    )
+
+    return parser.parse_args()
+
+
+def get_body_type_for_description(body_parameter: Dict[str, Any]) -> str:
+    if body_parameter["type"]["type"] == "binary":
+        return "binary"
+    if body_parameter["type"]["type"] == "string":
+        return "string"
+    return "JSON"
+
+
+# used if we want to get a string / binary type etc
+KNOWN_TYPES: Dict[str, Dict[str, Any]] = {
+    "string": {"type": "string"},
+    "binary": {"type": "binary"},
+    "anydict": {"type": "dict", "elementType": {"type": "any"}},
+}
+
+JSON_REGEXP = re.compile(r"^(application|text)/(.+\+)?json$")

package/autorest/black/__init__.py

@@ -10,8 +10,9 @@ from typing import Any, Dict
 import black
 
 from .. import Plugin, PluginAutorest
+from .._utils import parse_args
 
-_LOGGER = logging.getLogger(__name__)
+logging.getLogger("blib2to3").setLevel(logging.ERROR)
 
 _BLACK_MODE = black.Mode()
 _BLACK_MODE.line_length = 120
@@ -20,12 +21,12 @@ _BLACK_MODE.line_length = 120
 class BlackScriptPlugin(Plugin):  # pylint: disable=abstract-method
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
-        output_folder_uri = self.options["outputFolderUri"]
-        if output_folder_uri.startswith("file:"):
-            output_folder_uri = output_folder_uri[5:]
-        if os.name == "nt" and output_folder_uri.startswith("///"):
-            output_folder_uri = output_folder_uri[3:]
-        self.output_folder = Path(output_folder_uri)
+        output_folder = self.options.get("output_folder", str(self.output_folder))
+        if output_folder.startswith("file:"):
+            output_folder = output_folder[5:]
+        if os.name == "nt" and output_folder.startswith("///"):
+            output_folder = output_folder[3:]
+        self.output_folder = Path(output_folder)
 
     def process(self) -> bool:
         # apply format_file on every file in the output folder
@@ -54,4 +55,10 @@ class BlackScriptPlugin(Plugin):  # pylint: disable=abstract-method
 
 class BlackScriptPluginAutorest(BlackScriptPlugin, PluginAutorest):
     def get_options(self) -> Dict[str, Any]:
-        return {"outputFolderUri": self._autorestapi.get_value("outputFolderUri")}
+        return {"output_folder": self._autorestapi.get_value("outputFolderUri")}
+
+
+if __name__ == "__main__":
+    # CADL pipeline will call this
+    args = parse_args(need_cadl_file=False)
+    BlackScriptPlugin(output_folder=args.output_folder).process()

package/autorest/cadlflags/__init__.py

@@ -0,0 +1,128 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+import logging
+from typing import Any, Dict, List
+from .. import YamlUpdatePlugin
+from .._utils import parse_args
+
+_LOGGER = logging.getLogger(__name__)
+
+OAUTH_TYPE = "OAuth2"
+KEY_TYPE = "Key"
+
+
+def get_azure_key_credential(key: str) -> Dict[str, Any]:
+    return {
+        "type": KEY_TYPE,
+        "policy": {"type": "AzureKeyCredentialPolicy", "key": key},
+    }
+
+
+class CadlFlags(YamlUpdatePlugin):  # pylint: disable=abstract-method
+    """A plugin to apply flags from backdoor python.json into cadl yaml file"""
+
+    def update_yaml(self, yaml_data: Dict[str, Any]) -> None:
+        """Convert in place the YAML str."""
+        if self.options.get("add-credential"):
+            self.update_credential(yaml_data)
+        if self.options.get("namespace"):
+            yaml_data["client"]["namespace"] = self.options["namespace"]
+        if self.options.get("title"):
+            yaml_data["client"]["name"] = self.options["title"]
+
+    def get_credential_scopes_from_flags(self, auth_policy: str) -> List[str]:
+        if self.options.get("azure-arm"):
+            return ["https://management.azure.com/.default"]
+        credential_scopes_temp = self.options.get("credential-scopes")
+        credential_scopes = (
+            credential_scopes_temp.split(",") if credential_scopes_temp else None
+        )
+        if self.options.get("credential-scopes", False) and not credential_scopes:
+            raise ValueError(
+                "--credential-scopes takes a list of scopes in comma separated format. "
+                "For example: --credential-scopes=https://cognitiveservices.azure.com/.default"
+            )
+        if not credential_scopes:
+            _LOGGER.warning(
+                "You have default credential policy %s "
+                "but not the --credential-scopes flag set while generating non-management plane code. "
+                "This is not recommend because it forces the customer to pass credential scopes "
+                "through kwargs if they want to authenticate.",
+                auth_policy,
+            )
+            credential_scopes = []
+        return credential_scopes
+
+    def get_token_credential(self, credential_scopes: List[str]) -> Dict[str, Any]:
+        return {
+            "type": OAUTH_TYPE,
+            "policy": {
+                "type": "ARMChallengeAuthenticationPolicy"
+                if self.options.get("azure-arm")
+                else "BearerTokenCredentialPolicy",
+                "credentialScopes": credential_scopes,
+            },
+        }
+
+    def update_credential_from_flags(self) -> Dict[str, Any]:
+        default_auth_policy = (
+            "ARMChallengeAuthenticationPolicy"
+            if self.options.get("azure-arm")
+            else "BearerTokenCredentialPolicy"
+        )
+        auth_policy = (
+            self.options.get("credential-default-policy-type") or default_auth_policy
+        )
+        credential_scopes = self.get_credential_scopes_from_flags(auth_policy)
+        key = self.options.get("credential-key-header-name")
+        if auth_policy.lower() in (
+            "armchallengeauthenticationpolicy",
+            "bearertokencredentialpolicy",
+        ):
+            if key:
+                raise ValueError(
+                    "You have passed in a credential key header name with default credential policy type "
+                    f"{auth_policy}. This is not allowed, since credential key header "
+                    "name is tied with AzureKeyCredentialPolicy. Instead, with this policy it is recommend you "
+                    "pass in --credential-scopes."
+                )
+            return self.get_token_credential(credential_scopes)
+        # Otherwise you have AzureKeyCredentialPolicy
+        if self.options.get("credential-scopes"):
+            raise ValueError(
+                "You have passed in credential scopes with default credential policy type "
+                "AzureKeyCredentialPolicy. This is not allowed, since credential scopes is tied with "
+                f"{default_auth_policy}. Instead, with this policy "
+                "you must pass in --credential-key-header-name."
+            )
+        if not key:
+            key = "api-key"
+            _LOGGER.info(
+                "Defaulting the AzureKeyCredentialPolicy header's name to 'api-key'"
+            )
+        return get_azure_key_credential(key)
+
+    def update_credential(self, yaml_data: Dict[str, Any]) -> None:
+        credential_type = self.update_credential_from_flags()
+        yaml_data["types"].append(credential_type)
+        credential = {
+            "type": credential_type,
+            "optional": False,
+            "description": "Credential needed for the client to connect to Azure.",
+            "clientName": "credential",
+            "location": "other",
+            "restApiName": "credential",
+            "implementation": "Client",
+            "skipUrlEncoding": True,
+            "inOverload": False,
+        }
+        yaml_data["client"]["parameters"].append(credential)
+
+
+if __name__ == "__main__":
+    # CADL pipeline will call this
+    args = parse_args()
+    CadlFlags(output_folder=args.output_folder, cadl_file=args.cadl_file).process()

package/autorest/codegen/__init__.py

@@ -4,19 +4,20 @@
 # license information.
 # --------------------------------------------------------------------------
 import logging
-import sys
 from typing import Dict, Any, Union, cast
 from pathlib import Path
 import yaml
 
 
 from .. import Plugin, PluginAutorest
+from .._utils import parse_args
 from .models.client import Client, Config
 from .models.code_model import CodeModel
 from .models import build_type
 from .models.request_builder import get_request_builder
 from .models.operation_group import OperationGroup
 from .serializers import JinjaSerializer, JinjaSerializerAutorest
+from ._utils import DEFAULT_HEADER_TEXT
 
 
 def _build_convenience_layer(yaml_data: Dict[str, Any], code_model: CodeModel) -> None:
@@ -163,7 +164,7 @@ class CodeGenerator(Plugin):
     def _build_code_model_options(self) -> Dict[str, Any]:
         """Build en options dict from the user input while running autorest."""
         azure_arm = self.options.get("azure-arm", False)
-        license_header = self.options["header-text"]
+        license_header = self.options.get("header-text", DEFAULT_HEADER_TEXT)
         if license_header:
             license_header = license_header.replace("\n", "\n# ")
             license_header = (
@@ -236,12 +237,12 @@ class CodeGenerator(Plugin):
         return options
 
     def get_yaml(self) -> Dict[str, Any]:
-        # cadl should call this one
-        raise NotImplementedError()
+        # cadl file doesn't have to be relative to output folder
+        with open(self.options["cadl_file"], "r") as fd:
+            return yaml.safe_load(fd.read())
 
-    @staticmethod
-    def get_serializer(code_model: CodeModel):
-        return JinjaSerializer(code_model)
+    def get_serializer(self, code_model: CodeModel):
+        return JinjaSerializer(code_model, output_folder=self.output_folder)
 
     def process(self) -> bool:
         # List the input file, should be only one
@@ -351,20 +352,12 @@ class CodeGeneratorAutorest(CodeGenerator, PluginAutorest):
         return yaml.safe_load(file_content)
 
     def get_serializer(self, code_model: CodeModel):  # type: ignore
-        return JinjaSerializerAutorest(self._autorestapi, code_model)
-
-
-def main(yaml_model_file: str) -> None:
-    from ..jsonrpc.localapi import (  # pylint: disable=import-outside-toplevel
-        LocalAutorestAPI,
-    )
-
-    code_generator = CodeGeneratorAutorest(
-        autorestapi=LocalAutorestAPI(reachable_files=[yaml_model_file])
-    )
-    if not code_generator.process():
-        raise SystemExit("Process didn't finish gracefully")
+        return JinjaSerializerAutorest(
+            self._autorestapi, code_model, output_folder=self.output_folder
+        )
 
 
 if __name__ == "__main__":
-    main(sys.argv[1])
+    # CADL pipeline will call this
+    args = parse_args()
+    CodeGenerator(output_folder=args.output_folder, cadl_file=args.cadl_file).process()

package/autorest/codegen/_utils.py

@@ -0,0 +1,12 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+
+DEFAULT_HEADER_TEXT = (
+    "Copyright (c) Microsoft Corporation. All rights reserved.\n"
+    "Licensed under the MIT License. See License.txt in the project root for license information.\n"
+    "Code generated by Microsoft (R) Python Code Generator.\n"
+    "Changes may cause incorrect behavior and will be lost if the code is regenerated."
+)

package/autorest/codegen/models/__init__.py

@@ -3,6 +3,7 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
+import logging
 from typing import Any, Dict, Union
 from .base_model import BaseModel
 from .code_model import CodeModel
@@ -140,6 +141,7 @@ TYPE_TO_OBJECT = {
     "any-object": AnyObjectType,
     "unixtime": UnixTimeType,
 }
+_LOGGER = logging.getLogger(__name__)
 
 
 def build_type(yaml_data: Dict[str, Any], code_model: CodeModel) -> BaseType:
@@ -155,7 +157,14 @@ def build_type(yaml_data: Dict[str, Any], code_model: CodeModel) -> BaseType:
         code_model.types_map[yaml_id] = response
         response.fill_instance_from_yaml(yaml_data, code_model)
     else:
-        response = TYPE_TO_OBJECT[yaml_data["type"]].from_yaml(yaml_data, code_model)  # type: ignore
+        object_type = yaml_data.get("type", None)
+        if object_type is None:
+            _LOGGER.warning(
+                'Unrecognized definition type "%s" is found, falling back it as "string"! ',
+                yaml_data["type"],
+            )
+            object_type = "string"
+        response = TYPE_TO_OBJECT[object_type].from_yaml(yaml_data, code_model)  # type: ignore
     code_model.types_map[yaml_id] = response
     return response
 

package/autorest/codegen/models/combined_type.py

@@ -10,6 +10,7 @@ from .base_type import BaseType
 
 if TYPE_CHECKING:
     from .code_model import CodeModel
+    from .model_type import ModelType
 
 
 class CombinedType(BaseType):
@@ -82,6 +83,9 @@ class CombinedType(BaseType):
             "You shouldn't get a JSON template representation of multiple types"
         )
 
+    def get_polymorphic_subtypes(self, polymorphic_subtypes: List["ModelType"]) -> None:
+        raise ValueError("You shouldn't get polymorphic subtypes of multiple types")
+
     @property
     def instance_check_template(self) -> str:
         """Template of what an instance check of a variable for this type would look like"""

package/autorest/codegen/models/model_type.py

@@ -3,6 +3,7 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
+from collections import OrderedDict
 from typing import Any, Dict, List, Optional, TYPE_CHECKING, cast
 
 from autorest.codegen.models.utils import add_to_pylint_disable
@@ -60,6 +61,7 @@ class ModelType(BaseType):  # pylint: disable=too-many-instance-attributes
             "discriminatorValue"
         )
         self._created_json_template_representation = False
+        self._got_polymorphic_subtypes = False
         self.is_public: bool = self.yaml_data.get("isPublic", True)
         self.snake_case_name: str = self.yaml_data["snakeCaseName"]
 
@@ -153,12 +155,26 @@ class ModelType(BaseType):  # pylint: disable=too-many-instance-attributes
         # once we've finished, we want to reset created_json_template_representation to false
         # so we can call it again
         self._created_json_template_representation = False
-        return representation
+        optional_keys = [
+            f'"{p.rest_api_name}"'
+            for p in self.properties
+            if getattr(p, "optional", False)
+        ]
+        return OrderedDict(
+            sorted(
+                representation.items(),
+                key=lambda item: f"{1 if item[0] in optional_keys else 0}{item[0]}",
+            )
+        )
 
     def get_polymorphic_subtypes(self, polymorphic_subtypes: List["ModelType"]) -> None:
+
         is_polymorphic_subtype = (
             self.discriminator_value and not self.discriminated_subtypes
         )
+        if self._got_polymorphic_subtypes:
+            return
+        self._got_polymorphic_subtypes = True
         if (
             self.name not in (m.name for m in polymorphic_subtypes)
             and is_polymorphic_subtype
@@ -168,6 +184,7 @@ class ModelType(BaseType):  # pylint: disable=too-many-instance-attributes
             discriminated_subtype.get_polymorphic_subtypes(polymorphic_subtypes)
         for property in self.properties:
             property.get_polymorphic_subtypes(polymorphic_subtypes)
+        self._got_polymorphic_subtypes = False
 
     @classmethod
     def from_yaml(