@autorest/python 5.18.0 → 5.19.0

package/ChangeLog.md

@@ -1,39 +1,40 @@
-# Change
+# Release History
 
-### 2022-07-09 - 5.18.0
+### 2022-07-13 - 5.19.0
 
 | Library                                                                 | Min Version |
 | ----------------------------------------------------------------------- | ----------- |
 | `@autorest/core`                                                        | `3.8.1`     |
 | `@autorest/modelerfour`                                                 | `4.23.5`    |
-| `azure-core` dep of generated code                                      | `1.23.0`    |
-| `msrest` dep of generated code                                          | `0.6.21`    |
+| `azure-core` dep of generated code                                      | `1.24.0`    |
+| `msrest` dep of generated code                                          | `0.7.0`    |
 | `azure-mgmt-core` dep of generated code (If generating mgmt plane code) | `1.3.0`     |
 
-**Breaking Changes in Version Tolerant**
-
-- No longer allow users to specify `api_version` on the method level  #1281
-- Make `content_type` param required with no default if streaming with no `application/octet-stream`  #1288
-
-**Bug Fixes**
-
-- Fix duplicate params in signature with `--payload-flattening-threshold`  #1289
-- Fix overloaded request builder signatures  #1289
+**New Features**
+- Add _serialization.py for `--client-side-validation=false` generation, and migrate serilization from msrest to _serialization.py #1236
 
-### 2022-xx-xx - 5.17.1
+### 2022-07-13 - 5.18.0
 
 | Library                                                                 | Min Version |
 | ----------------------------------------------------------------------- | ----------- |
 | `@autorest/core`                                                        | `3.8.1`     |
 | `@autorest/modelerfour`                                                 | `4.23.5`    |
-| `azure-core` dep of generated code                                      | `1.23.0`    |
-| `msrest` dep of generated code                                          | `0.6.21`    |
+| `azure-core` dep of generated code                                      | `1.24.0`    |
+| `msrest` dep of generated code                                          | `0.7.0`    |
 | `azure-mgmt-core` dep of generated code (If generating mgmt plane code) | `1.3.0`     |
 
+**Breaking Changes in Version Tolerant**
+
+- No longer allow users to specify `api_version` on the method level  #1281
+- Make `content_type` param required with no default if streaming with no `application/octet-stream`  #1288
+
 **Bug Fixes**
 
+- Fix duplicate params in signature with `--payload-flattening-threshold`  #1289
+- Fix overloaded request builder signatures  #1289
 - Improve docstring templates, specifically for polymorphic bodies  #1279
 
+
 ### 2022-06-02 - 5.17.0
 
 | Library                                                                 | Min Version |

package/autorest/codegen/__init__.py

@@ -97,6 +97,11 @@ def _validate_code_model_options(options: Dict[str, Any]) -> None:
             "We are working on creating a new multiapi SDK for version tolerant and it is not available yet."
         )
 
