@autorest/python 5.18.0 → 6.0.0

package/autorest/codegen/serializers/__init__.py

@@ -14,9 +14,8 @@ from ..models import CodeModel, OperationGroup, RequestBuilder
 from ..models import TokenCredentialType
 from .enum_serializer import EnumSerializer
 from .general_serializer import GeneralSerializer
-from .model_generic_serializer import ModelGenericSerializer
 from .model_init_serializer import ModelInitSerializer
-from .model_python3_serializer import ModelPython3Serializer
+from .model_serializer import ModelSerializer
 from .operations_init_serializer import OperationsInitSerializer
 from .operation_groups_serializer import OperationGroupsSerializer
 from .metadata_serializer import MetadataSerializer
@@ -224,22 +223,9 @@ class JinjaSerializer:
         # Write the models folder
         models_path = namespace_path / Path("models")
         if self.code_model.model_types:
-            if not self.code_model.options["python3_only"]:
-                self._autorestapi.write_file(
-                    models_path
-                    / Path(
-                        f"{self.code_model.get_models_filename(is_python3_file=False)}.py"
-                    ),
-                    ModelGenericSerializer(
-                        code_model=self.code_model, env=env
-                    ).serialize(),
-                )
             self._autorestapi.write_file(
-                models_path
-                / Path(
-                    f"{self.code_model.get_models_filename(is_python3_file=True)}.py"
-                ),
-                ModelPython3Serializer(code_model=self.code_model, env=env).serialize(),
+                models_path / Path(f"{self.code_model.models_filename}.py"),
+                ModelSerializer(code_model=self.code_model, env=env).serialize(),
             )
         if self.code_model.enums:
             self._autorestapi.write_file(
@@ -287,18 +273,6 @@ class JinjaSerializer:
                 code_model=self.code_model,
                 env=env,
                 request_builders=request_builders,
-                is_python3_file=False,
-            ).serialize_request_builders(),
-        )
-
-        # write python3 request builders file
-        self._autorestapi.write_file(
-            output_path / Path("_request_builders_py3.py"),
-            RequestBuildersSerializer(
-                code_model=self.code_model,
-                env=env,
-                request_builders=request_builders,
-                is_python3_file=True,
             ).serialize_request_builders(),
         )
 
@@ -309,7 +283,6 @@ class JinjaSerializer:
                 code_model=self.code_model,
                 env=env,
                 request_builders=request_builders,
-                is_python3_file=True,
             ).serialize_init(),
         )
 
@@ -325,7 +298,6 @@ class JinjaSerializer:
             code_model=self.code_model,
             env=env,
             async_mode=False,
-            is_python3_file=self.code_model.options["python3_only"],
             operation_group=operation_group,
         )
         self._autorestapi.write_file(
@@ -335,31 +307,12 @@ class JinjaSerializer:
             operation_group_serializer.serialize(),
         )
 
-        if (
-            not self.code_model.options["python3_only"]
-            and self.code_model.options["add_python3_operation_files"]
-        ):
-            # write typed second file if not python 3 only
-            operation_group_serializer = OperationGroupsSerializer(
-                code_model=self.code_model,
-                env=env,
-                async_mode=False,
-                is_python3_file=True,
-            )
-            self._autorestapi.write_file(
-                namespace_path
-                / Path(self.code_model.operations_folder_name)
-                / Path(f"{filename}_py3.py"),
-                operation_group_serializer.serialize(),
-            )
-
         if self.has_aio_folder:
             # write async operation group and operation files
             operation_group_async_serializer = OperationGroupsSerializer(
                 code_model=self.code_model,
                 env=env,
                 async_mode=True,
-                is_python3_file=True,
                 operation_group=operation_group,
             )
             self._autorestapi.write_file(
@@ -477,6 +430,15 @@ class JinjaSerializer:
             namespace_path / Path("py.typed"), "# Marker file for PEP 561."
         )
 
