@autorest/python 6.2.0 → 6.2.2

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

@@ -39,7 +39,7 @@ class {{ client.name }}Configuration(Configuration):  # pylint: disable=too-many
         self.headers_policy = kwargs.get('headers_policy') or policies.HeadersPolicy(**kwargs)
         self.proxy_policy = kwargs.get('proxy_policy') or policies.ProxyPolicy(**kwargs)
         self.logging_policy = kwargs.get('logging_policy') or policies.NetworkTraceLoggingPolicy(**kwargs)
-        self.http_logging_policy = kwargs.get('http_logging_policy') or {{ "ARM" if client.namespace_model.options['azure_arm'] else "policies." }}HttpLoggingPolicy(**kwargs)
+        self.http_logging_policy = kwargs.get('http_logging_policy') or {{ "ARM" if client.code_model.options['azure_arm'] else "policies." }}HttpLoggingPolicy(**kwargs)
         self.retry_policy = kwargs.get('retry_policy') or policies.{{ keywords.async_class }}RetryPolicy(**kwargs)
         self.custom_hook_policy = kwargs.get('custom_hook_policy') or policies.CustomHookPolicy(**kwargs)
         self.redirect_policy = kwargs.get('redirect_policy') or policies.{{ keywords.async_class }}RedirectPolicy(**kwargs)

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

@@ -2,15 +2,15 @@
 {% import 'operation_tools.jinja2' as op_tools %}
 {# actual template starts here #}
 # coding=utf-8
-{{ namespace_model.options['license_header'] }}
+{{ code_model.options['license_header'] }}
 
 {{ imports }}
 
-{% if not namespace_model.options['package_version'] %}
+{% if not code_model.options['package_version'] %}
 VERSION = "unknown"
 {% endif %}
 
-{% for client in namespace_model.clients %}
+{% for client in clients %}
     {% set serializer = get_serializer(client) %}
 {% include "config.py.jinja2" %}
 {% endfor %}

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

@@ -1,9 +1,9 @@
 # coding=utf-8
-{{ namespace_model.options['license_header'] }}
+{{ code_model.options['license_header'] }}
 
 from enum import Enum
 from azure.core import CaseInsensitiveEnumMeta
 
-{% for enum in namespace_model.enums | sort %}
+{% for enum in code_model.enums | sort %}
 {% include "enum.py.jinja2" %}
 {% endfor %}

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

@@ -1,13 +1,13 @@
 {% import 'keywords.jinja2' as keywords %}
 # coding=utf-8
-{{ namespace_model.options['license_header'] }}
+{{ code_model.options['license_header'] }}
 
 {% if clients %}
     {% for client in clients %}
 from .{{ client.filename }} import {{ client.name }}
     {% endfor %}
 {% endif %}
-{% if not async_mode and namespace_model.options['package_version']%}
+{% if not async_mode and code_model.options['package_version']%}
 from ._version import VERSION
 
 __version__ = VERSION

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

@@ -14,6 +14,6 @@
 
     {{ op_tools.serialize(operation_serializer.return_lro_poller(operation)) | indent }}
     {% endif %}
-{% if not namespace_model.options["version_tolerant"] %}
+{% if not code_model.options["version_tolerant"] %}
 {{ operation_serializer.get_metadata_url(operation) -}}
 {% endif %}

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

@@ -16,6 +16,6 @@
     {{ op_tools.serialize(operation_serializer.get_long_running_output(operation)) | indent }}
     {{ op_tools.serialize(operation_serializer.return_lro_poller(operation)) | indent }}
     {% endif %}
-{% if not namespace_model.options["version_tolerant"] %}
+{% if not code_model.options["version_tolerant"] %}
 {{ operation_serializer.get_metadata_url(operation) }}
 {% endif %}

package/autorest/codegen/templates/metadata.json.jinja2

@@ -9,9 +9,9 @@
         "description": {{ client.description | tojson }},
         "host_value": {{ (client.parameters.host.client_default_value_declaration if not client.has_parameterized_host else None) | tojson }},
         "parameterized_host_template": {{ (keywords.escape_str(client.url) if client.has_parameterized_host else None) | tojson }},
-        "azure_arm": {{ client.namespace_model.options["azure_arm"]  | tojson }},
+        "azure_arm": {{ client.code_model.options["azure_arm"]  | tojson }},
         "has_lro_operations": {{ client.has_lro_operations | tojson }},
-        "client_side_validation": {{ client.namespace_model.options["client_side_validation"] | tojson }},
+        "client_side_validation": {{ client.code_model.options["client_side_validation"] | tojson }},
         "sync_imports": {{ sync_client_imports | tojson }},
         "async_imports": {{ async_client_imports | tojson }}
     },

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

