Merge branch 'python-3.6-to-3.10' into python-3.3-to-3.5

Fix when parsing NOP

.circleci/config.yml

@@ -1,80 +0,0 @@
-version: 2
-filters:
-  branches:
-    only: master
-jobs:
-  build:
-    working_directory: ~/rocky/python-uncompyle6
-    parallelism: 1
-    shell: /bin/bash --login
-    # CircleCI 2.0 does not support environment variables that refer to each other the same way as 1.0 did.
-    # If any of these refer to each other, rewrite them so that they don't or see https://circleci.com/docs/2.0/env-vars/#interpolating-environment-variables-to-set-other-environment-variables .
-    environment:
-      CIRCLE_ARTIFACTS: /tmp/circleci-artifacts
-      CIRCLE_TEST_REPORTS: /tmp/circleci-test-results
-      COMPILE: --compile
-    # To see the list of pre-built images that CircleCI provides for most common languages see
-    # https://circleci.com/docs/2.0/circleci-images/
-    docker:
-      - image: circleci/python:3.8
-    steps:
-      # Machine Setup
-      #   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
-      # The following `checkout` command checks out your code to your working directory. In 1.0 we did this implicitly. In 2.0 you can choose where in the course of a job your code should be checked out.
-      - checkout
-      # Prepare for artifact and test results  collection equivalent to how it was done on 1.0.
-      # In many cases you can simplify this from what is generated here.
-      # 'See docs on artifact collection here https://circleci.com/docs/2.0/artifacts/'
-      - run: mkdir -p $CIRCLE_ARTIFACTS $CIRCLE_TEST_REPORTS
-      # This is based on your 1.0 configuration file or project settings
-      - run:
-          working_directory: ~/rocky/python-uncompyle6
-          command: pip install --user virtualenv && pip install --user nose && pip install
-            --user pep8
-      # Dependencies
-      #   This would typically go in either a build or a build-and-test job when using workflows
-      # Restore the dependency cache
-      - restore_cache:
-          keys:
-            - v2-dependencies-{{ .Branch }}-
-            # fallback to using the latest cache if no exact match is found
-            - v2-dependencies-
-
-      - run:
-          command: | # Use pip to install dependengcies
-            sudo pip install --user --upgrade setuptools
-            # Until the next release
-            sudo pip install git+https://github.com/rocky/python-xdis#egg=xdis
-            pip install --user -e .
-            pip install --user -r requirements-dev.txt
-
-      # Save dependency cache
-      - save_cache:
-          key: v2-dependencies-{{ .Branch }}-{{ epoch }}
-          paths:
-            # This is a broad list of cache paths to include many possible development environments
-            # You can probably delete some of these entries
-            - vendor/bundle
-            - ~/virtualenvs
-            - ~/.m2
-            - ~/.ivy2
-            - ~/.bundle
-            - ~/.cache/bower
-
-      # 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: sudo python ./setup.py develop && make check-3.6
-      - run: cd ./test/stdlib && 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
-      - store_test_results:
-          path: /tmp/circleci-test-results
-      # Save artifacts
-      - store_artifacts:
-          path: /tmp/circleci-artifacts
-      - store_artifacts:
-          path: /tmp/circleci-test-results
-    # The resource_class feature allows configuring CPU and RAM resources for each job. Different resource classes are available for different executors. https://circleci.com/docs/2.0/configuration-reference/#resourceclass
-    resource_class: large

.github/FUNDING.yml

@@ -6,7 +6,7 @@ open_collective: # Replace with a single Open Collective username
 ko_fi: # Replace with a single Ko-fi username
 tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
 community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
-liberapay: # Replace with a single Liberapay username
+liberapay: rocky
 issuehunt: # Replace with a single IssueHunt username
 otechie: # Replace with a single Otechie username
 custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

.github/workflows/osx.yml

@@ -1,31 +0,0 @@
-name: uncompyle6 (osx)
-
-on:
-  push:
-    branches: [ master ]
-  pull_request:
-    branches: [ master ]
-
-jobs:
-  build:
-    runs-on: macos-latest
-    strategy:
-      matrix:
-        os: [macOS]
-        python-version: [3.7, 3.8]
-    steps:
-    - uses: actions/checkout@v2
-    - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@v2
-      with:
-        python-version: ${{ matrix.python-version }}
-    - name: Install dependencies
-      run: |
-        python -m pip install --upgrade pip
-        # Until the next xdis release
-        pip install git+https://github.com/rocky/python-xdis#egg=xdis
-        pip install -e .
-        pip install -r requirements-dev.txt
-    - name: Test uncompyle6
-      run: |
-        make check

.github/workflows/ubuntu.yml

@@ -1,30 +0,0 @@
-name: uncompyle6 (ubuntu)
-
-on:
-  push:
-    branches: [ master ]
-  pull_request:
-    branches: [ master ]
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        python-version: [3.7, 3.8]
-    steps:
-    - uses: actions/checkout@v2
-    - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@v2
-      with:
-        python-version: ${{ matrix.python-version }}
-    - name: Install dependencies
-      run: |
-        python -m pip install --upgrade pip
-        # Until the next xdis release
-        pip install git+https://github.com/rocky/python-xdis#egg=xdis
-        pip install -e .
-        pip install -r requirements-dev.txt
-    - name: Test uncompyle6
-      run: |
-        make check

.github/workflows/windows.yml

@@ -1,31 +0,0 @@
-name: uncompyle6 (windows)
-
-on:
-  push:
-    branches: [ master ]
-  pull_request:
-    branches: [ master ]
-
-jobs:
-  build:
-    runs-on: macos-latest
-    strategy:
-      matrix:
-        os: [windows]
-        python-version: [3.7, 3.8]
-    steps:
-    - uses: actions/checkout@v2
-    - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@v2
-      with:
-        python-version: ${{ matrix.python-version }}
-    - name: Install dependencies
-      run: |
-        python -m pip install --upgrade pip
-        # Until the next xdis release
-        pip install git+https://github.com/rocky/python-xdis#egg=xdis
-        pip install -e .
-        pip install -r requirements-dev.txt
-    - name: Test uncompyle6
-      run: |
-        make check

.gitignore

@@ -17,6 +17,7 @@
 /dist
 /how-to-make-a-release.txt
 /nose-*.egg
+/pycharm-venv
 /tmp
 /uncompyle6.egg-info
 /unpyc

.pre-commit-config.yaml

@@ -1,22 +0,0 @@
-default_language_version:
-  python: python
-repos:
--   repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.5.0
-    hooks:
-    - id: check-merge-conflict
-    - id: debug-statements
-      stages: [commit]
-    - id: end-of-file-fixer
-      stages: [commit]
--   repo: https://github.com/pycqa/isort
-    rev: 5.13.2
-    hooks:
-      - id: isort
-        stages: [commit]
--   repo: https://github.com/psf/black
-    rev: 23.12.1
-    hooks:
-    - id: black
-      language_version: python3
-      stages: [commit]

HOW-TO-REPORT-A-BUG.md