+    if options["client_side_validation"] and options["version_tolerant"]:
+        raise ValueError(
+            "Can not generate version tolerant with --client-side-validation. "
+        )
+
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -130,8 +135,8 @@ class CodeGenerator(Plugin):
     def _build_package_dependency() -> Dict[str, str]:
         return {
             "dependency_azure_mgmt_core": "azure-mgmt-core<2.0.0,>=1.3.0",
-            "dependency_azure_core": "azure-core<2.0.0,>=1.23.0",
-            "dependency_msrest": "msrest>=0.6.21",
+            "dependency_azure_core": "azure-core<2.0.0,>=1.24.0",
+            "dependency_msrest": "msrest>=0.7.0",
         }
 
     def _create_code_model(

package/autorest/codegen/models/client.py

@@ -7,7 +7,7 @@ from typing import Any, Dict, TYPE_CHECKING, TypeVar, Generic, Union
 
 from .base_model import BaseModel
 from .parameter_list import ClientGlobalParameterList, ConfigGlobalParameterList
-from .imports import FileImport, ImportType, TypingSection
+from .imports import FileImport, ImportType, TypingSection, MsrestImportType
 from .utils import add_to_pylint_disable
 
 ParameterListType = TypeVar(
@@ -89,10 +89,6 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
     def _imports_shared(self, async_mode: bool) -> FileImport:
         file_import = FileImport()
 
-        file_import.add_submodule_import("msrest", "Serializer", ImportType.THIRDPARTY)
-        file_import.add_submodule_import(
-            "msrest", "Deserializer", ImportType.THIRDPARTY
-        )
         file_import.add_submodule_import(
             "typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL
         )
@@ -113,6 +109,13 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
             ImportType.LOCAL,
         )
 
+        file_import.add_msrest_import(
+            self.code_model,
+            ".." if async_mode else ".",
+            MsrestImportType.SerializerDeserializer,
+            TypingSection.REGULAR,
+        )
+
         return file_import
 
     def imports(self, async_mode: bool) -> FileImport:

package/autorest/codegen/models/code_model.py

@@ -200,8 +200,15 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-publi
             name = f"_{name}"
         return name
 
+    @property
+    def has_abstract_operations(self) -> bool:
+        """Whether there is abstract operation in any operation group."""
+        return any(og.has_abstract_operations for og in self.operation_groups)
+
     def need_vendored_code(self, async_mode: bool) -> bool:
         """Whether we need to vendor code in the _vendor.py file for this SDK"""
+        if self.has_abstract_operations:
+            return True
         if async_mode:
             return self.need_mixin_abc
         return (
@@ -247,9 +254,7 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-publi
 
     def get_models_filename(self, is_python3_file: bool) -> str:
         """Get the names of the model file(s)"""
-        if (
-            self.options["version_tolerant"] or self.options["low_level_client"]
-        ) and self.options["python3_only"]:
+        if not self.is_legacy and self.options["python3_only"]:
             return "_models"
         if is_python3_file:
             return "_models_py3"
@@ -258,10 +263,16 @@ class CodeModel:  # pylint: disable=too-many-instance-attributes, too-many-publi
     @property
     def enums_filename(self) -> str:
         """The name of the enums file"""
-        if self.options["version_tolerant"] or self.options["low_level_client"]:
+        if not self.is_legacy:
             return "_enums"
         return f"_{self.module_name}_enums"
 
+    @property
+    def is_legacy(self) -> bool:
+        return not (
+            self.options["version_tolerant"] or self.options["low_level_client"]
+        )
+
     @property
     def rest_layer_name(self) -> str:
         """If we have a separate rest layer, what is its name?"""

package/autorest/codegen/models/imports.py

@@ -3,8 +3,11 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from enum import Enum
-from typing import Dict, List, Optional, Tuple, Union, Set, Mapping
+from enum import Enum, auto
+from typing import Dict, List, Optional, Tuple, Union, Set, Mapping, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .code_model import CodeModel
 
 
 class ImportType(str, Enum):
@@ -20,6 +23,16 @@ class TypingSection(str, Enum):
     TYPING = "typing"  # never a typing import
 
 
+class MsrestImportType(Enum):
+    Module = auto()  # import _serialization.py or msrest.serialization as Module
+    Serializer = (
+        auto()
+    )  # from _serialization.py or msrest.serialization import Serializer
+    SerializerDeserializer = (
+        auto()
+    )  # from _serialization.py or msrest.serialization import Serializer and Deserializer
+
+
 class ImportModel:
     def __init__(
         self,
@@ -190,3 +203,45 @@ class FileImport:
                 i.import_type, dict()
             ).setdefault(i.module_name, set()).add(name_import)
         return retval
+
+    def add_msrest_import(
+        self,
+        code_model: "CodeModel",
+        relative_path: str,
+        msrest_import_type: MsrestImportType,
+        typing_section: TypingSection,
+    ):
+        if code_model.options["client_side_validation"]:
+            if msrest_import_type == MsrestImportType.Module:
+                self.add_import(
+                    "msrest.serialization", ImportType.AZURECORE, typing_section
+                )
+            else:
+                self.add_submodule_import(
+                    "msrest", "Serializer", ImportType.THIRDPARTY, typing_section
+                )
+                if msrest_import_type == MsrestImportType.SerializerDeserializer:
+                    self.add_submodule_import(
+                        "msrest", "Deserializer", ImportType.THIRDPARTY, typing_section
+                    )
+        else:
+            if code_model.options["multiapi"]:
+                relative_path += "."
+            if msrest_import_type == MsrestImportType.Module:
+                self.add_submodule_import(
+                    relative_path, "_serialization", ImportType.LOCAL, typing_section
+                )
+            else:
+                self.add_submodule_import(
+                    f"{relative_path}_serialization",
+                    "Serializer",
+                    ImportType.LOCAL,
+                    typing_section,
+                )
+                if msrest_import_type == MsrestImportType.SerializerDeserializer:
+                    self.add_submodule_import(
+                        f"{relative_path}_serialization",
+                        "Deserializer",
+                        ImportType.LOCAL,
+                        typing_section,
+                    )

package/autorest/codegen/models/lro_operation.py

@@ -124,6 +124,8 @@ class LROOperationBase(OperationBase[LROResponseType]):
         self, async_mode: bool, is_python3_file: bool, **kwargs: Any
     ) -> FileImport:
         file_import = super().imports(async_mode, is_python3_file, **kwargs)
+        if self.abstract:
+            return file_import
         if async_mode:
             file_import.add_submodule_import(
                 f"azure.core.tracing.decorator_async",

package/autorest/codegen/models/operation.py

@@ -204,9 +204,8 @@ class OperationBase(  # pylint: disable=too-many-public-methods
         file_import.add_submodule_import(
             "typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL
         )
-        if not self.abstract:
-            for param in self.parameters.method:
-                file_import.merge(param.imports(async_mode, **kwargs))
+        for param in self.parameters.method:
+            file_import.merge(param.imports(async_mode, **kwargs))
 
         response_types = [
             r.type_annotation(async_mode=async_mode) for r in self.responses if r.type
@@ -218,6 +217,8 @@ class OperationBase(  # pylint: disable=too-many-public-methods
         return file_import
 
     def imports_for_multiapi(self, async_mode: bool, **kwargs: Any) -> FileImport:
+        if self.abstract:
+            return FileImport()
         file_import = self._imports_shared(async_mode, **kwargs)
         for response in self.responses:
             file_import.merge(
@@ -289,6 +290,8 @@ class OperationBase(  # pylint: disable=too-many-public-methods
     def imports(
         self, async_mode: bool, is_python3_file: bool, **kwargs: Any
     ) -> FileImport:
+        if self.abstract:
+            return FileImport()
         file_import = self._imports_shared(async_mode, **kwargs)
 
         for response in self.responses:
@@ -301,48 +304,45 @@ class OperationBase(  # pylint: disable=too-many-public-methods
             file_import.merge(self.parameters.body_parameter.type.imports(**kwargs))
 
         # Exceptions
-        if self.abstract:
-            file_import.add_import("abc", ImportType.STDLIB)
-        else:
-            file_import.add_submodule_import(
-                "azure.core.exceptions", "map_error", ImportType.AZURECORE
-            )
-            if self.code_model.options["azure_arm"]:
-                file_import.add_submodule_import(
-                    "azure.mgmt.core.exceptions", "ARMErrorFormat", ImportType.AZURECORE
-                )
-            file_import.add_submodule_import(
-                "azure.core.exceptions", "HttpResponseError", ImportType.AZURECORE
-            )
+        file_import.add_submodule_import(
+            "azure.core.exceptions", "map_error", ImportType.AZURECORE
+        )
+        if self.code_model.options["azure_arm"]:
             file_import.add_submodule_import(
-                "azure.core.exceptions",
-                "ClientAuthenticationError",
-                ImportType.AZURECORE,
+                "azure.mgmt.core.exceptions", "ARMErrorFormat", ImportType.AZURECORE
             )
+        file_import.add_submodule_import(
+            "azure.core.exceptions", "HttpResponseError", ImportType.AZURECORE
+        )
+        file_import.add_submodule_import(
+            "azure.core.exceptions",
+            "ClientAuthenticationError",
+            ImportType.AZURECORE,
+        )
+        file_import.add_submodule_import(
+            "azure.core.exceptions", "ResourceNotFoundError", ImportType.AZURECORE
+        )
+        file_import.add_submodule_import(
+            "azure.core.exceptions", "ResourceExistsError", ImportType.AZURECORE
+        )
+
+        kwargs_to_pop = self.parameters.kwargs_to_pop(is_python3_file)
+        if self.has_kwargs_to_pop_with_default(
+            kwargs_to_pop, ParameterLocation.HEADER
+        ) or self.has_kwargs_to_pop_with_default(
+            kwargs_to_pop, ParameterLocation.QUERY
+        ):
             file_import.add_submodule_import(
-                "azure.core.exceptions", "ResourceNotFoundError", ImportType.AZURECORE
+                "azure.core.utils", "case_insensitive_dict", ImportType.AZURECORE
             )
+        if self.deprecated:
+            file_import.add_import("warnings", ImportType.STDLIB)
+
+        if self.code_model.need_request_converter:
+            relative_path = "..." if async_mode else ".."
             file_import.add_submodule_import(
-                "azure.core.exceptions", "ResourceExistsError", ImportType.AZURECORE
+                f"{relative_path}_vendor", "_convert_request", ImportType.LOCAL
             )
-
-            kwargs_to_pop = self.parameters.kwargs_to_pop(is_python3_file)
-            if self.has_kwargs_to_pop_with_default(
-                kwargs_to_pop, ParameterLocation.HEADER
-            ) or self.has_kwargs_to_pop_with_default(
-                kwargs_to_pop, ParameterLocation.QUERY
-            ):
-                file_import.add_submodule_import(
-                    "azure.core.utils", "case_insensitive_dict", ImportType.AZURECORE
-                )
-            if self.deprecated:
-                file_import.add_import("warnings", ImportType.STDLIB)
-
-            if self.code_model.need_request_converter:
-                relative_path = "..." if async_mode else ".."
-                file_import.add_submodule_import(
-                    f"{relative_path}_vendor", "_convert_request", ImportType.LOCAL
-                )
         if async_mode:
             file_import.add_submodule_import(
                 "azure.core.pipeline.transport",
@@ -382,10 +382,9 @@ class OperationBase(  # pylint: disable=too-many-public-methods
                 f"distributed_trace",
                 ImportType.AZURECORE,
             )
-        if not self.abstract:
-            file_import.merge(
-                self.get_request_builder_import(self.request_builder, async_mode)
-            )
+        file_import.merge(
+            self.get_request_builder_import(self.request_builder, async_mode)
+        )
         if self.overloads:
             file_import.add_submodule_import("typing", "overload", ImportType.STDLIB)
         return file_import
@@ -473,14 +472,14 @@ class Operation(OperationBase[Response]):
         self, async_mode: bool, is_python3_file: bool, **kwargs: Any
     ) -> FileImport:
         file_import = super().imports(async_mode, is_python3_file, **kwargs)
+        if self.abstract:
+            return file_import
         if async_mode:
             file_import.add_submodule_import(
                 f"azure.core.tracing.decorator_async",
                 f"distributed_trace_async",
                 ImportType.AZURECORE,
             )
-        if self.abstract:
-            return file_import
         if (
             self.has_response_body
             and not self.has_optional_return_type

package/autorest/codegen/models/operation_group.py

@@ -42,8 +42,6 @@ class OperationGroup(BaseModel):
             base_classes.append("MixinABC")
         if not (async_mode or self.code_model.options["python3_only"]):
             base_classes.append("object")
-        if self.has_abstract_operations:
-            base_classes.append("abc.ABC")
         return ", ".join(base_classes)
 
     def imports_for_multiapi(self, async_mode: bool) -> FileImport:
@@ -89,6 +87,12 @@ class OperationGroup(BaseModel):
                 )
         if self.code_model.need_mixin_abc:
             file_import.add_submodule_import(".._vendor", "MixinABC", ImportType.LOCAL)
+        if self.has_abstract_operations:
+            file_import.add_submodule_import(
+                ".._vendor", "raise_if_not_implemented", ImportType.LOCAL
+            )
+        if all(o.abstract for o in self.operations):
+            return file_import
         file_import.add_submodule_import(
             "typing", "TypeVar", ImportType.STDLIB, TypingSection.CONDITIONAL
         )

package/autorest/codegen/models/paging_operation.py

@@ -130,6 +130,8 @@ class PagingOperationBase(OperationBase[PagingResponseType]):
     def imports(
         self, async_mode: bool, is_python3_file: bool, **kwargs: Any
     ) -> FileImport:
+        if self.abstract:
+            return FileImport()
         file_import = self._imports_shared(async_mode, **kwargs)
         file_import.merge(super().imports(async_mode, is_python3_file, **kwargs))
         if self.code_model.options["tracing"] and self.want_tracing:

package/autorest/codegen/models/request_builder.py

@@ -21,7 +21,7 @@ from .parameter_list import (
     RequestBuilderParameterList,
     OverloadedRequestBuilderParameterList,
 )
-from .imports import FileImport, ImportType, TypingSection
+from .imports import FileImport, ImportType, TypingSection, MsrestImportType
 from .request_builder_parameter import RequestBuilderMultipartBodyParameter
 
 if TYPE_CHECKING:
@@ -73,34 +73,45 @@ class RequestBuilderBase(BaseBuilder[ParameterListType]):
 
     def imports(self) -> FileImport:
         file_import = FileImport()
-        if not self.abstract:
-            for parameter in self.parameters.method:
-                file_import.merge(parameter.imports(async_mode=False))
+        if self.abstract:
+            return file_import
+        for parameter in self.parameters.method:
+            file_import.merge(parameter.imports(async_mode=False))
 
         file_import.add_submodule_import(
             "azure.core.rest",
             "HttpRequest",
             ImportType.AZURECORE,
         )
-        if not self.abstract:
-            if self.parameters.path:
-                relative_path = ".."
-                if (
-                    not self.code_model.options["builders_visibility"] == "embedded"
-                    and self.group_name
-                ):
-                    relative_path = "..." if self.group_name else ".."
-                file_import.add_submodule_import(
-                    f"{relative_path}_vendor", "_format_url_section", ImportType.LOCAL
-                )
-            if self.parameters.headers or self.parameters.query:
-                file_import.add_submodule_import(
-                    "azure.core.utils", "case_insensitive_dict", ImportType.AZURECORE
-                )
+
+        if self.parameters.path:
+            relative_path = ".."
+            if (
+                not self.code_model.options["builders_visibility"] == "embedded"
+                and self.group_name
+            ):
+                relative_path = "..." if self.group_name else ".."
+            file_import.add_submodule_import(
+                f"{relative_path}_vendor", "_format_url_section", ImportType.LOCAL
+            )
+        if self.parameters.headers or self.parameters.query:
+            file_import.add_submodule_import(
+                "azure.core.utils", "case_insensitive_dict", ImportType.AZURECORE
+            )
         file_import.add_submodule_import(
             "typing", "Any", ImportType.STDLIB, typing_section=TypingSection.CONDITIONAL
         )
-        file_import.add_submodule_import("msrest", "Serializer", ImportType.THIRDPARTY)
+        file_import.add_msrest_import(
+            self.code_model,
+            "..."
+            if (
+                not self.code_model.options["builders_visibility"] == "embedded"
+                and self.group_name
+            )
+            else "..",
+            MsrestImportType.Serializer,
+            TypingSection.REGULAR,
+        )
         if (
             self.overloads
             and self.code_model.options["builders_visibility"] != "embedded"

package/autorest/codegen/serializers/__init__.py

@@ -477,6 +477,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

@@ -598,8 +598,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(
@@ -1126,8 +1124,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]:

package/autorest/codegen/serializers/client_serializer.py

@@ -101,6 +101,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 (

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,
@@ -73,11 +74,11 @@ 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(
@@ -120,3 +121,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/model_base_serializer.py

@@ -7,7 +7,7 @@ from abc import abstractmethod
 from typing import cast, List
 from jinja2 import Environment
 from ..models import ModelType, CodeModel, Property
-from ..models.imports import FileImport, ImportType
+from ..models.imports import FileImport, TypingSection, MsrestImportType
 from .import_serializer import FileImportSerializer
 
 
@@ -49,7 +49,9 @@ class ModelBaseSerializer:
 
     def imports(self) -> FileImport:
         file_import = FileImport()
-        file_import.add_import("msrest.serialization", ImportType.AZURECORE)
+        file_import.add_msrest_import(
+            self.code_model, "..", MsrestImportType.Module, TypingSection.REGULAR
+        )
         for model in self.code_model.model_types:
             file_import.merge(model.imports(is_operation_file=False))
         return file_import
@@ -71,9 +73,12 @@ class ModelBaseSerializer:
             properties_to_initialize = model.properties
         return properties_to_initialize
 
-    @staticmethod
-    def declare_model(model: ModelType) -> str:
-        basename = "msrest.serialization.Model"
+    def declare_model(self, model: ModelType) -> str:
+        basename = (
+            "msrest.serialization.Model"
+            if self.code_model.options["client_side_validation"]
+            else "_serialization.Model"
+        )
         if model.parents:
             basename = ", ".join([cast(ModelType, m).name for m in model.parents])
         return f"class {model.name}({basename}):{model.pylint_disable}"

package/autorest/codegen/serializers/operation_groups_serializer.py

@@ -70,4 +70,7 @@ class OperationGroupsSerializer:
                 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/request_builders_serializer.py

@@ -46,7 +46,7 @@ class RequestBuildersSerializer:
 
         return template.render(
             code_model=self.code_model,
-            request_builders=self.request_builders,
+            request_builders=[rb for rb in self.request_builders if not rb.abstract],
             imports=FileImportSerializer(
                 self.imports,
                 is_python3_file=True,

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

@@ -11,6 +11,9 @@
 
     {{ op_tools.serialize_with_wrap(serializer.property_descriptions(async_mode), "\n ") | indent }}
     {{ serializer.init_signature_and_response_type_annotation(async_mode) | indent }}
+    {% 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) }}
     {% endif %}