@autorest/python 5.14.0 → 5.17.0

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

@@ -11,32 +11,32 @@
 VERSION = "unknown"
 {% endif %}
 
-class {{ code_model.class_name }}Configuration(Configuration):  # pylint: disable=too-many-instance-attributes
-    """Configuration for {{ code_model.class_name }}.
+class {{ code_model.client.name }}Configuration(Configuration):  # pylint: disable=too-many-instance-attributes
+    """Configuration for {{ code_model.client.name }}.
 
     Note that all parameters used to create this instance are saved as instance
     attributes.
-{% if code_model.global_parameters.config_method | first %}
+{% if code_model.config.parameters.method | first %}
 
 {% endif %}
-    {{ op_tools.serialize_with_wrap(serializer.property_descriptions(), "\n ") | indent }}
+    {{ op_tools.serialize_with_wrap(serializer.property_descriptions(async_mode), "\n ") | indent }}
     {{ serializer.init_signature_and_response_type_annotation(async_mode) | indent }}
-        super({{ code_model.class_name }}Configuration, self).__init__(**kwargs)
-    {% if code_model.service_client.parameters.config_kwargs_to_pop(async_mode) %}
+        super({{ code_model.client.name }}Configuration, self).__init__(**kwargs)
+    {% if code_model.config.parameters.kwargs_to_pop(async_mode) %}
         {{ op_tools.serialize(serializer.pop_kwargs_from_signature(async_mode)) | indent(8) }}
     {% endif %}
 {% if serializer.check_required_parameters() %}
         {{ op_tools.serialize(serializer.check_required_parameters()) | indent(8) -}}
 {% endif %}
 
-{% for parameter in code_model.global_parameters.config_method %}
-        self.{{ parameter.serialized_name }} = {{ parameter.serialized_name }}
+{% for parameter in code_model.config.parameters.method %}
+        self.{{ parameter.client_name }} = {{ parameter.client_name }}
 {% endfor %}
 {% if serializer.set_constants() %}
         {{ op_tools.serialize(serializer.set_constants()) | indent(8) -}}
 {% endif %}
-{% if code_model.options['credential'] and code_model.credential_schema_policy.credential_scopes is defined %}
-        self.credential_scopes = kwargs.pop('credential_scopes', {{ code_model.credential_schema_policy.credential_scopes }})
+{% if code_model.credential and code_model.credential.type.policy.credential_scopes is defined %}
+        self.credential_scopes = kwargs.pop('credential_scopes', {{ code_model.credential.type.policy.credential_scopes }})
 {% endif %}
         kwargs.setdefault('sdk_moniker', '{{ sdk_moniker }}/{}'.format(VERSION))
         self._configure(**kwargs)
@@ -57,12 +57,12 @@ class {{ code_model.class_name }}Configuration(Configuration):  # pylint: disabl
         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)
         self.authentication_policy = kwargs.get('authentication_policy')