@@ -19,17 +19,17 @@
 
 TL;DR (too long; didn't read)
 
-* Don't do something illegal. And don't ask me to do something illegal or help you do something illegal
-* We already have an infinite supply of decompilation bugs that need fixing, and an automated mechanism for finding more. Decompilation bugs get addressed by easiness to fix and by whim. If you expect yours to be fixed ahead of those, you need to justify why.
+* Don't do something illegal. And don't ask me to do something illegal or help you do something illegal.
+* We already have an infinite supply of decompilation bugs that need fixing, and an automated mechanism for finding more. Decompilation bugs get addressed by easiness to fix and by whim. If you expect yours to be fixed ahead of those, you need to justify why. You can ask for a hand-assisted decompilation, but that is expensive and beyond what most are willing to spend. A $100 fee is needed just to look at the bytecode.
 * When asking for help, you may be asked for what you've tried on your own first. There are plenty of sources of information about this code.
-* If you are looking for *timely* help or support, well, that is typically known as a _paid_ service. I don't really have a mechanism for that since I have a full-time job. But supporting the project is an approximation.
-* Submitting a bug or issue report that is likely to get acted upon may require a bit of effort on your part to make it easy for the problem solver. If you are not willing to do that, please don't waste our time. As indicated above, supporting the project will increase the likelihood of your issue getting noticed and acted upon.
+* Bugs get fixed, slowly. Sometimes on the order of months or years. If you are looking for *timely* help or support, that is typically known as a _paid_ service.
+* Submitting a bug or issue report that is likely to get acted upon may require a bit of effort on your part to make it easy for the problem solver. If you are not willing to do that, please don't waste your or our time. Bug report may be closed with about as much thought and care as apparent in the effort to create the bug. Supporting the project however, does increase the likelihood of your issue getting noticed and acted upon.
 
 # Ethics
 
-I do not condone using this program for unethical or illegal purposes. More detestable, at least to me, is asking for help to assist you in something that might not legitimate.
+Do not use this program for unethical or illegal purposes. More detestable, at least to me, is asking for help to assist you in something that might not legitimate.
 
-Don't use the issue tracker for such solicitations. To try to stave off illegitimate behavior, you should note that the issue tracker, the code, and bugs mentioned in that are in the open: there is no
+Don't use the issue tracker for such unethical or illegal solicitations. To try to stave off illegitimate behavior, you should note that the issue tracker, the code, and bugs mentioned in that are in the open: there is no
 confidentiality. You may be asked about the authorship or claimed ownership of the bytecode. If I think something is not quite right, I may label the issue questionable which may make the it easier those who are looking for illegal activity.
 
 
@@ -37,13 +37,13 @@ confidentiality. You may be asked about the authorship or claimed ownership of t
 
 For many open-source projects bugs where the expectation is that bugs are rare, reporting bugs in a *thoughtful* way can be helpful. See also [How to Ask Questions the Smart Way](http://www.catb.org/~esr/faqs/smart-questions.html).
 
-In this project though, most of the bug reports boil down to the something like: I am trying to reverse engineer some code that I am not the author/owner and that person doesn't want me to have access to. I am hitting a problem somewhere along the line which might have to do with decompilation, but it could be something else like how the bytecode was extracted, some problem in deliberately obfuscated code, or the use some kind of Python bytecode version that isn't supported by the decompiler.
+In this project though, most of the bug reports boil down to the something like: I am trying to reverse engineer some code that I am not the author/owner and that person doesn't want me to have access to. I am hitting a problem somewhere along the line which might have to do with decompilation. But it could be something else like how the bytecode was extracted, some problem in deliberately obfuscated code, or the use some kind of Python bytecode version that isn't supported by the decompiler. Gee this stuff is complicated, here's an open source project, so maybe someone there will help me figure stuff out.
 
-While you are free to report these, unless you sponsor the project, I may close them with about the same amount of effort spent that I think was used to open the report for them. And if you spent a considerable amount of time to create the bug report but didn't follow instructions given here and in the issue template, I am sorry in advance. Just go back, read, and follow instructions.
+While you are free to report bugs, unless you sponsor the project, I may close them with about the same amount of effort spent that I think was used to open the report for them. And if you spent a considerable amount of time to create the bug report but didn't follow instructions given here and in the issue template, I am sorry in advance. Just go back, read, and follow instructions.
 
 This project already has an infinite supply of bugs that have been narrowed to the most minimal form and where I have source code to compare against. And in the unlikely event this supply runs out, I have automated means for generating *another* infinite supply.
 
-In this project the task of justifying why addressing your bug is of use to the community, and why it should be prioritized over the others, is the bug reporter's responsibility.
+The task of justifying why addressing your bug is of use to the community, and why it should be prioritized over the others, is the bug reporter's responsibility.
 
 While in the abstract, I have no problem answering questions about how to read a Python traceback or install Python software, or trying to understand what is going wrong in your particular setup, I am not a paid support person and there other things I'd rather be doing with my limited volunteer time. So save us both time, effort, and aggravation: use other avenues like StackOverflow. Again, justifying why you should receive unpaid help is the help requester's responsibility.
 

NEWS.md

@@ -1,3 +1,29 @@
+3.9.2: 2024-07-21
+=================
+
+- track xdis API changes
+- Bug fixes and lint
+
+3.9.1: 2024-05-15
+=================
+
+Lots of changes major changes. track xdis API has changes.
+
+Separate Phases more clearly:
+* disassembly
+* tokenization
+* parsing
+* abstracting to AST (more is done in newer projects)
+* printing
+
+Although we do not decompile bytecode greater than 3.8, code supports running from up to 3.12.
+
+Many bugs fixed.
+
+A lot of Linting and coding style modernization.
+
+Work done in preparation for Blackhat Asia 2024
+
 3.9.0: 2022-12-22
 =================
 

PKG-INFO

@@ -1,10 +1,355 @@
-Metadata-Version: 2.0
+Metadata-Version: 1.1
 Name: uncompyle6
-Version: 2.0.1
-Summary: Python byte-code to source-code converter
-Home-page: http://github.com/rocky/python-uncompyle6
-Author: Rocky
+Version: 3.9.1
+Summary: Python cross-version byte-code decompiler
+Home-page: https://github.com/rocky/python-uncompyle6/
+Author: Rocky Bernstein, Hartmut Goebel, John Aycock, and others
 Author-email: rb@dustyfeet.com
-License: MIT
-Description: UNKNOWN
-Platform: UNKNOWN
+License: GPL3
+Description: |buildstatus|  |Pypi Installs| |Latest Version| |Supported Python Versions|
+
+        |packagestatus|
+
+        .. contents::
+
+        uncompyle6
+        ==========
+
+        A native Python cross-version decompiler and fragment decompiler.
+        The successor to decompyle, uncompyle, and uncompyle2.
+
+
+        Introduction
+        ------------
+
+        *uncompyle6* translates Python bytecode back into equivalent Python
+        source code. It accepts bytecodes from Python version 1.0 to version
+        3.8, spanning over 24 years of Python releases. We include Dropbox's
+        Python 2.5 bytecode and some PyPy bytecodes.
+
+        Why this?
+        ---------
+
+        Ok, I'll say it: this software is amazing. It is more than your
+        normal hacky decompiler. Using compiler_ technology, the program
+        creates a parse tree of the program from the instructions; nodes at
+        the upper levels that look a little like what might come from a Python
+        AST. So we can really classify and understand what's going on in
+        sections of Python bytecode.
+
+        Building on this, another thing that makes this different from other
+        CPython bytecode decompilers is the ability to deparse just
+        *fragments* of source code and give source-code information around a
+        given bytecode offset.
+
+        I use the tree fragments to deparse fragments of code *at run time*
+        inside my trepan_ debuggers_. For that, bytecode offsets are recorded
+        and associated with fragments of the source code. This purpose,
+        although compatible with the original intention, is yet a little bit
+        different.  See this_ for more information.
+
+        Python fragment deparsing given an instruction offset is useful in
+        showing stack traces and can be incorporated into any program that
+        wants to show a location in more detail than just a line number at
+        runtime.  This code can be also used when source-code information does
+        not exist and there is just bytecode. Again, my debuggers make use of
+        this.
+
+        There were (and still are) a number of decompyle, uncompyle,
+        uncompyle2, uncompyle3 forks around. Many of them come basically from
+        the same code base, and (almost?) all of them are no longer actively
+        maintained. One was really good at decompiling Python 1.5-2.3, another
+        really good at Python 2.7, but that only. Another handles Python 3.2
+        only; another patched that and handled only 3.3.  You get the
+        idea. This code pulls all of these forks together and *moves
+        forward*. There is some serious refactoring and cleanup in this code
+        base over those old forks. Even more experimental refactoring is going
+        on in decompyle3_.
+
+        This demonstrably does the best in decompiling Python across all
+        Python versions. And even when there is another project that only
+        provides decompilation for subset of Python versions, we generally do
+        demonstrably better for those as well.
+
+        How can we tell? By taking Python bytecode that comes distributed with
+        that version of Python and decompiling these.  Among those that
+        successfully decompile, we can then make sure the resulting programs
+        are syntactically correct by running the Python interpreter for that
+        bytecode version.  Finally, in cases where the program has a test for
+        itself, we can run the check on the decompiled code.
+
+        We use an automated processes to find bugs. In the issue trackers for
+        other decompilers, you will find a number of bugs we've found along
+        the way. Very few to none of them are fixed in the other decompilers.
+
+        Requirements
+        ------------
+
+        The code in the git repository can be run from Python 2.4 to the
+        latest Python version, with the exception of Python 3.0 through
+        3.2. Volunteers are welcome to address these deficiencies if there a
+        desire to do so.
+
+        The way it does this though is by segregating consecutive Python versions into
+        git branches:
+
+        master
+           Python 3.6 and up (uses type annotations)
+        python-3.3-to-3.5
+           Python 3.3 through 3.5 (Generic Python 3)
+        python-2.4
+           Python 2.4 through 2.7 (Generic Python 2)
+
+        PyPy 3-2.4 and later works as well.
+
+        The bytecode files it can read have been tested on Python
+        bytecodes from versions 1.4, 2.1-2.7, and 3.0-3.8 and later PyPy
+        versions.
+
+        Installation
+        ------------
+
+        You can install from PyPI using the name ``uncompyle6``::
+
+            pip install uncompyle6
+
+
+        To install from source code, this project uses setup.py, so it follows the standard Python routine::
+
+            $ pip install -e .  # set up to run from source tree
+
+        or::
+
+            $ python setup.py install # may need sudo
+
+        A GNU Makefile is also provided so :code:`make install` (possibly as root or
+        sudo) will do the steps above.
+
+        Running Tests
+        -------------
+
+        ::
+
+           make check
+
+        A GNU makefile has been added to smooth over setting running the right
+        command, and running tests from fastest to slowest.
+
+        If you have remake_ installed, you can see the list of all tasks
+        including tests via :code:`remake --tasks`
+
+
+        Usage
+        -----
+
+        Run
+
+        ::
+
+        $ uncompyle6 *compiled-python-file-pyc-or-pyo*
+
+        For usage help:
+
+        ::
+
+           $ uncompyle6 -h
+
+        Verification
+        ------------
+
+        In older versions of Python it was possible to verify bytecode by
+        decompiling bytecode, and then compiling using the Python interpreter
+        for that bytecode version. Having done this, the bytecode produced
+        could be compared with the original bytecode. However as Python's code
+        generation got better, this no longer was feasible.
+
+        If you want Python syntax verification of the correctness of the
+        decompilation process, add the :code:`--syntax-verify` option. However since
+        Python syntax changes, you should use this option if the bytecode is
+        the right bytecode for the Python interpreter that will be checking
+        the syntax.
+
+        You can also cross compare the results with another version of
+        `uncompyle6` since there are sometimes regressions in decompiling
+        specific bytecode as the overall quality improves.
+
+        For Python 3.7 and 3.8, the code in decompyle3_ is generally
+        better.
+
+        Or try specific another python decompiler like uncompyle2_, unpyc37_,
+        or pycdc_.  Since the later two work differently, bugs here often
+        aren't in that, and vice versa.
+
+        There is an interesting class of these programs that is readily
+        available give stronger verification: those programs that when run
+        test themselves. Our test suite includes these.
+
+        And Python comes with another a set of programs like this: its test
+        suite for the standard library. We have some code in :code:`test/stdlib` to
+        facilitate this kind of checking too.
+
+        Known Bugs/Restrictions
+        -----------------------
+
+        The biggest known and possibly fixable (but hard) problem has to do
+        with handling control flow. (Python has probably the most diverse and
+        screwy set of compound statements I've ever seen; there
+        are "else" clauses on loops and try blocks that I suspect many
+        programmers don't know about.)
+
+        All of the Python decompilers that I have looked at have problems
+        decompiling Python's control flow. In some cases we can detect an
+        erroneous decompilation and report that.
+
+        Python support is pretty good for Python 2
+
+        On the lower end of Python versions, decompilation seems pretty good although
+        we don't have any automated testing in place for Python's distributed tests.
+        Also, we don't have a Python interpreter for versions 1.6, and 2.0.
+
+        In the Python 3 series, Python support is strongest around 3.4 or
+        3.3 and drops off as you move further away from those versions. Python
+        3.0 is weird in that it in some ways resembles 2.6 more than it does
+        3.1 or 2.7. Python 3.6 changes things drastically by using word codes
+        rather than byte codes. As a result, the jump offset field in a jump
+        instruction argument has been reduced. This makes the :code:`EXTENDED_ARG`
+        instructions are now more prevalent in jump instruction; previously
+        they had been rare.  Perhaps to compensate for the additional
+        :code:`EXTENDED_ARG` instructions, additional jump optimization has been
+        added. So in sum handling control flow by ad hoc means as is currently
+        done is worse.
+
+        Between Python 3.5, 3.6, 3.7 there have been major changes to the
+        :code:`MAKE_FUNCTION` and :code:`CALL_FUNCTION` instructions.
+
+        Python 3.8 removes :code:`SETUP_LOOP`, :code:`SETUP_EXCEPT`,
+        :code:`BREAK_LOOP`, and :code:`CONTINUE_LOOP`, instructions which may
+        make control-flow detection harder, lacking the more sophisticated
+        control-flow analysis that is planned. We'll see.
+
+        Currently not all Python magic numbers are supported. Specifically in
+        some versions of Python, notably Python 3.6, the magic number has
+        changes several times within a version.
+
+        **We support only released versions, not candidate versions.** Note
+        however that the magic of a released version is usually the same as
+        the *last* candidate version prior to release.
+
+        There are also customized Python interpreters, notably Dropbox,
+        which use their own magic and encrypt bytecode. With the exception of
+        the Dropbox's old Python 2.5 interpreter this kind of thing is not
+        handled.
+
+        We also don't handle PJOrion_ or otherwise obfuscated code. For
+        PJOrion try: PJOrion Deobfuscator_ to unscramble the bytecode to get
+        valid bytecode before trying this tool; pydecipher_ might help with that.
+
+        This program can't decompile Microsoft Windows EXE files created by
+        Py2EXE_, although we can probably decompile the code after you extract
+        the bytecode properly. `Pydeinstaller <https://github.com/charles-dyfis-net/pydeinstaller>`_ may help with unpacking Pyinstaller bundlers.
+
+        Handling pathologically long lists of expressions or statements is
+        slow. We don't handle Cython_ or MicroPython which don't use bytecode.
+
+        There are numerous bugs in decompilation. And that's true for every
+        other CPython decompiler I have encountered, even the ones that
+        claimed to be "perfect" on some particular version like 2.4.
+
+        As Python progresses decompilation also gets harder because the
+        compilation is more sophisticated and the language itself is more
+        sophisticated. I suspect that attempts there will be fewer ad-hoc
+        attempts like unpyc37_ (which is based on a 3.3 decompiler) simply
+        because it is harder to do so. The good news, at least from my
+        standpoint, is that I think I understand what's needed to address the
+        problems in a more robust way. But right now until such time as
+        project is better funded, I do not intend to make any serious effort
+        to support Python versions 3.8 or 3.9, including bugs that might come
+        in. I imagine at some point I may be interested in it.
+
+        You can easily find bugs by running the tests against the standard
+        test suite that Python uses to check itself. At any given time, there are
+        dozens of known problems that are pretty well isolated and that could
+        be solved if one were to put in the time to do so. The problem is that
+        there aren't that many people who have been working on bug fixing.
+
+        Some of the bugs in 3.7 and 3.8 are simply a matter of back-porting
+        the fixes in decompyle3. Volunteers are welcome to do so.
+
+        You may run across a bug, that you want to report. Please do so after
+        reading `How to report a bug
+        <https://github.com/rocky/python-uncompyle6/blob/master/HOW-TO-REPORT-A-BUG.md>`_ and
+        follow the `instructions when opening an issue <https://github.com/rocky/python-uncompyle6/issues/new?assignees=&labels=&template=bug-report.md>`_.
+
+        Be aware that it might not get my attention for a while. If you
+        sponsor or support the project in some way, I'll prioritize your
+        issues above the queue of other things I might be doing instead.
+
+        See Also
+        --------
+
+        * https://github.com/rocky/python-decompile3 : Much smaller and more modern code, focusing on 3.7 and 3.8. Changes in that will get migrated back here.
+        * https://code.google.com/archive/p/unpyc3/ : supports Python 3.2 only. The above projects use a different decompiling technique than what is used here. Currently unmaintained.
+        * https://github.com/figment/unpyc3/ : fork of above, but supports Python 3.3 only. Includes some fixes like supporting function annotations. Currently unmaintained.
+        * https://github.com/wibiti/uncompyle2 : supports Python 2.7 only, but does that fairly well. There are situations where :code:`uncompyle6` results are incorrect while :code:`uncompyle2` results are not, but more often uncompyle6 is correct when uncompyle2 is not. Because :code:`uncompyle6` adheres to accuracy over idiomatic Python, :code:`uncompyle2` can produce more natural-looking code when it is correct. Currently :code:`uncompyle2` is lightly maintained. See its issue `tracker <https://github.com/wibiti/uncompyle2/issues>`_ for more details.
+        * `How to report a bug <https://github.com/rocky/python-uncompyle6/blob/master/HOW-TO-REPORT-A-BUG.md>`_
+        * The HISTORY_ file.
+        * https://github.com/rocky/python-xdis : Cross Python version disassembler
+        * https://github.com/rocky/python-xasm : Cross Python version assembler
+        * https://github.com/rocky/python-uncompyle6/wiki : Wiki Documents which describe the code and aspects of it in more detail
+        * https://github.com/zrax/pycdc : The README for this C++ code says it aims to support all versions of Python. You can aim your slign shot for the moon too, but I doubt you are going to hit it. This code is best for Python versions around 2.7 and 3.3 when the code was initially developed. Accuracy for current versions of Python3 and early versions of Python is lacking. Without major effort, it is unlikely it can be made to support current Python 3. See its `issue tracker <https://github.com/zrax/pycdc/issues>`_ for details. Currently lightly maintained.
+
+
+        .. _Cython: https://en.wikipedia.org/wiki/Cython
+        .. _trepan: https://pypi.python.org/pypi/trepan3k
+        .. _compiler: https://github.com/rocky/python-uncompyle6/wiki/How-does-this-code-work%3F
+        .. _HISTORY: https://github.com/rocky/python-uncompyle6/blob/master/HISTORY.md
+        .. _report_bug: https://github.com/rocky/python-uncompyle6/blob/master/HOW-TO-REPORT-A-BUG.md
+        .. _debuggers: https://pypi.python.org/pypi/trepan3k
+        .. _remake: https://bashdb.sf.net/remake
+        .. _pycdc: https://github.com/zrax/pycdc
+        .. _decompyle3: https://github.com/rocky/python-decompile3
+        .. _uncompyle2: https://github.com/wibiti/uncompyle2
+        .. _unpyc37: https://github.com/andrew-tavera/unpyc37
+        .. _this: https://github.com/rocky/python-uncompyle6/wiki/Deparsing-technology-and-its-use-in-exact-location-reporting
+        .. |buildstatus| image:: https://travis-ci.org/rocky/python-uncompyle6.svg
+        		 :target: https://travis-ci.org/rocky/python-uncompyle6
+        .. |packagestatus| image:: https://repology.org/badge/vertical-allrepos/python:uncompyle6.svg
+        		 :target: https://repology.org/project/python:uncompyle6/versions
+        .. _PJOrion: http://www.koreanrandom.com/forum/topic/15280-pjorion-%D1%80%D0%B5%D0%B4%D0%B0%D0%BA%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5-%D0%BA%D0%BE%D0%BC%D0%BF%D0%B8%D0%BB%D1%8F%D1%86%D0%B8%D1%8F-%D0%B4%D0%B5%D0%BA%D0%BE%D0%BC%D0%BF%D0%B8%D0%BB%D1%8F%D1%86%D0%B8%D1%8F-%D0%BE%D0%B1%D1%84
+        .. _pydecipher: https://github.com/mitre/pydecipher
+        .. _Deobfuscator: https://github.com/extremecoders-re/PjOrion-Deobfuscator
+        .. _Py2EXE: https://en.wikipedia.org/wiki/Py2exe
+        .. |Supported Python Versions| image:: https://img.shields.io/pypi/pyversions/uncompyle6.svg
+        .. |Latest Version| image:: https://badge.fury.io/py/uncompyle6.svg
+        		 :target: https://badge.fury.io/py/uncompyle6
+        .. |Pypi Installs| image:: https://pepy.tech/badge/uncompyle6/month
+
+
+Platform: uncompyle6
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.4
+Classifier: Programming Language :: Python :: 2.5
+Classifier: Programming Language :: Python :: 2.6
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.0
+Classifier: Programming Language :: Python :: 3.1
+Classifier: Programming Language :: Python :: 3.2
+Classifier: Programming Language :: Python :: 3.3
+Classifier: Programming Language :: Python :: 3.4
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Software Development :: Debuggers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules

README.rst

@@ -162,7 +162,7 @@ the right bytecode for the Python interpreter that will be checking
 the syntax.
 
 You can also cross compare the results with another version of
-`uncompyle6` since there are sometimes regressions in decompiling
+*uncompyle6* since there are sometimes regressions in decompiling
 specific bytecode as the overall quality improves.
 
 For Python 3.7 and 3.8, the code in decompyle3_ is generally
@@ -265,7 +265,7 @@ be solved if one were to put in the time to do so. The problem is that
 there aren't that many people who have been working on bug fixing.
 
 Some of the bugs in 3.7 and 3.8 are simply a matter of back-porting
-the fixes in decompyle3. Volunteers are welcome to do so.
+the fixes in *decompyle3*. Any volunteers?
 
 You may run across a bug, that you want to report. Please do so after
 reading `How to report a bug
@@ -274,11 +274,15 @@ follow the `instructions when opening an issue <https://github.com/rocky/python-
 
 Be aware that it might not get my attention for a while. If you
 sponsor or support the project in some way, I'll prioritize your
-issues above the queue of other things I might be doing instead.
+issues above the queue of other things I might be doing instead. In
+rare situtations, I can do a hand decompilation of bytecode for a fee.
+However this is expansive, usually beyond what most people are willing
+to spend.
 
 See Also
 --------
 
+* https://rocky.github.io/blackhat-asia-2024-additional/all-notes-print.html :  How to Read and Write a High-Level Bytecode Decompiler: ``uncompyle6`` ``decompyle3`` -- BlackHat 2024 Asia (`video <https://www.youtube.com/watch?v=NA77SFncppE>`_. A big thanks to the Organizers and Reviewers for letting me speak. This kind of thing encourages me to work on projects like this.
 * https://github.com/rocky/python-decompile3 : Much smaller and more modern code, focusing on 3.7 and 3.8. Changes in that will get migrated back here.
 * https://code.google.com/archive/p/unpyc3/ : supports Python 3.2 only. The above projects use a different decompiling technique than what is used here. Currently unmaintained.
 * https://github.com/figment/unpyc3/ : fork of above, but supports Python 3.3 only. Includes some fixes like supporting function annotations. Currently unmaintained.
@@ -303,8 +307,8 @@ See Also
 .. _uncompyle2: https://github.com/wibiti/uncompyle2
 .. _unpyc37: https://github.com/andrew-tavera/unpyc37
 .. _this: https://github.com/rocky/python-uncompyle6/wiki/Deparsing-technology-and-its-use-in-exact-location-reporting
-.. |buildstatus| image:: https://travis-ci.org/rocky/python-uncompyle6.svg
-		 :target: https://travis-ci.org/rocky/python-uncompyle6
+.. |buildstatus| image:: https://circleci.com/gh/rocky/python-uncompyle6.svg?style=svg
+		 :target: https://app.circleci.com/pipelines/github/rocky/python-uncompyle6
 .. |packagestatus| image:: https://repology.org/badge/vertical-allrepos/python:uncompyle6.svg
 		 :target: https://repology.org/project/python:uncompyle6/versions
 .. _PJOrion: http://www.koreanrandom.com/forum/topic/15280-pjorion-%D1%80%D0%B5%D0%B4%D0%B0%D0%BA%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5-%D0%BA%D0%BE%D0%BC%D0%BF%D0%B8%D0%BB%D1%8F%D1%86%D0%B8%D1%8F-%D0%B4%D0%B5%D0%BA%D0%BE%D0%BC%D0%BF%D0%B8%D0%BB%D1%8F%D1%86%D0%B8%D1%8F-%D0%BE%D0%B1%D1%84

__pkginfo__.py

@@ -62,6 +62,8 @@ classifiers = [
     "Programming Language :: Python :: 3.8",
     "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: Implementation :: PyPy",
     "Topic :: Software Development :: Debuggers",
     "Topic :: Software Development :: Libraries :: Python Modules",
@@ -77,7 +79,7 @@ entry_points = {
     ]
 }
 ftp_url = None
-install_requires = ["click", "spark-parser >= 1.8.9, < 1.9.0", "xdis >= 6.0.8, < 6.2.0"]
+install_requires = ["click", "spark-parser >= 1.8.9, < 1.9.2", "xdis >= 6.1.1, < 6.2.0"]
 
 license = "GPL3"
 mailing_list = "python-debugger@googlegroups.com"

admin-tools/.gitignore

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

admin-tools/check-3.0-3.2-versions.sh

@@ -0,0 +1,31 @@
+#!/bin/bash
+# Run tests over all Python versions in branch python-3.0-3.2
+set -e
+function finish {
+  cd $owd
+}
+
+owd=$(pwd)
+trap finish EXIT
+
+cd $(dirname ${BASH_SOURCE[0]})
+if ! source ./pyenv-3.0-3.2-versions ; then
+    exit $?
+fi
+if ! source ./setup-python-3.0.sh ; then
+    exit $?
+fi
+
+cd ..
+for version in $PYVERSIONS; do
+    echo --- $version ---
+    if ! pyenv local $version ; then
+	exit $?
+    fi
+    make clean && python setup.py develop
+    if ! make check ; then
+	exit $?
+    fi
+    echo === $version ===
+done
+finish

admin-tools/checkout_common.sh

@@ -0,0 +1,21 @@
+# Common checkout routine
+export PATH=$HOME/.pyenv/bin/pyenv:$PATH
+bs=${BASH_SOURCE[0]}
+mydir=$(dirname $bs)
+fulldir=$(readlink -f $mydir)
+
+function setup_version {
+    local repo=$1
+    version=$2
+    echo Running setup $version on $repo ...
+    (cd ../$repo && . ./admin-tools/setup-${version}.sh)
+    return $?
+}
+
+function checkout_finish {
+    branch=$1
+    cd $uncompyle6_owd
+    git checkout $branch && pyenv local $PYTHON_VERSION && git pull
+    rc=$?
+    return $rc
+}

admin-tools/make-dist-2.4-2.7.sh

@@ -3,9 +3,9 @@ PACKAGE=uncompyle6
 
 # FIXME put some of the below in a common routine
 function finish {
-  cd $owd
+  cd $make_dist_uncompyle6_owd
 }
-owd=$(pwd)
+make_dist_uncompyle6_owd=$(pwd)
 trap finish EXIT
 
 cd $(dirname ${BASH_SOURCE[0]})
@@ -21,6 +21,11 @@ source $PACKAGE/version.py
 echo $__version__
 
 for pyversion in $PYVERSIONS; do
+    echo --- $pyversion ---
+    if [[ ${pyversion:0:4} == "pypy" ]] ; then
+	echo "$pyversion - PyPy does not get special packaging"
+	continue
+    fi
     if ! pyenv local $pyversion ; then
 	exit $?
     fi
@@ -41,3 +46,4 @@ tarball=dist/${PACKAGE}-${__version_}_-tar.gz
 if [[ -f $tarball ]]; then
     rm -v dist/${PACKAGE}-${__version__}-tar.gz
 fi
+finish

admin-tools/make-dist-3.0-3.2.sh

@@ -0,0 +1,49 @@
+#!/bin/bash
+PACKAGE=uncompyle6
+
+# FIXME put some of the below in a common routine
+function finish {
+  cd $uncompyle6_30_make_dist_owd
+}
+
+cd $(dirname ${BASH_SOURCE[0]})
+uncompyle6_30_make_dist_owd=$(pwd)
+trap finish EXIT
+
+if ! source ./pyenv-3.0-3.2-versions ; then
+    exit $?
+fi
+if ! source ./setup-python-3.0.sh ; then
+    exit $?
+fi
+
+cd ..
+source $PACKAGE/version.py
+echo $__version__
+
+for pyversion in $PYVERSIONS; do
+    echo --- $pyversion ---
+    if [[ ${pyversion:0:4} == "pypy" ]] ; then
+	echo "$pyversion - PyPy does not get special packaging"
+	continue
+    fi
+    if ! pyenv local $pyversion ; then
+	exit $?
+    fi
+    # pip bdist_egg create too-general wheels. So
+    # we narrow that by moving the generated wheel.
+
+    # Pick out first two number of version, e.g. 3.5.1 -> 35
+    first_two=$(echo $pyversion | cut -d'.' -f 1-2 | sed -e 's/\.//')
+    rm -fr build
+    python setup.py bdist_egg bdist_wheel
+    mv -v dist/${PACKAGE}-$__version__-{py2.py3,py$first_two}-none-any.whl
+    echo === $pyversion ===
+done
+
+python ./setup.py sdist
+tarball=dist/${PACKAGE}-${__version__}.tar.gz
+if [[ -f $tarball ]]; then
+    mv -v $tarball dist/${PACKAGE}_31-${__version__}.tar.gz
+fi
+finish

admin-tools/make-dist-3.3-3.5.sh

@@ -3,11 +3,11 @@ PACKAGE=uncompyle6
 
 # FIXME put some of the below in a common routine
 function finish {
-  cd $owd
+  cd $uncompyle6_33_make_owd
 }
 
 cd $(dirname ${BASH_SOURCE[0]})
-owd=$(pwd)
+uncompyle6_33_make_owd=$(pwd)
 trap finish EXIT
 
 if ! source ./pyenv-3.3-3.5-versions ; then
@@ -22,6 +22,11 @@ source $PACKAGE/version.py
 echo $__version__
 
 for pyversion in $PYVERSIONS; do
+    echo --- $pyversion ---
+    if [[ ${pyversion:0:4} == "pypy" ]] ; then
+	echo "$pyversion - PyPy does not get special packaging"
+	continue
+    fi
     if ! pyenv local $pyversion ; then
 	exit $?
     fi
@@ -33,6 +38,12 @@ for pyversion in $PYVERSIONS; do
     rm -fr build
     python setup.py bdist_egg bdist_wheel
     mv -v dist/${PACKAGE}-$__version__-{py2.py3,py$first_two}-none-any.whl
+    echo === $pyversion ===
 done
 
 python ./setup.py sdist
+tarball=dist/${PACKAGE}-${__version__}.tar.gz
+if [[ -f $tarball ]]; then
+    mv -v $tarball dist/${PACKAGE}_31-${__version__}.tar.gz
+fi
+finish

admin-tools/make-dist-newest.sh

@@ -3,11 +3,11 @@ PACKAGE=uncompyle6
 
 # FIXME put some of the below in a common routine
 function finish {
-  cd $owd
+  cd $make_uncompyle6_newest_owd
 }
 
 cd $(dirname ${BASH_SOURCE[0]})
-owd=$(pwd)
+make_uncompyle6_newest_owd=$(pwd)
 trap finish EXIT
 
 if ! source ./pyenv-newest-versions ; then
@@ -22,6 +22,11 @@ source $PACKAGE/version.py
 echo $__version__
 
 for pyversion in $PYVERSIONS; do
+    echo --- $pyversion ---
+    if [[ ${pyversion:0:4} == "pypy" ]] ; then
+	echo "$pyversion - PyPy does not get special packaging"
+	continue
+    fi
     if ! pyenv local $pyversion ; then
 	exit $?
     fi
@@ -36,3 +41,4 @@ for pyversion in $PYVERSIONS; do
 done
 
 python ./setup.py sdist
+finish

admin-tools/merge-for-2.4.sh

@@ -1,7 +1,7 @@
 #/bin/bash
-owd=$(pwd)
+uncompyle6_merge_24_owd=$(pwd)
 cd $(dirname ${BASH_SOURCE[0]})
 if . ./setup-python-2.4.sh; then
     git merge python-3.0-to-3.2
 fi
-cd $owd
+cd $uncompyle6_merge_24_owd

admin-tools/merge-for-3.0.sh

@@ -1,7 +1,7 @@
 #/bin/bash
-owd=$(pwd)
+uncompyle6_merge_30_owd=$(pwd)
 cd $(dirname ${BASH_SOURCE[0]})
 if . ./setup-python-3.0.sh; then
     git merge python-3.3-to-3.5
 fi
-cd $owd
+cd $uncompyle6_merge_30_owd

admin-tools/merge-for-3.3.sh

@@ -1,7 +1,7 @@
 #/bin/bash
-owd=$(pwd)
+uncompyle6_merge_33_owd=$(pwd)
 cd $(dirname ${BASH_SOURCE[0]})
 if . ./setup-python-3.3.sh; then
-    git merge master
+    git merge python-3.6-to-3.10
 fi
-cd $owd
+cd $uncompyle6_merge_33_owd

admin-tools/merge-for-3.6.sh

@@ -0,0 +1,7 @@
+#/bin/bash
+uncompyle6_merge_36_owd=$(pwd)
+cd $(dirname ${BASH_SOURCE[0]})
+if . ./setup-python-3.6.sh; then
+    git merge master
+fi
+cd $uncompyle6_merge_36_owd

admin-tools/pyenv-3.3-3.5-versions

@@ -5,4 +5,4 @@ if [[ $0 == ${BASH_SOURCE[0]} ]] ; then
     echo "This script should be *sourced* rather than run directly through bash"
     exit 1
 fi
-export PYVERSIONS='3.5.10 3.3.7 3.4.10'
+export PYVERSIONS=' 3.3.7 3.4.10 3.5.10 '

admin-tools/setup-master.sh

@@ -1,32 +1,20 @@
 #!/bin/bash
 # Check out master branch and dependent development master branches
-PYTHON_VERSION=3.8.18
-
 bs=${BASH_SOURCE[0]}
 if [[ $0 == $bs ]] ; then
     echo "This script should be *sourced* rather than run directly through bash"
     exit 1
 fi
 
-function checkout_version {
-    local repo=$1
-    version=${2:-master}
-    echo Checking out $version on $repo ...
-    (cd ../$repo && git checkout $version && pyenv local $PYTHON_VERSION) && \
-	git pull
-    return $?
-}
-
-owd=$(pwd)
-
-export PATH=$HOME/.pyenv/bin/pyenv:$PATH
+PYTHON_VERSION=3.12
 
+uncompyle6_owd=$(pwd)
 mydir=$(dirname $bs)
 fulldir=$(readlink -f $mydir)
+cd $mydir
+. ./checkout_common.sh
 cd $fulldir/..
-(cd $fulldir/.. && checkout_version python-spark && checkout_version python-xdis &&
-     checkout_version python-uncompyle6)
-
-git pull
-rm -v */.python-version || true
-cd $owd
+(cd $fulldir/.. && \
+     setup_version python-spark master && \
+     setup_version python-xdis master )
+checkout_finish master

admin-tools/setup-python-2.4.sh

@@ -1,32 +1,23 @@
 #!/bin/bash
 # Check out python-2.4-to-2.7 and dependent development branches.
 
-PYTHON_VERSION=2.4.6
-
 bs=${BASH_SOURCE[0]}
 if [[ $0 == $bs ]] ; then
     echo "This script should be *sourced* rather than run directly through bash"
     exit 1
 fi
 
-function checkout_version {
-    local repo=$1
-    version=${2:-python-2.4-to-2.7}
-    echo Checking out $version on $repo ...
-    (cd ../$repo && git checkout $version && pyenv local $PYTHON_VERSION) && \
-	git pull
-    return $?
-}
-
-owd=$(pwd)
-
-export PATH=$HOME/.pyenv/bin/pyenv:$PATH
+PYTHON_VERSION=2.4
 
+uncompyle6_owd=$(pwd)
 mydir=$(dirname $bs)
 fulldir=$(readlink -f $mydir)
-(cd $fulldir/.. && checkout_version python-spark && checkout_version python-xdis python-2.4-to-2.7 &&
-     checkout_version python-uncompyle6)
+cd $mydir
+. ./checkout_common.sh
 
-git pull
-rm -v */.python-version || true
-cd $owd
+(cd $fulldir/.. && \
+     setup_version python-spark python-2.4 && \
+     setup_version python-xdis python-2.4)
+
+
+checkout_finish python-2.4-to-2.7

admin-tools/setup-python-3.0.sh

@@ -1,35 +1,20 @@
 #!/bin/bash
 # Check out python-3.0-to-3.2 and dependent development branches.
-
-PYTHON_VERSION=3.0.1
-
 bs=${BASH_SOURCE[0]}
 if [[ $0 == $bs ]] ; then
     echo "This script should be *sourced* rather than run directly through bash"
     exit 1
 fi
 
-# FIXME put some of the below in a common routine
-function checkout_version {
-    local repo=$1
-    version=${2:-python-3.0-to-3.2}
-    echo Checking out $version on $repo ...
-    (cd ../$repo && git checkout $version && pyenv local $PYTHON_VERSION) && \
-	git pull
-    return $?
-}
-
-owd=$(pwd)
-trap finish EXIT
-
-export PATH=$HOME/.pyenv/bin/pyenv:$PATH
+PYTHON_VERSION=3.0
 
+uncompyle6_owd=$(pwd)
 mydir=$(dirname $bs)
 fulldir=$(readlink -f $mydir)
-cd $fulldir/..
-(cd $fulldir/.. && checkout_version python-spark master && checkout_version python-xdis &&
-      checkout_version python-uncompyle6)
+cd $mydir
+. ./checkout_common.sh
+(cd $fulldir/.. && \
+     setup_version python-spark python-3.0 && \
+     setup_version python-xdis python-3.0)
 
-git pull
-rm -v */.python-version || true
-cd $owd
+checkout_finish python-3.0-to-3.2

admin-tools/setup-python-3.3.sh

@@ -1,34 +1,21 @@
 #!/bin/bash
 # Check out python-3.3-to-3.5 and dependent development branches.
-PYTHON_VERSION=3.3.7
-
 bs=${BASH_SOURCE[0]}
 if [[ $0 == $bs ]] ; then
     echo "This script should be *sourced* rather than run directly through bash"
     exit 1
 fi
 
-# FIXME put some of the below in a common routine
-function checkout_version {
-    local repo=$1
-    version=${2:-python-3.3-to-3.5}
-    echo Checking out $version on $repo ...
-    (cd ../$repo && git checkout $version && pyenv local $PYTHON_VERSION) && \
-	git pull
-    return $?
-}
-
-owd=$(pwd)
-
-export PATH=$HOME/.pyenv/bin/pyenv:$PATH
+PYTHON_VERSION=3.3
 
+uncompyle6_owd=$(pwd)
 mydir=$(dirname $bs)
+cd $mydir
 fulldir=$(readlink -f $mydir)
+. ./checkout_common.sh
 cd $fulldir/..
-(cd $fulldir/.. && checkout_version python-spark master && checkout_version python-xdis &&
-     checkout_version python-uncompyle6)
-rm -v */.python-version || true
+(cd $fulldir/.. && \
+     setup_version python-spark python-3.3 && \
+     setup_version python-xdis python-3.3 )
 
-git pull
-rm -v */.python-version || true
-cd $owd
+checkout_finish python-3.3-to-3.5

admin-tools/setup-python-3.6.sh

@@ -0,0 +1,21 @@
+#!/bin/bash
+# Check out python-3.6-to-3.10 and dependent development branches.
+bs=${BASH_SOURCE[0]}
+if [[ $0 == $bs ]] ; then
+    echo "This script should be *sourced* rather than run directly through bash"
+    exit 1
+fi
+
+PYTHON_VERSION=3.6
+
+uncompyle6_owd=$(pwd)
+mydir=$(dirname $bs)
+cd $mydir
+fulldir=$(readlink -f $mydir)
+. ./checkout_common.sh
+cd $fulldir/..
+(cd $fulldir/.. && \
+     setup_version python-spark python-3.6 && \
+     setup_version python-xdis python-3.6 )
+
+checkout_finish python-3.6-to-3.10

pytest/test_grammar.py

@@ -123,6 +123,7 @@ def test_grammar():
             opcode_set.add("THEN")
         check_tokens(tokens, opcode_set)
     elif PYTHON_VERSION_TRIPLE[:2] == (3, 4):
+        ignore_set.add("LOAD_ARG")  # Used in grammar for comprehension. But not in 3.4
         ignore_set.add("LOAD_CLASSNAME")
         ignore_set.add("STORE_LOCALS")
         opcode_set = set(s.opc.opname).union(ignore_set)

requirements.txt

@@ -4,6 +4,6 @@ pytest
 -e .
 
 Click~=7.0
-xdis>=6.0.4
+xdis >= 6.1.0, < 6.2.0
 configobj~=5.0.6
-setuptools~=65.5.1
+setuptools

setup-pretoml.py

@@ -0,0 +1,71 @@
+#!/usr/bin/env python
+import sys
+
+import setuptools
+
+"""Setup script for the 'uncompyle6' distribution."""
+
+SYS_VERSION = sys.version_info[0:2]
+if SYS_VERSION < (3, 6):
+    mess = "Python Release 3.6 .. 3.12 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]
+        )
+    if SYS_VERSION >= (3, 6):
+        mess += (
+            "\nFor your Python, version %s, use the master code/branch."
+            % sys.version[0:3]
+        )
+    if (3, 0) >= SYS_VERSION < (3, 3):
+        mess += (
+            "\nFor your Python, version %s, use the python-3.0-to-3.2 code/branch."
+            % sys.version[0:3]
+        )
+    if (3, 3) >= SYS_VERSION < (3, 6):
+        mess += (
+            "\nFor your Python, version %s, use the python-3.3-to-3.5 code/branch."
+            % sys.version[0:3]
+        )
+    elif SYS_VERSION < (2, 4):
+        mess += (
+            "\nThis package is not supported for Python version %s." % sys.version[0:3]
+        )
+    print(mess)
+    raise Exception(mess)
+
+from __pkginfo__ import (
+    __version__,
+    author,
+    author_email,
+    classifiers,
+    entry_points,
+    install_requires,
+    license,
+    long_description,
+    modname,
+    py_modules,
+    short_desc,
+    web,
+    zip_safe,
+)
+
+setuptools.setup(
+    author=author,
+    author_email=author_email,
+    classifiers=classifiers,
+    description=short_desc,
+    entry_points=entry_points,
+    install_requires=install_requires,
+    license=license,
+    long_description=long_description,
+    long_description_content_type="text/x-rst",
+    name=modname,
+    packages=setuptools.find_packages(),
+    py_modules=py_modules,
+    test_suite="nose.collector",
+    url=web,
+    version=__version__,
+    zip_safe=zip_safe,
+)

setup.cfg

@@ -12,10 +12,11 @@ doc_files = README.rst
 #		examples/
 
 [bdist_wheel]
-universal=1
+universal = no
 
 [metadata]
 description_file = README.rst
+licences_files = COPYING
 
 [flake8]
 # max-line-length setting: NO we do not want everyone writing 120-character lines!

setup.py

@@ -1,20 +1,25 @@
 #!/usr/bin/env python
-import setuptools
+"""Setup script for the 'uncompyle6' distribution."""
 import sys
 
-"""Setup script for the 'uncompyle6' distribution."""
+import setuptools
 
 SYS_VERSION = sys.version_info[0:2]
-if not ((2, 4) <= SYS_VERSION < (3, 13)):
-    mess = "Python Release 2.6 .. 3.12 are supported in this code branch."
+if not ((3, 3) <= SYS_VERSION < (3, 6)):
+    mess = "Python Release 3.3 .. 3.5 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]
         )
-    if (3, 3) <= SYS_VERSION < (3, 6):
+    if SYS_VERSION >= (3, 6):
         mess += (
-            "\nFor your Python, version %s, use the python-3.3-to-3.5 code/branch."
+            "\nFor your Python, version %s, use the master code/branch."
+            % sys.version[0:3]
+        )
+    if (3, 0) >= SYS_VERSION < (3, 3):
+        mess += (
+            "\nFor your Python, version %s, use the python-3.0-to-3.2 code/branch."
             % sys.version[0:3]
         )
     elif SYS_VERSION < (2, 4):
@@ -25,17 +30,17 @@ if not ((2, 4) <= SYS_VERSION < (3, 13)):
     raise Exception(mess)
 
 from __pkginfo__ import (
+    __version__,
     author,
     author_email,
+    classifiers,
+    entry_points,
     install_requires,
     license,
     long_description,
-    classifiers,
-    entry_points,
     modname,
     py_modules,
     short_desc,
-    __version__,
     web,
     zip_safe,
 )
@@ -55,7 +60,6 @@ setuptools.setup(
     py_modules=py_modules,
     test_suite="nose.collector",
     url=web,
-    tests_require=["nose>=1.0"],
     version=__version__,
     zip_safe=zip_safe,
 )

test/Makefile

@@ -115,7 +115,7 @@ check-bytecode-2:
 # FIXME: Until we shaked out problems with xdis...
 check-bytecode-3:
 	$(PYTHON) test_pythonlib.py \
-	--bytecode-3.4 --bytecode-3.5 --bytecode-3.6 \
+	--bytecode-3.3 --bytecode-3.4 --bytecode-3.5 --bytecode-3.6 \
         --bytecode-3.7  --bytecode-3.8
 
 #: Check deparsing on selected bytecode 3.x

test/ok_lib2.7/bsddb/dbshelve.py

@@ -29,6 +29,7 @@ storage.
 #------------------------------------------------------------------------
 
 import sys
+
 absolute_import = (sys.version_info[0] >= 3)
 if absolute_import :
     # Because this syntaxis is not valid before Python 2.5
@@ -229,7 +230,7 @@ class DBShelf(MutableMapping):
 
     def associate(self, secondaryDB, callback, flags=0):
         def _shelf_callback(priKey, priData, realCallback=callback):
-            # Safe in Python 2.x because expresion short circuit
+            # Safe in Python 2.x because expression short circuit
             if sys.version_info[0] < 3 or isinstance(priData, bytes) :
                 data = cPickle.loads(priData)
             else :
@@ -366,7 +367,7 @@ class DBShelfCursor:
             return None
         else:
             key, data = rec
-            # Safe in Python 2.x because expresion short circuit
+            # Safe in Python 2.x because expression short circuit
             if sys.version_info[0] < 3 or isinstance(data, bytes) :
                 return key, cPickle.loads(data)
             else :

test/simple_source/bug25/06_if_and_bugs.py

@@ -0,0 +1,18 @@
+# 2.5 Bug is from nose/plugins/cover.py
+def wantFile(self, file, package=None):
+    if self.coverInclusive:
+        if file.endswith(".py"):
+            if package and self.coverPackages:
+                for want in self.coverPackages:
+                    if package.startswith(want):
+                        return True
+            else:
+                return True
+    return None
+
+
+# 2.5 bug is from nose/plugins/doctests.py
+def wantFile2(self, file):
+    if self and (self.conf or [exc.search(file) for exc in self.conf]):
+        return True
+    return None

test/simple_source/bug26/.gitignore

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

test/simple_source/bug26/03_weird26.py

@@ -3,10 +3,10 @@
 # Grammar allows multiple adjacent 'if's in listcomps and genexps,
 # even though it's silly. Make sure it works (ifelse broke this.)
 
-[ x for x in range(10) if x % 2 if x % 3 ]
+[x for x in range(10) if x % 2 if x % 3]
 list(x for x in range(10) if x % 2 if x % 3)
 
-# expresion which evaluates True unconditionally,
+# expression which evaluates True unconditionally,
 # but leave dead code or junk around that we have to match on.
 # Tests "if_exp_true" rule
 5 if 1 else 2

test/simple_source/bug26/07_try_except.py

@@ -0,0 +1,34 @@
+# Bug portion of Issue #405 https://github.com/rocky/python-uncompyle6/issues/405
+# Bug was detecting if/else as the last item in a "try: .. except" block.
+class Saveframe(object):
+    """A saveframe. Use the classmethod from_scratch to create one."""
+
+    frame_list = {}
+
+    def frame_dict(self):
+        return
+
+    # Next line is 1477
+    def __setitem__(self, key, item):
+        # Next line is 1481
+        if isinstance(item, Saveframe):
+            try:
+                self.frame_list[key] = item
+            except TypeError:
+                if key in (self.frame_dict()):
+                    dict((frame.name, frame) for frame in self.frame_list)
+                    for pos, frame in enumerate(self.frame_list):
+                        if frame.name == key:
+                            self.frame_list[pos] = item
+                else:
+                    raise KeyError(
+                        "Saveframe with name '%s' does not exist and "
+                        "therefore cannot be written to. Use the add_saveframe method to add new saveframes."
+                        % key
+                    )
+        # Next line is 1498
+        raise ValueError("You can only assign an entry to a saveframe splice.")
+
+
+x = Saveframe()
+x.__setitem__("foo", 5)

test/simple_source/bug27+/01_module_doc.py

@@ -1,8 +1,8 @@
 # From 2.7.17 test_bdb.py
-# The problem was detecting a docstring at the begining of the module
+# The problem was detecting a docstring at the beginning of the module
 # It must be detected and change'd or else the "from __future__" below
 # is invalid.
-# Note that this has to be compiled with optimation < 2 or else optimization
+# Note that this has to be compiled with optimization < 2 or else optimization
 # will remove the docstring
 """Rational, infinite-precision, real numbers."""
 

test/simple_source/bug30/01_ops.py

@@ -1,20 +1,20 @@
 # Statements to beef up grammar coverage rules
 # Force "inplace" ops
 # Note this is like simple_source/bug22/01_ops.py
-# But we don't ahve the UNARY_CONVERT which dropped
+# But we don't have the UNARY_CONVERT which dropped
 # out around 2.7
 y = +10  # UNARY_POSITIVE
-y /= 1   # INPLACE_DIVIDE
-y %= 4   # INPLACE_MODULO
+y /= 1  # INPLACE_DIVIDE
+y %= 4  # INPLACE_MODULO
 y **= 1  # INPLACE POWER
 y >>= 2  # INPLACE_RSHIFT
 y <<= 2  # INPLACE_LSHIFT
 y //= 1  # INPLACE_TRUE_DIVIDE
-y &= 1   # INPLACE_AND
-y ^= 1   # INPLACE_XOR
+y &= 1  # INPLACE_AND
+y ^= 1  # INPLACE_XOR
 
 # Beef up aug_assign and STORE_SLICE+3
-x = [1,2,3,4,5]
+x = [1, 2, 3, 4, 5]
 x[0:1] = 1
 x[0:3] += 1, 2, 3
 

test/simple_source/bug33/04_lambda_star_default.py

@@ -1,18 +1,20 @@
 # From 3.x test_audiop.py
 
 # Bug is handling default value after * argument in a lambda.
-# That's a mouthful of desciption; I am not sure if the really
+# That's a mouthful of description; I am not sure if the really
 # hacky fix to the code is even correct.
 
 #
 # FIXME: try and test with more than one default argument.
 
+
 # RUNNABLE
 def pack(width, data):
     return (width, data)
 
+
 packs = {w: (lambda *data, width=w: pack(width, data)) for w in (1, 2, 4)}
 
-assert packs[1]('a') == (1, ('a',))
-assert packs[2]('b') == (2, ('b',))
-assert packs[4]('c') == (4, ('c',))
+assert packs[1]("a") == (1, ("a",))
+assert packs[2]("b") == (2, ("b",))
+assert packs[4]("c") == (4, ("c",))

test/simple_source/bug33/08_if_else.py

@@ -1,16 +1,19 @@
 # From python 3.3.7 trace
 # Bug was not having not having semantic rule for conditional not
 
+
 # RUNNABLE!
 def init(modules=None):
     mods = set() if not modules else set(modules)
     return mods
 
+
 assert init() == set()
 assert init([1, 2, 3]) == set([1, 2, 3])
 
+
 # From 3.6 sre_parse
-# Bug was in handling multple COME_FROMS from nested if's
+# Bug was in handling multiple COME_FROMS from nested if's
 def _escape(a, b, c, d, e):
     if a:
         if b:
@@ -24,15 +27,16 @@ def _escape(a, b, c, d, e):
             return
         raise
 
-assert _escape(False, True, True,  True,  True) is None
-assert _escape(True,  True, True,  False, True) is None
-assert _escape(True,  True, False, False, True) is None
+
+assert _escape(False, True, True, True, True) is None
+assert _escape(True, True, True, False, True) is None
+assert _escape(True, True, False, False, True) is None
 
 for args in (
-        (True, True,  True, False, True),
-        (True, False, True, True,  True),
-        (True, False, True, True,  False),
-        ):
+    (True, True, True, False, True),
+    (True, False, True, True, True),
+    (True, False, True, True, False),
+):
     try:
         _escape(*args)
         assert False, args

