flake8_simplify 0.20.0__py3-none-any.whl

flake8_simplify/rules/ast_try.py

@@ -0,0 +1,96 @@
+# Core Library
+import ast
+from typing import List, Tuple
+
+# First party
+from flake8_simplify.utils import to_source
+
+
+def get_sim105(node: ast.Try) -> List[Tuple[int, int, str]]:
+    """
+    Get a list of all "try-except-pass" patterns.
+
+    try:
+        foo()
+    except ValueError:
+        pass
+
+    which is
+
+        Try(
+            body=[
+                Expr(
+                    value=Call(
+                        func=Name(id='foo', ctx=Load()),
+                        args=[],
+                        keywords=[],
+                    ),
+                ),
+            ],
+            handlers=[
+                ExceptHandler(
+                    type=Name(id='ValueError', ctx=Load()),
+                    name=None,
+                    body=[Pass()],
+                ),
+            ],
+            orelse=[],
+            finalbody=[],
+        ),
+
+
+    """
+    SIM105 = "SIM105 Use 'contextlib.suppress({exception})'"
+    errors: List[Tuple[int, int, str]] = []
+    if (
+        len(node.body) != 1
+        or len(node.handlers) != 1
+        or not isinstance(node.handlers[0], ast.ExceptHandler)
+        or len(node.handlers[0].body) != 1
+        or not isinstance(node.handlers[0].body[0], ast.Pass)
+        or node.orelse != []
+    ):
+        return errors
+    if node.handlers[0].type is None:
+        exception = "Exception"
+    else:
+        exception = to_source(node.handlers[0].type)
+    errors.append(
+        (node.lineno, node.col_offset, SIM105.format(exception=exception))
+    )
+    return errors
+
+
+def get_sim107(node: ast.Try) -> List[Tuple[int, int, str]]:
+    """
+    Get a list of all calls where try/except and finally have 'return'.
+    """
+    SIM107 = "SIM107 Don't use return in try/except and finally"
+    errors: List[Tuple[int, int, str]] = []
+
+    try_has_return = False
+    for stmt in node.body:
+        if isinstance(stmt, ast.Return):
+            try_has_return = True
+            break
+
+    except_has_return = False
+    for stmt2 in node.handlers:
+        if isinstance(stmt2, ast.Return):
+            except_has_return = True
+            break
+
+    finally_has_return = False
+    finally_return = None
+    for stmt in node.finalbody:
+        if isinstance(stmt, ast.Return):
+            finally_has_return = True
+            finally_return = stmt
+            break
+
+    if (try_has_return or except_has_return) and finally_has_return:
+        assert finally_return is not None, "hint for mypy"
+        errors.append(
+            (finally_return.lineno, finally_return.col_offset, SIM107)
+        )
+    return errors

flake8_simplify/rules/ast_unary_op.py

