@autorest/python 5.14.0 → 5.15.0

package/autorest/codegen/serializers/builder_serializer.py

@@ -110,12 +110,6 @@ def _serialize_files_and_data_body(builder, param_name: str) -> List[str]:
     retval.append("}")
     return retval
 
-def _pop_parameters_kwarg(
-    function_name: str,
-    kwarg_name: str,
-) -> str:
-    return f'_{function_name}_parameters = kwargs.pop("{kwarg_name}", {{}})  # type: Dict[str, Any]'
-
 def _serialize_grouped_body(builder) -> List[str]:
     retval: List[str] = []
     for grouped_parameter in builder.parameters.grouped:
@@ -165,7 +159,7 @@ def _content_type_docstring(builder) -> str:
     ).default_value_declaration
     return (
         ":keyword content_type: Media type of the body sent to the API. " +
-        f"Possible values are: {possible_values_str}. " +
+        f"Known values are: {possible_values_str}. " +
         f"Default value is {default_value}."
     )
 
@@ -411,10 +405,11 @@ class _BuilderBaseSerializer(_BuilderSerializerProtocol):  # pylint: disable=abs
         ...
 
     def _serialize_parameter(
-        self, param: Parameter, function_name: str
+        self, param: Parameter, kwarg_name: str
     ) -> List[str]:
