flake8_simplify 0.30.0__tar.gz → 0.31.1__tar.gz

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

@@ -1,35 +1,36 @@
 Metadata-Version: 2.4
 Name: flake8_simplify
-Version: 0.30.0
+Version: 0.31.1
 Summary: flake8 plugin which checks for code that can be simplified
 Keywords: flake8
+Author: Martin Thoma
 Author-email: Martin Thoma <info@martin-thoma.de>
-Maintainer-email: Martin Thoma <info@martin-thoma.de>
-Requires-Python: >=3.9.0
-Description-Content-Type: text/markdown
+License-Expression: MIT
+License-File: LICENSE
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Natural Language :: English
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development
 Classifier: Framework :: Flake8
-License-File: LICENSE
 Requires-Dist: flake8>=3.7
+Maintainer: Martin Thoma
+Maintainer-email: Martin Thoma <info@martin-thoma.de>
+Requires-Python: >=3.10
 Project-URL: Homepage, https://github.com/MartinThoma/flake8-simplify
+Description-Content-Type: text/markdown
 
 [![PyPI version](https://badge.fury.io/py/flake8-simplify.svg)](https://badge.fury.io/py/flake8-simplify)
 [![Code on Github](https://img.shields.io/badge/Code-GitHub-brightgreen)](https://github.com/MartinThoma/flake8-simplify)
 [![Actions Status](https://github.com/MartinThoma/flake8-simplify/workflows/Unit%20Tests/badge.svg)](https://github.com/MartinThoma/flake8-simplify/actions)
-[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
 
 # flake8-simplify
 
@@ -43,7 +44,7 @@ Install with `pip`:
 pip install flake8-simplify
 ```
 
-Python 3.9 to 3.13 are supported.
+Python 3.10 to 3.14 are supported.
 
 
 ## Usage
@@ -653,4 +654,3 @@ dict.get(key, None)
 # Good
 dict.get(key)
 ```
-

{flake8_simplify-0.30.0 → flake8_simplify-0.31.1}/README.md

@@ -1,7 +1,6 @@
 [![PyPI version](https://badge.fury.io/py/flake8-simplify.svg)](https://badge.fury.io/py/flake8-simplify)
 [![Code on Github](https://img.shields.io/badge/Code-GitHub-brightgreen)](https://github.com/MartinThoma/flake8-simplify)
 [![Actions Status](https://github.com/MartinThoma/flake8-simplify/workflows/Unit%20Tests/badge.svg)](https://github.com/MartinThoma/flake8-simplify/actions)
-[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
 
 # flake8-simplify
 
@@ -15,7 +14,7 @@ Install with `pip`:
 pip install flake8-simplify
 ```
 
-Python 3.9 to 3.13 are supported.
+Python 3.10 to 3.14 are supported.
 
 
 ## Usage

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.30.0 → flake8_simplify-0.31.1}/flake8_simplify/rules/ast_assign.py

@@ -1,9 +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 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.
 
@@ -36,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)
@@ -48,25 +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)
     ):
-        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
 
@@ -86,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)):
@@ -96,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.30.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