@azure-tools/typespec-python 0.28.0 → 0.30.0

package/generator/pygen/codegen/models/operation.py

@@ -418,8 +418,19 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
         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)
-        if self.non_default_errors and self.code_model.options["models_mode"] == "dpg":
-            file_import.add_submodule_import(f"{relative_path}_model_base", "_deserialize", ImportType.LOCAL)
+        if self.code_model.options["models_mode"] == "dpg":
+            if self.parameters.has_body:
+                if self.has_form_data_body:
+                    file_import.add_submodule_import(relative_path, "_model_base", ImportType.LOCAL)
+                else:
+                    file_import.add_submodule_import(
+                        f"{relative_path}_model_base",
+                        "SdkJSONEncoder",
+                        ImportType.LOCAL,
+                    )
+                    file_import.add_import("json", ImportType.STDLIB)
+            if (self.default_error_deserialization or any(r.type for r in self.responses)) or self.non_default_errors:
+                file_import.add_submodule_import(f"{relative_path}_model_base", "_deserialize", ImportType.LOCAL)
         return file_import
 
     def get_response_from_status(self, status_code: Optional[Union[str, int]]) -> ResponseType:
@@ -492,20 +503,6 @@ class Operation(OperationBase[Response]):
             )
         if self.has_response_body and not self.has_optional_return_type and not self.code_model.options["models_mode"]:
             file_import.add_submodule_import("typing", "cast", ImportType.STDLIB)
-        relative_path = "..." if async_mode else ".."
-        if self.code_model.options["models_mode"] == "dpg":
-            if self.parameters.has_body:
-                if self.has_form_data_body:
-                    file_import.add_submodule_import(relative_path, "_model_base", ImportType.LOCAL)
-                else:
-                    file_import.add_submodule_import(
-                        f"{relative_path}_model_base",
-                        "SdkJSONEncoder",
-                        ImportType.LOCAL,
-                    )
-                    file_import.add_import("json", ImportType.STDLIB)
-            if self.default_error_deserialization or any(r.type for r in self.responses):
-                file_import.add_submodule_import(f"{relative_path}_model_base", "_deserialize", ImportType.LOCAL)
 
         return file_import
 

package/generator/pygen/codegen/models/paging_operation.py

@@ -1,4 +1,3 @@
-# pylint: disable=multiple-statements
 # -------------------------------------------------------------------------
 # Copyright (c) Microsoft Corporation. All rights reserved.
 # Licensed under the MIT License. See License.txt in the project root for

package/generator/pygen/codegen/models/parameter_list.py

@@ -261,8 +261,7 @@ class _ParameterListBase(
         )
 
 
-class _ParameterList(_ParameterListBase[Parameter, BodyParameter]):  # pylint: disable=unsubscriptable-object
-    """Base Parameter class for the two operation ParameterLists"""
+class _ParameterList(_ParameterListBase[Parameter, BodyParameter]):
 
     @staticmethod
     def parameter_creator() -> Callable[[Dict[str, Any], "CodeModel"], Parameter]:
@@ -285,9 +284,7 @@ class ParameterList(_ParameterList):
     """ParameterList is the parameter list for Operation classes"""
 
 
-class _RequestBuilderParameterList(
-    _ParameterListBase[RequestBuilderParameter, RequestBuilderBodyParameter]  # pylint: disable=unsubscriptable-object
-):
+class _RequestBuilderParameterList(_ParameterListBase[RequestBuilderParameter, RequestBuilderBodyParameter]):
     """_RequestBuilderParameterList is base parameter list for RequestBuilder classes"""
 
     @staticmethod

package/generator/pygen/codegen/models/primitive_types.py

@@ -22,8 +22,8 @@ class RawString(object):
         return "r'{}'".format(self.string.replace("'", "\\'"))
 
 
-class PrimitiveType(BaseType):  # pylint: disable=abstract-method
-    def description(self, *, is_operation_file: bool) -> str:  # pylint: disable=unused-argument
+class PrimitiveType(BaseType):
+    def description(self, *, is_operation_file: bool) -> str:
         return ""
 
     def type_annotation(self, **kwargs: Any) -> str:
@@ -188,7 +188,7 @@ class AnyObjectType(PrimitiveType):
         return "JSON"
 
 
