flake8_simplify 0.20.0__py3-none-any.whl

flake8_simplify/__init__.py

@@ -0,0 +1,177 @@
+# Core Library
+import ast
+import logging
+import sys
+from typing import Any, Generator, List, Tuple, Type
+
+# First party
+from flake8_simplify.rules.ast_assign import get_sim904, get_sim909
+from flake8_simplify.rules.ast_bool_op import (
+    get_sim101,
+    get_sim109,
+    get_sim220,
+    get_sim221,
+    get_sim222,
+    get_sim223,
+)
+from flake8_simplify.rules.ast_call import (
+    get_sim115,
+    get_sim901,
+    get_sim905,
+    get_sim906,
+    get_sim910,
+)
+from flake8_simplify.rules.ast_classdef import get_sim120
+from flake8_simplify.rules.ast_compare import get_sim118, get_sim300
+from flake8_simplify.rules.ast_expr import get_sim112
+from flake8_simplify.rules.ast_for import (
+    get_sim104,
+    get_sim110_sim111,
+    get_sim113,
+)
+from flake8_simplify.rules.ast_if import (
+    get_sim102,
+    get_sim103,
+    get_sim108,
+    get_sim114,
+    get_sim116,
+    get_sim401,
+    get_sim908,
+)
+from flake8_simplify.rules.ast_ifexp import get_sim210, get_sim211, get_sim212
+from flake8_simplify.rules.ast_subscript import get_sim907
+from flake8_simplify.rules.ast_try import get_sim105, get_sim107
+from flake8_simplify.rules.ast_unary_op import (
+    get_sim201,
+    get_sim202,
+    get_sim203,
+    get_sim208,
+)
+from flake8_simplify.rules.ast_with import get_sim117
+from flake8_simplify.utils import Assign, Call, For, If, UnaryOp
+
+logger = logging.getLogger(__name__)
+
+
+if sys.version_info < (3, 8):  # pragma: no cover (<PY38)
+    # Third party
+    import importlib_metadata
+else:  # pragma: no cover (PY38+)
+    # Core Library
+    import importlib.metadata as importlib_metadata
+
+
+class Visitor(ast.NodeVisitor):
+    def __init__(self) -> None:
+        self.errors: List[Tuple[int, int, str]] = []
+
+    def visit_Assign(self, node: ast.Assign) -> Any:
+        self.errors += get_sim904(node)
+        self.errors += get_sim909(Assign(node))
+        self.generic_visit(node)
+
+    def visit_Call(self, node: ast.Call) -> Any:
+        self.errors += get_sim115(Call(node))
+        self.errors += get_sim901(node)
+        self.errors += get_sim905(node)
+        self.errors += get_sim906(node)
+        self.errors += get_sim910(Call(node))
+        self.generic_visit(node)
+
+    def visit_With(self, node: ast.With) -> Any:
+        self.errors += get_sim117(node)
+        self.generic_visit(node)
+
+    def visit_Expr(self, node: ast.Expr) -> None:
+        self.errors += get_sim112(node)
+        self.generic_visit(node)
+
+    def visit_BoolOp(self, node: ast.BoolOp) -> None:
+        self.errors += get_sim101(node)
+        self.errors += get_sim109(node)
+        self.errors += get_sim220(node)
+        self.errors += get_sim221(node)
+        self.errors += get_sim222(node)
+        self.errors += get_sim223(node)
+        self.generic_visit(node)
+
+    def visit_If(self, node: ast.If) -> None:
+        self.errors += get_sim102(node)
+        self.errors += get_sim103(node)
+        self.errors += get_sim108(If(node))
+        self.errors += get_sim114(node)
+        self.errors += get_sim116(node)
+        self.errors += get_sim908(node)
+        self.errors += get_sim401(node)
+        self.generic_visit(node)
+
+    def visit_For(self, node: ast.For) -> None:
+        self.errors += get_sim104(node)
+        self.errors += get_sim110_sim111(node)
+        self.errors += get_sim113(For(node))
+        self.generic_visit(node)
+
+    def visit_Subscript(self, node: ast.Subscript) -> None:
+        self.errors += get_sim907(node)
+        self.generic_visit(node)
+
+    def visit_Try(self, node: ast.Try) -> None:
+        self.errors += get_sim105(node)
+        self.errors += get_sim107(node)
+        self.generic_visit(node)
+
+    def visit_UnaryOp(self, node_v: ast.UnaryOp) -> None:
+        node = UnaryOp(node_v)
+        self.errors += get_sim201(node)
+        self.errors += get_sim202(node)
+        self.errors += get_sim203(node)
+        self.errors += get_sim208(node)
+        self.generic_visit(node)
+
+    def visit_IfExp(self, node: ast.IfExp) -> None:
+        self.errors += get_sim210(node)
+        self.errors += get_sim211(node)
+        self.errors += get_sim212(node)
+        self.generic_visit(node)
+
+    def visit_Compare(self, node: ast.Compare) -> None:
+        self.errors += get_sim118(node)
+        self.errors += get_sim300(node)
+        self.generic_visit(node)
+
+    def visit_ClassDef(self, node: ast.ClassDef) -> None:
+        self.errors += get_sim120(node)
+        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)
+
+
+def add_meta(root: ast.AST, level: int = 0) -> None:
+    previous_sibling = None
+    for node in ast.iter_child_nodes(root):
+        if level == 0:
+            node.parent = root  # type: ignore
+        node.previous_sibling = previous_sibling  # type: ignore
+        node.next_sibling = None  # type: ignore
+        if previous_sibling:
+            node.previous_sibling.next_sibling = node  # type: ignore
+        previous_sibling = node
+        for child in ast.iter_child_nodes(node):
+            child.parent = node  # type: ignore
+        add_meta(node, level=level + 1)

