pycharm lint, isort & black

Author: rocky

uncompyle6/parsers/parse24.py

@@ -3,19 +3,21 @@
 spark grammar differences over Python2.5 for Python 2.4.
 """
 
-from uncompyle6.parser import PythonParserSingle
 from spark_parser import DEFAULT_DEBUG as PARSER_DEFAULT_DEBUG
+
+from uncompyle6.parser import PythonParserSingle
 from uncompyle6.parsers.parse25 import Python25Parser
 
+
 class Python24Parser(Python25Parser):
     def __init__(self, debug_parser=PARSER_DEFAULT_DEBUG):
         super(Python24Parser, self).__init__(debug_parser)
         self.customized = {}
 
     def p_misc24(self, args):
-        '''
+        """
         # Python 2.4 only adds something like the below for if 1:
-        # However we will just treat it as a noop (which of course messes up
+        # However we will just treat it as a noop which messes up
         # simple verify of bytecode.
         # See also below in reduce_is_invalid where we check that the JUMP_FORWARD
         # target matches the COME_FROM target
@@ -69,16 +71,18 @@ def p_misc24(self, args):
         # Python 2.3- use kv
         kvlist ::= kvlist kv2
         kv2    ::= DUP_TOP expr expr ROT_THREE STORE_SUBSCR