-class NumberType(PrimitiveType):  # pylint: disable=abstract-method
+class NumberType(PrimitiveType):
     def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
         super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.precision: Optional[int] = yaml_data.get("precision")
@@ -233,6 +233,12 @@ class NumberType(PrimitiveType):  # pylint: disable=abstract-method
 
 
 class IntegerType(NumberType):
+
+    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
+        super().__init__(yaml_data=yaml_data, code_model=code_model)
+        if yaml_data.get("encode") == "string":
+            self.encode = "str"
+
     @property
     def serialization_type(self) -> str:
         return "int"
@@ -624,3 +630,29 @@ class SdkCoreType(PrimitiveType):
     @property
     def serialization_type(self) -> str:
         return self.name
+
+
+class MultiPartFileType(PrimitiveType):
+    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
+        super().__init__(yaml_data=yaml_data, code_model=code_model)
+        self.name = "FileType"
+
+    def type_annotation(self, **kwargs: Any) -> str:
+        return self.name
+
+    def docstring_type(self, **kwargs: Any) -> str:
+        return f"~{self.code_model.namespace}._vendor.{self.name}"
+
+    def imports(self, **kwargs: Any) -> FileImport:
+        file_import = super().imports(**kwargs)
+        relative_path = "..." if kwargs.get("async_mode") else ".."
+        file_import.add_submodule_import(f"{relative_path}_vendor", self.name, ImportType.LOCAL)
+        return file_import
+
+    @property
+    def default_template_representation_declaration(self) -> str:
+        return '"filetype"' if self.code_model.for_test else "filetype"
+
+    @property
+    def instance_check_template(self) -> str:
+        return f"isinstance({{}}, {self.name})"

package/generator/pygen/codegen/models/property.py

@@ -97,12 +97,9 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
         return self.is_discriminator and self.is_polymorphic and cast(ConstantType, self.type).value is None
 
     def type_annotation(self, *, is_operation_file: bool = False) -> str:
-        types_type_annotation = self.type.type_annotation(is_operation_file=is_operation_file)
-        if self.is_multipart_file_input:
-            # we only support FileType or list of FileType
-            types_type_annotation = types_type_annotation.replace("bytes", "FileType")
         if self.is_base_discriminator:
             return "str"
+        types_type_annotation = self.type.type_annotation(is_operation_file=is_operation_file)
         if self.optional and self.client_default_value is None:
             return f"Optional[{types_type_annotation}]"
         return types_type_annotation
@@ -115,9 +112,6 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
         *,
         client_default_value_declaration: Optional[str] = None,
     ) -> Any:
-        if self.is_multipart_file_input:
-            file_type_str = '"filetype"' if self.code_model.for_test else "filetype"
-            return f"[{file_type_str}]" if self.type.type == "list" else file_type_str
         if self.client_default_value:
             client_default_value_declaration = self.get_declaration(self.client_default_value)
         # make sure there is no \n otherwise the json template will be invalid
@@ -156,8 +150,6 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
                 "rest_discriminator" if self.is_discriminator else "rest_field",
                 ImportType.LOCAL,
             )
-        if self.is_multipart_file_input:
-            file_import.add_submodule_import(".._vendor", "FileType", ImportType.LOCAL)
         return file_import
 
     @classmethod

package/generator/pygen/codegen/serializers/__init__.py

@@ -66,7 +66,7 @@ def _sample_output_path(source_file_path: str) -> Path:
     return Path("")
 
 