test/simple_source/bug34/03_ifelse_in_lambda.py

@@ -0,0 +1,4 @@
+# Next line is 1164
+def foo():
+    name = "bar"
+    lambda x: compile(x, "<register %s's commit>" % name, "exec") if x else None

test/simple_source/bug35/02_for_else_bug.py

@@ -0,0 +1,10 @@
+# Adapted 3.5 from _bootstrap_external.py
+
+
+def spec_from_file_location(loader, location):
+    if loader:
+        for _ in __file__:
+            if location:
+                break
+        else:
+            return None

test/simple_source/bug35/06_while_return.py

@@ -1,8 +1,9 @@
 # From Python 3.4 asynchat.py
-# Tests presence or absense of
+# Tests presence or absence of
 # SETUP_LOOP testexpr return_stmts POP_BLOCK COME_FROM_LOOP
 # Note: that there is no JUMP_BACK because of the return_stmts.
 
+
 def initiate_send(a, b, c, num_sent):
     while a and b:
         try:
@@ -24,6 +25,7 @@ def initiate_send2(a, b):
 
         return 2
 
+
 assert initiate_send(1, 1, 2, False) == 1
 assert initiate_send(1, 2, 3, False) == 3
 assert initiate_send(1, 2, 3, True) == 2

test/simple_source/bug36/03_fn_defaults.py