@@ -0,0 +1,106 @@
+# Core Library
+import ast
+from typing import List, Tuple
+
+# First party
+from flake8_simplify.utils import UnaryOp, is_exception_check, to_source
+
+
+def get_sim201(node: UnaryOp) -> List[Tuple[int, int, str]]:
+    """
+    Get a list of all calls where an unary 'not' is used for an equality.
+    """
+    SIM201 = (
+        "SIM201 Use '{left} != {right}' instead of 'not {left} == {right}'"
+    )
+    errors: List[Tuple[int, int, str]] = []
+    if (
+        (
+            not isinstance(node.op, ast.Not)
+            or not isinstance(node.operand, ast.Compare)
+            or len(node.operand.ops) != 1
+            or not isinstance(node.operand.ops[0], ast.Eq)
+        )
+        or isinstance(node.parent, ast.If)
+        and is_exception_check(node.parent)
+    ):
+        return errors
+    comparison = node.operand
+    left = to_source(comparison.left)
+    right = to_source(comparison.comparators[0])
+    errors.append(
+        (node.lineno, node.col_offset, SIM201.format(left=left, right=right))
+    )
+
+    return errors
+
+
+def get_sim202(node: UnaryOp) -> List[Tuple[int, int, str]]:
+    """
+    Get a list of all calls where an unary 'not' is used for an quality.
+    """
+    SIM202 = (
+        "SIM202 Use '{left} == {right}' instead of 'not {left} != {right}'"
+    )
+    errors: List[Tuple[int, int, str]] = []
+    if (
+        (
+            not isinstance(node.op, ast.Not)
+            or not isinstance(node.operand, ast.Compare)
+            or len(node.operand.ops) != 1
+            or not isinstance(node.operand.ops[0], ast.NotEq)
+        )
+        or isinstance(node.parent, ast.If)
+        and is_exception_check(node.parent)
+    ):
+        return errors
+    comparison = node.operand
+    left = to_source(comparison.left)
+    right = to_source(comparison.comparators[0])
+    errors.append(
+        (node.lineno, node.col_offset, SIM202.format(left=left, right=right))
+    )
+
+    return errors
+
+
+def get_sim203(node: UnaryOp) -> List[Tuple[int, int, str]]:
+    """
+    Get a list of all calls where an unary 'not' is used for an in-check.
+    """
+    SIM203 = "SIM203 Use '{a} not in {b}' instead of 'not {a} in {b}'"
+    errors: List[Tuple[int, int, str]] = []
+    if (
+        (
+            not isinstance(node.op, ast.Not)
+            or not isinstance(node.operand, ast.Compare)
+            or len(node.operand.ops) != 1
+            or not isinstance(node.operand.ops[0], ast.In)
+        )
+        or isinstance(node.parent, ast.If)
+        and is_exception_check(node.parent)
+    ):
+        return errors
+    comparison = node.operand
+    left = to_source(comparison.left)
+    right = to_source(comparison.comparators[0])
+    errors.append(
+        (node.lineno, node.col_offset, SIM203.format(a=left, b=right))
+    )
+
+    return errors
+
+
+def get_sim208(node: ast.UnaryOp) -> List[Tuple[int, int, str]]:
+    """Get a list of all calls of the type "not (not a)"."""
+    SIM208 = "SIM208 Use '{a}' instead of 'not (not {a})'"
+    errors: List[Tuple[int, int, str]] = []
+    if (
+        not isinstance(node.op, ast.Not)
+        or not isinstance(node.operand, ast.UnaryOp)
+        or not isinstance(node.operand.op, ast.Not)
+    ):
+        return errors
+    a = to_source(node.operand.operand)
+    errors.append((node.lineno, node.col_offset, SIM208.format(a=a)))
+    return errors

flake8_simplify/rules/ast_with.py

@@ -0,0 +1,62 @@
+# Core Library
+import ast
+from typing import List, Tuple
+
+# First party
+from flake8_simplify.utils import to_source
+
+
+def get_sim117(node: ast.With) -> List[Tuple[int, int, str]]:
+    """
+    Find multiple with-statements with same scope.
+
+        With(
+            items=[
+                withitem(
+                    context_expr=Call(
+                        func=Name(id='A', ctx=Load()),
+                        args=[],
+                        keywords=[],
+                    ),
+                    optional_vars=Name(id='a', ctx=Store()),
+                ),
+            ],
+            body=[
+                With(
+                    items=[
+                        withitem(
+                            context_expr=Call(
+                                func=Name(id='B', ctx=Load()),
+                                args=[],
+                                keywords=[],
+                            ),
+                            optional_vars=Name(id='b', ctx=Store()),
+                        ),
+                    ],
+                    body=[
+                        Expr(
+                            value=Call(
+                                func=Name(id='print', ctx=Load()),
+                                args=[Constant(value='hello', kind=None)],
+                                keywords=[],
+                            ),
+                        ),
+                    ],
+                    type_comment=None,
+                ),
+            ],
+            type_comment=None,
+        ),
+    """
+    SIM117 = "SIM117 Use '{merged_with}' instead of multiple with statements"
+    errors: List[Tuple[int, int, str]] = []
+    if not (len(node.body) == 1 and isinstance(node.body[0], ast.With)):
+        return errors
+    with_items = []
+    for withitem in node.items + node.body[0].items:
+        with_items.append(f"{to_source(withitem)}")
+    merged_with = f"with {', '.join(with_items)}:"
+    errors.append(
+        (node.lineno, node.col_offset, SIM117.format(merged_with=merged_with))
+    )
+    return errors

