Administrivia

.circleci/config.yml

@@ -42,7 +42,7 @@ jobs:
     # This is based on your 1.0 configuration file or project settings
     - run:
         working_directory: ~/rocky/python-uncompyle6
-        command: pyenv install 2.4.6 && pyenv local 2.4.6 && pyenv rehash && easy_install nose && pyenv rehash
+        command: pyenv local 2.7.11 && pyenv rehash && pip install virtualenv && pip install nose && pip install pep8 && pip install six && pyenv rehash
     # Dependencies
     #   This would typically go in either a build or a build-and-test job when using workflows
     # Restore the dependency cache
@@ -55,7 +55,9 @@ jobs:
         # Any branch if there are none on the default branch - this should be unnecessary if you have your default branch configured correctly
         - v1-dep-
     # This is based on your 1.0 configuration file or project settings
-    - run: easy_install spark_parser==1.8.5 && easy_install xdis==3.8.4
+    - run: pip install --upgrade setuptools
+    - run: pip install -e .
+    - run: pip install pytest==3.2.5 hypothesis==3.0.0
     # Save dependency cache
     - save_cache:
         key: v1-dep-{{ .Branch }}-{{ epoch }}
@@ -73,8 +75,8 @@ jobs:
     # Test
     #   This would typically be a build job when using workflows, possibly combined with build
     # This is based on your 1.0 configuration file or project settings
-    - run: python ./setup.py develop && make check-2.4
-    - run: cd ./test/stdlib && pyenv local 2.4.6 && bash ./runtests.sh 'test_[p-z]*.py'
+    - run: python ./setup.py develop && make check-2.7
+    - run: cd ./test/stdlib && pyenv local 2.7.11 && bash ./runtests.sh 'test_[p-z]*.py'
     # Teardown
     #   If you break your build into multiple jobs with workflows, you will probably want to do the parts of this that are relevant in each
     # Save test results

.travis.yml

@@ -1,11 +1,15 @@
 language: python
 
 python:
-  - '2.7' # this is a cheat here because travis doesn't do 2.4-2.6
+  - '3.5'
+  - '2.7'
+  - '2.6'
+  - '3.4'
+  - '3.6'
 
 matrix:
   include:
-    - python: '2.7'
+    - python: '3.7'
       dist: xenial  # required for Python >= 3.7 (travis-ci/travis-ci#9069)
 
 install:

Makefile

@@ -40,9 +40,8 @@ check-3.0 check-3.1 check-3.2 check-3.6:
 check-3.7: pytest
 	$(MAKE) -C test check
 
-#:Tests for Python 2.4-2.5 (don't have pytest)
-check-2.4 check-2.5:
-	$(MAKE) -C test $@
+check-3.8:
+	$(MAKE) -C test check
 
 #:PyPy 2.6.1 PyPy 5.0.1, or PyPy 5.8.0-beta0
 # Skip for now

NEWS.md

@@ -30,7 +30,8 @@ Lots of decomplation bugs, especially in the 3.x series fixed. Don't worry thoug
 3.3.0 2019-43-14 Holy Week
 ==========================
 
-* First cut at Python 3.8 (many bug remain)
+* First cut at Python 3.8 (many bugs remain)
+* Reinstate -c | --compile (compile before disassembly) option
 * The usual smattering of bug and doc fixes
 
 3.2.6 2019-03-23 Mueller Report

admin-tools/how-to-make-a-release.txt

@@ -1,46 +0,0 @@
-git pull
-
-Change version in uncompyle6/version.py
-source uncompyle6/version.py
-echo $VERSION
-git commit -m"Get ready for release $VERSION" .
-
-Update ChangeLog:
-  make ChangeLog
-
-Update NEWS from ChangeLog
-make check
-
-git commit --amend .
-
-git push
-
-Make sure pyenv is running
-# Pyenv
-
-source admin-tools/check-newer-versions.sh
-
-
-# Switch to python-2.4 and build that first...
-source admin-tools/setup-python-2.4
-
-rm ChangeLog
-git merge master
-
-Update NEWS from master branch
-
-git commit -m"Get ready for release $VERSION" .
-
-source admin-tools/check-older-versions.sh
-source admin-tools/check-newer-versions.sh
-
-make-dist-older.sh
-
-git tag release-python-2.4-$VERSION
-
-./make-dist-newer.sh
-
-git tag release-$VERSION
-
-
-twine upload dist/uncompyle6-${VERSION}*

admin-tools/update-sources.sh

@@ -1,3 +0,0 @@
-#!/bin/bash
-cd $(dirname ${BASH_SOURCE[0]})/..
-git pull

pytest/test_deparse.py

@@ -30,7 +30,7 @@ def list_comp():
     [y for y in range(3)]
 
 def get_parsed_for_fn(fn):
-    code = fn.func_code
+    code = fn.__code__ if PYTHON3 else fn.func_code
     return deparse(code, version=PYTHON_VERSION)
 
 def check_expect(expect, parsed, fn_name):

pytest/test_docstring.py

@@ -10,7 +10,7 @@ else:
     maxint = sys.maxint
 from uncompyle6.semantics.helper import print_docstring
 
-class PrintFake:
+class PrintFake():
     def __init__(self):
         self.pending_newlines = 0
         self.f = StringIO()

pytest/test_fjt.py

@@ -20,7 +20,7 @@ def bug_loop(disassemble, tb=None):
     disassemble(tb)
 
 def test_if_in_for():
-    code = bug.func_code
+    code = bug.__code__
     scan = get_scanner(PYTHON_VERSION)
     if 2.7 <= PYTHON_VERSION <= 3.0 and not IS_PYPY:
         scan.build_instructions(code)

pytest/test_fstring.py