@@ -1,13 +1,20 @@
-# Python 3.6 changes, yet again, the way deafult pairs are handled
+# Python 3.6 changes, yet again, the way default pairs are handled
 def foo1(bar, baz=1):
     return 1
+
+
 def foo2(bar, baz, qux=1):
     return 2
+
+
 def foo3(bar, baz=1, qux=2):
     return 3
+
+
 def foo4(bar, baz, qux=1, quux=2):
     return 4
 
+
 # From 3.6 compileall.
 # Bug was in omitting default which when used in an "if"
 # are treated as False would be

test/simple_source/bug36/04_class_kwargs.py

@@ -1,17 +1,23 @@
 # From 3.6 test_abc.py
-# Bug was Reciever() class definition
+# Bug was Receiver() class definition
 import abc
 import unittest
+
+
 class TestABCWithInitSubclass(unittest.TestCase):
     def test_works_with_init_subclass(self):
         class ReceivesClassKwargs:
             def __init_subclass__(cls, **kwargs):
                 super().__init_subclass__()
+
         class Receiver(ReceivesClassKwargs, abc.ABC, x=1, y=2, z=3):
             pass
 
+
 def test_abstractmethod_integration(self):
     for abstractthing in [abc.abstractmethod]:
+
         class C(metaclass=abc.ABCMeta):
             @abstractthing
