How to use the uncompyle6.IS_PYPY function in uncompyle6

def test_grammar(self):

        def check_tokens(tokens, opcode_set):
            remain_tokens = set(tokens) - opcode_set
            remain_tokens = set([re.sub('_\d+$','', t) for t in remain_tokens])
            remain_tokens = set([re.sub('_CONT$','', t) for t in remain_tokens])
            remain_tokens = set(remain_tokens) - opcode_set
            self.assertEqual(remain_tokens, set([]),
                    "Remaining tokens %s\n====\n%s" % (remain_tokens, p.dump_grammar()))

        p = get_python_parser(PYTHON_VERSION, is_pypy=IS_PYPY)
        (lhs, rhs, tokens,
         right_recursive, dup_rhs) = p.check_sets()
        expect_lhs = set(['expr1024', 'pos_arg'])
        unused_rhs = set(['list', 'call', 'mkfunc',
                          'mklambda',
                          'unpack',])

        expect_right_recursive = frozenset([('designList',
                                             ('store', 'DUP_TOP', 'designList'))])
        expect_lhs.add('kwarg')

        self.assertEqual(expect_lhs, set(lhs))
        self.assertEqual(unused_rhs, set(rhs))
        self.assertEqual(expect_right_recursive, right_recursive)

        expect_dup_rhs = frozenset([('COME_FROM',), ('CONTINUE',), ('JUMP_ABSOLUTE',),

def test_if_in_for():
    code = bug.func_code
    scan = get_scanner(PYTHON_VERSION)
    if 2.7 <= PYTHON_VERSION <= 3.0 and not IS_PYPY:
        n = scan.setup_code(code)
        scan.build_lines_data(code, n)
        scan.build_prev_op(n)
        fjt = scan.find_jump_targets(False)
        assert {15: [3], 69: [66], 63: [18]} == fjt
        assert scan.structs == \
          [{'start': 0, 'end': 72, 'type': 'root'},
           {'start': 15, 'end': 66, 'type': 'if-then'},
           {'start': 31, 'end': 59, 'type': 'for-loop'},
           {'start': 62, 'end': 63, 'type': 'for-else'}]

        code = bug_loop.__code__
        n = scan.setup_code(code)
        scan.build_lines_data(code, n)
        scan.build_prev_op(n)
        fjt = scan.find_jump_targets(False)

def test_dup_rule(self):
        import inspect
        python_parser(PYTHON_VERSION, inspect.currentframe().f_code,
                      is_pypy=IS_PYPY,
                      parser_debug={
                          'dups': True, 'transition': False, 'reduce': False,
                          'rules': False, 'errorstack': None, 'context': True})
if __name__ == '__main__':

pass

class Python30ParserSingle(Python30Parser, PythonParserSingle):
    pass

if __name__ == '__main__':
    # Check grammar
    p = Python30Parser()
    p.remove_rules_30()
    p.check_grammar()
    from uncompyle6 import PYTHON_VERSION, IS_PYPY
    if PYTHON_VERSION == 3.0:
        lhs, rhs, tokens, right_recursive, dup_rhs = p.check_sets()
        from uncompyle6.scanner import get_scanner
        s = get_scanner(PYTHON_VERSION, IS_PYPY)
        opcode_set = set(s.opc.opname).union(set(
            """JUMP_BACK CONTINUE RETURN_END_IF COME_FROM
               LOAD_GENEXPR LOAD_ASSERT LOAD_SETCOMP LOAD_DICTCOMP LOAD_CLASSNAME
               LAMBDA_MARKER RETURN_LAST
            """.split()))
        ## FIXME: try this
        remain_tokens = set(tokens) - opcode_set
        import re
        remain_tokens = set([re.sub(r'_\d+$', '',  t) for t in remain_tokens])
        remain_tokens = set([re.sub('_CONT$', '', t) for t in remain_tokens])
        remain_tokens = set(remain_tokens) - opcode_set
        print(remain_tokens)
        import sys
        if len(sys.argv) > 1:
            from spark_parser.spark import rule2str
            for rule in sorted(p.rule2name.items()):

pass
            pass
        return False

class Python36ParserSingle(Python36Parser, PythonParserSingle):
    pass

if __name__ == '__main__':
    # Check grammar
    p = Python36Parser()
    p.check_grammar()
    from uncompyle6 import PYTHON_VERSION, IS_PYPY
    if PYTHON_VERSION == 3.6:
        lhs, rhs, tokens, right_recursive, dup_rhs = p.check_sets()
        from uncompyle6.scanner import get_scanner
        s = get_scanner(PYTHON_VERSION, IS_PYPY)
        opcode_set = set(s.opc.opname).union(set(
            """JUMP_BACK CONTINUE RETURN_END_IF COME_FROM
               LOAD_GENEXPR LOAD_ASSERT LOAD_SETCOMP LOAD_DICTCOMP LOAD_CLASSNAME
               LAMBDA_MARKER RETURN_LAST
            """.split()))
        remain_tokens = set(tokens) - opcode_set
        import re
        remain_tokens = set([re.sub(r'_\d+$', '', t) for t in remain_tokens])
        remain_tokens = set([re.sub('_CONT$', '', t) for t in remain_tokens])
        remain_tokens = set(remain_tokens) - opcode_set
        print(remain_tokens)
        # print(sorted(p.rule2name.items()))

def parse_test(co):
        from uncompyle6 import PYTHON_VERSION, IS_PYPY
        ast = python_parser(PYTHON_VERSION, co, showasm=True, is_pypy=IS_PYPY)
        print(ast)
        return
    parse_test(parse_test.__code__)

pass


if __name__ == "__main__":
    # Check grammar
    # FIXME: DRY this with other parseXX.py routines
    p = Python38Parser()
    p.remove_rules_38()
    p.check_grammar()
    from uncompyle6 import PYTHON_VERSION, IS_PYPY

    if PYTHON_VERSION == 3.8:
        lhs, rhs, tokens, right_recursive, dup_rhs = p.check_sets()
        from uncompyle6.scanner import get_scanner

        s = get_scanner(PYTHON_VERSION, IS_PYPY)
        opcode_set = set(s.opc.opname).union(
            set(
                """JUMP_BACK CONTINUE RETURN_END_IF COME_FROM
               LOAD_GENEXPR LOAD_ASSERT LOAD_SETCOMP LOAD_DICTCOMP LOAD_CLASSNAME
               LAMBDA_MARKER RETURN_LAST
            """.split()
            )
        )
        remain_tokens = set(tokens) - opcode_set
        import re

        remain_tokens = set([re.sub(r"_\d+$", "", t) for t in remain_tokens])
        remain_tokens = set([re.sub("_CONT$", "", t) for t in remain_tokens])
        remain_tokens = set(remain_tokens) - opcode_set
        print(remain_tokens)
        import sys

    def deparse_test(co, is_pypy=IS_PYPY):
        sys_version = sys.version_info.major + (sys.version_info.minor / 10.0)
        walk = deparse_code(sys_version, co, showasm=False, showast=False,
                            showgrammar=False, is_pypy=IS_PYPY)
        print("deparsed source")
        print(walk.text, "\n")
        print('------------------------')
        for name, offset in sorted(walk.offsets.keys(),
                                   key=lambda x: str(x[0])):
            print("name %s, offset %s" % (name, offset))
            nodeInfo = walk.offsets[name, offset]
            node = nodeInfo.node
            extractInfo = walk.extract_node_info(node)
            print("code: %s" % node.type)
            # print extractInfo
            print(extractInfo.selectedText)
            print(extractInfo.selectedLine)

out=StringIO(),
    version=None,
    is_pypy=None,
    debug_opts=DEFAULT_DEBUG_OPTS,
):
    """
    Like deparse_code(), but given  a function/module name and
    offset, finds the node closest to offset. If offset is not an instruction boundary,
    we raise an IndexError.
    """
    assert iscode(co)

    if version is None:
        version = sysinfo2float()
    if is_pypy is None:
        is_pypy = IS_PYPY

    deparsed = code_deparse(co, out, version, is_pypy, debug_opts)
    if (name, offset) in deparsed.offsets.keys():
        # This is the easy case
        return deparsed

    valid_offsets = [t for t in deparsed.offsets if isinstance(t[1], int)]
    offset_list = sorted([t[1] for t in valid_offsets if t[0] == name])

    # FIXME: should check for branching?
    found_offset = find_gt(offset_list, offset)
    deparsed.offsets[name, offset] = deparsed.offsets[name, found_offset]
    return deparsed

else:
            scanner = eval(
                "scan.Scanner%s(show_asm=show_asm)" % v_str, locals(), globals()
            )
    else:
        raise RuntimeError("Unsupported Python version %s" % version)
    return scanner


if __name__ == "__main__":
    import inspect, uncompyle6

    co = inspect.currentframe().f_code
    # scanner = get_scanner('2.7.13', True)
    # scanner = get_scanner(sys.version[:5], False)
    scanner = get_scanner(uncompyle6.PYTHON_VERSION, IS_PYPY, True)
    tokens, customize = scanner.ingest(co, {}, show_asm="after")