@@ -1,10 +1,10 @@
 # coding=utf-8
 # pylint: disable=too-many-lines
-{{ namespace_model.options['license_header'] }}
+{{ code_model.options['license_header'] }}
 
 {{ imports }}
-{% for model in namespace_model.model_types %}
-{% if namespace_model.options["models_mode"] == "dpg" %}
+{% for model in code_model.model_types %}
+{% if code_model.options["models_mode"] == "dpg" %}
 {% include "model_dpg.py.jinja2" %}
 {% else %}
 {% include "model_msrest.py.jinja2" %}

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

@@ -30,7 +30,7 @@
     {% if model.is_polymorphic %}
     __mapping__ = {}
     {% endif %}
-    {% for p in serializer.get_properties_to_initialize(model)%}
+    {% for p in serializer.get_properties_to_declare(model)%}
         {% for line in serializer.declare_property(p) %}
     {{ line }}
         {% endfor %}
@@ -57,6 +57,6 @@
     {% endif %}
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
-    {% if model.discriminator_value %}
-        {{ serializer.initialize_discriminator_property(model, model.discriminator_property) }}
-    {% endif %}
+    {% for initialize_property in serializer.initialize_properties(model) %}
+        {{ initialize_property }}
+    {% endfor %}

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

@@ -1,16 +1,16 @@
 {% import 'keywords.jinja2' as keywords %}
 # coding=utf-8
-{{ namespace_model.options['license_header'] }}
+{{ code_model.options['license_header'] }}
 {% if schemas %}
 
     {% for schema in schemas %}
-from .{{ namespace_model.models_filename }} import {{ schema }}
+from .{{ code_model.models_filename }} import {{ schema }}
     {% endfor %}
 {% endif %}
 {% if enums %}
 
 {% for enum in enums %}
-from .{{ namespace_model.enums_filename }} import {{ enum }}
+from .{{ code_model.enums_filename }} import {{ enum }}
 {% endfor %}
 {% endif %}
 {{ keywords.patch_imports() }}

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

@@ -19,6 +19,6 @@
     {{ op_tools.serialize(operation_serializer.make_pipeline_call(operation)) | indent }}
     {{ op_tools.serialize(operation_serializer.handle_response(operation)) | indent }}
     {% endif %}
-{% if not namespace_model.options["version_tolerant"] %}
+{% if not code_model.options["version_tolerant"] %}
 {{ operation_serializer.get_metadata_url(operation) }}
 {% endif %}

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

@@ -16,11 +16,11 @@ class {{ operation_group.class_name }}{{ base_class }}:{{ disable }}
         **DO NOT** instantiate this class directly.
 
         Instead, you should access the following operations through
-        :class:`{{ "~" + namespace_model.namespace + (".aio." if async_mode else ".") + operation_group.client.name }}`'s
+        :class:`{{ "~" + code_model.namespace + (".aio." if async_mode else ".") + operation_group.client.name }}`'s
         :attr:`{{ operation_group.property_name }}` attribute.
     """
 
-{% if namespace_model.public_model_types and namespace_model.options["models_mode"] == "msrest" %}
+{% if code_model.public_model_types and code_model.options["models_mode"] == "msrest" %}
     models = _models
 
 {% endif %}

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

@@ -3,11 +3,11 @@
 {% set return_none_type_annotation = " -> None" if async_mode else "" %}
 # pylint: disable=too-many-lines
 # coding=utf-8
-{{ namespace_model.options['license_header'] }}
+{{ code_model.options['license_header'] }}
 {{ imports }}
 
-{% if namespace_model.options["builders_visibility"] == "embedded" and not async_mode %}
-{{ op_tools.declare_serializer(namespace_model) }}
+{% if code_model.options["builders_visibility"] == "embedded" and not async_mode %}
+{{ op_tools.declare_serializer(code_model) }}
     {% for operation_group in operation_groups %}
         {% for request_builder in get_request_builders(operation_group) %}
 

package/autorest/codegen/templates/operation_tools.jinja2

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

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

@@ -2,16 +2,16 @@
 {% import 'keywords.jinja2' as keywords %}
 {# actual template starts here #}
 # coding=utf-8
-{{ namespace_model.options['license_header'] }}
+{{ code_model.options['license_header'] }}
 
 {{ op_tools.serialize(operation_group_imports()) }}
 {{ keywords.patch_imports() }}
-{% if namespace_model.operation_groups %}
 __all__ = [
-    {% for operation_group in namespace_model.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()

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

@@ -7,7 +7,7 @@ import re
 {% endif -%}
 from setuptools import setup, find_packages
 
-{% set package_name = package_name or code_model.namespace_models[0].clients[0].name %}
+{% set package_name = package_name or code_model.clients[0].name %}
 
 PACKAGE_NAME = "{{ package_name|lower }}"
 {% if package_mode -%}
@@ -91,6 +91,9 @@ setup(
         {% else %}
         "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",

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

@@ -19,6 +19,6 @@
         get_next, extract_data
     )
     {% endif %}
-{% if not namespace_model.options["version_tolerant"] %}
+{% if not code_model.options["version_tolerant"] %}
 {{ operation_serializer.get_metadata_url(operation) -}}
 {% endif %}

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

@@ -1,7 +1,7 @@
 {% import 'keywords.jinja2' as keywords with context %}
 {% import 'operation_tools.jinja2' as op_tools with context %}
 {{ request_builder_serializer.method_signature_and_response_type_annotation(request_builder) }}
-{% if namespace_model.options["builders_visibility"] == "public" %}
+{% if code_model.options["builders_visibility"] == "public" %}
     {{ op_tools.description(request_builder, request_builder_serializer) | indent }}
 {% endif %}
 {% if not request_builder.is_overload %}

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

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

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

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

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

@@ -1,7 +1,7 @@
 # coding=utf-8
 {% set aad_token = "DefaultAzureCredential" %}
 {% set azure_key = "AzureKeyCredential" %}
-{{ namespace_model.options['license_header'] }}
+{{ code_model.options['license_header'] }}
 
 {{ imports }}
 """
