@autorest/python 6.1.11 → 6.2.1

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

@@ -16,7 +16,7 @@ class {{ operation_group.class_name }}{{ base_class }}:{{ disable }}
         **DO NOT** instantiate this class directly.
 
         Instead, you should access the following operations through
-        :class:`{{ "~" + code_model.namespace + (".aio." if async_mode else ".") + code_model.client.name }}`'s
+        :class:`{{ "~" + code_model.namespace + (".aio." if async_mode else ".") + operation_group.client.name }}`'s
         :attr:`{{ operation_group.property_name }}` attribute.
     """
 
@@ -50,4 +50,4 @@ class {{ operation_group.class_name }}{{ base_class }}:{{ disable }}
     {% macro someop() %}{% include "operation.py.jinja2" %}{% endmacro %}
     {% endif %}
     {{ someop()|indent }}
-{% endfor %}
+{% endfor %}

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

@@ -7,13 +7,13 @@
 {{ imports }}
 
 {% if code_model.options["builders_visibility"] == "embedded" and not async_mode %}
-{{ op_tools.declare_serializer(code_model, request_builders) }}
-{% for operation_group in operation_groups %}
-    {% for request_builder in request_builders | selectattr("group_name", "equalto", operation_group.property_name) | rejectattr("is_overload") %}
+{{ op_tools.declare_serializer(code_model) }}
+    {% for operation_group in operation_groups %}
+        {% for request_builder in get_request_builders(operation_group) %}
 
-        {% include "request_builder.py.jinja2" %}
+{% include "request_builder.py.jinja2" %}
+        {% endfor %}
     {% endfor %}
-{% endfor %}
 {% endif %}
 {% for operation_group in operation_groups %}
     {% include "operation_group.py.jinja2" %}

package/autorest/codegen/templates/operation_tools.jinja2

@@ -50,8 +50,8 @@ Example:
     {% endif %}
 {% endfor %}{% endmacro %}
 
-{% macro declare_serializer(code_model, request_builders) %}
-{% if request_builders %}
+{% macro declare_serializer(code_model) %}
+{% if code_model.has_non_abstract_operations %}
 _SERIALIZER = Serializer()
     {% if not code_model.options["client_side_validation"] %}
 _SERIALIZER.client_side_validation = False

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

@@ -6,12 +6,12 @@
 
 {{ op_tools.serialize(operation_group_imports()) }}
 {{ keywords.patch_imports() }}
-{% if operation_groups %}
 __all__ = [
-    {% for operation_group in operation_groups %}
+    {% for client in clients %}
+        {% for operation_group in client.operation_groups %}
     '{{ operation_group.class_name }}',
+        {% endfor %}
     {% endfor %}
 ]
-{% endif %}
 {{ keywords.extend_all }}
-_patch_sdk()
+_patch_sdk()

package/autorest/codegen/templates/{setup.py.jinja2 → packaging_templates/setup.py.jinja2}

@@ -7,9 +7,9 @@ import re
 {% endif -%}
 from setuptools import setup, find_packages
 
-{% set package_name_render = package_name or code_model.client.name %}
+{% set package_name = package_name or code_model.clients[0].name %}
 
-PACKAGE_NAME = "{{ package_name_render|lower }}"
+PACKAGE_NAME = "{{ package_name|lower }}"
 {% if package_mode -%}
 PACKAGE_PPRINT_NAME = "{{ package_pprint_name }}"
 
@@ -28,9 +28,9 @@ if not version:
 {% set author_email = "azpysdkhelp@microsoft.com" %}
 {% set url = "https://github.com/Azure/azure-sdk-for-python/tree/main/sdk" %}
 {% else %}
-version = "{{ code_model.options['package_version'] }}"
-{% set description = "%s"|format(package_name_render) %}
-{% set long_description = code_model.client.description %}
+version = "{{ package_version }}"
+{% set description = "%s"|format(package_name) %}
+{% set long_description = code_model.description %}
 {% set author_email = "" %}
 {% set url = "" %}
 {% endif -%}
@@ -82,21 +82,24 @@ setup(
     {% endif %}
     install_requires=[
         {% if code_model.is_legacy %}
-        "{{ dependency_msrest }}",
+        "msrest>=0.7.1",
         {% else %}
         "isodate<1.0.0,>=0.6.1",
         {% endif %}
         {% if azure_arm %}
-        "{{ dependency_azure_mgmt_core }}",
+        "azure-mgmt-core<2.0.0,>=1.3.2",
         {% else %}
-        "{{ dependency_azure_core }}",
+        "azure-core<2.0.0,>=1.24.0",
+        {% endif %}
+        {% if code_model.need_typing_extensions %}
+        "typing_extensions>=4.3.0; python_version<'3.8.0'",
         {% endif %}
     ],
     {% if package_mode %}
     python_requires=">=3.7",
     {% else %}
     long_description="""\
