@autorest/python 6.1.11 → 6.2.0

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

@@ -1,10 +1,10 @@
 {% import 'operation_tools.jinja2' as op_tools %}
 # coding=utf-8
-{{ code_model.options['license_header'] }}
+{{ namespace_model.options['license_header'] }}
 {{ imports }}
 
-{{ op_tools.declare_serializer(code_model, request_builders) }}
+{{ op_tools.declare_serializer(namespace_model) }}
 {% for request_builder in request_builders %}
 
 {% include "request_builder.py.jinja2" %}
-{% endfor %}
+{% endfor %}

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

@@ -1,5 +1,5 @@
 # coding=utf-8
-{{ code_model.options['license_header'] }}
+{{ client.namespace_model.options['license_header'] }}
 
 {% for request_builder in request_builders %}
 from ._request_builders import {{ request_builder.name }}

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

@@ -0,0 +1,44 @@
+# coding=utf-8
+{% set aad_token = "DefaultAzureCredential" %}
+{% set azure_key = "AzureKeyCredential" %}
+{{ namespace_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 {{ (namespace_model.options["package_name"] or namespace_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 = {{ namespace_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/validation.py.jinja2

@@ -1,4 +1,4 @@
-{{ code_model.options['license_header'] }}
+{{ namespace_model.options['license_header'] }}
 import functools
 
 def api_version_validation(**kwargs):

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

@@ -1,9 +1,9 @@
 {% import 'keywords.jinja2' as keywords with context %}
-{{ code_model.options['license_header'] }}
+{{ namespace_model.options['license_header'] }}
 
 {{ imports }}
 
-{% if code_model.need_request_converter and not async_mode %}
+{% if namespace_model.need_request_converter and not async_mode %}
 def _convert_request(request, files=None):
     data = request.content if not files else None
     request = HttpRequest(method=request.method, url=request.url, headers=request.headers, data=data)
@@ -11,7 +11,7 @@ def _convert_request(request, files=None):
         request.set_formdata_body(files)
     return request
 {% endif %}
-{% if code_model.need_format_url and not async_mode %}
+{% if namespace_model.need_format_url and not async_mode %}
 
 def _format_url_section(template, **kwargs):
     components = template.split("/")
@@ -25,16 +25,18 @@ def _format_url_section(template, **kwargs):
             ]
             template = "/".join(components)
 {% endif %}
-{% if code_model.need_mixin_abc %}
+{% if namespace_model.need_mixin_abc %}
+    {% for client in namespace_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 %}
+{% if namespace_model.has_abstract_operations %}
 
 def raise_if_not_implemented(cls, abstract_methods):
     not_implemented = [f for f in abstract_methods if not callable(getattr(cls, f, None))]

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

@@ -1,4 +1,4 @@
 # coding=utf-8
-{{ code_model.options['license_header'] }}
+{{ namespace_model.options['license_header'] }}
 
-VERSION = "{{ code_model.options['package_version'] }}"
+VERSION = "{{ namespace_model.options['package_version'] }}"

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,18 +1108,20 @@ 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] = {}
+        yaml_data[namespace]["clients"] = [self.update_client(yaml_data)]
+        yaml_data[namespace]["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(
-            KNOWN_TYPES.values()
-        )
+        yaml_data[namespace]["types"] = list(
+            ORIGINAL_ID_TO_UPDATED_TYPE.values()
+        ) + list(KNOWN_TYPES.values())
         if yaml_data.get("globalParameters"):
             del yaml_data["globalParameters"]
         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/preprocess/__init__.py

@@ -16,7 +16,9 @@ from .. import YamlUpdatePlugin, YamlUpdatePluginAutorest
 from .._utils import parse_args, get_body_type_for_description, JSON_REGEXP, KNOWN_TYPES
 
 
-def add_body_param_type(code_model: Dict[str, Any], body_parameter: Dict[str, Any]):
+def add_body_param_type(
+    namespace_model: Dict[str, Any], body_parameter: Dict[str, Any]
+):
     if (
         body_parameter
         and body_parameter["type"]["type"] in ("model", "dict", "list")
@@ -30,7 +32,7 @@ def add_body_param_type(code_model: Dict[str, Any], body_parameter: Dict[str, An
             "type": "combined",
             "types": [body_parameter["type"], KNOWN_TYPES["binary"]],
         }
-        code_model["types"].append(body_parameter["type"])
+        namespace_model["types"].append(body_parameter["type"])
 
 
 def update_overload_section(
@@ -133,7 +135,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 +177,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:
@@ -208,7 +214,7 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
 
     def update_operation(
         self,
-        code_model: Dict[str, Any],
+        namespace_model: Dict[str, Any],
         yaml_data: Dict[str, Any],
         *,
         is_overload: bool = False,
@@ -231,12 +237,12 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
             for entry in yaml_data["bodyParameter"].get("entries", []):
                 update_parameter(entry)
         for overload in yaml_data.get("overloads", []):
-            self.update_operation(code_model, overload, is_overload=True)
+            self.update_operation(namespace_model, overload, is_overload=True)
         for response in yaml_data.get("responses", []):
             response["discriminator"] = "operation"
         if body_parameter and not is_overload:
             # if we have a JSON body, we add a binary overload
-            add_body_param_type(code_model, body_parameter)
+            add_body_param_type(namespace_model, body_parameter)
             add_overloads_for_body_param(yaml_data)
 
     def _update_lro_operation_helper(self, yaml_data: Dict[str, Any]) -> None:
@@ -264,36 +270,40 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
 
     def update_lro_paging_operation(
         self,
-        code_model: Dict[str, Any],
+        namespace_model: Dict[str, Any],
         yaml_data: Dict[str, Any],
         is_overload: bool = False,
     ) -> None:
-        self.update_lro_operation(code_model, yaml_data, is_overload=is_overload)
-        self.update_paging_operation(code_model, yaml_data, is_overload=is_overload)
+        self.update_lro_operation(namespace_model, yaml_data, is_overload=is_overload)
+        self.update_paging_operation(
+            namespace_model, yaml_data, is_overload=is_overload
+        )
         yaml_data["discriminator"] = "lropaging"
         for response in yaml_data.get("responses", []):
             response["discriminator"] = "lropaging"
         for overload in yaml_data.get("overloads", []):
-            self.update_lro_paging_operation(code_model, overload, is_overload=True)
+            self.update_lro_paging_operation(
+                namespace_model, overload, is_overload=True
+            )
 
     def update_lro_operation(
         self,
-        code_model: Dict[str, Any],
+        namespace_model: Dict[str, Any],
         yaml_data: Dict[str, Any],
         is_overload: bool = False,
     ) -> None:
-        self.update_operation(code_model, yaml_data, is_overload=is_overload)
+        self.update_operation(namespace_model, yaml_data, is_overload=is_overload)
         self._update_lro_operation_helper(yaml_data)
         for overload in yaml_data.get("overloads", []):
             self._update_lro_operation_helper(overload)
 
     def update_paging_operation(
         self,
-        code_model: Dict[str, Any],
+        namespace_model: Dict[str, Any],
         yaml_data: Dict[str, Any],
         is_overload: bool = False,
     ) -> None:
-        self.update_operation(code_model, yaml_data, is_overload=is_overload)
+        self.update_operation(namespace_model, yaml_data, is_overload=is_overload)
         if not yaml_data.get("pagerSync"):
             yaml_data["pagerSync"] = "azure.core.paging.ItemPaged"
         if not yaml_data.get("pagerAsync"):
@@ -328,11 +338,14 @@ class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
             update_paging_response(response)
             response["itemType"] = item_type
         for overload in yaml_data.get("overloads", []):
-            self.update_paging_operation(code_model, overload, is_overload=True)
+            self.update_paging_operation(namespace_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, namespace: 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 +353,18 @@ 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)(namespace, 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 namespace in yaml_data.values():
+            update_types(namespace["types"])
+            for client in namespace["clients"]:
+                update_client(client)
+                self.update_operation_groups(namespace, client)
 
 
 class PreProcessPluginAutorest(YamlUpdatePluginAutorest, PreProcessPlugin):

package/package.json

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