-class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
+class JinjaSerializer(ReaderAndWriter):
     def __init__(
         self,
         code_model: CodeModel,

package/generator/pygen/codegen/serializers/builder_serializer.py

@@ -1,4 +1,4 @@
-# pylint: disable=too-many-lines,multiple-statements
+# pylint: disable=too-many-lines
 # -------------------------------------------------------------------------
 # Copyright (c) Microsoft Corporation. All rights reserved.
 # Licensed under the MIT License. See License.txt in the project root for
@@ -23,7 +23,6 @@ from ..models import (
     BinaryType,
     BodyParameter,
     ParameterMethodLocation,
-    RequestBuilderBodyParameter,
     OverloadedRequestBuilder,
     Property,
     RequestBuilderType,
@@ -218,7 +217,7 @@ def is_json_model_type(parameters: ParameterListType) -> bool:
     )
 
 
-class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-method
+class _BuilderBaseSerializer(Generic[BuilderType]):
     def __init__(self, code_model: CodeModel, async_mode: bool) -> None:
         self.code_model = code_model
         self.async_mode = async_mode
@@ -391,7 +390,7 @@ class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-
 ############################## REQUEST BUILDERS ##############################
 
 
-class RequestBuilderSerializer(_BuilderBaseSerializer[RequestBuilderType]):  # pylint: disable=abstract-method
+class RequestBuilderSerializer(_BuilderBaseSerializer[RequestBuilderType]):
     def description_and_summary(self, builder: RequestBuilderType) -> List[str]:
         retval = super().description_and_summary(builder)
         retval += [
@@ -517,7 +516,7 @@ class RequestBuilderSerializer(_BuilderBaseSerializer[RequestBuilderType]):  # p
 ############################## NORMAL OPERATIONS ##############################
 
 
-class _OperationSerializer(_BuilderBaseSerializer[OperationType]):  # pylint: disable=abstract-method
+class _OperationSerializer(_BuilderBaseSerializer[OperationType]):
     def description_and_summary(self, builder: OperationType) -> List[str]:
         retval = super().description_and_summary(builder)
         if builder.deprecated:
@@ -535,9 +534,9 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):  # pylint: di
         return "response"
 
     def example_template(self, builder: OperationType) -> List[str]:
+        if self.code_model.options["models_mode"] in ("msrest", "dpg"):
+            return []
         retval = super().example_template(builder)
-        if self.code_model.options["models_mode"] == "msrest":
-            return retval
         for response in builder.responses:
             polymorphic_subtypes: List[ModelType] = []
             if not response.type:
@@ -842,14 +841,14 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):  # pylint: di
         elif request_builder.overloads:
             seen_body_params = set()
             for overload in request_builder.overloads:
-                body_param = cast(RequestBuilderBodyParameter, overload.parameters.body_parameter)
+                body_param = 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},")
         elif request_builder.parameters.has_body:
-            body_param = cast(RequestBuilderBodyParameter, request_builder.parameters.body_parameter)
+            body_param = request_builder.parameters.body_parameter
             retval.append(f"    {body_param.client_name}={body_param.name_in_high_level_operation},")
         retval.append("    headers=_headers,")
         retval.append("    params=_params,")
@@ -871,7 +870,7 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):  # pylint: di
         )
         return retval
 
-    def _call_request_builder_helper(  # pylint: disable=too-many-statements
+    def _call_request_builder_helper(
         self,
         builder: OperationType,
         request_builder: RequestBuilderType,
@@ -1031,7 +1030,7 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):  # pylint: di
             retval.append("deserialized = None")
         if builder.any_response_has_headers:
             retval.append("response_headers = {}")
-        if builder.has_response_body or builder.any_response_has_headers:
+        if builder.has_response_body or builder.any_response_has_headers:  # pylint: disable=too-many-nested-blocks
             if len(builder.responses) > 1:
                 status_codes, res_headers, res_deserialization = [], [], []
                 for status_code in builder.success_status_codes:
@@ -1173,7 +1172,7 @@ class OperationSerializer(_OperationSerializer[Operation]): ...
 PagingOperationType = TypeVar("PagingOperationType", bound=Union[PagingOperation, LROPagingOperation])
 
 
-class _PagingOperationSerializer(_OperationSerializer[PagingOperationType]):  # pylint: disable=abstract-method
+class _PagingOperationSerializer(_OperationSerializer[PagingOperationType]):
     def __init__(self, code_model: CodeModel, async_mode: bool) -> None:
         # for pylint reasons need to redefine init
         # probably because inheritance is going too deep
@@ -1458,7 +1457,7 @@ class LROOperationSerializer(_LROOperationSerializer[LROOperation]): ...
 class LROPagingOperationSerializer(
     _LROOperationSerializer[LROPagingOperation],
     _PagingOperationSerializer[LROPagingOperation],
-):  # pylint: disable=abstract-method
+):
     @property
     def _call_method(self) -> str:
         return "await " if self.async_mode else ""

package/generator/pygen/codegen/serializers/general_serializer.py

@@ -124,7 +124,6 @@ class GeneralSerializer(BaseSerializer):
             file_import.add_submodule_import("typing", "Union", ImportType.STDLIB)
             file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB)
             file_import.add_submodule_import("typing", "Mapping", ImportType.STDLIB)