flake8_simplify/constants.py

@@ -0,0 +1,7 @@
+# Core Library
+import ast
+
+# ast.Constant in Python 3.8, ast.NameConstant in Python 3.6 and 3.7
+BOOL_CONST_TYPES = (ast.Constant, ast.NameConstant)
+AST_CONST_TYPES = (ast.Constant, ast.NameConstant, ast.Str, ast.Num)
+STR_TYPES = (ast.Constant, ast.Str)

flake8_simplify/rules/ast_assign.py

@@ -0,0 +1,116 @@
+# Core Library
+import ast
+from typing import List, Tuple
+
+# First party
+from flake8_simplify.utils import Assign, expression_uses_variable, to_source
+
+
+def get_sim904(node: ast.Assign) -> List[Tuple[int, int, str]]:
+    """
+    Assign values to dictionary directly at initialization.
+
+    Example
+    -------
+    Code:
+        # Bad
+        a = { }
+        a['b] = 'c'
+
+        # Good
+        a = {'b': 'c'}
+    Bad AST:
+        [
+            Assign(
+                targets=[Name(id='a', ctx=Store())],
+                value=Dict(keys=[], values=[]),
+                type_comment=None,
+            ),
+            Assign(
+                targets=[
+                    Subscript(
+                        value=Name(id='a', ctx=Load()),
+                        slice=Constant(value='b', kind=None),
+                        ctx=Store(),
+                    ),
+                ],
+                value=Constant(value='c', kind=None),
+                type_comment=None,
+            ),
+        ]
+    """
+    RULE = "SIM904 Initialize dictionary '{dict_name}' directly"
+    errors: List[Tuple[int, int, str]] = []
+    n2 = node.next_sibling  # type: ignore
+    if not (
+        isinstance(node.value, ast.Dict)
+        and isinstance(n2, ast.Assign)
+        and len(n2.targets) == 1
+        and len(node.targets) == 1
+        and isinstance(n2.targets[0], ast.Subscript)
+        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
+    ):
+        return errors
+
+    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
+
+    errors.append(
+        (
+            node.lineno,
+            node.col_offset,
+            RULE.format(dict_name=dict_name),
+        )
+    )
+    return errors
+
+
+def get_sim909(node: Assign) -> List[Tuple[int, int, str]]:
+    """
+    Avoid reflexive assignments
+
+    Example
+    -------
+    Code:
+        # Bad
+        foo = foo
+
+        # Good: Just remove them
+    Bad AST:
+        [
+            Assign(
+                targets=[Name(id='foo', ctx=Store())],
+                value=Name(id='foo', ctx=Load()),
+                type_comment=None,
+            ),
+        ]
+    """
+    RULE = "SIM909 Remove reflexive assignment '{code}'"
+    errors: List[Tuple[int, int, str]] = []
+
+    names = []
+    if isinstance(node.value, (ast.Name, ast.Subscript, ast.Tuple)):
+        names.append(to_source(node.value))
+    for target in node.targets:
+        names.append(to_source(target))
+
+    if len(names) == len(set(names)):
+        return errors
+
+    if isinstance(node.parent, ast.ClassDef):
+        return errors
+
+    code = to_source(node.orig)
+
+    errors.append(
+        (
+            node.lineno,
+            node.col_offset,
+            RULE.format(code=code),
+        )
+    )
+    return errors

flake8_simplify/rules/ast_bool_op.py

