flake8_simplify 0.20.0__py3-none-any.whl

flake8_simplify/rules/ast_call.py

@@ -0,0 +1,235 @@
+# Core Library
+import ast
+import json
+import logging
+from typing import List, Tuple
+
+# First party
+from flake8_simplify.constants import BOOL_CONST_TYPES
+from flake8_simplify.utils import Call, to_source
+
+logger = logging.getLogger(__name__)
+
+
+def get_sim115(node: Call) -> List[Tuple[int, int, str]]:
+    """
+    Find places where open() is called without a context handler.
+
+    Example AST
+    -----------
+        Assign(
+            targets=[Name(id='f', ctx=Store())],
+            value=Call(
+                func=Name(id='open', ctx=Load()),
+                args=[Constant(value=Ellipsis, kind=None)],
+                keywords=[],
+            ),
+            type_comment=None,
+        )
+        ...
+        Expr(
+            value=Call(
+                func=Attribute(
+                    value=Name(id='f', ctx=Load()),
+                    attr='close',
+                    ctx=Load(),
+                ),
+                args=[],
+                keywords=[],
+            ),
+        ),
+    """
+    RULE = "SIM115 Use context handler for opening files"
+    errors: List[Tuple[int, int, str]] = []
+    if not (
+        isinstance(node.func, ast.Name)
+        and node.func.id == "open"
+        and not isinstance(node.parent, ast.withitem)
+    ):
+        return errors
+    errors.append((node.lineno, node.col_offset, RULE))
+    return errors
+
+
+# Experimental rules
+
+
+def get_sim901(node: ast.Call) -> List[Tuple[int, int, str]]:
+    """
+    Get a list of all calls of the type "bool(comparison)".
+
+    Call(
+        func=Name(id='bool', ctx=Load()),
+        args=[
+            Compare(
+                left=Name(id='a', ctx=Load()),
+                ops=[Eq()],
+                comparators=[Name(id='b', ctx=Load())],
+            ),
+        ],
+        keywords=[],
+    )
+    """
+    RULE = "SIM901 Use '{expected}' instead of '{actual}'"
+    errors: List[Tuple[int, int, str]] = []
+    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
+
+    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
+
+
+def get_sim905(node: ast.Call) -> List[Tuple[int, int, str]]:
+    RULE = "SIM905 Use '{expected}' instead of '{actual}'"
+    errors: List[Tuple[int, int, str]] = []
+    if not (
+        isinstance(node.func, ast.Attribute)
+        and node.func.attr == "split"
+        and isinstance(node.func.value, (ast.Str, ast.Constant))
+    ):
+        return errors
+
+    if isinstance(node.func.value, ast.Constant):
+        value = node.func.value.value
+    else:
+        value = node.func.value.s
+
+    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
+
+
+def get_sim906(node: ast.Call) -> List[Tuple[int, int, str]]:
+    RULE = "SIM906 Use '{expected}' instead of '{actual}'"
+    errors: List[Tuple[int, int, str]] = []
+    if not (
+        isinstance(node.func, ast.Attribute)
+        and isinstance(node.func.value, ast.Attribute)
+        and isinstance(node.func.value.value, ast.Name)
+        and node.func.value.value.id == "os"
+        and node.func.value.attr == "path"
+        and node.func.attr == "join"
+        and len(node.args) == 2
+        and any(
+            (
+                isinstance(arg, ast.Call)
+                and isinstance(arg.func, ast.Attribute)
+                and isinstance(arg.func.value, ast.Attribute)
+                and isinstance(arg.func.value.value, ast.Name)
+                and arg.func.value.value.id == "os"
+                and arg.func.value.attr == "path"
+                and arg.func.attr == "join"
+            )
+            for arg in node.args
+        )
+    ):
+        return errors
+
+    def get_os_path_join_args(node: ast.Call) -> List[str]:
+        names: List[str] = []
+        for arg in node.args:
+            if (
+                isinstance(arg, ast.Call)
+                and isinstance(arg.func, ast.Attribute)
+                and isinstance(arg.func.value, ast.Attribute)
+                and isinstance(arg.func.value.value, ast.Name)
+                and arg.func.value.value.id == "os"
+                and arg.func.value.attr == "path"
+                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.Str):
+                names.append(f"'{arg.s}'")
+            else:
+                logger.debug(
+                    f"Unexpected os.path.join arg: {arg} -- {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
+
+
+def get_sim910(node: Call) -> List[Tuple[int, int, str]]:
+    """
+    Get a list of all usages of "dict.get(key, None)"
+
+    Example AST
+    -----------
+        Expr(
+            value=Call(
+                func=Attribute(
+                    value=Name(id='a_dict', ctx=Load()),
+                    attr='get',
+                    ctx=Load()
+                ),
+                args=[
+                    Name(id='key', ctx=Load()),
+                    Constant(value=None)
+                ],
+                keywords=[]
+            ),
+        ),
+    """
+    RULE = "SIM910 Use '{expected}' instead of '{actual}'"
+    errors: List[Tuple[int, int, str]] = []
+    if not (
+        isinstance(node.func, ast.Attribute)
+        and node.func.attr == "get"
+        and isinstance(node.func.ctx, ast.Load)
+    ):
+        return errors
+
+    # check the argument value
+    if not (
+        len(node.args) == 2
+        and isinstance(node.args[1], BOOL_CONST_TYPES)
+        and node.args[1].value is None
+    ):
+        return errors
+
+    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

flake8_simplify/rules/ast_classdef.py

@@ -0,0 +1,24 @@
+# Core Library
+import ast
+from typing import List, Tuple
+
+
+def get_sim120(node: ast.ClassDef) -> List[Tuple[int, int, str]]:
+    """
+    Get a list of all classes that inherit from object.
+    """
+    RULE = (
+        "SIM120 Use 'class {classname}:' "
+        "instead of 'class {classname}(object):'"
+    )
+    errors: List[Tuple[int, int, str]] = []
+    if not (
+        len(node.bases) == 1
+        and isinstance(node.bases[0], ast.Name)
+        and node.bases[0].id == "object"
+    ):
+        return errors
+    errors.append(
+        (node.lineno, node.col_offset, RULE.format(classname=node.name))
+    )
+    return errors

flake8_simplify/rules/ast_compare.py

@@ -0,0 +1,90 @@
+# Core Library
+import ast
+from typing import List, Tuple
+
+# First party
+from flake8_simplify.constants import AST_CONST_TYPES
+from flake8_simplify.utils import to_source
+
+
+def get_sim118(node: ast.Compare) -> List[Tuple[int, int, str]]:
+    """
+    Get a list of all usages of "key in dict.keys()"
+
+    Compare(left=Name(id='key', ctx=Load()),
+            ops=[In()],
+            comparators=[
+                Call(
+                    func=Attribute(
+                        value=Name(id='dict', ctx=Load()),
+                        attr='keys',
+                        ctx=Load(),
+                    ),
+                    args=[],
+                    keywords=[],
+                ),
+            ],
+        )
+    """
+    RULE = "SIM118 Use '{el} in {dict}' instead of '{el} in {dict}.keys()'"
+    errors: List[Tuple[int, int, str]] = []
+    if not (
+        len(node.ops) == 1
+        and isinstance(node.ops[0], ast.In)
+        and len(node.comparators) == 1
+    ):
+        return errors
+    call_node = node.comparators[0]
+    if not isinstance(call_node, ast.Call):
+        return errors
+
+    attr_node = call_node.func
+    if not (
+        isinstance(call_node.func, ast.Attribute)
+        and call_node.func.attr == "keys"
+        and isinstance(call_node.func.ctx, ast.Load)
+    ):
+        return errors
+    assert isinstance(attr_node, ast.Attribute), "hint for mypy"  # noqa
+
+    key_str = to_source(node.left)
+    dict_str = to_source(attr_node.value)
+    errors.append(
+        (
+            node.lineno,
+            node.col_offset,
+            RULE.format(el=key_str, dict=dict_str),
+        )
+    )
+    return errors
+
+
+def get_sim300(node: ast.Compare) -> List[Tuple[int, int, str]]:
+    """
+    Get a list of all Yoda conditions.
+
+    Compare(
+                left=Constant(value='Yoda', kind=None),
+                ops=[Eq()],
+                comparators=[Name(id='i_am', ctx=Load())],
+            )
+    """
+
+    RULE = (
+        "SIM300 Use '{right} == {left}' instead of "
+        "'{left} == {right}' (Yoda-conditions)"
+    )
+    errors: List[Tuple[int, int, str]] = []
+    if not (
+        isinstance(node.left, AST_CONST_TYPES)
+        and len(node.ops) == 1
+        and isinstance(node.ops[0], ast.Eq)
+    ):
+        return errors
+
+    left = to_source(node.left)
+    right = to_source(node.comparators[0])
+    errors.append(
+        (node.lineno, node.col_offset, RULE.format(left=left, right=right))
+    )
+    return errors

flake8_simplify/rules/ast_expr.py

@@ -0,0 +1,103 @@
+# Core Library
+import ast
+from typing import List, Tuple
+
+# First party
+from flake8_simplify.constants import STR_TYPES
+from flake8_simplify.utils import to_source
+
+
+def get_sim112(node: ast.Expr) -> List[Tuple[int, int, str]]:
+    """
+    Find non-capitalized calls to environment variables.
+
+    os.environ["foo"]
+        Expr(
+            value=Subscript(
+                value=Attribute(
+                    value=Name(id='os', ctx=Load()),
+                    attr='environ',
+                    ctx=Load(),
+                ),
+                slice=Index(
+                    value=Constant(value='foo', kind=None),
+                ),
+                ctx=Load(),
+            ),
+        ),
+    """
+    RULE = "SIM112 Use '{expected}' instead of '{original}'"
+    errors: List[Tuple[int, int, str]] = []
+
+    is_index_call = (
+        isinstance(node.value, ast.Subscript)
+        and isinstance(node.value.value, ast.Attribute)
+        and isinstance(node.value.value.value, ast.Name)
+        and node.value.value.value.id == "os"
+        and node.value.value.attr == "environ"
+        and (
+            (
+                isinstance(node.value.slice, ast.Index)
+                and isinstance(node.value.slice.value, STR_TYPES)  # type: ignore  # noqa
+            )
+            or isinstance(node.value.slice, ast.Constant)
+        )
+    )
+    if is_index_call:
+        subscript = node.value
+        assert isinstance(subscript, ast.Subscript), "hint for mypy"  # noqa
+        slice_ = subscript.slice
+        if isinstance(slice_, ast.Index):
+            # Python < 3.9
+            string_part = slice_.value  # type: ignore
+            assert isinstance(string_part, STR_TYPES), "hint for mypy"  # noqa
+            env_name = to_source(string_part)
+        elif isinstance(slice_, ast.Constant):
+            # Python 3.9
+            env_name = to_source(slice_)
+
+        # Check if this has a change
+        has_change = env_name != env_name.upper()
+
+    is_get_call = (
+        isinstance(node.value, ast.Call)
+        and isinstance(node.value.func, ast.Attribute)
+        and isinstance(node.value.func.value, ast.Attribute)
+        and isinstance(node.value.func.value.value, ast.Name)
+        and node.value.func.value.value.id == "os"
+        and node.value.func.value.attr == "environ"
+        and node.value.func.attr == "get"
+        and len(node.value.args) in [1, 2]
+        and isinstance(node.value.args[0], STR_TYPES)
+    )
+    if is_get_call:
+        call = node.value
+        assert isinstance(call, ast.Call), "hint for mypy"  # noqa
+        string_part = call.args[0]
+        assert isinstance(string_part, STR_TYPES), "hint for mypy"  # noqa
+        env_name = to_source(string_part)
+        # Check if this has a change
+        has_change = env_name != env_name.upper()
+    if not (is_index_call or is_get_call) or not has_change:
+        return errors
+    if is_index_call:
+        original = to_source(node)
+        expected = f"os.environ[{env_name.upper()}]"
+    elif is_get_call:
+        original = to_source(node)
+        if len(node.value.args) == 1:  # type: ignore
+            expected = f"os.environ.get({env_name.upper()})"
+        else:
+            assert isinstance(node.value, ast.Call), "hint for mypy"  # noqa
+            default_value = to_source(node.value.args[1])
+            expected = f"os.environ.get({env_name.upper()}, {default_value})"
+    else:
+        return errors
+    errors.append(
+        (
+            node.lineno,
+            node.col_offset,
+            RULE.format(original=original, expected=expected),
+        )
+    )
+    return errors

flake8_simplify/rules/ast_for.py

@@ -0,0 +1,207 @@
+# Core Library
+import ast
+from typing import List, Tuple
+
+# First party
+from flake8_simplify.constants import BOOL_CONST_TYPES
+from flake8_simplify.utils import (
+    For,
+    body_contains_continue,
+    is_constant_increase,
+    to_source,
+)
+
+
+def get_sim104(node: ast.For) -> List[Tuple[int, int, str]]:
+    """
+    Get a list of all "iterate and yield" patterns.
+
+    for item in iterable:
+        yield item
+
+    which is
+
+        For(
+            target=Name(id='item', ctx=Store()),
+            iter=Name(id='iterable', ctx=Load()),
+            body=[
+                Expr(
+                    value=Yield(
+                        value=Name(id='item', ctx=Load()),
+                    ),
+                ),
+            ],
+            orelse=[],
+            type_comment=None,
+        ),
+
+    """
+    RULE = "SIM104 Use 'yield from {iterable}'"
+    errors: List[Tuple[int, int, str]] = []
+    if (
+        len(node.body) != 1
+        or not isinstance(node.body[0], ast.Expr)
+        or not isinstance(node.body[0].value, ast.Yield)
+        or not isinstance(node.target, ast.Name)
+        or not isinstance(node.body[0].value.value, ast.Name)
+        or node.target.id != node.body[0].value.value.id
+        or node.orelse != []
+    ):
+        return errors
+
+    parent = getattr(node, "parent", None)
+    while (parent
+           and hasattr(parent, "parent")
+           and parent.parent is not parent
+           and not isinstance(parent, ast.AsyncFunctionDef)):
+        parent = getattr(parent, "parent", None)
+
+    if isinstance(parent, ast.AsyncFunctionDef):  # type: ignore
+        return errors
+    iterable = to_source(node.iter)
+    errors.append(
+        (node.lineno, node.col_offset, RULE.format(iterable=iterable))
+    )
+    return errors
+
+
+def get_sim110_sim111(node: ast.For) -> List[Tuple[int, int, str]]:
+    """
+    Check if any / all could be used.
+
+    For(
+        target=Name(id='x', ctx=Store()),
+        iter=Name(id='iterable', ctx=Load()),
+        body=[
+            If(
+                test=Call(
+                    func=Name(id='check', ctx=Load()),
+                    args=[Name(id='x', ctx=Load())],
+                    keywords=[],
+                ),
+                body=[
+                    Return(
+                        value=Constant(value=True, kind=None),
+                    ),
+                ],
+                orelse=[],
+            ),
+        ],
+        orelse=[],
+        type_comment=None,
+    ),
+    Return(value=Constant(value=False, kind=None))
+    """
+    SIM110 = "SIM110 Use 'return any({check} for {target} in {iterable})'"
+    SIM111 = "SIM111 Use 'return all({check} for {target} in {iterable})'"
+    errors: List[Tuple[int, int, str]] = []
+    if not (
+        len(node.body) == 1
+        and isinstance(node.body[0], ast.If)
+        and len(node.body[0].body) == 1
+        and isinstance(node.body[0].body[0], ast.Return)
+        and isinstance(node.body[0].body[0].value, BOOL_CONST_TYPES)
+    ):
+        return errors
+    if not hasattr(node.body[0].body[0].value, "value"):
+        return errors
+    if not isinstance(node.next_sibling, ast.Return):  # type: ignore
+        return errors
+    check = to_source(node.body[0].test)
+    target = to_source(node.target)
+    iterable = to_source(node.iter)
+    if node.body[0].body[0].value.value is True:
+        errors.append(
+            (
+                node.lineno,
+                node.col_offset,
+                SIM110.format(check=check, target=target, iterable=iterable),
+            )
+        )
+    elif node.body[0].body[0].value.value is False:
+        is_compound_expression = " and " in check or " or " in check
+
+        if is_compound_expression:
+            check = f"not ({check})"
+        else:
+            if check.startswith("not "):
+                check = check[len("not ") :]
+            else:
+                check = f"not {check}"
+        errors.append(
+            (
+                node.lineno,
+                node.col_offset,
+                SIM111.format(check=check, target=target, iterable=iterable),
+            )
+        )
+    return errors
+
+
+def get_sim113(node: For) -> List[Tuple[int, int, str]]:
+    """
+    Find loops in which "enumerate" should be used.
+
+        For(
+            target=Name(id='el', ctx=Store()),
+            iter=Name(id='iterable', ctx=Load()),
+            body=[
+                Expr(
+                    value=Constant(value=Ellipsis, kind=None),
+                ),
+                AugAssign( -- argument and assign, aka "+= 1"
+                    target=Name(id='idx', ctx=Store()),
+                    op=Add(),
+                    value=Constant(value=1, kind=None),
+                ),
+            ],
+            orelse=[],
+            type_comment=None,
+        ),
+    """
+    errors: List[Tuple[int, int, str]] = []
+    variable_candidates = []
+    if body_contains_continue(node.body):
+        return errors
+
+    # Find variables that might just count the iteration of the current loop
+    for expression in node.body:
+        if (
+            isinstance(expression, ast.AugAssign)
+            and is_constant_increase(expression)
+            and isinstance(expression.target, ast.Name)
+        ):
+            variable_candidates.append(expression.target)
+    str_candidates = [to_source(x) for x in variable_candidates]
+
+    older_siblings = []
+    for older_sibling in node.parent.body:  # type: ignore
+        if older_sibling is node:
+            break
+        older_siblings.append(older_sibling)
+
+    matches = [
+        n.targets[0]
+        for n in older_siblings
+        if isinstance(n, ast.Assign)
+        and len(n.targets) == 1
+        and isinstance(n.targets[0], ast.Name)
+        and to_source(n.targets[0]) in str_candidates
+    ]
+    if len(matches) == 0:
+        return errors
+
+    sibling = node.previous_sibling
+    while sibling is not None:
+        sibling = sibling.previous_sibling
+
+    for match in matches:
+        variable = to_source(match)
+        errors.append(
+            (
+                match.lineno,
+                match.col_offset,
+                f"SIM113 Use enumerate for '{variable}'",
+            )
+        )
+    return errors