-        set_parameter = "_{}_parameters['{}'] = {}".format(
-            function_name,
+        function_name = "header" if kwarg_name == "headers" else "query"
+        set_parameter = "_{}['{}'] = {}".format(
+            kwarg_name,
             param.rest_api_name,
             utils.build_serialize_data_call(param, function_name, self.serializer_name)
         )
@@ -434,10 +429,6 @@ class _BuilderBaseSerializer(_BuilderSerializerProtocol):  # pylint: disable=abs
             template.extend(f"response.json() == {response_body}".splitlines())
         return template
 
-
-    def pop_kwargs_from_signature(self, builder) -> List[str]:
-        return utils.pop_kwargs_from_signature(self._get_kwargs_to_pop(builder))
-
     def serialize_path(self, builder) -> List[str]:
         return utils.serialize_path(builder.parameters.path, self.serializer_name)
 
@@ -463,6 +454,21 @@ class _RequestBuilderBaseSerializer(_BuilderBaseSerializer):  # pylint: disable=
     def serializer_name(self) -> str:
         return "_SERIALIZER"
 
+    @staticmethod
+    def declare_non_inputtable_constants(builder) -> List[str]:
+        def _get_value(param: Parameter):
+            if param.location in [ParameterLocation.Header, ParameterLocation.Query]:
+                kwarg_dict = "headers" if param.location == ParameterLocation.Header else "params"
+                return f"_{kwarg_dict}.pop('{param.rest_api_name}', {param.constant_declaration})"
+            return f"{param.constant_declaration}"
+        return [
+            f"{p.serialized_name} = {_get_value(p)}"
+            for p in builder.parameters.constant
+            if p.original_parameter is None and
+            p.in_method_code and
+            not p.in_method_signature
+        ]
+
     def want_example_template(self, builder) -> bool:
         if self.code_model.options["builders_visibility"] != "public":
             return False  # if we're not exposing rest layer, don't need to generate
@@ -507,14 +513,24 @@ class _RequestBuilderBaseSerializer(_BuilderBaseSerializer):  # pylint: disable=
     def _body_params_to_pass_to_request_creation(self, builder) -> List[str]:
         ...
 
+    def pop_kwargs_from_signature(self, builder) -> List[str]:
+        return utils.pop_kwargs_from_signature(
+            self._get_kwargs_to_pop(builder),
+            check_kwarg_dict=True,
+            pop_headers_kwarg=utils.PopKwargType.CASE_INSENSITIVE if bool(builder.parameters.headers)
+                                else utils.PopKwargType.NO,
+            pop_params_kwarg=utils.PopKwargType.CASE_INSENSITIVE if bool(builder.parameters.query)
+                                else utils.PopKwargType.NO,
+        )
+
     def create_http_request(self, builder) -> List[str]:
         retval = ["return HttpRequest("]
         retval.append(f'    method="{builder.method}",')
         retval.append("    url=_url,")
         if builder.parameters.query:
-            retval.append("    params=_query_parameters,")
+            retval.append("    params=_params,")
         if builder.parameters.headers:
-            retval.append("    headers=_header_parameters,")
+            retval.append("    headers=_headers,")
         if builder.parameters.has_body:
             retval.extend([
                 f"    {body_kwarg}={body_kwarg},"
@@ -526,21 +542,19 @@ class _RequestBuilderBaseSerializer(_BuilderBaseSerializer):  # pylint: disable=
 
     def serialize_headers(self, builder) -> List[str]:
         retval = ["# Construct headers"]
-        retval.append(_pop_parameters_kwarg("header", "headers"))
         for parameter in builder.parameters.headers:
             retval.extend(self._serialize_parameter(
                 parameter,
-                function_name="header",
+                kwarg_name="headers",
             ))
         return retval
 
     def serialize_query(self, builder) -> List[str]:
         retval = ["# Construct parameters"]
-        retval.append(_pop_parameters_kwarg("query", "params"))
         for parameter in builder.parameters.query:
             retval.extend(self._serialize_parameter(
                 parameter,
-                function_name="query",
+                kwarg_name="params",
             ))
         return retval
 
@@ -644,7 +658,7 @@ class _OperationBaseSerializer(_BuilderBaseSerializer):  # pylint: disable=abstr
             return "bool"
         response_body_annotations: OrderedSet[str] = {}
         for response in [r for r in builder.responses if r.has_body]:
-            response_body_annotations[response.operation_type_annotation] = None
+            response_body_annotations[response.type_annotation(is_operation_file=True)] = None
         response_str = ", ".join(response_body_annotations.keys()) or "None"
         if len(response_body_annotations) > 1:
             response_str = f"Union[{response_str}]"
@@ -652,6 +666,19 @@ class _OperationBaseSerializer(_BuilderBaseSerializer):  # pylint: disable=abstr
             response_str = f"Optional[{response_str}]"
         return response_str
 
+    def pop_kwargs_from_signature(self, builder) -> List[str]:
+        kwargs_to_pop = self._get_kwargs_to_pop(builder)
+        kwargs = utils.pop_kwargs_from_signature(
+            kwargs_to_pop,
+            check_kwarg_dict=True,
+            pop_headers_kwarg=utils.PopKwargType.CASE_INSENSITIVE if builder.has_kwargs_to_pop_with_default(
+                kwargs_to_pop, ParameterLocation.Header) else utils.PopKwargType.SIMPLE,
+            pop_params_kwarg=utils.PopKwargType.CASE_INSENSITIVE if builder.has_kwargs_to_pop_with_default(
+                kwargs_to_pop, ParameterLocation.Query) else utils.PopKwargType.SIMPLE,
+        )
+        kwargs.append(f"cls = kwargs.pop('cls', None)  {self.cls_type_annotation(builder)}")
+        return kwargs
+
     def cls_type_annotation(self, builder) -> str:
         return f"# type: ClsType[{self._response_type_annotation(builder, modify_if_head_as_boolean=False)}]"
 
@@ -780,6 +807,7 @@ class _OperationBaseSerializer(_BuilderBaseSerializer):  # pylint: disable=abstr
         if len(body_kwargs) == 1:
             retval.extend(self._set_body_content_kwarg(builder, builder.parameters.body[0], body_kwargs[0]))
         else:
+            retval.append('content_type = content_type or ""')
             for idx, body_kwarg in enumerate(body_kwargs):
                 body_param = next(
                     b for b in builder_params
@@ -854,6 +882,8 @@ class _OperationBaseSerializer(_BuilderBaseSerializer):  # pylint: disable=abstr
         if not self.code_model.options["version_tolerant"]:
             template_url = template_url or f"self.{builder.name}.metadata['url']"
             retval.append(f"    template_url={template_url},")
+        retval.append('    headers=_headers,')
+        retval.append('    params=_params,')
         retval.append(f")")
         if not self.code_model.options["version_tolerant"]:
             pass_files = ""
@@ -866,7 +896,7 @@ class _OperationBaseSerializer(_BuilderBaseSerializer):  # pylint: disable=abstr
         if self.code_model.options["version_tolerant"] and template_url:
             url_to_format = template_url
         retval.append(
-            "request.url = self._client.format_url({}{})".format(
+            "request.url = self._client.format_url({}{})  # type: ignore".format(
                 url_to_format,
                 ", **path_format_arguments" if builder.parameters.path else ""
             )
@@ -901,12 +931,11 @@ class _OperationBaseSerializer(_BuilderBaseSerializer):  # pylint: disable=abstr
                 retval.append(f"deserialized = self._deserialize('{response.serialization_type}', pipeline_response)")
             else:
                 is_xml = any(["xml" in ct for ct in response.content_types])
-                deserialized_value = ""
                 deserialized_value = "ET.fromstring(response.text())" if is_xml else "response.json()"
                 retval.append(f"if response.content:")
                 retval.append(f"    deserialized = {deserialized_value}")
                 retval.append("else:")
-                retval.append("    deserialized = None")
+                retval.append(f"    deserialized = None")
         return retval
 
     @property
@@ -954,14 +983,18 @@ class _OperationBaseSerializer(_BuilderBaseSerializer):  # pylint: disable=abstr
                     builder.responses[0]
                 ))
                 retval.append("")
+        if builder.has_optional_return_type or self.code_model.options["models_mode"]:
+            deserialized = "deserialized"
+        else:
+            deserialized = f"cast({self._response_type_annotation(builder)}, deserialized)"
         retval.append("if cls:")
         retval.append("    return cls(pipeline_response, {}, {})".format(
-            "deserialized" if builder.has_response_body else "None",
+            deserialized if builder.has_response_body else "None",
             "response_headers" if builder.any_response_has_headers else '{}'
         ))
         if builder.has_response_body:
             retval.append("")
-            retval.append("return deserialized")
+            retval.append(f"return {deserialized}")
         if builder.request_builder.method == 'HEAD' and self.code_model.options['head_as_boolean']:
             retval.append("return 200 <= response.status_code <= 299")
         return retval
@@ -1010,7 +1043,7 @@ class _OperationBaseSerializer(_BuilderBaseSerializer):  # pylint: disable=abstr
         else:
             retval.append("    401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError")
         retval.append("}")
-        retval.append("error_map.update(kwargs.pop('error_map', {}))")
+        retval.append("error_map.update(kwargs.pop('error_map', {}) or {})")
         return retval
 
     @staticmethod
@@ -1185,7 +1218,7 @@ class _PagingOperationBaseSerializer(_OperationBaseSerializer):  # pylint: disab
         return retval
 
     def set_up_params_for_pager(self, builder) -> List[str]:
-        retval = [f"cls = kwargs.pop('cls', None)  {self.cls_type_annotation(builder)}"]
+        retval = []
         retval.extend(self.error_map(builder))
         retval.extend(self._prepare_request_callback(builder))
         retval.append("")
@@ -1276,19 +1309,20 @@ class _LROOperationBaseSerializer(_OperationBaseSerializer):  # pylint: disable=
 
     def initial_call(self, builder) -> List[str]:
         retval = [f"polling = kwargs.pop('polling', True)  # type: Union[bool, {self._polling_method_type}]"]
-        retval.append(f"cls = kwargs.pop('cls', None)  {self.cls_type_annotation(builder)}")
         retval.append("lro_delay = kwargs.pop(")
         retval.append("    'polling_interval',")
         retval.append("    self._config.polling_interval")
         retval.append(")")
         retval.append("cont_token = kwargs.pop('continuation_token', None)  # type: Optional[str]")
         retval.append("if cont_token is None:")
-        retval.append(f"    raw_result = {self._call_method}self.{builder.initial_operation.name}(")
+        retval.append(f"    raw_result = {self._call_method}self.{builder.initial_operation.name}(  # type: ignore")
         retval.extend([
             f"        {parameter.serialized_name}={parameter.serialized_name},"
             for parameter in builder.parameters.method
         ])
         retval.append("        cls=lambda x,y,z: x,")
+        retval.append("        headers=_headers,")
+        retval.append("        params=_params,")
         retval.append("        **kwargs")
         retval.append("    )")
         retval.append("kwargs.pop('error_map', None)")
@@ -1297,20 +1331,27 @@ class _LROOperationBaseSerializer(_OperationBaseSerializer):  # pylint: disable=
     def return_lro_poller(self, builder) -> List[str]:
         retval = []
         lro_options_str = (
-            ", lro_options={'final-state-via': '" + builder.lro_options['final-state-via'] + "'}"
+            "lro_options={'final-state-via': '" + builder.lro_options['final-state-via'] + "'},"
             if builder.lro_options else ""
         )
         path_format_arguments_str = ""
         if builder.parameters.path:
-            path_format_arguments_str = ", path_format_arguments=path_format_arguments"
+            path_format_arguments_str = "path_format_arguments=path_format_arguments,"
             retval.extend(self.serialize_path(builder))
             retval.append("")
-        retval.append(
-            f"if polling is True: polling_method = {self._default_polling_method(builder)}" +
-            f"(lro_delay{lro_options_str}{path_format_arguments_str}, **kwargs)"
+        retval.extend([
+            "if polling is True:",
+            f"    polling_method = cast({self._polling_method_type}, {self._default_polling_method(builder)}(",
+            "        lro_delay,",
+            f"        {lro_options_str}",
+            f"        {path_format_arguments_str}",
+            "        **kwargs",
+            f"))  # type: {self._polling_method_type}",
+        ]
         )
         retval.append(
-            f"elif polling is False: polling_method = {self._default_no_polling_method(builder)}()"
+            f"elif polling is False: polling_method = cast({self._polling_method_type}, "
+            f"{self._default_no_polling_method(builder)}())"
         )
         retval.append("else: polling_method = polling")
         retval.append("if cont_token:")
@@ -1331,7 +1372,8 @@ class _LROOperationBaseSerializer(_OperationBaseSerializer):  # pylint: disable=
         if builder.lro_response:
             if builder.lro_response.has_headers:
                 retval.append("    response_headers = {}")
-            retval.append("    response = pipeline_response.http_response")
+            if not self.code_model.options["models_mode"] or builder.lro_response.has_headers:
+                retval.append("    response = pipeline_response.http_response")
             retval.extend([
                 f"    {line}"
                 for line in self.response_headers_and_deserialization(builder.lro_response)

package/autorest/codegen/serializers/client_serializer.py

@@ -32,9 +32,14 @@ class ClientSerializer:
         )
 
     def pop_kwargs_from_signature(self, async_mode: bool) -> List[str]:
-        return utils.pop_kwargs_from_signature(self.code_model.service_client.parameters.kwargs_to_pop(
-            async_mode or self.is_python3_file
-        ))
+        return utils.pop_kwargs_from_signature(
+            self.code_model.service_client.parameters.kwargs_to_pop(
+                async_mode or self.is_python3_file,
+            ),
+            check_kwarg_dict=False,
+            pop_headers_kwarg=utils.PopKwargType.NO,
+            pop_params_kwarg=utils.PopKwargType.NO,
+        )
 
     def class_definition(self, async_mode) -> str:
         class_name = self.code_model.class_name
@@ -212,9 +217,14 @@ class ConfigSerializer:
         )
 
     def pop_kwargs_from_signature(self, async_mode: bool) -> List[str]:
-        return utils.pop_kwargs_from_signature(self.code_model.global_parameters.config_kwargs_to_pop(
-            async_mode or self.is_python3_file
-        ))
+        return utils.pop_kwargs_from_signature(
+            self.code_model.global_parameters.config_kwargs_to_pop(
+                async_mode or self.is_python3_file
+            ),
+            check_kwarg_dict=False,
+            pop_headers_kwarg=utils.PopKwargType.NO,
+            pop_params_kwarg=utils.PopKwargType.NO,
+        )
 
     def set_constants(self) -> List[str]:
         return [

package/autorest/codegen/serializers/general_serializer.py

@@ -50,7 +50,7 @@ class GeneralSerializer:
 
         if (
             self.code_model.options['credential'] and
-            isinstance(self.code_model.credential_schema_policy.credential, TokenCredentialSchema)
+            isinstance(self.code_model.credential_model.credential_schema_policy.credential, TokenCredentialSchema)
         ):
             self._correct_credential_parameter()
 
@@ -77,12 +77,33 @@ class GeneralSerializer:
                 ImportType.AZURECORE,
             )
 
+        if self.code_model.need_mixin_abc:
+            file_import.add_submodule_import(
+                "abc",
+                "ABC",
+                ImportType.STDLIB,
+            )
+            file_import.add_submodule_import(
+                "azure.core",
+                f"{'Async' if self.async_mode else ''}PipelineClient",
+                ImportType.AZURECORE,
+                TypingSection.TYPING,
+            )
+            file_import.add_submodule_import(
+                "._configuration",
+                f"{self.code_model.class_name}Configuration",
+                ImportType.LOCAL
+            )
+            file_import.add_submodule_import("msrest", "Serializer", ImportType.THIRDPARTY, TypingSection.TYPING)
+            file_import.add_submodule_import("msrest", "Deserializer", ImportType.THIRDPARTY, TypingSection.TYPING)
+
         return template.render(
             code_model=self.code_model,
             imports=FileImportSerializer(
                 file_import,
                 is_python3_file=self.async_mode,
-            )
+            ),
+            async_mode=self.async_mode,
         )
 
 
@@ -95,7 +116,7 @@ class GeneralSerializer:
 
         if (
             self.code_model.options['credential'] and
-            isinstance(self.code_model.credential_schema_policy.credential, TokenCredentialSchema)
+            isinstance(self.code_model.credential_model.credential_schema_policy.credential, TokenCredentialSchema)
         ):
             self._correct_credential_parameter()
 

package/autorest/codegen/serializers/import_serializer.py

@@ -12,7 +12,7 @@ def _serialize_package(
 ) -> str:
     buffer = []
     if any(i for i in imports if i.submodule_name is None):
-        buffer.append(f"import {imports[0].module_name}")
+        buffer.append(f"import {imports[0].module_name}{f' as {imports[0].alias}' if imports[0].alias else ''}")
     else:
         import_str = ", ".join(sorted([
             f"{i.submodule_name} as {i.alias}" if i.alias else i.submodule_name for i in imports # type: ignore

package/autorest/codegen/serializers/metadata_serializer.py

@@ -145,7 +145,7 @@ class MetadataSerializer:
         async_global_parameters = self.code_model.global_parameters
         if (
             self.code_model.options['credential'] and
-            isinstance(self.code_model.credential_schema_policy.credential, TokenCredentialSchema)
+            isinstance(self.code_model.credential_model.credential_schema_policy.credential, TokenCredentialSchema)
         ):
             # this ensures that the TokenCredentialSchema showing up in the list of code model's global parameters
             # is sync. This way we only have to make a copy for an async_credential

package/autorest/codegen/serializers/model_base_serializer.py

@@ -40,6 +40,7 @@ class ModelBaseSerializer:
             init_args=self.init_args,
             input_documentation_string=ModelBaseSerializer.input_documentation_string,
             variable_documentation_string=ModelBaseSerializer.variable_documentation_string,
+            declare_model=ModelBaseSerializer.declare_model,
         )
 
     def imports(self) -> FileImport:
@@ -62,6 +63,13 @@ class ModelBaseSerializer:
             properties_to_initialize = model.properties
         return properties_to_initialize
 
+    @staticmethod
+    def declare_model(model: ObjectSchema) -> str:
+        basename = "msrest.serialization.Model"
+        if model.base_models:
+            basename = ", ".join([cast(ObjectSchema, m).name for m in model.base_models])
+        return f"class {model.name}({basename}):"
+
     @staticmethod
     def input_documentation_string(prop: Property) -> List[str]:
         # building the param line of the property doc

package/autorest/codegen/serializers/model_python3_serializer.py

@@ -46,11 +46,11 @@ class ModelPython3Serializer(ModelBaseSerializer):
         return ", ".join(properties_to_pass_to_super)
 
     def required_property_no_default_init(self, prop: Property) -> str:
-        return f"{prop.name}: {prop.type_annotation}"
+        return f"{prop.name}: {prop.type_annotation()}"
 
     def optional_property_init(self, prop: Property) -> str:
         default = prop.default_value_declaration
-        return f"{prop.name}: {prop.type_annotation} = {default}"
+        return f"{prop.name}: {prop.type_annotation()} = {default}"
 
     def initialize_standard_arg(self, prop: Property) -> str:
         return f"self.{prop.name} = {prop.name}"

package/autorest/codegen/serializers/operation_groups_serializer.py

@@ -43,6 +43,7 @@ class OperationGroupsSerializer:
         for operation_group in operation_groups:
             imports.merge(operation_group.imports(
                 async_mode=self.async_mode,
+                is_python3_file=self.is_python3_file,
             ))
 
         template = self.env.get_or_select_template("operation_groups_container.py.jinja2")

package/autorest/codegen/serializers/patch_serializer.py

@@ -4,12 +4,21 @@
 # license information.
 # --------------------------------------------------------------------------
 from jinja2 import Environment
-
+from .import_serializer import FileImportSerializer
+from ..models import CodeModel, FileImport, ImportType, TypingSection
 
 class PatchSerializer:
-    def __init__(self, env: Environment) -> None:
+    def __init__(self, env: Environment, code_model: CodeModel) -> None:
         self.env = env
+        self.code_model = code_model
 
     def serialize(self) -> str:
         template = self.env.get_template("patch.py.jinja2")
-        return template.render()
+        imports = FileImport()
+        imports.add_submodule_import("typing", "List", ImportType.STDLIB, TypingSection.CONDITIONAL)
+        is_python3_file = self.code_model.options["python3_only"]
+        return template.render(
+            code_model=self.code_model,
+            imports=FileImportSerializer(imports, is_python3_file=is_python3_file),
+            is_python3_file=is_python3_file,
+        )

package/autorest/codegen/serializers/utils.py

@@ -3,8 +3,9 @@
 # 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
+from ..models import ParameterStyle, ListSchema, Parameter, ParameterLocation
 
 
 def serialize_method(
@@ -102,16 +103,40 @@ def method_signature_and_response_type_annotation_template(
         return f"{method_signature} -> {response_type_annotation}:"
     return f"{method_signature}:\n    # type: (...) -> {response_type_annotation}"
 
-def pop_kwargs_from_signature(kwargs_to_pop: List[Parameter]) -> List[str]:
+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"{kwarg.default_value_declaration})  # type: {kwarg.type_annotation}"
+                + 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: {kwarg.type_annotation}"
+                f"{kwarg.serialized_name} = kwargs.pop('{kwarg.serialized_name}')  # type: {type_annot}"
             )
     return retval

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

@@ -35,8 +35,8 @@ class {{ code_model.class_name }}Configuration(Configuration):  # pylint: disabl
 {% 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.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 }})
 {% endif %}
         kwargs.setdefault('sdk_moniker', '{{ sdk_moniker }}/{}'.format(VERSION))
         self._configure(**kwargs)
@@ -59,10 +59,10 @@ class {{ code_model.class_name }}Configuration(Configuration):  # pylint: disabl
         self.authentication_policy = kwargs.get('authentication_policy')
         {% if code_model.options['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_model.credential_schema_policy.credential_scopes is defined and code_model.credential_model.credential_schema_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_model.credential_schema_policy.call(async_mode) }}
         {% endif %}

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

@@ -1,5 +1,5 @@
 
-class {{ enum.name }}(with_metaclass(CaseInsensitiveEnumMeta, {{ enum.enum_type.type_annotation }}, Enum)):
+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    ') }}
     """

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

@@ -2,7 +2,6 @@
 {{ 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 %}

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.rest.request_builders %}
+from .{{ code_model.service_client.filename }} import {{ code_model.class_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.class_name + "'") if code_model.rest.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

@@ -6,7 +6,7 @@
 {% 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 operation_serializer.pop_kwargs_from_signature(operation) %}
     {{ op_tools.serialize(operation_serializer.pop_kwargs_from_signature(operation)) | indent }}
     {%- endif %}
     {{ op_tools.serialize(operation_serializer.initial_call(operation)) | indent }}

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

@@ -7,7 +7,7 @@
 {% 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 operation_serializer.pop_kwargs_from_signature(operation) %}
     {{ op_tools.serialize(operation_serializer.pop_kwargs_from_signature(operation)) | indent }}
     {% endif %}
     {{ op_tools.serialize(operation_serializer.set_up_params_for_pager(operation)) | indent }}