-            def foo(self): pass  # abstract
+            def foo(self):
+                pass  # abstract

test/simple_source/bug36/05_if_and_comp.py

@@ -1,12 +1,12 @@
 # From 3.6 base64.py
-# Bug was handling "and" condition in the presense of POP_JUMP_IF_FALSE
+# Bug was handling "and" condition in the presence of POP_JUMP_IF_FALSE
 # locations
 def _85encode(foldnuls, words):
-    return ['z' if foldnuls and word
-                else  'y'
-                for word in words]
+    return ["z" if foldnuls and word else "y" for word in words]
+
 
 # From Python 3.6 enum.py
 
+
 def __new__(metacls, cls, bases, classdict):
     {k: classdict[k] for k in classdict._member_names}

test/simple_source/bug36/09_long_whilestmt.py

@@ -0,0 +1,74 @@
+# From https://github.com/rocky/python-uncompyle6/issues/420
+# Related to EXTENDED_ARG in whilestmt
+ERRPR_CODE_DEFINE = {}  # Remove this and things works
+
+try:
+    print()
+except Exception:
+    var1 = 0
+    var2 = 1
+    if var1 or var2:
+        times = 1
+        while times != False and self.scanner.is_open():
+            try:
+                try:
+                    print()
+                except Exception:
+                    print()
+
+                out = 0
+                count = 1
+                if out == 1:
+                    break
+                elif out == 2:
+                    count += 1
+                    if times == 3:
+                        self.func.emit({})
+                        break
+                    else:
+                        continue
+                if out == 3 or out == b"":
+                    if self.times == 3:
+                        break
+                    count += 1
+                    if count == 3:
+                        count = 0
+                        if out == 4:
+                            self.func.emit(ERRPR_CODE_DEFINE.ReceiedError())
+                        else:
+                            print()
+                        break
+                    continue
+                else:
+                    count = 0
+            except Exception:
+                print("upper exception")
+    else:
+        try:
+            print("jump forward")
+            while True:
+                out = self.func.read(count)
+                if out == b"":
+                    self.func.emit(ERRPR_CODE_DEFINE.ReceiedError())
+                    break
+                    continue
+                imagedata = out[0]
+                if imagedata == b"\x05":
+                    self.func.emit(INFORMATION.UnsupportedImage())
+                    break
+                    continue
+                if imagedata == b"\x15":
+                    self.func.emit(INFORMATION.NoneImage())
+                    break
+                    continue
+                if out[1] == False:
+                    start_index = imagedata.find(b"BM6")
+                    self.func.emit(imagedata[start_index:], False)
+                    continue
+                (imagedata, all_code) = imagedata
+                self.func.emit({})
+                self.func.emit({})
+                self.func.emit({})  # remove {} and this works
+                break
+        except Exception:
+            pass

test/simple_source/bug36/10_fstring.py