+        if (
+            not self.code_model.options["client_side_validation"]
+            and not self.code_model.options["multiapi"]
+        ):
+            self._autorestapi.write_file(
+                namespace_path / Path("_serialization.py"),
+                general_serializer.serialize_serialization_file(),
+            )
+
         # Write the config file
         if self.code_model.request_builders:
             self._autorestapi.write_file(

package/autorest/codegen/serializers/builder_serializer.py

@@ -176,12 +176,9 @@ def _get_json_response_template_to_status_codes(
 
 
 class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-method
-    def __init__(
-        self, code_model: CodeModel, async_mode: bool, is_python3_file: bool
-    ) -> None:
+    def __init__(self, code_model: CodeModel, async_mode: bool) -> None:
         self.code_model = code_model
         self.async_mode = async_mode
-        self.is_python3_file = is_python3_file
         self.parameter_serializer = ParameterSerializer()
 
     @property
@@ -225,9 +222,7 @@ class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-
             function_def=self._function_def,
             method_name=builder.name,
             need_self_param=self._need_self_param,
-            method_param_signatures=builder.method_signature(
-                self.async_mode or self.is_python3_file, self.async_mode
-            ),
+            method_param_signatures=builder.method_signature(self.async_mode),
             pylint_disable=builder.pylint_disable,
         )
 
@@ -245,7 +240,6 @@ class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-
         return (
             decorators_str
             + utils.method_signature_and_response_type_annotation_template(
-                is_python3_file=self.is_python3_file,
                 method_signature=method_signature,
                 response_type_annotation=response_type_annotation,
             )
@@ -442,7 +436,7 @@ class RequestBuilderSerializer(
 
     def pop_kwargs_from_signature(self, builder: RequestBuilderType) -> List[str]:
         return self.parameter_serializer.pop_kwargs_from_signature(
-            builder.parameters.kwargs_to_pop(is_python3_file=self.is_python3_file),
+            builder.parameters.kwargs_to_pop,
             check_kwarg_dict=True,
             pop_headers_kwarg=PopKwargType.CASE_INSENSITIVE
             if bool(builder.parameters.headers)
@@ -452,7 +446,8 @@ class RequestBuilderSerializer(
             else PopKwargType.NO,
         )
 
-    def create_http_request(self, builder: RequestBuilderType) -> List[str]:
+    @staticmethod
+    def create_http_request(builder: RequestBuilderType) -> List[str]:
         retval = ["return HttpRequest("]
         retval.append(f'    method="{builder.method}",')
         retval.append("    url=_url,")
@@ -465,9 +460,9 @@ class RequestBuilderSerializer(
             and builder.parameters.body_parameter.in_method_signature
         ):
             body_param = builder.parameters.body_parameter
-            if body_param.constant or (
-                self.is_python3_file
-                and body_param.method_location != ParameterMethodLocation.KWARG
+            if (
+                body_param.constant
+                or body_param.method_location != ParameterMethodLocation.KWARG
             ):
                 # we only need to pass it through if it's not a kwarg or it's a popped kwarg
                 retval.append(
@@ -598,8 +593,6 @@ class _OperationSerializer(
     def decorators(self, builder: OperationType) -> List[str]:
         """Decorators for the method"""
         super_decorators = super().decorators(builder)
-        if builder.abstract:
-            super_decorators.append("@abc.abstractmethod")
         return super_decorators
 
     def param_description(
@@ -613,9 +606,7 @@ class _OperationSerializer(
         return description_list
 
     def pop_kwargs_from_signature(self, builder: OperationType) -> List[str]:
-        kwargs_to_pop = builder.parameters.kwargs_to_pop(
-            is_python3_file=self.is_python3_file
-        )
+        kwargs_to_pop = builder.parameters.kwargs_to_pop
         kwargs = self.parameter_serializer.pop_kwargs_from_signature(
             kwargs_to_pop,
             check_kwarg_dict=True,
@@ -824,7 +815,6 @@ class _OperationSerializer(
                 is_next_request
                 and builder.operation_type == "paging"
                 and not bool(builder.next_request_builder)  # type: ignore
-                and not self.code_model.options["reformat_next_link"]
                 and parameter.location == ParameterLocation.QUERY
             ):
                 # if we don't want to reformat query parameters for next link calls
@@ -835,10 +825,15 @@ class _OperationSerializer(
                 f"    {parameter.client_name}={parameter.name_in_high_level_operation},"
             )
         if request_builder.overloads:
+            seen_body_params = set()
             for overload in request_builder.overloads:
                 body_param = cast(
                     RequestBuilderBodyParameter, overload.parameters.body_parameter
                 )
+                if body_param.client_name in seen_body_params:
+                    continue
+                seen_body_params.add(body_param.client_name)
+
                 retval.append(
                     f"    {body_param.client_name}={body_param.name_in_high_level_operation},"
                 )
@@ -1105,15 +1100,12 @@ PagingOperationType = TypeVar(
 class _PagingOperationSerializer(
     _OperationSerializer[PagingOperationType]
 ):  # pylint: disable=abstract-method
-    def __init__(
-        self, code_model: CodeModel, async_mode: bool, is_python3_file: bool
-    ) -> None:
+    def __init__(self, code_model: CodeModel, async_mode: bool) -> None:
         # for pylint reasons need to redefine init
         # probably because inheritance is going too deep
-        super().__init__(code_model, async_mode, is_python3_file)
+        super().__init__(code_model, async_mode)
         self.code_model = code_model
         self.async_mode = async_mode
-        self.is_python3_file = is_python3_file
         self.parameter_serializer = ParameterSerializer()
 
     def serialize_path(self, builder: PagingOperationType) -> List[str]:
@@ -1126,8 +1118,6 @@ class _PagingOperationSerializer(
         retval: List[str] = []
         if self.code_model.options["tracing"] and builder.want_tracing:
             retval.append("@distributed_trace")
-        if builder.abstract:
-            retval.append("@abc.abstractmethod")
         return retval
 
     def call_next_link_request_builder(self, builder: PagingOperationType) -> List[str]:
@@ -1143,9 +1133,39 @@ class _PagingOperationSerializer(
             template_url = "next_link"
 
         request_builder = builder.next_request_builder or builder.request_builder
-        return self._call_request_builder_helper(
-            builder, request_builder, template_url=template_url, is_next_request=True
-        )
+        if builder.next_request_builder:
+            return self._call_request_builder_helper(
+                builder,
+                request_builder,
+                template_url=template_url,
+                is_next_request=True,
+            )
+        retval: List[str] = []
+        query_str = ""
+        next_link_str = "next_link"
+        try:
+            api_version_param = next(
+                p
+                for p in self.code_model.client.parameters
+                if p.rest_api_name == "api-version"
+            )
+            retval.append("# make call to next link with the client's api-version")
+            retval.append("_parsed_next_link = urlparse(next_link)")
+            retval.append(
+                "_next_request_params = case_insensitive_dict(parse_qs(_parsed_next_link.query))"
+            )
+            retval.append(
+                f'_next_request_params["api-version"] = {api_version_param.full_client_name}'
+            )
+            query_str = ", params=_next_request_params"
+            next_link_str = "urljoin(next_link, _parsed_next_link.path)"
+        except StopIteration:
+            pass
+
+        retval.append(f'request = HttpRequest("GET", {next_link_str}{query_str})')
+        retval.extend(self._postprocess_http_request(builder, "request.url"))
+
+        return retval
 
     def _prepare_request_callback(self, builder: PagingOperationType) -> List[str]:
         retval = ["def prepare_request(next_link=None):"]
@@ -1158,10 +1178,7 @@ class _PagingOperationSerializer(
         retval.extend(
             [f"        {line}" for line in self.call_next_link_request_builder(builder)]
         )
-        if not builder.next_request_builder and builder.parameters.path:
-            retval.append("")
-            retval.extend([f"        {line}" for line in self.serialize_path(builder)])
-        if not builder.next_request_builder:
+        if not builder.next_request_builder and self.code_model.is_legacy:
             retval.append('        request.method = "GET"')
         else:
             retval.append("")
@@ -1239,15 +1256,12 @@ LROOperationType = TypeVar(
 
 
 class _LROOperationSerializer(_OperationSerializer[LROOperationType]):
-    def __init__(
-        self, code_model: CodeModel, async_mode: bool, is_python3_file: bool
-    ) -> None:
+    def __init__(self, code_model: CodeModel, async_mode: bool) -> None:
         # for pylint reasons need to redefine init
         # probably because inheritance is going too deep
-        super().__init__(code_model, async_mode, is_python3_file)
+        super().__init__(code_model, async_mode)
         self.code_model = code_model
         self.async_mode = async_mode
-        self.is_python3_file = is_python3_file
         self.parameter_serializer = ParameterSerializer()
 
     def param_description(self, builder: LROOperationType) -> List[str]:
@@ -1427,7 +1441,6 @@ def get_operation_serializer(
     builder: Operation,
     code_model,
     async_mode: bool,
-    is_python3_file: bool,
 ) -> Union[
     OperationSerializer,
     PagingOperationSerializer,
@@ -1446,4 +1459,4 @@ def get_operation_serializer(
         retcls = LROOperationSerializer
     elif builder.operation_type == "paging":
         retcls = PagingOperationSerializer
-    return retcls(code_model, async_mode, is_python3_file)
+    return retcls(code_model, async_mode)

package/autorest/codegen/serializers/client_serializer.py

@@ -11,9 +11,8 @@ from .parameter_serializer import ParameterSerializer, PopKwargType
 
 
 class ClientSerializer:
-    def __init__(self, code_model: CodeModel, is_python3_file: bool) -> None:
+    def __init__(self, code_model: CodeModel) -> None:
         self.code_model = code_model
-        self.is_python3_file = is_python3_file
         self.parameter_serializer = ParameterSerializer()
 
     def _init_signature(self, async_mode: bool) -> str:
@@ -22,36 +21,32 @@ class ClientSerializer:
             method_name="__init__",
             need_self_param=True,
             method_param_signatures=self.code_model.client.parameters.method_signature(
-                async_mode or self.is_python3_file, async_mode
+                async_mode
             ),
         )
 
     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]:
+    def pop_kwargs_from_signature(self) -> List[str]:
         return self.parameter_serializer.pop_kwargs_from_signature(
-            self.code_model.client.parameters.kwargs_to_pop(
-                async_mode or self.is_python3_file,
-            ),
+            self.code_model.client.parameters.kwargs_to_pop,
             check_kwarg_dict=False,
             pop_headers_kwarg=PopKwargType.NO,
             pop_params_kwarg=PopKwargType.NO,
         )
 
-    def class_definition(self, async_mode) -> str:
+    @property
+    def class_definition(self) -> str:
         class_name = self.code_model.client.name
         has_mixin_og = any(og for og in self.code_model.operation_groups if og.is_mixin)
         base_class = ""
         if has_mixin_og:
             base_class = f"{class_name}OperationsMixin"
-        elif not (async_mode or self.is_python3_file):
-            base_class = "object"
         pylint_disable = self.code_model.client.pylint_disable
         if base_class:
             return f"class {class_name}({base_class}):{pylint_disable}"
@@ -101,6 +96,14 @@ class ClientSerializer:
         except StopIteration:
             return "_endpoint"
 
+    @property
+    def should_init_super(self) -> bool:
+        return any(
+            og
+            for og in self.code_model.operation_groups
+            if og.is_mixin and og.has_abstract_operations
+        )
+
     def initialize_pipeline_client(self, async_mode: bool) -> str:
         pipeline_client_name = self.code_model.client.pipeline_class(async_mode)
         return (
@@ -138,17 +141,10 @@ class ClientSerializer:
             )
         return retval
 
-    def _send_request_signature(self, async_mode: bool) -> str:
-        is_python3_file = async_mode or self.code_model.options["python3_only"]
-        request_signature = [
+    def _send_request_signature(self) -> str:
+        send_request_signature = [
             "request: HttpRequest,"
-            if is_python3_file
-            else "request,  # type: HttpRequest"
-        ]
-        send_request_signature = (
-            request_signature
-            + self.code_model.client.parameters.method_signature_kwargs(is_python3_file)
-        )
+        ] + self.code_model.client.parameters.method_signature_kwargs
         return self.parameter_serializer.serialize_method(
             function_def="def",
             method_name=self.code_model.client.send_request_name,
@@ -159,9 +155,8 @@ class ClientSerializer:
     def send_request_signature_and_response_type_annotation(
         self, async_mode: bool
     ) -> str:
-        send_request_signature = self._send_request_signature(async_mode)
+        send_request_signature = self._send_request_signature()
         return utils.method_signature_and_response_type_annotation_template(
-            is_python3_file=async_mode or self.is_python3_file,
             method_signature=send_request_signature,
             response_type_annotation="Awaitable[AsyncHttpResponse]"
             if async_mode
@@ -247,10 +242,9 @@ class ClientSerializer:
 
 
 class ConfigSerializer:
-    def __init__(self, code_model: CodeModel, is_python3_file: bool) -> None:
+    def __init__(self, code_model: CodeModel) -> None:
         self.code_model = code_model
         self.parameter_serializer = ParameterSerializer()
-        self.is_python3_file = is_python3_file
 
     def _init_signature(self, async_mode: bool) -> str:
         return self.parameter_serializer.serialize_method(
@@ -258,23 +252,20 @@ class ConfigSerializer:
             method_name="__init__",
             need_self_param=True,
             method_param_signatures=self.code_model.config.parameters.method_signature(
-                async_mode or self.is_python3_file, async_mode
+                async_mode
             ),
         )
 
     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]:
+    def pop_kwargs_from_signature(self) -> List[str]:
         return self.parameter_serializer.pop_kwargs_from_signature(
-            self.code_model.config.parameters.kwargs_to_pop(
-                async_mode or self.is_python3_file
-            ),
+            self.code_model.config.parameters.kwargs_to_pop,
             check_kwarg_dict=False,
             pop_headers_kwarg=PopKwargType.NO,
             pop_params_kwarg=PopKwargType.NO,

package/autorest/codegen/serializers/general_serializer.py

@@ -5,6 +5,7 @@
 # --------------------------------------------------------------------------
 from jinja2 import Environment
 from .import_serializer import FileImportSerializer, TypingSection
+from ..models.imports import MsrestImportType
 from ..models import (
     FileImport,
     ImportType,
@@ -33,14 +34,12 @@ class GeneralSerializer:
 
         template = self.env.get_template("client.py.jinja2")
 
-        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, is_python3_file=python3_only),
+            serializer=ClientSerializer(self.code_model),
             imports=FileImportSerializer(
                 self.code_model.client.imports(self.async_mode),
-                is_python3_file=self.async_mode or python3_only,
             ),
         )
 
@@ -73,18 +72,17 @@ class GeneralSerializer:
                 f"{self.code_model.client.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
+            file_import.add_msrest_import(
+                self.code_model,
+                ".." if self.async_mode else ".",
+                MsrestImportType.SerializerDeserializer,
+                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,
         )
@@ -98,15 +96,13 @@ class GeneralSerializer:
             package_name if package_name else self.code_model.client.name.lower()
         )
         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(
                 self.code_model.config.imports(self.async_mode),
-                is_python3_file=self.async_mode or python3_only,
             ),
-            serializer=ConfigSerializer(self.code_model, is_python3_file=python3_only),
+            serializer=ConfigSerializer(self.code_model),
             sdk_moniker=sdk_moniker,
         )
 
@@ -120,3 +116,7 @@ class GeneralSerializer:
         params.update(self.code_model.options)
         params.update(self.code_model.package_dependency)
         return template.render(code_model=self.code_model, **params)
+
+    def serialize_serialization_file(self) -> str:
+        template = self.env.get_template("serialization.py.jinja2")
+        return template.render(code_model=self.code_model)

package/autorest/codegen/serializers/import_serializer.py

@@ -58,11 +58,8 @@ def _get_import_clauses(imports: List[ImportModel], delimiter: str) -> List[str]
 
 
 class FileImportSerializer:
-    def __init__(
-        self, file_import: FileImport, is_python3_file: bool, async_mode: bool = False
-    ) -> None:
+    def __init__(self, file_import: FileImport, async_mode: bool = False) -> None:
         self.file_import = file_import
-        self.is_python3_file = is_python3_file
         self.async_mode = async_mode
 
     def _get_imports_list(
@@ -82,20 +79,14 @@ class FileImportSerializer:
         return file_import_copy.get_imports_from_section(baseline_typing_section)
 
     def _add_type_checking_import(self):
-        any_typing = any(
-            self.file_import.get_imports_from_section(TypingSection.TYPING)
-        )
-        conditional_and_not_py3 = not self.is_python3_file and any(
-            self.file_import.get_imports_from_section(TypingSection.CONDITIONAL)
-        )
-        if any_typing or conditional_and_not_py3:
+        if any(self.file_import.get_imports_from_section(TypingSection.TYPING)):
             self.file_import.add_submodule_import(
                 "typing", "TYPE_CHECKING", ImportType.STDLIB
             )
 
     def _get_typing_definitions(self) -> str:
         def declare_defintion(
-            spacing: str, type_name: str, type_definition: TypeDefinition
+            type_name: str, type_definition: TypeDefinition
         ) -> List[str]:
             ret: List[str] = []
             definition_value = (
@@ -112,21 +103,20 @@ class FileImportSerializer:
                 ):
                     if version is not None:
                         ret.append(
-                            "{}{} sys.version_info >= {}:".format(
-                                spacing, "if" if i == 0 else "elif", version
+                            "{} sys.version_info >= {}:".format(
+                                "if" if i == 0 else "elif", version
                             )
                         )
                     elif i > 0:
-                        ret.append("{}else:".format(spacing))
+                        ret.append("else:")
                     for import_clause in _get_import_clauses(
                         [type_definition.version_imports[version]], "\n"
                     ):
                         ret.append(
-                            "{}{}{}".format(
+                            "{}{}".format(
                                 "    "
                                 if len(versions) > 1 or version is not None
                                 else "",
-                                spacing,
                                 import_clause,
                             )
                         )
@@ -134,15 +124,14 @@ class FileImportSerializer:
                             ret[
                                 -1
                             ] += "  # type: ignore  # pylint: disable=ungrouped-imports"
-            ret.append("{}{} = {}".format(spacing, type_name, definition_value))
+            ret.append("{} = {}".format(type_name, definition_value))
             return ret
 
         if not self.file_import.type_definitions:
             return ""
-        spacing = "" if self.is_python3_file else "    "
         declarations: List[str] = [""]
         for type_name, value in self.file_import.type_definitions.items():
-            declarations.extend(declare_defintion(spacing, type_name, value))
+            declarations.extend(declare_defintion(type_name, value))
         return "\n".join(declarations)
 
     def __str__(self) -> str:
@@ -150,7 +139,7 @@ class FileImportSerializer:
         regular_imports = ""
         regular_imports_list = self._get_imports_list(
             baseline_typing_section=TypingSection.REGULAR,
-            add_conditional_typing=self.is_python3_file,
+            add_conditional_typing=True,
         )
 
         if regular_imports_list:
@@ -161,7 +150,7 @@ class FileImportSerializer:
         typing_imports = ""
         typing_imports_list = self._get_imports_list(
             baseline_typing_section=TypingSection.TYPING,
-            add_conditional_typing=not self.is_python3_file,
+            add_conditional_typing=False,
         )
         if typing_imports_list:
             typing_imports += "\n\nif TYPE_CHECKING:\n    # pylint: disable=unused-import,ungrouped-imports\n    "

package/autorest/codegen/serializers/metadata_serializer.py

@@ -143,13 +143,11 @@ class MetadataSerializer:
                 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_python3_file=False,
             ),
             has_credential=bool(self.code_model.credential),
         )