flake8_simplify 0.31.0__tar.gz → 0.31.1__tar.gz

{flake8_simplify-0.31.0 → flake8_simplify-0.31.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flake8_simplify
-Version: 0.31.0
+Version: 0.31.1
 Summary: flake8 plugin which checks for code that can be simplified
 Keywords: flake8
 Author: Martin Thoma

flake8_simplify-0.31.1/flake8_simplify/__init__.py

@@ -0,0 +1,45 @@
+import ast
+import importlib.metadata as importlib_metadata
+from collections.abc import Generator
+from typing import Any
+
+from flake8_simplify.registry import get_rules
+from flake8_simplify.utils import add_meta
+
+
+class Visitor(ast.NodeVisitor):
+    """Run every rule registered for a node type on each node of that type."""
+
+    def __init__(self) -> None:
+        self.errors: list[tuple[int, int, str]] = []
+        self._rules = get_rules()
+
+    def visit(self, node: ast.AST) -> Any:
+        for rule in self._rules.get(type(node), ()):
+            for violation in rule.check(node):
+                self.errors.append(
+                    (
+                        violation.node.lineno,
+                        violation.node.col_offset,
+                        f"{rule.code} {violation.message}",
+                    )
+                )
+        self.generic_visit(node)
+
+
+class Plugin:
+    name = __name__
+    version = importlib_metadata.version(__name__)  # type: ignore
+
+    def __init__(self, tree: ast.AST):
+        self._tree = tree
+
+    def run(self) -> Generator[tuple[int, int, str, type[Any]], None, None]:
+        visitor = Visitor()
+
+        # Add parent
+        add_meta(self._tree)
+        visitor.visit(self._tree)
+
+        for line, col, msg in visitor.errors:
+            yield line, col, msg, type(self)

flake8_simplify-0.31.1/flake8_simplify/registry.py

@@ -0,0 +1,71 @@
+"""
+Registry of all rules.
+
+A rule is a generator function which receives a node of the given type and
+yields a ``Violation`` for every problem it finds. It registers itself with
+the ``rule`` decorator; modules in ``flake8_simplify/rules/`` are discovered
+automatically, so adding a rule never requires touching any other file.
+
+    @rule("SIM120", ast.ClassDef)
+    def get_sim120(node: ast.ClassDef) -> Iterator[Violation]:
+        if ...:
+            yield Violation(node, "Use 'class Foo:' ...")
+"""
+
+import ast
+import functools
+import importlib
+import pkgutil
+from collections import defaultdict
+from collections.abc import Callable, Iterator
+from dataclasses import dataclass
+from typing import Any, NamedTuple
+
+
+class Violation(NamedTuple):
+    """A problem found by a rule, reported at the position of ``node``."""
+
+    node: ast.expr | ast.stmt
+    message: str
+
+
+@dataclass(frozen=True)
+class Rule:
+    code: str
+    node_type: type[ast.AST]
+    check: Callable[[Any], Iterator[Violation]]
+
+
+_RULES: list[Rule] = []
+
+
+def rule(
+    code: str,
+    node_type: type[ast.AST],
+) -> Callable[
+    [Callable[[Any], Iterator[Violation]]],
+    Callable[[Any], Iterator[Violation]],
+]:
+    """Register a function as the check for ``code`` on ``node_type`` nodes."""
+
+    def register(
+        check: Callable[[Any], Iterator[Violation]],
+    ) -> Callable[[Any], Iterator[Violation]]:
+        _RULES.append(Rule(code, node_type, check))
+        return check
+
+    return register
+
+
+@functools.cache
+def get_rules() -> dict[type[ast.AST], list[Rule]]:
+    """Get all rules, grouped by the type of node they check."""
+    from flake8_simplify import rules
+
+    for module in pkgutil.iter_modules(rules.__path__):
+        importlib.import_module(f"{rules.__name__}.{module.name}")
+
+    by_node_type: dict[type[ast.AST], list[Rule]] = defaultdict(list)
+    for registered in _RULES:
+        by_node_type[registered.node_type].append(registered)
+    return by_node_type

{flake8_simplify-0.31.0 → flake8_simplify-0.31.1}/flake8_simplify/rules/ast_assign.py

@@ -1,25 +1,18 @@
 import ast
+from collections.abc import Iterator
 
-from flake8_simplify.utils import Assign, expression_uses_variable, to_source
+from flake8_simplify.registry import Violation, rule
+from flake8_simplify.utils import (
+    expression_uses_variable,
+    get_next_sibling,
+    get_parent,
+    in_same_block,
+    to_source,
+)
 
 
-def _in_same_block(first: ast.stmt, second: ast.stmt) -> bool:
-    """
-    Check that both statements are part of the same statement list.
-
-    Siblings are linked across the fields of a node, so the last statement of
-    ``body`` has the first statement of ``orelse`` as next sibling.
-    """
-    parent = getattr(first, "parent", None)
-    if parent is None:
-        return True
-    for _, value in ast.iter_fields(parent):
-        if isinstance(value, list) and first in value:
-            return second in value
-    return True
-
-
-def get_sim904(node: ast.Assign) -> list[tuple[int, int, str]]:
+@rule("SIM904", ast.Assign)
+def get_sim904(node: ast.Assign) -> Iterator[Violation]:
     """
     Assign values to dictionary directly at initialization.
 
@@ -52,9 +45,8 @@ def get_sim904(node: ast.Assign) -> list[tuple[int, int, str]]:
             ),
         ]
     """
-    RULE = "SIM904 Initialize dictionary '{dict_name}' directly"
-    errors: list[tuple[int, int, str]] = []
-    n2 = node.next_sibling  # type: ignore
+    RULE = "Initialize dictionary '{dict_name}' directly"
+    n2 = get_next_sibling(node)
     if not (
         isinstance(node.value, ast.Dict)
         and isinstance(n2, ast.Assign)
@@ -64,26 +56,20 @@ def get_sim904(node: ast.Assign) -> list[tuple[int, int, str]]:
         and isinstance(n2.targets[0].value, ast.Name)
         and isinstance(node.targets[0], ast.Name)
         and n2.targets[0].value.id == node.targets[0].id
-        and _in_same_block(node, n2)
+        and in_same_block(node, n2)
     ):
-        return errors
+        return
 
     dict_name = to_source(node.targets[0])
     # Capture cases where the assigned value uses another dictionary value
     if expression_uses_variable(n2.value, dict_name):
-        return errors
+        return
 
-    errors.append(
-        (
-            node.lineno,
-            node.col_offset,
-            RULE.format(dict_name=dict_name),
-        )
-    )
-    return errors
+    yield Violation(node, RULE.format(dict_name=dict_name))
 
 
-def get_sim909(node: Assign) -> list[tuple[int, int, str]]:
+@rule("SIM909", ast.Assign)
+def get_sim909(node: ast.Assign) -> Iterator[Violation]:
     """
     Avoid reflexive assignments
 
@@ -103,8 +89,7 @@ def get_sim909(node: Assign) -> list[tuple[int, int, str]]:
             ),
         ]
     """
-    RULE = "SIM909 Remove reflexive assignment '{code}'"
-    errors: list[tuple[int, int, str]] = []
+    RULE = "Remove reflexive assignment '{code}'"
 
     names = []
     if isinstance(node.value, (ast.Name, ast.Subscript, ast.Tuple)):
@@ -113,18 +98,11 @@ def get_sim909(node: Assign) -> list[tuple[int, int, str]]:
         names.append(to_source(target))
 
     if len(names) == len(set(names)):
-        return errors
+        return
 
-    if isinstance(node.parent, ast.ClassDef):
-        return errors
+    if isinstance(get_parent(node), ast.ClassDef):
+        return
 
-    code = to_source(node.orig)
+    code = to_source(node)
 
-    errors.append(
-        (
-            node.lineno,
-            node.col_offset,
-            RULE.format(code=code),
-        )
-    )
-    return errors
+    yield Violation(node, RULE.format(code=code))

{flake8_simplify-0.31.0 → flake8_simplify-0.31.1}/flake8_simplify/rules/ast_bool_op.py

@@ -1,7 +1,8 @@
 import ast
 from collections import defaultdict
+from collections.abc import Iterator
 
-from flake8_simplify.constants import BOOL_CONST_TYPES
+from flake8_simplify.registry import Violation, rule
 from flake8_simplify.utils import (
     _get_duplicated_isinstance_call_by_node,
     is_same_expression,
@@ -9,24 +10,24 @@ from flake8_simplify.utils import (
 )
 
 
+@rule("SIM101", ast.BoolOp)
 def get_sim101(
     node: ast.BoolOp,
-) -> list[tuple[int, int, str]]:
+) -> Iterator[Violation]:
     """Get a positions where the duplicate isinstance problem appears."""
-    errors: list[tuple[int, int, str]] = []
     if not isinstance(node.op, ast.Or):
-        return errors
+        return
 
     RULE = (
-        "SIM101 Multiple isinstance-calls which can be merged into a single "
+        "Multiple isinstance-calls which can be merged into a single "
         "call for variable '{var}'"
     )
     for var in _get_duplicated_isinstance_call_by_node(node):
-        errors.append((node.lineno, node.col_offset, RULE.format(var=var)))
-    return errors
+        yield Violation(node, RULE.format(var=var))
 
 
-def get_sim109(node: ast.BoolOp) -> list[tuple[int, int, str]]:
+@rule("SIM109", ast.BoolOp)
+def get_sim109(node: ast.BoolOp) -> Iterator[Violation]:
     """
     Check if multiple equalities with the same value are combined via "or".
 
@@ -46,9 +47,8 @@ def get_sim109(node: ast.BoolOp) -> list[tuple[int, int, str]]:
                 ],
         )
     """
-    errors: list[tuple[int, int, str]] = []
     if not isinstance(node.op, ast.Or):
-        return errors
+        return
     equalities = [
         value
         for value in node.values
@@ -64,25 +64,22 @@ def get_sim109(node: ast.BoolOp) -> list[tuple[int, int, str]]:
             and isinstance(eq.comparators[0], ast.Name)
         ):
             id2vals[eq.left.id].append(eq.comparators[0])
-    RULE = "SIM109 Use '{value} in {values}' instead of '{or_op}'"
+    RULE = "Use '{value} in {values}' instead of '{or_op}'"
     for value, values in id2vals.items():
         if len(values) == 1:
             continue
-        errors.append(
-            (
-                node.lineno,
-                node.col_offset,
-                RULE.format(
-                    or_op=to_source(node),
-                    value=value,
-                    values=f"({to_source(ast.Tuple(elts=values))})",  # type: ignore
-                ),
-            )
+        yield Violation(
+            node,
+            RULE.format(
+                or_op=to_source(node),
+                value=value,
+                values=f"({to_source(ast.Tuple(elts=values))})",  # type: ignore
+            ),
         )
-    return errors
 
 
-def get_sim220(node: ast.BoolOp) -> list[tuple[int, int, str]]:
+@rule("SIM220", ast.BoolOp)
+def get_sim220(node: ast.BoolOp) -> Iterator[Violation]:
     """
     Get a list of all calls of the type "a and not a".
 
@@ -97,9 +94,8 @@ def get_sim220(node: ast.BoolOp) -> list[tuple[int, int, str]]:
         ],
     )
     """
-    errors: list[tuple[int, int, str]] = []
     if not (isinstance(node.op, ast.And) and len(node.values) >= 2):
-        return errors
+        return
     # We have a boolean And. Let's make sure there is two times the same
     # expression, but once with a "not"
     negated_expressions = []
@@ -110,19 +106,19 @@ def get_sim220(node: ast.BoolOp) -> list[tuple[int, int, str]]:
         else:
             non_negated_expressions.append(exp)
     if len(negated_expressions) == 0:
-        return errors
+        return
 
-    RULE = "SIM220 Use 'False' instead of '{a} and not {a}'"
+    RULE = "Use 'False' instead of '{a} and not {a}'"
     for negated_expression in negated_expressions:
         for non_negated_expression in non_negated_expressions:
             if is_same_expression(negated_expression, non_negated_expression):
                 a = to_source(negated_expression)
-                errors.append((node.lineno, node.col_offset, RULE.format(a=a)))
-                return errors
-    return errors
+                yield Violation(node, RULE.format(a=a))
+                return
 
 
-def get_sim221(node: ast.BoolOp) -> list[tuple[int, int, str]]:
+@rule("SIM221", ast.BoolOp)
+def get_sim221(node: ast.BoolOp) -> Iterator[Violation]:
     """
     Get a list of all calls of the type "a or not a".
 
@@ -137,9 +133,8 @@ def get_sim221(node: ast.BoolOp) -> list[tuple[int, int, str]]:
         ],
     )
     """
-    errors: list[tuple[int, int, str]] = []
     if not (isinstance(node.op, ast.Or) and len(node.values) >= 2):
-        return errors
+        return
     # We have a boolean OR. Let's make sure there is two times the same
     # expression, but once with a "not"
     negated_expressions = []
@@ -150,19 +145,19 @@ def get_sim221(node: ast.BoolOp) -> list[tuple[int, int, str]]:
         else:
             non_negated_expressions.append(exp)
     if len(negated_expressions) == 0:
-        return errors
+        return
 
-    RULE = "SIM221 Use 'True' instead of '{a} or not {a}'"
+    RULE = "Use 'True' instead of '{a} or not {a}'"
     for negated_expression in negated_expressions:
         for non_negated_expression in non_negated_expressions:
             if is_same_expression(negated_expression, non_negated_expression):
                 a = to_source(negated_expression)
-                errors.append((node.lineno, node.col_offset, RULE.format(a=a)))
-                return errors
-    return errors
+                yield Violation(node, RULE.format(a=a))
+                return
 
 
-def get_sim222(node: ast.BoolOp) -> list[tuple[int, int, str]]:
+@rule("SIM222", ast.BoolOp)
+def get_sim222(node: ast.BoolOp) -> Iterator[Violation]:
     """
     Get a list of all calls of the type "... or True".
 
@@ -177,19 +172,18 @@ def get_sim222(node: ast.BoolOp) -> list[tuple[int, int, str]]:
         ],
     )
     """
-    errors: list[tuple[int, int, str]] = []
     if not (isinstance(node.op, ast.Or)):
-        return errors
+        return
 
-    RULE = "SIM222 Use 'True' instead of '... or True'"
+    RULE = "Use 'True' instead of '... or True'"
     for exp in node.values:
-        if isinstance(exp, BOOL_CONST_TYPES) and exp.value is True:
-            errors.append((node.lineno, node.col_offset, RULE))
-            return errors
-    return errors
+        if isinstance(exp, ast.Constant) and exp.value is True:
+            yield Violation(node, RULE)
+            return
 
 
-def get_sim223(node: ast.BoolOp) -> list[tuple[int, int, str]]:
+@rule("SIM223", ast.BoolOp)
+def get_sim223(node: ast.BoolOp) -> Iterator[Violation]:
     """
     Get a list of all calls of the type "... and False".
 
@@ -204,13 +198,11 @@ def get_sim223(node: ast.BoolOp) -> list[tuple[int, int, str]]:
         ],
     )
     """
-    errors: list[tuple[int, int, str]] = []
     if not (isinstance(node.op, ast.And)):
-        return errors
+        return
 
-    RULE = "SIM223 Use 'False' instead of '... and False'"
+    RULE = "Use 'False' instead of '... and False'"
     for exp in node.values:
-        if isinstance(exp, BOOL_CONST_TYPES) and exp.value is False:
-            errors.append((node.lineno, node.col_offset, RULE))
-            return errors
-    return errors
+        if isinstance(exp, ast.Constant) and exp.value is False:
+            yield Violation(node, RULE)
+            return

{flake8_simplify-0.31.0 → flake8_simplify-0.31.1}/flake8_simplify/rules/ast_call.py

@@ -1,14 +1,13 @@
 import ast
 import json
-import logging
+from collections.abc import Iterator
 
-from flake8_simplify.constants import BOOL_CONST_TYPES
-from flake8_simplify.utils import Call, to_source
+from flake8_simplify.registry import Violation, rule
+from flake8_simplify.utils import get_parent, to_source
 
-logger = logging.getLogger(__name__)
 
-
-def get_sim115(node: Call) -> list[tuple[int, int, str]]:
+@rule("SIM115", ast.Call)
+def get_sim115(node: ast.Call) -> Iterator[Violation]:
     """
     Find places where open() is called without a context handler.
 
@@ -36,22 +35,21 @@ def get_sim115(node: Call) -> list[tuple[int, int, str]]:
             ),
         ),
     """
-    RULE = "SIM115 Use context handler for opening files"
-    errors: list[tuple[int, int, str]] = []
+    RULE = "Use context handler for opening files"
     if not (
         isinstance(node.func, ast.Name)
         and node.func.id == "open"
-        and not isinstance(node.parent, ast.withitem)
+        and not isinstance(get_parent(node), ast.withitem)
     ):
-        return errors
-    errors.append((node.lineno, node.col_offset, RULE))
-    return errors
+        return
+    yield Violation(node, RULE)
 
 
 # Experimental rules
 
 
-def get_sim901(node: ast.Call) -> list[tuple[int, int, str]]:
+@rule("SIM901", ast.Call)
+def get_sim901(node: ast.Call) -> Iterator[Violation]:
     """
     Get a list of all calls of the type "bool(comparison)".
 
@@ -67,60 +65,44 @@ def get_sim901(node: ast.Call) -> list[tuple[int, int, str]]:
         keywords=[],
     )
     """
-    RULE = "SIM901 Use '{expected}' instead of '{actual}'"
-    errors: list[tuple[int, int, str]] = []
+    RULE = "Use '{expected}' instead of '{actual}'"
     if not (
         isinstance(node.func, ast.Name)
         and node.func.id == "bool"
         and len(node.args) == 1
         and isinstance(node.args[0], ast.Compare)
     ):
-        return errors
+        return
 
     actual = to_source(node)
     expected = to_source(node.args[0])
 
-    errors.append(
-        (
-            node.lineno,
-            node.col_offset,
-            RULE.format(actual=actual, expected=expected),
-        )
-    )
-    return errors
+    yield Violation(node, RULE.format(actual=actual, expected=expected))
 
 
-def get_sim905(node: ast.Call) -> list[tuple[int, int, str]]:
-    RULE = "SIM905 Use '{expected}' instead of '{actual}'"
-    errors: list[tuple[int, int, str]] = []
+@rule("SIM905", ast.Call)
+def get_sim905(node: ast.Call) -> Iterator[Violation]:
+    RULE = "Use '{expected}' instead of '{actual}'"
     if not (
         isinstance(node.func, ast.Attribute)
         and node.func.attr == "split"
         and isinstance(node.func.value, ast.Constant)
         and isinstance(node.func.value.value, str)
+        and not node.args
+        and not node.keywords
     ):
-        return errors
+        return
 
-    if isinstance(node.func.value, ast.Constant):
-        value = node.func.value.value
-    else:
-        value = node.func.value.value
+    value = node.func.value.value
 
     expected = json.dumps(value.split())
     actual = to_source(node.func.value) + ".split()"
-    errors.append(
-        (
-            node.lineno,
-            node.col_offset,
-            RULE.format(expected=expected, actual=actual),
-        )
-    )
-    return errors
+    yield Violation(node, RULE.format(expected=expected, actual=actual))
 
 
-def get_sim906(node: ast.Call) -> list[tuple[int, int, str]]:
-    RULE = "SIM906 Use '{expected}' instead of '{actual}'"
-    errors: list[tuple[int, int, str]] = []
+@rule("SIM906", ast.Call)
+def get_sim906(node: ast.Call) -> Iterator[Violation]:
+    RULE = "Use '{expected}' instead of '{actual}'"
     if not (
         isinstance(node.func, ast.Attribute)
         and isinstance(node.func.value, ast.Attribute)
@@ -142,7 +124,7 @@ def get_sim906(node: ast.Call) -> list[tuple[int, int, str]]:
             for arg in node.args
         )
     ):
-        return errors
+        return
 
     def get_os_path_join_args(node: ast.Call) -> list[str]:
         names: list[str] = []
@@ -157,31 +139,21 @@ def get_sim906(node: ast.Call) -> list[tuple[int, int, str]]:
                 and arg.func.attr == "join"
             ):
                 names = names + get_os_path_join_args(arg)