-    {{ code_model.client.description }}
+    {{ code_model.description }}
     """
     {% endif %}
 )

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

@@ -3,8 +3,8 @@
 {{ code_model.options['license_header'] }}
 {{ imports }}
 
-{{ op_tools.declare_serializer(code_model, request_builders) }}
+{{ op_tools.declare_serializer(code_model) }}
 {% for request_builder in request_builders %}
 
 {% include "request_builder.py.jinja2" %}
-{% endfor %}
+{% endfor %}

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

@@ -0,0 +1,44 @@
+# coding=utf-8
+{% set aad_token = "DefaultAzureCredential" %}
+{% set azure_key = "AzureKeyCredential" %}
+{{ code_model.options['license_header'] }}
+
+{{ imports }}
+"""
+# PREREQUISITES
+{% if "credential" in client_params and aad_token in client_params["credential"] %}
+    pip install azure-identity
+{% endif %}
+    pip install {{ (code_model.options["package_name"] or code_model.clients[0].name)|lower }}
+# USAGE
+    python {{ file_name }}
+    {% if "credential" in client_params and aad_token in client_params["credential"] %}
+
+    Before run the sample, please set the values of the client ID, tenant ID and client secret
+    of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
+    AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
+    https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
+    {% elif "credential" in client_params and azure_key in client_params["credential"] %}
+
+    Before run the sample, please set environment variables AZURE_KEY with real value
+    which can access your service
+    {% endif %}
+"""
+def main():
+    client = {{ code_model.clients[0].name }}(
+        {% for key,value in client_params.items() %}
+        {{ key }}={{ value }},
+        {% endfor %}
+    )
+
+    response = client{{ operation_group_name }}{{ operation_name }}(
+        {% for key, value in operation_params.items() %}
+        {{ key }}={{ value|indent(8) }},
+        {% endfor %}
+    ){{ operation_result }}
+
+{% if origin_file %}
+# x-ms-original-file: {{ origin_file }}
+{% endif %}
+if __name__ == "__main__":
+    main()

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

@@ -26,13 +26,15 @@ def _format_url_section(template, **kwargs):
             template = "/".join(components)
 {% endif %}
 {% if code_model.need_mixin_abc %}
+    {% for client in code_model.clients | selectattr("has_mixin") %}
 
-class MixinABC(ABC):
+class {{ client.name }}MixinABC(ABC):
     """DO NOT use this class. It is for internal typing use only."""
     _client: "{{ keywords.async_class }}PipelineClient"
-    _config: {{ code_model.client.name }}Configuration
+    _config: {{ client.name }}Configuration
     _serialize: "Serializer"
     _deserialize: "Deserializer"
+    {% endfor %}
 {% endif %}
 {% if code_model.has_abstract_operations %}
 

package/autorest/m4reformatter/__init__.py

@@ -6,6 +6,7 @@
 # --------------------------------------------------------------------------
 """The modelerfour reformatter autorest plugin.
 """
+import re
 import copy
 import logging
 from typing import Callable, Dict, Any, Iterable, List, Optional, Set
@@ -421,6 +422,10 @@ def update_client_url(yaml_data: Dict[str, Any]) -> str:
     ]["uri"]
 
 
+def to_lower_camel_case(name: str) -> str:
+    return re.sub(r"_([a-z])", lambda x: x.group(1).upper(), name)
+
+
 class M4Reformatter(
     YamlUpdatePluginAutorest
 ):  # pylint: disable=too-many-public-methods
@@ -554,6 +559,7 @@ class M4Reformatter(
         operation["overloads"] = self.update_overloads(
             group_name, yaml_data, body_parameter, content_types=content_types
         )
+        operation["samples"] = yaml_data.get("extensions", {}).get("x-ms-examples", {})
         return operation
 
     def add_paging_information(
@@ -665,6 +671,9 @@ class M4Reformatter(
                 body_param["clientDefaultValue"] = body_type["value"]
         body_param["flattened"] = flattened
         body_param["isPartialBody"] = is_partial_body
+        body_param["restApiName"] = body_param["restApiName"] or to_lower_camel_case(
+            body_param["clientName"]
+        )
         return body_param
 
     def update_multipart_body_parameter(
@@ -1081,12 +1090,14 @@ class M4Reformatter(
             "url": update_client_url(yaml_data)
             if yaml_data.get("globalParameters")
             else "",
-            "namespace": self._autorestapi.get_value("namespace")
-            or to_snake_case(yaml_data["info"]["title"].replace(" ", "")),
         }
 
     def update_yaml(self, yaml_data: Dict[str, Any]) -> None:
         """Convert in place the YAML str."""
+        # there can only be one namespace and client from swagger
+        namespace = self._autorestapi.get_value("namespace") or to_snake_case(
+            yaml_data["info"]["title"].replace(" ", "")
+        )
         # First we update the types, so we can access for when we're creating parameters etc.
         for type_group, types in yaml_data["schemas"].items():
             for t in types:
@@ -1097,8 +1108,10 @@ class M4Reformatter(
                     # we don't generate cloud error
                     continue
                 update_type(t)
-        yaml_data["client"] = self.update_client(yaml_data)
-        yaml_data["operationGroups"] = [
+        yaml_data["namespace"] = namespace
+        yaml_data["subnamespaceToClients"] = {}
+        yaml_data["clients"] = [self.update_client(yaml_data)]
+        yaml_data["clients"][0]["operationGroups"] = [
             self.update_operation_group(og) for og in yaml_data["operationGroups"]
         ]
         yaml_data["types"] = list(ORIGINAL_ID_TO_UPDATED_TYPE.values()) + list(
@@ -1109,6 +1122,7 @@ class M4Reformatter(
         del yaml_data["info"]
         del yaml_data["language"]
         del yaml_data["protocol"]
+        del yaml_data["operationGroups"]
         if yaml_data.get("schemas"):
             del yaml_data["schemas"]
         if yaml_data.get("security"):

package/autorest/multiapi/models/imports.py

@@ -5,6 +5,7 @@
 # --------------------------------------------------------------------------
 from enum import Enum
 from typing import Dict, Optional, Set, Union, Tuple
+from ..utils import convert_list_to_tuple
 
 
 class ImportType(str, Enum):
@@ -12,6 +13,7 @@ class ImportType(str, Enum):
     THIRDPARTY = "thirdparty"
     AZURECORE = "azurecore"
     LOCAL = "local"
+    BYVERSION = "by_version"
 
 
 class TypingSection(str, Enum):
@@ -25,7 +27,28 @@ class FileImport:
         self,
         imports: Dict[
             TypingSection,
-            Dict[ImportType, Dict[str, Set[Optional[Union[str, Tuple[str, str]]]]]],
+            Dict[
+                ImportType,
+                Dict[
+                    str,
+                    Set[
+                        Optional[
+                            Union[
+                                str,
+                                Tuple[
+                                    str,
+                                    str,
+                                ],
+                                Tuple[
+                                    str,
+                                    str,
+                                    Tuple[Tuple[Tuple[int, int], str, Optional[str]]],
+                                ],
+                            ]
+                        ]
+                    ],
+                ],
+            ],
         ] = None,
     ) -> None:
         # Basic implementation
@@ -35,7 +58,28 @@ class FileImport:
         # Fourth level set: None if this import is a "import", the name to import if it's a "from"
         self._imports: Dict[
             TypingSection,
-            Dict[ImportType, Dict[str, Set[Optional[Union[str, Tuple[str, str]]]]]],
+            Dict[
+                ImportType,
+                Dict[
+                    str,
+                    Set[
+                        Optional[
+                            Union[
+                                str,
+                                Tuple[
+                                    str,
+                                    str,
+                                ],
+                                Tuple[
+                                    str,
+                                    str,
+                                    Tuple[Tuple[Tuple[int, int], str, Optional[str]]],
+                                ],
+                            ]
+                        ]
+                    ],
+                ],
+            ],
         ] = (
             imports or dict()
         )
@@ -44,14 +88,29 @@ class FileImport:
         self,
         from_section: str,
         import_type: ImportType,
-        name_import: Optional[Union[str, Tuple[str, str]]] = None,
+        name_import: Optional[
+            Union[
+                str,
+                Tuple[
+                    str,
+                    str,
+                ],
+                Tuple[str, str, Tuple[Tuple[Tuple[int, int], str, Optional[str]]]],
+            ]
+        ] = None,
         typing_section: TypingSection = TypingSection.REGULAR,
     ) -> None:
-        name_input: Optional[Union[str, Tuple[str, str]]] = None
-        if isinstance(name_import, list):
-            name_input = tuple(name_import)
-        else:
-            name_input = name_import
+        name_input: Optional[
+            Union[
+                str,
+                Tuple[
+                    str,
+                    str,
+                ],
+                Tuple[str, str, Tuple[Tuple[Tuple[int, int], str, Optional[str]]]],
+            ]
+        ] = None
+        name_input = convert_list_to_tuple(name_import)
         self._imports.setdefault(typing_section, dict()).setdefault(
             import_type, dict()
         ).setdefault(from_section, set()).add(name_input)
@@ -66,21 +125,33 @@ class FileImport:
         """Add an import to this import block."""
         self._add_import(from_section, import_type, name_import, typing_section)
 
-    def add_import(
-        self,
-        name_import: str,
-        import_type: ImportType,
-        typing_section: TypingSection = TypingSection.REGULAR,
-    ) -> None:
-        # Implementation detail: a regular import is just a "from" with no from
-        self._add_import(name_import, import_type, None, typing_section)
-
     @property
     def imports(
         self,
     ) -> Dict[
         TypingSection,
-        Dict[ImportType, Dict[str, Set[Optional[Union[str, Tuple[str, str]]]]]],
+        Dict[
+            ImportType,
+            Dict[
+                str,
+                Set[
+                    Optional[
+                        Union[
+                            str,
+                            Tuple[
+                                str,
+                                str,
+                            ],
+                            Tuple[
+                                str,
+                                str,
+                                Tuple[Tuple[Tuple[int, int], str, Optional[str]]],
+                            ],
+                        ]
+                    ]
+                ],
+            ],
+        ],
     ]:
         return self._imports
 

package/autorest/multiapi/serializers/import_serializer.py

@@ -4,17 +4,43 @@
 # license information.
 # --------------------------------------------------------------------------
 from copy import deepcopy
-from typing import Dict, Set, Optional, List
+from typing import Dict, Set, Optional, List, Tuple, Union
 from ..models import ImportType, FileImport, TypingSection
+from ..utils import convert_list_to_tuple
 
 
 def _serialize_package(
-    package_name: str, module_list: Set[Optional[str]], delimiter: str
+    package_name: str,
+    module_list: Set[
+        Optional[
+            Union[
+                str,
+                Tuple[
+                    str,
+                    str,
+                ],
+                Tuple[
+                    str,
+                    Optional[str],
+                    Tuple[Tuple[Tuple[int, int], str, Optional[str]]],
+                ],
+            ]
+        ]
+    ],
+    delimiter: str,
 ) -> str:
     buffer = []
-    if None in module_list:
+
+    versioned_modules = set()
+    normal_modules = set()
+    for m in module_list:
+        if m and isinstance(m, (tuple, list)) and len(m) > 2:
+            versioned_modules.add(convert_list_to_tuple(m))
+        else:
+            normal_modules.add(m)
+    if None in normal_modules:
         buffer.append(f"import {package_name}")
-    if module_list != {None}:
+    if normal_modules != {None} and len(normal_modules) > 0:
         buffer.append(
             "from {} import {}".format(
                 package_name,
@@ -22,18 +48,51 @@ def _serialize_package(
                     sorted(
                         [
                             mod if isinstance(mod, str) else f"{mod[0]} as {mod[1]}"
-                            for mod in module_list
+                            for mod in normal_modules
                             if mod is not None
                         ]
                     )
                 ),
             )
         )
+    for submodule_name, alias, version_modules in versioned_modules:  # type: ignore
+        for n, (version, module_name, comment) in enumerate(version_modules):
+            buffer.append(
+                "{} sys.version_info >= {}:".format("if" if n == 0 else "elif", version)
+            )
+            buffer.append(
+                f"    from {module_name} import {submodule_name}{f' as {alias}' if alias else ''}"
+                f"{f' # {comment}' if comment else ''}"
+            )
+        buffer.append("else:")
+        buffer.append(
+            f"    from {package_name} import {submodule_name}{f' as {alias}' if alias else ''}"
+            "  # type: ignore  # pylint: disable=ungrouped-imports"
+        )
     return delimiter.join(buffer)
 
 
 def _serialize_type(
-    import_type_dict: Dict[str, Set[Optional[str]]], delimiter: str
+    import_type_dict: Dict[
+        str,
+        Set[
+            Optional[
+                Union[
+                    str,
+                    Tuple[
+                        str,
+                        str,
+                    ],
+                    Tuple[
+                        str,
+                        Optional[str],
+                        Tuple[Tuple[Tuple[int, int], str, Optional[str]]],
+                    ],
+                ]
+            ]
+        ],
+    ],
+    delimiter: str,
 ) -> str:
     """Serialize a given import type."""
     import_list = []
@@ -44,7 +103,29 @@ def _serialize_type(
 
 
 def _get_import_clauses(
-    imports: Dict[ImportType, Dict[str, Set[Optional[str]]]], delimiter: str
+    imports: Dict[
+        ImportType,
+        Dict[
+            str,
+            Set[
+                Optional[
+                    Union[
+                        str,
+                        Tuple[
+                            str,
+                            str,
+                        ],
+                        Tuple[
+                            str,
+                            Optional[str],
+                            Tuple[Tuple[Tuple[int, int], str, Optional[str]]],
+                        ],
+                    ]
+                ]
+            ],
+        ],
+    ],
+    delimiter: str,
 ) -> List[str]:
     import_clause = []
     for import_type in ImportType:

package/autorest/multiapi/utils.py

@@ -47,3 +47,9 @@ def _get_default_api_version_from_list(
 
     # If not preview mode, and there is preview, take the latest known stable
     return sorted(not_preview_versions)[-1]
+
+
+def convert_list_to_tuple(l):
+    if not isinstance(l, list):
+        return l
+    return tuple(convert_list_to_tuple(x) for x in l) if isinstance(l, list) else l

package/autorest/preprocess/__init__.py

@@ -133,7 +133,7 @@ def update_operation_group_class_name(
     yaml_data: Dict[str, Any], class_name: str
 ) -> str:
     if class_name == "":
-        return yaml_data["client"]["name"] + "OperationsMixin"
+        return yaml_data["name"] + "OperationsMixin"
     if class_name == "Operations":
         return "Operations"
     return class_name + "Operations"
@@ -175,9 +175,13 @@ def update_client(yaml_data: Dict[str, Any]) -> None:
     yaml_data["description"] = update_description(
         yaml_data["description"], default_description=yaml_data["name"]
     )
-    yaml_data["moduleName"] = to_snake_case(yaml_data["name"].replace(" ", "_"))
+    yaml_data["legacyFilename"] = to_snake_case(yaml_data["name"].replace(" ", "_"))
     for parameter in yaml_data["parameters"]:
         update_parameter(parameter)
+    prop_name = yaml_data["name"]
+    if prop_name.endswith("Client"):
+        prop_name = prop_name[: len(prop_name) - len("Client")]
+    yaml_data["builderPadName"] = to_snake_case(prop_name)
 
 
 def update_paging_response(yaml_data: Dict[str, Any]) -> None:
@@ -330,9 +334,12 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
         for overload in yaml_data.get("overloads", []):
             self.update_paging_operation(code_model, overload, is_overload=True)
 
-    def update_operation_groups(self, yaml_data: Dict[str, Any]) -> None:
-        operation_groups_yaml_data = yaml_data["operationGroups"]
+    def update_operation_groups(
+        self, code_model: Dict[str, Any], client: Dict[str, Any]
+    ) -> None:
+        operation_groups_yaml_data = client["operationGroups"]
         for operation_group in operation_groups_yaml_data:
+            operation_group["clientName"] = client["name"]
             operation_group["propertyName"] = pad_reserved_words(
                 operation_group["propertyName"], PadType.OPERATION_GROUP
             )
@@ -340,16 +347,21 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
                 operation_group["propertyName"]
             )
             operation_group["className"] = update_operation_group_class_name(
-                yaml_data, operation_group["className"]
+                client, operation_group["className"]
             )
             for operation in operation_group["operations"]:
-                self.get_operation_updater(operation)(yaml_data, operation)
+                self.get_operation_updater(operation)(code_model, operation)
 
     def update_yaml(self, yaml_data: Dict[str, Any]) -> None:
         """Convert in place the YAML str."""
-        update_client(yaml_data["client"])
-        self.update_operation_groups(yaml_data)
         update_types(yaml_data["types"])
+        for client in yaml_data["clients"]:
+            update_client(client)
+            self.update_operation_groups(yaml_data, client)
+        for clients in yaml_data["subnamespaceToClients"].values():
+            for client in clients:
+                update_client(client)
+                self.update_operation_groups(yaml_data, client)
 
 
 class PreProcessPluginAutorest(YamlUpdatePluginAutorest, PreProcessPlugin):

package/package.json

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

package/run_cadl.py

@@ -38,6 +38,5 @@ if __name__ == "__main__":
     # run m2r
     python_run(venv_context, "autorest.m2r.__init__", command=sys.argv[1:])
     python_run(venv_context, "autorest.preprocess.__init__", command=sys.argv[1:])
-    python_run(venv_context, "autorest.cadlflags.__init__", command=sys.argv[1:])
     python_run(venv_context, "autorest.codegen.__init__", command=sys.argv[1:])
     python_run(venv_context, "autorest.black.__init__", command=sys.argv[1:])