@autorest/python 6.2.6 → 6.2.8

package/autorest/black/__init__.py

@@ -8,13 +8,14 @@ from pathlib import Path
 import os
 from typing import Any, Dict
 import black
+from black.report import NothingChanged
 
 from .. import Plugin, PluginAutorest
 from .._utils import parse_args
 
 logging.getLogger("blib2to3").setLevel(logging.ERROR)
 
-_BLACK_MODE = black.Mode()
+_BLACK_MODE = black.Mode()  # pyright: ignore [reportPrivateImportUsage]
 _BLACK_MODE.line_length = 120
 
 
@@ -42,7 +43,7 @@ class BlackScriptPlugin(Plugin):  # pylint: disable=abstract-method
             file_content = black.format_file_contents(
                 file_content, fast=True, mode=_BLACK_MODE
             )
-        except black.NothingChanged:
+        except NothingChanged:
             pass
         self.write_file(file, file_content)
 

package/autorest/codegen/__init__.py

@@ -293,7 +293,7 @@ class CodeGeneratorAutorest(CodeGenerator, PluginAutorest):
         # Parse the received YAML
         return yaml.safe_load(file_content)
 
-    def get_serializer(self, code_model: CodeModel):  # type: ignore
+    def get_serializer(self, code_model: CodeModel):
         return JinjaSerializerAutorest(
             self._autorestapi,
             code_model,

package/autorest/codegen/models/base.py

@@ -32,7 +32,7 @@ class BaseModel:
         return f"<{self.__class__.__name__}>"
 
 
-class BaseType(BaseModel, ABC):
+class BaseType(BaseModel, ABC):  # pylint: disable=too-many-public-methods
     """This is the base class for all types.
 
     :param yaml_data: the yaml data for this schema
@@ -60,6 +60,14 @@ class BaseType(BaseModel, ABC):
     def imports_for_multiapi(self, **kwargs: Any) -> FileImport:
         return self.imports(**kwargs)
 
+    @staticmethod
+    def imports_for_sample() -> FileImport:
+        return FileImport()
+
+    @staticmethod
+    def serialize_sample_value(value: Any) -> str:
+        return repr(value)
+
     @property
     def xml_metadata(self) -> Dict[str, Any]:
         """XML metadata for the type, if the type has it."""

package/autorest/codegen/models/client.py

@@ -86,7 +86,7 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
                     client=self,
                 )
                 if request_builder.overloads:
-                    request_builders.extend(request_builder.overloads)  # type: ignore
+                    request_builders.extend(request_builder.overloads)
                 request_builders.append(request_builder)
                 if operation_yaml.get("nextOperation"):
                     # i am a paging operation and i have a next operation.
@@ -176,7 +176,9 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
         for gp in self.parameters:
             if gp.method_location == ParameterMethodLocation.KWARG:
                 continue
-            file_import.merge(gp.imports(async_mode))
+            file_import.merge(
+                gp.imports(async_mode, relative_path=".." if async_mode else ".")
+            )
         file_import.add_submodule_import(
             "._configuration",
             f"{self.name}Configuration",

package/autorest/codegen/models/operation.py

@@ -160,10 +160,10 @@ class OperationBase(  # pylint: disable=too-many-public-methods
             isinstance(r.type, ModelType) for r in self.responses
         ):
             r = next(r for r in self.responses if isinstance(r.type, ModelType))
-            type_name = getattr(r, "item_type", getattr(r, "type")).docstring_text(
-                **kwargs
-            )
-            retval += f". The {type_name} is compatible with MutableMapping"
+            item_type = getattr(r, "item_type", getattr(r, "type"))
+            if item_type:
+                type_name = item_type.docstring_text(**kwargs)
+                retval += f". The {type_name} is compatible with MutableMapping"
         return retval
 
     def response_docstring_type(self, **kwargs) -> str:
@@ -344,9 +344,9 @@ class OperationBase(  # pylint: disable=too-many-public-methods
             )
 
         if self.has_kwargs_to_pop_with_default(
-            self.parameters.kwargs_to_pop, ParameterLocation.HEADER
+            self.parameters.kwargs_to_pop, ParameterLocation.HEADER  # type: ignore
         ) or self.has_kwargs_to_pop_with_default(
-            self.parameters.kwargs_to_pop, ParameterLocation.QUERY
+            self.parameters.kwargs_to_pop, ParameterLocation.QUERY  # type: ignore
         ):
             file_import.add_submodule_import(
                 "azure.core.utils", "case_insensitive_dict", ImportType.AZURECORE

package/autorest/codegen/models/operation_group.py

@@ -68,12 +68,6 @@ class OperationGroup(BaseModel):
             retval = add_to_pylint_disable(retval, "abstract-class-instantiated")
         return retval
 
-    @property
-    def mypy_ignore(self) -> str:
-        if self.has_abstract_operations:
-            return "  # type: ignore"
-        return ""
-
     @property
     def need_validation(self) -> bool:
         """Whether any of its operations need validation"""

package/autorest/codegen/models/primitive_types.py

@@ -384,6 +384,16 @@ class DatetimeType(PrimitiveType):
     def instance_check_template(self) -> str:
         return "isinstance({}, datetime.datetime)"
 
+    @staticmethod
+    def imports_for_sample() -> FileImport:
+        file_import = super(DatetimeType, DatetimeType).imports_for_sample()
+        file_import.add_import("isodate", ImportType.STDLIB)
+        return file_import
+
+    @staticmethod
+    def serialize_sample_value(value: Any) -> str:
+        return f"isodate.parse_datetime({repr(value)})"
+
 
 class TimeType(PrimitiveType):
     @property
@@ -418,6 +428,16 @@ class TimeType(PrimitiveType):
     def instance_check_template(self) -> str:
         return "isinstance({}, datetime.time)"
 
+    @staticmethod
+    def imports_for_sample() -> FileImport:
+        file_import = super(TimeType, TimeType).imports_for_sample()
+        file_import.add_import("isodate", ImportType.STDLIB)
+        return file_import
+
+    @staticmethod
+    def serialize_sample_value(value: Any) -> str:
+        return f"isodate.parse_time({repr(value)})"
+
 
 class UnixTimeType(PrimitiveType):
     @property
@@ -452,6 +472,16 @@ class UnixTimeType(PrimitiveType):
     def instance_check_template(self) -> str:
         return "isinstance({}, datetime.time)"
 
+    @staticmethod
+    def imports_for_sample() -> FileImport:
+        file_import = super(UnixTimeType, UnixTimeType).imports_for_sample()
+        file_import.add_import("datetime", ImportType.STDLIB)
+        return file_import
+
+    @staticmethod
+    def serialize_sample_value(value: Any) -> str:
+        return f"datetime.datetime.fromtimestamp({repr(value)}, datetime.timezone.utc)"
+
 
 class DateType(PrimitiveType):
     @property
@@ -486,6 +516,16 @@ class DateType(PrimitiveType):
     def instance_check_template(self) -> str:
         return "isinstance({}, datetime.date)"
 
+    @staticmethod
+    def imports_for_sample() -> FileImport:
+        file_import = super(DateType, DateType).imports_for_sample()
+        file_import.add_import("isodate", ImportType.STDLIB)
+        return file_import
+
+    @staticmethod
+    def serialize_sample_value(value: Any) -> str:
+        return f"isodate.parse_date({repr(value)})"
+
 
 class DurationType(PrimitiveType):
     @property
@@ -520,6 +560,16 @@ class DurationType(PrimitiveType):
     def instance_check_template(self) -> str:
         return "isinstance({}, datetime.timedelta)"
 
+    @staticmethod
+    def imports_for_sample() -> FileImport:
+        file_import = super(DurationType, DurationType).imports_for_sample()
+        file_import.add_import("isodate", ImportType.STDLIB)
+        return file_import
+
+    @staticmethod
+    def serialize_sample_value(value: Any) -> str:
+        return f"isodate.parse_duration({repr(value)})"
+
 
 class ByteArraySchema(PrimitiveType):
     def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:

package/autorest/codegen/serializers/__init__.py

@@ -4,7 +4,7 @@
 # license information.
 # --------------------------------------------------------------------------
 import logging
-from typing import List, Optional, Any, Union, cast
+from typing import List, Optional, Any, Union
 from pathlib import Path
 from jinja2 import PackageLoader, Environment, FileSystemLoader, StrictUndefined
 
@@ -28,6 +28,7 @@ from .request_builders_serializer import RequestBuildersSerializer
 from .patch_serializer import PatchSerializer
 from .sample_serializer import SampleSerializer
 from ..._utils import to_snake_case
+from .utils import extract_sample_name
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -141,7 +142,7 @@ class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
         namespace_path = (
             Path(".")
             if self.code_model.options["no_namespace_folders"]
-            else Path(*(self.code_model.namespace.split(".")))
+            else Path(*self._name_space().split("."))
         )
 
         p = namespace_path.parent
@@ -190,7 +191,7 @@ class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
             if self.read_file(namespace_path / Path("models.py")):
                 self.write_file(
                     namespace_path / Path("models.py"),
-                    cast(str, self.read_file(namespace_path / Path("models.py"))),
+                    self.read_file(namespace_path / Path("models.py")),
                 )
 
     def _serialize_and_write_package_files(self, namespace_path: Path) -> None:
@@ -531,9 +532,17 @@ class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
             namespace_path / Path("_metadata.json"), metadata_serializer.serialize()
         )
 
+    def _name_space(self) -> str:
+        if self.code_model.namespace.count(".") >= (
+            self.code_model.options["package_name"] or ""
+        ).count("-"):
+            return self.code_model.namespace
+
+        return self.code_model.options["package_name"].replace("-", ".")
+
     # find root folder where "setup.py" is
     def _package_root_folder(self, namespace_path: Path) -> Path:
-        return namespace_path / Path("../" * (self.code_model.namespace.count(".") + 1))
+        return namespace_path / Path("../" * (self._name_space().count(".") + 1))
 
     def _serialize_and_write_sample(self, env: Environment, namespace_path: Path):
         out_path = self._package_root_folder(namespace_path) / Path("generated_samples")
@@ -543,8 +552,9 @@ class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
                     samples = operation.yaml_data["samples"]
                     if not samples or operation.name.startswith("_"):
                         continue
-                    for key, value in samples.items():
-                        file_name = to_snake_case(key) + ".py"
+                    for value in samples.values():
+                        file = value.get("x-ms-original-file", "sample.json")
+                        file_name = to_snake_case(extract_sample_name(file)) + ".py"
                         try:
                             self.write_file(
                                 out_path / file_name,
@@ -555,12 +565,11 @@ class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
                                     operation=operation,
                                     sample=value,
                                     file_name=file_name,
-                                    sample_origin_name=key,
                                 ).serialize(),
                             )
                         except Exception as e:  # pylint: disable=broad-except
                             # sample generation shall not block code generation, so just log error
-                            log_error = f"error happens in sample {key}: {e}"
+                            log_error = f"error happens in sample {file}: {e}"
                             _LOGGER.error(log_error)
 
 

package/autorest/codegen/serializers/builder_serializer.py

@@ -583,8 +583,10 @@ class _OperationSerializer(
         return retval
 
     def make_pipeline_call(self, builder: OperationType) -> List[str]:
+        type_ignore = self.async_mode and builder.group_name == ""  # is in a mixin
         return [
-            f"pipeline_response = {self._call_method}self._client._pipeline.run(  # type: ignore # pylint: disable=protected-access",
+            f"pipeline_response: PipelineResponse = {self._call_method}self._client._pipeline.run(  "
+            + f"{'# type: ignore' if type_ignore else ''} # pylint: disable=protected-access",
             "    request,",
             f"    stream={builder.has_stream_response},",
             "    **kwargs",
@@ -627,24 +629,22 @@ class _OperationSerializer(
             check_kwarg_dict=True,
             pop_headers_kwarg=PopKwargType.CASE_INSENSITIVE
             if builder.has_kwargs_to_pop_with_default(
-                kwargs_to_pop, ParameterLocation.HEADER
+                kwargs_to_pop, ParameterLocation.HEADER  # type: ignore
             )
             else PopKwargType.SIMPLE,
             pop_params_kwarg=PopKwargType.CASE_INSENSITIVE
             if builder.has_kwargs_to_pop_with_default(
-                kwargs_to_pop, ParameterLocation.QUERY
+                kwargs_to_pop, ParameterLocation.QUERY  # type: ignore
             )
             else PopKwargType.SIMPLE,
             check_client_input=not self.code_model.options["multiapi"],
         )
-        kwargs.append(
-            f"cls = kwargs.pop('cls', None)  {self.cls_type_annotation(builder)}"
-        )
+        cls_annotation = builder.cls_type_annotation(async_mode=self.async_mode)
+        kwargs.append(f"cls: {cls_annotation} = kwargs.pop('cls', None)")
+        if any(x.startswith("_") for x in cls_annotation.split(".")):
+            kwargs[-1] += " # pylint: disable=protected-access"
         return kwargs
 
-    def cls_type_annotation(self, builder: OperationType) -> str:
-        return f"# type: {builder.cls_type_annotation(async_mode=self.async_mode)}"
-
     def response_docstring(self, builder: OperationType) -> List[str]:
         response_str = (
             f":return: {builder.response_docstring_text(async_mode=self.async_mode)}"
@@ -847,8 +847,18 @@ class _OperationSerializer(
                 # in paging operations with a single swagger operation defintion,
                 # we skip passing query params when building the next request
                 continue
+            type_ignore = (
+                parameter.grouped_by
+                and parameter.client_default_value is not None
+                and next(
+                    p
+                    for p in builder.parameters
+                    if p.grouper and p.client_name == parameter.grouped_by
+                ).optional
+            )
             retval.append(
                 f"    {parameter.client_name}={parameter.name_in_high_level_operation},"
+                f"{'  # type: ignore' if type_ignore else ''}"
             )
         if request_builder.overloads:
             seen_body_params = set()
@@ -896,7 +906,7 @@ class _OperationSerializer(
         if self.code_model.options["version_tolerant"] and template_url:
             url_to_format = template_url
         retval.append(
-            "request.url = self._client.format_url({}{})  # type: ignore".format(
+            "request.url = self._client.format_url({}{})".format(
                 url_to_format,
                 ", **path_format_arguments" if builder.parameters.path else "",
             )
@@ -1044,20 +1054,41 @@ class _OperationSerializer(
                     self.response_headers_and_deserialization(builder.responses[0])
                 )
                 retval.append("")
+        type_ignore = (
+            builder.has_response_body
+            and not builder.has_optional_return_type
+            and not (
+                self.code_model.options["models_mode"] == "msrest"
+                and any(not resp.is_stream_response for resp in builder.responses)
+            )
+        )
         if builder.has_optional_return_type or self.code_model.options["models_mode"]:
             deserialized = "deserialized"
         else:
             deserialized = f"cast({builder.response_type_annotation(async_mode=self.async_mode)}, deserialized)"
+            type_ignore = False
+        if (
+            not builder.has_optional_return_type
+            and len(builder.responses) > 1
+            and any(resp.is_stream_response or resp.type for resp in builder.responses)
+        ):
+            type_ignore = True
         retval.append("if cls:")
         retval.append(
-            "    return cls(pipeline_response, {}, {})".format(
+            "    return cls(pipeline_response, {}, {}){}".format(
                 deserialized if builder.has_response_body else "None",
                 "response_headers" if builder.any_response_has_headers else "{}",
+                " # type: ignore" if type_ignore else "",
             )
         )
-        if builder.has_response_body:
+        if builder.has_response_body and any(
+            response.is_stream_response or response.type
+            for response in builder.responses
+        ):
             retval.append("")
-            retval.append(f"return {deserialized}")
+            retval.append(
+                f"return {deserialized}{' # type: ignore' if type_ignore else ''}"
+            )
         if (
             builder.request_builder.method == "HEAD"
             and self.code_model.options["head_as_boolean"]
@@ -1131,7 +1162,7 @@ class _OperationSerializer(
     @staticmethod
     def get_metadata_url(builder: OperationType) -> str:
         url = _escape_str(builder.request_builder.url)
-        return f"{builder.name}.metadata = {{'url': { url }}}  # type: ignore"
+        return f"{builder.name}.metadata = {{'url': { url }}}"
 
     @property
     def _call_method(self) -> str:
@@ -1280,7 +1311,7 @@ class _PagingOperationSerializer(
         )
         retval.append(f"    list_of_elem = deserialized{list_of_elem}")
         retval.append("    if cls:")
-        retval.append("        list_of_elem = cls(list_of_elem)")
+        retval.append("        list_of_elem = cls(list_of_elem) # type: ignore")
 
         continuation_token_name = builder.continuation_token_name
         if not continuation_token_name:
@@ -1364,19 +1395,19 @@ class _LROOperationSerializer(_OperationSerializer[LROOperationType]):
 
     def initial_call(self, builder: LROOperationType) -> List[str]:
         retval = [
-            "polling = kwargs.pop('polling', True)  # type: Union[bool, "
-            f"{builder.get_base_polling_method(self.async_mode)}]"
+            f"polling: Union[bool, {builder.get_base_polling_method(self.async_mode)}] = kwargs.pop('polling', True)",
         ]
         retval.append("lro_delay = kwargs.pop(")
         retval.append("    'polling_interval',")
         retval.append("    self._config.polling_interval")
         retval.append(")")
         retval.append(
-            "cont_token = kwargs.pop('continuation_token', None)  # type: Optional[str]"
+            "cont_token: Optional[str] = kwargs.pop('continuation_token', None)"
         )
         retval.append("if cont_token is None:")
         retval.append(
-            f"    raw_result = {self._call_method}self.{builder.initial_operation.name}(  # type: ignore"
+            f"    raw_result = {self._call_method}self.{builder.initial_operation.name}("
+            f"{''  if builder.lro_response and builder.lro_response.type else '  # type: ignore'}"
         )
         retval.extend(
             [
@@ -1409,13 +1440,14 @@ class _LROOperationSerializer(_OperationSerializer[LROOperationType]):
         retval.extend(
             [
                 "if polling is True:",
-                f"    polling_method = cast({builder.get_base_polling_method(self.async_mode)}, "
+                f"    polling_method: {builder.get_base_polling_method(self.async_mode)} "
+                + f"= cast({builder.get_base_polling_method(self.async_mode)}, "
                 f"{builder.get_polling_method(self.async_mode)}(",
                 "        lro_delay,",
                 f"        {lro_options_str}",
                 f"        {path_format_arguments_str}",
                 "        **kwargs",
-                f"))  # type: {builder.get_base_polling_method(self.async_mode)}",
+                f"))",
             ]
         )
         retval.append(
@@ -1434,7 +1466,7 @@ class _LROOperationSerializer(_OperationSerializer[LROOperationType]):
         retval.append("    )")
         retval.append(
             f"return {builder.get_poller(self.async_mode)}"
-            "(self._client, raw_result, get_long_running_output, polling_method)"
+            "(self._client, raw_result, get_long_running_output, polling_method)  # type: ignore"
         )
         return retval
 
@@ -1462,13 +1494,18 @@ class _LROOperationSerializer(_OperationSerializer[LROOperationType]):
             )
         retval.append("    if cls:")
         retval.append(
-            "        return cls(pipeline_response, {}, {})".format(
+            "        return cls(pipeline_response, {}, {}){}".format(
                 "deserialized"
                 if builder.lro_response and builder.lro_response.type
                 else "None",
                 "response_headers"
                 if builder.lro_response and builder.lro_response.headers
                 else "{}",
+                " # type: ignore"
+                if builder.lro_response
+                and builder.lro_response.type
+                and not self.code_model.options["models_mode"]
+                else "",
             )
         )
         if builder.lro_response and builder.lro_response.type:
@@ -1507,7 +1544,7 @@ class LROPagingOperationSerializer(
         retval.append("    )")
         return retval
 
-    def decorators(self, builder: LROPagingOperation) -> List[str]:  # type: ignore
+    def decorators(self, builder: LROPagingOperation) -> List[str]:
         """Decorators for the method"""
         return _LROOperationSerializer.decorators(self, builder)  # type: ignore
 

package/autorest/codegen/serializers/client_serializer.py

@@ -120,7 +120,7 @@ class ClientSerializer:
         def _get_client_models_value(models_dict_name: str) -> str:
             if self.client.code_model.model_types:
                 return f"{{k: v for k, v in {models_dict_name}.__dict__.items() if isinstance(v, type)}}"
-            return "{}  # type: Dict[str, Any]"
+            return "{}"
 
         is_msrest_model = self.client.code_model.options["models_mode"] == "msrest"
         if is_msrest_model:
@@ -133,7 +133,8 @@ class ClientSerializer:
                 else "_models"
             )
             retval.append(
-                f"client_models = {_get_client_models_value(model_dict_name)}"
+                f"client_models{': Dict[str, Any]' if not self.client.code_model.model_types else ''}"
+                f" = {_get_client_models_value(model_dict_name)}"
             )
             if add_private_models and self.client.code_model.model_types:
                 update_dict = f"{{k: v for k, v in _models.__dict__.items() if isinstance(v, type)}}"
@@ -149,7 +150,7 @@ class ClientSerializer:
         for og in operation_groups:
             retval.extend(
                 [
-                    f"self.{og.property_name} = {og.class_name}({og.mypy_ignore}{og.pylint_disable}",
+                    f"self.{og.property_name} = {og.class_name}({og.pylint_disable}",
                     "    self._client, self._config, self._serialize, self._deserialize",
                     ")",
                 ]

package/autorest/codegen/serializers/metadata_serializer.py

@@ -58,7 +58,13 @@ def _json_serialize_imports(
                 name_import_ordered_list = []
                 if name_imports:
                     name_import_ordered_list = list(name_imports)
-                    name_import_ordered_list.sort()
+                    name_import_ordered_list.sort(
+                        key=lambda e: "".join(e)  # type: ignore
+                        if isinstance(e, (list, tuple))
+                        else e
+                        if isinstance(e, str)
+                        else ""
+                    )
                 json_package_name_dictionary[package_name] = name_import_ordered_list
             json_import_type_dictionary[import_type_key] = json_package_name_dictionary
         json_serialize_imports[typing_section_key] = json_import_type_dictionary

package/autorest/codegen/serializers/model_serializer.py

@@ -3,7 +3,7 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import cast, List
+from typing import List, cast
 from abc import ABC, abstractmethod
 
 from jinja2 import Environment
@@ -77,7 +77,7 @@ class _ModelSerializer(ABC):
             typing = "Optional[str]"
         else:
             typing = "str"
-        return f"self.{prop.client_name} = {discriminator_value}  # type: {typing}"
+        return f"self.{prop.client_name}: {typing}  = {discriminator_value}"
 
     @staticmethod
     def initialize_standard_property(prop: Property):
@@ -152,7 +152,7 @@ class MsrestModelSerializer(_ModelSerializer):
             else "_serialization.Model"
         )
         if model.parents:
-            basename = ", ".join([cast(ModelType, m).name for m in model.parents])
+            basename = ", ".join([m.name for m in model.parents])
         return f"class {model.name}({basename}):{model.pylint_disable}"
 
     @staticmethod
@@ -163,9 +163,7 @@ class MsrestModelSerializer(_ModelSerializer):
                     p.client_name: p
                     for bm in model.parents
                     for p in model.properties
-                    if p not in cast(ModelType, bm).properties
-                    or p.is_discriminator
-                    or p.constant
+                    if p not in bm.properties or p.is_discriminator or p.constant
                 }.values()
             )
         else:
@@ -223,7 +221,7 @@ class DpgModelSerializer(_ModelSerializer):
     def declare_model(self, model: ModelType) -> str:
         basename = "_model_base.Model"
         if model.parents:
-            basename = ", ".join([cast(ModelType, m).name for m in model.parents])
+            basename = ", ".join([m.name for m in model.parents])
         if model.discriminator_value:
             basename += f", discriminator='{model.discriminator_value}'"
         return f"class {model.name}({basename}):{model.pylint_disable}"
@@ -231,9 +229,7 @@ class DpgModelSerializer(_ModelSerializer):
     @staticmethod
     def get_properties_to_declare(model: ModelType) -> List[Property]:
         if model.parents:
-            parent_properties = [
-                p for bm in model.parents for p in cast(ModelType, bm).properties
-            ]
+            parent_properties = [p for bm in model.parents for p in bm.properties]
             properties_to_declare = [
                 p
                 for p in model.properties
@@ -274,7 +270,7 @@ class DpgModelSerializer(_ModelSerializer):
         for prop in self.get_properties_to_declare(model):
             if prop.constant or prop.is_discriminator:
                 init_args.append(
-                    f"self.{prop.client_name} = {cast(ConstantType, prop.type).get_declaration()}   "
-                    f"# type: {prop.type_annotation()}"
+                    f"self.{prop.client_name}: {prop.type_annotation()} = "
+                    f"{cast(ConstantType, prop.type).get_declaration()}"
                 )
         return init_args

package/autorest/codegen/serializers/operation_groups_serializer.py

@@ -64,6 +64,7 @@ class OperationGroupsSerializer:
         template = self.env.get_or_select_template(
             "operation_groups_container.py.jinja2"
         )
+
         return template.render(
             code_model=self.code_model,
             operation_groups=operation_groups,

package/autorest/codegen/serializers/parameter_serializer.py

@@ -145,13 +145,13 @@ class ParameterSerializer:
                         f"_{kwarg_dict}.pop('{kwarg.rest_api_name}', {default_value})"
                     )
                 retval.append(
-                    f"{kwarg.client_name} = kwargs.pop('{kwarg.client_name}', "
-                    + f"{default_value})  # type: {kwarg.type_annotation()}"
+                    f"{kwarg.client_name}: {kwarg.type_annotation()} = kwargs.pop('{kwarg.client_name}', "
+                    + f"{default_value})"
                 )
             else:
                 type_annot = kwarg.type_annotation()
                 retval.append(
-                    f"{kwarg.client_name} = kwargs.pop('{kwarg.client_name}')  # type: {type_annot}"
+                    f"{kwarg.client_name}: {type_annot} = kwargs.pop('{kwarg.client_name}')"
                 )
         return retval
 

package/autorest/codegen/serializers/patch_serializer.py

@@ -5,7 +5,7 @@
 # --------------------------------------------------------------------------
 from jinja2 import Environment
 from .import_serializer import FileImportSerializer
-from ..models import CodeModel, FileImport, ImportType, TypingSection
+from ..models import CodeModel, FileImport, ImportType
 
 
 class PatchSerializer:
@@ -16,9 +16,7 @@ class PatchSerializer:
     def serialize(self) -> str:
         template = self.env.get_template("patch.py.jinja2")
         imports = FileImport()
-        imports.add_submodule_import(
-            "typing", "List", ImportType.STDLIB, TypingSection.CONDITIONAL
-        )
+        imports.add_submodule_import("typing", "List", ImportType.STDLIB)
         return template.render(
             code_model=self.code_model,
             imports=FileImportSerializer(imports),