@@ -0,0 +1,158 @@
+# std
+# test
+from uncompyle6 import PYTHON_VERSION, deparse_code
+import pytest
+pytestmark = pytest.mark.skipif(PYTHON_VERSION <= 2.6,
+                                reason='hypothesis needs 2.7 or later')
+if PYTHON_VERSION > 2.6:
+
+    import hypothesis
+    from hypothesis import strategies as st
+
+    # uncompyle6
+
+
+    @st.composite
+    def expressions(draw):
+        # todo : would be nice to generate expressions using hypothesis however
+        # this is pretty involved so for now just use a corpus of expressions
+        # from which to select.
+        return draw(st.sampled_from((
+            'abc',
+            'len(items)',
+            'x + 1',
+            'lineno',
+            'container',
+            'self.attribute',
+            'self.method()',
+            # These expressions are failing, I think these are control
+            # flow problems rather than problems with FORMAT_VALUE,
+            # however I need to confirm this...
+            #'sorted(items, key=lambda x: x.name)',
+            #'func(*args, **kwargs)',
+            #'text or default',
+            #'43 if life_the_universe and everything else None'
+        )))
+
+
+    @st.composite
+    def format_specifiers(draw):
+        """
+        Generate a valid format specifier using the rules:
+
+        format_spec ::=  [[fill]align][sign][#][0][width][,][.precision][type]
+        fill        ::=  <any character>
+        align       ::=  "<" | ">" | "=" | "^"
+        sign        ::=  "+" | "-" | " "
+        width       ::=  integer
+        precision   ::=  integer
+        type        ::=  "b" | "c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" | "n" | "o" | "s" | "x" | "X" | "%"
+
+        See https://docs.python.org/2/library/string.html
+
+        :param draw: Let hypothesis draw from other strategies.
+
+        :return: An example format_specifier.
+        """
+        alphabet_strategy = st.characters(min_codepoint=ord('a'), max_codepoint=ord('z'))
+        fill = draw(st.one_of(alphabet_strategy, st.none()))
+        align = draw(st.sampled_from(list('<>=^')))
+        fill_align = (fill + align or '') if fill else ''
+
+        type_ = draw(st.sampled_from('bcdeEfFgGnosxX%'))
+        can_have_sign = type_ in 'deEfFgGnoxX%'
+        can_have_comma = type_ in 'deEfFgG%'
+        can_have_precision = type_ in 'fFgG'
+        can_have_pound = type_ in 'boxX%'
+        can_have_zero = type_ in 'oxX'
+
+        sign = draw(st.sampled_from(list('+- ') + [''])) if can_have_sign else ''
+        pound = draw(st.sampled_from(('#', '',))) if can_have_pound else ''
+        zero = draw(st.sampled_from(('0', '',))) if can_have_zero else ''
+
+        int_strategy = st.integers(min_value=1, max_value=1000)
+
+        width = draw(st.one_of(int_strategy, st.none()))
+        width = str(width) if width is not None else ''
+
+        comma = draw(st.sampled_from((',', '',))) if can_have_comma else ''
+        if can_have_precision:
+            precision = draw(st.one_of(int_strategy, st.none()))
+            precision = '.' + str(precision) if precision else ''
+        else:
+            precision = ''
+
+        return ''.join((fill_align, sign, pound, zero, width, comma, precision, type_,))
+
+
+    @st.composite
+    def fstrings(draw):
+        """
+        Generate a valid f-string.
+        See https://www.python.org/dev/peps/pep-0498/#specification
+
+        :param draw: Let hypothsis draw from other strategies.
+
+        :return: A valid f-string.
+        """
+        character_strategy = st.characters(
+            blacklist_characters='\r\n\'\\s{}',
+            min_codepoint=1,
+            max_codepoint=1000,
+        )
+        is_raw = draw(st.booleans())
+        integer_strategy = st.integers(min_value=0, max_value=3)
+        expression_count = draw(integer_strategy)
+        content = []
+        for _ in range(expression_count):
+            expression = draw(expressions())
+            conversion = draw(st.sampled_from(('', '!s', '!r', '!a',)))
+            has_specifier = draw(st.booleans())
+            specifier = ':' + draw(format_specifiers()) if has_specifier else ''
+            content.append('{{{}{}}}'.format(expression, conversion, specifier))
+            content.append(draw(st.text(character_strategy)))
+        content = ''.join(content)
+        return "f{}'{}'".format('r' if is_raw else '', content)
+
+
+    @pytest.mark.skipif(PYTHON_VERSION != 3.6, reason='need Python 3.6')
+    @hypothesis.given(format_specifiers())
+    def test_format_specifiers(format_specifier):
+        """Verify that format_specifiers generates valid specifiers"""
+        try:
+            exec('"{:' + format_specifier + '}".format(0)')
+        except ValueError as e:
+            if 'Unknown format code' not in str(e):
+                raise
+
+
+    def run_test(text):
+        hypothesis.assume(len(text))
+        hypothesis.assume("f'{" in text)
+        expr = text + '\n'
+        code = compile(expr, '<string>', 'single')
+        deparsed = deparse_code(PYTHON_VERSION, code, compile_mode='single')
+        recompiled = compile(deparsed.text, '<string>', 'single')
+        if recompiled != code:
+            print(recompiled)
+            print('================')
+            print(code)
+            print('----------------')
+            assert 'dis(' + deparsed.text.strip('\n') + ')' == 'dis(' + expr.strip('\n') + ')'
+
+
+    @pytest.mark.skipif(PYTHON_VERSION != 3.6, reason='need Python 3.6')
+    @hypothesis.given(fstrings())
+    def test_uncompyle_fstring(fstring):
+        """Verify uncompyling fstring bytecode"""
+        run_test(fstring)
+
+
+    @pytest.mark.skipif(PYTHON_VERSION != 3.6, reason='need Python 3.6+')
+    @pytest.mark.parametrize('fstring', [
+        "f'{abc}{abc!s}'",
+        "f'{abc}0'",
+    ])
+    def test_uncompyle_direct(fstring):
+        """useful for debugging"""
+        run_test(fstring)

pytest/test_function_call.py