-        '''
+        """
 
     def remove_rules_24(self):
-        self.remove_rules("""
+        self.remove_rules(
+            """
         expr ::= if_exp
-        """)
-
+        """
+        )
 
     def customize_grammar_rules(self, tokens, customize):
-        self.remove_rules("""
+        self.remove_rules(
+            """
         gen_comp_body ::= expr YIELD_VALUE POP_TOP
         kvlist        ::= kvlist kv3
         while1stmt    ::= SETUP_LOOP l_stmts JUMP_BACK COME_FROM
@@ -91,44 +95,49 @@ def customize_grammar_rules(self, tokens, customize):
         with          ::= expr setupwith SETUP_FINALLY suite_stmts_opt POP_BLOCK LOAD_CONST COME_FROM with_cleanup
         stmt ::= with
         stmt ::= withasstmt
-        """)
+        """
+        )
         super(Python24Parser, self).customize_grammar_rules(tokens, customize)
         self.remove_rules_24()
         if self.version[:2] == (2, 4):
-            self.check_reduce['nop_stmt'] = 'tokens'
+            self.check_reduce["nop_stmt"] = "tokens"
 
         if self.version[:2] <= (2, 4):
             # TODO: We may add something different or customize something
             del self.reduce_check_table["ifelsestmt"]
 
     def reduce_is_invalid(self, rule, ast, tokens, first, last):
-        invalid = super(Python24Parser,
-                        self).reduce_is_invalid(rule, ast,
-                                                tokens, first, last)
+        invalid = super(Python24Parser, self).reduce_is_invalid(
+            rule, ast, tokens, first, last
+        )
         if invalid or tokens is None:
             return invalid
 
         lhs = rule[0]
-        if lhs == 'nop_stmt':
+        if lhs == "nop_stmt":
             l = len(tokens)
             if 0 <= l < len(tokens):
                 return not int(tokens[first].pattr) == tokens[last].offset
-        elif lhs == 'try_except':
+        elif lhs == "try_except":
             if last == len(tokens):
                 last -= 1
-            if tokens[last] != 'COME_FROM' and tokens[last-1] == 'COME_FROM':
+            if tokens[last] != "COME_FROM" and tokens[last - 1] == "COME_FROM":
                 last -= 1
-            return (tokens[last] == 'COME_FROM'
-                    and tokens[last-1] == 'END_FINALLY'
-                    and tokens[last-2] == 'POP_TOP'
-                    and tokens[last-3].kind != 'JUMP_FORWARD')
+            return (
+                tokens[last] == "COME_FROM"
+                and tokens[last - 1] == "END_FINALLY"
+                and tokens[last - 2] == "POP_TOP"
+                and tokens[last - 3].kind != "JUMP_FORWARD"
+            )
 
         return False
 
+
 class Python24ParserSingle(Python24Parser, PythonParserSingle):
     pass
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     # Check grammar
     p = Python24Parser()
     p.check_grammar()

uncompyle6/parsers/parse25.py

@@ -3,10 +3,12 @@
 spark grammar differences over Python2.6 for Python 2.5.
 """
 
-from uncompyle6.parser import PythonParserSingle
 from spark_parser import DEFAULT_DEBUG as PARSER_DEFAULT_DEBUG
+
+from uncompyle6.parser import PythonParserSingle
 from uncompyle6.parsers.parse26 import Python26Parser
-from uncompyle6.parsers.reducecheck import (ifelsestmt)
+from uncompyle6.parsers.reducecheck import ifelsestmt
+
 
 class Python25Parser(Python26Parser):
     def __init__(self, debug_parser=PARSER_DEFAULT_DEBUG):
@@ -60,7 +62,8 @@ def p_misc25(self, args):
 
     def customize_grammar_rules(self, tokens, customize):
         # Remove grammar rules inherited from Python 2.6 or Python 2
-        self.remove_rules("""
+        self.remove_rules(
+            """
         setupwith  ::= DUP_TOP LOAD_ATTR ROT_TWO LOAD_ATTR CALL_FUNCTION_0 POP_TOP
         with       ::= expr setupwith SETUP_FINALLY suite_stmts_opt
                        POP_BLOCK LOAD_CONST COME_FROM WITH_CLEANUP END_FINALLY
@@ -87,17 +90,18 @@ def customize_grammar_rules(self, tokens, customize):
                                return_stmt_lambda LAMBDA_MARKER
         if_exp_not_lambda ::= expr jmp_true_then expr return_if_lambda
                               return_stmt_lambda LAMBDA_MARKER
-        """)
+        """
+        )
         super(Python25Parser, self).customize_grammar_rules(tokens, customize)
         if self.version[:2] == (2, 5):
             self.check_reduce["try_except"] = "AST"
         self.check_reduce["aug_assign1"] = "AST"
         self.check_reduce["ifelsestmt"] = "AST"
 
     def reduce_is_invalid(self, rule, ast, tokens, first, last):
-        invalid = super(Python25Parser,
-                        self).reduce_is_invalid(rule, ast,
-                                                tokens, first, last)
+        invalid = super(Python25Parser, self).reduce_is_invalid(
+            rule, ast, tokens, first, last
+        )
         if invalid or tokens is None:
             return invalid
         if rule == ("aug_assign1", ("expr", "expr", "inplace_op", "store")):
@@ -112,6 +116,7 @@ def reduce_is_invalid(self, rule, ast, tokens, first, last):
 class Python25ParserSingle(Python26Parser, PythonParserSingle):
     pass
 
+
 if __name__ == "__main__":
     # Check grammar
     p = Python25Parser()

uncompyle6/parsers/parse26.py

@@ -3,15 +3,16 @@
 spark grammar differences over Python2 for Python 2.6.
 """
 
-from uncompyle6.parser import PythonParserSingle
 from spark_parser import DEFAULT_DEBUG as PARSER_DEFAULT_DEBUG
+
+from uncompyle6.parser import PythonParserSingle
 from uncompyle6.parsers.parse2 import Python2Parser
 from uncompyle6.parsers.reducecheck import (
     except_handler,
     ifelsestmt2,
     ifstmt2,
-    tryexcept,
     tryelsestmt,
+    tryexcept,
 )
 
 
@@ -64,8 +65,8 @@ def p_try_except26(self, args):
         except_suite   ::= c_stmts_opt jmp_abs come_from_pop
 
         # This is what happens after a jump where
-        # we start a new block. For reasons I don't fully
-        # understand, there is also a value on the top of the stack
+        # we start a new block. For reasons that I don't fully
+        # understand, there is also a value on the top of the stack.
         come_from_pop   ::=  COME_FROM POP_TOP
         come_froms_pop  ::= come_froms POP_TOP
         """
@@ -78,7 +79,7 @@ def p_try_except26(self, args):
     def p_jumps26(self, args):
         """
 
-        # The are the equivalents of Python 2.7+'s
+        # There are the equivalents of Python 2.7+'s
         # POP_JUMP_IF_TRUE and POP_JUMP_IF_FALSE
         jmp_true     ::= JUMP_IF_TRUE POP_TOP
         jmp_false    ::= JUMP_IF_FALSE POP_TOP
@@ -106,8 +107,8 @@ def p_jumps26(self, args):
         _ifstmts_jump ::= c_stmts_opt JUMP_FORWARD come_froms POP_TOP COME_FROM
 
         # This is what happens after a jump where
-        # we start a new block. For reasons I don't fully
-        # understand, there is also a value on the top of the stack
+        # we start a new block. For reasons that I don't fully
+        # understand, there is also a value on the top of the stack.
         come_froms_pop  ::=  come_froms POP_TOP
 
         """
@@ -394,7 +395,7 @@ def reduce_is_invalid(self, rule, ast, tokens, first, last):
             if ast[1] is None:
                 return False
 
-            # For now, we won't let the 2nd 'expr' be a "if_exp_not"
+            # For now, we won't let the 2nd 'expr' be an "if_exp_not"
             # However in < 2.6 where we don't have if/else expression it *can*
             # be.
             if self.version >= (2, 6) and ast[2][0] == "if_exp_not":
@@ -464,7 +465,7 @@ def reduce_is_invalid(self, rule, ast, tokens, first, last):
             ja_attr = ast[4].attr
             return tokens[last].offset != ja_attr
         elif lhs == "try_except":
-            # We need to distingush try_except from tryelsestmt and we do that
+            # We need to distingush "try_except" from "tryelsestmt"; we do that
             # by checking the jump before the END_FINALLY
             # If we have:
             #    insn
@@ -490,7 +491,7 @@ def reduce_is_invalid(self, rule, ast, tokens, first, last):
                 ) or (tokens[last - 3] == "JUMP_FORWARD" and tokens[last - 3].attr != 2)
         elif lhs == "tryelsestmt":
 
-            # We need to distingush try_except from tryelsestmt and we do that
+            # We need to distinguish "try_except" from "tryelsestmt"; we do that
             # by making sure that the jump before the except handler jumps to
             # code somewhere before the end of the construct.
             # This AST method is slower, but the token-only based approach
@@ -508,8 +509,8 @@ def reduce_is_invalid(self, rule, ast, tokens, first, last):
                         return else_start >= last_offset
 
             # The above test apparently isn't good enough, so we have additional
-            # checks distinguish try_except from tryelsestmt and we do that
-            # by checking the jump before the END_FINALLY
+            # checks distinguish "try_except" from "tryelsestmt". we do that
+            # by checking the jump before the "END_FINALLY".
             # If we have:
             #    insn
             #    POP_TOP
@@ -546,7 +547,7 @@ class Python26ParserSingle(Python2Parser, PythonParserSingle):
     # Check grammar
     p = Python26Parser()
     p.check_grammar()
-    from xdis.version_info import PYTHON_VERSION_TRIPLE, IS_PYPY
+    from xdis.version_info import IS_PYPY, PYTHON_VERSION_TRIPLE
 
     if PYTHON_VERSION_TRIPLE[:2] == (2, 6):
         lhs, rhs, tokens, right_recursive, dup_rhs = p.check_sets()