community-of-python-flake8-plugin 0.3.1__tar.gz → 0.3.2__tar.gz

{community_of_python_flake8_plugin-0.3.1 → community_of_python_flake8_plugin-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: community-of-python-flake8-plugin
-Version: 0.3.1
+Version: 0.3.2
 Summary: Community of Python flake8 plugin
 Author: Lev Vereshchagin
 Author-email: Lev Vereshchagin <mail@vrslev.com>

{community_of_python_flake8_plugin-0.3.1 → community_of_python_flake8_plugin-0.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "community-of-python-flake8-plugin"
-version = "0.3.1"
+version = "0.3.2"
 description = "Community of Python flake8 plugin"
 readme = "README.md"
 authors = [{ name = "Lev Vereshchagin", email = "mail@vrslev.com" }]

{community_of_python_flake8_plugin-0.3.1 → community_of_python_flake8_plugin-0.3.2}/src/community_of_python_flake8_plugin/checks/final_class.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 import ast
 import typing
 
+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
 
@@ -25,9 +26,20 @@ def is_protocol_class(class_node: ast.ClassDef) -> bool:
         # Check for attributed Protocol reference: class MyClass(typing.Protocol):
         if isinstance(one_base, ast.Attribute) and one_base.attr == "Protocol":
             return True
+        # Check for subscripted Protocol reference: class MyClass(Protocol[SomeType]):
+        if isinstance(one_base, ast.Subscript):
+            if isinstance(one_base.value, ast.Name) and one_base.value.id == "Protocol":
+                return True
+            if isinstance(one_base.value, ast.Attribute) and one_base.value.attr == "Protocol":
+                return True
     return False
 
 
+def is_model_factory_class(class_node: ast.ClassDef) -> bool:
+    """Check if the class inherits from ModelFactory or SQLAlchemyFactory."""
+    return check_inherits_from_bases(class_node, {"ModelFactory", "SQLAlchemyFactory"})
+
+
 @typing.final
 class FinalClassCheck(ast.NodeVisitor):
     def __init__(self, syntax_tree: ast.AST) -> None:  # noqa: ARG002
@@ -38,8 +50,8 @@ class FinalClassCheck(ast.NodeVisitor):
         self.generic_visit(ast_node)
 
     def _check_final_decorator(self, ast_node: ast.ClassDef) -> None:
-        # Skip Protocol classes and test classes
-        if is_protocol_class(ast_node) or ast_node.name.startswith("Test"):
+        # Skip Protocol classes, test classes, and ModelFactory classes
+        if is_protocol_class(ast_node) or ast_node.name.startswith("Test") or is_model_factory_class(ast_node):
             return
 
         if not contains_final_decorator(ast_node):

{community_of_python_flake8_plugin-0.3.1 → community_of_python_flake8_plugin-0.3.2}/src/community_of_python_flake8_plugin/checks/function_verb.py

@@ -11,19 +11,20 @@ from community_of_python_flake8_plugin.violations import Violation
 def check_is_ignored_name(identifier: str) -> bool:
     if identifier == "main":
         return True
-    if identifier.startswith("__") and identifier.endswith("__"):
-        return True
-    return bool(identifier.startswith("_"))
+    return bool(identifier.startswith("__") and identifier.endswith("__"))
 
 
 def check_is_verb_name(identifier: str) -> bool:
-    return any(identifier == verb_name or identifier.startswith(f"{verb_name}_") for verb_name in VERB_PREFIXES)
+    return any(
+        identifier == one_verb_name or identifier.startswith((f"{one_verb_name}_", f"_{one_verb_name}"))
+        for one_verb_name in VERB_PREFIXES
+    )
 
 
 def check_is_property(function_node: ast.AST) -> bool:
     if not isinstance(function_node, (ast.FunctionDef, ast.AsyncFunctionDef)):
         return False
-    return any(check_is_property_decorator(decorator) for decorator in function_node.decorator_list)  # noqa: COP011
+    return any(check_is_property_decorator(one_decorator) for one_decorator in function_node.decorator_list)  # noqa: COP011
 
 
 def check_is_property_decorator(decorator: ast.expr) -> bool:  # noqa: PLR0911
@@ -56,7 +57,7 @@ def check_is_property_decorator(decorator: ast.expr) -> bool:  # noqa: PLR0911
 def check_is_pytest_fixture(function_node: ast.AST) -> bool:
     if not isinstance(function_node, (ast.FunctionDef, ast.AsyncFunctionDef)):
         return False
-    return any(check_is_fixture_decorator(decorator) for decorator in function_node.decorator_list)  # noqa: COP011
+    return any(check_is_fixture_decorator(one_decorator) for one_decorator in function_node.decorator_list)  # noqa: COP011
 
 
 def check_is_fixture_decorator(decorator: ast.expr) -> bool:

{community_of_python_flake8_plugin-0.3.1 → community_of_python_flake8_plugin-0.3.2}/src/community_of_python_flake8_plugin/checks/mapping_proxy.py

@@ -71,9 +71,9 @@ class MappingProxyCheck(ast.NodeVisitor):
         self.violations: list[Violation] = []
 
     def visit_Module(self, ast_node: ast.Module) -> None:
-        for statement in ast_node.body:
-            if isinstance(statement, (ast.Assign, ast.AnnAssign)):
-                self._check_mapping_assignment(statement)
+        for one_statement in ast_node.body:
+            if isinstance(one_statement, (ast.Assign, ast.AnnAssign)):
+                self._check_mapping_assignment(one_statement)
         self.generic_visit(ast_node)
 
     def _check_mapping_assignment(self, ast_node: ast.Assign | ast.AnnAssign) -> None:
@@ -99,8 +99,8 @@ class MappingProxyCheck(ast.NodeVisitor):
         # Only check module-level assignments (no parent function/class)
         if assigned_value is not None and isinstance(assigned_value, ast.Dict) and assignment_targets:
             # Check if this is a module-level assignment
-            for target in assignment_targets:  # noqa: COP011
-                if isinstance(target, ast.Name):
+            for one_target in assignment_targets:  # noqa: COP011
+                if isinstance(one_target, ast.Name):
                     self.violations.append(
                         Violation(
                             line_number=ast_node.lineno,

{community_of_python_flake8_plugin-0.3.1 → community_of_python_flake8_plugin-0.3.2}/src/community_of_python_flake8_plugin/checks/name_length.py

@@ -3,7 +3,11 @@ import ast
 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 check_inherits_from_bases, find_parent_class_definition
+from community_of_python_flake8_plugin.utils import (
+    check_inherits_from_bases,
+    find_parent_class_definition,
+    find_parent_function_definition,
+)
 from community_of_python_flake8_plugin.violation_codes import ViolationCodes
 from community_of_python_flake8_plugin.violations import Violation
 
@@ -33,7 +37,7 @@ def check_is_whitelisted_annotation(annotation: ast.expr | None) -> bool:
 def check_is_pytest_fixture(ast_node: ast.AST) -> bool:
     if not isinstance(ast_node, (ast.FunctionDef, ast.AsyncFunctionDef)):
         return False
-    return any(check_is_fixture_decorator(decorator) for decorator in ast_node.decorator_list)  # noqa: COP011
+    return any(check_is_fixture_decorator(one_decorator) for one_decorator in ast_node.decorator_list)  # noqa: COP011
 
 
 def check_is_fixture_decorator(decorator: ast.expr) -> bool:
@@ -58,9 +62,11 @@ class COP004NameLengthCheck(ast.NodeVisitor):
         self.generic_visit(ast_node)
 
     def visit_Assign(self, ast_node: ast.Assign) -> None:
-        for target in ast_node.targets:
-            if isinstance(target, ast.Name):
-                self.validate_name_length(target.id, ast_node, find_parent_class_definition(self.syntax_tree, ast_node))
+        for one_target in ast_node.targets:
+            if isinstance(one_target, ast.Name):
+                self.validate_name_length(
+                    one_target.id, ast_node, find_parent_class_definition(self.syntax_tree, ast_node)
+                )
         self.generic_visit(ast_node)
 
     def visit_FunctionDef(self, ast_node: ast.FunctionDef) -> None:
@@ -79,18 +85,18 @@ class COP004NameLengthCheck(ast.NodeVisitor):
         self.generic_visit(ast_node)
 
     def visit_ListComp(self, ast_node: ast.ListComp) -> None:
-        for comprehension in ast_node.generators:
-            self._validate_comprehension_target(comprehension.target)
+        for one_comprehension in ast_node.generators:
+            self._validate_comprehension_target(one_comprehension.target)
         self.generic_visit(ast_node)
 
     def visit_SetComp(self, ast_node: ast.SetComp) -> None:
-        for comprehension in ast_node.generators:
-            self._validate_comprehension_target(comprehension.target)
+        for one_comprehension in ast_node.generators:
+            self._validate_comprehension_target(one_comprehension.target)
         self.generic_visit(ast_node)
 
     def visit_DictComp(self, ast_node: ast.DictComp) -> None:
-        for comprehension in ast_node.generators:
-            self._validate_comprehension_target(comprehension.target)
+        for one_comprehension in ast_node.generators:
+            self._validate_comprehension_target(one_comprehension.target)
         self.generic_visit(ast_node)
 
     def visit_Lambda(self, ast_node: ast.Lambda) -> None:
@@ -98,9 +104,9 @@ class COP004NameLengthCheck(ast.NodeVisitor):
         self.generic_visit(ast_node)
 
     def visit_With(self, ast_node: ast.With) -> None:
-        for item in ast_node.items:
-            if item.optional_vars is not None:
-                self._validate_with_target(item.optional_vars)
+        for one_item in ast_node.items:
+            if one_item.optional_vars is not None:
+                self._validate_with_target(one_item.optional_vars)
         self.generic_visit(ast_node)
 
     def visit_ExceptHandler(self, ast_node: ast.ExceptHandler) -> None:
@@ -109,18 +115,18 @@ class COP004NameLengthCheck(ast.NodeVisitor):
         self.generic_visit(ast_node)
 
     def visit_GeneratorExp(self, ast_node: ast.GeneratorExp) -> None:
-        for comprehension in ast_node.generators:
-            self._validate_comprehension_target(comprehension.target)
+        for one_comprehension in ast_node.generators:
+            self._validate_comprehension_target(one_comprehension.target)
         self.generic_visit(ast_node)
 
     def _validate_function_args(self, arguments_node: ast.arguments) -> None:
         # Process all argument types
-        for argument in arguments_node.posonlyargs:
-            self._validate_argument_name_length(argument)
-        for argument in arguments_node.args:
-            self._validate_argument_name_length(argument)
-        for argument in arguments_node.kwonlyargs:
-            self._validate_argument_name_length(argument)
+        for one_argument in arguments_node.posonlyargs:
+            self._validate_argument_name_length(one_argument)
+        for one_argument in arguments_node.args:
+            self._validate_argument_name_length(one_argument)
+        for one_argument in arguments_node.kwonlyargs:
+            self._validate_argument_name_length(one_argument)
 
         if arguments_node.vararg is not None:
             self._validate_argument_name_length(arguments_node.vararg)
@@ -157,8 +163,8 @@ class COP004NameLengthCheck(ast.NodeVisitor):
                 )
         elif isinstance(comprehension_target, ast.Tuple):
             # Handle tuple unpacking in comprehensions like [(a, b) for a, b in pairs]
-            for elt in comprehension_target.elts:
-                self._validate_comprehension_target(elt)
+            for one_elt in comprehension_target.elts:
+                self._validate_comprehension_target(one_elt)
 
     def _validate_with_target(self, target_node: ast.expr) -> None:
         if isinstance(target_node, ast.Name):
@@ -173,8 +179,8 @@ class COP004NameLengthCheck(ast.NodeVisitor):
                 )
         elif isinstance(target_node, ast.Tuple):
             # Handle tuple unpacking in with statements like with open(f1) as f1, open(f2) as f2:
-            for elt in target_node.elts:
-                self._validate_with_target(elt)
+            for one_elt in target_node.elts:
+                self._validate_with_target(one_elt)
 
     def _validate_except_target(self, ast_node: ast.ExceptHandler) -> None:
         # For except targets, we'll treat them as variables
@@ -204,15 +210,18 @@ class COP004NameLengthCheck(ast.NodeVisitor):
             return
 
         if len(identifier) < MIN_NAME_LENGTH:
-            # Determine if this is an attribute (inside a class) or variable (at module level)
+            # Determine if this is an attribute (inside a class but not in a method) or variable
+            parent_function: typing.Final = find_parent_function_definition(self.syntax_tree, ast_node)
+
+            # It's an attribute only if it's in a class but NOT in a function/method
+            is_attribute: typing.Final = parent_class is not None and parent_function is None
+
             self.violations.append(
                 Violation(
                     line_number=ast_node.lineno,
                     column_number=ast_node.col_offset,
                     violation_code=(
-                        ViolationCodes.ATTRIBUTE_NAME_LENGTH
-                        if parent_class is not None
-                        else ViolationCodes.VARIABLE_NAME_LENGTH
+                        ViolationCodes.ATTRIBUTE_NAME_LENGTH if is_attribute else ViolationCodes.VARIABLE_NAME_LENGTH
                     ),
                 )
             )
@@ -240,12 +249,12 @@ class COP004NameLengthCheck(ast.NodeVisitor):
 
     def validate_function_args(self, ast_node: ast.FunctionDef | ast.AsyncFunctionDef) -> None:
         # Process all argument types
-        for argument in ast_node.args.posonlyargs:
-            self.validate_argument_name_length(argument)
-        for argument in ast_node.args.args:
-            self.validate_argument_name_length(argument)
-        for argument in ast_node.args.kwonlyargs:
-            self.validate_argument_name_length(argument)
+        for one_argument in ast_node.args.posonlyargs:
+            self.validate_argument_name_length(one_argument)
+        for one_argument in ast_node.args.args:
+            self.validate_argument_name_length(one_argument)
+        for one_argument in ast_node.args.kwonlyargs:
+            self.validate_argument_name_length(one_argument)
 
         if ast_node.args.vararg is not None:
             self.validate_argument_name_length(ast_node.args.vararg)

{community_of_python_flake8_plugin-0.3.1 → community_of_python_flake8_plugin-0.3.2}/src/community_of_python_flake8_plugin/checks/temp_var.py

@@ -15,32 +15,30 @@ def extract_names(expression: ast.expr) -> typing.Iterable[str]:
     if isinstance(expression, ast.Name):
         yield expression.id
     elif isinstance(expression, ast.Tuple):
-        for elt in expression.elts:
-            yield from extract_names(elt)
+        for one_elt in expression.elts:
+            yield from extract_names(one_elt)
 
 
-def is_single_line_assignment(assign_node: ast.Assign) -> bool:
+def is_single_line_assignment(assign_node: ast.Assign | ast.AnnAssign) -> bool:
     """Check if assignment value fits on a single line."""
     # For simple values, they're always single line
     if isinstance(assign_node.value, (ast.Constant, ast.Name, ast.Attribute)):
         return True
-    
+
     # For complex expressions, check if they span multiple lines
     # We'll consider it multi-line if the end line is different from start line
-    if hasattr(assign_node, 'lineno') and hasattr(assign_node.value, 'end_lineno'):
+    if hasattr(assign_node, "lineno") and assign_node.value is not None and hasattr(assign_node.value, "end_lineno"):
         return assign_node.lineno == assign_node.value.end_lineno
-    
+
     return True
 
 
-def collect_variable_usage_and_stores_with_nodes(function_node: ast.AST) -> tuple[
-    dict[str, list[ast.Name]], 
-    set[str], 
-    dict[str, ast.Assign]
-]:
+def collect_variable_usage_and_stores_with_nodes(
+    function_node: ast.AST,
+) -> tuple[dict[str, list[ast.Name]], set[str], dict[str, ast.Assign | ast.AnnAssign]]:
     variable_usage: typing.Final[defaultdict[str, list[ast.Name]]] = defaultdict(list)
     assigned_variable_names: typing.Final[set[str]] = set()
-    variable_assignments: typing.Final[dict[str, ast.Assign]] = {}
+    variable_assignments: typing.Final[dict[str, ast.Assign | ast.AnnAssign]] = {}
 
     @typing.final
     class UsageCollector(ast.NodeVisitor):
@@ -54,43 +52,42 @@ def collect_variable_usage_and_stores_with_nodes(function_node: ast.AST) -> tupl
                 self.generic_visit(assign_node)
                 return
 
-            for target in assign_node.targets:
-                names = list(extract_names(target))
-                assigned_variable_names.update(names)
+            for one_target in assign_node.targets:
+                one_names = list(extract_names(one_target))
+                assigned_variable_names.update(one_names)
                 # Store the assignment node for each variable
-                for name in names:
-                    variable_assignments[name] = assign_node
+                for one_name in one_names:
+                    variable_assignments[one_name] = assign_node
             self.generic_visit(assign_node)
 
         def visit_AugAssign(self, aug_assign_node: ast.AugAssign) -> None:
-            names = list(extract_names(aug_assign_node.target))
-            assigned_variable_names.update(names)
+            assigned_variable_names.update(list(extract_names(aug_assign_node.target)))
             self.generic_visit(aug_assign_node)
 
         def visit_AnnAssign(self, ann_assign_node: ast.AnnAssign) -> None:
-            names = list(extract_names(ann_assign_node.target))
-            assigned_variable_names.update(names)
+            extracted_names: typing.Final = list(extract_names(ann_assign_node.target))  # noqa: COP011
+            assigned_variable_names.update(extracted_names)
             # Store the assignment node for each variable
-            for name in names:
-                variable_assignments[name] = ann_assign_node
+            for one_name in extracted_names:
+                variable_assignments[one_name] = ann_assign_node
             self.generic_visit(ann_assign_node)
 
     UsageCollector().visit(function_node)
     return dict(variable_usage), assigned_variable_names, variable_assignments
 
 
-def is_used_in_next_line(assign_node: ast.Assign, usage_nodes: list[ast.Name]) -> bool:
+def is_used_in_next_line(assign_node: ast.Assign | ast.AnnAssign, usage_nodes: list[ast.Name]) -> bool:
     """Check if variable is used in the immediate next line."""
     if not usage_nodes:
         return False
-        
+
     # Find the load usage (actual use of the variable)
-    load_usages = [node for node in usage_nodes if isinstance(node.ctx, ast.Load)]
+    load_usages: typing.Final = [one_node for one_node in usage_nodes if isinstance(one_node.ctx, ast.Load)]
     if not load_usages:
         return False
-        
-    first_load = load_usages[0]
-    
+
+    first_load: typing.Final = load_usages[0]
+
     # Check if the usage is on the line immediately following the assignment
     return first_load.lineno == assign_node.lineno + 1
 
@@ -110,16 +107,20 @@ class TempVarCheck(ast.NodeVisitor):
 
     def _check_temporary_variables(self, ast_node: ast.FunctionDef | ast.AsyncFunctionDef) -> None:
         usage_and_stores: typing.Final = collect_variable_usage_and_stores_with_nodes(ast_node)
-        variable_usages = usage_and_stores[0]
-        assigned_variable_names = usage_and_stores[1]
-        variable_assignments = usage_and_stores[2]
+        variable_usages: typing.Final = usage_and_stores[0]
+        assigned_variable_names: typing.Final = usage_and_stores[1]
+        variable_assignments: typing.Final = usage_and_stores[2]
 
         for variable_name, usages in variable_usages.items():
             if variable_name.startswith("_") or variable_name in {"self", "cls"}:
                 continue
 
-            store_count = len([usage_element for usage_element in usages if isinstance(usage_element.ctx, ast.Store)])
-            load_count = len([usage_element for usage_element in usages if isinstance(usage_element.ctx, ast.Load)])
+            store_count = len(
+                [one_usage_element for one_usage_element in usages if isinstance(one_usage_element.ctx, ast.Store)]
+            )
+            load_count = len(
+                [one_usage_element for one_usage_element in usages if isinstance(one_usage_element.ctx, ast.Load)]
+            )
 
             # Check if variable is assigned once and used once
             if store_count == 1 and load_count == 1 and variable_name in assigned_variable_names:
@@ -127,16 +128,16 @@ class TempVarCheck(ast.NodeVisitor):
                 assign_node = variable_assignments.get(variable_name)
                 if not assign_node:
                     continue
-                    
+
                 # Check if it's a single-line assignment
                 if not is_single_line_assignment(assign_node):
                     continue
-                    
+
                 # Check if it's used in the next line
                 if is_used_in_next_line(assign_node, usages):
                     # Only flag the variable that is assigned and then immediately used
                     # Find the store usage (assignment)
-                    store_usages = [node for node in usages if isinstance(node.ctx, ast.Store)]
+                    store_usages = [one_node for one_node in usages if isinstance(one_node.ctx, ast.Store)]
                     if store_usages:
                         first_store = store_usages[0]
                         self.violations.append(

{community_of_python_flake8_plugin-0.3.1 → community_of_python_flake8_plugin-0.3.2}/src/community_of_python_flake8_plugin/constants.py

@@ -109,6 +109,8 @@ VERB_PREFIXES: typing.Final = {
     "submit",
     "clear",
     "undo",
+    "cache",
+    "fill",
 }
 
 SCALAR_ANNOTATIONS: typing.Final = {"int", "str", "float", "bool", "bytes", "complex"}

{community_of_python_flake8_plugin-0.3.1 → community_of_python_flake8_plugin-0.3.2}/src/community_of_python_flake8_plugin/plugin.py

@@ -31,23 +31,23 @@ class CommunityOfPythonFlake8Plugin:
         self.ast_syntax_tree: typing.Final[ast.AST] = tree
 
     def run(self) -> Iterable[tuple[int, int, str, type[object]]]:  # noqa: COP007
-        for check_instance in self._collect_checks():
-            for violation in check_instance.violations:
+        for one_check_instance in self._collect_checks():
+            for one_violation in one_check_instance.violations:
                 yield (
-                    violation.line_number,
-                    violation.column_number,
-                    f"{violation.violation_code.code} {violation.violation_code.description}",
+                    one_violation.line_number,
+                    one_violation.column_number,
+                    f"{one_violation.violation_code.code} {one_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}")
+        for _, one_module_name, _ in pkgutil.iter_modules(checks_module.__path__):
+            imported_module = importlib.import_module(f"{checks_module.__name__}.{one_module_name}")
 
-            for attribute_name in dir(imported_module):
-                attribute = getattr(imported_module, attribute_name)
-                if isinstance(attribute, type) and attribute_name.endswith("Check") and hasattr(attribute, "visit"):
+            for one_attribute_name in dir(imported_module):
+                attribute = getattr(imported_module, one_attribute_name)
+                if isinstance(attribute, type) and one_attribute_name.endswith("Check") and hasattr(attribute, "visit"):
                     check_instance = attribute(self.ast_syntax_tree)
                     check_instance.visit(self.ast_syntax_tree)
                     checks_collection.append(check_instance)

community_of_python_flake8_plugin-0.3.2/src/community_of_python_flake8_plugin/utils.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+import ast
+
+
+def find_parent_class_definition(syntax_tree: ast.AST, target_node: ast.AST) -> ast.ClassDef | None:
+    for one_potential_parent in ast.walk(syntax_tree):
+        if isinstance(one_potential_parent, ast.ClassDef):
+            for one_child_node in ast.walk(one_potential_parent):
+                if one_child_node is target_node:
+                    return one_potential_parent
+    return None
+
+
+def find_parent_function_definition(
+    syntax_tree: ast.AST, target_node: ast.AST
+) -> ast.FunctionDef | ast.AsyncFunctionDef | None:
+    for one_potential_parent in ast.walk(syntax_tree):
+        if isinstance(one_potential_parent, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            for one_child_node in ast.walk(one_potential_parent):
+                if one_child_node is target_node:
+                    return one_potential_parent
+    return None
+
+
+def check_inherits_from_bases(class_definition: ast.ClassDef, base_classes: set[str]) -> bool:
+    for one_base_class in class_definition.bases:
+        if isinstance(one_base_class, ast.Name) and one_base_class.id in base_classes:
+            return True
+        if isinstance(one_base_class, ast.Attribute) and one_base_class.attr in base_classes:
+            return True
+        # Handle generic types like ModelFactory[SomeType]
+        if isinstance(one_base_class, ast.Subscript):
+            if isinstance(one_base_class.value, ast.Name) and one_base_class.value.id in base_classes:
+                return True
+            if isinstance(one_base_class.value, ast.Attribute) and one_base_class.value.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 one_potential_parent in ast.walk(syntax_tree):
+        if isinstance(one_potential_parent, node_types):
+            for one_child_node in ast.walk(one_potential_parent):
+                if one_child_node is target_node:
+                    return one_potential_parent
+    return None

{community_of_python_flake8_plugin-0.3.1 → community_of_python_flake8_plugin-0.3.2}/src/community_of_python_flake8_plugin/violation_codes.py

@@ -35,7 +35,9 @@ class ViolationCodes:
     ASYNC_GET_PREFIX = ViolationCodeItem(code="COP010", description="Avoid get_ prefix in async function names")
 
     # Variable usage violations
-    TEMP_VAR = ViolationCodeItem(code="COP011", description="Inline variables that are used only once")
+    TEMP_VAR = ViolationCodeItem(
+        code="COP011", description="Inline those temporary variables that are used only once and close to assignment"
+    )
 
     # Class related violations
     FINAL_CLASS = ViolationCodeItem(code="COP012", description="Classes must be marked final with @typing.final")

community_of_python_flake8_plugin-0.3.1/src/community_of_python_flake8_plugin/utils.py

@@ -1,35 +0,0 @@
-from __future__ import annotations
-import ast
-
-
-def find_parent_class_definition(syntax_tree: ast.AST, target_node: ast.AST) -> ast.ClassDef | None:
-    for potential_parent in ast.walk(syntax_tree):
-        if isinstance(potential_parent, ast.ClassDef):
-            for child_node in ast.walk(potential_parent):
-                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
-        # Handle generic types like ModelFactory[SomeType]
-        if isinstance(base_class, ast.Subscript):
-            if isinstance(base_class.value, ast.Name) and base_class.value.id in base_classes:
-                return True
-            if isinstance(base_class.value, ast.Attribute) and base_class.value.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