@@ -0,0 +1,185 @@
+import string
+from uncompyle6 import PYTHON_VERSION
+import pytest
+pytestmark = pytest.mark.skip(PYTHON_VERSION < 2.7,
+                              reason="need at least Python 2.7")
+
+if PYTHON_VERSION > 2.6:
+    from hypothesis import given, assume, example, settings, strategies as st
+    from validate import validate_uncompyle
+    from test_fstring import expressions
+
+    alpha = st.sampled_from(string.ascii_lowercase)
+    numbers = st.sampled_from(string.digits)
+    alphanum = st.sampled_from(string.ascii_lowercase + string.digits)
+
+
+    @st.composite
+    def function_calls(draw,
+                       min_keyword_args=0, max_keyword_args=5,
+                       min_positional_args=0, max_positional_args=5,
+                       min_star_args=0, max_star_args=1,
+                       min_double_star_args=0, max_double_star_args=1):
+        """
+        Strategy factory for generating function calls.
+
+        :param draw: Callable which draws examples from other strategies.
+
+        :return: The function call text.
+        """
+        st_positional_args = st.lists(
+            alpha,
+            min_size=min_positional_args,
+            max_size=max_positional_args
+        )
+        st_keyword_args = st.lists(
+            alpha,
+            min_size=min_keyword_args,
+            max_size=max_keyword_args
+        )
+        st_star_args = st.lists(
+            alpha,
+            min_size=min_star_args,
+            max_size=max_star_args
+        )
+        st_double_star_args = st.lists(
+            alpha,
+            min_size=min_double_star_args,
+            max_size=max_double_star_args
+        )
+
+        positional_args = draw(st_positional_args)
+        keyword_args = draw(st_keyword_args)
+        st_values = st.lists(
+            expressions(),
+            min_size=len(keyword_args),
+            max_size=len(keyword_args)
+        )
+        keyword_args = [
+            x + '=' + e
+            for x, e in
+            zip(keyword_args, draw(st_values))
+        ]
+        star_args = ['*' + x for x in draw(st_star_args)]
+        double_star_args = ['**' + x for x in draw(st_double_star_args)]
+
+        arguments = positional_args + keyword_args + star_args + double_star_args
+        draw(st.randoms()).shuffle(arguments)
+        arguments = ','.join(arguments)
+
+        function_call = 'fn({arguments})'.format(arguments=arguments)
+        try:
+            # TODO: Figure out the exact rules for ordering of positional, keyword,
+            # star args, double star args and in which versions the various
+            # types of arguments are supported so we don't need to check that the
+            # expression compiles like this.
+            compile(function_call, '<string>', 'single')
+        except:
+            assume(False)
+        return function_call
+
+
+    def test_function_no_args():
+        validate_uncompyle("fn()")
+
+    @pytest.mark.skipif(PYTHON_VERSION < 2.7,
+                        reason="need at least Python 2.7")
+    def isolated_function_calls(which):
+        """
+        Returns a strategy for generating function calls, but isolated to
+        particular types of arguments, for example only positional arguments.
+
+        This can help reason about debugging errors in specific types of function
+        calls.
+
+        :param which: One of 'keyword', 'positional', 'star', 'double_star'
+
+        :return: Strategy for generating an function call isolated to specific
+                 argument types.
+        """
+        kwargs = dict(
+            max_keyword_args=0,
+            max_positional_args=0,
+            max_star_args=0,
+            max_double_star_args=0,
+        )
+        kwargs['_'.join(('min', which, 'args'))] = 1
+        kwargs['_'.join(('max', which, 'args'))] = 5 if 'star' not in which else 1
+        return function_calls(**kwargs)
+
+
+    with settings(max_examples=25):
+
+        @pytest.mark.skipif(PYTHON_VERSION < 2.7,
+                            reason="need at least Python 2.7")
+        @given(isolated_function_calls('positional'))
+        @example("fn(0)")
+        def test_function_positional_only(expr):
+            validate_uncompyle(expr)
+
+        @pytest.mark.skipif(PYTHON_VERSION < 2.7,
+                            reason="need at least Python 2.7")
+        @given(isolated_function_calls('keyword'))
+        @example("fn(a=0)")
+        def test_function_call_keyword_only(expr):
+            validate_uncompyle(expr)
+
+        @pytest.mark.skipif(PYTHON_VERSION < 2.7,
+                            reason="need at least Python 2.7")
+        @given(isolated_function_calls('star'))
+        @example("fn(*items)")
+        def test_function_call_star_only(expr):
+            validate_uncompyle(expr)
+
+        @pytest.mark.skipif(PYTHON_VERSION < 2.7,
+                            reason="need at least Python 2.7")
+        @given(isolated_function_calls('double_star'))
+        @example("fn(**{})")
+        def test_function_call_double_star_only(expr):
+            validate_uncompyle(expr)
+
+
+    @pytest.mark.xfail()
+    def test_BUILD_CONST_KEY_MAP_BUILD_MAP_UNPACK_WITH_CALL_BUILD_TUPLE_CALL_FUNCTION_EX():
+        validate_uncompyle("fn(w=0,m=0,**v)")
+
+
+    @pytest.mark.xfail()
+    def test_BUILD_MAP_BUILD_MAP_UNPACK_WITH_CALL_BUILD_TUPLE_CALL_FUNCTION_EX():
+        validate_uncompyle("fn(a=0,**g)")
+
+
+    @pytest.mark.xfail()
+    def test_CALL_FUNCTION_EX():
+        validate_uncompyle("fn(*g,**j)")
+
+
+    @pytest.mark.xfail()
+    def test_BUILD_MAP_CALL_FUNCTION_EX():
+        validate_uncompyle("fn(*z,u=0)")
+
+
+    @pytest.mark.xfail()
+    def test_BUILD_TUPLE_CALL_FUNCTION_EX():
+        validate_uncompyle("fn(**a)")
+
+
+    @pytest.mark.xfail()
+    def test_BUILD_MAP_BUILD_TUPLE_BUILD_TUPLE_UNPACK_WITH_CALL_CALL_FUNCTION_EX():
+        validate_uncompyle("fn(b,b,b=0,*a)")
+
+
+    @pytest.mark.xfail()
+    def test_BUILD_TUPLE_BUILD_TUPLE_UNPACK_WITH_CALL_CALL_FUNCTION_EX():
+        validate_uncompyle("fn(*c,v)")
+
+
+    @pytest.mark.xfail()
+    def test_BUILD_CONST_KEY_MAP_CALL_FUNCTION_EX():
+        validate_uncompyle("fn(i=0,y=0,*p)")
+
+
+    @pytest.mark.skip(reason='skipping property based test until all individual tests are passing')
+    @given(function_calls())
+    def test_function_call(function_call):
+        validate_uncompyle(function_call)

pytest/test_pysource.py