-            file_import.add_submodule_import("typing", "Sequence", ImportType.STDLIB)
             file_import.add_submodule_import("typing", "Dict", ImportType.STDLIB)
             file_import.add_submodule_import("typing", "Any", ImportType.STDLIB)
             file_import.add_submodule_import("typing", "List", ImportType.STDLIB)
@@ -183,12 +182,13 @@ class GeneralSerializer(BaseSerializer):
     def serialize_cross_language_definition_file(self) -> str:
         cross_langauge_def_dict = {
             f"{self.code_model.namespace}.models.{model.name}": model.cross_language_definition_id
-            for model in self.code_model.model_types
+            for model in self.code_model.public_model_types
         }
         cross_langauge_def_dict.update(
             {
                 f"{self.code_model.namespace}.models.{enum.name}": enum.cross_language_definition_id
                 for enum in self.code_model.enums
+                if not enum.internal
             }
         )
         cross_langauge_def_dict.update(

package/generator/pygen/codegen/serializers/model_serializer.py

@@ -194,6 +194,8 @@ class DpgModelSerializer(_ModelSerializer):
         )
 
         for model in self.code_model.model_types:
+            if model.base == "json":
+                continue
             file_import.merge(model.imports(is_operation_file=False))
             for prop in model.properties:
                 file_import.merge(prop.imports())

package/generator/pygen/codegen/serializers/sample_serializer.py

@@ -1,4 +1,3 @@
-# pylint: disable=too-many-lines
 # -------------------------------------------------------------------------
 # Copyright (c) Microsoft Corporation. All rights reserved.
 # Licensed under the MIT License. See License.txt in the project root for
@@ -22,7 +21,6 @@ from ..models import (
     FileImport,
 )
 from .utils import get_namespace_config, get_namespace_from_package_name
-from ...utils import to_snake_case
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -42,7 +40,7 @@ class SampleSerializer(BaseSerializer):
         self.operation = operation
         self.sample = sample
         self.file_name = file_name
-        self.sample_params = {to_snake_case(k): v for k, v in sample.get("parameters", {}).items()}
+        self.sample_params = sample.get("parameters", {})
 
     def _imports(self) -> FileImportSerializer:
         imports = FileImport(self.code_model)
@@ -66,8 +64,8 @@ class SampleSerializer(BaseSerializer):
                 "AzureKeyCredential",
                 ImportType.SDKCORE,
             )
-        for param in self.operation.parameters.positional:
-            if not param.client_default_value and not param.optional and param.client_name in self.sample_params:
+        for param in self.operation.parameters.positional + self.operation.parameters.keyword_only:
+            if not param.client_default_value and not param.optional and param.wire_name in self.sample_params:
                 imports.merge(param.type.imports_for_sample())
         return FileImportSerializer(imports, True)
 
@@ -80,15 +78,19 @@ class SampleSerializer(BaseSerializer):
         elif isinstance(credential_type, KeyCredentialType):
             special_param.update({"credential": 'AzureKeyCredential(key=os.getenv("AZURE_KEY"))'})
 