@@ -9,23 +9,23 @@
 {% 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 }}
+    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 
+    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 }}(
+    client = {{ code_model.clients[0].name }}(
         {% for key,value in client_params.items() %}
         {{ key }}={{ value }},
         {% endfor %}

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

@@ -1,4 +1,4 @@
-{{ namespace_model.options['license_header'] }}
+{{ code_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 %}
-{{ namespace_model.options['license_header'] }}
+{{ code_model.options['license_header'] }}
 
 {{ imports }}
 
-{% if namespace_model.need_request_converter and not async_mode %}
+{% if code_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 namespace_model.need_format_url and not async_mode %}
+{% if code_model.need_format_url and not async_mode %}
 
 def _format_url_section(template, **kwargs):
     components = template.split("/")
@@ -25,8 +25,8 @@ def _format_url_section(template, **kwargs):
             ]
             template = "/".join(components)
 {% endif %}
-{% if namespace_model.need_mixin_abc %}
-    {% for client in namespace_model.clients | selectattr("has_mixin") %}
+{% if code_model.need_mixin_abc %}
+    {% for client in code_model.clients | selectattr("has_mixin") %}
 
 class {{ client.name }}MixinABC(ABC):
     """DO NOT use this class. It is for internal typing use only."""
@@ -36,7 +36,7 @@ class {{ client.name }}MixinABC(ABC):
     _deserialize: "Deserializer"
     {% endfor %}
 {% endif %}
-{% if namespace_model.has_abstract_operations %}
+{% if code_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
-{{ namespace_model.options['license_header'] }}
+{{ code_model.options['license_header'] }}
 
-VERSION = "{{ namespace_model.options['package_version'] }}"
+VERSION = "{{ code_model.options['package_version'] }}"

package/autorest/m4reformatter/__init__.py

@@ -280,35 +280,6 @@ def update_type(yaml_data: Dict[str, Any]) -> Dict[str, Any]:
     return updated_type
 
 
-def update_parameter_base(
-    yaml_data: Dict[str, Any], *, override_client_name: Optional[str] = None
-) -> Dict[str, Any]:
-    location = yaml_data["protocol"].get("http", {}).get("in")
-    if not location:
-        location = "other"
-    if location == "uri":
-        location = "endpointPath"
-    grouped_by = (
-        yaml_data["groupedBy"]["language"]["default"]["name"]
-        if yaml_data.get("groupedBy")
-        else None
-    )
-    client_name: str = override_client_name or yaml_data["language"]["default"]["name"]
-    if grouped_by and client_name[0] != "_":
-        # this is an m4 bug, doesn't hide constant grouped params, patching m4 for now
-        client_name = "_" + client_name
-    return {
-        "optional": not yaml_data.get("required", False),
-        "description": yaml_data["language"]["default"]["description"],
-        "clientName": client_name,
-        "restApiName": yaml_data["language"]["default"].get("serializedName"),
-        "clientDefaultValue": yaml_data.get("clientDefaultValue"),
-        "location": location,
-        "groupedBy": grouped_by,
-        "checkClientInput": yaml_data.get("checkClientInput", False),
-    }
-
-
 def update_parameter_delimiter(style: Optional[str]) -> Optional[str]:
     if not style:
         return None
@@ -458,6 +429,45 @@ class M4Reformatter(
             or self.version_tolerant
         )
 
+    def update_parameter_base(
+        self, yaml_data: Dict[str, Any], *, override_client_name: Optional[str] = None
+    ) -> Dict[str, Any]:
+        location = yaml_data["protocol"].get("http", {}).get("in")
+        if not location:
+            location = "other"
+        if location == "uri":
+            location = "endpointPath"
+        grouped_by = (
+            yaml_data["groupedBy"]["language"]["default"]["name"]
+            if yaml_data.get("groupedBy")
+            else None
+        )
+        client_name: str = (
+            override_client_name or yaml_data["language"]["default"]["name"]
+        )
+        if grouped_by and client_name[0] != "_":
+            # this is an m4 bug, doesn't hide constant grouped params, patching m4 for now
+            client_name = "_" + client_name
+        if yaml_data.get("origin") == "modelerfour:synthesized/api-version":
+            yaml_data["inDocstring"] = False
+            if self.legacy:
+                yaml_data["implementation"] = "Method"
+                yaml_data["checkClientInput"] = self.check_client_input
+            yaml_data["isApiVersion"] = True
+        return {
+            "optional": not yaml_data.get("required", False),
+            "description": yaml_data["language"]["default"]["description"],
+            "clientName": client_name,
+            "restApiName": yaml_data["language"]["default"].get("serializedName"),
+            "clientDefaultValue": yaml_data.get("clientDefaultValue"),
+            "location": location,
+            "groupedBy": grouped_by,
+            "checkClientInput": yaml_data.get("checkClientInput", False),
+            "inDocstring": yaml_data.get("inDocstring", True),
+            "isApiVersion": yaml_data.get("isApiVersion", False),
+            "implementation": yaml_data.get("implementation"),
+        }
+
     def update_overloads(
         self,
         group_name: str,
@@ -646,7 +656,7 @@ class M4Reformatter(
     ) -> Dict[str, Any]:
         flattened = body_param.get("flattened")
         is_partial_body = body_param.get("isPartialBody")
-        param_base = update_parameter_base(body_param)
+        param_base = self.update_parameter_base(body_param)
         body_param = copy.deepcopy(param_base)
         body_param["type"] = body_type
         body_param["contentTypes"] = content_types or [
@@ -811,11 +821,6 @@ class M4Reformatter(
             ):
                 continue
             seen_client_names.add(client_name)
-            if param.get("origin") == "modelerfour:synthesized/api-version":
-                param["inDocstring"] = False
-                if self.legacy:
-                    param["implementation"] = "Method"
-                    param["checkClientInput"] = self.check_client_input
             if has_flattened_body and param.get("targetProperty"):
                 retval.append(self.update_flattened_parameter(param, body_parameter))
                 continue
@@ -910,7 +915,7 @@ class M4Reformatter(
         in_overload: bool = False,
         in_overriden: bool = False,
     ) -> Dict[str, Any]:
-        param_base = update_parameter_base(
+        param_base = self.update_parameter_base(
             yaml_data, override_client_name=override_client_name
         )
         type = get_type(yaml_data["schema"])
@@ -948,13 +953,17 @@ class M4Reformatter(
 
                 client_name = "base_url" if self.legacy else "endpoint"
                 global_parameter["language"]["default"]["description"] = "Service URL."
-            elif name == "api_version":
+            elif (
+                global_parameter.get("origin") == "modelerfour:synthesized/api-version"
+            ):
                 self.check_client_input = True
-            global_params.append(
-                self.update_parameter(
-                    global_parameter, override_client_name=client_name
-                )
+            param = self.update_parameter(
+                global_parameter, override_client_name=client_name
             )
+            if global_parameter.get("origin") == "modelerfour:synthesized/api-version":
+                param["implementation"] = "Client"
+                param["checkClientInput"] = False
+            global_params.append(param)
         return global_params
 
     def get_token_credential(self, credential_scopes: List[str]) -> Dict[str, Any]:
@@ -1108,14 +1117,15 @@ class M4Reformatter(
                     # we don't generate cloud error
                     continue
                 update_type(t)
-        yaml_data[namespace] = {}
-        yaml_data[namespace]["clients"] = [self.update_client(yaml_data)]
-        yaml_data[namespace]["clients"][0]["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[namespace]["types"] = list(
-            ORIGINAL_ID_TO_UPDATED_TYPE.values()
-        ) + list(KNOWN_TYPES.values())
+        yaml_data["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"]