Fix all rules with safe fix

Author: AdrienVannson

src/betterproto2_compiler/casing.py

@@ -22,20 +22,20 @@ def safe_snake_case(value: str) -> str:
 
 
 def snake_case(value: str, strict: bool = True) -> str:
-    """
-    Join words with an underscore into lowercase and remove symbols.
+    """Join words with an underscore into lowercase and remove symbols.
 
     Parameters
-    -----------
+    ----------
     value: :class:`str`
         The value to convert.
     strict: :class:`bool`
         Whether or not to force single underscores.
 
     Returns
-    --------
+    -------
     :class:`str`
         The value in snake_case.
+
     """
 
     def substitute_word(symbols: str, word: str, is_start: bool) -> str:
@@ -61,20 +61,20 @@ def substitute_word(symbols: str, word: str, is_start: bool) -> str:
 
 
 def pascal_case(value: str, strict: bool = True) -> str:
-    """
-    Capitalize each word and remove symbols.
+    """Capitalize each word and remove symbols.
 
     Parameters
-    -----------
+    ----------
     value: :class:`str`
         The value to convert.
     strict: :class:`bool`
         Whether or not to output only alphanumeric characters.
 
     Returns
-    --------
+    -------
     :class:`str`
         The value in PascalCase.
+
     """
 
     def substitute_word(symbols, word):
@@ -96,27 +96,26 @@ def substitute_word(symbols, word):
 
 
 def camel_case(value: str, strict: bool = True) -> str:
-    """
-    Capitalize all words except first and remove symbols.
+    """Capitalize all words except first and remove symbols.
 
     Parameters
-    -----------
+    ----------
     value: :class:`str`
         The value to convert.
     strict: :class:`bool`
         Whether or not to output only alphanumeric characters.
 
     Returns
-    --------
+    -------
     :class:`str`
         The value in camelCase.
+
     """
     return lowercase_first(pascal_case(value, strict=strict))
 
 
 def lowercase_first(value: str) -> str:
-    """
-    Lower cases the first character of the value.
+    """Lower cases the first character of the value.
 
     Parameters
     ----------
@@ -127,6 +126,7 @@ def lowercase_first(value: str) -> str:
     -------
     :class:`str`
         The lower cased string.
+
     """
     return value[0:1].lower() + value[1:]
 

src/betterproto2_compiler/compile/importing.py

@@ -27,8 +27,7 @@
 
 
 def parse_source_type_name(field_type_name: str, request: PluginRequestCompiler) -> tuple[str, str]:
-    """
-    Split full source type name into package and type name.
+    """Split full source type name into package and type name.
     E.g. 'root.package.Message' -> ('root.package', 'Message')
          'root.Message.SomeEnum' -> ('root', 'Message.SomeEnum')
 
@@ -76,8 +75,7 @@ def get_type_reference(
     unwrap: bool = True,
     pydantic: bool = False,
 ) -> str:
-    """
-    Return a Python type name for a proto type reference. Adds the import if
+    """Return a Python type name for a proto type reference. Adds the import if
     necessary. Unwraps well known type if required.
     """
     if unwrap:
@@ -88,7 +86,7 @@ def get_type_reference(
         if source_type == ".google.protobuf.Duration":
             return "datetime.timedelta"
 
-        elif source_type == ".google.protobuf.Timestamp":
+        if source_type == ".google.protobuf.Timestamp":
             return "datetime.datetime"
 
     source_package, source_type = parse_source_type_name(source_type, request)
@@ -118,25 +116,20 @@ def get_type_reference(
 
 
 def reference_absolute(imports: set[str], py_package: list[str], py_type: str) -> str:
-    """
-    Returns a reference to a python type located in the root, i.e. sys.path.
-    """
+    """Returns a reference to a python type located in the root, i.e. sys.path."""
     string_import = ".".join(py_package)
     string_alias = safe_snake_case(string_import)
     imports.add(f"import {string_import} as {string_alias}")
     return f"{string_alias}.{py_type}"
 
 
 def reference_sibling(py_type: str) -> str:
-    """
-    Returns a reference to a python type within the same package as the current package.
-    """
+    """Returns a reference to a python type within the same package as the current package."""
     return f"{py_type}"
 
 
 def reference_descendent(current_package: list[str], imports: set[str], py_package: list[str], py_type: str) -> str:
-    """
-    Returns a reference to a python type in a package that is a descendent of the
+    """Returns a reference to a python type in a package that is a descendent of the
     current package, and adds the required import that is aliased to avoid name
     conflicts.
     """