-        params_positional = [
-            p for p in self.code_model.clients[0].parameters.positional if not (p.optional or p.client_default_value)
+        params = [
+            p
+            for p in (
+                self.code_model.clients[0].parameters.positional + self.code_model.clients[0].parameters.keyword_only
+            )
+            if not (p.optional or p.client_default_value)
         ]
         client_params = {
             p.client_name: special_param.get(
                 p.client_name,
-                f'"{self.sample_params.get(p.client_name) or p.client_name.upper()}"',
+                f'"{self.sample_params.get(p.wire_name) or p.client_name.upper()}"',
             )
-            for p in params_positional
+            for p in params
         }
 
         return client_params
@@ -103,15 +105,18 @@ class SampleSerializer(BaseSerializer):
 
     # prepare operation parameters
     def _operation_params(self) -> Dict[str, Any]:
-        params_positional = [p for p in self.operation.parameters.positional if not p.client_default_value]
+        params = [
+            p
+            for p in (self.operation.parameters.positional + self.operation.parameters.keyword_only)
+            if not p.client_default_value
+        ]
         failure_info = "fail to find required param named {}"
         operation_params = {}
-        for param in params_positional:
-            name = param.client_name
-            param_value = self.sample_params.get(name)
+        for param in params:
             if not param.optional:
+                param_value = self.sample_params.get(param.wire_name)
                 if not param_value:
-                    raise Exception(failure_info.format(name))  # pylint: disable=broad-exception-raised
+                    raise Exception(failure_info.format(param.client_name))  # pylint: disable=broad-exception-raised
                 operation_params[param.client_name] = self.handle_param(param, param_value)
         return operation_params
 
@@ -145,7 +150,7 @@ class SampleSerializer(BaseSerializer):
         name = self.sample.get("x-ms-original-file", "")
         if "specification" in name:
             return "specification" + name.split("specification")[-1]
-        return ""
+        return name if self.code_model.options["from_typespec"] else ""
 
     def serialize(self) -> str:
         operation_result, return_var = self._operation_result()

package/generator/pygen/codegen/templates/model_base.py.jinja2

@@ -454,6 +454,10 @@ def _serialize(o, format: typing.Optional[str] = None):  # pylint: disable=too-m
         return float(o)
     if isinstance(o, enum.Enum):
         return o.value
+    if isinstance(o, int):
+        if format == "str":
+            return str(o)
+        return o
     try:
         # First try datetime.datetime
         return _serialize_datetime(o, format)
@@ -489,6 +493,9 @@ def _create_value(rf: typing.Optional["_RestField"], value: typing.Any) -> typin
 
 class Model(_MyMutableMapping):
     _is_model = True
+    # label whether current class's _attr_to_rest_field has been calculated
+    # could not see _attr_to_rest_field directly because subclass inherits it from parent class
+    _calculated: typing.Set[str] = set()
 
     def __init__(self, *args: typing.Any, **kwargs: typing.Any) -> None:
         class_name = self.__class__.__name__
@@ -521,24 +528,27 @@ class Model(_MyMutableMapping):
         return Model(self.__dict__)
 
     def __new__(cls, *args: typing.Any, **kwargs: typing.Any) -> Self:  # pylint: disable=unused-argument
-        # we know the last three classes in mro are going to be 'Model', 'dict', and 'object'
-        mros = cls.__mro__[:-3][::-1]  # ignore model, dict, and object parents, and reverse the mro order
-        attr_to_rest_field: typing.Dict[str, _RestField] = {  # map attribute name to rest_field property
-            k: v for mro_class in mros for k, v in mro_class.__dict__.items() if k[0] != "_" and hasattr(v, "_type")
-        }
-        annotations = {
-            k: v
-            for mro_class in mros
-            if hasattr(mro_class, "__annotations__")  # pylint: disable=no-member
-            for k, v in mro_class.__annotations__.items()  # pylint: disable=no-member
-        }
-        for attr, rf in attr_to_rest_field.items():
-            rf._module = cls.__module__
-            if not rf._type:
-                rf._type = rf._get_deserialize_callable_from_annotation(annotations.get(attr, None))
-            if not rf._rest_name_input:
-                rf._rest_name_input = attr
-        cls._attr_to_rest_field: typing.Dict[str, _RestField] = dict(attr_to_rest_field.items())
+        if f"{cls.__module__}.{cls.__qualname__}" not in cls._calculated:
+            # we know the last nine classes in mro are going to be 'Model', '_MyMutableMapping', 'MutableMapping', 
+            # 'Mapping', 'Collection', 'Sized', 'Iterable', 'Container' and 'object'
+            mros = cls.__mro__[:-9][::-1]  # ignore parents, and reverse the mro order
+            attr_to_rest_field: typing.Dict[str, _RestField] = {  # map attribute name to rest_field property
+                k: v for mro_class in mros for k, v in mro_class.__dict__.items() if k[0] != "_" and hasattr(v, "_type")
+            }
+            annotations = {
+                k: v
+                for mro_class in mros
+                if hasattr(mro_class, "__annotations__")  # pylint: disable=no-member
+                for k, v in mro_class.__annotations__.items()  # pylint: disable=no-member
+            }
+            for attr, rf in attr_to_rest_field.items():
+                rf._module = cls.__module__
+                if not rf._type:
+                    rf._type = rf._get_deserialize_callable_from_annotation(annotations.get(attr, None))
+                if not rf._rest_name_input:
+                    rf._rest_name_input = attr
+            cls._attr_to_rest_field: typing.Dict[str, _RestField] = dict(attr_to_rest_field.items())
+            cls._calculated.add(f"{cls.__module__}.{cls.__qualname__}")
 
         return super().__new__(cls)  # pylint: disable=no-value-for-parameter
 
@@ -669,6 +679,8 @@ def _get_deserialize_callable_from_annotation(  # pylint: disable=R0911, R0915,
     rf: typing.Optional["_RestField"] = None,
 ) -> typing.Optional[typing.Callable[[typing.Any], typing.Any]]:
     if not annotation or annotation in [int, float]:
+        if annotation is int and rf and rf._format == "str":
+            return int
         return None
 
     # is it a type alias?

package/generator/pygen/codegen/templates/vendor.py.jinja2

@@ -70,8 +70,6 @@ FileType = Union[
     Tuple[Optional[str], FileContent, Optional[str]],
 ]
 
-FilesType = Union[Mapping[str, FileType], Sequence[Tuple[str, FileType]]]
-
 def serialize_multipart_data_entry(data_entry: Any) -> Any:
     if isinstance(data_entry, (list, tuple, dict, Model)):
         return json.dumps(data_entry, cls=SdkJSONEncoder, exclude_readonly=True)

package/generator/pygen/m2r.py

@@ -27,7 +27,7 @@ class GeneratorRenderer(m2r2.RestRenderer):
         return f":code:`{html}`"
 
 
-class M2R(YamlUpdatePlugin):  # pylint: disable=abstract-method
+class M2R(YamlUpdatePlugin):
     """A plugin to convert any description and summary from MD to RST."""
 
     def update_yaml(self, yaml_data: Dict[str, Any]) -> None:

package/generator/pygen/postprocess/__init__.py

@@ -3,7 +3,7 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import Tuple, Any, Dict
+from typing import Tuple, Any
 from pathlib import Path
 import os
 import shutil
@@ -28,7 +28,7 @@ def format_file(file: Path, file_content: str) -> str:
     return file_content
 
 
-class PostProcessPlugin(Plugin):  # pylint: disable=abstract-method
+class PostProcessPlugin(Plugin):
     def __init__(self, **kwargs: Any):
         super().__init__(**kwargs)
         output_folder_uri = self.options["outputFolderUri"]

package/generator/pygen/postprocess/venvtools.py

@@ -52,9 +52,7 @@ def create(
     return builder.context
 
 
-def python_run(  # pylint: disable=inconsistent-return-statements
-    venv_context, module, command, directory=_ROOT_DIR
-) -> Optional[str]:
+def python_run(venv_context, module, command, directory=_ROOT_DIR) -> Optional[str]:
     try:
         cmd_line = [
             venv_context.env_exe,

package/generator/pygen/preprocess/__init__.py

@@ -163,7 +163,7 @@ def has_multi_part_content_type(yaml_data: Dict[str, Any]) -> bool:
     return any(ct for ct in yaml_data.get("contentTypes", []) if ct == "multipart/form-data")
 
 
-class PreProcessPlugin(YamlUpdatePlugin):  # pylint: disable=abstract-method
+class PreProcessPlugin(YamlUpdatePlugin):
     """Add Python naming information."""
 
     @property

package/generator/pygen/utils.py

@@ -82,9 +82,7 @@ def parse_args(
         return value
 
     unknown_args_ret = {
-        ua.strip("--").split("=", maxsplit=1)[0]: _get_value(  # pylint: disable=bad-str-strip-call
-            ua.strip("--").split("=", maxsplit=1)[1]  # pylint: disable=bad-str-strip-call
-        )
+        ua.strip("--").split("=", maxsplit=1)[0]: _get_value(ua.strip("--").split("=", maxsplit=1)[1])
         for ua in unknown_args
     }
     return args, unknown_args_ret

package/generator/setup.py

@@ -15,7 +15,7 @@ from setuptools import setup, find_packages
 
 # Version extraction inspired from 'requests'
 with open(os.path.join("pygen", "_version.py"), "r") as fd:
-    version = re.search(r'^VERSION\s*=\s*[\'"]([^\'"]*)[\'"]', fd.read(), re.MULTILINE).group(1)
+    version = re.search(r'^VERSION\s*=\s*[\'"]([^\'"]*)[\'"]', fd.read(), re.MULTILINE).group(1)  # type: ignore
 
 if not version:
     raise RuntimeError("Cannot find version information")