-            elif isinstance(arg, ast.Name):
-                names.append(arg.id)
             elif isinstance(arg, ast.Constant) and isinstance(arg.value, str):
-                names.append(f"'{arg.value}'")
+                names.append(repr(arg.value))
             else:
-                logger.debug(
-                    f"Unexpected os.path.join arg: {arg} -- {to_source(arg)}"
-                )
+                names.append(to_source(arg))
         return names
 
     names = get_os_path_join_args(node)
 
     actual = to_source(node)
     expected = f"os.path.join({', '.join(names)})"
-    errors.append(
-        (
-            node.lineno,
-            node.col_offset,
-            RULE.format(actual=actual, expected=expected),
-        )
-    )
-    return errors
+    yield Violation(node, RULE.format(actual=actual, expected=expected))
 
 
-def get_sim910(node: Call) -> list[tuple[int, int, str]]:
+@rule("SIM910", ast.Call)
+def get_sim910(node: ast.Call) -> Iterator[Violation]:
     """
     Get a list of all usages of "dict.get(key, None)"
 
@@ -202,38 +174,31 @@ def get_sim910(node: Call) -> list[tuple[int, int, str]]:
             ),
         ),
     """
-    RULE = "SIM910 Use '{expected}' instead of '{actual}'"
-    errors: list[tuple[int, int, str]] = []
+    RULE = "Use '{expected}' instead of '{actual}'"
     if not (
         isinstance(node.func, ast.Attribute)
         and node.func.attr == "get"
         and isinstance(node.func.ctx, ast.Load)
     ):