@@ -8,8 +8,12 @@ from uncompyle6.semantics.consts import (
 
 if PYTHON3:
     from io import StringIO
+    def iteritems(d):
+        return d.items()
 else:
     from StringIO import StringIO
+    def iteritems(d):
+        return d.iteritems()
 
 from uncompyle6.semantics.pysource import SourceWalker as SourceWalker
 
@@ -26,7 +30,7 @@ def test_template_engine():
     # FIXME: and so on...
 
 from uncompyle6.semantics.consts import (
-    TABLE_R, TABLE_DIRECT,
+    TABLE_DIRECT, TABLE_R,
     )
 
 from uncompyle6.semantics.fragments import (
@@ -40,7 +44,7 @@ def test_tables():
             (TABLE_DIRECT, 'TABLE_DIRECT', False),
             (TABLE_R, 'TABLE_R', False),
             (TABLE_DIRECT_FRAGMENT, 'TABLE_DIRECT_FRAGMENT', True)):
-        for k, entry in t.iteritems():
+        for k, entry in iteritems(t):
             if k in skip_for_now:
                 continue
             fmt = entry[0]

pytest/test_single_compile.py

@@ -1,4 +1,7 @@
+import pytest
 from uncompyle6 import PYTHON_VERSION, code_deparse
+pytestmark = pytest.mark.skip(PYTHON_VERSION < 2.7,
+                              reason="need at least Python 2.7")
 
 if PYTHON_VERSION > 2.6:
     def test_single_mode():

pytest/validate.py

@@ -1,25 +1,28 @@
+# future
+from __future__ import print_function
 # std
 import os
 import difflib
 import subprocess
 import tempfile
-from StringIO import StringIO
-
+import functools
 # uncompyle6 / xdis
-from uncompyle6 import PYTHON_VERSION, IS_PYPY, deparse_code
+from uncompyle6 import PYTHON_VERSION, PYTHON3, IS_PYPY, deparse_code
 # TODO : I think we can get xdis to support the dis api (python 3 version) by doing something like this there
 from xdis.bytecode import Bytecode
 from xdis.main import get_opcode
 opc = get_opcode(PYTHON_VERSION, IS_PYPY)
-from StringIO import StringIO
+Bytecode = functools.partial(Bytecode, opc=opc)
+import six
 
-try:
-    import functools
-    Bytecode = functools.partial(Bytecode, opc=opc)
-    def _dis_to_text(co):
+if PYTHON3:
+    from io import StringIO
+else:
+    from StringIO import StringIO
+
+def _dis_to_text(co):
     return Bytecode(co).dis()
-except:
-    pass
+
 
 def print_diff(original, uncompyled):
     """
@@ -42,11 +45,8 @@ def print_diff(original, uncompyled):
         print('\nTo display diff highlighting run:\n    pip install BeautifulSoup4')
         diff = difflib.HtmlDiff().make_table(*args)
 
-    f = tempfile.NamedTemporaryFile(delete=False)
-    try:
+    with tempfile.NamedTemporaryFile(delete=False) as f:
         f.write(str(diff).encode('utf-8'))
-    finally:
-        f.close()
 
     try:
         print()
@@ -63,6 +63,7 @@ def print_diff(original, uncompyled):
         print('\nFor side by side diff install elinks')
         diff = difflib.Differ().compare(original_lines, uncompyled_lines)
         print('\n'.join(diff))
+    finally:
         os.unlink(f.name)
 
 
@@ -125,9 +126,8 @@ def validate_uncompyle(text, mode='exec'):
     original_text = text
 
     deparsed = deparse_code(PYTHON_VERSION, original_code,
-
                             compile_mode=mode,
-                            out=StringIO(),
+                            out=six.StringIO(),
                             is_pypy=IS_PYPY)
     uncompyled_text = deparsed.text
     uncompyled_code = compile(uncompyled_text, '<string>', 'exec')

setup.py

@@ -1,16 +1,16 @@
 #!/usr/bin/env python
-"""Setup script for the 'uncompyle6' distribution."""
-
 import sys
 
+"""Setup script for the 'uncompyle6' distribution."""
+
 SYS_VERSION = sys.version_info[0:2]
-if not ((2, 4) <= SYS_VERSION  <= (2, 7)):
-    mess = "Python Release 2.4 .. 2.7 are supported in this code branch."
-    if ((3, 2) <= SYS_VERSION  <= (3, 8)):
-        mess += ("\nFor your Python, version %s, use the master code/branch." %
+if not ((2, 6) <= SYS_VERSION  <= (3, 8)):
+    mess = "Python Release 2.6 .. 3.8 are supported in this code branch."
+    if ((2, 4) <= SYS_VERSION <= (2, 7)):
+        mess += ("\nFor your Python, version %s, use the python-2.4 code/branch." %
                  sys.version[0:3])
-    else:
-        mess += ("\nThis package is not supported before Python 2.4. Your Python version is %s."
+    elif SYS_VERSION < (2, 4):
+        mess += ("\nThis package is not supported for Python version %s."
                  % sys.version[0:3])
     print(mess)
     raise Exception(mess)

test-unit/test_grammar.py

@@ -1,55 +0,0 @@
-import re
-import unittest
-from uncompyle6 import PYTHON_VERSION, IS_PYPY # , PYTHON_VERSION
-from uncompyle6.parser import get_python_parser, python_parser
-
-class TestGrammar(unittest.TestCase):
-    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',),
-                                    ('LOAD_CONST',),
-                                    ('JUMP_BACK',), ('JUMP_FORWARD',)])
-
-        reduced_dup_rhs = {}
-        for k in dup_rhs:
-            if k not in expect_dup_rhs:
-                reduced_dup_rhs[k] = dup_rhs[k]
-                pass
-            pass
-        for k in reduced_dup_rhs:
-            print(k, reduced_dup_rhs[k])
-        # assert not reduced_dup_rhs, reduced_dup_rhs
-
-    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__':
-    unittest.main()

test/Makefile

@@ -29,7 +29,7 @@ check:
 	$(MAKE) check-$(PYTHON_VERSION)
 
 #: Run working tests from Python 2.6 or 2.7
-check-2.4 check-2.5 check-2.6 check-2.7: check-bytecode-2 check-bytecode-3 check-bytecode-1  check-native-short
+check-2.6 check-2.7: check-bytecode-2 check-bytecode-3 check-bytecode-1 check-native-short
 
 #: Run working tests from Python 3.0
 check-3.0: check-bytecode
@@ -148,7 +148,6 @@ check-bytecode-2.3:
 
 #: Check deparsing Python 2.4
 check-bytecode-2.4:
-	$(PYTHON) test_pythonlib.py --bytecode-2.4-run --verify-run
 	$(PYTHON) test_pythonlib.py --bytecode-2.4
 
 #: Check deparsing Python 2.5
@@ -281,10 +280,6 @@ check-native-short:
 	$(PYTHON) test_pythonlib.py --bytecode-$(PYTHON_VERSION) --weak-verify $(COMPILE)
 	$(PYTHON) test_pythonlib.py --bytecode-$(PYTHON_VERSION)-run --verify-run $(COMPILE)
 
-#: Run longer Python 2.6's lib files known to be okay
-check-2.4-ok:
-	$(PYTHON) test_pythonlib.py --ok-2.4 --verify $(COMPILE)
-
 #: Run longer Python 2.6's lib files known to be okay
 check-2.6-ok:
 	$(PYTHON) test_pythonlib.py --ok-2.6 --weak-verify $(COMPILE)

test/dis-compare.py

@@ -1,8 +1,9 @@
 #!/usr/bin/env python
 # Mode: -*- python -*-
 #
-# Copyright (c) 2015, 2017 by Rocky Bernstein <rb@dustyfeet.com>
+# Copyright (c) 2015 by Rocky Bernstein <rb@dustyfeet.com>
 #
+from __future__ import print_function
 
 
 import dis, os.path

test/simple-uncompyle-code-test.py

@@ -1,6 +1,7 @@
 #!/usr/bin/env python
 
-from uncompyle6 import uncompyle
+from __future__ import print_function
+
 from uncompyle6.main import decompile
 from xdis.magics import sysinfo2float
 import sys, inspect

test/simple_source/bug25/02_yield_bug.py

@@ -1,7 +0,0 @@
-# From 2.4 test_array.py
-# In Python 2.4 and earlier "yield" is not valid and instead
-# we must use "yield None". Bug was not adding "None"
-
-def yield_bug():
-    yield None
-    return

test/simple_source/bug25/04_try_else_confuse.py

@@ -1,19 +0,0 @@
-# From 2.4 test_sax.py
-# Bug was distinguishing try from try/else
-
-def verify_empty_attrs():
-    gvqk = 3
-    try:
-        gvk = 1/0
-    except ZeroDivisionError:
-        gvk = 1
-
-    try:
-        gvqk = 0
-    except KeyError:
-        gvqk = 1
-
-    # If try/else was used above the return will be 4
-    return gvk + gvqk
-
-assert 1 == verify_empty_attrs()

test/test_pyenvlib.py

@@ -20,7 +20,8 @@ Step 2: Run the test:
 	  test_pyenvlib --mylib --verify # decompile verify 'mylib'
 """
 
-from uncompyle6 import main, PYTHON3
+from __future__ import print_function
+
 import os, time, re, shutil, sys
 from fnmatch import fnmatch
 

test/test_pythonlib.py

@@ -27,6 +27,8 @@ Step 2: Run the test:
   test_pythonlib.py --mylib --verify # decompile verify 'mylib'
 """
 
+from __future__ import print_function
+
 import getopt, os, py_compile, sys, shutil, tempfile, time
 
 from uncompyle6 import PYTHON_VERSION
@@ -128,10 +130,8 @@ def do_tests(src_dir, obj_patterns, target_dir, opts):
     if opts['do_compile']:
         compiled_version = opts['compiled_version']
         if compiled_version and PYTHON_VERSION != compiled_version:
-            sys.stderr.write("Not compiling: "
-                             "desired Python version is %s "
-                             "but we are running %s" %
-                             (compiled_version, PYTHON_VERSION))
+            print("Not compiling: desired Python version is %s but we are running %s" %
+                  (compiled_version, PYTHON_VERSION), file=sys.stderr)
         else:
             for root, dirs, basenames in os.walk(src_dir):
                 file_matches(files, root, basenames, PY)
@@ -149,8 +149,8 @@ def do_tests(src_dir, obj_patterns, target_dir, opts):
         file_matches(files, dirname, basenames, obj_patterns)
 
     if not files:
-        sys.stderr.write("Didn't come up with any files to test! "
-                         "Try with --compile?")
+        print("Didn't come up with any files to test! Try with --compile?",
+              file=sys.stderr)
         exit(1)
 
     os.chdir(cwd)
@@ -164,9 +164,9 @@ def do_tests(src_dir, obj_patterns, target_dir, opts):
         except ValueError:
             pass
 
-    print time.ctime()
-    print 'Source directory: ', src_dir
-    print 'Output directory: ', target_dir
+    print(time.ctime())
+    print('Source directory: ', src_dir)
+    print('Output directory: ', target_dir)
     try:
         _, _, failed_files, failed_verify = \
           main(src_dir, target_dir, files, [],
@@ -242,13 +242,14 @@ if __name__ == '__main__':
         if os.path.isdir(src_dir):
             checked_dirs.append([src_dir, pattern, target_dir])
         else:
-            sys.stderr.write("Can't find directory %s. Skipping" % src_dir)
+            print("Can't find directory %s. Skipping" % src_dir,
+                  file=sys.stderr)
             continue
         last_compile_version = compiled_version
         pass
 
     if not checked_dirs:
-        sys.stderr.write("No directories found to check\n")
+        print("No directories found to check", file=sys.stderr)
         sys.exit(1)
 
     test_opts['compiled_version'] = last_compile_version

uncompyle6/.gitignore

@@ -1 +0,0 @@
-/.python-version

uncompyle6/bin/pydisassemble.py

@@ -3,6 +3,7 @@
 #
 # Copyright (c) 2015-2016, 2018 by Rocky Bernstein <rb@dustyfeet.com>
 #
+from __future__ import print_function
 import sys, os, getopt
 
 from uncompyle6.disas import disassemble_file
@@ -12,8 +13,8 @@ program, ext = os.path.splitext(os.path.basename(__file__))
 
 __doc__ = """
 Usage:
-  %s [OPTIONS]... FILE
-  %s [--help | -h | -V | --version]
+  {0} [OPTIONS]... FILE
+  {0} [--help | -h | -V | --version]
 
 Disassemble FILE with the instruction mangling that is done to
 assist uncompyle6 in parsing the instruction stream. For example
@@ -22,9 +23,9 @@ BUILD_LIST have arguement counts appended to the instruction name, and
 COME_FROM instructions are inserted into the instruction stream.
 
 Examples:
-  %s foo.pyc
-  %s foo.py    # same thing as above but find the file
-  %s foo.pyc bar.pyc  # disassemble foo.pyc and bar.pyc
+  {0} foo.pyc
+  {0} foo.py    # same thing as above but find the file
+  {0} foo.pyc bar.pyc  # disassemble foo.pyc and bar.pyc
 
 See also `pydisasm' from the `xdis' package.
 
@@ -32,7 +33,7 @@ Options:
   -V | --version     show version and stop
   -h | --help        show this message
 
-""" % ((program,) * 5)
+""".format(program)
 
 PATTERNS = ('*.pyc', '*.pyo')
 
@@ -41,15 +42,15 @@ def main():
 Type -h for for full help.""" % program
 
     if len(sys.argv) == 1:
-        sys.stderr.write("No file(s) given\n")
-        sys.stderr.write(Usage_short)
+        print("No file(s) given", file=sys.stderr)
+        print(Usage_short, file=sys.stderr)
         sys.exit(1)
 
     try:
         opts, files = getopt.getopt(sys.argv[1:], 'hVU',
                                     ['help', 'version', 'uncompyle6'])
-    except getopt.GetoptError(e):
-        sys.stderr.write('%s: %s' % (os.path.basename(sys.argv[0]), e))
+    except getopt.GetoptError as e:
+        print('%s: %s' % (os.path.basename(sys.argv[0]), e),  file=sys.stderr)
         sys.exit(-1)
 
     for opt, val in opts:
@@ -61,14 +62,15 @@ Type -h for for full help.""" % program
             sys.exit(0)
         else:
             print(opt)
-            sys.stderr.write(Usage_short)
+            print(Usage_short, file=sys.stderr)
             sys.exit(1)
 
     for file in files:
         if os.path.exists(files[0]):
             disassemble_file(file, sys.stdout)
         else:
-            sys.stderr.write("Can't read %s - skipping\n" % files[0])
+            print("Can't read %s - skipping" % files[0],
+                  file=sys.stderr)
             pass
         pass
     return

uncompyle6/bin/uncompile.py

@@ -4,6 +4,7 @@
 # Copyright (c) 2015-2017, 2019 by Rocky Bernstein
 # Copyright (c) 2000-2002 by hartmut Goebel <h.goebel@crazy-compilers.com>
 #
+from __future__ import print_function
 import sys, os, getopt, time
 
 program = 'uncompyle6'
@@ -66,9 +67,13 @@ def usage():
 
 
 def main_bin():
-    if not (sys.version_info[0:2] in ((2, 4), (2, 5), (2, 6), (2, 7))):
-        sys.stderr.write('Error: this branch of %s requires Python 2.4, 2.5, 2.6 or 2.7'
-                         % program)
+    if not (sys.version_info[0:2] in ((2, 6), (2, 7), (3, 0),
+                                      (3, 1), (3, 2), (3, 3),
+                                      (3, 4), (3, 5), (3, 6),
+                                      (3, 7), (3, 8)
+        )):
+        print('Error: %s requires Python 2.6-3.8' % program,
+              file=sys.stderr)
         sys.exit(-1)
 
     do_verify = recurse_dirs = False
@@ -86,8 +91,8 @@ def main_bin():
                                     'fragments verify verify-run version '
                                     'weak-verify '
                                     'showgrammar'.split(' '))
