community-of-python-flake8-plugin 0.2.0__tar.gz → 0.3.0__tar.gz

{community_of_python_flake8_plugin-0.2.0 → community_of_python_flake8_plugin-0.3.0}/PKG-INFO

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

{community_of_python_flake8_plugin-0.2.0 → community_of_python_flake8_plugin-0.3.0}/pyproject.toml

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

{community_of_python_flake8_plugin-0.2.0 → community_of_python_flake8_plugin-0.3.0}/src/community_of_python_flake8_plugin/checks/dataclass_config.py

@@ -24,7 +24,11 @@ def has_required_dataclass_params(decorator: ast.expr) -> bool:
     if not isinstance(decorator, ast.Call):
         return False
 
-    keywords: typing.Final = {kw.arg: kw.value for kw in decorator.keywords if isinstance(kw.value, ast.Constant)}
+    keywords: typing.Final = {
+        one_keyword_item.arg: one_keyword_item.value
+        for one_keyword_item in decorator.keywords
+        if isinstance(one_keyword_item.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")
@@ -43,20 +47,20 @@ def has_required_dataclass_params(decorator: ast.expr) -> bool:
 
 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:
-        if isinstance(base_class, ast.Name) and base_class.id in {"BaseModel", "RootModel"}:
+    for one_base_class in class_node.bases:
+        if isinstance(one_base_class, ast.Name) and one_base_class.id in {"BaseModel", "RootModel"}:
             return True
-        if isinstance(base_class, ast.Attribute) and base_class.attr in {"BaseModel", "RootModel"}:
+        if isinstance(one_base_class, ast.Attribute) and one_base_class.attr in {"BaseModel", "RootModel"}:
             return True
     return False
 
 
 def is_model_factory(class_node: ast.ClassDef) -> bool:
     """Check if class inherits from ModelFactory."""
-    for base_class in class_node.bases:
-        if isinstance(base_class, ast.Name) and base_class.id in {"ModelFactory", "SQLAlchemyFactory"}:
+    for one_base_class in class_node.bases:
+        if isinstance(one_base_class, ast.Name) and one_base_class.id in {"ModelFactory", "SQLAlchemyFactory"}:
             return True
-        if isinstance(base_class, ast.Attribute) and base_class.attr in {"ModelFactory", "SQLAlchemyFactory"}:
+        if isinstance(one_base_class, ast.Attribute) and one_base_class.attr in {"ModelFactory", "SQLAlchemyFactory"}:
             return True
     return False
 
@@ -78,9 +82,9 @@ class DataclassConfigCheck(ast.NodeVisitor):
             return
 
         # Check for dataclass decorator
-        for decorator in ast_node.decorator_list:
-            if is_dataclass_decorator(decorator):
-                if not has_required_dataclass_params(decorator):
+        for one_decorator in ast_node.decorator_list:
+            if is_dataclass_decorator(one_decorator):
+                if not has_required_dataclass_params(one_decorator):
                     self.violations.append(
                         Violation(
                             line_number=ast_node.lineno,
@@ -94,9 +98,9 @@ class DataclassConfigCheck(ast.NodeVisitor):
 
     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):
+        for one_base in ast_node.bases:
+            if isinstance(one_base, ast.Name) and ("Error" in one_base.id or "Exception" in one_base.id):
                 return True
-            if isinstance(base, ast.Attribute) and ("Error" in base.attr or "Exception" in base.attr):
+            if isinstance(one_base, ast.Attribute) and ("Error" in one_base.attr or "Exception" in one_base.attr):
                 return True
         return False

{community_of_python_flake8_plugin-0.2.0 → community_of_python_flake8_plugin-0.3.0}/src/community_of_python_flake8_plugin/checks/disabled/module_import_many_names.py

@@ -17,15 +17,16 @@ from community_of_python_flake8_plugin.violations import Violation
 
 
 def check_module_has_all_declaration(module_node: ast.Module) -> bool:
-    for statement in module_node.body:
-        if isinstance(statement, ast.Assign) and any(
-            isinstance(target, ast.Name) and target.id == "__all__" for target in statement.targets
+    for one_statement in module_node.body:
+        if isinstance(one_statement, ast.Assign) and any(
+            isinstance(one_target_element, ast.Name) and one_target_element.id == "__all__"
+            for one_target_element in one_statement.targets
         ):
             return True
         if (
-            isinstance(statement, ast.AnnAssign)
-            and isinstance(statement.target, ast.Name)
-            and statement.target.id == "__all__"
+            isinstance(one_statement, ast.AnnAssign)
+            and isinstance(one_statement.target, ast.Name)
+            and one_statement.target.id == "__all__"
         ):
             return True
     return False
@@ -76,9 +77,9 @@ class ModuleImportManyNamesCheck(ast.NodeVisitor):
             return
 
         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
+            check_module_path_exists(f"{module_name}.{one_alias_element.name}")
+            for one_alias_element in ast_node.names
+            if isinstance(one_alias_element, ast.alias) and module_name is not None
         ):
             self.violations.append(
                 Violation(

{community_of_python_flake8_plugin-0.2.0 → community_of_python_flake8_plugin-0.3.0}/src/community_of_python_flake8_plugin/checks/final_class.py

@@ -7,8 +7,8 @@ from community_of_python_flake8_plugin.violations import Violation
 
 
 def contains_final_decorator(class_node: ast.ClassDef) -> bool:
-    for decorator in class_node.decorator_list:
-        target_name = decorator.func if isinstance(decorator, ast.Call) else decorator
+    for one_decorator in class_node.decorator_list:
+        target_name = one_decorator.func if isinstance(one_decorator, ast.Call) else one_decorator
         if isinstance(target_name, ast.Name) and target_name.id == "final":
             return True
         if isinstance(target_name, ast.Attribute) and target_name.attr == "final":
@@ -18,12 +18,12 @@ def contains_final_decorator(class_node: ast.ClassDef) -> bool:
 
 def is_protocol_class(class_node: ast.ClassDef) -> bool:
     """Check if the class directly inherits from typing.Protocol."""
-    for base in class_node.bases:
+    for one_base in class_node.bases:
         # Check for direct Protocol reference: class MyClass(Protocol):
-        if isinstance(base, ast.Name) and base.id == "Protocol":
+        if isinstance(one_base, ast.Name) and one_base.id == "Protocol":
             return True
         # Check for attributed Protocol reference: class MyClass(typing.Protocol):
-        if isinstance(base, ast.Attribute) and base.attr == "Protocol":
+        if isinstance(one_base, ast.Attribute) and one_base.attr == "Protocol":
             return True
     return False
 

community_of_python_flake8_plugin-0.3.0/src/community_of_python_flake8_plugin/checks/for_loop_one_prefix.py

@@ -0,0 +1,121 @@
+from __future__ import annotations
+import ast
+import typing
+
+from community_of_python_flake8_plugin.violation_codes import ViolationCodes
+from community_of_python_flake8_plugin.violations import Violation
+
+
+def _is_ignored_target(target_node: ast.expr) -> bool:
+    """Check if target should be ignored (e.g., underscore variables)."""
+    # Ignore underscore variables
+    return bool(isinstance(target_node, ast.Name) and target_node.id == "_")
+
+
+@typing.final
+class COP015ForLoopOnePrefixCheck(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_ListComp(self, ast_node: ast.ListComp) -> None:
+        # Validate targets in generators (the 'v' in 'for v in lst')
+        for one_comprehension in ast_node.generators:
+            if not self._is_partial_unpacking(ast_node.elt, one_comprehension.target):
+                self._validate_comprehension_target(one_comprehension.target)
+        self.generic_visit(ast_node)
+
+    def visit_SetComp(self, ast_node: ast.SetComp) -> None:
+        # Validate targets in generators (the 'v' in 'for v in lst')
+        for one_comprehension in ast_node.generators:
+            if not self._is_partial_unpacking(ast_node.elt, one_comprehension.target):
+                self._validate_comprehension_target(one_comprehension.target)
+        self.generic_visit(ast_node)
+
+    def visit_DictComp(self, ast_node: ast.DictComp) -> None:
+        # Validate targets in generators (the 'v' in 'for v in lst')
+        # For dict comprehensions, we consider both key and value
+        # key and value are both used
+        for one_comprehension in ast_node.generators:
+            if not self._is_partial_unpacking_expr_count(2, one_comprehension.target):
+                self._validate_comprehension_target(one_comprehension.target)
+        self.generic_visit(ast_node)
+
+    def visit_For(self, ast_node: ast.For) -> None:
+        # Validate target variables in regular for-loops
+        # Apply same unpacking logic as comprehensions
+        # For-loops don't have an expression that references vars
+        if not self._is_partial_unpacking_expr_count(1, ast_node.target):
+            self._validate_comprehension_target(ast_node.target)
+        self.generic_visit(ast_node)
+
+    def visit_GeneratorExp(self, ast_node: ast.GeneratorExp) -> None:
+        # Validate targets in generators (the 'v' in 'for v in lst')
+        for one_comprehension in ast_node.generators:
+            if not self._is_partial_unpacking(ast_node.elt, one_comprehension.target):
+                self._validate_comprehension_target(one_comprehension.target)
+        self.generic_visit(ast_node)
+
+    def _is_partial_unpacking(self, expression: ast.expr, target_node: ast.expr) -> bool:
+        """Check if this is partial unpacking (referencing fewer vars than unpacked)."""
+        return self._is_partial_unpacking_expr_count(self._count_referenced_vars(expression), target_node)
+
+    def _is_partial_unpacking_expr_count(self, expression_count: int, target_node: ast.expr) -> bool:
+        """Check if this is partial unpacking given expression variable count."""
+        target_count: typing.Final = self._count_unpacked_vars(target_node)
+        return target_count > expression_count and target_count > 1
+
+    def _count_referenced_vars(self, expression: ast.expr) -> int:
+        """Count how many variables are referenced in the expression."""
+        if isinstance(expression, ast.Name):
+            return 1
+        if isinstance(expression, ast.Tuple):
+            return len([one_element for one_element in expression.elts if isinstance(one_element, ast.Name)])
+        # For simplicity, assume other expressions reference 1 variable
+        # This covers cases like function calls, attributes, etc.
+        return 1
+
+    def _count_unpacked_vars(self, target_node: ast.expr) -> int:
+        """Count how many variables are unpacked in the target."""
+        if isinstance(target_node, ast.Name):
+            return 1
+        if isinstance(target_node, ast.Tuple):
+            return len([one_element for one_element in target_node.elts if isinstance(one_element, ast.Name)])
+        return 0
+
+    def _validate_comprehension_target(self, target_node: ast.expr) -> None:
+        """Validate that comprehension target follows the one_ prefix rule."""
+        # Skip ignored targets (underscore, unpacking)
+        if _is_ignored_target(target_node):
+            return
+
+        # For simple names, validate the prefix
+        if isinstance(target_node, ast.Name):
+            if not self._has_valid_one_prefix(target_node.id):
+                self.violations.append(
+                    Violation(
+                        line_number=target_node.lineno,
+                        column_number=target_node.col_offset,
+                        violation_code=ViolationCodes.FOR_LOOP_VARIABLE_PREFIX,
+                    )
+                )
+        # For tuples (unpacking), validate each element
+        elif isinstance(target_node, ast.Tuple):
+            for one_element in target_node.elts:
+                if isinstance(one_element, ast.Name) and not self._has_valid_one_prefix(one_element.id):
+                    self.violations.append(
+                        Violation(
+                            line_number=one_element.lineno,
+                            column_number=one_element.col_offset,
+                            violation_code=ViolationCodes.FOR_LOOP_VARIABLE_PREFIX,
+                        )
+                    )
+
+    def _has_valid_one_prefix(self, identifier: str) -> bool:
+        """Check if identifier has valid one_ prefix."""
+        # Allow underscore variables
+        if identifier == "_":
+            return True
+
+        # Check for one_ prefix
+        return identifier.startswith("one_")

{community_of_python_flake8_plugin-0.2.0 → community_of_python_flake8_plugin-0.3.0}/src/community_of_python_flake8_plugin/checks/function_verb.py

@@ -17,7 +17,7 @@ def check_is_ignored_name(identifier: str) -> bool:
 
 
 def check_is_verb_name(identifier: str) -> bool:
-    return any(identifier == verb or identifier.startswith(f"{verb}_") for verb in VERB_PREFIXES)
+    return any(identifier == verb_name or identifier.startswith(f"{verb_name}_") for verb_name in VERB_PREFIXES)
 
 
 def check_is_property(function_node: ast.AST) -> bool:

{community_of_python_flake8_plugin-0.2.0 → community_of_python_flake8_plugin-0.3.0}/src/community_of_python_flake8_plugin/checks/mapping_proxy.py

@@ -17,6 +17,54 @@ def is_mapping_proxy_type(annotation: ast.expr | None) -> bool:
     return False
 
 
+def _get_base_name(annotation_value: ast.expr) -> str:
+    """Extract the base name from an annotation value."""
+    if isinstance(annotation_value, ast.Name):
+        return annotation_value.id
+    if isinstance(annotation_value, ast.Attribute):
+        return annotation_value.attr
+    return ""
+
+
+def is_dict_type_annotation(annotation: ast.expr | None) -> bool:
+    """Check if annotation represents a dict type that should trigger COP013.
+
+    Returns True for:
+    - dict
+    - Final[dict]
+    - dict[key, value]
+    - Final[dict[key, value]]
+
+    Returns False for TypedDict and other non-dict annotations.
+    """
+    is_dict_annotation = False
+
+    if annotation is not None:
+        # Handle simple name annotations like 'dict'
+        if isinstance(annotation, ast.Name):
+            is_dict_annotation = annotation.id == "dict"
+        # Handle attribute annotations like 'typing.Final'
+        elif isinstance(annotation, ast.Attribute):
+            is_dict_annotation = annotation.attr == "dict"
+        # Handle subscript annotations like 'dict[str, int]' or 'Final[dict]'
+        elif isinstance(annotation, ast.Subscript):
+            base_name: typing.Final = _get_base_name(annotation.value)
+            if base_name:
+                # Check for Final[...] annotations
+                if base_name == "Final":
+                    # Extract the inner type from Final[inner_type]
+                    inner_type = annotation.slice
+                    # Handle Python 3.8 vs 3.9+ differences
+                    if hasattr(inner_type, "value"):  # Python 3.8
+                        inner_type = inner_type.value
+                    is_dict_annotation = is_dict_type_annotation(inner_type)
+                # Check for dict[...] annotations
+                elif base_name == "dict":
+                    is_dict_annotation = True
+
+    return is_dict_annotation
+
+
 @typing.final
 class MappingProxyCheck(ast.NodeVisitor):
     def __init__(self, syntax_tree: ast.AST) -> None:  # noqa: ARG002
@@ -33,6 +81,10 @@ class MappingProxyCheck(ast.NodeVisitor):
         if isinstance(ast_node, ast.AnnAssign) and is_mapping_proxy_type(ast_node.annotation):
             return
 
+        # Skip annotated assignments that are not dict-like types
+        if isinstance(ast_node, ast.AnnAssign) and not is_dict_type_annotation(ast_node.annotation):
+            return
+
         # Check for dictionary literals assigned to module-level variables
         assigned_value: ast.expr | None
         assignment_targets: list[ast.expr]

{community_of_python_flake8_plugin-0.2.0 → community_of_python_flake8_plugin-0.3.0}/src/community_of_python_flake8_plugin/checks/name_length.py

@@ -78,6 +78,119 @@ class COP004NameLengthCheck(ast.NodeVisitor):
             self.validate_class_name_length(ast_node)
         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)
+        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)
+        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)
+        self.generic_visit(ast_node)
+
+    def visit_Lambda(self, ast_node: ast.Lambda) -> None:
+        self._validate_function_args(ast_node.args)
+        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)
+        self.generic_visit(ast_node)
+
+    def visit_ExceptHandler(self, ast_node: ast.ExceptHandler) -> None:
+        if ast_node.name is not None:
+            self._validate_except_target(ast_node)
+        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)
+        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)
+
+        if arguments_node.vararg is not None:
+            self._validate_argument_name_length(arguments_node.vararg)
+        if arguments_node.kwarg is not None:
+            self._validate_argument_name_length(arguments_node.kwarg)
+
+    def _validate_argument_name_length(self, argument: ast.arg) -> None:
+        if argument.arg in {"self", "cls"}:
+            return
+        if check_is_ignored_name(argument.arg):
+            return
+        if check_is_whitelisted_annotation(argument.annotation):
+            return
+
+        if len(argument.arg) < MIN_NAME_LENGTH:
+            self.violations.append(
+                Violation(
+                    line_number=argument.lineno,
+                    column_number=argument.col_offset,
+                    violation_code=ViolationCodes.ARGUMENT_NAME_LENGTH,
+                )
+            )
+
+    def _validate_comprehension_target(self, comprehension_target: ast.expr) -> None:
+        if isinstance(comprehension_target, ast.Name):
+            # For comprehension targets, we'll treat them as variables
+            if not check_is_ignored_name(comprehension_target.id) and len(comprehension_target.id) < MIN_NAME_LENGTH:
+                self.violations.append(
+                    Violation(
+                        line_number=comprehension_target.lineno,
+                        column_number=comprehension_target.col_offset,
+                        violation_code=ViolationCodes.VARIABLE_NAME_LENGTH,
+                    )
+                )
+        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)
+
+    def _validate_with_target(self, target_node: ast.expr) -> None:
+        if isinstance(target_node, ast.Name):
+            # For with targets, we'll treat them as variables
+            if not check_is_ignored_name(target_node.id) and len(target_node.id) < MIN_NAME_LENGTH:
+                self.violations.append(
+                    Violation(
+                        line_number=target_node.lineno,
+                        column_number=target_node.col_offset,
+                        violation_code=ViolationCodes.VARIABLE_NAME_LENGTH,
+                    )
+                )
+        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)
+
+    def _validate_except_target(self, ast_node: ast.ExceptHandler) -> None:
+        # For except targets, we'll treat them as variables
+        if (
+            ast_node.name is not None
+            and not check_is_ignored_name(ast_node.name)
+            and len(ast_node.name) < MIN_NAME_LENGTH
+        ):
+            self.violations.append(
+                Violation(
+                    line_number=ast_node.lineno,
+                    column_number=0,  # ast.ExceptHandler doesn't have col_offset
+                    violation_code=ViolationCodes.VARIABLE_NAME_LENGTH,
+                )
+            )
+
     def validate_name_length(self, identifier: str, ast_node: ast.stmt, parent_class: ast.ClassDef | None) -> None:
         if check_is_ignored_name(identifier):
             return

{community_of_python_flake8_plugin-0.2.0 → community_of_python_flake8_plugin-0.3.0}/src/community_of_python_flake8_plugin/checks/temp_var.py

@@ -73,8 +73,8 @@ class TempVarCheck(ast.NodeVisitor):
                 continue
 
             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
+                len([usage_element for usage_element in usages if isinstance(usage_element.ctx, ast.Store)]) == 1
+                and len([usage_element for usage_element in usages if isinstance(usage_element.ctx, ast.Load)]) == 1
                 and variable_name in usage_and_stores[1]
                 and not found_temporary_variable
             ):

{community_of_python_flake8_plugin-0.2.0 → community_of_python_flake8_plugin-0.3.0}/src/community_of_python_flake8_plugin/violation_codes.py

@@ -47,3 +47,8 @@ class ViolationCodes:
     DATACLASS_CONFIG = ViolationCodeItem(
         code="COP014", description="Use dataclasses with kw_only=True, slots=True, frozen=True"
     )
+
+    # For-loop variable prefix violations
+    FOR_LOOP_VARIABLE_PREFIX = ViolationCodeItem(
+        code="COP015", description="For-loop variables must be prefixed with 'one_'"
+    )