-        return errors
+        return
 
     # check the argument value
     if not (
         len(node.args) == 2
-        and isinstance(node.args[1], BOOL_CONST_TYPES)
+        and isinstance(node.args[1], ast.Constant)
         and node.args[1].value is None
     ):
-        return errors
+        return
 
     actual = to_source(node)
     func = to_source(node.func)
     key = to_source(node.args[0])
     expected = f"{func}({key})"
-    errors.append(
-        (
-            node.lineno,
-            node.col_offset,
-            RULE.format(actual=actual, expected=expected),
-        )
-    )
-    return errors
+    yield Violation(node, RULE.format(actual=actual, expected=expected))
 
 
-def get_sim911(node: ast.AST) -> list[tuple[int, int, str]]:
+@rule("SIM911", ast.Call)
+def get_sim911(node: ast.AST) -> Iterator[Violation]:
     """
     Find nodes representing the expression "zip(_.keys(), _.values())".
 
@@ -267,10 +232,8 @@ def get_sim911(node: ast.AST) -> list[tuple[int, int, str]]:
         )
     """
     RULE = (
-        "SIM911 Use '{name}.items()' instead of "
-        "'zip({name}.keys(), {name}.values())'"
+        "Use '{name}.items()' instead of 'zip({name}.keys(), {name}.values())'"
     )
-    errors: list[tuple[int, int, str]] = []
 
     if isinstance(node, ast.Call) and (
         isinstance(node.func, ast.Name)
@@ -289,11 +252,4 @@ def get_sim911(node: ast.AST) -> list[tuple[int, int, str]]:
             and second_arg.func.attr == "values"
             and first_arg.func.value.id == second_arg.func.value.id
         ):
-            errors.append(
-                (
-                    node.lineno,
-                    node.col_offset,
-                    RULE.format(name=first_arg.func.value.id),
-                )
-            )
-    return errors
+            yield Violation(node, RULE.format(name=first_arg.func.value.id))