@autorest/python 5.19.0 → 6.0.1

package/autorest/codegen/serializers/client_serializer.py

@@ -11,47 +11,48 @@ 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:
+        pylint_disable = ""
+        if not self.code_model.client.parameters.credential:
+            pylint_disable = (
+                "  # pylint: disable=missing-client-constructor-parameter-credential"
+            )
         return self.parameter_serializer.serialize_method(
             function_def="def",
             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
             ),
+            pylint_disable=pylint_disable,
         )
 
     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}"
@@ -146,17 +147,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,
@@ -167,9 +161,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
@@ -255,10 +248,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(
@@ -266,23 +258,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

@@ -34,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,
             ),
         )
 
@@ -85,7 +83,6 @@ class GeneralSerializer:
             code_model=self.code_model,
             imports=FileImportSerializer(
                 file_import,
-                is_python3_file=self.async_mode,
             ),
             async_mode=self.async_mode,
         )
@@ -99,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,
         )
 

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),
         )

package/autorest/codegen/serializers/{model_base_serializer.py → model_serializer.py}

@@ -3,7 +3,6 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from abc import abstractmethod
 from typing import cast, List
 from jinja2 import Environment
 from ..models import ModelType, CodeModel, Property
@@ -27,22 +26,17 @@ def _documentation_string(
     return retval
 
 
-class ModelBaseSerializer:
-    def __init__(
-        self, code_model: CodeModel, env: Environment, is_python3_file: bool
-    ) -> None:
+class ModelSerializer:
+    def __init__(self, code_model: CodeModel, env: Environment) -> None:
         self.code_model = code_model
         self.env = env
-        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_python3_file=self.is_python3_file
-            ),
+            imports=FileImportSerializer(self.imports()),
             str=str,
             serializer=self,
         )
@@ -54,6 +48,11 @@ class ModelBaseSerializer:
         )
         for model in self.code_model.model_types:
             file_import.merge(model.imports(is_operation_file=False))
+            init_line_parameters = [
+                p for p in model.properties if not p.readonly and not p.is_discriminator
+            ]
+            for param in init_line_parameters:
+                file_import.merge(param.imports())
         return file_import
 
     @staticmethod
@@ -92,18 +91,12 @@ class ModelBaseSerializer:
     def variable_documentation_string(prop: Property) -> List[str]:
         return _documentation_string(prop, "ivar", "vartype")
 
-    @abstractmethod
-    def super_call_template(self, model: ModelType) -> str:
-        ...
-
     def super_call(self, model: ModelType):
-        return self.super_call_template(model).format(
-            self.properties_to_pass_to_super(model)
-        )
+        return f"super().__init__({self.properties_to_pass_to_super(model)})"
 
     def initialize_properties(self, model: ModelType) -> List[str]:
         init_args = []
-        for prop in ModelBaseSerializer.get_properties_to_initialize(model):
+        for prop in self.get_properties_to_initialize(model):
             if prop.is_discriminator:
                 discriminator_value = (
                     f"'{model.discriminator_value}'"
@@ -120,13 +113,17 @@ class ModelBaseSerializer:
             elif prop.readonly:
                 init_args.append(f"self.{prop.client_name} = None")
             elif not prop.constant:
-                init_args.append(self.initialize_standard_arg(prop))
+                init_args.append(f"self.{prop.client_name} = {prop.client_name}")
         return init_args
 
-    def initialize_standard_property(self, prop: Property):
+    @staticmethod
+    def initialize_standard_property(prop: Property):
         if not (prop.optional or prop.client_default_value is not None):
-            return self.required_property_no_default_init(prop)
-        return self.optional_property_init(prop)
+            return f"{prop.client_name}: {prop.type_annotation()},{prop.pylint_disable}"
+        return (
+            f"{prop.client_name}: {prop.type_annotation()} = "
+            f"{prop.client_default_value_declaration},{prop.pylint_disable}"
+        )
 
     @staticmethod
     def discriminator_docstring(model: ModelType) -> str:
@@ -135,22 +132,34 @@ class ModelBaseSerializer:
             f"Known sub-classes are: {', '.join(v.name for v in model.discriminated_subtypes.values())}"
         )
 
-    @abstractmethod
     def init_line(self, model: ModelType) -> List[str]:
-        ...
+        init_properties_declaration = []
+        init_line_parameters = [
+            p
+            for p in model.properties
+            if not p.readonly and not p.is_discriminator and not p.constant
+        ]
+        init_line_parameters.sort(key=lambda x: x.optional)
+        if init_line_parameters:
+            init_properties_declaration.append("*,")
+        for param in init_line_parameters:
+            init_properties_declaration.append(self.initialize_standard_property(param))
+
+        return init_properties_declaration
 
-    @abstractmethod
-    def properties_to_pass_to_super(self, model: ModelType) -> str:
-        ...
-
-    @abstractmethod
-    def required_property_no_default_init(self, prop: Property) -> str:
-        ...
-
-    @abstractmethod
-    def optional_property_init(self, prop: Property) -> str:
-        ...
-
-    @abstractmethod
-    def initialize_standard_arg(self, prop: Property) -> str:
-        ...
+    @staticmethod
+    def properties_to_pass_to_super(model: ModelType) -> str:
+        properties_to_pass_to_super = []
+        for parent in model.parents:
+            for prop in model.properties:
+                if (
+                    prop in parent.properties
+                    and not prop.is_discriminator
+                    and not prop.constant
+                    and not prop.readonly
+                ):
+                    properties_to_pass_to_super.append(
+                        f"{prop.client_name}={prop.client_name}"
+                    )
+        properties_to_pass_to_super.append("**kwargs")
+        return ", ".join(properties_to_pass_to_super)

package/autorest/codegen/serializers/operation_groups_serializer.py

@@ -22,13 +22,11 @@ class OperationGroupsSerializer:
         code_model: CodeModel,
         env: Environment,
         async_mode: bool,
-        is_python3_file: bool,
         operation_group: Optional[OperationGroup] = None,
     ) -> None:
         self.code_model = code_model
         self.env = env
         self.async_mode = async_mode
-        self.is_python3_file = is_python3_file
         self.operation_group = operation_group
 
     def serialize(self) -> str:
@@ -42,7 +40,6 @@ class OperationGroupsSerializer:
             imports.merge(
                 operation_group.imports(
                     async_mode=self.async_mode,
-                    is_python3_file=self.is_python3_file,
                 )
             )
 
@@ -54,21 +51,17 @@ class OperationGroupsSerializer:
             operation_groups=operation_groups,
             imports=FileImportSerializer(
                 imports,
-                is_python3_file=self.is_python3_file,
                 async_mode=self.async_mode,
             ),
             async_mode=self.async_mode,
-            is_python3_file=self.is_python3_file,
             get_operation_serializer=functools.partial(
                 get_operation_serializer,
                 code_model=self.code_model,
                 async_mode=self.async_mode,
-                is_python3_file=self.is_python3_file,
             ),
             request_builder_serializer=RequestBuilderSerializer(
                 self.code_model,
                 async_mode=False,
-                is_python3_file=self.is_python3_file,
             ),
             request_builders=[
                 rb for rb in self.code_model.request_builders if not rb.abstract

package/autorest/codegen/serializers/operations_init_serializer.py

@@ -18,40 +18,19 @@ class OperationsInitSerializer:
         self.env = env
         self.async_mode = async_mode
 
-    def _operation_group_imports_helper(self, filename_suffix: str = "") -> List[str]:
+    def operation_group_imports(self) -> List[str]:
         def _get_filename(operation_group: OperationGroup) -> str:
-            prefix = (
+            return (
                 "_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_folder_init.py.jinja2"

package/autorest/codegen/serializers/patch_serializer.py

@@ -19,9 +19,7 @@ class PatchSerializer:
         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,
+            imports=FileImportSerializer(imports),
         )

package/autorest/codegen/serializers/request_builders_serializer.py

@@ -18,13 +18,11 @@ class RequestBuildersSerializer:
         code_model: CodeModel,
         env: Environment,
         request_builders: List[RequestBuilderType],
-        is_python3_file: bool,
     ) -> None:
         self.code_model = code_model
         self.env = env
         self.request_builders = request_builders
         self.group_name = request_builders[0].group_name
-        self.is_python3_file = is_python3_file
 
     @property
     def imports(self) -> FileImport:
@@ -49,9 +47,8 @@ class RequestBuildersSerializer:
             request_builders=[rb for rb in self.request_builders if not rb.abstract],
             imports=FileImportSerializer(
                 self.imports,
-                is_python3_file=True,
             ),
             request_builder_serializer=RequestBuilderSerializer(
-                self.code_model, async_mode=False, is_python3_file=self.is_python3_file
+                self.code_model, async_mode=False
             ),
         )

package/autorest/codegen/serializers/utils.py

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

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

@@ -6,7 +6,7 @@
 
 {{ imports }}
 