-    except getopt.GetoptError(e):
-        sys.stderr.write('%s: %s\n' % (os.path.basename(sys.argv[0]), e))
+    except getopt.GetoptError as e:
+        print('%s: %s' % (os.path.basename(sys.argv[0]), e),  file=sys.stderr)
         sys.exit(-1)
 
     options = {}
@@ -130,7 +135,7 @@ def main_bin():
         elif opt in ('--recurse', '-r'):
             recurse_dirs = True
         else:
-            sys.stderr.write(opt)
+            print(opt, file=sys.stderr)
             usage()
 
     # expand directory if specified
@@ -154,8 +159,8 @@ def main_bin():
         sb_len = len( os.path.join(src_base, '') )
         pyc_paths = [f[sb_len:] for f in pyc_paths]
 
-    if not pyc_paths:
-        sys.stderr.write("No files given\n")
+    if not pyc_paths and not source_paths:
+        print("No input files given to decompile", file=sys.stderr)
         usage()
 
     if outfile == '-':

uncompyle6/disas.py

@@ -29,6 +29,8 @@ Second, we need structured instruction information for the
 want to run on earlier Python versions.
 """
 
+from __future__ import print_function
+
 import sys
 from collections import deque
 
@@ -47,9 +49,10 @@ def disco(version, co, out=None, is_pypy=False):
 
     # store final output stream for case of error
     real_out = out or sys.stdout
-    real_out.write('# Python %s\n' % version)
+    print('# Python %s' % version, file=real_out)
     if co.co_filename:
-        real_out.write('# Embedded file name: %s\n' % co.co_filename)
+        print('# Embedded file name: %s' % co.co_filename,
+              file=real_out)
 
     scanner = get_scanner(version, is_pypy=is_pypy)
 
@@ -61,15 +64,16 @@ def disco_loop(disasm, queue, real_out):
     while len(queue) > 0:
         co = queue.popleft()
         if co.co_name != '<module>':
-            real_out.write('\n# %s line %d of %s\n' %
-                      (co.co_name, co.co_firstlineno, co.co_filename))
+            print('\n# %s line %d of %s' %
+                      (co.co_name, co.co_firstlineno, co.co_filename),
+                      file=real_out)
         tokens, customize = disasm(co)
         for t in tokens:
             if iscode(t.pattr):
                 queue.append(t.pattr)
             elif iscode(t.attr):
                 queue.append(t.attr)
-            real_out.write(t)
+            print(t, file=real_out)
             pass
         pass
 

uncompyle6/linenumbers.py

@@ -25,7 +25,7 @@ def line_number_mapping(pyc_filename, src_filename):
      source_size) = load_module(pyc_filename)
     try:
         code2 = load_file(src_filename)
-    except SyntaxError, e:
+    except SyntaxError as e:
         return str(e)
 
     queue = deque([code1, code2])

uncompyle6/main.py

@@ -12,7 +12,8 @@
 #
 #  You should have received a copy of the GNU General Public License
 #  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-import datetime, os, subprocess, sys
+from __future__ import print_function
+import datetime, py_compile, os, subprocess, sys, tempfile
 
 from uncompyle6 import verify, IS_PYPY, PYTHON_VERSION
 from xdis.code import iscode
@@ -38,7 +39,10 @@ def _get_outstream(outfile):
         os.makedirs(dir)
     except OSError:
         pass
-    return open(outfile, 'wb')
+    if PYTHON_VERSION < 3.0:
+        return open(outfile, mode='wb')
+    else:
+        return open(outfile, mode='w', encoding='utf-8')
 
 def decompile(
         bytecode_version, co, out=None, showasm=None, showast=False,
@@ -65,35 +69,20 @@ def decompile(
 
     assert iscode(co)
 
-    if is_pypy:
-        co_pypy_str = 'PyPy '
-    else:
-        co_pypy_str = ''
-
-    if IS_PYPY:
-        run_pypy_str = 'PyPy '
-    else:
-        run_pypy_str = ''
-
-    if magic_int:
-        m = str(magic_int)
-    else:
-        m = ""
-
+    co_pypy_str = 'PyPy ' if is_pypy else ''
+    run_pypy_str = 'PyPy ' if IS_PYPY else ''
     sys_version_lines = sys.version.split('\n')
     write('# uncompyle6 version %s\n'
           '# %sPython bytecode %s%s\n# Decompiled from: %sPython %s' %
           (VERSION, co_pypy_str, bytecode_version,
-               " (%s)" % m, run_pypy_str,
-           '\n# '.join(sys_version_lines)))
+               " (%s)" % str(magic_int) if magic_int else "",
+          run_pypy_str, '\n# '.join(sys_version_lines)))
     if co.co_filename:
         write('# Embedded file name: %s' % co.co_filename,)
     if timestamp:
-        write('# Compiled at: %s' %
-              datetime.datetime.fromtimestamp(timestamp))
+        write('# Compiled at: %s' % datetime.datetime.fromtimestamp(timestamp))
     if source_size:
-        real_out.write('# Size of source mod 2**32: %d bytes\n' %
-                       source_size)
+        write('# Size of source mod 2**32: %d bytes' % source_size)
 
     debug_opts = {
         'asm': showasm,
@@ -126,7 +115,7 @@ def decompile(
                                   is_pypy=is_pypy)
             pass
         return deparsed
-    except pysource.SourceWalkerError, e:
+    except pysource.SourceWalkerError as e:
         # deparsing failed
         raise pysource.SourceWalkerError(str(e))
 
@@ -225,12 +214,18 @@ def main(in_base, out_base, compiled_files, source_files, outfile=None,
                     prefix = prefix[:-len('.py')]
 
                 # Unbuffer output if possible
-                if sys.stdout.isatty():
-                    buffering = -1
+                buffering = -1 if sys.stdout.isatty() else 0
+                if PYTHON_VERSION >= 3.5:
+                    t = tempfile.NamedTemporaryFile(mode='w+b',
+                                                    buffering=buffering,
+                                                    suffix='.py',
+                                                    prefix=prefix)
                 else:
-                    buffering = 0
+                    t = tempfile.NamedTemporaryFile(mode='w+b',
+                                                    suffix='.py',
+                                                    prefix=prefix)
+                current_outfile = t.name
                 sys.stdout = os.fdopen(sys.stdout.fileno(), 'w', buffering)
-                if PYTHON_VERSION > 2.5:
                 tee = subprocess.Popen(["tee", current_outfile],
                                        stdin=subprocess.PIPE)
                 os.dup2(tee.stdin.fileno(), sys.stdout.fileno())
@@ -268,9 +263,9 @@ def main(in_base, out_base, compiled_files, source_files, outfile=None,
                     pass
                 pass
             tot_files += 1
-        except (ValueError, SyntaxError, ParserError, pysource.SourceWalkerError):
+        except (ValueError, SyntaxError, ParserError, pysource.SourceWalkerError) as e:
             sys.stdout.write("\n")
-            sys.stderr.write("# file %s\n" % (infile))
+            sys.stderr.write("\n# file %s\n# %s\n" % (infile, e))
             failed_files += 1
             tot_files += 1
         except KeyboardInterrupt:
@@ -308,16 +303,13 @@ def main(in_base, out_base, compiled_files, source_files, outfile=None,
                         else:
                             okay_files += 1
                             pass
-                    except verify.VerifyCmpError, e:
+                    except verify.VerifyCmpError as e:
                         print(e)
                         verify_failed_files += 1
                         os.rename(current_outfile, current_outfile + '_unverified')
                         sys.stderr.write("### Error Verifying %s\n" % filename)
                         sys.stderr.write(str(e) + "\n")
                         if not outfile:
-                            sys.stderr.write("### Error Verifiying %s" %
-                                            filename)
-                            sys.stderr.write(e)
                             if raise_on_error:
                                 raise
                             pass
@@ -327,15 +319,14 @@ def main(in_base, out_base, compiled_files, source_files, outfile=None,
                     okay_files += 1
                 pass
             elif do_verify:
-                sys.stderr.write("\n### uncompile successful, "
-                                 "but no file to compare against")
+                sys.stderr.write("\n### uncompile successful, but no file to compare against\n")
                 pass
             else:
                 okay_files += 1
                 if not current_outfile:
                     mess = '\n# okay decompiling'
                     # mem_usage = __memUsage()
-                    print mess, infile
+                    print(mess, infile)
         if current_outfile:
             sys.stdout.write("%s\r" %
                              status_msg(do_verify, tot_files, okay_files, failed_files,

uncompyle6/parser.py

@@ -19,6 +19,8 @@
 Common uncompyle6 parser routines.
 """
 