flake8_simplify/utils.py

@@ -0,0 +1,247 @@
+# Core Library
+import ast
+import itertools
+from collections import defaultdict
+from typing import DefaultDict, List, Tuple, Union
+
+# Third party
+import astor
+
+
+# The following types were created to help mypy understand that there is a
+# "parent" attribute on the ast.AST nodes.
+class UnaryOp(ast.UnaryOp):
+    def __init__(self, orig: ast.UnaryOp) -> None:
+        self.op = orig.op
+        self.operand = orig.operand
+        # For all ast.*:
+        self.lineno = orig.lineno
+        self.col_offset = orig.col_offset
+        self.parent: ast.Expr = orig.parent  # type: ignore
+
+
+class Call(ast.Call):
+    """For mypy so that it knows that added attributes exist."""
+
+    def __init__(self, orig: ast.Call) -> None:
+        self.func = orig.func
+        self.args = orig.args
+        self.keywords = orig.keywords
+        # For all ast.*:
+        self.lineno = orig.lineno
+        self.col_offset = orig.col_offset
+
+        # Added attributes
+        self.parent: ast.Expr = orig.parent  # type: ignore
+
+
+class If(ast.If):
+    """For mypy so that it knows that added attributes exist."""
+
+    def __init__(self, orig: ast.If) -> None:
+        self.test = orig.test
+        self.body = orig.body
+        self.orelse = orig.orelse
+
+        # For all ast.*:
+        self.lineno = orig.lineno
+        self.col_offset = orig.col_offset
+
+        # Added attributes
+        self.parent: ast.Expr = orig.parent  # type: ignore
+
+
+class For(ast.For):
+    """For mypy so that it knows that added attributes exist."""
+
+    def __init__(self, orig: ast.For) -> None:
+        self.target = orig.target
+        self.iter = orig.iter
+        self.body = orig.body
+        self.orelse = orig.orelse
+        # For all ast.*:
+        self.lineno = orig.lineno
+        self.col_offset = orig.col_offset
+
+        # Added attributes
+        self.parent: ast.AST = orig.parent  # type: ignore
+        self.previous_sibling = orig.previous_sibling  # type: ignore
+
+
+class Assign(ast.Assign):
+    """For mypy so that it knows that added attributes exist."""
+
+    def __init__(self, orig: ast.Assign) -> None:
+        self.targets = orig.targets
+        self.value = orig.value
+        # For all ast.*:
+        self.orig = orig
+        self.lineno = orig.lineno
+        self.col_offset = orig.col_offset
+
+        # Added attributes
+        self.parent: ast.AST = orig.parent  # type: ignore
+        self.previous_sibling = orig.previous_sibling  # type: ignore
+
+
+def to_source(
+    node: Union[None, ast.expr, ast.Expr, ast.withitem, ast.slice, ast.Assign]
+) -> str:
+    if node is None:
+        return "None"
+    source: str = astor.to_source(node).strip()
+    source = strip_parenthesis(source)
+    source = strip_triple_quotes(source)
+    source = use_double_quotes(source)
+    return source
+
+
+def strip_parenthesis(string: str) -> str:
+    if len(string) >= 2 and string[0] == "(" and string[-1] == ")":
+        return string[1:-1]
+    return string
+
+
+def strip_triple_quotes(string: str) -> str:
+    quotes = '"""'
+    is_tripple_quoted = string.startswith(quotes) and string.endswith(quotes)
+    if not (
+        is_tripple_quoted and '"' not in string[len(quotes) : -len(quotes)]
+    ):
+        return string
+    string = string[len(quotes) : -len(quotes)]
+    string = f'"{string}"'
+    if len(string) == 0:
+        string = '""'
+    return string
+
+
+def use_double_quotes(string: str) -> str:
+    quotes = "'''"
+    if string.startswith(quotes) and string.endswith(quotes):
+        return f'"""{string[len(quotes):-len(quotes)]}"""'
+    if len(string) >= 2 and string[0] == "'" and string[-1] == "'":
+        return f'"{string[1:-1]}"'
+    return string
+
+
+def is_body_same(body1: List[ast.stmt], body2: List[ast.stmt]) -> bool:
+    """Check if two lists of expressions are equivalent."""
+    if len(body1) != len(body2):
+        return False
+    for a, b in zip(body1, body2):
+        try:
+            stmt_equal = is_stmt_equal(a, b)
+        except RecursionError:  # maximum recursion depth
+            stmt_equal = False
+        if not stmt_equal:
+            return False
+    return True
+
+
+def is_stmt_equal(a: ast.stmt, b: ast.stmt) -> bool:
+    if type(a) is not type(b):
+        return False
+    if isinstance(a, ast.AST):
+        specials = (
+            "lineno",
+            "col_offset",
+            "ctx",
+            "end_lineno",
+            "parent",
+            "previous_sibling",
+            "next_sibling",
+        )
+        for k, v in vars(a).items():
+            if k.startswith("_") or k in specials:
+                continue
+            if not is_stmt_equal(v, getattr(b, k)):
+                return False
+        return True
+    elif isinstance(a, list):
+        if len(a) != len(b):
+            return False
+        return all(itertools.starmap(is_stmt_equal, zip(a, b)))
+    else:
+        return a == b
+
+
+def get_if_body_pairs(node: ast.If) -> List[Tuple[ast.expr, List[ast.stmt]]]:
+    pairs = [(node.test, node.body)]
+    orelse = node.orelse
+    while (
+        isinstance(orelse, list)
+        and len(orelse) == 1
+        and isinstance(orelse[0], ast.If)
+    ):
+        pairs.append((orelse[0].test, orelse[0].body))
+        orelse = orelse[0].orelse
+    return pairs
+
+
+def is_constant_increase(expr: ast.AugAssign) -> bool:
+    return isinstance(expr.op, ast.Add) and (
+        (isinstance(expr.value, ast.Constant) and expr.value.value == 1)
+        or (isinstance(expr.value, ast.Num) and expr.value.n == 1)
+    )
+
+
+def is_exception_check(node: ast.If) -> bool:
+    if len(node.body) == 1 and isinstance(node.body[0], ast.Raise):
+        return True
+    return False
+
+
+def is_same_expression(a: ast.expr, b: ast.expr) -> bool:
+    """Check if two expressions are equal to each other."""
+    if isinstance(a, ast.Name) and isinstance(b, ast.Name):
+        return a.id == b.id
+    else:
+        return False
+
+
+def expression_uses_variable(expr: ast.expr, var: str) -> bool:
+    if var in to_source(expr):
+        # This is WAY too broad, but it's better to have false-negatives
+        # than false-positives
+        return True
+    return False
+
+
+def _get_duplicated_isinstance_call_by_node(node: ast.BoolOp) -> List[str]:
+    """
+    Get a list of isinstance arguments which could be shortened.
+
+    This checks SIM101.
+
+    Examples
+    --------
+    >> g = _get_duplicated_isinstance_call_by_node
+    >> g("isinstance(a, int) or isinstance(a, float) or isinstance(b, int)
+    ['a']
+    >> g("isinstance(a, int) or isinstance(b, float) or isinstance(b, int)
+    ['b']
+    """
+    counter: DefaultDict[str, int] = defaultdict(int)
+
+    for call in node.values:
+        # Make sure that this function call is actually a call of the built-in
+        # "isinstance"
+        if not isinstance(call, ast.Call) or len(call.args) != 2:
+            continue
+        function_name = to_source(call.func)
+        if function_name != "isinstance":
+            continue
+
+        # Collect the name of the argument
+        isinstance_arg0_name = to_source(call.args[0])
+        counter[isinstance_arg0_name] += 1
+    return [arg0_name for arg0_name, count in counter.items() if count > 1]
+
+
+def body_contains_continue(stmts: List[ast.stmt]) -> bool:
+    return any(
+        isinstance(stmt, ast.Continue)
+        or (isinstance(stmt, ast.If) and body_contains_continue(stmt.body))
+        for stmt in stmts
+    )

flake8_simplify-0.20.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Martin Thoma
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.