-{{ serializer.class_definition(async_mode) }}
+{{ serializer.class_definition }}
     """{{ op_tools.wrap_string(code_model.client.description, "\n") | indent }}
 
     {{ op_tools.serialize_with_wrap(serializer.property_descriptions(async_mode), "\n ") | indent }}
@@ -14,8 +14,8 @@
     {% if serializer.should_init_super %}
         super().__init__()
     {% endif %}
-    {% if code_model.client.parameters.kwargs_to_pop(async_mode) %}
-        {{ op_tools.serialize(serializer.pop_kwargs_from_signature(async_mode)) | indent(8) }}
+    {% if code_model.client.parameters.kwargs_to_pop %}
+        {{ op_tools.serialize(serializer.pop_kwargs_from_signature()) | indent(8) }}
     {% endif %}
         {% if code_model.client.has_parameterized_host %}
         {{ serializer.host_variable_name }} = {{ keywords.escape_str(code_model.client.url) }}

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

@@ -22,8 +22,8 @@ class {{ code_model.client.name }}Configuration(Configuration):  # pylint: disab
     {{ 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.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) }}
+    {% if code_model.config.parameters.kwargs_to_pop %}
+        {{ op_tools.serialize(serializer.pop_kwargs_from_signature()) | indent(8) }}
     {% endif %}
 {% if serializer.check_required_parameters() %}
         {{ op_tools.serialize(serializer.check_required_parameters()) | indent(8) -}}

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

@@ -20,7 +20,7 @@
         "sync": {
             {% 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 }},
+                "signature": {{ gp.method_signature(async_mode=False) | tojson }},
                 "description": {{ gp.description | tojson }},
                 "docstring_type": {{ gp.docstring_type(async_mode=False) | tojson }},
                 "required": {{ (not gp.optional) | tojson }}
@@ -30,7 +30,7 @@
         "async": {
             {% 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 }},
+                "signature": {{ (gp.method_signature(async_mode=True)) | tojson }},
                 "description": {{ gp.description | tojson }},
                 "docstring_type": {{ gp.docstring_type(async_mode=True) | tojson }},
                 "required": {{ (not gp.optional) | tojson }}
@@ -53,7 +53,7 @@
                 },
                 {% if not client.has_parameterized_host %}
                 "base_url": {
-                    "signature": {{ client.parameters.host.method_signature(False, async_mode=False) | tojson }},
+                    "signature": {{ client.parameters.host.method_signature(async_mode=False) | tojson }},
                     "description": "Service URL",
                     "docstring_type": "str",
                     "required": false
@@ -75,7 +75,7 @@
                 },
                 {% if not client.has_parameterized_host %}
                 "base_url": {
-                    "signature": {{ client.parameters.host.method_signature(True, async_mode=True) | tojson }},
+                    "signature": {{ client.parameters.host.method_signature(async_mode=True) | tojson }},
                     "description": "Service URL",
                     "docstring_type": "str",
                     "required": false

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

@@ -3,21 +3,14 @@
 {{ code_model.options['license_header'] }}
 {% macro iterate_models_py3() %}
     {% for schema in schemas %}
-from .{{ code_model.get_models_filename(is_python3_file=True) }} import {{ schema }}
+from .{{ code_model.models_filename }} import {{ schema }}
     {% endfor %}
 {% endmacro %}
-
 {% if schemas %}
-    {% if code_model.options["python3_only"] %}
-{{ iterate_models_py3() }}
-    {% else %}
-try:
-    {{ iterate_models_py3() | indent-}}
-except (SyntaxError, ImportError):
-        {% for schema in schemas %}
-    from .{{ code_model.get_models_filename(is_python3_file=False) }} import {{ schema }}  # type: ignore
-        {% endfor %}
-    {% endif %}
+
+    {% for schema in schemas %}
+from .{{ code_model.models_filename }} import {{ schema }}
+    {% endfor %}
 {% endif %}
 {% if enums %}
 

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

@@ -1,5 +1,5 @@
 {% set disable = "  # pylint: disable=too-many-public-methods" if operation_group.operations | length > 20 else "" %}
-{% set base_class = ("(" + operation_group.base_class(async_mode) + ")") if operation_group.base_class(async_mode) else "" %}
+{% set base_class = ("(" + operation_group.base_class + ")") if operation_group.base_class else "" %}
 {% macro check_abstract_methods() %}
 {% if operation_group.has_abstract_operations %}
         raise_if_not_implemented(self.__class__, [