@@ -14,6 +14,7 @@ assert (
 assert "def0" == f"{abc}0"
 assert "defdef" == f"{abc}{abc!s}"
 
+
 # From 3.8 test/test_string.py
 # We had the precedence of yield vs. lambda incorrect.
 def fn(x):
@@ -97,9 +98,10 @@ else:
 (x, y, width) = ("foo", 2, 10)
 assert f"x={x*y:{width}}" == "x=foofoo    "
 
+
 # Why the fact that the distinction of docstring versus stmt is a
 # string expression is important academic, but we will decompile an
-# equivalent thing. For compatiblity with older Python we'll use "%"
+# equivalent thing. For compatibility with older Python we'll use "%"
 # instead of a format string
 def f():
     f"""Not a docstring"""  # noqa

test/simple_source/bug36/10_long_pop_jump.py

@@ -1,26 +1,27 @@
 # From 3.6 _markupbase.py
 
-# Bug is that the routine is long enough that POP_JUMP_IF_FALSE instruciton has an
-# EXTENDED_ARG intruction before it and we weren't picking out the jump offset properly
+# Bug is that the routine is long enough that POP_JUMP_IF_FALSE instruction has an
+# EXTENDED_ARG instruction before it and we weren't picking out the jump offset properly
+
 
 def parse_declaration(self, i):
     if rawdata[j:j] in ("-", ""):
         return -1
     n = len(rawdata)
-    if rawdata[j:j+2] == '-':
+    if rawdata[j : j + 2] == "-":
         return self.parse_comment(i)
-    elif rawdata[j] == '[':
+    elif rawdata[j] == "[":
         return self.parse_marked_section(i)
     else:
         decltype, j = self._scan_name(j, i)
     if j < 0:
         return j
     if decltype == "d":
-        self._decl_otherchars = ''
+        self._decl_otherchars = ""
     while j < n:
         c = rawdata[j]
         if c == ">":
-            data = rawdata[i+2:j]
+            data = rawdata[i + 2 : j]
             if decltype == "d":
                 self.handle_decl(data)
             else:
@@ -43,8 +44,7 @@ def parse_declaration(self, i):
             else:
                 self.error("unexpected '[' char in declaration")
         else:
-            self.error(
-                "unexpected %r char in declaration" % rawdata[j])
+            self.error("unexpected %r char in declaration" % rawdata[j])
         if j < 0:
             return j
     return -1

test/simple_source/bug38/03_while_bug.py

@@ -0,0 +1,9 @@
+# See https://github.com/rocky/python-uncompyle6/issues/498
+# Bug was in not allowing _stmts in whilestmt38
+import time
+
+r = 0
+while r == 1:
+    print(time.time())
+    if r == 1:
+        r = 0

test/simple_source/calls/01_positional.py

@@ -1,5 +1,5 @@
 # Tests custom added grammar rule:
 #   expr ::= expr {expr}^n CALL_FUNCTION_n
-# which in the specifc case below is:
+# which in the specific case below is:
 #   expr ::= expr expr expr CALL_FUNCTION_2
 max(1, 2)

test/simple_source/looping/04_while1_while1.py

@@ -27,7 +27,7 @@ while 1:
     else:
         raise RuntimeError
 
-# Degenerate case. Note: we can't run becase this causes an infinite loop.
+# Degenerate case. Note: we can't run because this causes an infinite loop.
 # Suggested in issue #172
 while 1:
     pass

test/simple_source/operation_logic/05_control_flow_bugs.py

@@ -1,7 +1,8 @@
 # From 3.6.10 test_binascii.py
-# Bug was getting "while c and noise" parsed correclty
+# Bug was getting "while c and noise" parsed correctly
 # and not put into the "ifelsesmt"
 
+
 # RUNNABLE!
 def addnoise(c, noise):
     while c and noise:
@@ -12,6 +13,7 @@ def addnoise(c, noise):
         noise = False
     return c
 
+
 assert addnoise(0, True) == 0
 assert addnoise(1, False) == 1
 assert addnoise(2, True) == 2
@@ -19,9 +21,10 @@ assert addnoise(3, True) == 3
 assert addnoise(4, True) == 3
 assert addnoise(5, False) == 5
 
+
 # From 3.6.10 test_dbm_dumb.py
 # Bug was getting attaching "else" to the right "if" in the
-# presense of a loop.
+# presence of a loop.
 def test_random(a, r):
     x = 0
     for dummy in r:
@@ -32,11 +35,13 @@ def test_random(a, r):
             x += 1
     return x
 
+
 assert test_random(True, [1]) == 2
 assert test_random(True, [1, 1]) == 4
 assert test_random(False, [1]) == 0
 assert test_random(False, [1, 1]) == 0
 
+
 # From 2.7.17 test_frozen.py
 # Bug was getting making sure we have "try" not
 # "try"/"else"
@@ -53,11 +58,13 @@ def test_frozen(a, b):
 
     return x
 
+
 assert test_frozen(1, 1) == 4.0
 assert test_frozen(0, 1) == 5.0
 assert test_frozen(0.5, 0) == 6.0
 assert test_frozen(0, 0.5) == 8.0
 
+
 # From 3.6.10 test_binop.py
 # Bug was getting "other += 3" outside of "if"/"else.
 def __floordiv__(a, b):
@@ -70,6 +77,7 @@ def __floordiv__(a, b):
     other += 3
     return other
 
+
 assert __floordiv__(True, True) == 4
 assert __floordiv__(True, False) == 4
 assert __floordiv__(False, True) == 3

test/simple_source/operation_logic/10_mixed_boolean.py

@@ -1,19 +1,19 @@
 # Self-checking test.
-# Mixed boolean expresions
+# Mixed boolean expressions
 
 b = True
-assert b, 'b = True'
+assert b, "b = True"
 c = False
-assert not c, 'c = False'
+assert not c, "c = False"
 d = True
 a = b and c or d
-assert a, 'b and c or d'
+assert a, "b and c or d"
 a = (b or c) and d
-assert a, '(b or c) and d'
+assert a, "(b or c) and d"
 a = b or c or d
-assert  a, 'b or c or d'
+assert a, "b or c or d"
 a = b and c and d
-assert not a, 'b and c and d'
+assert not a, "b and c and d"
 a = b or c and d
 assert a
 a = b and (c or d)

test/simple_source/stmts/03_if_elif.py

@@ -1,5 +1,5 @@
 # 2.6.9 symbols.py
-# Bug in 2.6 is having multple COME_FROMs due to the
+# Bug in 2.6 is having multiple COME_FROMs due to the
 # "and" in the "if" clause
 
 # RUNNABLE
@@ -10,7 +10,7 @@ if __name__:
         assert False
 
 # 2.6.9 transformer.py
-# Bug in 2.6 is multple COME_FROMs as a result
+# Bug in 2.6 is multiple COME_FROMs as a result
 # of the "or" in the "assert"
 
 # In PyPy the assert is handled via PyPy's unique JUMP_IF_NOT_DEBUG
@@ -24,6 +24,7 @@ elif __file__:
 else:
     pass
 
+
 # From 3.3.7 test_binop.py
 # Bug was in ifelsestmt(c) ensuring b+=5 is not in "else"
 # Also note: ifelsetmtc should not have been used since this
@@ -36,6 +37,7 @@ def __floordiv__(a, b):
     b += 5
     return b
 
+
 assert __floordiv__(1, 1) == 7
 assert __floordiv__(1, 0) == 6
 assert __floordiv__(0, 3) == 8

test/simple_source/stmts/08_test_contextmanager.py

@@ -0,0 +1,21 @@
+"""
+This program is self checking!
+"""
+
+
+class TestContextManager:
+    def __enter__(self):
+        return 1, 2
+
+    def __exit__(self, exc_type, exc_value, exc_tb):
+        return self, exc_type, exc_value, exc_tb
+
+
+with open(__file__) as a:
+    assert a
+
+with open(__file__) as a, open(__file__) as b:
+    assert a.read() == b.read()
+
+with TestContextManager() as a, b:
+    assert (a, b) == (1, 2)

test/simple_source/stmts/16_bytestring_docstring.py

@@ -0,0 +1,45 @@
+"""Module docstring"""
+class A:
+    b"""Got \xe7\xfe Bytes?"""
+    assert __doc__ == b"""Got \xe7\xfe Bytes?"""
+
+    def class_func(self):
+       b"""Got \xe7\xfe Bytes?"""
+       assert __doc__ == """Module docstring"""
+
+class B:
+    """Got no Bytes?"""
+    assert __doc__ == """Got no Bytes?"""
+
+    def class_func(self):
+        """Got no Bytes?"""
+        assert __doc__ == """Module docstring"""
+
+def single_func():
+    """single docstring?"""
+    assert __doc__ == """Module docstring"""
+
+def single_byte_func():
+    b"""Got \xe7\xfe Bytes?"""
+    assert __doc__ == """Module docstring"""
+
+assert __doc__ == """Module docstring"""
+
+assert single_func.__doc__ == """single docstring?"""
+single_func()
+
+assert single_byte_func.__doc__ == b"""Got \xe7\xfe Bytes?"""
+single_byte_func()
+
+assert A.__doc__ == b"""Got \xe7\xfe Bytes?"""
+assert A.class_func.__doc__ == b"""Got \xe7\xfe Bytes?"""
+a = A()
+assert a.class_func.__doc__ == b"""Got \xe7\xfe Bytes?"""
+a.class_func()
+
+assert B.__doc__ == """Got no Bytes?"""
+assert B.class_func.__doc__ == """Got no Bytes?"""
+b = B()
+assert b.class_func.__doc__ == """Got no Bytes?"""
+b.class_func()
+

test/simple_source/stmts/16_no_bytestring_docstring.py

@@ -0,0 +1,45 @@
+"""Module docstring"""
+class A:
+    b"""Got \xe7\xfe Bytes?"""
+    assert __doc__ == """Module docstring"""
+
+    def class_func(self):
+       b"""Got \xe7\xfe Bytes?"""
+       assert __doc__ == """Module docstring"""
+
+class B:
+    """Got no Bytes?"""
+    assert __doc__ == """Got no Bytes?"""
+
+    def class_func(self):
+        """Got no Bytes?"""
+        assert __doc__ == """Module docstring"""
+
+def single_func():
+    """single docstring?"""
+    assert __doc__ == """Module docstring"""
+
+def single_byte_func():
+    b"""Got \xe7\xfe Bytes?"""
+    assert __doc__ == """Module docstring"""
+
+assert __doc__ == """Module docstring"""
+
+assert single_func.__doc__ == """single docstring?"""
+single_func()
+
+assert single_byte_func.__doc__ is None
+single_byte_func()
+
+assert A.__doc__ is None
+assert A.class_func.__doc__ is None
+a = A()
+assert a.class_func.__doc__ is None
+a.class_func()
+
+assert B.__doc__ == """Got no Bytes?"""
+assert B.class_func.__doc__ == """Got no Bytes?"""
+b = B()
+assert b.class_func.__doc__ == """Got no Bytes?"""
+b.class_func()
+

test/stdlib/2.4-exclude.sh

@@ -38,17 +38,14 @@ SKIP_TESTS=(
     [test_winreg.py]=1 # it fails on its own
     [test_winsound.py]=1 # it fails on its own
     [test_zlib.py]=1 # it fails on its own
-
-    [test_decimal.py]=1  #
+    [test_decimal.py]=1  # fails on its own - no module named test_support
     [test_dis.py]=1   # We change line numbers - duh!
-    [test_generators.py]=1  # Investigate
+    [test_generators.py]=1  # fails on its own - no module named test_support
     # [test_grammar.py]=1    # fails on its own - no module tests.test_support
     [test_grp.py]=1      # Long test - might work Control flow?
-    [test_pep247.py]=1 # Long test - might work? Control flow?
     [test_socketserver.py]=1 # -- test takes too long to run: 40 seconds
     [test_threading.py]=1 # test takes too long to run: 11 seconds
     [test_thread.py]=1 # test takes too long to run: 36 seconds
     [test_trace.py]=1 # Long test - works
-    [test_zipfile64.py]=1  # Runs ok but takes 204 seconds
 )
  # About 243 files, 0 in 19 minutes

test/stdlib/3.3-exclude.sh

@@ -10,7 +10,7 @@ SKIP_TESTS=(
     #       tgt.append(elem)
     [test_itertools.py]=1
 
-    [test_buffer.py]=pytest  # FIXME: Works on c90ff51
+    [test_buffer.py]=pytest
     [test_cmath.py]=pytest
 
     [test_atexit.py]=1  # The atexit test starting at 3.3 looks for specific comments in error lines
@@ -19,7 +19,6 @@ SKIP_TESTS=(
     [test_concurrent_futures.py]=1  # too long?
 
     [test_decimal.py]=1 # test takes too long to run: 18 seconds
-    [test_descr.py]=1  # test assertion errors
     [test_doctest.py]=1  # test assertion errors
     [test_doctest2.py]=1  # test assertion errors
     [test_dis.py]=1   # We change line numbers - duh!

test/stdlib/3.4-exclude.sh

@@ -26,7 +26,16 @@ SKIP_TESTS=(
 
     [test_dbm_gnu.py]=1   # fails on its own
     [test_devpoll.py]=1 # it fails on its own
+
     [test_descr.py]=1   # test assertion errors
+    # ERROR: test_reent_set_bases_on_base (__main__.MroTest)
+    # Traceback (most recent call last):
+    # File "test_descr.py", line 5521, in test_reent_set_bases_on_base
+    # class A(metaclass=M):
+    # File "test_descr.py", line 5472, in __new__
+    # return type.__new__(mcls, name, bases, attrs)
+    # TypeError: 'NoneType' object is not iterable
+
     [test_dis.py]=1   # We change line numbers - duh!
     [test_distutils.py]=1 # it fails on its own
     [test_doctest2.py]=1

test/test_pyenvlib.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 # emacs-mode: -*-python-*-
 """
-test_pyenvlib -- uncompyle and verify Python libraries
+test_pyenvlib -- decompile and verify Python libraries
 
 Usage-Examples:
 
@@ -20,14 +20,19 @@ Step 2: Run the test:
 	  test_pyenvlib --mylib --verify # decompile verify 'mylib'
 """
 
-from __future__ import print_function
-
-import os, time, re, shutil, sys
+# Does not work on 2.5.9 or before
+# from __future__ import print_function
+import os
+import re
+import shutil
+import sys
+import time
 from fnmatch import fnmatch
 
-from uncompyle6 import main
 import xdis.magics as magics
 
+from uncompyle6 import main
+
 # ----- configure this for your needs
 
 python_versions = [v for v in magics.python_versions if re.match("^[0-9.]+$", v)]
@@ -82,9 +87,10 @@ for vers in TEST_VERSIONS:
         if vers == "native":
             short_vers = os.path.basename(sys.path[-1])
             from xdis.version_info import PYTHON_VERSION_TRIPLE, version_tuple_to_str
+
             if PYTHON_VERSION_TRIPLE > (3, 0):
                 version = version_tuple_to_str(end=2)
-                PYC = f"*.cpython-{version}.pyc"
+                PYC = "*.cpython-%s.pyc" % version
             test_options[vers] = (sys.path[-1], PYC, short_vers)
         else:
             short_vers = vers[:3]
@@ -133,8 +139,17 @@ def do_tests(
             pass
 
     if len(files) > max_files:
-        files = [file for file in files if not "site-packages" in file and (file.endswith(".pyo") or file.endswith(".pyc"))]
-        files = [file for file in files if not "test" in file and (file.endswith(".pyo") or file.endswith(".pyc"))]
+        files = [
+            file
+            for file in files
+            if not "site-packages" in file
+            and (file.endswith(".pyo") or file.endswith(".pyc"))
+        ]
+        files = [
+            file
+            for file in files
+            if not "test" in file and (file.endswith(".pyo") or file.endswith(".pyc"))
+        ]
         if len(files) > max_files:
             # print("Number of files %d - truncating to last 200" % len(files))
             print(
@@ -151,7 +166,8 @@ def do_tests(
 
 
 if __name__ == "__main__":
-    import getopt, sys
+    import getopt
+    import sys
 
     do_coverage = do_verify = False
     test_dirs = []

uncompyle6/bin/pydisassemble.py

@@ -64,8 +64,9 @@ PATTERNS = ("*.pyc", "*.pyo")
 
 def main():
     usage_short = (
-        f"""usage: {program} FILE...
+        """usage: %s FILE...
 Type -h for for full help."""
+        % program
     )
 
     if len(sys.argv) == 1:
@@ -78,7 +79,7 @@ Type -h for for full help."""
             sys.argv[1:], "hVU", ["help", "version", "uncompyle6"]
         )
     except getopt.GetoptError as e:
-        print(f"{os.path.basename(sys.argv[0])}: {e}", file=sys.stderr)
+        print("%s: %s" % (os.path.basename(sys.argv[0]), e), file=sys.stderr)
         sys.exit(-1)
 
     for opt, val in opts:
@@ -86,7 +87,7 @@ Type -h for for full help."""
             print(__doc__)
             sys.exit(1)
         elif opt in ("-V", "--version"):
-            print(f"{program} {__version__}")
+            print("%s %s" % (program, __version__))
             sys.exit(0)
         else:
             print(opt)
@@ -97,7 +98,7 @@ Type -h for for full help."""
         if os.path.exists(files[0]):
             disassemble_file(file, sys.stdout)
         else:
-            print(f"Can't read {files[0]} - skipping", file=sys.stderr)
+            print("Can't read %s - skipping" % files[0], file=sys.stderr)
             pass
         pass
     return

uncompyle6/bin/uncompile.py

@@ -5,12 +5,10 @@
 # by Rocky Bernstein
 # Copyright (c) 2000-2002 by hartmut Goebel <h.goebel@crazy-compilers.com>
 #
-from __future__ import print_function
 
 import os
 import sys
 import time
-from typing import List
 
 import click
 from xdis.version_info import version_tuple_to_str
@@ -30,7 +28,7 @@ def usage():
 # __doc__ = """
 # Usage:
 #   %s [OPTIONS]... [ FILE | DIR]...
-#   %s [--help | -h | --V | --version]
+#   %s [--help | --version]
 
 # Examples:
 #   %s      foo.pyc bar.pyc       # decompile foo.pyc, bar.pyc to stdout
@@ -159,19 +157,27 @@ def main_bin(
     """
 
     version_tuple = sys.version_info[0:2]
-    if version_tuple < (3, 6):
-        print(
-            f"Error: This version of the {program} runs from Python 3.6 or greater."
-            f"You need another branch of this code for Python before 3.6."
-            f""" \n\tYou have version: {version_tuple_to_str()}."""
-        )
-        sys.exit(-1)
+    if not ((3, 3) <= version_tuple < (3, 6)):
+        if version_tuple > (3, 5):
+            print(
+                "This version of the {program} is tailored for Python 3.3 to 3.5.\n"
+                "It may run on other versions, but there are problems, switch to code "
+                "from another branch.\n"
+                "You have version: %s." % version_tuple_to_str()
+            )
+        else:
+            print(
+                "Error: This version of the {program} runs from Python 3.3 to 3.5.\n"
+                "You need another branch of this code for other Python versions."
+                " \n\tYou have version: %s." % version_tuple_to_str()
+            )
+            sys.exit(-1)
 
     numproc = 0
     out_base = None
 
     out_base = None
-    source_paths: List[str] = []
+    source_paths = []
     timestamp = False
     timestampfmt = "# %Y.%m.%d %H:%M:%S %Z"
     pyc_paths = files

uncompyle6/code_fns.py

@@ -1,4 +1,4 @@
-#  Copyright (c) 2015-2016, 2818-2022 by Rocky Bernstein
+#  Copyright (c) 2015-2016, 2818-2022, 2024 by Rocky Bernstein
 #  Copyright (c) 2005 by Dan Pascu <dan@windowmaker.org>
 #  Copyright (c) 2000-2002 by hartmut Goebel <h.goebel@crazy-compilers.com>
 #  Copyright (c) 1999 John Aycock
@@ -17,10 +17,12 @@
 #  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 """
-CPython magic- and version- independent disassembly routines
+CPython magic- and version-independent disassembly routines
 
 There are two reasons we can't use Python's built-in routines
-from dis. First, the bytecode we are extracting may be from a different
+from ``dis``.
+
+First, the bytecode we are extracting may be from a different
 version of Python (different magic number) than the version of Python
 that is doing the extraction.
 
@@ -39,12 +41,12 @@ from uncompyle6.scanner import get_scanner
 
 def disco(version, co, out=None, is_pypy=False):
     """
-    diassembles and deparses a given code block 'co'
+    diassembles and deparses a given code block ``co``.
     """
 
     assert iscode(co)
 
-    # store final output stream for case of error
+    # Store final output stream in case there is an error.
     real_out = out or sys.stdout
     print("# Python %s" % version_tuple_to_str(version), file=real_out)
     if co.co_filename:
@@ -99,7 +101,7 @@ def disco_loop(disasm, queue, real_out):
 
 def disassemble_file(filename, outstream=None):
     """
-    disassemble Python byte-code file (.pyc)
+    Disassemble Python byte-code file (.pyc).
 
     If given a Python source file (".py") file, we'll
     try to find the corresponding compiled object.
@@ -113,7 +115,6 @@ def disassemble_file(filename, outstream=None):
             disco(version, con, outstream)
     else:
         disco(version, co, outstream, is_pypy=is_pypy)
-    co = None
 
 
 def _test():

uncompyle6/main.py

@@ -21,7 +21,6 @@ import py_compile
 import subprocess
 import sys
 import tempfile
-from typing import Any, Optional, TextIO, Tuple
 
 from xdis import iscode
 from xdis.load import load_module
@@ -38,7 +37,7 @@ from uncompyle6.version import __version__
 # from uncompyle6.linenumbers import line_number_mapping
 
 
-def _get_outstream(outfile: str) -> Any:
+def _get_outstream(outfile):
     """
     Return an opened output file descriptor for ``outfile``.
     """
@@ -66,9 +65,9 @@ def syntax_check(filename: str) -> bool:
 
 def decompile(
     co,
-    bytecode_version: Tuple[int] = PYTHON_VERSION_TRIPLE,
-    out: Optional[TextIO] = sys.stdout,
-    showasm: Optional[str] = None,
+    bytecode_version=PYTHON_VERSION_TRIPLE,
+    out=sys.stdout,
+    showasm=None,
     showast={},
     timestamp=None,
     showgrammar=False,
@@ -82,7 +81,7 @@ def decompile(
     compile_mode="exec",
     start_offset: int = 0,
     stop_offset: int = -1,
-) -> Any:
+):
     """
     ingests and deparses a given code block 'co'
 
@@ -101,13 +100,13 @@ def decompile(
         s += "\n"
         real_out.write(s)
 
-    assert iscode(co), f"""{co} does not smell like code"""
+    assert iscode(co), "%s does not smell like code" % co
 
     co_pypy_str = "PyPy " if is_pypy else ""
     run_pypy_str = "PyPy " if IS_PYPY else ""
     sys_version_lines = sys.version.split("\n")
     if source_encoding:
-        write(f"# -*- coding: {source_encoding} -*-")
+        write("# -*- coding: %s -*-" % source_encoding)
     write(
         "# uncompyle6 version %s\n"
         "# %sPython bytecode version base %s%s\n# Decompiled from: %sPython %s"
@@ -121,9 +120,9 @@ def decompile(
         )
     )
     if co.co_filename:
-        write(f"# Embedded file name: {co.co_filename}")
+        write("# Embedded file name: %s" % co.co_filename)
     if timestamp:
-        write(f"# Compiled at: {datetime.datetime.fromtimestamp(timestamp)}")
+        write("# Compiled at: %s" % datetime.datetime.fromtimestamp(timestamp))
     if source_size:
         write("# Size of source mod 2**32: %d bytes" % source_size)
 
@@ -154,7 +153,7 @@ def decompile(
                     (line_no, deparsed.source_linemap[line_no] + header_count)
                     for line_no in sorted(deparsed.source_linemap.keys())
                 ]
-                mapstream.write(f"\n\n# {linemap}\n")
+                mapstream.write("\n\n# %s\n" % linemap)
         else:
             if do_fragments:
                 deparse_fn = code_deparse_fragments
@@ -178,26 +177,26 @@ def decompile(
         raise pysource.SourceWalkerError(str(e))
 
 
-def compile_file(source_path: str) -> str:
+def compile_file(source_path):
     if source_path.endswith(".py"):
         basename = source_path[:-3]
     else:
         basename = source_path
 
     if hasattr(sys, "pypy_version_info"):
-        bytecode_path = f"{basename}-pypy{version_tuple_to_str()}.pyc"
+        bytecode_path = "%s-pypy%s.pyc" % (basename, version_tuple_to_str())
     else:
-        bytecode_path = f"{basename}-{version_tuple_to_str()}.pyc"
+        bytecode_path = "%s-%s.pyc" % (basename, version_tuple_to_str())
 
-    print(f"compiling {source_path} to {bytecode_path}")
+    print("compiling %s to %s" % (source_path, bytecode_path))
     py_compile.compile(source_path, bytecode_path, "exec")
     return bytecode_path
 
 
 def decompile_file(
     filename: str,
-    outstream: Optional[TextIO] = None,
-    showasm: Optional[str] = None,
+    outstream=None,
+    showasm=None,
     showast={},
     showgrammar=False,
     source_encoding=None,
@@ -205,7 +204,7 @@ def decompile_file(
     do_fragments=False,
     start_offset=0,
     stop_offset=-1,
-) -> Any:
+):
     """
     decompile Python byte-code file (.pyc). Return objects to
     all of the deparsed objects found in `filename`.
@@ -266,20 +265,20 @@ def decompile_file(
 # FIXME: combine into an options parameter
 def main(
     in_base: str,
-    out_base: Optional[str],
+    out_base,
     compiled_files: list,
     source_files: list,
-    outfile: Optional[str] = None,
-    showasm: Optional[str] = None,
+    outfile=None,
+    showasm=None,
     showast={},
-    do_verify: Optional[str] = None,
+    do_verify=None,
     showgrammar: bool = False,
     source_encoding=None,
     do_linemaps=False,
     do_fragments=False,
     start_offset: int = 0,
     stop_offset: int = -1,
-) -> Tuple[int, int, int, int]:
+):
     """
     in_base	base directory for input files
     out_base	base directory for output files (ignored when
@@ -303,7 +302,7 @@ def main(
         infile = osp.join(in_base, filename)
         # print("XXX", infile)
         if not osp.exists(infile):
-            sys.stderr.write(f"File '{infile}' doesn't exist. Skipped\n")
+            sys.stderr.write("File '%s' doesn't exist. Skipped\n" % infile)
             continue
 
         if do_linemaps:
@@ -358,11 +357,11 @@ def main(
                     ):
                         if e[0] != last_mod:
                             line = "=" * len(e[0])
-                            outstream.write(f"{line}\n{e[0]}\n{line}\n")
+                            outstream.write("%s\n%s\n%s\n" % (line, e[0], line))
                         last_mod = e[0]
                         info = offsets[e]
-                        extract_info = deparse_object.extract_node_info(info)
-                        outstream.write(f"{info.node.format().strip()}" + "\n")
+                        extract_info = deparsed_object.extract_node_info(info)
+                        outstream.write("%s" % info.node.format().strip() + "\n")
                         outstream.write(extract_info.selectedLine + "\n")
                         outstream.write(extract_info.markerLine + "\n\n")
                     pass
@@ -372,49 +371,41 @@ def main(
                     deparsed_object.f.close()
                     if PYTHON_VERSION_TRIPLE[:2] != deparsed_object.version[:2]:
                         sys.stdout.write(
-                            f"\n# skipping running {deparsed_object.f.name}; it is"
-                            f"{version_tuple_to_str(deparsed_object.version, end=2)}, "
-                            "and we are "
-                            f"{version_tuple_to_str(PYTHON_VERSION_TRIPLE, end=2)}\n"
+                            "\n# skipping running %s; it is %s and we are %s"
+                            % (
+                                deparsed_object.f.name,
+                                version_tuple_to_str(deparsed_object.version, end=2),
+                                version_tuple_to_str(PYTHON_VERSION_TRIPLE, end=2),
+                            )
                         )
                     else:
                         check_type = "syntax check"
                         if do_verify == "run":
                             check_type = "run"
-                            if PYTHON_VERSION_TRIPLE >= (3, 7):
-                                result = subprocess.run(
-                                    [sys.executable, deparsed_object.f.name],
-                                    capture_output=True,
-                                )
-                                valid = result.returncode == 0
-                                output = result.stdout.decode()
-                                if output:
-                                    print(output)
-                                pass
-                            else:
-                                result = subprocess.run(
-                                    [sys.executable, deparsed_object.f.name],
-                                )
-                                valid = result.returncode == 0
-                                pass
+                            return_code = subprocess.call(
+                                [sys.executable, deparsed_object.f.name],
+                                stdout=sys.stdout,
+                                stderr=sys.stderr,
+                            )
+                            valid = return_code == 0
                             if not valid:
-                                print(result.stderr.decode())
-
+                                sys.stderr.write("Got return code %d\n" % return_code)
                         else:
                             valid = syntax_check(deparsed_object.f.name)
 
                         if not valid:
                             verify_failed_files += 1
                             sys.stderr.write(
-                                f"\n# {check_type} failed on file {deparsed_object.f.name}\n"
+                                "\n# %s failed on file %s\n"
+                                % (check_type, deparsed_object.f.name)
                             )
 
-                    # sys.stderr.write(f"Ran {deparsed_object.f.name}\n")
+                    # sys.stderr.write("Ran %\n" % deparsed_object.f.name)
                 pass
             tot_files += 1
         except (ValueError, SyntaxError, ParserError, pysource.SourceWalkerError) as e:
             sys.stdout.write("\n")
-            sys.stderr.write(f"\n# file {infile}\n# {e}\n")
+            sys.stderr.write("\n# file %s\n# %s\n" % (infile, e))
             failed_files += 1
             tot_files += 1
         except KeyboardInterrupt:
@@ -422,19 +413,21 @@ def main(
                 outstream.close()
                 os.remove(outfile)
             sys.stdout.write("\n")
-            sys.stderr.write(f"\nLast file: {infile}   ")
+            sys.stderr.write("\nLast file: %s   " % (infile))
             raise
         except RuntimeError as e:
-            sys.stdout.write(f"\n{str(e)}\n")
+            sys.stdout.write("\n%s\n" % str(e))
             if str(e).startswith("Unsupported Python"):
                 sys.stdout.write("\n")
-                sys.stderr.write(f"\n# Unsupported bytecode in file {infile}\n# {e}\n")
+                sys.stderr.write(
+                    "\n# Unsupported bytecode in file %s\n# %s\n" % (infile, e)
+                )
             else:
                 if outfile:
                     outstream.close()
                     os.remove(outfile)
                 sys.stdout.write("\n")
-                sys.stderr.write(f"\nLast file: {infile}   ")
+                sys.stderr.write("\nLast file: %s   " % (infile))
                 raise
 
         # except:
@@ -511,5 +504,9 @@ def status_msg(tot_files, okay_files, failed_files, verify_failed_files):
             return "\n# Successfully decompiled file"
             pass
         pass
-    mess = f"decompiled {tot_files} files: {okay_files} okay, {failed_files} failed"
+    mess = "decompiled %i files: %i okay, %i failed" % (
+        tot_files,
+        okay_files,
+        failed_files,
+    )
     return mess

uncompyle6/parser.py

@@ -1,4 +1,4 @@
-#  Copyright (c) 2015-2023 Rocky Bernstein
+#  Copyright (c) 2015-2024 Rocky Bernstein
 #  Copyright (c) 2005 by Dan Pascu <dan@windowmaker.org>
 #  Copyright (c) 2000-2002 by hartmut Goebel <h.goebel@crazy-compilers.com>
 #  Copyright (c) 1999 John Aycock
@@ -21,10 +21,11 @@ Common uncompyle6 parser routines.
 
 import sys
 
-from spark_parser import GenericASTBuilder, DEFAULT_DEBUG as PARSER_DEFAULT_DEBUG
-from uncompyle6.show import maybe_show_asm
+from spark_parser import DEFAULT_DEBUG as PARSER_DEFAULT_DEBUG, GenericASTBuilder
 from xdis import iscode
 
+from uncompyle6.show import maybe_show_asm
+
 
 class ParserError(Exception):
     def __init__(self, token, offset, debug=PARSER_DEFAULT_DEBUG):
@@ -91,7 +92,14 @@ class PythonParser(GenericASTBuilder):
         # singleton reduction that we can simplify. It also happens to be optional
         # in its other derivation
         self.optional_nt |= frozenset(
-            ("come_froms", "suite_stmts", "l_stmts_opt", "c_stmts_opt", "stmts_opt", "stmt")
+            (
+                "come_froms",
+                "suite_stmts",
+                "l_stmts_opt",
+                "c_stmts_opt",
+                "stmts_opt",
+                "stmt",
+            )
         )
 
         # Reduce singleton reductions in these nonterminals:
@@ -113,10 +121,10 @@ class PythonParser(GenericASTBuilder):
 
     def add_unique_rule(self, rule, opname, arg_count, customize):
         """Add rule to grammar, but only if it hasn't been added previously
-           opname and stack_count are used in the customize() semantic
-           the actions to add the semantic action rule. Stack_count is
-           used in custom opcodes like MAKE_FUNCTION to indicate how
-           many arguments it has. Often it is not used.
+        opname and stack_count are used in the customize() semantic
+        the actions to add the semantic action rule. Stack_count is
+        used in custom opcodes like MAKE_FUNCTION to indicate how
+        many arguments it has. Often it is not used.
         """
         if rule not in self.new_rules:
             # print("XXX ", rule) # debug
@@ -223,7 +231,9 @@ class PythonParser(GenericASTBuilder):
         """
         # Low byte indicates number of positional parameters,
         # high byte number of keyword parameters
-        assert token.kind.startswith("CALL_FUNCTION") or token.kind.startswith("CALL_METHOD")
+        assert token.kind.startswith("CALL_FUNCTION") or token.kind.startswith(
+            "CALL_METHOD"
+        )
         args_pos = token.attr & 0xFF
         args_kw = (token.attr >> 8) & 0xFF
         return args_pos, args_kw
@@ -364,7 +374,7 @@ class PythonParser(GenericASTBuilder):
         stmt ::= tryelsestmt
         stmt ::= tryfinallystmt
         stmt ::= with
-        stmt ::= withasstmt
+        stmt ::= with_as
 
         stmt   ::= delete
         delete ::= DELETE_FAST
@@ -381,6 +391,10 @@ class PythonParser(GenericASTBuilder):
 
         returns ::= return
         returns ::= _stmts return
+        
+        # NOP
+        stmt     ::= nop_stmt
+        nop_stmt ::= NOP
 
         """
         pass
@@ -659,6 +673,8 @@ def get_python_parser(
 
     version = version[:2]
 
+    p = None
+
     # FIXME: there has to be a better way...
     # We could do this as a table lookup, but that would force us
     # in import all of the parsers all of the time. Perhaps there is
@@ -907,7 +923,7 @@ def python_parser(
 if __name__ == "__main__":
 
     def parse_test(co):
-        from xdis import PYTHON_VERSION_TRIPLE, IS_PYPY
+        from xdis import IS_PYPY, PYTHON_VERSION_TRIPLE
 
         ast = python_parser(PYTHON_VERSION_TRIPLE, co, showasm=True, is_pypy=IS_PYPY)
         print(ast)

uncompyle6/parsers/parse14.py

@@ -64,7 +64,7 @@ class Python14Parser(Python15Parser):
 
             if opname_base == "UNPACK_VARARG":
                 if token.attr > 1:
-                    self.addRule(f"star_args ::= RESERVE_FAST {opname} args_store", nop_func)
+                    self.addRule("star_args ::= RESERVE_FAST %s args_store" % opname, nop_func)
 
 
     def reduce_is_invalid(self, rule, ast, tokens, first, last):

uncompyle6/parsers/parse24.py

@@ -1,4 +1,4 @@
-#  Copyright (c) 2016-2018, 2020, 2022-2023 Rocky Bernstein
+#  Copyright (c) 2016-2018, 2020, 2022-2024 Rocky Bernstein
 """
 spark grammar differences over Python2.5 for Python 2.4.
 """
@@ -89,12 +89,14 @@ class Python24Parser(Python25Parser):
         while1stmt    ::= SETUP_LOOP l_stmts_opt JUMP_BACK COME_FROM
         while1stmt    ::= SETUP_LOOP returns COME_FROM
         whilestmt     ::= SETUP_LOOP testexpr returns POP_BLOCK COME_FROM
+        with          ::= expr setupwith SETUP_FINALLY suite_stmts_opt POP_BLOCK
+                          LOAD_CONST COME_FROM with_cleanup
+        with_as       ::= expr setupwithas store suite_stmts_opt POP_BLOCK
+                          LOAD_CONST COME_FROM with_cleanup
         with_cleanup  ::= LOAD_FAST DELETE_FAST WITH_CLEANUP END_FINALLY
         with_cleanup  ::= LOAD_NAME DELETE_NAME WITH_CLEANUP END_FINALLY
-        withasstmt    ::= expr setupwithas store suite_stmts_opt POP_BLOCK LOAD_CONST COME_FROM with_cleanup
-        with          ::= expr setupwith SETUP_FINALLY suite_stmts_opt POP_BLOCK LOAD_CONST COME_FROM with_cleanup
-        stmt ::= with
-        stmt ::= withasstmt
+        stmt          ::= with
+        stmt          ::= with_as
         """
         )
         super(Python24Parser, self).customize_grammar_rules(tokens, customize)
@@ -118,19 +120,6 @@ class Python24Parser(Python25Parser):
             token_len = len(tokens)
             if 0 <= token_len < 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
 
 
 class Python24ParserSingle(Python24Parser, PythonParserSingle):

uncompyle6/parsers/parse25.py

@@ -1,4 +1,4 @@
-#  Copyright (c) 2016-2018, 2020, 2022 Rocky Bernstein
+#  Copyright (c) 2016-2018, 2020, 2022, 2024 Rocky Bernstein
 """
 spark grammar differences over Python2.6 for Python 2.5.
 """
@@ -33,9 +33,11 @@ class Python25Parser(Python26Parser):
                       POP_BLOCK LOAD_CONST COME_FROM with_cleanup
 
         # Semantic actions want store to be at index 2
-        withasstmt ::= expr setupwithas store suite_stmts_opt
+        with_as ::= expr setupwithas store suite_stmts_opt
                        POP_BLOCK LOAD_CONST COME_FROM with_cleanup
 
+        # The last except of a "try: ... except" can do this...
+        except_suite ::= c_stmts_opt COME_FROM JUMP_ABSOLUTE POP_TOP
 
         store ::= STORE_NAME
         store ::= STORE_FAST
@@ -48,7 +50,7 @@ class Python25Parser(Python26Parser):
 
         # Python 2.6 omits the LOAD_FAST DELETE_FAST below
         # withas is allowed as a "from future" in 2.5
-        withasstmt ::= expr setupwithas store suite_stmts_opt
+        with_as ::= expr setupwithas store suite_stmts_opt
                        POP_BLOCK LOAD_CONST COME_FROM
                        with_cleanup
 
@@ -58,6 +60,13 @@ class Python25Parser(Python26Parser):
 
         kvlist ::= kvlist kv
         kv     ::= DUP_TOP expr ROT_TWO expr STORE_SUBSCR
+
+        _ifstmts_jump ::= c_stmts_opt COME_FROM JUMP_ABSOLUTE COME_FROM POP_TOP
+
+
+        # "and_then" is a hack around the fact we have THEN detection.
+        and_then ::= expr JUMP_IF_FALSE THEN POP_TOP expr JUMP_IF_FALSE THEN POP_TOP
+        testexpr_then ::= and_then
         """
 
     def customize_grammar_rules(self, tokens, customize):
@@ -67,7 +76,7 @@ class Python25Parser(Python26Parser):
         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
-        withasstmt ::= expr setupwithas store suite_stmts_opt
+        with_as    ::= expr setupwithas store suite_stmts_opt
                        POP_BLOCK LOAD_CONST COME_FROM WITH_CLEANUP END_FINALLY
         assert2       ::= assert_expr jmp_true LOAD_ASSERT expr CALL_FUNCTION_1 RAISE_VARARGS_1
         classdefdeco  ::= classdefdeco1 store

uncompyle6/parsers/parse26.py

@@ -1,4 +1,4 @@
-#  Copyright (c) 2017-2023 Rocky Bernstein
+#  Copyright (c) 2017-2024 Rocky Bernstein
 """
 spark grammar differences over Python2 for Python 2.6.
 """
@@ -130,13 +130,20 @@ class Python26Parser(Python2Parser):
         # Semantic actions want else_suitel to be at index 3
         ifelsestmtl ::= testexpr c_stmts_opt cf_jb_cf_pop else_suitel
         ifelsestmtc ::= testexpr c_stmts_opt ja_cf_pop    else_suitec
+        ifelsestmt ::=  testexpr stmts_opt ja_cf_pop      else_suite
+
+        stmts_opt ::= stmts
+        stmts_opt ::=
+
+        # The last except of a "try: ... except" can do this...
+        except_suite ::= stmts_opt COME_FROM JUMP_ABSOLUTE POP_TOP
 
         # Semantic actions want suite_stmts_opt to be at index 3
         with        ::= expr setupwith SETUP_FINALLY suite_stmts_opt
                         POP_BLOCK LOAD_CONST COME_FROM WITH_CLEANUP END_FINALLY
 
         # Semantic actions want store to be at index 2
-        withasstmt ::= expr setupwithas store suite_stmts_opt
+        with_as ::= expr setupwithas store suite_stmts_opt
                        POP_BLOCK LOAD_CONST COME_FROM WITH_CLEANUP END_FINALLY
 
         # This is truly weird. 2.7 does this (not including POP_TOP) with
@@ -352,9 +359,9 @@ class Python26Parser(Python2Parser):
     def customize_grammar_rules(self, tokens, customize):
         self.remove_rules(
             """
-        withasstmt ::= expr SETUP_WITH store suite_stmts_opt
-                POP_BLOCK LOAD_CONST COME_FROM_WITH
-                WITH_CLEANUP END_FINALLY
+        with_as ::= expr SETUP_WITH store suite_stmts_opt
+                    POP_BLOCK LOAD_CONST COME_FROM_WITH
+                    WITH_CLEANUP END_FINALLY
         """
         )
         super(Python26Parser, self).customize_grammar_rules(tokens, customize)
@@ -391,7 +398,6 @@ class Python26Parser(Python2Parser):
             ("and", ("expr", "jmp_false", "expr", "come_from_opt")),
             ("assert_expr_and", ("assert_expr", "jmp_false", "expr")),
         ):
-
             # FIXME: workaround profiling bug
             if ast[1] is None:
                 return False
@@ -467,14 +473,16 @@ class Python26Parser(Python2Parser):
             return tokens[last].offset != ja_attr
         elif lhs == "try_except":
             # We need to distinguish "try_except" from "tryelsestmt"; we do that
-            # by checking the jump before the END_FINALLY
+            # by looking for a jump before the END_FINALLY to the "else" clause of
+            # "try else".
+            #
             # If we have:
-            #    insn
+            #    <insn>
             #    POP_TOP
             #    END_FINALLY
             #    COME_FROM
-            # then insn has to be either a JUMP_FORWARD or a RETURN_VALUE
-            # and if it is JUMP_FORWARD, then it has to be a JUMP_FORWARD to right after
+            # then <insn> has to be either a a jump of some sort (JUMP_FORWARD, BREAK_LOOP, JUMP_BACK, or RETURN_VALUE).
+            # Furthermore, if it is JUMP_FORWARD, then it has to be a JUMP_FORWARD to right after
             # COME_FROM
             if last == len(tokens):
                 last -= 1
@@ -488,54 +496,8 @@ class Python26Parser(Python2Parser):
                 # A jump of 2 is a jump around POP_TOP, END_FINALLY which
                 # would indicate try/else rather than try
                 return tokens[last - 3].kind not in frozenset(
-                    ("JUMP_FORWARD", "RETURN_VALUE")
+                    ("JUMP_FORWARD", "JUMP_BACK", "BREAK_LOOP", "RETURN_VALUE")
                 ) or (tokens[last - 3] == "JUMP_FORWARD" and tokens[last - 3].attr != 2)
-        elif lhs == "tryelsestmt":
-
-            # 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
-            # didn't work as it failed with a "try" embedded inside a "try/else"
-            # since we can't detect COME_FROM boundaries.
-
-            if ast[3] == "except_handler":
-                except_handler = ast[3]
-                if except_handler[0] == "JUMP_FORWARD":
-                    else_start = int(except_handler[0].pattr)
-                    if last == len(tokens):
-                        last -= 1
-                    if tokens[last] == "COME_FROM" and isinstance:
-                        last_offset = int(tokens[last].offset.split("_")[0])
-                        return else_start >= last_offset
-
-            # The above test apparently isn't good enough, so we have additional
-            # checks distinguish "try_except" from "tryelsestmt". we do that
-            # by checking the jump before the "END_FINALLY".
-            # If we have:
-            #    insn
-            #    POP_TOP
-            #    END_FINALLY
-            #    COME_FROM
-            # then insn is neither a JUMP_FORWARD nor RETURN_VALUE,
-            # or if it is JUMP_FORWARD, then it can't be a JUMP_FORWARD to right after
-            # COME_FROM
-            if last == len(tokens):
-                last -= 1
-            while tokens[last - 1] == "COME_FROM" and tokens[last - 2] == "COME_FROM":
-                last -= 1
-            if tokens[last] == "COME_FROM" and tokens[last - 1] == "COME_FROM":
-                last -= 1
-            if (
-                tokens[last] == "COME_FROM"
-                and tokens[last - 1] == "END_FINALLY"
-                and tokens[last - 2] == "POP_TOP"
-            ):
-                # A jump of 2 is a jump around POP_TOP, END_FINALLY which
-                # would indicate try/else rather than try
-                return tokens[last - 3].kind in frozenset(
-                    ("JUMP_FORWARD", "RETURN_VALUE")
-                ) and (tokens[last - 3] != "JUMP_FORWARD" or tokens[last - 3].attr == 2)
 
         return False
 

uncompyle6/parsers/parse27.py

@@ -1,4 +1,4 @@
-#  Copyright (c) 2016-2020, 2023 Rocky Bernstein
+#  Copyright (c) 2016-2020, 2023-2024 Rocky Bernstein
 #  Copyright (c) 2005 by Dan Pascu <dan@windowmaker.org>
 #  Copyright (c) 2000-2002 by hartmut Goebel <hartmut@goebel.noris.de>
 
@@ -161,9 +161,9 @@ class Python27Parser(Python2Parser):
                        POP_BLOCK LOAD_CONST COME_FROM_WITH
                        WITH_CLEANUP END_FINALLY
 
-        withasstmt ::= expr SETUP_WITH store suite_stmts_opt
-                POP_BLOCK LOAD_CONST COME_FROM_WITH
-                WITH_CLEANUP END_FINALLY
+        with_as    ::= expr SETUP_WITH store suite_stmts_opt
+                       POP_BLOCK LOAD_CONST COME_FROM_WITH
+                       WITH_CLEANUP END_FINALLY
 
         whilestmt         ::= SETUP_LOOP testexpr returns
                               _come_froms POP_BLOCK COME_FROM

uncompyle6/parsers/parse3.py

@@ -287,9 +287,9 @@ class Python3Parser(PythonParser):
                     POP_BLOCK LOAD_CONST COME_FROM_WITH
                     WITH_CLEANUP END_FINALLY
 
-        withasstmt ::= expr SETUP_WITH store suite_stmts_opt
-                POP_BLOCK LOAD_CONST COME_FROM_WITH
-                WITH_CLEANUP END_FINALLY
+        with_as ::= expr SETUP_WITH store suite_stmts_opt
+                    POP_BLOCK LOAD_CONST COME_FROM_WITH
+                    WITH_CLEANUP END_FINALLY
 
         expr_jt     ::= expr jmp_true
         expr_jitop  ::= expr JUMP_IF_TRUE_OR_POP
@@ -706,7 +706,7 @@ class Python3Parser(PythonParser):
         # Note: BUILD_TUPLE_UNPACK_WITH_CALL gets considered by
         # default because it starts with BUILD. So we'll set to ignore it from
         # the start.
-        custom_ops_processed = set(("BUILD_TUPLE_UNPACK_WITH_CALL",))
+        custom_ops_processed = {"BUILD_TUPLE_UNPACK_WITH_CALL"}
 
         # A set of instruction operation names that exist in the token stream.
         # We use this customize the grammar that we create.
@@ -1240,7 +1240,7 @@ class Python3Parser(PythonParser):
                         ) % (
                             pos_kw_tuple[0],
                             pos_kw_tuple[1],
-                            "annotate_pair " * (annotate_args),
+                            "annotate_tuple " * (annotate_args),
                             opname,
                         )
                     self.add_unique_rule(rule, opname, token.attr, customize)

uncompyle6/parsers/parse30.py

@@ -66,7 +66,7 @@ class Python30Parser(Python31Parser):
         iflaststmt  ::= testexpr c_stmts_opt JUMP_ABSOLUTE COME_FROM POP_TOP
 
 
-        withasstmt    ::= expr setupwithas store suite_stmts_opt
+        with_as    ::= expr setupwithas store suite_stmts_opt
                           POP_BLOCK LOAD_CONST COME_FROM_FINALLY
                           LOAD_FAST DELETE_FAST WITH_CLEANUP END_FINALLY
         setupwithas   ::= DUP_TOP LOAD_ATTR STORE_FAST LOAD_ATTR CALL_FUNCTION_0 setup_finally
@@ -222,12 +222,17 @@ class Python30Parser(Python31Parser):
         # The were found using grammar coverage
         while1stmt     ::= SETUP_LOOP l_stmts COME_FROM JUMP_BACK COME_FROM_LOOP
         whileTruestmt  ::= SETUP_LOOP l_stmts_opt JUMP_BACK POP_BLOCK COME_FROM_LOOP
-        whileelsestmt  ::= SETUP_LOOP testexpr l_stmts_opt JUMP_BACK POP_BLOCK else_suitel COME_FROM_LOOP
-        whilestmt      ::= SETUP_LOOP testexpr l_stmts_opt JUMP_BACK POP_BLOCK COME_FROM_LOOP
-        whilestmt      ::= SETUP_LOOP testexpr l_stmts_opt JUMP_BACK POP_BLOCK JUMP_BACK COME_FROM_LOOP
+        whileelsestmt  ::= SETUP_LOOP testexpr l_stmts_opt JUMP_BACK POP_BLOCK
+                           else_suitel COME_FROM_LOOP
+        whilestmt      ::= SETUP_LOOP testexpr l_stmts_opt JUMP_BACK POP_BLOCK
+                           COME_FROM_LOOP
+        whilestmt      ::= SETUP_LOOP testexpr l_stmts_opt JUMP_BACK POP_BLOCK JUMP_BACK
+                           COME_FROM_LOOP
         whilestmt      ::= SETUP_LOOP testexpr returns POP_TOP POP_BLOCK COME_FROM_LOOP
-        withasstmt     ::= expr SETUP_WITH store suite_stmts_opt POP_BLOCK LOAD_CONST COME_FROM_WITH WITH_CLEANUP END_FINALLY
-        with           ::= expr SETUP_WITH POP_TOP suite_stmts_opt POP_BLOCK LOAD_CONST COME_FROM_WITH WITH_CLEANUP END_FINALLY
+        with_as        ::= expr SETUP_WITH store suite_stmts_opt POP_BLOCK LOAD_CONST
+                           COME_FROM_WITH WITH_CLEANUP END_FINALLY
+        with           ::= expr SETUP_WITH POP_TOP suite_stmts_opt POP_BLOCK LOAD_CONST
+                           COME_FROM_WITH WITH_CLEANUP END_FINALLY
 
         # lc_body ::= LOAD_FAST expr LIST_APPEND
         # lc_body ::= LOAD_NAME expr LIST_APPEND

uncompyle6/parsers/parse31.py

@@ -1,4 +1,4 @@
-#  Copyright (c) 2016-2017, 2022 Rocky Bernstein
+#  Copyright (c) 2016-2017, 2022, 2024 Rocky Bernstein
 """
 spark grammar differences over Python 3.2 for Python 3.1.
 """
@@ -23,7 +23,7 @@ class Python31Parser(Python32Parser):
         # Keeps Python 3.1 "with .. as" designator in the same position as it is in other version.
         setupwithas31  ::= setupwithas SETUP_FINALLY load delete
 
-        withasstmt     ::= expr setupwithas31 store
+        with_as        ::= expr setupwithas31 store
                            suite_stmts_opt
                            POP_BLOCK LOAD_CONST COME_FROM_FINALLY
                            load delete WITH_CLEANUP END_FINALLY

uncompyle6/parsers/parse32.py

@@ -1,4 +1,4 @@
-#  Copyright (c) 2016-2017, 2022 Rocky Bernstein
+#  Copyright (c) 2016-2017, 2022-2024 Rocky Bernstein
 """
 spark grammar differences over Python 3 for Python 3.2.
 """
@@ -84,7 +84,7 @@ class Python32Parser(Python3Parser):
         for i, token in enumerate(tokens):
             opname = token.kind
             if opname.startswith("MAKE_FUNCTION_A"):
-                args_pos, args_kw, annotate_args = token.attr
+                args_pos, _, annotate_args = token.attr
                 # Check that there are 2 annotated params?
                 rule = (
                     "mkfunc_annotate ::= %s%sannotate_tuple "

uncompyle6/parsers/parse34.py

@@ -1,4 +1,4 @@
-#  Copyright (c) 2017-2018 Rocky Bernstein
+#  Copyright (c) 2017-2018, 2022-2024 Rocky Bernstein
 
 #  This program is free software: you can redistribute it and/or modify
 #  it under the terms of the GNU General Public License as published by
@@ -21,7 +21,6 @@ from uncompyle6.parsers.parse33 import Python33Parser
 
 
 class Python34Parser(Python33Parser):
-
     def p_misc34(self, args):
         """
         expr ::= LOAD_ASSERT
@@ -54,39 +53,52 @@ class Python34Parser(Python33Parser):
         _ifstmts_jump ::= c_stmts_opt JUMP_ABSOLUTE JUMP_FORWARD COME_FROM
 
         genexpr_func ::= LOAD_ARG _come_froms FOR_ITER store comp_iter JUMP_BACK
+
+        if_exp_lambda      ::= expr jmp_false expr return_if_lambda come_froms return_stmt_lambda LAMBDA_MARKER
+        return_if_lambda   ::= RETURN_END_IF_LAMBDA come_froms
+        return_if_stmt     ::= return_expr RETURN_END_IF POP_BLOCK
         """
 
     def customize_grammar_rules(self, tokens, customize):
-        self.remove_rules("""
+        self.remove_rules(
+            """
         yield_from    ::= expr expr YIELD_FROM
         # 3.4.2 has this. 3.4.4 may now
         # while1stmt ::= SETUP_LOOP l_stmts COME_FROM JUMP_BACK COME_FROM_LOOP
-        """)
+        """
+        )
         super(Python34Parser, self).customize_grammar_rules(tokens, customize)
         return
 
+
 class Python34ParserSingle(Python34Parser, PythonParserSingle):
     pass
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     # Check grammar
     p = Python34Parser()
     p.check_grammar()
     from xdis.version_info import IS_PYPY, PYTHON_VERSION_TRIPLE
+
     if PYTHON_VERSION_TRIPLE[:2] == (3, 4):
         lhs, rhs, tokens, right_recursive, dup_rhs = p.check_sets()
         from uncompyle6.scanner import get_scanner
+
         s = get_scanner(PYTHON_VERSION_TRIPLE, IS_PYPY)
-        opcode_set = set(s.opc.opname).union(set(
-            """JUMP_BACK CONTINUE RETURN_END_IF COME_FROM
+        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()))
+            """.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([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()))