@@ -0,0 +1,219 @@
+# Core Library
+import ast
+from collections import defaultdict
+from typing import Dict, List, Tuple
+
+# First party
+from flake8_simplify.constants import BOOL_CONST_TYPES
+from flake8_simplify.utils import (
+    _get_duplicated_isinstance_call_by_node,
+    is_same_expression,
+    to_source,
+)
+
+
+def get_sim101(
+    node: ast.BoolOp,
+) -> List[Tuple[int, int, str]]:
+    """Get a positions where the duplicate isinstance problem appears."""
+    errors: List[Tuple[int, int, str]] = []
+    if not isinstance(node.op, ast.Or):
+        return errors
+
+    RULE = (
+        "SIM101 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
+
+
+def get_sim109(node: ast.BoolOp) -> List[Tuple[int, int, str]]:
+    """
+    Check if multiple equalities with the same value are combined via "or".
+
+        BoolOp(
+                op=Or(),
+                values=[
+                    Compare(
+                        left=Name(id='a', ctx=Load()),
+                        ops=[Eq()],
+                        comparators=[Name(id='b', ctx=Load())],
+                    ),
+                    Compare(
+                        left=Name(id='a', ctx=Load()),
+                        ops=[Eq()],
+                        comparators=[Name(id='c', ctx=Load())],
+                    ),
+                ],
+        )
+    """
+    errors: List[Tuple[int, int, str]] = []
+    if not isinstance(node.op, ast.Or):
+        return errors
+    equalities = [
+        value
+        for value in node.values
+        if isinstance(value, ast.Compare)
+        and len(value.ops) == 1
+        and isinstance(value.ops[0], ast.Eq)
+    ]
+    id2vals: Dict[str, List[ast.Name]] = defaultdict(list)
+    for eq in equalities:
+        if (
+            isinstance(eq.left, ast.Name)
+            and len(eq.comparators) == 1
+            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}'"
+    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))})",
+                ),
+            )
+        )
+    return errors
+
+
+def get_sim220(node: ast.BoolOp) -> List[Tuple[int, int, str]]:
+    """
+    Get a list of all calls of the type "a and not a".
+
+    BoolOp(
+        op=And(),
+        values=[
+            Name(id='a', ctx=Load()),
+            UnaryOp(
+                op=Not(),
+                operand=Name(id='a', ctx=Load()),
+            ),
+        ],
+    )
+    """
+    errors: List[Tuple[int, int, str]] = []
+    if not (isinstance(node.op, ast.And) and len(node.values) >= 2):
+        return errors
+    # We have a boolean And. Let's make sure there is two times the same
+    # expression, but once with a "not"
+    negated_expressions = []
+    non_negated_expressions = []
+    for exp in node.values:
+        if isinstance(exp, ast.UnaryOp) and isinstance(exp.op, ast.Not):
+            negated_expressions.append(exp.operand)
+        else:
+            non_negated_expressions.append(exp)
+    if len(negated_expressions) == 0:
+        return errors
+
+    RULE = "SIM220 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
+
+
+def get_sim221(node: ast.BoolOp) -> List[Tuple[int, int, str]]:
+    """
+    Get a list of all calls of the type "a or not a".
+
+    BoolOp(
+        op=Or(),
+        values=[
+            Name(id='a', ctx=Load()),
+            UnaryOp(
+                op=Not(),
+                operand=Name(id='a', ctx=Load()),
+            ),
+        ],
+    )
+    """
+    errors: List[Tuple[int, int, str]] = []
+    if not (isinstance(node.op, ast.Or) and len(node.values) >= 2):
+        return errors
+    # We have a boolean OR. Let's make sure there is two times the same
+    # expression, but once with a "not"
+    negated_expressions = []
+    non_negated_expressions = []
+    for exp in node.values:
+        if isinstance(exp, ast.UnaryOp) and isinstance(exp.op, ast.Not):
+            negated_expressions.append(exp.operand)
+        else:
+            non_negated_expressions.append(exp)
+    if len(negated_expressions) == 0:
+        return errors
+
+    RULE = "SIM221 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
+
+
+def get_sim222(node: ast.BoolOp) -> List[Tuple[int, int, str]]:
+    """
+    Get a list of all calls of the type "... or True".
+
+    BoolOp(
+        op=Or(),
+        values=[
+            Name(id='a', ctx=Load()),
+            UnaryOp(
+                op=Not(),
+                operand=Name(id='a', ctx=Load()),
+            ),
+        ],
+    )
+    """
+    errors: List[Tuple[int, int, str]] = []
+    if not (isinstance(node.op, ast.Or)):
+        return errors
+
+    RULE = "SIM222 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
+
+
+def get_sim223(node: ast.BoolOp) -> List[Tuple[int, int, str]]:
+    """
+    Get a list of all calls of the type "... and False".
+
+    BoolOp(
+        op=And(),
+        values=[
+            Name(id='a', ctx=Load()),
+            UnaryOp(
+                op=Not(),
+                operand=Name(id='a', ctx=Load()),
+            ),
+        ],
+    )
+    """
+    errors: List[Tuple[int, int, str]] = []
+    if not (isinstance(node.op, ast.And)):
+        return errors
+
+    RULE = "SIM223 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