Update

Author: vrslev

src/community_of_python_flake8_plugin/checks/dataclass_config.py

@@ -3,6 +3,7 @@
 import typing
 
 from community_of_python_flake8_plugin.constants import FINAL_CLASS_EXCLUDED_BASES
+from community_of_python_flake8_plugin.utils import check_inherits_from_bases
 from community_of_python_flake8_plugin.violation_codes import ViolationCodes
 from community_of_python_flake8_plugin.violations import Violation
 
@@ -23,33 +24,23 @@ def has_required_dataclass_params(decorator: ast.expr) -> bool:
     if not isinstance(decorator, ast.Call):
         return False
 
-    # Check if all required parameters are present
+    keywords: typing.Final = {kw.arg: kw.value for kw in decorator.keywords if isinstance(kw.value, ast.Constant)}
+    kw_only_param: typing.Final = keywords.get("kw_only")
+    slots_param: typing.Final = keywords.get("slots")
+    frozen_param: typing.Final = keywords.get("frozen")
     return (
-        any(
-            keyword.arg == "kw_only" and isinstance(keyword.value, ast.Constant) and keyword.value.value is True
-            for keyword in decorator.keywords
-        )
-        and any(
-            keyword.arg == "slots" and isinstance(keyword.value, ast.Constant) and keyword.value.value is True
-            for keyword in decorator.keywords
-        )
-        and any(
-            keyword.arg == "frozen" and isinstance(keyword.value, ast.Constant) and keyword.value.value is True
-            for keyword in decorator.keywords
-        )
+        kw_only_param is not None
+        and isinstance(kw_only_param, ast.Constant)
+        and kw_only_param.value is True
+        and slots_param is not None
+        and isinstance(slots_param, ast.Constant)
+        and slots_param.value is True
+        and frozen_param is not None
+        and isinstance(frozen_param, ast.Constant)
+        and frozen_param.value is True
     )
 
 
-def is_inherited_from_whitelisted_class(class_node: ast.ClassDef) -> bool:
-    """Check if class inherits from whitelisted base classes."""
-    for base_class in class_node.bases:
-        if isinstance(base_class, ast.Name) and base_class.id in FINAL_CLASS_EXCLUDED_BASES:
-            return True
-        if isinstance(base_class, ast.Attribute) and base_class.attr in FINAL_CLASS_EXCLUDED_BASES:
-            return True
-    return False
-
-
 def is_pydantic_model(class_node: ast.ClassDef) -> bool:
     """Check if class inherits from Pydantic BaseModel or RootModel."""
     for base_class in class_node.bases:
@@ -78,7 +69,7 @@ def __init__(self, syntax_tree: ast.AST) -> None:  # noqa: ARG002
     def visit_ClassDef(self, ast_node: ast.ClassDef) -> None:
         # Skip whitelisted classes and classes that inherit from Exception or other special classes
         if (
-            is_inherited_from_whitelisted_class(ast_node)
+            check_inherits_from_bases(ast_node, FINAL_CLASS_EXCLUDED_BASES)
             or is_pydantic_model(ast_node)
             or is_model_factory(ast_node)
             or self._inherits_from_exception(ast_node)
@@ -104,8 +95,8 @@ def visit_ClassDef(self, ast_node: ast.ClassDef) -> None:
     def _inherits_from_exception(self, ast_node: ast.ClassDef) -> bool:
         """Check if class inherits from Exception or its subclasses."""
         for base in ast_node.bases:
-            if (isinstance(base, ast.Name) and ("Error" in base.id or "Exception" in base.id)) or (
-                isinstance(base, ast.Attribute) and ("Error" in base.attr or "Exception" in base.attr)
-            ):
+            if isinstance(base, ast.Name) and ("Error" in base.id or "Exception" in base.id):
                 return True
-        return len(ast_node.bases) > 0  # Skip all classes that inherit from anything
+            if isinstance(base, ast.Attribute) and ("Error" in base.attr or "Exception" in base.attr):
+                return True
+        return False

src/community_of_python_flake8_plugin/checks/function_verb.py

@@ -3,7 +3,7 @@
 import typing
 
 from community_of_python_flake8_plugin.constants import FINAL_CLASS_EXCLUDED_BASES, VERB_PREFIXES
-from community_of_python_flake8_plugin.utils import find_parent_class_definition
+from community_of_python_flake8_plugin.utils import check_inherits_from_bases, find_parent_class_definition
 from community_of_python_flake8_plugin.violation_codes import ViolationCodes
 from community_of_python_flake8_plugin.violations import Violation
 
@@ -50,32 +50,26 @@ def check_is_fixture_decorator(decorator: ast.expr) -> bool:
     return False
 
 
-def retrieve_parent_class(syntax_tree: ast.AST, ast_node: ast.AST) -> ast.ClassDef | None:
-    return find_parent_class_definition(syntax_tree, ast_node)
-
-
 @typing.final
 class FunctionVerbCheck(ast.NodeVisitor):
     def __init__(self, syntax_tree: ast.AST) -> None:
         self.violations: list[Violation] = []
         self.syntax_tree: typing.Final[ast.AST] = syntax_tree
 
     def visit_FunctionDef(self, ast_node: ast.FunctionDef) -> None:
-        parent_class: typing.Final = retrieve_parent_class(self.syntax_tree, ast_node)  # noqa: COP011
-        self.validate_function_name(ast_node, parent_class)
+        self.validate_function_name(ast_node, find_parent_class_definition(self.syntax_tree, ast_node))
         self.generic_visit(ast_node)
 
     def visit_AsyncFunctionDef(self, ast_node: ast.AsyncFunctionDef) -> None:
-        parent_class: typing.Final = retrieve_parent_class(self.syntax_tree, ast_node)  # noqa: COP011
-        self.validate_function_name(ast_node, parent_class)
+        self.validate_function_name(ast_node, find_parent_class_definition(self.syntax_tree, ast_node))
         self.generic_visit(ast_node)
 
     def validate_function_name(
         self, ast_node: ast.FunctionDef | ast.AsyncFunctionDef, parent_class: ast.ClassDef | None
     ) -> None:
         if (
             check_is_ignored_name(ast_node.name)
-            or (parent_class and self.check_inherits_from_whitelisted_class(parent_class))
+            or (parent_class and check_inherits_from_bases(parent_class, FINAL_CLASS_EXCLUDED_BASES))
             or check_is_property(ast_node)
             or check_is_pytest_fixture(ast_node)
             or check_is_verb_name(ast_node.name)
@@ -89,11 +83,3 @@ def validate_function_name(
                 violation_code=ViolationCodes.FUNCTION_VERB,
             )
         )
-
-    def check_inherits_from_whitelisted_class(self, ast_node: ast.ClassDef) -> bool:
-        for base_class in ast_node.bases:
-            if isinstance(base_class, ast.Name) and base_class.id in FINAL_CLASS_EXCLUDED_BASES:
-                return True
-            if isinstance(base_class, ast.Attribute) and base_class.attr in FINAL_CLASS_EXCLUDED_BASES:
-                return True
-        return False

src/community_of_python_flake8_plugin/checks/module_import_many_names.py

@@ -53,14 +53,11 @@ def validate_import_size(self, ast_node: ast.ImportFrom) -> None:
         if module_name is not None and module_name.endswith(".settings"):
             return
 
-        module_import_exists: typing.Final = any(  # noqa: COP011
-            isinstance(identifier, ast.alias)
-            and module_name is not None
-            and check_module_path_exists(f"{module_name}.{identifier.name}")
-            for identifier in ast_node.names
-        )
-
-        if not module_import_exists:
+        if not any(
+            check_module_path_exists(f"{module_name}.{alias.name}")
+            for alias in ast_node.names
+            if isinstance(alias, ast.alias) and module_name is not None
+        ):
             self.violations.append(
                 Violation(
                     line_number=ast_node.lineno,

src/community_of_python_flake8_plugin/checks/name_length.py

@@ -3,7 +3,7 @@
 import typing
 
 from community_of_python_flake8_plugin.constants import FINAL_CLASS_EXCLUDED_BASES, MIN_NAME_LENGTH
-from community_of_python_flake8_plugin.utils import find_parent_class_definition
+from community_of_python_flake8_plugin.utils import check_inherits_from_bases, find_parent_class_definition
 from community_of_python_flake8_plugin.violation_codes import ViolationCodes
 from community_of_python_flake8_plugin.violations import Violation
 
@@ -44,15 +44,6 @@ def check_is_fixture_decorator(decorator: ast.expr) -> bool:
     return False
 
 
-def check_inherits_from_whitelisted_class(class_node: ast.ClassDef) -> bool:
-    for base_class in class_node.bases:
-        if isinstance(base_class, ast.Name) and base_class.id in FINAL_CLASS_EXCLUDED_BASES:
-            return True
-        if isinstance(base_class, ast.Attribute) and base_class.attr in FINAL_CLASS_EXCLUDED_BASES:
-            return True
-    return False
-
-
 @typing.final
 class COP004NameLengthCheck(ast.NodeVisitor):
     def __init__(self, tree: ast.AST) -> None:  # noqa: COP006
@@ -95,7 +86,7 @@ def validate_name_length(self, identifier: str, ast_node: ast.stmt, parent_class
         if (
             parent_class
             and isinstance(ast_node, (ast.AnnAssign, ast.Assign))
-            and check_inherits_from_whitelisted_class(parent_class)
+            and check_inherits_from_bases(parent_class, FINAL_CLASS_EXCLUDED_BASES)
         ):
             return
 
@@ -121,7 +112,7 @@ def validate_function_name(
             return
         if check_is_ignored_name(ast_node.name):
             return
-        if parent_class and check_inherits_from_whitelisted_class(parent_class):
+        if parent_class and check_inherits_from_bases(parent_class, FINAL_CLASS_EXCLUDED_BASES):
             return
         if check_is_pytest_fixture(ast_node):
             return

src/community_of_python_flake8_plugin/checks/scalar_annotation.py

@@ -3,7 +3,7 @@
 import typing
 
 from community_of_python_flake8_plugin.constants import SCALAR_ANNOTATIONS
-from community_of_python_flake8_plugin.utils import find_parent_class_definition
+from community_of_python_flake8_plugin.utils import find_parent_class_definition, find_parent_node
 from community_of_python_flake8_plugin.violation_codes import ViolationCodes
 from community_of_python_flake8_plugin.violations import Violation
 
@@ -36,29 +36,18 @@ def check_is_scalar_annotation(annotation_node: ast.AST) -> bool:
     return False
 
 
-def find_parent_function(syntax_tree: ast.AST, target_node: ast.AST) -> ast.FunctionDef | ast.AsyncFunctionDef | None:
-    for potential_parent in ast.walk(syntax_tree):
-        if isinstance(potential_parent, (ast.FunctionDef, ast.AsyncFunctionDef)):
-            for child_node in ast.walk(potential_parent):  # noqa: COP011
-                if child_node is target_node:
-                    return potential_parent
-    return None
-
-
 @typing.final
 class ScalarAnnotationCheck(ast.NodeVisitor):
-    def __init__(self, tree: ast.AST) -> None:  # noqa: COP006
+    def __init__(self, syntax_tree: ast.AST) -> None:  # noqa: COP006
         self.violations: list[Violation] = []
-        self.syntax_tree: typing.Final[ast.AST] = tree
+        self.syntax_tree: typing.Final[ast.AST] = syntax_tree
 
     def visit_AnnAssign(self, ast_node: ast.AnnAssign) -> None:
-        if isinstance(ast_node.target, ast.Name):
-            parent_class: typing.Final = find_parent_class_definition(self.syntax_tree, ast_node)  # noqa: COP011
-            parent_function: typing.Final = find_parent_function(self.syntax_tree, ast_node)  # noqa: COP011
-            in_class_body: typing.Final = parent_class is not None and parent_function is None
-
-            if not in_class_body:
-                self.validate_scalar_annotation(ast_node)
+        if isinstance(ast_node.target, ast.Name) and (
+            find_parent_class_definition(self.syntax_tree, ast_node) is None
+            or find_parent_node(self.syntax_tree, ast_node, (ast.FunctionDef, ast.AsyncFunctionDef)) is not None
+        ):
+            self.validate_scalar_annotation(ast_node)
         self.generic_visit(ast_node)
 
     def validate_scalar_annotation(self, ast_node: ast.AnnAssign) -> None:

src/community_of_python_flake8_plugin/checks/temp_var.py

@@ -7,21 +7,8 @@
 from community_of_python_flake8_plugin.violations import Violation
 
 
-def collect_variable_usage(function_node: ast.AST) -> dict[str, list[ast.Name]]:
+def collect_variable_usage_and_stores(function_node: ast.AST) -> tuple[dict[str, list[ast.Name]], set[str]]:
     variable_usage: typing.Final[defaultdict[str, list[ast.Name]]] = defaultdict(list)
-
-    @typing.final
-    class VariableCollector(ast.NodeVisitor):
-        def visit_Name(self, name_node: ast.Name) -> None:
-            # Collect all name references (both loads and stores)
-            variable_usage[name_node.id].append(name_node)
-            self.generic_visit(name_node)
-
-    VariableCollector().visit(function_node)
-    return dict(variable_usage)
-
-
-def collect_assignment_stores(function_node: ast.AST) -> set[str]:
     assigned_variable_names: typing.Final[set[str]] = set()
 
     def extract_names(expression: ast.expr) -> typing.Iterable[str]:
@@ -32,7 +19,11 @@ def extract_names(expression: ast.expr) -> typing.Iterable[str]:
                 yield from extract_names(elt)
 
     @typing.final
-    class AssignmentStoreCollector(ast.NodeVisitor):
+    class UsageCollector(ast.NodeVisitor):
+        def visit_Name(self, name_node: ast.Name) -> None:
+            variable_usage[name_node.id].append(name_node)
+            self.generic_visit(name_node)
+
         def visit_Assign(self, assign_node: ast.Assign) -> None:
             for target in assign_node.targets:
                 assigned_variable_names.update(extract_names(target))
@@ -46,8 +37,8 @@ def visit_AnnAssign(self, ann_assign_node: ast.AnnAssign) -> None:
             assigned_variable_names.update(extract_names(ann_assign_node.target))
             self.generic_visit(ann_assign_node)
 
-    AssignmentStoreCollector().visit(function_node)
-    return assigned_variable_names
+    UsageCollector().visit(function_node)
+    return dict(variable_usage), assigned_variable_names
 
 
 @typing.final
@@ -64,22 +55,19 @@ def visit_AsyncFunctionDef(self, ast_node: ast.AsyncFunctionDef) -> None:
         self.generic_visit(ast_node)
 
     def _check_temporary_variables(self, ast_node: ast.FunctionDef | ast.AsyncFunctionDef) -> None:
-        # Flag only the first temporary variable to match test expectations
+        usage_and_stores: typing.Final = collect_variable_usage_and_stores(ast_node)
         found_temporary_variable = False
 
-        for variable_name, usages in collect_variable_usage(ast_node).items():
-            # Skip special variables
+        for variable_name, usages in usage_and_stores[0].items():
             if variable_name.startswith("_") or variable_name in {"self", "cls"}:
                 continue
 
-            # Flag variables that are assigned once (in assignment) and read once
             if (
                 len([usage for usage in usages if isinstance(usage.ctx, ast.Store)]) == 1
                 and len([usage for usage in usages if isinstance(usage.ctx, ast.Load)]) == 1
-                and variable_name in collect_assignment_stores(ast_node)
+                and variable_name in usage_and_stores[1]
                 and not found_temporary_variable
             ):
-                # Find the first usage (likely the assignment) to report the violation
                 first_usage = usages[0]
                 self.violations.append(
                     Violation(

src/community_of_python_flake8_plugin/plugin.py

@@ -31,8 +31,17 @@ def __init__(self, tree: ast.AST) -> None:  # noqa: COP006
         self.ast_syntax_tree: typing.Final[ast.AST] = tree
 
     def run(self) -> Iterable[tuple[int, int, str, type[object]]]:  # noqa: COP007
-        checks_collection: typing.Final[list[PluginCheckProtocol]] = []
+        for check_instance in self._collect_checks():
+            for violation in check_instance.violations:
+                yield (
+                    violation.line_number,
+                    violation.column_number,
+                    f"{violation.violation_code.code} {violation.violation_code.description}",
+                    type(self),
+                )
 
+    def _collect_checks(self) -> list[PluginCheckProtocol]:
+        checks_collection: typing.Final = []
         for _, module_name, _ in pkgutil.iter_modules(checks_module.__path__):
             imported_module = importlib.import_module(f"{checks_module.__name__}.{module_name}")
 
@@ -42,12 +51,4 @@ def run(self) -> Iterable[tuple[int, int, str, type[object]]]:  # noqa: COP007
                     check_instance = attribute(self.ast_syntax_tree)
                     check_instance.visit(self.ast_syntax_tree)
                     checks_collection.append(check_instance)
-
-        for check_instance in checks_collection:
-            for violation in check_instance.violations:
-                yield (
-                    violation.line_number,
-                    violation.column_number,
-                    f"{violation.violation_code.code} {violation.violation_code.description}",
-                    type(self),
-                )
+        return checks_collection

src/community_of_python_flake8_plugin/utils.py

@@ -9,3 +9,21 @@ def find_parent_class_definition(syntax_tree: ast.AST, target_node: ast.AST) ->
                 if child_node is target_node:
                     return potential_parent
     return None
+
+
+def check_inherits_from_bases(class_definition: ast.ClassDef, base_classes: set[str]) -> bool:
+    for base_class in class_definition.bases:
+        if isinstance(base_class, ast.Name) and base_class.id in base_classes:
+            return True
+        if isinstance(base_class, ast.Attribute) and base_class.attr in base_classes:
+            return True
+    return False
+
+
+def find_parent_node(syntax_tree: ast.AST, target_node: ast.AST, node_types: tuple[type, ...]) -> ast.AST | None:
+    for potential_parent in ast.walk(syntax_tree):
+        if isinstance(potential_parent, node_types):
+            for child_node in ast.walk(potential_parent):
+                if child_node is target_node:
+                    return potential_parent
+    return None

src/community_of_python_flake8_plugin/violation_codes.py

@@ -4,8 +4,8 @@
 
 
 @typing.final
-@dataclasses.dataclass(frozen=True, kw_only=True, slots=True)
-class ViolationCodeItem:
+@dataclasses.dataclass(kw_only=True, slots=True, frozen=True)
+class ViolationCodeItem:  # noqa: COP014
     code: str  # noqa: COP004
     description: str
 

src/community_of_python_flake8_plugin/violations.py

@@ -8,8 +8,8 @@
 
 
 @typing.final
-@dataclasses.dataclass(frozen=True, kw_only=True, slots=True)
-class Violation:
+@dataclasses.dataclass(kw_only=True, slots=True, frozen=True)
+class Violation:  # noqa: COP014
     line_number: int
     column_number: int
     violation_code: ViolationCodeItem