-        {% if code_model.options['credential'] %}
+        {% if code_model.credential %}
         {# only adding this if credential_scopes is not passed during code generation #}
-        {% if code_model.credential_schema_policy.credential_scopes is defined and code_model.credential_schema_policy.credential_scopes|length == 0 %}
+        {% if code_model.credential.type.policy.credential_scopes is defined and code_model.credential.type.policy.credential_scopes | length == 0 %}
         if not self.credential_scopes and not self.authentication_policy:
             raise ValueError("You must provide either credential_scopes or authentication_policy as kwargs")
         {% endif %}
         if self.credential and not self.authentication_policy:
-            self.authentication_policy = {{ code_model.credential_schema_policy.call(async_mode) }}
+            self.authentication_policy = {{ code_model.credential.type.policy.call(async_mode) }}
         {% endif %}

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

@@ -1,7 +1,7 @@
 
-class {{ enum.name }}(with_metaclass(CaseInsensitiveEnumMeta, {{ enum.enum_type.type_annotation }}, Enum)):
-    {% if enum.description %}
-    """{{ enum.description | wordwrap(width=95, break_long_words=False, break_on_hyphens=False, wrapstring='\n    ') }}
+class {{ enum.name }}({{ enum.value_type.type_annotation(is_operation_file=False) }}, Enum, metaclass=CaseInsensitiveEnumMeta):
+    {% if enum.yaml_data.get("description") %}
+    """{{ enum.yaml_data["description"] | wordwrap(width=95, break_long_words=False, break_on_hyphens=False, wrapstring='\n    ') }}
     """
     {% endif %}
 
@@ -9,5 +9,5 @@ class {{ enum.name }}(with_metaclass(CaseInsensitiveEnumMeta, {{ enum.enum_type.
     {% if value.description %}
     #: {{ value.description | wordwrap(width=95, break_long_words=False, break_on_hyphens=False, wrapstring='\n    #: ') }}
     {% endif %}
-    {{ value.name }} = {{ enum.enum_type.get_declaration(value.value) }}
+    {{ value.name }} = {{ enum.value_type.get_declaration(value.value) }}
     {% endfor %}

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

@@ -2,9 +2,8 @@
 {{ code_model.options['license_header'] }}
 
 from enum import Enum
-from six import with_metaclass
 from azure.core import CaseInsensitiveEnumMeta
 
-{% for enum in code_model.enums.values() | sort %}
+{% for enum in code_model.enums | sort %}
 {% include "enum.py.jinja2" %}
 {% endfor %}

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

@@ -1,15 +1,18 @@
+{% import 'keywords.jinja2' as keywords %}
 # coding=utf-8
 {{ code_model.options['license_header'] }}
 
-from ._{{ code_model.module_name }} import {{ code_model.class_name }}
+{% if code_model.request_builders %}
+from .{{ code_model.client.filename }} import {{ code_model.client.name }}
+{% endif %}
 {% if not async_mode and code_model.options['package_version']%}
 from ._version import VERSION
 
 __version__ = VERSION
 {% endif %}
-__all__ = ['{{ code_model.class_name }}']
 
-# `._patch.py` is used for handwritten extensions to the generated code
-# Example: https://github.com/Azure/azure-sdk-for-python/blob/main/doc/dev/customize_code/how-to-patch-sdk-code.md
-from ._patch import patch_sdk
-patch_sdk()
+{{ keywords.patch_imports(try_except=True) }}
+__all__ = [{{("'" + code_model.client.name + "'") if code_model.request_builders else ""}}]
+{{ keywords.extend_all }}
+
+_patch_sdk()

package/autorest/codegen/templates/keywords.jinja2

@@ -3,4 +3,17 @@
 {% set await = "await " if async_mode else "" %}
 {% set async_class = "Async" if async_mode else "" %}
 {% macro escape_str(s) %}'{{ s|replace("'", "\\'") }}'{% endmacro %}
-{% set kwargs_declaration = "**kwargs: Any" if async_mode else "**kwargs  # type: Any" %}
+{% set kwargs_declaration = "**kwargs: Any" if async_mode else "**kwargs  # type: Any" %}
+{% set extend_all = "__all__.extend([p for p in _patch_all if p not in __all__])" %}
+{% macro patch_imports(try_except=False) %}
+{% set indentation = "    " if try_except else "" %}
+{% if try_except %}
+try:
+{% endif %}
+{{ indentation }}from ._patch import __all__ as _patch_all
+{{ indentation }}from ._patch import *  # type: ignore # pylint: disable=unused-wildcard-import
+{% if try_except %}
+except ImportError:
+    _patch_all = []
+{% endif %}
+from ._patch import patch_sdk as _patch_sdk{% endmacro %}

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

@@ -1,18 +1,19 @@
 {% import 'operation_tools.jinja2' as op_tools with context %}
-{% set trace_decorator = "@distributed_trace_async" if async_mode else "@distributed_trace" %}
 {# actual template starts here #}
-{% if code_model.options['tracing'] %}
-{{ trace_decorator }}
+{% if operation.overloads and operation.public %}
+{{ op_tools.generate_overloads(operation_serializer, operation) }}
 {% endif %}
 {{ operation_serializer.method_signature_and_response_type_annotation(operation) }}
     {{ op_tools.description(operation, operation_serializer) | indent -}}
-    {% if operation.parameters.kwargs_to_pop(async_mode) %}
+    {% if not operation.abstract %}
+        {% if operation_serializer.pop_kwargs_from_signature(operation) %}
     {{ op_tools.serialize(operation_serializer.pop_kwargs_from_signature(operation)) | indent }}
-    {%- endif %}
+        {%- endif %}
     {{ op_tools.serialize(operation_serializer.initial_call(operation)) | indent }}
     {{ op_tools.serialize(operation_serializer.get_long_running_output(operation)) | indent }}
 
     {{ op_tools.serialize(operation_serializer.return_lro_poller(operation)) | indent }}
+    {% endif %}
 {% if not code_model.options["version_tolerant"] %}
 {{ operation_serializer.get_metadata_url(operation) -}}
 {% endif %}

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

@@ -1,20 +1,21 @@
 {% import 'operation_tools.jinja2' as op_tools with context %}
 {% import 'keywords.jinja2' as keywords with context %}
-{% set trace_decorator = "@distributed_trace_async" if async_mode else "@distributed_trace" %}
 {# actual template starts here #}
-{% if code_model.options['tracing'] %}
-{{ trace_decorator }}
+{% if operation.overloads and operation.public %}
+{{ op_tools.generate_overloads(operation_serializer, operation) }}
 {% endif %}
 {{ operation_serializer.method_signature_and_response_type_annotation(operation) }}
     {{ op_tools.description(operation, operation_serializer) | indent }}
-    {% if operation.parameters.kwargs_to_pop(async_mode) %}
+    {% if not operation.abstract %}
+        {% if operation_serializer.pop_kwargs_from_signature(operation) %}
     {{ op_tools.serialize(operation_serializer.pop_kwargs_from_signature(operation)) | indent }}
-    {% endif %}
+        {% endif %}
     {{ op_tools.serialize(operation_serializer.set_up_params_for_pager(operation)) | indent }}
 
     {{ op_tools.serialize(operation_serializer.initial_call(operation)) | indent }}
     {{ op_tools.serialize(operation_serializer.get_long_running_output(operation)) | indent }}
     {{ op_tools.serialize(operation_serializer.return_lro_poller(operation)) | indent }}
+    {% endif %}
 {% if not code_model.options["version_tolerant"] %}
 {{ operation_serializer.get_metadata_url(operation) }}
 {% endif %}

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

@@ -1,15 +1,15 @@
 {% import 'operation_tools.jinja2' as op_tools %}
 {% import 'keywords.jinja2' as keywords %}
-{% set service_client = code_model.service_client %}
+{% set client = code_model.client %}
 {
     "chosen_version": {{ chosen_version | tojson }},
     "total_api_version_list": {{ total_api_version_list | tojson }},
     "client": {
-        "name": {{ code_model.class_name | tojson }},
+        "name": {{ code_model.client.name | tojson }},
         "filename": {{ ("_" + code_model.module_name) | tojson }},
-        "description": {{ code_model.description | tojson }},
-        "host_value": {{ (service_client.parameters.host.default_value_declaration if not service_client.has_parameterized_host else None) | tojson }},
-        "parameterized_host_template": {{ (keywords.escape_str(service_client.parameterized_host_template) if service_client.has_parameterized_host else None) | tojson }},
+        "description": {{ code_model.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": {{ code_model.options["azure_arm"]  | tojson }},
         "has_lro_operations": {{ code_model.has_lro_operations | tojson }},
         "client_side_validation": {{ code_model.options["client_side_validation"] | tojson }},
@@ -18,31 +18,31 @@
     },
     "global_parameters": {
         "sync": {
-            {% for gp in sync_global_parameters.config_method | rejectattr("serialized_name", "equalto", "api_version") %}
-            {{ gp.serialized_name | tojson }}: {
-                "signature": {{ gp.method_signature(is_python3_file=False) | tojson }},
+            {% for gp in global_parameters.method | rejectattr("client_name", "equalto", "api_version") | rejectattr("is_host") %}
+            {{ gp.client_name | tojson }}: {
+                "signature": {{ gp.method_signature(is_python3_file=False, async_mode=False) | tojson }},
                 "description": {{ gp.description | tojson }},
-                "docstring_type": {{ gp.docstring_type | tojson }},
-                "required": {{ gp.required | tojson }}
+                "docstring_type": {{ gp.docstring_type(async_mode=False) | tojson }},
+                "required": {{ (not gp.optional) | tojson }}
             }{{ "," if not loop.last else "" }}
             {% endfor %}
         },
         "async": {
-            {% for gp in async_global_parameters.config_method | rejectattr("serialized_name", "equalto", "api_version") %}
-            {{ gp.serialized_name | tojson }}: {
-                "signature": {{ (gp.method_signature(is_python3_file=True)) | tojson }},
+            {% for gp in global_parameters.method | rejectattr("client_name", "equalto", "api_version") | rejectattr("is_host") %}
+            {{ gp.client_name | tojson }}: {
+                "signature": {{ (gp.method_signature(is_python3_file=True, async_mode=True)) | tojson }},
                 "description": {{ gp.description | tojson }},
-                "docstring_type": {{ gp.docstring_type | tojson }},
-                "required": {{ gp.required | tojson }}
+                "docstring_type": {{ gp.docstring_type(async_mode=True) | tojson }},
+                "required": {{ (not gp.optional) | tojson }}
             }{{ "," if not loop.last else "" }}
             {% endfor %}
         },
         "constant": {
-            {% for gp in code_model.global_parameters.constant | rejectattr("serialized_name", "equalto", "api_version") %}
-            {{ gp.serialized_name | tojson }}: {{ gp.constant_declaration | tojson }}{{ "," if not loop.last else "" }}
+            {% for gp in code_model.client.parameters.constant | rejectattr("client_name", "equalto", "api_version") %}
+            {{ gp.client_name | tojson }}: {{ gp.constant_declaration | tojson }}{{ "," if not loop.last else "" }}
             {% endfor %}
         },
-        "call": {{ code_model.global_parameters.config_method | rejectattr("serialized_name", "equalto", "api_version") | map(attribute="serialized_name") | join(', ') | tojson }},
+        "call": {{ code_model.client.parameters.method | rejectattr("client_name", "equalto", "api_version") | rejectattr("is_host") | map(attribute="client_name") | join(', ') | tojson }},
         "service_client_specific": {
             "sync": {
                 "api_version": {
@@ -51,9 +51,9 @@
                     "docstring_type": "str",
                     "required": false
                 },
-                {% if not service_client.has_parameterized_host %}
+                {% if not client.has_parameterized_host %}
                 "base_url": {
-                    "signature": {{ service_client.parameters.host.method_signature(False) | tojson }},
+                    "signature": {{ client.parameters.host.method_signature(False, async_mode=False) | tojson }},
                     "description": "Service URL",
                     "docstring_type": "str",
                     "required": false
@@ -73,9 +73,9 @@
                     "docstring_type": "str",
                     "required": false
                 },
-                {% if not service_client.has_parameterized_host %}
+                {% if not client.has_parameterized_host %}
                 "base_url": {
-                    "signature": {{ service_client.parameters.host.method_signature(True) | tojson }},
+                    "signature": {{ client.parameters.host.method_signature(True, async_mode=True) | tojson }},
                     "description": "Service URL",
                     "docstring_type": "str",
                     "required": false
@@ -91,16 +91,16 @@
         }
     },
     "config": {
-        "credential": {{ code_model.options['credential'] | tojson }},
-        "credential_scopes": {{ (code_model.credential_schema_policy.credential_scopes if code_model.options['credential'] and code_model.credential_schema_policy.credential_scopes is defined else None)| tojson}},
-        "credential_call_sync": {{ (code_model.credential_schema_policy.call(async_mode=False) if code_model.options['credential'] else None) | tojson }},
-        "credential_call_async": {{ (code_model.credential_schema_policy.call(async_mode=True) if code_model.options['credential'] else None) | tojson }},
+        "credential": {{ has_credential | tojson }},
+        "credential_scopes": {{ (code_model.credential.type.policy.credential_scopes if has_credential and code_model.credential.type.policy.credential_scopes is defined else None)| tojson}},
+        "credential_call_sync": {{ (code_model.credential.type.policy.call(async_mode=False) if has_credential else None) | tojson }},
+        "credential_call_async": {{ (code_model.credential.type.policy.call(async_mode=True) if has_credential else None) | tojson }},
         "sync_imports": {{ sync_config_imports | tojson }},
         "async_imports": {{ async_config_imports | tojson }}
     },
     "operation_groups": {
-        {% for operation_group in code_model.operation_groups | rejectattr('is_empty_operation_group') %}
-        {{ operation_group.name | tojson }}: {{ operation_group.class_name | tojson }}{{ "," if not loop.last else "" }}
+        {% for operation_group in code_model.operation_groups | rejectattr('is_mixin') %}
+        {{ operation_group.property_name | tojson }}: {{ operation_group.class_name | tojson }}{{ "," if not loop.last else "" }}
         {% endfor %}
     }{{ "," if mixin_operations }}
     {% if mixin_operations %}
@@ -109,7 +109,7 @@
         "async_imports": {{ str(async_mixin_imports) | tojson }},
         "operations": {
             {% for operation in mixin_operations %}
-            {{ operation.python_name | tojson }} : {
+            {{ operation.name | tojson }} : {
                 {% set request_builder = operation.request_builder %}
                 "sync": {
                     {% set operation_serializer = get_sync_operation_serializer(operation) %}
@@ -126,8 +126,9 @@
                         {% from "operation.py.jinja2" import operation_docstring with context %}
                         {% set sync_return_type_wrapper = "" %}
                     {% endif %}
-                    "signature": {{ (operation_serializer.method_signature_and_response_type_annotation(operation) + "\n") | tojson }},
-                    "doc": {{ op_tools.description(operation, operation_serializer).rstrip("\n") | tojson }}
+                    "signature": {{ (operation_serializer.method_signature_and_response_type_annotation(operation, want_decorators=False) + "\n") | tojson }},
+                    "doc": {{ op_tools.description(operation, operation_serializer).rstrip("\n") | tojson }},
+                    "call": {{ operation.parameters.call | join(', ') | tojson }}
                 },
                 "async": {
                     {% set coroutine = False if (is_paging(operation) and not is_lro(operation)) else True %}
@@ -146,10 +147,10 @@
                         {% from "operation.py.jinja2" import operation_docstring with context %}
                         {% set async_return_type_wrapper = "" %}
                     {% endif %}
-                    "signature": {{ (operation_serializer.method_signature_and_response_type_annotation(operation) + "\n") | tojson }},
-                    "doc": {{ op_tools.description(operation, operation_serializer).rstrip("\n") | tojson }}
-                },
-                "call": {{ operation.parameters.method | rejectattr("is_kwarg") | map(attribute="serialized_name") | rejectattr("is_kwarg") | join(', ') | tojson }}
+                    "signature": {{ (operation_serializer.method_signature_and_response_type_annotation(operation, want_decorators=False) + "\n") | tojson }},
+                    "doc": {{ op_tools.description(operation, operation_serializer).rstrip("\n") | tojson }},
+                    "call": {{ operation.parameters.call | join(', ') | tojson }}
+                }
             }{{ "," if not loop.last else "" }}
             {% endfor %}
         }

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

@@ -1,30 +1,24 @@
-{% set basename = model.base_models | join(', ', attribute='name') if model.base_models else "" %}
 {# actual template starts here #}
 
 
-{% if basename %}
-class {{ model.name }}({{ basename }}):
-{% else %}
-class {{ model.name }}(msrest.serialization.Model):
-{% endif %}
-    """{{ model.description }}
-    {% if model.discriminator_name %}
+{{ serializer.declare_model(model) }}
+    """{{ model.description(is_operation_file=False) }}
+    {% if model.discriminated_subtypes %}
 
-    You probably want to use the sub-classes and not this class directly. Known
-    sub-classes are: {{ model.subtype_map.values()|join(', ') }}.
+    {{ serializer.discriminator_docstring(model) | wordwrap(width=95, break_long_words=False, break_on_hyphens=False, wrapstring='\n    ') }}
     {% endif %}
     {% if model.has_readonly_or_constant_property %}
 
     Variables are only populated by the server, and will be ignored when sending a request.
     {% endif %}
-    {% if (model.properties | selectattr('required') | first) is defined %}
+    {% if (model.properties | selectattr('optional', "equalto", false) | first) is defined %}
 
     All required parameters must be populated in order to send to Azure.
     {% endif %}
 
     {% if model.properties != None %}
         {% for p in model.properties %}
-            {% for line in variable_documentation_string(p) %}
+            {% for line in serializer.variable_documentation_string(p) %}
                 {% for doc_string in line.replace('\n', '\n ').split('\n') %}
     {{ doc_string | wordwrap(width=95, break_long_words=False, break_on_hyphens=False, wrapstring='\n     ') }}
                 {% endfor %}
@@ -32,45 +26,44 @@ class {{ model.name }}(msrest.serialization.Model):
         {% endfor %}
     {% endif %}
     """
-    {% if (model.properties | selectattr('validation_map') ) | first %}
+    {% if (model.properties | selectattr('validation') ) | first %}
 
     _validation = {
-        {% for p in model.properties | selectattr('validation_map')%}
-        '{{ p.name }}': {{ str(p.validation_map) }},
+        {% for p in model.properties | selectattr('validation')%}
+        '{{ p.client_name }}': {{ str(p.validation) }},
         {% endfor %}
     }
     {% endif %}
 
     _attribute_map = {
-        {% if model.properties != None %}
+        {% if model.properties %}
             {% for p in model.properties %}
-        '{{ p.name }}': {'key': '{{ p.escaped_swagger_name }}', 'type': '{{ p.serialization_type}}'{{ p.xml_metadata }}},
+        {{ p.attribute_map }}
             {% endfor %}
-        {% else%}
         {% endif %}
     }
-    {% if model.discriminator_name %}
+    {% if model.discriminated_subtypes %}
 
     _subtype_map = {
-        '{{ model.discriminator_name }}': {{ str(model.subtype_map) }}
+        '{{ model.discriminator.client_name }}': {{ str(model.discriminated_subtypes) }}
     }
     {% endif %}
-    {% if model.xml_metadata %}
+    {% if model.xml_map_content %}
     _xml_map = {
-        {{ model.xml_map_content() }}
+        {{ model.xml_map_content }}
     }
     {% endif %}
     {% if (model.properties | selectattr('constant') | first) is defined %}
 
         {% for p in model.properties | selectattr('constant')%}
-    {{ p.name }} = {{ p.constant_declaration }}
+    {{ p.client_name }} = {{ p.type.get_declaration() }}
         {% endfor %}
     {% endif %}
 
-    def __init__(
+    def __init__({{ model.init_pylint_disable }}
         self,
-        {% for param_signature in init_line(model) %}
-        {{ param_signature }},
+        {% for param_signature in serializer.init_line(model) %}
+        {{ param_signature }}
         {% endfor %}
         **kwargs
     ):
@@ -78,7 +71,7 @@ class {{ model.name }}(msrest.serialization.Model):
     {% if model.properties %}
         {% for p in model.properties %}
             {% if p.is_input %}
-                {% for line in input_documentation_string(p) %}
+                {% for line in serializer.input_documentation_string(p) %}
                     {% for doc_string in line.replace('\n', '\n ').split('\n') %}
         {{ doc_string | wordwrap(width=95, break_long_words=False, break_on_hyphens=False, wrapstring='\n         ') }}
                     {% endfor %}
@@ -87,6 +80,7 @@ class {{ model.name }}(msrest.serialization.Model):
         {% endfor %}
     {% endif %}
         """
-    {% for arg in init_args(model) %}
-        {{ arg }}
+        {{ serializer.super_call(model) }}
+    {% for initialize_property in serializer.initialize_properties(model) %}
+        {{ initialize_property }}
     {% endfor %}

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

@@ -1,7 +1,8 @@
 # coding=utf-8
+# pylint: disable=too-many-lines
 {{ code_model.options['license_header'] }}
 
 {{ imports }}
-{% for model in code_model.sorted_schemas %}
+{% for model in code_model.model_types %}
 {% include "model.py.jinja2" %}
 {% endfor %}

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

@@ -1,8 +1,9 @@
+{% import 'keywords.jinja2' as keywords %}
 # coding=utf-8
 {{ code_model.options['license_header'] }}
 {% macro iterate_models_py3() %}
     {% for schema in schemas %}
-from ._models_py3 import {{ schema }}
+from .{{ code_model.get_models_filename(is_python3_file=True) }} import {{ schema }}
     {% endfor %}
 {% endmacro %}
 
@@ -14,19 +15,17 @@ try:
     {{ iterate_models_py3() | indent-}}
 except (SyntaxError, ImportError):
         {% for schema in schemas %}
-    from ._models import {{ schema }}  # type: ignore
+    from .{{ code_model.get_models_filename(is_python3_file=False) }} import {{ schema }}  # type: ignore
         {% endfor %}
     {% endif %}
 {% endif %}
 {% if enums %}
 
-from ._{{ code_model.module_name }}_enums import (
-    {% for enum in enums %}
-    {{ enum }},
-    {% endfor %}
-)
+{% for enum in enums %}
+from .{{ code_model.enums_filename }} import {{ enum }}
+{% endfor %}
 {% endif %}
-
+{{ keywords.patch_imports() }}
 __all__ = [
     {% for schema in schemas %}
     '{{ schema }}',
@@ -37,3 +36,5 @@ __all__ = [
     {% endfor %}
 {% endif %}
 ]
+{{ keywords.extend_all }}
+_patch_sdk()

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

@@ -1,29 +1,24 @@
 {% import 'keywords.jinja2' as keywords with context %}
 {% import 'operation_tools.jinja2' as op_tools %}
-{% set trace_decorator = "@distributed_trace_async" if async_mode else "@distributed_trace" %}
-{% set stream_request_parameter = "stream=" ~ ("True" if operation.is_stream_response else "False") %}
 {# actual template starts here #}
-{%- if code_model.options['tracing'] and operation.want_tracing -%}
-{{ trace_decorator }}
+{% if operation.overloads and operation.public %}
+{{ op_tools.generate_overloads(operation_serializer, operation) }}
 {% endif %}
 {{ operation_serializer.method_signature_and_response_type_annotation(operation) }}
-{% if operation.want_description_docstring %}
+{% if operation.public %}
     {{ op_tools.description(operation, operation_serializer) | indent }}{% endif %}
-    cls = kwargs.pop('cls', None)  {{ operation_serializer.cls_type_annotation(operation) }}
-{% if operation.deprecated %}
+    {% if not operation.abstract %}
+        {% if operation.deprecated %}
     warnings.warn('Method {{operation.name}} is deprecated', DeprecationWarning)
-{% endif %}
+        {% endif %}
     {{ op_tools.serialize(operation_serializer.error_map(operation)) | indent }}
-    {% if operation.parameters.kwargs_to_pop(async_mode) %}
+        {% if operation_serializer.pop_kwargs_from_signature(operation) %}
     {{ op_tools.serialize(operation_serializer.pop_kwargs_from_signature(operation)) | indent }}
-    {% endif %}
+        {% endif %}
     {{ op_tools.serialize(operation_serializer.call_request_builder(operation)) | indent }}
-    pipeline_response = {{ keywords.await }}self._client._pipeline.run(  # pylint: disable=protected-access
-        request,
-        {{ stream_request_parameter }},
-        **kwargs
-    )
+    {{ op_tools.serialize(operation_serializer.make_pipeline_call(operation)) | indent }}
     {{ op_tools.serialize(operation_serializer.handle_response(operation)) | indent }}
+    {% endif %}
 {% if not code_model.options["version_tolerant"] %}
 {{ operation_serializer.get_metadata_url(operation) }}
 {% endif %}

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

@@ -1,36 +1,37 @@
 {% set disable = "  # pylint: disable=too-many-public-methods" if operation_group.operations | length > 20 else "" %}
-class {{ operation_group.class_name }}{{ object_base_class }}:{{ disable }}
-{% if not operation_group.is_empty_operation_group %}
+{% set base_class = ("(" + operation_group.base_class(async_mode) + ")") if operation_group.base_class(async_mode) else "" %}
+class {{ operation_group.class_name }}{{ base_class }}:{{ disable }}
+{% if not operation_group.is_mixin %}
     """
     .. warning::
         **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.class_name }}`'s
-        :attr:`{{ operation_group.name }}` attribute.
+        :class:`{{ "~" + code_model.namespace + (".aio." if async_mode else ".") + code_model.client.name }}`'s
+        :attr:`{{ operation_group.property_name }}` attribute.
     """
 
-{% if code_model.schemas and code_model.options["models_mode"] %}
+{% if code_model.public_model_types and code_model.options["models_mode"] %}
     models = _models
 
 {% endif %}
     def __init__(self, *args, **kwargs){{ return_none_type_annotation }}:
-        args = list(args)
-        self._client = args.pop(0) if args else kwargs.pop("client")
-        self._config = args.pop(0) if args else kwargs.pop("config")
-        self._serialize = args.pop(0) if args else kwargs.pop("serializer")
-        self._deserialize = args.pop(0) if args else kwargs.pop("deserializer")
+        input_args = list(args)
+        self._client = input_args.pop(0) if input_args else kwargs.pop("client")
+        self._config = input_args.pop(0) if input_args else kwargs.pop("config")
+        self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer")
+        self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer")
 
 {% endif %}
 {% for operation in operation_group.operations %}
 
 {% set request_builder = operation.request_builder %}
 {% set operation_serializer = get_operation_serializer(operation) %}
-    {% if is_lro(operation) and is_paging(operation) %}
+    {% if operation.operation_type == "lropaging" %}
     {%- macro someop() %}{% include "lro_paging_operation.py.jinja2" %}{% endmacro %}
-    {% elif is_lro(operation) %}
+    {% elif operation.operation_type == "lro" %}
     {%- macro someop() %}{% include "lro_operation.py.jinja2" %}{% endmacro %}
-    {% elif is_paging(operation) %}
+    {% elif operation.operation_type == "paging" %}
     {% macro someop() %}{% include "paging_operation.py.jinja2" %}{% endmacro %}
     {% else %}
     {% macro someop() %}{% include "operation.py.jinja2" %}{% endmacro %}

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

@@ -1,5 +1,4 @@
 {% import 'operation_tools.jinja2' as op_tools %}
-{% set object_base_class = "" if async_mode else "(object)" %}
 {% set operations_description = "async operations" if async_mode else "operations" %}
 {% set return_none_type_annotation = " -> None" if async_mode else "" %}
 # pylint: disable=too-many-lines
@@ -13,7 +12,7 @@
 # fmt: off
 {% endif %}
 {% for operation_group in operation_groups %}
-    {% for request_builder in code_model.rest.request_builders | selectattr("operation_group_name", "equalto", operation_group.name) %}
+    {% for request_builder in code_model.request_builders | selectattr("group_name", "equalto", operation_group.property_name) | rejectattr("is_overload") %}
 
         {% include "request_builder.py.jinja2" %}
     {% endfor %}