+from __future__ import print_function
+
 import sys
 
 from xdis.code import iscode
@@ -186,7 +188,7 @@ class PythonParser(GenericASTBuilder):
                     indent = '   '
                 else:
                     indent = '-> '
-                print "%s%s" % (indent, instructions[i])
+                print("%s%s" % (indent, instructions[i]))
             raise ParserError(err_token, err_token.offset)
         else:
             raise ParserError(None, -1)
@@ -806,4 +808,4 @@ if __name__ == '__main__':
         ast = python_parser(PYTHON_VERSION, co, showasm=True, is_pypy=IS_PYPY)
         print(ast)
         return
-    # parse_test(parse_test.__code__)
+    parse_test(parse_test.__code__)

uncompyle6/parsers/parse2.py

@@ -25,6 +25,8 @@ If we succeed in creating a parse tree, then we have a Python program
 that a later phase can turn into a sequence of ASCII text.
 """
 
+from __future__ import print_function
+
 from uncompyle6.parser import PythonParser, PythonParserSingle, nop_func
 from uncompyle6.parsers.treenode import SyntaxTree
 from spark_parser import DEFAULT_DEBUG as PARSER_DEFAULT_DEBUG

uncompyle6/parsers/parse24.py

@@ -87,6 +87,15 @@ class Python24Parser(Python25Parser):
             l = len(tokens)
             if 0 <= l < len(tokens):
                 return not int(tokens[first].pattr) == tokens[last].offset
+        elif lhs == 'try_except':
+            if last == len(tokens):
+                last -= 1
+            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 False
 

uncompyle6/parsers/parse25.py

@@ -19,9 +19,6 @@ class Python25Parser(Python26Parser):
 
         return_if_stmt ::= ret_expr  RETURN_END_IF JUMP_BACK
 
-        # We have no jumps to jumps, so no "come_froms" but a single "COME_FROM"
-        ifelsestmt ::= testexpr c_stmts_opt jf_cf_pop else_suite COME_FROM
-
         # Python 2.6 uses ROT_TWO instead of the STORE_xxx
         # withas is allowed as a "from future" in 2.5
         # 2.6 and 2.7 do something slightly different
@@ -39,8 +36,6 @@ class Python25Parser(Python26Parser):
         # loop. FIXME: should "come_froms" below be a single COME_FROM?
         tryelsestmt    ::= SETUP_EXCEPT suite_stmts_opt POP_BLOCK
                            except_handler else_suite come_froms
-        tryelsestmtl   ::= SETUP_EXCEPT suite_stmts_opt POP_BLOCK
-                            except_handler else_suitel
 
         # Python 2.6 omits the LOAD_FAST DELETE_FAST below
         # withas is allowed as a "from future" in 2.5
@@ -59,9 +54,6 @@ class Python25Parser(Python26Parser):
     def customize_grammar_rules(self, tokens, customize):
         # Remove grammar rules inherited from Python 2.6 or Python 2
         self.remove_rules("""
