@autorest/python 6.0.0 → 6.1.1

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/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
@@ -153,7 +154,17 @@ 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 = (

package/autorest/codegen/serializers/__init__.py

@@ -3,12 +3,13 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import Dict, List, Optional, Any, Union
+from typing import Dict, List, Optional, Any, Union, cast
 from pathlib import Path
 from jinja2 import PackageLoader, Environment, FileSystemLoader, StrictUndefined
 from autorest.codegen.models.operation_group import OperationGroup
 from autorest.codegen.models.request_builder import OverloadedRequestBuilder
 
+from ... import ReaderAndWriter, ReaderAndWriterAutorest
 from ...jsonrpc import AutorestAPI
 from ..models import CodeModel, OperationGroup, RequestBuilder
 from ..models import TokenCredentialType
@@ -38,9 +39,11 @@ _PACKAGE_FILES = [
 _REGENERATE_FILES = {"setup.py", "MANIFEST.in"}
 
 
-class JinjaSerializer:
-    def __init__(self, autorestapi: AutorestAPI, code_model: CodeModel) -> None:
-        self._autorestapi = autorestapi
+class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
+    def __init__(
+        self, code_model: CodeModel, *, output_folder: Union[str, Path], **kwargs: Any
+    ) -> None:
+        super().__init__(output_folder=output_folder, **kwargs)
         self.code_model = code_model
 
     @property
@@ -129,10 +132,10 @@ class JinjaSerializer:
             )
         if not self.code_model.options["models_mode"]:
             # keep models file if users ended up just writing a models file
-            if self._autorestapi.read_file(namespace_path / Path("models.py")):
-                self._autorestapi.write_file(
+            if self.read_file(namespace_path / Path("models.py")):
+                self.write_file(
                     namespace_path / Path("models.py"),
-                    self._autorestapi.read_file(namespace_path / Path("models.py")),
+                    cast(str, self.read_file(namespace_path / Path("models.py"))),
                 )
 
         if self.code_model.options["package_mode"]:
@@ -143,16 +146,15 @@ class JinjaSerializer:
             for template_name in package_files:
                 file = template_name.replace(".jinja2", "")
                 output_name = out_path / file
-                if (
-                    not self._autorestapi.read_file(output_name)
-                    or file in _REGENERATE_FILES
-                ):
+                if not self.read_file(output_name) or file in _REGENERATE_FILES:
                     template = env.get_template(template_name)
                     render_result = template.render(**kwargs)
-                    self._autorestapi.write_file(output_name, render_result)
+                    self.write_file(output_name, render_result)
 
         def _prepare_params() -> Dict[Any, Any]:
-            package_parts = package_name.split("-")[:-1]
+            package_parts = (self.code_model.options["package_name"] or "").split("-")[
+                :-1
+            ]
             token_cred = isinstance(
                 getattr(self.code_model.credential, "type", None), TokenCredentialType
             )
@@ -179,14 +181,7 @@ class JinjaSerializer:
             params.update(self.code_model.package_dependency)
             return params
 
-        package_name = (
-            self.code_model.options["package_name"]
-            or self.code_model.client.name.lower()
-        )
-        count = package_name.count("-") + 1
-        for _ in range(count):
-            out_path = out_path / Path("..")
-
+        out_path = out_path / Path("../" * (self.code_model.namespace.count(".") + 1))
         if self.code_model.options["package_mode"] in ("dataplane", "mgmtplane"):
             env = Environment(
                 loader=PackageLoader("autorest.codegen", "templates"),
@@ -207,12 +202,10 @@ class JinjaSerializer:
             _serialize_and_write_package_files_proc(**params)
 
     def _keep_patch_file(self, path_file: Path, env: Environment):
-        if self._autorestapi.read_file(path_file):
-            self._autorestapi.write_file(
-                path_file, self._autorestapi.read_file(path_file)
-            )
+        if self.read_file(path_file):
+            self.write_file(path_file, self.read_file(path_file))
         else:
-            self._autorestapi.write_file(
+            self.write_file(
                 path_file,
                 PatchSerializer(env=env, code_model=self.code_model).serialize(),
             )
@@ -223,16 +216,16 @@ class JinjaSerializer:
         # Write the models folder
         models_path = namespace_path / Path("models")
         if self.code_model.model_types:
-            self._autorestapi.write_file(
+            self.write_file(
                 models_path / Path(f"{self.code_model.models_filename}.py"),
                 ModelSerializer(code_model=self.code_model, env=env).serialize(),
             )
         if self.code_model.enums:
-            self._autorestapi.write_file(
+            self.write_file(
                 models_path / Path(f"{self.code_model.enums_filename}.py"),
                 EnumSerializer(code_model=self.code_model, env=env).serialize(),
             )
-        self._autorestapi.write_file(
+        self.write_file(
             models_path / Path("__init__.py"),
             ModelInitSerializer(code_model=self.code_model, env=env).serialize(),
         )
@@ -253,7 +246,7 @@ class JinjaSerializer:
                 env, rest_path, request_builders
             )
         if not "" in group_names:
-            self._autorestapi.write_file(
+            self.write_file(
                 rest_path / Path("__init__.py"),
                 self.code_model.options["license_header"],
             )
@@ -267,7 +260,7 @@ class JinjaSerializer:
         group_name = request_builders[0].group_name
         output_path = rest_path / Path(group_name) if group_name else rest_path
         # write generic request builders file
-        self._autorestapi.write_file(
+        self.write_file(
             output_path / Path("_request_builders.py"),
             RequestBuildersSerializer(
                 code_model=self.code_model,
@@ -277,7 +270,7 @@ class JinjaSerializer:
         )
 
         # write rest init file
-        self._autorestapi.write_file(
+        self.write_file(
             output_path / Path("__init__.py"),
             RequestBuildersSerializer(
                 code_model=self.code_model,
@@ -300,7 +293,7 @@ class JinjaSerializer:
             async_mode=False,
             operation_group=operation_group,
         )
-        self._autorestapi.write_file(
+        self.write_file(
             namespace_path
             / Path(self.code_model.operations_folder_name)
             / Path(f"{filename}.py"),
@@ -315,7 +308,7 @@ class JinjaSerializer:
                 async_mode=True,
                 operation_group=operation_group,
             )
-            self._autorestapi.write_file(
+            self.write_file(
                 (
                     namespace_path
                     / Path("aio")
@@ -332,7 +325,7 @@ class JinjaSerializer:
         operations_init_serializer = OperationsInitSerializer(
             code_model=self.code_model, env=env, async_mode=False
         )
-        self._autorestapi.write_file(
+        self.write_file(
             namespace_path
             / Path(self.code_model.operations_folder_name)
             / Path("__init__.py"),
@@ -344,7 +337,7 @@ class JinjaSerializer:
             operations_async_init_serializer = OperationsInitSerializer(
                 code_model=self.code_model, env=env, async_mode=True
             )
-            self._autorestapi.write_file(
+            self.write_file(
                 namespace_path
                 / Path("aio")
                 / Path(self.code_model.operations_folder_name)
@@ -369,12 +362,10 @@ class JinjaSerializer:
         self, namespace_path: Path, general_serializer: GeneralSerializer
     ):
         def _read_version_file(original_version_file_name: str) -> str:
-            return self._autorestapi.read_file(
-                namespace_path / original_version_file_name
-            )
+            return self.read_file(namespace_path / original_version_file_name)
 
         def _write_version_file(original_version_file_name: str) -> None:
-            self._autorestapi.write_file(
+            self.write_file(
                 namespace_path / Path("_version.py"),
                 _read_version_file(original_version_file_name),
             )
@@ -385,7 +376,7 @@ class JinjaSerializer:
         elif keep_version_file and _read_version_file("version.py"):
             _write_version_file(original_version_file_name="version.py")
         elif self.code_model.options["package_version"]:
-            self._autorestapi.write_file(
+            self.write_file(
                 namespace_path / Path("_version.py"),
                 general_serializer.serialize_version_file(),
             )
@@ -397,14 +388,14 @@ class JinjaSerializer:
             code_model=self.code_model, env=env, async_mode=False
         )
 
-        self._autorestapi.write_file(
+        self.write_file(
             namespace_path / Path("__init__.py"),
             general_serializer.serialize_init_file(),
         )
         p = namespace_path.parent
         while p != Path("."):
             # write pkgutil init file
-            self._autorestapi.write_file(
+            self.write_file(
                 p / Path("__init__.py"),
                 general_serializer.serialize_pkgutil_init_file(),
             )
@@ -412,13 +403,13 @@ class JinjaSerializer:
 
         # Write the service client
         if self.code_model.request_builders:
-            self._autorestapi.write_file(
+            self.write_file(
                 namespace_path / Path(f"{self.code_model.client.filename}.py"),
                 general_serializer.serialize_service_client_file(),
             )
 
         if self.code_model.need_vendored_code(async_mode=False):
-            self._autorestapi.write_file(
+            self.write_file(
                 namespace_path / Path("_vendor.py"),
                 general_serializer.serialize_vendor_file(),
             )
@@ -426,31 +417,27 @@ class JinjaSerializer:
         self._serialize_and_write_version_file(namespace_path, general_serializer)
 
         # write the empty py.typed file
-        self._autorestapi.write_file(
-            namespace_path / Path("py.typed"), "# Marker file for PEP 561."
-        )
+        self.write_file(namespace_path / Path("py.typed"), "# Marker file for PEP 561.")
 
         if (
             not self.code_model.options["client_side_validation"]
             and not self.code_model.options["multiapi"]
         ):
-            self._autorestapi.write_file(
+            self.write_file(
                 namespace_path / Path("_serialization.py"),
                 general_serializer.serialize_serialization_file(),
             )
 
         # Write the config file
         if self.code_model.request_builders:
-            self._autorestapi.write_file(
+            self.write_file(
                 namespace_path / Path("_configuration.py"),
                 general_serializer.serialize_config_file(),
             )
 
         # Write the setup file
         if self.code_model.options["basic_setup_py"]:
-            self._autorestapi.write_file(
-                Path("setup.py"), general_serializer.serialize_setup_file()
-            )
+            self.write_file(Path("setup.py"), general_serializer.serialize_setup_file())
 
     def _serialize_and_write_aio_top_level_folder(
         self, env: Environment, namespace_path: Path
@@ -462,24 +449,24 @@ class JinjaSerializer:
         aio_path = namespace_path / Path("aio")
 
         # Write the __init__ file
-        self._autorestapi.write_file(
+        self.write_file(
             aio_path / Path("__init__.py"), aio_general_serializer.serialize_init_file()
         )
 
         # Write the service client
         if self.code_model.request_builders:
-            self._autorestapi.write_file(
+            self.write_file(
                 aio_path / Path(f"{self.code_model.client.filename}.py"),
                 aio_general_serializer.serialize_service_client_file(),
             )
 
         # Write the config file
-        self._autorestapi.write_file(
+        self.write_file(
             aio_path / Path("_configuration.py"),
             aio_general_serializer.serialize_config_file(),
         )
         if self.code_model.need_vendored_code(async_mode=True):
-            self._autorestapi.write_file(
+            self.write_file(
                 aio_path / Path("_vendor.py"),
                 aio_general_serializer.serialize_vendor_file(),
             )
@@ -488,6 +475,19 @@ class JinjaSerializer:
         self, env: Environment, namespace_path: Path
     ) -> None:
         metadata_serializer = MetadataSerializer(self.code_model, env)
-        self._autorestapi.write_file(
+        self.write_file(
             namespace_path / Path("_metadata.json"), metadata_serializer.serialize()
         )
+
+
+class JinjaSerializerAutorest(JinjaSerializer, ReaderAndWriterAutorest):
+    def __init__(
+        self,
+        autorestapi: AutorestAPI,
+        code_model: CodeModel,
+        *,
+        output_folder: Union[str, Path],
+    ) -> None:
+        super().__init__(
+            autorestapi=autorestapi, code_model=code_model, output_folder=output_folder
+        )

package/autorest/codegen/serializers/builder_serializer.py

@@ -79,9 +79,7 @@ def _improve_json_string(template_representation: str) -> Any:
 
 def _json_dumps_template(template_representation: Any) -> Any:
     # only for template use, since it wraps everything in strings
-    return _improve_json_string(
-        json.dumps(template_representation, sort_keys=True, indent=4)
-    )
+    return _improve_json_string(json.dumps(template_representation, indent=4))
 
 
 def _get_polymorphic_subtype_template(polymorphic_subtype: ModelType) -> List[str]:

package/autorest/codegen/serializers/client_serializer.py

@@ -16,6 +16,11 @@ class ClientSerializer:
         self.parameter_serializer = ParameterSerializer()
 
     def _init_signature(self, async_mode: bool) -> str:
+        pylint_disable = ""
+        if not self.code_model.client.parameters.credential:
+            pylint_disable = (
+                "  # pylint: disable=missing-client-constructor-parameter-credential"
+            )
         return self.parameter_serializer.serialize_method(
             function_def="def",
             method_name="__init__",
@@ -23,6 +28,7 @@ class ClientSerializer:
             method_param_signatures=self.code_model.client.parameters.method_signature(
                 async_mode
             ),
+            pylint_disable=pylint_disable,
         )
 
     def init_signature_and_response_type_annotation(self, async_mode: bool) -> str:

package/autorest/codegen/templates/README.md.jinja2

@@ -2,7 +2,7 @@
 # Microsoft Azure SDK for Python
 
 This is the Microsoft {{package_pprint_name}} Client Library.
-This package has been tested with Python 3.6+.
+This package has been tested with Python 3.7+.
 For a more complete view of Azure libraries, see the [azure sdk python release](https://aka.ms/azsdk/python/all).
 
 # Usage
@@ -17,7 +17,7 @@ Additional code samples for different Azure services are available at [Samples R
 
 If you encounter any bugs or have suggestions, please file an issue in the
 [Issues](https://github.com/Azure/azure-sdk-for-python/issues)
-section of the project. 
+section of the project.
 
 
 ![Impressions](https://azure-sdk-impressions.azurewebsites.net/api/impressions/azure-sdk-for-python%2F{{package_name}}%2FREADME.png)
@@ -35,7 +35,7 @@ python -m pip install {{ package_name }}
 
 #### Prequisites
 
-- Python 3.6 or later is required to use this package.
+- Python 3.7 or later is required to use this package.
 - You need an [Azure subscription][azure_sub] to use this package.
 - An existing {{ package_pprint_name }} instance.
 

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

@@ -54,7 +54,6 @@ setup(
         "Programming Language :: Python",
         "Programming Language :: Python :: 3 :: Only",
         "Programming Language :: Python :: 3",
-        "Programming Language :: Python :: 3.6",
         "Programming Language :: Python :: 3.7",
         "Programming Language :: Python :: 3.8",
         "Programming Language :: Python :: 3.9",
@@ -94,7 +93,7 @@ setup(
         {% endif %}
     ],
     {% if package_mode %}
-    python_requires=">=3.6",
+    python_requires=">=3.7",
     {% else %}
     long_description="""\
     {{ code_model.client.description }}

package/autorest/jsonrpc/server.py

@@ -26,6 +26,7 @@ def GetPluginNames():
         "black",
         "multiapiscript",
         "postprocess",
+        "multiclientscript",
     ]
 
 
@@ -43,24 +44,29 @@ def Process(plugin_name: str, session_id: str) -> bool:
             session_id,
         )
         if plugin_name == "m2r":
-            from ..m2r import M2R as PluginToLoad
+            from ..m2r import M2RAutorest as PluginToLoad
         elif plugin_name == "preprocess":
-            from ..preprocess import PreProcessPlugin as PluginToLoad  # type: ignore
+            from ..preprocess import PreProcessPluginAutorest as PluginToLoad  # type: ignore
         elif plugin_name == "m4reformatter":
             from ..m4reformatter import M4Reformatter as PluginToLoad  # type: ignore
         elif plugin_name == "codegen":
-            from ..codegen import CodeGenerator as PluginToLoad  # type: ignore
+            from ..codegen import CodeGeneratorAutorest as PluginToLoad  # type: ignore
         elif plugin_name == "postprocess":
-            from ..postprocess import PostProcessPlugin as PluginToLoad  # type: ignore
+            from ..postprocess import PostProcessPluginAutorest as PluginToLoad  # type: ignore
         elif plugin_name == "black":
-            from ..black import BlackScriptPlugin as PluginToLoad  # type: ignore
+            from ..black import BlackScriptPluginAutorest as PluginToLoad  # type: ignore
         elif plugin_name == "multiapiscript":
-            from ..multiapi import MultiApiScriptPlugin as PluginToLoad  # type: ignore
+            from ..multiapi import MultiApiScriptPluginAutorest as PluginToLoad  # type: ignore
+        elif plugin_name == "multiclientscript":
+            from ..multiclient import MultiClientPluginAutorest as PluginToLoad  # type: ignore
         else:
             _LOGGER.fatal("Unknown plugin name %s", plugin_name)
             raise RuntimeError(f"Unknown plugin name {plugin_name}")
 
-        plugin = PluginToLoad(stdstream_connection)
+        plugin = PluginToLoad(
+            autorestapi=stdstream_connection,
+            output_folder=stdstream_connection.get_value("output-folder"),
+        )
 
         try:
             _LOGGER.debug("Starting plugin %s", PluginToLoad.__name__)

package/autorest/m2r/__init__.py

@@ -8,25 +8,26 @@
 import logging
 from typing import Any, Dict, Set
 
-import m2r
+import m2r2
 
-from .. import YamlUpdatePlugin
+from .. import YamlUpdatePluginAutorest, YamlUpdatePlugin
+from .._utils import parse_args
 
 
 _LOGGER = logging.getLogger(__name__)
 
 
-class AutorestRender(m2r.RestRenderer):
+class AutorestRender(m2r2.RestRenderer):
     """Redefine the concept of inline HTML in the renderer, we don't want to define a new format
     in the description/summary.
     """
 
-    def inline_html(self, html: str) -> str:
+    def inline_html(self, html: str) -> str:  # pylint: disable=no-self-use
         """Do not render inline HTML with a role definition."""
         return f":code:`{html}`"
 
 
-class M2R(YamlUpdatePlugin):
+class M2R(YamlUpdatePlugin):  # pylint: disable=abstract-method
     """A plugin to convert any description and summary from MD to RST."""
 
     def update_yaml(self, yaml_data: Dict[str, Any]) -> None:
@@ -55,6 +56,17 @@ class M2R(YamlUpdatePlugin):
     def convert_to_rst(string_to_convert: str) -> str:
         """Convert that string from MD to RST."""
         try:
-            return m2r.convert(string_to_convert, renderer=AutorestRender()).strip()
+            return m2r2.convert(string_to_convert, renderer=AutorestRender()).strip()
         except Exception:  # pylint: disable=broad-except
             return string_to_convert
+
+
+class M2RAutorest(YamlUpdatePluginAutorest, M2R):
+    def get_options(self) -> Dict[str, Any]:
+        return {}
+
+
+if __name__ == "__main__":
+    # CADL pipeline will call this
+    args = parse_args()
+    M2R(output_folder=args.output_folder, cadl_file=args.cadl_file).process()

package/autorest/m4reformatter/__init__.py

@@ -11,7 +11,8 @@ import copy
 import logging
 from typing import Callable, Dict, Any, Iterable, List, Optional, Set
 
-from .. import YamlUpdatePlugin
+from .._utils import to_snake_case
+from .. import YamlUpdatePluginAutorest
 
 JSON_REGEXP = re.compile(r"^(application|text)/(.+\+)?json$")
 ORIGINAL_ID_TO_UPDATED_TYPE: Dict[int, Dict[str, Any]] = {}
@@ -431,7 +432,9 @@ def update_client_url(yaml_data: Dict[str, Any]) -> str:
     ]["uri"]
 
 
-class M4Reformatter(YamlUpdatePlugin):  # pylint: disable=too-many-public-methods
+class M4Reformatter(
+    YamlUpdatePluginAutorest
+):  # pylint: disable=too-many-public-methods
     """Add Python naming information."""
 
     @property
@@ -1098,7 +1101,7 @@ class M4Reformatter(YamlUpdatePlugin):  # pylint: disable=too-many-public-method
             if yaml_data.get("globalParameters")
             else "",
             "namespace": self._autorestapi.get_value("namespace")
-            or yaml_data["language"]["default"]["name"],
+            or to_snake_case(yaml_data["info"]["title"].replace(" ", "")),
         }
 
     def update_yaml(self, yaml_data: Dict[str, Any]) -> None: