@autorest/python 5.11.0 → 5.12.1

package/autorest/codegen/serializers/client_serializer.py

@@ -9,27 +9,32 @@ from ..models import CodeModel
 
 
 class ClientSerializer:
-    def __init__(self, code_model: CodeModel) -> None:
+    def __init__(self, code_model: CodeModel, is_python3_file: bool) -> None:
         self.code_model = code_model
+        self.is_python3_file = is_python3_file
 
     def _init_signature(self, async_mode: bool) -> str:
         return utils.serialize_method(
             function_def="def",
             method_name="__init__",
             is_in_class=True,
-            method_param_signatures=self.code_model.service_client.parameters.client_method_signature(async_mode),
+            method_param_signatures=self.code_model.service_client.parameters.client_method_signature(
+                async_mode or self.is_python3_file
+            ),
         )
 
     def init_signature_and_response_type_annotation(self, async_mode: bool) -> str:
         init_signature = self._init_signature(async_mode)
         return utils.method_signature_and_response_type_annotation_template(
-            is_python_3_file=async_mode,
+            is_python3_file=async_mode or self.is_python3_file,
             method_signature=init_signature,
             response_type_annotation="None",
         )
 
     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))
+        return utils.pop_kwargs_from_signature(self.code_model.service_client.parameters.kwargs_to_pop(
+            async_mode or self.is_python3_file
+        ))
 
     def class_definition(self, async_mode) -> str:
         class_name = self.code_model.class_name
@@ -37,7 +42,7 @@ class ClientSerializer:
         base_class = ""
         if has_mixin_og:
             base_class = f"{class_name}OperationsMixin"
-        elif not async_mode:
+        elif not (async_mode or self.is_python3_file):
             base_class = "object"
         if base_class:
             return f"class {class_name}({base_class}):"
@@ -107,13 +112,15 @@ class ClientSerializer:
             function_def="def",
             method_name=self.code_model.send_request_name,
             is_in_class=True,
-            method_param_signatures=self.code_model.service_client.send_request_signature(async_mode),
+            method_param_signatures=self.code_model.service_client.send_request_signature(
+                async_mode, async_mode or self.is_python3_file
+            ),
         )
 
     def send_request_signature_and_response_type_annotation(self, async_mode: bool) -> str:
         send_request_signature = self._send_request_signature(async_mode)
         return utils.method_signature_and_response_type_annotation_template(
-            is_python_3_file=async_mode,
+            is_python3_file=async_mode or self.is_python3_file,
             method_signature=send_request_signature,
             response_type_annotation="Awaitable[AsyncHttpResponse]" if async_mode else "HttpResponse",
         )
@@ -179,11 +186,32 @@ class ClientSerializer:
 
 class ConfigSerializer:
 
-    def __init__(self, code_model: CodeModel) -> None:
+    def __init__(self, code_model: CodeModel, is_python3_file: bool) -> None:
         self.code_model = code_model
+        self.is_python3_file = is_python3_file
+
+    def _init_signature(self, async_mode: bool) -> str:
+        return utils.serialize_method(
+            function_def="def",
+            method_name="__init__",
+            is_in_class=True,
+            method_param_signatures=self.code_model.global_parameters.config_method_signature(
+                async_mode or self.is_python3_file
+            ),
+        )
+
+    def init_signature_and_response_type_annotation(self, async_mode: bool) -> str:
+        init_signature = self._init_signature(async_mode)
+        return utils.method_signature_and_response_type_annotation_template(
+            is_python3_file=async_mode or self.is_python3_file,
+            method_signature=init_signature,
+            response_type_annotation="None",
+        )
 
     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))
+        return utils.pop_kwargs_from_signature(self.code_model.global_parameters.config_kwargs_to_pop(
+            async_mode or self.is_python3_file
+        ))
 
     def set_constants(self) -> List[str]:
         return [

package/autorest/codegen/serializers/general_serializer.py

@@ -54,13 +54,14 @@ class GeneralSerializer:
         ):
             self._correct_credential_parameter()
 
+        python3_only = self.code_model.options["python3_only"]
         return template.render(
             code_model=self.code_model,
             async_mode=self.async_mode,
-            serializer=ClientSerializer(self.code_model),
+            serializer=ClientSerializer(self.code_model, is_python3_file=python3_only),
             imports=FileImportSerializer(
                 self.code_model.service_client.imports(self.async_mode),
-                is_python_3_file=self.async_mode
+                is_python3_file=self.async_mode or python3_only
             ),
         )
 
@@ -80,7 +81,7 @@ class GeneralSerializer:
             code_model=self.code_model,
             imports=FileImportSerializer(
                 file_import,
-                is_python_3_file=self.async_mode,
+                is_python3_file=self.async_mode,
             )
         )
 
@@ -99,15 +100,16 @@ class GeneralSerializer:
             self._correct_credential_parameter()
 
         template = self.env.get_template("config.py.jinja2")
+        python3_only = self.code_model.options["python3_only"]
         return template.render(
             code_model=self.code_model,
             async_mode=self.async_mode,
             imports=FileImportSerializer(
                 config_imports(
                     self.code_model, self.code_model.global_parameters, self.async_mode
-                ), is_python_3_file=self.async_mode
+                ), is_python3_file=self.async_mode or python3_only
             ),
-            serializer=ConfigSerializer(self.code_model),
+            serializer=ConfigSerializer(self.code_model, is_python3_file=python3_only),
             sdk_moniker=sdk_moniker,
         )
 

package/autorest/codegen/serializers/import_serializer.py

@@ -42,9 +42,9 @@ def _get_import_clauses(
 
 
 class FileImportSerializer:
-    def __init__(self, file_import: FileImport, is_python_3_file: bool, async_mode: bool = False) -> None:
+    def __init__(self, file_import: FileImport, is_python3_file: bool, async_mode: bool = False) -> None:
         self._file_import = file_import
-        self.is_python_3_file = is_python_3_file
+        self.is_python3_file = is_python3_file
         self.async_mode = async_mode
 
     def _switch_typing_section_key(self, new_key: TypingSection):
@@ -67,14 +67,14 @@ class FileImportSerializer:
     def _add_type_checking_import(self):
         if (
             self._file_import.imports.get(TypingSection.TYPING) or
-            (not self.is_python_3_file and self._file_import.imports.get(TypingSection.CONDITIONAL))
+            (not self.is_python3_file and self._file_import.imports.get(TypingSection.CONDITIONAL))
         ):
             self._file_import.add_from_import("typing", "TYPE_CHECKING", ImportType.STDLIB)
 
     def _get_typing_definitions(self) -> str:
         if not self._file_import.type_definitions:
             return ""
-        spacing = "" if self.is_python_3_file else "    "
+        spacing = "" if self.is_python3_file else "    "
         declarations: List[str] = [f"\n{spacing}T = TypeVar('T')"]
         declarations.extend([
             "{}{} = {}".format(
@@ -90,7 +90,7 @@ class FileImportSerializer:
         self._add_type_checking_import()
         regular_imports = ""
         regular_imports_dict = self._get_imports_dict(
-            baseline_typing_section=TypingSection.REGULAR, add_conditional_typing=self.is_python_3_file
+            baseline_typing_section=TypingSection.REGULAR, add_conditional_typing=self.is_python3_file
         )
 
         if regular_imports_dict:
@@ -100,7 +100,7 @@ class FileImportSerializer:
 
         typing_imports = ""
         typing_imports_dict = self._get_imports_dict(
-            baseline_typing_section=TypingSection.TYPING, add_conditional_typing=not self.is_python_3_file
+            baseline_typing_section=TypingSection.TYPING, add_conditional_typing=not self.is_python3_file
         )
         if typing_imports_dict:
             typing_imports += "\n\nif TYPE_CHECKING:\n    # pylint: disable=unused-import,ungrouped-imports\n    "

package/autorest/codegen/serializers/metadata_serializer.py

@@ -185,9 +185,9 @@ class MetadataSerializer:
                 config_imports(self.code_model, async_global_parameters, async_mode=True).imports
             ),
             get_async_operation_serializer=functools.partial(
-                get_operation_serializer, code_model=self.code_model, async_mode=True, is_python_3_file=True
+                get_operation_serializer, code_model=self.code_model, async_mode=True, is_python3_file=True
             ),
             get_sync_operation_serializer=functools.partial(
-                get_operation_serializer, code_model=self.code_model, async_mode=False, is_python_3_file=False
+                get_operation_serializer, code_model=self.code_model, async_mode=False, is_python3_file=False
             ),
         )

package/autorest/codegen/serializers/model_base_serializer.py

@@ -24,17 +24,17 @@ def _documentation_string(
 
 
 class ModelBaseSerializer:
-    def __init__(self, code_model: CodeModel, env: Environment, is_python_3_file: bool) -> None:
+    def __init__(self, code_model: CodeModel, env: Environment, is_python3_file: bool) -> None:
         self.code_model = code_model
         self.env = env
-        self.is_python_3_file = is_python_3_file
+        self.is_python3_file = is_python3_file
 
     def serialize(self) -> str:
         # Generate the models
         template = self.env.get_template("model_container.py.jinja2")
         return template.render(
             code_model=self.code_model,
-            imports=FileImportSerializer(self.imports(), is_python_3_file=self.is_python_3_file),
+            imports=FileImportSerializer(self.imports(), is_python3_file=self.is_python3_file),
             str=str,
             init_line=self.init_line,
             init_args=self.init_args,

package/autorest/codegen/serializers/model_generic_serializer.py

@@ -13,7 +13,7 @@ class ModelGenericSerializer(ModelBaseSerializer):
 
     def __init__(self, code_model: CodeModel, env: Environment) -> None:
         super(ModelGenericSerializer, self).__init__(
-            code_model=code_model, env=env, is_python_3_file=False
+            code_model=code_model, env=env, is_python3_file=False
         )
 
     def init_line(self, model: ObjectSchema) -> List[str]:

package/autorest/codegen/serializers/model_python3_serializer.py

@@ -14,7 +14,7 @@ class ModelPython3Serializer(ModelBaseSerializer):
 
     def __init__(self, code_model: CodeModel, env: Environment) -> None:
         super(ModelPython3Serializer, self).__init__(
-            code_model=code_model, env=env, is_python_3_file=True
+            code_model=code_model, env=env, is_python3_file=True
         )
 
     def init_line(self, model: ObjectSchema) -> List[str]:

package/autorest/codegen/serializers/{operation_group_serializer.py → operation_groups_serializer.py}

@@ -3,30 +3,34 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
+from typing import Optional
 import functools
-from copy import copy
-from typing import List
 from jinja2 import Environment
 
+from ..models import (
+    CodeModel,
+    OperationGroup,
+    FileImport,
+    LROOperation,
+    PagingOperation
+)
 from .import_serializer import FileImportSerializer
-from ..models import LROOperation, PagingOperation, CodeModel, OperationGroup
 from .builder_serializer import get_operation_serializer, get_request_builder_serializer
 
-
-class OperationGroupSerializer:
+class OperationGroupsSerializer:
     def __init__(
         self,
         code_model: CodeModel,
         env: Environment,
-        operation_groups: List[OperationGroup],
         async_mode: bool,
-        is_python_3_file: bool,
+        is_python3_file: bool,
+        operation_group: Optional[OperationGroup] = None,
     ) -> None:
         self.code_model = code_model
         self.env = env
-        self.operation_groups = operation_groups
         self.async_mode = async_mode
-        self.is_python_3_file = is_python_3_file
+        self.is_python3_file = is_python3_file
+        self.operation_group = operation_group
 
     def serialize(self) -> str:
         def _is_lro(operation):
@@ -34,39 +38,33 @@ class OperationGroupSerializer:
 
         def _is_paging(operation):
             return isinstance(operation, PagingOperation)
+        operation_groups = [self.operation_group] if self.operation_group else self.code_model.operation_groups
+        imports = FileImport()
+        for operation_group in operation_groups:
+            imports.merge(operation_group.imports(
+                async_mode=self.async_mode,
+            ))
 
-        operation_group_template = self.env.get_template("operations_container.py.jinja2")
-        if not self.code_model.options["combine_operation_files"] and self.operation_groups[0].is_empty_operation_group:
-            operation_group_template = self.env.get_template("operations_container_mixin.py.jinja2")
-
-        has_schemas = self.code_model.schemas or self.code_model.enums
-
-        # extract all operations from operation_groups
-        operaions_all = [operation for groups in self.operation_groups for operation in groups.operations]
-        operation_group_temp = copy(self.operation_groups[0])
-        operation_group_temp.operations = operaions_all
-
-        return operation_group_template.render(
+        template = self.env.get_or_select_template("operation_groups_container.py.jinja2")
+        return template.render(
             code_model=self.code_model,
-            operation_groups=self.operation_groups,
+            operation_groups=operation_groups,
             imports=FileImportSerializer(
-                operation_group_temp.imports(
-                    async_mode=self.async_mode,
-                    has_schemas=bool(has_schemas)
-                ), is_python_3_file=self.is_python_3_file,
+                imports,
+                is_python3_file=self.is_python3_file,
                 async_mode=self.async_mode
             ),
             async_mode=self.async_mode,
-            is_python_3_file=self.is_python_3_file,
+            is_python3_file=self.is_python3_file,
             is_lro=_is_lro,
             is_paging=_is_paging,
             get_operation_serializer=functools.partial(
                 get_operation_serializer,
                 code_model=self.code_model,
                 async_mode=self.async_mode,
-                is_python_3_file=self.is_python_3_file,
+                is_python3_file=self.is_python3_file,
             ),
             request_builder_serializer=get_request_builder_serializer(
-                self.code_model, self.is_python_3_file,
+                self.code_model, self.is_python3_file,
             ),
         )

package/autorest/codegen/serializers/operations_init_serializer.py

@@ -3,7 +3,10 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
+from typing import List
 from jinja2 import Environment
+
+from autorest.codegen.models.operation_group import OperationGroup
 from ..models import CodeModel
 
 
@@ -13,9 +16,38 @@ class OperationsInitSerializer:
         self.env = env
         self.async_mode = async_mode
 
+    def _operation_group_imports_helper(self, filename_suffix: str = "") -> List[str]:
+        def _get_filename(operation_group: OperationGroup) -> str:
+            prefix = "_operations" if self.code_model.options["combine_operation_files"] else operation_group.filename
+            return prefix + filename_suffix
+        return [
+            f"from .{_get_filename(og)} import {og.class_name}"
+            for og in self.code_model.operation_groups
+        ]
+
+    def operation_group_imports(self) -> List[str]:
+        typed_py3_files = self.code_model.options["add_python3_operation_files"]
+        py3_only = self.code_model.options["python3_only"]
+        if typed_py3_files and not py3_only and not self.async_mode:
+            retval: List[str] = ["try:"]
+            retval.extend([
+                f"    {line}"
+                for line in self._operation_group_imports_helper(filename_suffix="_py3")
+            ])
+            retval.append("except (SyntaxError, ImportError):")
+            retval.extend([
+                f"    {line}"
+                for line in self._operation_group_imports_helper()
+            ])
+            return retval
+        return self._operation_group_imports_helper()
+
     def serialize(self) -> str:
-        operation_group_init_template = self.env.get_template("operations_container_init.py.jinja2")
+        operation_group_init_template = self.env.get_template("operations_folder_init.py.jinja2")
 
         return operation_group_init_template.render(
-            code_model=self.code_model, operation_groups=self.code_model.operation_groups, async_mode=self.async_mode
+            code_model=self.code_model,
+            operation_groups=self.code_model.operation_groups,
+            async_mode=self.async_mode,
+            operation_group_imports=self.operation_group_imports,
         )

package/autorest/codegen/serializers/patch_serializer.py

@@ -0,0 +1,15 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+from jinja2 import Environment
+
+
+class PatchSerializer:
+    def __init__(self, env: Environment) -> None:
+        self.env = env
+
+    def serialize(self) -> str:
+        template = self.env.get_template("patch.py.jinja2")
+        return template.render()

package/autorest/codegen/serializers/rest_serializer.py

@@ -20,6 +20,7 @@ class RestSerializer:
         self.code_model = code_model
         self.env = env
         self.request_builders = request_builders
+        self.builder_group_name = request_builders[0].builder_group_name
 
     def serialize_init(self) -> str:
         template = self.env.get_template("rest_init.py.jinja2")
@@ -33,8 +34,10 @@ class RestPython3Serializer(RestSerializer):
         return template.render(
             code_model=self.code_model,
             request_builders=self.request_builders,
-            imports=FileImportSerializer(self.code_model.rest.imports(), is_python_3_file=True),
-            is_python_3_file=True,
+            imports=FileImportSerializer(self.code_model.rest.imports(
+                self.builder_group_name
+            ), is_python3_file=True),
+            is_python3_file=True,
             request_builder_serializer=RequestBuilderPython3Serializer(self.code_model),
         )
 
@@ -46,7 +49,9 @@ class RestGenericSerializer(RestSerializer):
         return template.render(
             code_model=self.code_model,
             request_builders=self.request_builders,
-            imports=FileImportSerializer(self.code_model.rest.imports(), is_python_3_file=False),
-            is_python_3_file=False,
+            imports=FileImportSerializer(self.code_model.rest.imports(
+                self.builder_group_name
+            ), is_python3_file=False),
+            is_python3_file=False,
             request_builder_serializer=RequestBuilderGenericSerializer(self.code_model),
         )

package/autorest/codegen/serializers/utils.py

@@ -90,11 +90,11 @@ def serialize_path(
 
 def method_signature_and_response_type_annotation_template(
     *,
-    is_python_3_file: bool,
+    is_python3_file: bool,
     method_signature: str,
     response_type_annotation: str,
 ) -> str:
-    if is_python_3_file:
+    if is_python3_file:
         return f"{method_signature} -> {response_type_annotation}:"
     return f"{method_signature}:\n    # type: (...) -> {response_type_annotation}"
 

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

@@ -1,13 +1,6 @@
 {% import 'keywords.jinja2' as keywords with context %}
 {% import 'operation_tools.jinja2' as op_tools %}
 {% set version_import = ".._version" if async_mode else "._version" %}
-{% macro method_signature() %}
-def __init__(
-    self,
-    {% for param_signature in code_model.global_parameters.config_method_signature(async_mode) %}
-    {{ param_signature }}
-    {% endfor %}
-){{" -> None" if async_mode else "" }}:{% endmacro %}
 {# actual template starts here #}
 # coding=utf-8
 {{ code_model.options['license_header'] }}
@@ -32,10 +25,7 @@ class {{ code_model.class_name }}Configuration(Configuration):
 {% endfor %}
     """
 
-    {{ method_signature()|indent }}
-    {% if not async_mode %}
-        # type: (...) -> None
-    {% endif %}
+    {{ 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) %}
         {{ op_tools.serialize(serializer.pop_kwargs_from_signature(async_mode)) | indent(8) }}

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

@@ -9,8 +9,7 @@ __version__ = VERSION
 {% endif %}
 __all__ = ['{{ code_model.class_name }}']
 
-try:
-    from ._patch import patch_sdk  # type: ignore
-    patch_sdk()
-except ImportError:
-    pass
+# `._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()

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

@@ -20,7 +20,7 @@
         "sync": {
             {% for gp in sync_global_parameters.config_method %}
             {{ gp.serialized_name | tojson }}: {
-                "signature": {{ gp.method_signature(is_python_3_file=False) | tojson }},
+                "signature": {{ gp.method_signature(is_python3_file=False) | tojson }},
                 "description": {{ gp.description | tojson }},
                 "docstring_type": {{ gp.docstring_type | tojson }},
                 "required": {{ gp.required | tojson }}
@@ -30,7 +30,7 @@
         "async": {
             {% for gp in async_global_parameters.config_method %}
             {{ gp.serialized_name | tojson }}: {
-                "signature": {{ (gp.method_signature(is_python_3_file=True)) | tojson }},
+                "signature": {{ (gp.method_signature(is_python3_file=True)) | tojson }},
                 "description": {{ gp.description | tojson }},
                 "docstring_type": {{ gp.docstring_type | tojson }},
                 "required": {{ gp.required | tojson }}

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

@@ -7,7 +7,7 @@ from ._models_py3 import {{ schema }}
 {% endmacro %}
 
 {% if schemas %}
-    {% if code_model.options["python_3_only"] %}
+    {% if code_model.options["python3_only"] %}
 {{ iterate_models_py3() }}
     {% else %}
 try:

package/autorest/codegen/templates/{operations_class.py.jinja2 → operation_group.py.jinja2}

@@ -1,4 +1,5 @@
 class {{ operation_group.class_name }}{{ object_base_class }}:
+{% if not operation_group.is_empty_operation_group %}
     """{{ operation_group.class_name }} {{ operations_description }}.
 
     You should not instantiate this class directly. Instead, you should create a Client instance that
@@ -23,6 +24,7 @@ class {{ operation_group.class_name }}{{ object_base_class }}:
         self._serialize = serializer
         self._deserialize = deserializer
         self._config = config
+{% endif %}
 {% for operation in operation_group.operations %}
 
 {% set request_builder = operation.request_builder %}

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

@@ -0,0 +1,26 @@
+{% 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 "" %}
+# coding=utf-8
+{{ code_model.options['license_header'] }}
+{{ imports }}
+
+{% if code_model.options["builders_visibility"] == "embedded" and not async_mode %}
+{{ op_tools.declare_serializer(code_model) }}
+{%- if not is_python3_file %}
+# 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) %}
+
+        {% include "request_builder.py.jinja2" %}
+    {% endfor %}
+{% endfor %}
+{% if not is_python3_file %}
+# fmt: on
+{% endif %}
+{% endif %}
+{% for operation_group in operation_groups %}
+    {% include "operation_group.py.jinja2" %}
+{% endfor %}

package/autorest/codegen/templates/operation_tools.jinja2

@@ -48,3 +48,10 @@ Example:
 
     {% endif %}
 {% endfor %}{% endmacro %}
+
+{% macro declare_serializer(code_model) %}
+_SERIALIZER = Serializer()
+    {% if not code_model.options["client_side_validation"] %}
+_SERIALIZER.client_side_validation = False
+    {% endif %}
+{% endmacro %}

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

@@ -0,0 +1,13 @@
+{% import 'operation_tools.jinja2' as op_tools %}
+{# actual template starts here #}
+# coding=utf-8
+{{ code_model.options['license_header'] }}
+
+{{ op_tools.serialize(operation_group_imports()) }}
+{% if operation_groups %}
+__all__ = [
+    {% for operation_group in operation_groups %}
+    '{{ operation_group.class_name }}',
+    {% endfor %}
+]
+{% endif %}

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

@@ -0,0 +1,31 @@
+# coding=utf-8
+# --------------------------------------------------------------------------
+#
+# Copyright (c) Microsoft Corporation. All rights reserved.
+#
+# The MIT License (MIT)
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the ""Software""), to
+# deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+# sell copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+#
+# --------------------------------------------------------------------------
+
+# This file 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
+def patch_sdk():
+    pass

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

@@ -4,7 +4,7 @@
 {% if code_model.options["builders_visibility"] == "public" %}
     {{ op_tools.description(request_builder, request_builder_serializer) | indent }}
 {% endif %}
-{% if request_builder.parameters.kwargs_to_pop(is_python_3_file) %}
+{% if request_builder.parameters.kwargs_to_pop(is_python3_file) %}
     {{ op_tools.serialize(request_builder_serializer.pop_kwargs_from_signature(request_builder)) | indent }}
 {% endif %}
 {% if request_builder.parameters.constant|selectattr("original_parameter", "equalto", None)|selectattr("in_method_code")|selectattr("in_method_signature", "equalto", False) %}
@@ -13,7 +13,12 @@
     {% endfor %}
 {% endif %}
     # Construct URL
-    url = kwargs.pop("template_url", {{ keywords.escape_str(request_builder.url) }})
+{% if code_model.options["version_tolerant"] or code_model.options["low_level_client"] %}
+    {% set url_value = keywords.escape_str(request_builder.url) %}
+{% else %}
+    {% set url_value = 'kwargs.pop("template_url", ' + keywords.escape_str(request_builder.url) + ')' %}
+{% endif %}
+    url = {{ url_value }}
 {% if request_builder.parameters.path %}
     {{ op_tools.serialize(request_builder_serializer.serialize_path(request_builder)) | indent }}
     url = _format_url_section(url, **path_format_arguments)