-        # No jump to jumps in 2.4 so we have a single "COME_FROM", not "come_froms"
-        ifelsestmt    ::= testexpr c_stmts_opt jf_cf_pop else_suite come_froms
-
         setupwith  ::= DUP_TOP LOAD_ATTR ROT_TWO LOAD_ATTR CALL_FUNCTION_0 POP_TOP
         withstmt   ::= expr setupwith SETUP_FINALLY suite_stmts_opt
                        POP_BLOCK LOAD_CONST COME_FROM WITH_CLEANUP END_FINALLY

uncompyle6/parsers/parse27.py

@@ -302,5 +302,4 @@ if __name__ == '__main__':
                              for t in remain_tokens])
         remain_tokens = set(remain_tokens) - opcode_set
         print(remain_tokens)
-        p.check_grammar()
-        p.dump_grammar()
+        # p.dump_grammar()

uncompyle6/parsers/parse3.py

@@ -31,7 +31,6 @@ from uncompyle6.parser import PythonParser, PythonParserSingle, nop_func
 from uncompyle6.parsers.treenode import SyntaxTree
 from spark_parser import DEFAULT_DEBUG as PARSER_DEFAULT_DEBUG
 from xdis import PYTHON3
-from itertools import islice,chain,repeat
 
 class Python3Parser(PythonParser):
 
@@ -1226,10 +1225,11 @@ class Python3Parser(PythonParser):
                 cfl = last
             assert tokens[cfl] == 'COME_FROM_LOOP'
 
-            if tokens[cfl-1] != 'JUMP_BACK':
-                cfl_offset = tokens[cfl-1].offset
-                insn = chain((i for i in self.insts if cfl_offset == i.offset), repeat(None)).next()
-                if insn and  insn.is_jump_target:
+            for i in range(cfl-1, first, -1):
+                if tokens[i] != 'POP_BLOCK':
+                    break
+            if tokens[i].kind not in ('JUMP_BACK', 'RETURN_VALUE'):
+                if not tokens[i].kind.startswith('COME_FROM'):
                     return True
 
             # Check that the SETUP_LOOP jumps to the offset after the

uncompyle6/parsers/parse30.py

@@ -2,6 +2,7 @@
 """
 spark grammar differences over Python 3.1 for Python 3.0.
 """
+from __future__ import print_function
 
 from uncompyle6.parser import PythonParserSingle
 from uncompyle6.parsers.parse31 import Python31Parser

uncompyle6/parsers/parse31.py

@@ -2,6 +2,7 @@
 """
 spark grammar differences over Python 3.2 for Python 3.1.
 """
+from __future__ import print_function
 
 from uncompyle6.parser import PythonParserSingle
 from uncompyle6.parsers.parse32 import Python32Parser

uncompyle6/parsers/parse32.py

@@ -2,6 +2,8 @@
 """
 spark grammar differences over Python 3 for Python 3.2.
 """
+from __future__ import print_function
+
 from uncompyle6.parser import PythonParserSingle
 from uncompyle6.parsers.parse3 import Python3Parser
 

uncompyle6/parsers/parse33.py

@@ -2,6 +2,7 @@
 """
 spark grammar differences over Python 3.2 for Python 3.3.
 """
+from __future__ import print_function
 
 from uncompyle6.parser import PythonParserSingle
 from uncompyle6.parsers.parse32 import Python32Parser

uncompyle6/parsers/parse35.py

@@ -2,6 +2,7 @@
 """
 spark grammar differences over Python 3.4 for Python 3.5.
 """
+from __future__ import print_function
 
 from uncompyle6.parser import PythonParserSingle, nop_func
 from spark_parser import DEFAULT_DEBUG as PARSER_DEFAULT_DEBUG