@@ -147,14 +140,12 @@ def reference_descendent(current_package: list[str], imports: set[str], py_packa
         string_alias = "_".join(importing_descendent)
         imports.add(f"from .{string_from} import {string_import} as {string_alias}")
         return f"{string_alias}.{py_type}"
-    else:
-        imports.add(f"from . import {string_import}")
-        return f"{string_import}.{py_type}"
+    imports.add(f"from . import {string_import}")
+    return f"{string_import}.{py_type}"
 
 
 def reference_ancestor(current_package: list[str], imports: set[str], py_package: list[str], py_type: str) -> str:
-    """
-    Returns a reference to a python type in a package which is an ancestor to the
+    """Returns a reference to a python type in a package which is an ancestor to the
     current package, and adds the required import that is aliased (if possible) to avoid
     name conflicts.
 
@@ -167,15 +158,13 @@ def reference_ancestor(current_package: list[str], imports: set[str], py_package
         string_from = f"..{'.' * distance_up}"
         imports.add(f"from {string_from} import {string_import} as {string_alias}")
         return f"{string_alias}.{py_type}"
-    else:
-        string_alias = f"{'_' * distance_up}{py_type}__"
-        imports.add(f"from .{'.' * distance_up} import {py_type} as {string_alias}")
-        return string_alias
+    string_alias = f"{'_' * distance_up}{py_type}__"
+    imports.add(f"from .{'.' * distance_up} import {py_type} as {string_alias}")
+    return string_alias
 
 
 def reference_cousin(current_package: list[str], imports: set[str], py_package: list[str], py_type: str) -> str:
-    """
-    Returns a reference to a python type in a package that is not descendent, ancestor
+    """Returns a reference to a python type in a package that is not descendent, ancestor
     or sibling, and adds the required import that is aliased to avoid name conflicts.
     """
     shared_ancestry = os.path.commonprefix([current_package, py_package])  # type: ignore

src/betterproto2_compiler/enum.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from collections.abc import Iterator
 from enum import (
     EnumMeta,
     IntEnum,
@@ -37,7 +38,7 @@ def __new__(mcs, name: str, bases: tuple[type, ...], namespace: dict[str, Any])
         new_mcs = type(
             f"{name}Type",
             tuple(
-                dict.fromkeys([base.__class__ for base in bases if base.__class__ is not type] + [EnumType, type])
+                dict.fromkeys([base.__class__ for base in bases if base.__class__ is not type] + [EnumType, type]),
             ),  # reorder the bases so EnumType and type are last to avoid conflicts
             {"_value_map_": value_map, "_member_map_": member_map},
         )
@@ -73,7 +74,7 @@ def __call__(cls, value: int) -> Enum:
             except (KeyError, TypeError):
                 raise ValueError(f"{value!r} is not a valid {cls.__name__}") from None
 
-        def __iter__(cls) -> Generator[Enum, None, None]:
+        def __iter__(cls) -> Iterator[Enum]:
             yield from cls._member_map_.values()
 
         def __reversed__(cls) -> Generator[Enum, None, None]:
@@ -103,8 +104,7 @@ def __contains__(cls, member: object) -> bool:
 
 
 class Enum(IntEnum if TYPE_CHECKING else int, metaclass=EnumType):
-    """
-    The base class for protobuf enumerations, all generated enumerations will
+    """The base class for protobuf enumerations, all generated enumerations will
     inherit from this. Emulates `enum.IntEnum`.
     """
 
@@ -142,7 +142,7 @@ def try_value(cls, value: int = 0) -> Self:
         """Return the value which corresponds to the value.
 
         Parameters
-        -----------
+        ----------
         value: :class:`int`
             The value of the enum member to get.
 
@@ -151,6 +151,7 @@ def try_value(cls, value: int = 0) -> Self:
         :class:`Enum`
             The corresponding member or a new instance of the enum if
             ``value`` isn't actually a member.
+
         """
         try:
             return cls._value_map_[value]
@@ -162,14 +163,15 @@ def from_string(cls, name: str) -> Self:
         """Return the value which corresponds to the string name.
 
         Parameters
-        -----------
+        ----------
         name: :class:`str`
             The name of the enum member to get.
 
         Raises
-        -------
+        ------
         :exc:`ValueError`
             The member was not found in the Enum.
+
         """
         try:
             return cls._member_map_[name]

src/betterproto2_compiler/plugin/compiler.py

@@ -14,7 +14,7 @@
         "Please ensure that you've installed betterproto as "
         '`pip install "betterproto[compiler]"` so that compiler dependencies '
         "are included."
-        "\033[0m"
+        "\033[0m",
     )
     raise SystemExit(1)
 

src/betterproto2_compiler/plugin/main.py

@@ -38,8 +38,7 @@ def main() -> None:
 
 
 def dump_request(dump_file: str, request: CodeGeneratorRequest) -> None:
-    """
-    For developers: Supports running plugin.py standalone so its possible to debug it.
+    """For developers: Supports running plugin.py standalone so its possible to debug it.
     Run protoc (or generate.py) with BETTERPROTO_DUMP="yourfile.bin" to write the request to a file.
     Then run plugin.py from your IDE in debugging mode, and redirect stdin to the file.
     """

src/betterproto2_compiler/plugin/models.py

@@ -188,10 +188,7 @@ def __post_init__(self) -> None:
                 raise ValueError(f"`{field_name}` is a required field.")
 
     def ready(self) -> None:
-        """
-        This function is called after all the compilers are created, but before generating the output code.
-        """
-        pass
+        """This function is called after all the compilers are created, but before generating the output code."""
 
     @property
     def output_file(self) -> "OutputTemplate":
@@ -229,6 +226,7 @@ def all_messages(self) -> list["MessageCompiler"]:
         -------
         List[MessageCompiler]
             List of all of the messages in this request.
+
         """
         return [msg for output in self.output_packages.values() for msg in output.messages.values()]
 
@@ -261,6 +259,7 @@ def package(self) -> str:
         -------
         str
             Name of input package.
+
         """
         return self.package_proto_obj.package
 
@@ -272,6 +271,7 @@ def input_filenames(self) -> Iterable[str]:
         -------
         Iterable[str]
             Names of the input files used to build this output.
+
         """
         return sorted(f.name for f in self.input_files)
 
@@ -345,8 +345,7 @@ def is_map(proto_field_obj: FieldDescriptorProto, parent_message: DescriptorProt
 
 
 def is_oneof(proto_field_obj: FieldDescriptorProto) -> bool:
-    """
-    True if proto_field_obj is a OneOf, otherwise False.
+    """True if proto_field_obj is a OneOf, otherwise False.
 
     .. warning::
         TODO update comment
@@ -358,7 +357,6 @@ def is_oneof(proto_field_obj: FieldDescriptorProto) -> bool:
         essentially making oneof_index the sole member of a one_of group, which allows
         us to tell whether it was set, via the which_one_of interface.
     """
-
     return not proto_field_obj.proto3_optional and proto_field_obj.oneof_index is not None
 
 
@@ -420,7 +418,8 @@ def field_wraps(self) -> str | None:
     @property
     def repeated(self) -> bool:
         return self.proto_obj.label == FieldDescriptorProtoLabel.LABEL_REPEATED and not is_map(
-            self.proto_obj, self.parent
+            self.proto_obj,
+            self.parent,
         )
 
     @property
@@ -452,15 +451,15 @@ def py_type(self) -> str:
         """String representation of Python type."""
         if self.proto_obj.type in PROTO_FLOAT_TYPES:
             return "float"
-        elif self.proto_obj.type in PROTO_INT_TYPES:
+        if self.proto_obj.type in PROTO_INT_TYPES:
             return "int"
-        elif self.proto_obj.type in PROTO_BOOL_TYPES:
+        if self.proto_obj.type in PROTO_BOOL_TYPES:
             return "bool"
-        elif self.proto_obj.type in PROTO_STR_TYPES:
+        if self.proto_obj.type in PROTO_STR_TYPES:
             return "str"
-        elif self.proto_obj.type in PROTO_BYTES_TYPES:
+        if self.proto_obj.type in PROTO_BYTES_TYPES:
             return "bytes"
-        elif self.proto_obj.type in PROTO_MESSAGE_TYPES:
+        if self.proto_obj.type in PROTO_MESSAGE_TYPES:
             # Type referencing another defined Message or a named enum
             return get_type_reference(
                 package=self.output_file.package,
@@ -470,8 +469,7 @@ def py_type(self) -> str:
                 request=self.request,
                 pydantic=self.output_file.pydantic_dataclasses,
             )
-        else:
-            raise NotImplementedError(f"Unknown type {self.proto_obj.type}")
+        raise NotImplementedError(f"Unknown type {self.proto_obj.type}")
 
     @property
     def annotation(self) -> str:
@@ -643,6 +641,7 @@ def py_input_message_type(self) -> str:
         -------
         str
             String representation of the Python type corresponding to the input message.
+
         """
         return get_type_reference(
             package=self.output_file.package,
@@ -670,6 +669,7 @@ def py_input_message_param(self) -> str:
         -------
         str
             Param name corresponding to py_input_message_type.
+
         """
         return pythonize_field_name(self.py_input_message_type)
 
@@ -682,6 +682,7 @@ def py_output_message_type(self) -> str:
         -------
         str
             String representation of the Python type corresponding to the output message.
+
         """
         return get_type_reference(
             package=self.output_file.package,