@autorest/python 5.16.0 → 5.17.0

package/autorest/codegen/serializers/utils.py

@@ -3,96 +3,6 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from enum import Enum, auto
-from typing import List
-from ..models import ParameterStyle, ListSchema, Parameter, ParameterLocation
-
-
-def serialize_method(
-    *,
-    function_def: str,
-    method_name: str,
-    is_in_class: bool,
-    method_param_signatures: List[str],
-    ignore_inconsistent_return_statements: bool = False,
-):
-    lines: List[str] = []
-    first_line = f"{function_def} {method_name}("
-    if ignore_inconsistent_return_statements:
-        first_line += "  # pylint: disable=inconsistent-return-statements"
-    lines.append(first_line)
-    if is_in_class:
-        lines.append("    self,")
-    lines.extend([("    " + line) for line in method_param_signatures])
-    lines.append(")")
-    return "\n".join(lines)
-
-
-def build_serialize_data_call(
-    parameter: Parameter, function_name: str, serializer_name: str
-) -> str:
-
-    optional_parameters = []
-
-    if parameter.skip_url_encoding:
-        optional_parameters.append("skip_quote=True")
-
-    if parameter.style and not parameter.explode:
-        if parameter.style in [ParameterStyle.simple, ParameterStyle.form]:
-            div_char = ","
-        elif parameter.style in [ParameterStyle.spaceDelimited]:
-            div_char = " "
-        elif parameter.style in [ParameterStyle.pipeDelimited]:
-            div_char = "|"
-        elif parameter.style in [ParameterStyle.tabDelimited]:
-            div_char = "\t"
-        else:
-            raise ValueError(f"Do not support {parameter.style} yet")
-        optional_parameters.append(f"div='{div_char}'")
-
-    if parameter.explode:
-        if not isinstance(parameter.schema, ListSchema):
-            raise ValueError("Got a explode boolean on a non-array schema")
-        serialization_schema = parameter.schema.element_type
-    else:
-        serialization_schema = parameter.schema
-
-    serialization_constraints = serialization_schema.serialization_constraints
-    if serialization_constraints:
-        optional_parameters += serialization_constraints
-
-    origin_name = parameter.full_serialized_name
-
-    parameters = [
-        f'"{origin_name.lstrip("_")}"',
-        "q" if parameter.explode else origin_name,
-        f"'{serialization_schema.serialization_type}'",
-        *optional_parameters,
-    ]
-    parameters_line = ", ".join(parameters)
-
-    serialize_line = f"{serializer_name}.{function_name}({parameters_line})"
-
-    if parameter.explode:
-        return f"[{serialize_line} if q is not None else '' for q in {origin_name}]"
-    return serialize_line
-
-
-def serialize_path(parameters: List[Parameter], serializer_name: str) -> List[str]:
-    retval = ["path_format_arguments = {"]
-    retval.extend(
-        [
-            '    "{}": {},'.format(
-                path_parameter.rest_api_name,
-                build_serialize_data_call(path_parameter, "url", serializer_name),
-            )
-            for path_parameter in parameters
-        ]
-    )
-    retval.append("}")
-    return retval
-
-
 def method_signature_and_response_type_annotation_template(
     *,
     is_python3_file: bool,
@@ -102,55 +12,3 @@ def method_signature_and_response_type_annotation_template(
     if is_python3_file:
         return f"{method_signature} -> {response_type_annotation}:"
     return f"{method_signature}:\n    # type: (...) -> {response_type_annotation}"
-
-
-class PopKwargType(Enum):
-    NO = auto()
-    SIMPLE = auto()
-    CASE_INSENSITIVE = auto()
-
-
-def pop_kwargs_from_signature(
-    kwargs_to_pop: List[Parameter],
-    check_kwarg_dict: bool,
-    pop_headers_kwarg: PopKwargType,
-    pop_params_kwarg: PopKwargType,
-) -> List[str]:
-    retval = []
-
-    def append_pop_kwarg(key: str, pop_type: PopKwargType) -> None:
-        if PopKwargType.CASE_INSENSITIVE == pop_type:
-            retval.append(
-                f'_{key} = case_insensitive_dict(kwargs.pop("{key}", {{}}) or {{}})'
-            )
-        elif PopKwargType.SIMPLE == pop_type:
-            retval.append(f'_{key} = kwargs.pop("{key}", {{}}) or {{}}')
-
-    append_pop_kwarg("headers", pop_headers_kwarg)
-    append_pop_kwarg("params", pop_params_kwarg)
-    if pop_headers_kwarg != PopKwargType.NO or pop_params_kwarg != PopKwargType.NO:
-        retval.append("")
-    for kwarg in kwargs_to_pop:
-        if kwarg.has_default_value:
-            default_value = kwarg.default_value_declaration
-            if check_kwarg_dict and (
-                kwarg.location in [ParameterLocation.Header, ParameterLocation.Query]
-            ):
-                kwarg_dict = (
-                    "headers"
-                    if kwarg.location == ParameterLocation.Header
-                    else "params"
-                )
-                default_value = (
-                    f"_{kwarg_dict}.pop('{kwarg.rest_api_name}', {default_value})"
-                )
-            retval.append(
-                f"{kwarg.serialized_name} = kwargs.pop('{kwarg.serialized_name}', "
-                + f"{default_value})  # type: {kwarg.type_annotation(is_operation_file=True)}"
-            )
-        else:
-            type_annot = kwarg.type_annotation(is_operation_file=True)
-            retval.append(
-                f"{kwarg.serialized_name} = kwargs.pop('{kwarg.serialized_name}')  # type: {type_annot}"
-            )
-    return retval

package/autorest/codegen/templates/MANIFEST.in.jinja2

@@ -1,5 +1,6 @@
 include *.md
 include LICENSE
+include {{ package_name.replace('-', '/') }}/py.typed
 recursive-include tests *.py
 recursive-include samples *.py *.md
 {%- for init_name in init_names %}

package/autorest/codegen/templates/{service_client.py.jinja2 → client.py.jinja2}

@@ -7,15 +7,15 @@
 {{ imports }}
 
 {{ serializer.class_definition(async_mode) }}
-    """{{ op_tools.wrap_string(code_model.description, "\n") | indent }}
+    """{{ op_tools.wrap_string(code_model.client.description, "\n") | indent }}
 
     {{ op_tools.serialize_with_wrap(serializer.property_descriptions(async_mode), "\n ") | indent }}
     {{ serializer.init_signature_and_response_type_annotation(async_mode) | indent }}
-    {% if code_model.service_client.parameters.kwargs_to_pop(async_mode) %}
+    {% if code_model.client.parameters.kwargs_to_pop(async_mode) %}
         {{ op_tools.serialize(serializer.pop_kwargs_from_signature(async_mode)) | indent(8) }}
     {% endif %}
-        {% if code_model.service_client.has_parameterized_host %}
-        _{{ code_model.service_client.parameters.host_variable_name }} = {{ keywords.escape_str(code_model.service_client.parameterized_host_template) }}
+        {% if code_model.client.has_parameterized_host %}
+        {{ serializer.host_variable_name }} = {{ keywords.escape_str(code_model.client.url) }}
         {% endif %}
         {{ serializer.initialize_config() }}
         {{ serializer.initialize_pipeline_client(async_mode) }}
@@ -26,7 +26,7 @@
     {{ serializer.send_request_signature_and_response_type_annotation(async_mode) | indent }}
         {{ op_tools.serialize(serializer.send_request_description(async_mode)) | indent(8) }}
         request_copy = deepcopy(request)
-        {% if code_model.global_parameters.path %}
+        {% if code_model.client.parameters.path %}
         {{ op_tools.serialize(serializer.serialize_path()) | indent(8) }}
         request_copy.url = self._client.format_url(request_copy.url, **path_format_arguments)
         {% else %}
@@ -40,9 +40,9 @@
         {% endif %}
         {{ keywords.await }}self._client.close()
 
-    {{ keywords.def }} __{{ keywords.async_prefix }}enter__(self){{ (" -> \"" + code_model.class_name + "\"") if async_mode else "" }}:
+    {{ keywords.def }} __{{ keywords.async_prefix }}enter__(self){{ (" -> \"" + code_model.client.name + "\"") if async_mode else "" }}:
         {% if not async_mode %}
-        # type: () -> {{ code_model.class_name }}
+        # type: () -> {{ code_model.client.name }}
         {% endif %}
         {{ keywords.await }}self._client.__{{ keywords.async_prefix }}enter__()
         return self

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_model.credential_schema_policy.credential_scopes is defined %}
-        self.credential_scopes = kwargs.pop('credential_scopes', {{ code_model.credential_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_model.credential_schema_policy.credential_scopes is defined and code_model.credential_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_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 }}({{ enum.enum_type.type_annotation() }}, Enum, metaclass=CaseInsensitiveEnumMeta):
-    {% 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 }}({{ enum.enum_type.type_annotation() }}, Enum, metaclass=Ca
     {% 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

@@ -4,6 +4,6 @@
 from enum import Enum
 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

@@ -3,7 +3,7 @@
 {{ code_model.options['license_header'] }}
 
 {% if code_model.request_builders %}
-from .{{ code_model.service_client.filename }} import {{ code_model.class_name }}
+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
@@ -12,7 +12,7 @@ __version__ = VERSION
 {% endif %}
 
 {{ keywords.patch_imports(try_except=True) }}
-__all__ = [{{("'" + code_model.class_name + "'") if code_model.request_builders else ""}}]
+__all__ = [{{("'" + code_model.client.name + "'") if code_model.request_builders else ""}}]
 {{ keywords.extend_all }}
 
 _patch_sdk()

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

@@ -1,6 +1,9 @@
 {% import 'operation_tools.jinja2' as op_tools with context %}
 {# actual template starts here #}
-{{ operation_serializer.method_signature_and_response_type_annotation(operation, async_mode) }}
+{% 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 not operation.abstract %}
         {% if operation_serializer.pop_kwargs_from_signature(operation) %}

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

@@ -1,7 +1,10 @@
 {% import 'operation_tools.jinja2' as op_tools with context %}
 {% import 'keywords.jinja2' as keywords with context %}
 {# actual template starts here #}
-{{ operation_serializer.method_signature_and_response_type_annotation(operation, async_mode) }}
+{% 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 not operation.abstract %}
         {% if operation_serializer.pop_kwargs_from_signature(operation) %}

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_model.credential_schema_policy.credential_scopes if code_model.options['credential'] and code_model.credential_model.credential_schema_policy.credential_scopes is defined else None)| tojson}},
-        "credential_call_sync": {{ (code_model.credential_model.credential_schema_policy.call(async_mode=False) if code_model.options['credential'] else None) | tojson }},
-        "credential_call_async": {{ (code_model.credential_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,9 +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, False, want_decorators=False) + "\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(is_python3_file=False) | join(', ') | tojson }}
+                    "call": {{ operation.parameters.call | join(', ') | tojson }}
                 },
                 "async": {
                     {% set coroutine = False if (is_paging(operation) and not is_lro(operation)) else True %}
@@ -147,9 +147,9 @@
                         {% 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, True, want_decorators=False) + "\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(is_python3_file=True) | join(', ') | tojson }}
+                    "call": {{ operation.parameters.call | join(', ') | tojson }}
                 }
             }{{ "," if not loop.last else "" }}
             {% endfor %}

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

@@ -1,25 +1,24 @@
 {# actual template starts here #}
 
 
-{{ declare_model(model) }}
-    """{{ 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 %}
@@ -27,45 +26,44 @@
         {% 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
     ):
@@ -73,7 +71,7 @@
     {% 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 %}
@@ -82,6 +80,7 @@
         {% 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

@@ -21,11 +21,9 @@ except (SyntaxError, ImportError):
 {% endif %}
 {% if enums %}
 
-from .{{ code_model.enums_filename }} import (
-    {% for enum in enums %}
-    {{ enum }},
-    {% endfor %}
-)
+{% for enum in enums %}
+from .{{ code_model.enums_filename }} import {{ enum }}
+{% endfor %}
 {% endif %}
 {{ keywords.patch_imports() }}
 __all__ = [

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

@@ -1,9 +1,11 @@
 {% import 'keywords.jinja2' as keywords with context %}
 {% import 'operation_tools.jinja2' as op_tools %}
-{% set stream_request_parameter = "stream=" ~ ("True" if operation.is_stream_response else "False") %}
 {# actual template starts here #}
-{{ operation_serializer.method_signature_and_response_type_annotation(operation, async_mode) }}
-{% if operation.want_description_docstring %}
+{% 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.public %}
     {{ op_tools.description(operation, operation_serializer) | indent }}{% endif %}
     {% if not operation.abstract %}
         {% if operation.deprecated %}
@@ -14,11 +16,7 @@
     {{ op_tools.serialize(operation_serializer.pop_kwargs_from_signature(operation)) | indent }}
         {% endif %}
     {{ op_tools.serialize(operation_serializer.call_request_builder(operation)) | indent }}
-    pipeline_response = {{ keywords.await }}self._client._pipeline.run(  # type: ignore # 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"] %}