uncompyle6/parsers/parse36.py

@@ -15,6 +15,7 @@
 """
 spark grammar differences over Python 3.5 for Python 3.6.
 """
+from __future__ import print_function
 
 from uncompyle6.parser import PythonParserSingle, nop_func
 from spark_parser import DEFAULT_DEBUG as PARSER_DEFAULT_DEBUG
@@ -324,7 +325,7 @@ class Python36Parser(Python35Parser):
         if opname.startswith('CALL_FUNCTION_KW'):
             self.addRule("expr ::= call_kw36", nop_func)
             values = 'expr ' * token.attr
-            rule = "call_kw36 ::= expr %s LOAD_CONST %s" % (values, opname)
+            rule = "call_kw36 ::= expr {values} LOAD_CONST {opname}".format(**locals())
             self.add_unique_rule(rule, token.kind, token.attr, customize)
         elif opname == 'CALL_FUNCTION_EX_KW':
             # Note: this doesn't exist in 3.7 and later

uncompyle6/parsers/parse37.py

@@ -15,6 +15,7 @@
 """
 spark grammar differences over Python 3.6 for Python 3.7
 """
+from __future__ import print_function
 
 from uncompyle6.parser import PythonParserSingle
 from spark_parser import DEFAULT_DEBUG as PARSER_DEFAULT_DEBUG

uncompyle6/scanner.py

@@ -21,10 +21,13 @@ scanner/ingestion module. From here we call various version-specific
 scanners, e.g. for Python 2.7 or 3.4.
 """
 
+from __future__ import print_function
+
 from array import array
+from collections import namedtuple
 import sys
 
-from uncompyle6 import PYTHON3, IS_PYPY, PYTHON_VERSION
+from uncompyle6 import PYTHON3, IS_PYPY
 from uncompyle6.scanners.tok import Token
 import xdis
 from xdis.bytecode import (
@@ -32,11 +35,6 @@ from xdis.bytecode import (
 from xdis.magics import canonic_python_version
 from xdis.util import code2num
 
-if PYTHON_VERSION < 2.6:
-    from xdis.namedtuple24 import namedtuple
-else:
-    from collections import namedtuple
-
 # The byte code versions we support.
 # Note: these all have to be floats
 PYTHON_VERSIONS = frozenset((1.3, 1.4, 1.5,

uncompyle6/scanners/scanner15.py

@@ -13,13 +13,13 @@ import uncompyle6.scanners.scanner21 as scan
 from xdis.opcodes import opcode_15
 JUMP_OPS = opcode_15.JUMP_OPS
 
-# We base this off of 2.1 instead of the other way around
+# We base this off of 2.2 instead of the other way around
 # because we cleaned things up this way.
 # The history is that 2.7 support is the cleanest,
 # then from that we got 2.6 and so on.
 class Scanner15(scan.Scanner21):
     def __init__(self, show_asm=False):
-        scan.Scanner21.__init__(self, show_asm=False)
+        scan.Scanner21.__init__(self, show_asm)
         self.opc = opcode_15
         self.opname = opcode_15.opname
         self.version = 1.5

uncompyle6/scanners/scanner2.py

@@ -33,7 +33,7 @@ For example:
 Finally we save token information.
 """
 
-from uncompyle6 import PYTHON_VERSION
+from __future__ import print_function
 
 from copy import copy
 

uncompyle6/scanners/scanner21.py

@@ -19,7 +19,7 @@ JUMP_OPS = opcode_21.JUMP_OPS
 # then from that we got 2.6 and so on.
 class Scanner21(scan.Scanner22):
     def __init__(self, show_asm=False):
-        scan.Scanner22.__init__(self, show_asm=False)
+        scan.Scanner22.__init__(self, show_asm)
         self.opc = opcode_21
         self.opname = opcode_21.opname
         self.version = 2.1

uncompyle6/scanners/scanner22.py

@@ -19,7 +19,7 @@ JUMP_OPS = opcode_22.JUMP_OPS
 # then from that we got 2.6 and so on.
 class Scanner22(scan.Scanner23):
     def __init__(self, show_asm=False):
-        scan.Scanner23.__init__(self, show_asm=False)
+        scan.Scanner23.__init__(self, show_asm)
         self.opc = opcode_22
         self.opname = opcode_22.opname
         self.version = 2.2

uncompyle6/scanners/scanner27.py

@@ -7,6 +7,8 @@ grammar parsing.
 """
 
 
+from __future__ import print_function
+
 from uncompyle6.scanners.scanner2 import Scanner2
 
 from uncompyle6 import PYTHON3

uncompyle6/scanners/scanner3.py

@@ -33,12 +33,7 @@ For example:
 Finally we save token information.
 """
 
-from uncompyle6 import PYTHON_VERSION
-
-if PYTHON_VERSION < 2.6:
-    from xdis.namedtuple24 import namedtuple
-else:
-    from collections import namedtuple
+from __future__ import print_function
 
 from xdis.code import iscode
 from xdis.bytecode import instruction_size, _get_const_info
@@ -188,9 +183,6 @@ class Scanner3(Scanner):
         cause specific rules for the specific number of arguments they take.
         """
 
-        if not show_asm:
-            show_asm = self.show_asm
-
         if not show_asm:
             show_asm = self.show_asm
 

uncompyle6/scanners/scanner30.py

@@ -6,6 +6,8 @@ This sets up opcodes Python's 3.0 and calls a generalized
 scanner routine for Python 3.
 """
 
+from __future__ import print_function
+
 # bytecode verification, verify(), uses JUMP_OPs from here
 from xdis.opcodes import opcode_30 as opc
 from xdis.bytecode import instruction_size

uncompyle6/scanners/scanner31.py

@@ -6,6 +6,8 @@ This sets up opcodes Python's 3.1 and calls a generalized
 scanner routine for Python 3.
 """
 
+from __future__ import print_function
+
 # bytecode verification, verify(), uses JUMP_OPs from here
 from xdis.opcodes import opcode_31 as opc
 JUMP_OPS = opc.JUMP_OPS

uncompyle6/scanners/scanner32.py

@@ -9,6 +9,8 @@ This sets up opcodes Python's 3.2 and calls a generalized
 scanner routine for Python 3.
 """
 
+from __future__ import print_function
+
 # bytecode verification, verify(), uses JUMP_OPs from here
 from xdis.opcodes import opcode_32 as opc
 JUMP_OPS = opc.JUMP_OPS

uncompyle6/scanners/scanner33.py

@@ -19,6 +19,8 @@ This sets up opcodes Python's 3.3 and calls a generalized
 scanner routine for Python 3.
 """
 
+from __future__ import print_function
+
 # bytecode verification, verify(), uses JUMP_OPs from here
 from xdis.opcodes import opcode_33 as opc
 JUMP_OPS = opc.JUMP_OPS

uncompyle6/scanners/scanner34.py

@@ -22,6 +22,8 @@ This sets up opcodes Python's 3.4 and calls a generalized
 scanner routine for Python 3.
 """
 
+from __future__ import print_function
+
 from xdis.opcodes import opcode_34 as opc
 
 # bytecode verification, verify(), uses JUMP_OPs from here