Administrivia

until we can find an image that might run this

.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
-            pip install --user -e .
-            # Not sure why "pip install -e" doesn't work above
-            # pip install click spark-parser xdis
-            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/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.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
-        pip install -e .
-        # Not sure why "pip install -e" doesn't work above
-        # pip install click spark-parser xdis
-        pip install -r requirements-dev.txt
-    - name: Test uncompyle6
-      run: |
-        make check

.github/workflows/ubuntu.yml

@@ -1,29 +0,0 @@
-name: uncompyle6 (ubuntu)
-
-on:
-  push:
-    branches: [ master ]
-  pull_request:
-    branches: [ master ]
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        python-version: [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
-        pip install -e .
-        # pip install click spark-parser xdis
-        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.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
-        pip install -e .
-        # Not sure why "pip install -e" doesn't work above
-        # pip install click spark-parser xdis
-        pip install -r requirements-dev.txt
-    - name: Test uncompyle6
-      run: |
-        make check

.pre-commit-config.yaml

@@ -9,14 +9,3 @@ repos:
       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. 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.
+* 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.
 * 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.
-* 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.
+* 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.
 
 # Ethics
 
-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.
+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.
 
-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
+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
 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. Gee this stuff is complicated, here's an open source project, so maybe someone there will help me figure stuff out.
+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.
 
-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.
+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.
 
 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.
 
-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.
+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.
 
 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,9 +1,3 @@
-3.9.2: 2024-07-21
-=================
-
-- track xdis API changes
-- Bug fixes and lint
-
 3.9.1: 2024-05-15
 =================
 

PKG-INFO

@@ -1,355 +1,10 @@
-Metadata-Version: 1.1
+Metadata-Version: 2.0
 Name: uncompyle6
-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
+Version: 2.0.1
+Summary: Python byte-code to source-code converter
+Home-page: http://github.com/rocky/python-uncompyle6
+Author: Rocky
 Author-email: rb@dustyfeet.com
-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
-        
-        
+License: MIT
+Description: UNKNOWN
 Platform: UNKNOWN
-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*. Any volunteers?
+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
@@ -274,10 +274,7 @@ 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. 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.
+issues above the queue of other things I might be doing instead.
 
 See Also
 --------

__pkginfo__.py

@@ -79,7 +79,7 @@ entry_points = {
     ]
 }
 ftp_url = None
-install_requires = ["click", "spark-parser >= 1.8.9, < 1.9.0", "xdis >= 6.1.1, < 6.2.0"]
+install_requires = ["click", "spark-parser >= 1.8.9, < 1.9.0", "xdis >= 6.0.8, < 6.2.0"]
 
 license = "GPL3"
 mailing_list = "python-debugger@googlegroups.com"

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 '

pyproject.toml

@@ -1,6 +1,6 @@
 [build-system]
 requires = [
-    "setuptools>=71.0.3",
+    "setuptools>=61.2",
 ]
 
 build-backend = "setuptools.build_meta"
@@ -15,7 +15,7 @@ description = "Python cross-version byte-code library and disassembler"
 dependencies = [
     "click",
     "spark-parser >= 1.8.9, < 1.9.0",
-    "xdis >= 6.1.0, < 6.2.0",
+    "xdis >= 6.0.8, < 6.2.0",
 ]
 readme = "README.rst"
 license = {text = "GPL"}

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

@@ -6,4 +6,4 @@ pytest
 Click~=7.0
 xdis>=6.0.4
 configobj~=5.0.6
-setuptools~=71.0.3
+setuptools~=65.5.1

setup-pretoml.py

@@ -1,71 +0,0 @@
-#!/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,11 +12,10 @@ doc_files = README.rst
 #		examples/
 
 [bdist_wheel]
-universal = no
+universal=1
 
 [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,6 +1,66 @@
 #!/usr/bin/env python
+import setuptools
+import sys
+
 """Setup script for the 'uncompyle6' distribution."""
 
-from setuptools import setup
+SYS_VERSION = sys.version_info[0:2]
+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 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]
+        )
+    elif SYS_VERSION < (2, 4):
+        mess += (
+            "\nThis package is not supported for Python version %s." % sys.version[0:3]
+        )
+    print(mess)
+    raise Exception(mess)
 
-setup(packages=["uncompyle6"])
+from __pkginfo__ import (
+    author,
+    author_email,
+    install_requires,
+    license,
+    long_description,
+    classifiers,
+    entry_points,
+    modname,
+    py_modules,
+    short_desc,
+    __version__,
+    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,
+    tests_require=["nose>=1.0"],
+    version=__version__,
+    zip_safe=zip_safe,
+)

test/ok_lib2.7/bsddb/dbshelve.py

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

@@ -1,18 +0,0 @@
-# 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

@@ -1 +0,0 @@
-/.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)
 
-# expression which evaluates True unconditionally,
+# expresion 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

@@ -1,34 +0,0 @@
-# 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 beginning of the module
+# The problem was detecting a docstring at the begining 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 optimization < 2 or else optimization
+# Note that this has to be compiled with optimation < 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 have the UNARY_CONVERT which dropped
+# But we don't ahve 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,20 +1,18 @@
 # From 3.x test_audiop.py
 
 # Bug is handling default value after * argument in a lambda.
-# That's a mouthful of description; I am not sure if the really
+# That's a mouthful of desciption; 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,19 +1,16 @@
 # 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 multiple COME_FROMS from nested if's
+# Bug was in handling multple COME_FROMS from nested if's
 def _escape(a, b, c, d, e):
     if a:
         if b:
@@ -27,16 +24,15 @@ 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

@@ -1,4 +0,0 @@
-# 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

@@ -1,10 +0,0 @@
-# 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,9 +1,8 @@
 # From Python 3.4 asynchat.py
-# Tests presence or absence of
+# Tests presence or absense 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:
@@ -25,7 +24,6 @@ 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,20 +1,13 @@
-# Python 3.6 changes, yet again, the way default pairs are handled
+# Python 3.6 changes, yet again, the way deafult 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,23 +1,17 @@
 # From 3.6 test_abc.py
-# Bug was Receiver() class definition
+# Bug was Reciever() 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 presence of POP_JUMP_IF_FALSE
+# Bug was handling "and" condition in the presense 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

@@ -1,74 +0,0 @@
-# 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,7 +14,6 @@ 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):
@@ -98,10 +97,9 @@ 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 compatibility with older Python we'll use "%"
+# equivalent thing. For compatiblity 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,27 +1,26 @@
 # From 3.6 _markupbase.py
 
-# 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
-
+# 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
 
 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:
@@ -44,7 +43,8 @@ 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

@@ -1,9 +0,0 @@
-# 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 specific case below is:
+# which in the specifc 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 because this causes an infinite loop.
+# Degenerate case. Note: we can't run becase this causes an infinite loop.
 # Suggested in issue #172
 while 1:
     pass

test/simple_source/operation_logic/05_control_flow_bugs.py

@@ -1,8 +1,7 @@
 # From 3.6.10 test_binascii.py
-# Bug was getting "while c and noise" parsed correctly
+# Bug was getting "while c and noise" parsed correclty
 # and not put into the "ifelsesmt"
 
-
 # RUNNABLE!
 def addnoise(c, noise):
     while c and noise:
@@ -13,7 +12,6 @@ def addnoise(c, noise):
         noise = False
     return c
 
-
 assert addnoise(0, True) == 0
 assert addnoise(1, False) == 1
 assert addnoise(2, True) == 2
@@ -21,10 +19,9 @@ 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
-# presence of a loop.
+# presense of a loop.
 def test_random(a, r):
     x = 0
     for dummy in r:
@@ -35,13 +32,11 @@ 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"
@@ -58,13 +53,11 @@ 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):
@@ -77,7 +70,6 @@ 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 expressions
+# Mixed boolean expresions
 
 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 multiple COME_FROMs due to the
+# Bug in 2.6 is having multple 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 multiple COME_FROMs as a result
+# Bug in 2.6 is multple 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,7 +24,6 @@ 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
@@ -37,7 +36,6 @@ def __floordiv__(a, b):
     b += 5
     return b
 
-
 assert __floordiv__(1, 1) == 7
 assert __floordiv__(1, 0) == 6
 assert __floordiv__(0, 3) == 8

test/stdlib/2.4-exclude.sh

@@ -38,14 +38,17 @@ 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  # fails on its own - no module named test_support
+
+    [test_decimal.py]=1  #
     [test_dis.py]=1   # We change line numbers - duh!
-    [test_generators.py]=1  # fails on its own - no module named test_support
+    [test_generators.py]=1  # Investigate
     # [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/test_pyenvlib.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 # emacs-mode: -*-python-*-
 """
-test_pyenvlib -- decompile and verify Python libraries
+test_pyenvlib -- uncompyle and verify Python libraries
 
 Usage-Examples:
 
@@ -20,18 +20,13 @@ Step 2: Run the test:
 	  test_pyenvlib --mylib --verify # decompile verify 'mylib'
 """
 
-# 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 __future__ import print_function
+
+import os, time, re, shutil, sys
 from fnmatch import fnmatch
 
-import xdis.magics as magics
-
 from uncompyle6 import main
+import xdis.magics as magics
 
 # ----- configure this for your needs
 
@@ -87,7 +82,6 @@ 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"
@@ -139,17 +133,8 @@ 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(
@@ -166,8 +151,7 @@ def do_tests(
 
 
 if __name__ == "__main__":
-    import getopt
-    import sys
+    import getopt, 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
@@ -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, 2024 by Rocky Bernstein
+#  Copyright (c) 2015-2016, 2818-2022 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,12 +17,10 @@
 #  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.
 
@@ -41,12 +39,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 in case there is an error.
+    # store final output stream for case of error
     real_out = out or sys.stdout
     print("# Python %s" % version_tuple_to_str(version), file=real_out)
     if co.co_filename:
@@ -101,7 +99,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.
@@ -115,6 +113,7 @@ 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 = deparsed_object.extract_node_info(info)
-                        outstream.write(f"{info.node.format().strip()}" + "\n")
+                        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

@@ -669,8 +669,6 @@ 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

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

@@ -120,6 +120,19 @@ 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

@@ -36,8 +36,6 @@ class Python25Parser(Python26Parser):
         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
@@ -60,13 +58,6 @@ 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):

uncompyle6/parsers/parse26.py

@@ -130,13 +130,6 @@ 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
@@ -473,16 +466,14 @@ 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 looking for a jump before the END_FINALLY to the "else" clause of
-            # "try else".
-            #
+            # by checking the jump before the END_FINALLY
             # If we have:
-            #    <insn>
+            #    insn
             #    POP_TOP
             #    END_FINALLY
             #    COME_FROM
-            # 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
+            # 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
             # COME_FROM
             if last == len(tokens):
                 last -= 1
@@ -496,8 +487,53 @@ 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", "JUMP_BACK", "BREAK_LOOP", "RETURN_VALUE")
+                    ("JUMP_FORWARD", "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-2024 Rocky Bernstein
+#  Copyright (c) 2016-2020, 2023 Rocky Bernstein
 #  Copyright (c) 2005 by Dan Pascu <dan@windowmaker.org>
 #  Copyright (c) 2000-2002 by hartmut Goebel <hartmut@goebel.noris.de>
 

uncompyle6/parsers/parse3.py

@@ -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 = {"BUILD_TUPLE_UNPACK_WITH_CALL"}
+        custom_ops_processed = set(("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/parse31.py

@@ -1,4 +1,4 @@
-#  Copyright (c) 2016-2017, 2022, 2024 Rocky Bernstein
+#  Copyright (c) 2016-2017, 2022 Rocky Bernstein
 """
 spark grammar differences over Python 3.2 for Python 3.1.
 """

uncompyle6/parsers/parse32.py

@@ -1,4 +1,4 @@
-#  Copyright (c) 2016-2017, 2022-2024 Rocky Bernstein
+#  Copyright (c) 2016-2017, 2022 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, _, annotate_args = token.attr
+                args_pos, args_kw, 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, 2022-2024 Rocky Bernstein
+#  Copyright (c) 2017-2018 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,6 +21,7 @@ from uncompyle6.parsers.parse33 import Python33Parser
 
 
 class Python34Parser(Python33Parser):
+
     def p_misc34(self, args):
         """
         expr ::= LOAD_ASSERT
@@ -53,52 +54,39 @@ 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 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()))

uncompyle6/parsers/parse35.py

@@ -108,10 +108,9 @@ class Python35Parser(Python34Parser):
         # Python 3.5+ does jump optimization
         # In <.3.5 the below is a JUMP_FORWARD to a JUMP_ABSOLUTE.
 
+        return_if_stmt    ::= return_expr RETURN_END_IF POP_BLOCK
         return_if_lambda  ::= RETURN_END_IF_LAMBDA COME_FROM
 
-        return            ::= return_expr RETURN_END_IF
-
         jb_else     ::= JUMP_BACK ELSE
         ifelsestmtc ::= testexpr c_stmts_opt JUMP_FORWARD else_suitec
         ifelsestmtl ::= testexpr c_stmts_opt jb_else else_suitel

uncompyle6/parsers/parse36.py

@@ -53,8 +53,6 @@ class Python36Parser(Python35Parser):
         for_block       ::= l_stmts_opt come_from_loops JUMP_BACK
         come_from_loops ::= COME_FROM_LOOP*
 
-        whilestmt       ::= SETUP_LOOP testexpr l_stmts_opt
-                            JUMP_BACK come_froms POP_BLOCK
         whilestmt       ::= SETUP_LOOP testexpr l_stmts_opt
                             JUMP_BACK come_froms POP_BLOCK COME_FROM_LOOP
         whilestmt       ::= SETUP_LOOP testexpr l_stmts_opt

uncompyle6/parsers/parse37base.py

@@ -138,7 +138,7 @@ class Python37BaseParser(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 = {"BUILD_TUPLE_UNPACK_WITH_CALL"}
+        custom_ops_processed = set(("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.
@@ -320,18 +320,24 @@ class Python37BaseParser(PythonParser):
 
             elif opname in ("BUILD_CONST_LIST", "BUILD_CONST_DICT", "BUILD_CONST_SET"):
                 if opname == "BUILD_CONST_DICT":
-                    rule = f"""
+                    rule = (
+                        """
                             add_consts          ::= ADD_VALUE*
-                            const_list          ::= COLLECTION_START add_consts {opname}
+                            const_list          ::= COLLECTION_START add_consts %s
                             dict                ::= const_list
                             expr                ::= dict
                         """
+                        % opname
+                    )
                 else:
-                    rule = f"""
+                    rule = (
+                        """
                             add_consts          ::= ADD_VALUE*
-                            const_list          ::= COLLECTION_START add_consts {opname}
+                            const_list          ::= COLLECTION_START add_consts %s
                             expr                ::= const_list
                         """
+                        % opname
+                    )
                 self.addRule(rule, nop_func)
 
             elif opname_base == "BUILD_CONST_KEY_MAP":
@@ -1263,9 +1269,14 @@ class Python37BaseParser(PythonParser):
             import traceback
 
             print(
-                f"Exception in {fn.__name__} {sys.exc_info()[1]}\n"
-                + f"rule: {rule2str(rule)}\n"
-                + f"offsets {tokens[first].offset} .. {tokens[last].offset}"
+                ("Exception in %s %s\n" + "rule: %s\n" + "offsets %s .. %s")
+                % (
+                    fn.__name__,
+                    sys.exc_info()[1],
+                    rule2str(rule),
+                    tokens[first].offset,
+                    tokens[last].offset,
+                )
             )
             print(traceback.print_tb(sys.exc_info()[2], -1))
             raise ParserError(tokens[last], tokens[last].off2int(), self.debug["rules"])

uncompyle6/parsers/parse38.py

@@ -417,7 +417,7 @@ class Python38Parser(Python37Parser):
             [opname[: opname.rfind("_")] for opname in self.seen_ops]
         )
 
-        custom_ops_processed = {"DICT_MERGE"}
+        custom_ops_processed = set(["DICT_MERGE"])
 
         # Loop over instructions adding custom grammar rules based on
         # a specific instruction seen.

uncompyle6/parsers/reducecheck/and_check.py

@@ -5,9 +5,7 @@
 
 
 
-def and_invalid(
-    self, lhs: str, n: int, rule, ast, tokens: list, first: int, last: int
- ) -> bool:
+def and_invalid( self, lhs, n, rule, ast, tokens, first, last):
     jmp = ast[1]
     if jmp.kind.startswith("jmp_"):
         if last == n:

uncompyle6/parsers/reducecheck/and_not_check.py

@@ -3,7 +3,7 @@
 
 def and_not_check(
     self, lhs, n, rule, ast, tokens, first, last
-) -> bool:
+):
     jmp = ast[1]
     if jmp.kind.startswith("jmp_"):
         if last == n:

uncompyle6/parsers/reducecheck/except_handler.py

@@ -1,8 +1,7 @@
 #  Copyright (c) 2020 Rocky Bernstein
 
-
 def except_handler(self, lhs, n, rule, ast, tokens, first, last):
-    end_token = tokens[last - 1]
+    end_token = tokens[last-1]
 
     # print("XXX", first, last)
     # for t in range(first, last):
@@ -14,7 +13,7 @@ def except_handler(self, lhs, n, rule, ast, tokens, first, last):
     if self.version[:2] == (1, 4):
         return False
 
-    # Make sure COME_FROMs froms come from within "except_handler".
+    # Make sure come froms all come from within "except_handler".
     if end_token != "COME_FROM":
         return False
     return end_token.attr < tokens[first].offset

uncompyle6/parsers/reducecheck/for_block_check.py

@@ -1,9 +1,9 @@
-#  Copyright (c) 2022 Rocky Bernstein
+#  Copyright (c) 2022, 2024 Rocky Bernstein
 
 from uncompyle6.scanners.tok import Token
 
 
-def for_block_invalid(self, lhs, n, rule, tree, tokens, first: int, last: int) -> bool:
+def for_block_invalid(self, lhs, n, rule, tree, tokens, first, last):
     # print("XXX", first, last)
     # for t in range(first, last):
     #     print(tokens[t])

uncompyle6/parsers/reducecheck/ifelsestmt.py

@@ -82,8 +82,14 @@ IFELSE_STMT_RULES = frozenset(
             ),
         ),
         (
-            "ifelsestmtc",
-            ("testexpr", "c_stmts_opt", "JUMP_FORWARD", "else_suite", "come_froms"),
+            'ifelsestmtc',
+            (
+                'testexpr',
+                'c_stmts_opt',
+                'JUMP_FORWARD',
+                'else_suite',
+                'come_froms'
+            ),
         ),
         (
             "ifelsestmt",
@@ -149,6 +155,7 @@ IFELSE_STMT_RULES = frozenset(
 
 
 def ifelsestmt(self, lhs, n, rule, tree, tokens, first, last):
+
     if (last + 1) < n and tokens[last + 1] == "COME_FROM_LOOP" and lhs != "ifelsestmtc":
         # ifelsestmt jumped outside of loop. No good.
         return True
@@ -169,10 +176,13 @@ def ifelsestmt(self, lhs, n, rule, tree, tokens, first, last):
     stmts = tree[1]
     if stmts in ("c_stmts",) and len(stmts) == 1:
         raise_stmt1 = stmts[0]
-        if raise_stmt1 == "raise_stmt1" and raise_stmt1[0] in ("LOAD_ASSERT",):
+        if (
+                raise_stmt1 == "raise_stmt1" and
+                raise_stmt1[0] in ("LOAD_ASSERT",)
+        ):
             return True
 
-    # Make sure all the offsets from the "COME_FROMs" at the
+    # Make sure all the offsets from the "come froms" at the
     # end of the "if" come from somewhere inside the "if".
     # Since the come_froms are ordered so that lowest
     # offset COME_FROM is last, it is sufficient to test
@@ -267,18 +277,17 @@ def ifelsestmt(self, lhs, n, rule, tree, tokens, first, last):
                 # only if we are trying to match or reduce an "if"
                 # statement of the kind that can occur only inside a
                 # loop construct.
-
                 if lhs in ("ifelsestmtl", "ifelsestmtc"):
                     jump_false = jmp
                     if (
-                        tree[2].kind in ("JUMP_FORWARD", "JUMP_ABSOLUTE")
+                        tree[2].kind == "JUMP_FORWARD"
                         and jump_false == "jmp_false"
                         and len(else_suite) == 1
                     ):
                         suite_stmts = else_suite[0]
                         continue_stmt = suite_stmts[0]
                         if (
-                            suite_stmts in ("suite_stmts", "c_stmts")
+                            suite_stmts == "suite_stmts"
                             and len(suite_stmts) == 1
                             and continue_stmt == "continue"
                             and jump_false[0].attr == continue_stmt[0].attr

uncompyle6/parsers/reducecheck/joined_str_check.py

@@ -13,9 +13,7 @@
 #  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 
-def joined_str_invalid(
-    self, lhs: str, n: int, rule, tree, tokens: list, first: int, last: int
-) -> bool:
+def joined_str_invalid(self, lhs, n, rule, tree, tokens, first, last):
     # In Python 3.8, there is a new "=" specifier.
     # See https://docs.python.org/3/whatsnew/3.8.html#f-strings-support-for-self-documenting-expressions-and-debugging
     # We detect this here inside joined_str by looking for an

uncompyle6/parsers/reducecheck/tryexcept.py

@@ -1,17 +1,16 @@
-#  Copyright (c) 2020, 2022, 2024 Rocky Bernstein
-
+#  Copyright (c) 2020, 2022 Rocky Bernstein
 
 def tryexcept(self, lhs, n, rule, ast, tokens, first, last):
     come_from_except = ast[-1]
     if rule == (
-        "try_except",
-        (
-            "SETUP_EXCEPT",
-            "suite_stmts_opt",
-            "POP_BLOCK",
-            "except_handler",
-            "opt_come_from_except",
-        ),
+            "try_except",
+            (
+                "SETUP_EXCEPT",
+                "suite_stmts_opt",
+                "POP_BLOCK",
+                "except_handler",
+                "opt_come_from_except",
+            ),
     ):
         if come_from_except[0] == "COME_FROM":
             # There should be at least two COME_FROMs, one from an
@@ -21,31 +20,31 @@ def tryexcept(self, lhs, n, rule, ast, tokens, first, last):
         pass
 
     elif rule == (
-        "try_except",
-        (
-            "SETUP_EXCEPT",
-            "suite_stmts_opt",
-            "POP_BLOCK",
-            "except_handler",
-            "COME_FROM",
-        ),
+            "try_except",
+            (
+                "SETUP_EXCEPT",
+                "suite_stmts_opt",
+                "POP_BLOCK",
+                "except_handler",
+                "COME_FROM",
+            ),
     ):
         return come_from_except.attr < tokens[first].offset
 
     elif rule == (
-        "try_except",
-        (
-            "SETUP_EXCEPT",
-            "suite_stmts_opt",
-            "POP_BLOCK",
-            "except_handler",
-            "\\e_opt_come_from_except",
-        ),
+            'try_except',
+            (
+                'SETUP_EXCEPT',
+                'suite_stmts_opt',
+                'POP_BLOCK',
+                'except_handler',
+                '\\e_opt_come_from_except'
+            ),
     ):
         # Find END_FINALLY.
         for i in range(last, first, -1):
             if tokens[i] == "END_FINALLY":
-                jump_before_finally = tokens[i - 1]
+                jump_before_finally = tokens[i-1]
                 if jump_before_finally.kind.startswith("JUMP"):
                     if jump_before_finally == "JUMP_FORWARD":
                         # If there is a JUMP_FORWARD before
@@ -53,9 +52,7 @@ def tryexcept(self, lhs, n, rule, ast, tokens, first, last):
                         # beyond tokens[last].off2int() then
                         # this is a try/else rather than an
                         # try (no else).
-                        return tokens[i - 1].attr > tokens[last].off2int(
-                            prefer_last=True
-                        )
+                        return tokens[i-1].attr > tokens[last].off2int(prefer_last=True)
                     elif jump_before_finally == "JUMP_BACK":
                         # If there is a JUMP_BACK before the
                         # END_FINALLY then this is a looping
@@ -64,10 +61,8 @@ def tryexcept(self, lhs, n, rule, ast, tokens, first, last):
                         # jump or this is a try/else rather
                         # than an try (no else).
                         except_handler = ast[3]
-                        if (
-                            except_handler == "except_handler"
-                            and except_handler[0] == "JUMP_FORWARD"
-                        ):
+                        if (except_handler == "except_handler" and
+                            except_handler[0] == "JUMP_FORWARD"):
                             return True
                         return False
                     pass

uncompyle6/parsers/treenode.py

@@ -1,9 +1,6 @@
-import sys
 from uncompyle6.scanners.tok import NoneToken
 from spark_parser.ast import AST as spark_AST
 
-intern = sys.intern
-
 
 class SyntaxTree(spark_AST):
     def __init__(self, *args, transformed_by=None, **kwargs):

uncompyle6/scanner.py

@@ -21,11 +21,9 @@ scanner/ingestion module. From here we call various version-specific
 scanners, e.g. for Python 2.7 or 3.4.
 """
 
-from abc import ABC
+import sys
 from array import array
 from collections import namedtuple
-from types import ModuleType
-from typing import Optional, Union
 
 import xdis
 from xdis import (
@@ -80,6 +78,7 @@ CANONIC2VERSION["3.5.2"] = 3.5
 
 
 # FIXME: DRY
+intern = sys.intern
 L65536 = 65536
 
 
@@ -109,20 +108,19 @@ class Code:
         self._tokens, self._customize = scanner.ingest(co, classname, show_asm=show_asm)
 
 
-class Scanner(ABC):
+class Scanner:
     def __init__(self, version: tuple, show_asm=None, is_pypy=False):
         self.version = version
         self.show_asm = show_asm
         self.is_pypy = is_pypy
 
-        # Temoorary initialization.
-        self.opc = ModuleType("uninitialized")
-
         if version[:2] in PYTHON_VERSIONS:
-            v_str = f"""opcode_{version_tuple_to_str(version, start=0, end=2, delimiter="")}"""
+            v_str = "opcode_%s" % version_tuple_to_str(
+                version, start=0, end=2, delimiter=""
+            )
             if is_pypy:
                 v_str += "pypy"
-            exec(f"""from xdis.opcodes import {v_str}""")
+            exec("from xdis.opcodes import %s" % v_str)
             exec("self.opc = %s" % v_str)
         else:
             raise TypeError(
@@ -281,7 +279,7 @@ class Scanner(ABC):
             for _ in range(instruction_size(op, self.opc)):
                 self.prev_op.append(offset)
 
-    def is_jump_forward(self, offset: int) -> bool:
+    def is_jump_forward(self, offset):
         """
         Return True if the code at offset is some sort of jump forward.
         That is, it is ether "JUMP_FORWARD" or an absolute jump that
@@ -303,7 +301,7 @@ class Scanner(ABC):
     def prev_offset(self, offset: int) -> int:
         return self.insts[self.offset2inst_index[offset] - 1].offset
 
-    def get_inst(self, offset: int):
+    def get_inst(self, offset):
         # Instructions can get moved as a result of EXTENDED_ARGS removal.
         # So if "offset" is not in self.offset2inst_index, then
         # we assume that it was an instruction moved back.
@@ -314,7 +312,7 @@ class Scanner(ABC):
             assert self.code[offset] == self.opc.EXTENDED_ARG
         return self.insts[self.offset2inst_index[offset]]
 
-    def get_target(self, offset: int, extended_arg: int = 0) -> int:
+    def get_target(self, offset, extended_arg=0):
         """
         Get next instruction offset for op located at given <offset>.
         NOTE: extended_arg is no longer used
@@ -327,14 +325,23 @@ class Scanner(ABC):
             target = next_offset(inst.opcode, self.opc, inst.offset)
         return target
 
-    def get_argument(self, pos: int):
+    def get_argument(self, pos):
         arg = self.code[pos + 1] + self.code[pos + 2] * 256
         return arg
 
-    def next_offset(self, op, offset: int) -> int:
+    def next_offset(self, op, offset):
         return xdis.next_offset(op, self.opc, offset)
 
-    def first_instr(self, start: int, end: int, instr, target=None, exact=True):
+    def print_bytecode(self):
+        for i in self.op_range(0, len(self.code)):
+            op = self.code[i]
+            if op in self.JUMP_OPS:
+                dest = self.get_target(i, op)
+                print("%i\t%s\t%i" % (i, self.opname[op], dest))
+            else:
+                print("%i\t%s\t" % (i, self.opname[op]))
+
+    def first_instr(self, start, end, instr, target=None, exact=True):
         """
         Find the first <instr> in the block from start to end.
         <instr> is any python bytecode instruction or a list of opcodes
@@ -368,9 +375,7 @@ class Scanner(ABC):
                         result_offset = offset
         return result_offset
 
-    def last_instr(
-        self, start: int, end: int, instr, target=None, exact=True
-    ) -> Optional[int]:
+    def last_instr(self, start, end, instr, target=None, exact=True):
         """
         Find the last <instr> in the block from start to end.
         <instr> is any python bytecode instruction or a list of opcodes
@@ -466,9 +471,7 @@ class Scanner(ABC):
     # FIXME: this is broken on 3.6+. Replace remaining (2.x-based) calls
     # with inst_matches
 
-    def all_instr(
-        self, start: int, end: int, instr, target=None, include_beyond_target=False
-    ):
+    def all_instr(self, start, end, instr, target=None, include_beyond_target=False):
         """
         Find all `instr` in the block from start to end.
         `instr` is any Python opcode or a list of opcodes
@@ -593,30 +596,28 @@ class Scanner(ABC):
     def resetTokenClass(self):
         return self.setTokenClass(Token)
 
-    def restrict_to_parent(self, target: int, parent) -> int:
+    def restrict_to_parent(self, target, parent):
         """Restrict target to parent structure boundaries."""
         if not (parent["start"] < target < parent["end"]):
             target = parent["end"]
         return target
 
-    def setTokenClass(self, tokenClass: Token) -> Token:
+    def setTokenClass(self, tokenClass):
+        # assert isinstance(tokenClass, types.ClassType)
         self.Token = tokenClass
         return self.Token
 
 
-def get_scanner(version: Union[str, tuple], is_pypy=False, show_asm=None) -> Scanner:
-    """
-    Import the right scanner module for ``version`` and return the Scanner class
-    in that module.
-    """
+def get_scanner(version, is_pypy=False, show_asm=None):
     # If version is a string, turn that into the corresponding float.
     if isinstance(version, str):
         if version not in canonic_python_version:
-            raise RuntimeError(f"Unknown Python version in xdis {version}")
+            raise RuntimeError("Unknown Python version in xdis %s" % version)
         canonic_version = canonic_python_version[version]
         if canonic_version not in CANONIC2VERSION:
             raise RuntimeError(
-                f"Unsupported Python version {version} (canonic {canonic_version})"
+                "Unsupported Python version %s (canonic %s)"
+                % (version, canonic_version)
             )
         version = CANONIC2VERSION[canonic_version]
 
@@ -655,7 +656,8 @@ def get_scanner(version: Union[str, tuple], is_pypy=False, show_asm=None) -> Sca
             )
     else:
         raise RuntimeError(
-            f"Unsupported Python version, {version_tuple_to_str(version)}, for decompilation"
+            "Unsupported Python version, %s, for decompilation"
+            % version_tuple_to_str(version)
         )
     return scanner
 

uncompyle6/scanners/scanner2.py

@@ -200,6 +200,7 @@ class Scanner2(Scanner):
         grammar rules. Specifically, variable arg tokens like MAKE_FUNCTION or BUILD_LIST
         cause specific rules for the specific number of arguments they take.
         """
+
         if not show_asm:
             show_asm = self.show_asm
 
@@ -213,7 +214,7 @@ class Scanner2(Scanner):
                 names=co.co_names,
                 constants=co.co_consts,
                 cells=bytecode._cell_names,
-                line_starts=bytecode._linestarts,
+                linestarts=bytecode._linestarts,
                 asm_format="extended",
             )
 
@@ -495,8 +496,7 @@ class Scanner2(Scanner):
 
         if show_asm in ("both", "after"):
             print("\n# ---- tokenization:")
-            # FIXME: t.format() is changing tokens!
-            for t in new_tokens.copy():
+            for t in new_tokens:
                 print(t.format(line_prefix=""))
             print()
         return new_tokens, customize
@@ -1468,3 +1468,16 @@ class Scanner2(Scanner):
             instr_offsets = filtered
             filtered = []
         return instr_offsets
+
+
+if __name__ == "__main__":
+    import inspect
+
+    from xdis.version_info import PYTHON_VERSION_TRIPLE
+
+    co = inspect.currentframe().f_code
+
+    tokens, customize = Scanner2(PYTHON_VERSION_TRIPLE).ingest(co)
+    for t in tokens:
+        print(t)
+    pass

uncompyle6/scanners/scanner26.py

@@ -81,15 +81,9 @@ class Scanner26(scan.Scanner2):
         # show_asm = 'after'
         if show_asm in ("both", "before"):
             print("\n# ---- disassembly:")
-            bytecode.disassemble_bytes(
-                co.co_code,
-                varnames=co.co_varnames,
-                names=co.co_names,
-                constants=co.co_consts,
-                cells=bytecode._cell_names,
-                line_starts=bytecode._linestarts,
-                asm_format="extended",
-            )
+            for instr in bytecode.get_instructions(co):
+                print(instr.disassemble(self.opc))
+
         # Container for tokens
         tokens = []
 
@@ -353,8 +347,7 @@ class Scanner26(scan.Scanner2):
 
         if show_asm in ("both", "after"):
             print("\n# ---- tokenization:")
-            # FIXME: t.format() is changing tokens!
-            for t in tokens.copy():
+            for t in tokens:
                 print(t.format(line_prefix=""))
             print()
         return tokens, customize

uncompyle6/scanners/scanner3.py

@@ -36,7 +36,6 @@ Finally we save token information.
 from __future__ import print_function
 
 import sys
-from typing import Optional, Tuple
 
 import xdis
 
@@ -214,9 +213,9 @@ class Scanner3(Scanner):
         t: Token,
         i: int,
         collection_type: str,
-    ) -> Optional[list]:
+    ):
         """
-        Try to replace a sequence of instruction that ends with a
+        Try to a replace sequence of instruction that ends with a
         BUILD_xxx with a sequence that can be parsed much faster, but
         inserting the token boundary at the beginning of the sequence.
         """
@@ -261,7 +260,7 @@ class Scanner3(Scanner):
                 opname="COLLECTION_START",
                 attr=collection_enum,
                 pattr=collection_type,
-                offset=f"{start_offset}_0",
+                offset="%s_0" % start_offset,
                 linestart=False,
                 has_arg=True,
                 has_extended_arg=False,
@@ -285,7 +284,7 @@ class Scanner3(Scanner):
             )
         new_tokens.append(
             Token(
-                opname=f"BUILD_{collection_type}",
+                opname="BUILD_%s" % collection_type,
                 attr=t.attr,
                 pattr=t.pattr,
                 offset=t.offset,
@@ -298,10 +297,9 @@ class Scanner3(Scanner):
         )
         return new_tokens
 
-    # Move to scanner35?
-    def bound_map_from_inst_35(
-        self, insts: list, next_tokens: list, t: Token, i: int
-    ) -> Optional[list]:
+    def bound_map_from_inst(
+        self, insts: list, next_tokens: list, inst: Instruction, t: Token, i: int
+    ):
         """
         Try to a sequence of instruction that ends with a BUILD_MAP into
         a sequence that can be parsed much faster, but inserting the
@@ -316,8 +314,6 @@ class Scanner3(Scanner):
         if count < 5:
             return None
 
-        # Newer Python BUILD_MAP argument's count is a
-        # key and value pair so it is multiplied by two.
         collection_start = i - (count * 2)
         assert (count * 2) <= i
 
@@ -340,8 +336,8 @@ class Scanner3(Scanner):
                 opname="COLLECTION_START",
                 attr=collection_enum,
                 pattr="CONST_MAP",
-                offset=f"{start_offset}_0",
-                linestart=insts[collection_start].starts_line,
+                offset="%s_0" % start_offset,
+                linestart=False,
                 has_arg=True,
                 has_extended_arg=False,
                 opc=self.opc,
@@ -359,7 +355,6 @@ class Scanner3(Scanner):
                     has_arg=True,
                     has_extended_arg=False,
                     opc=self.opc,
-                    optype="pseudo",
                 )
             )
             new_tokens.append(
@@ -372,7 +367,7 @@ class Scanner3(Scanner):
                     has_arg=True,
                     has_extended_arg=False,
                     opc=self.opc,
-                    optype="pseudo",
+                    optype=insts[j + 1].optype,
                 )
             )
         new_tokens.append(
@@ -385,14 +380,12 @@ class Scanner3(Scanner):
                 has_arg=t.has_arg,
                 has_extended_arg=False,
                 opc=t.opc,
-                optype="pseudo",
+                optype=t.optype,
             )
         )
         return new_tokens
 
-    def ingest(
-        self, co, classname=None, code_objects={}, show_asm=None
-    ) -> Tuple[list, dict]:
+    def ingest(self, co, classname=None, code_objects={}, show_asm=None):
         """
         Create "tokens" the bytecode of an Python code object. Largely these
         are the opcode name, but in some cases that has been modified to make parsing
@@ -429,7 +422,7 @@ class Scanner3(Scanner):
                 names=co.co_names,
                 constants=co.co_consts,
                 cells=bytecode._cell_names,
-                line_starts=bytecode._linestarts,
+                linestarts=bytecode._linestarts,
                 asm_format="extended",
             )
 
@@ -494,16 +487,7 @@ class Scanner3(Scanner):
         last_op_was_break = False
         new_tokens = []
 
-        skip_end_offset = None
-
         for i, inst in enumerate(self.insts):
-            # BUILD_MAP for < 3.5 can skip *forward* in instructions and
-            # replace them. So we use the below to get up to the position
-            # scanned and replaced forward
-            if skip_end_offset and inst.offset <= skip_end_offset:
-                continue
-            skip_end_offset = None
-
             opname = inst.opname
             argval = inst.argval
             pattr = inst.argrepr
@@ -532,26 +516,22 @@ class Scanner3(Scanner):
                     else opname.split("_")[1]
                 )
                 try_tokens = self.bound_collection_from_inst(
-                    self.insts, new_tokens, inst, t, i, f"CONST_{collection_type}"
+                    self.insts, new_tokens, inst, t, i, "CONST_%s" % collection_type
                 )
                 if try_tokens is not None:
                     new_tokens = try_tokens
                     continue
-
             elif opname in ("BUILD_MAP",):
-                if self.version >= (3, 5):
-                    try_tokens = self.bound_map_from_inst_35(
-                        self.insts,
-                        new_tokens,
-                        t,
-                        i,
-                    )
-                    if try_tokens is not None:
-                        new_tokens = try_tokens
-                        continue
-                        pass
-                    pass
-                pass
+                try_tokens = self.bound_map_from_inst(
+                    self.insts,
+                    new_tokens,
+                    inst,
+                    t,
+                    i,
+                )
+                if try_tokens is not None:
+                    new_tokens = try_tokens
+                    continue
 
             argval = inst.argval
             op = inst.opcode
@@ -657,7 +637,7 @@ class Scanner3(Scanner):
                     elif flags == 9:
                         opname = "MAKE_FUNCTION_CLOSURE_POS"
                     else:
-                        opname = f"MAKE_FUNCTION_{flags}"
+                        opname = "MAKE_FUNCTION_%d" % (flags)
                     attr = []
                     for flag in self.MAKE_FUNCTION_FLAGS:
                         bit = flags & 1
@@ -669,17 +649,21 @@ class Scanner3(Scanner):
                         inst.argval
                     )
 
-                    pattr = f"{pos_args} positional, {name_pair_args} keyword only, {annotate_args} annotated"
+                    pattr = "%s positional, %s keyword only, %s annotated" % (
+                        pos_args,
+                        name_pair_args,
+                        annotate_args,
+                    )
 
                     if name_pair_args > 0 and annotate_args > 0:
                         # FIXME: this should probably be K_
-                        opname += f"_N{name_pair_args}_A{annotate_args}"
+                        opname += "_N%s_A%s" % (name_pair_args, annotate_args)
                         pass
                     elif annotate_args > 0:
-                        opname += f"_A_{annotate_args}"
+                        opname += "_A_%s" % annotate_args
                         pass
                     elif name_pair_args > 0:
-                        opname += f"_N_{name_pair_args}"
+                        opname += "_N_%s" % name_pair_args
                         pass
                     else:
                         # Rule customization mathics, MAKE_FUNCTION_...
@@ -806,8 +790,7 @@ class Scanner3(Scanner):
 
         if show_asm in ("both", "after"):
             print("\n# ---- tokenization:")
-            # FIXME: t.format() is changing tokens!
-            for t in new_tokens.copy():
+            for t in new_tokens:
                 print(t.format(line_prefix=""))
             print()
         return new_tokens, customize
@@ -1564,16 +1547,12 @@ class Scanner3(Scanner):
 
 
 if __name__ == "__main__":
+    import inspect
+
     from xdis.version_info import PYTHON_VERSION_TRIPLE
 
-    if PYTHON_VERSION_TRIPLE >= (3, 2):
-        import inspect
+    co = inspect.currentframe().f_code
 
-        co = inspect.currentframe().f_code
-
-        tokens, customize = Scanner3(PYTHON_VERSION_TRIPLE).ingest(co)
-        for t in tokens:
-            print(t)
-    else:
-        print("Need to be Python 3.2 or greater to demo; I am %s." % sys.version)
-    pass
+    tokens, customize = Scanner3(PYTHON_VERSION_TRIPLE).ingest(co)
+    for t in tokens:
+        print(t)

uncompyle6/scanners/scanner37.py

@@ -22,13 +22,12 @@ This sets up opcodes Python's 3.7 and calls a generalized
 scanner routine for Python 3.
 """
 
-from typing import Tuple
-
 # bytecode verification, verify(), uses JUMP_OPs from here
 from xdis.opcodes import opcode_37 as opc
 
-from uncompyle6.scanner import CONST_COLLECTIONS, Token
+from uncompyle6.scanner import CONST_COLLECTIONS
 from uncompyle6.scanners.scanner37base import Scanner37Base
+from uncompyle6.scanners.tok import Token
 
 # bytecode verification, verify(), uses JUMP_OPS from here
 JUMP_OPs = opc.JUMP_OPS
@@ -85,7 +84,7 @@ class Scanner37(Scanner37Base):
                 opname="COLLECTION_START",
                 attr=collection_enum,
                 pattr=collection_type,
-                offset=f"{start_offset}_0",
+                offset="%s_0" % start_offset,
                 linestart=False,
                 has_arg=True,
                 has_extended_arg=False,
@@ -109,7 +108,7 @@ class Scanner37(Scanner37Base):
             )
         new_tokens.append(
             Token(
-                opname=f"BUILD_{collection_type}",
+                opname="BUILD_%s" % collection_type,
                 attr=t.attr,
                 pattr=t.pattr,
                 offset=t.offset,
@@ -121,9 +120,7 @@ class Scanner37(Scanner37Base):
         )
         return new_tokens
 
-    def ingest(
-        self, bytecode, classname=None, code_objects={}, show_asm=None
-    ) -> Tuple[list, dict]:
+    def ingest(self, bytecode, classname=None, code_objects={}, show_asm=None):
         """
         Create "tokens" the bytecode of an Python code object. Largely these
         are the opcode name, but in some cases that has been modified to make parsing
@@ -159,7 +156,7 @@ class Scanner37(Scanner37Base):
                     else t.kind.split("_")[1]
                 )
                 new_tokens = self.bound_collection_from_tokens(
-                    tokens, new_tokens, t, i, f"CONST_{collection_type}"
+                    tokens, new_tokens, t, i, "CONST_%s" % collection_type
                 )
                 continue
 
@@ -197,4 +194,6 @@ if __name__ == "__main__":
             print(t.format())
         pass
     else:
-        print(f"Need to be Python 3.7 to demo; I am version {version_tuple_to_str()}.")
+        print(
+            "Need to be Python 3.7 to demo; I am version %s." % version_tuple_to_str()
+        )

uncompyle6/scanners/scanner37base.py

@@ -30,7 +30,6 @@ Finally we save token information.
 """
 
 import sys
-from typing import Any, Dict, List, Set, Tuple
 
 import xdis
 
@@ -48,9 +47,7 @@ CONST_COLLECTIONS = ("CONST_LIST", "CONST_SET", "CONST_DICT")
 
 
 class Scanner37Base(Scanner):
-    def __init__(
-        self, version: Tuple[int, int], show_asm=None, debug="", is_pypy=False
-    ):
+    def __init__(self, version: tuple, show_asm=None, debug="", is_pypy=False):
         super(Scanner37Base, self).__init__(version, show_asm, is_pypy)
         self.offset2tok_index = None
         self.debug = debug
@@ -228,13 +225,13 @@ class Scanner37Base(Scanner):
 
         if show_asm in ("both", "before"):
             print("\n# ---- disassembly:")
-            bytecode.disassemble_bytes(
+            self.insts = bytecode.disassemble_bytes(
                 co.co_code,
                 varnames=co.co_varnames,
                 names=co.co_names,
                 constants=co.co_consts,
                 cells=bytecode._cell_names,
-                line_starts=bytecode._linestarts,
+                linestarts=bytecode._linestarts,
                 asm_format="extended",
                 filename=co.co_filename,
                 show_source=True,
@@ -481,17 +478,12 @@ class Scanner37Base(Scanner):
                     next_opname = self.insts[i + 1].opname
 
                     # 'Continue's include jumps to loops that are not
-                    # and the end of a block which follow with
-                    # POP_BLOCK and COME_FROM_LOOP.  If the
-                    # JUMP_ABSOLUTE is to a FOR_ITER, and it is
-                    # followed by another JUMP_FORWARD then we'll take
-                    # it as a "continue".
-                    next_inst = self.insts[i + 1]
-                    is_continue = self.insts[
-                        self.offset2inst_index[target]
-                    ].opname == "FOR_ITER" and next_inst.opname in (
-                        "JUMP_FORWARD",
-                        "JUMP_ABSOLUTE",
+                    # and the end of a block which follow with POP_BLOCK and COME_FROM_LOOP.
+                    # If the JUMP_ABSOLUTE is to a FOR_ITER and it is followed by another JUMP_FORWARD
+                    # then we'll take it as a "continue".
+                    is_continue = (
+                        self.insts[self.offset2inst_index[target]].opname == "FOR_ITER"
+                        and self.insts[i + 1].opname == "JUMP_FORWARD"
                     )
 
                     if self.version < (3, 8) and (
@@ -506,65 +498,21 @@ class Scanner37Base(Scanner):
                     ):
                         opname = "CONTINUE"
                     else:
-                        # "continue" versus "break_loop" dectction is more complicated
-                        # because "continue" to an outer loop is really a "break loop"
                         opname = "JUMP_BACK"
-
                         # FIXME: this is a hack to catch stuff like:
                         #   if x: continue
                         # the "continue" is not on a new line.
-                        #
-                        # Another situation is where we have
-                        #   for method in methods:
-                        #      for B in method:
-                        #         if c:
-                        #           return
-                        #        break  # A "continue" but not the innermost one
-                        if tokens[-1].kind == "JUMP_LOOP" and tokens[-1].attr <= argval:
+                        # There are other situations where we don't catch
+                        # CONTINUE as well.
+                        if tokens[-1].kind == "JUMP_BACK" and tokens[-1].attr <= argval:
                             if tokens[-2].kind == "BREAK_LOOP":
                                 del tokens[-1]
-                                j -= 1
                             else:
-                                # "intern" is used because we are
-                                # changing the *previous* token.  A
-                                # POP_TOP suggests a "break" rather
-                                # than a "continue"?
-                                if tokens[-2] == "POP_TOP" and (
-                                    is_continue and next_inst.argval != tokens[-1].attr
-                                ):
-                                    tokens[-1].kind = sys.intern("BREAK_LOOP")
-                                else:
-                                    tokens[-1].kind = sys.intern("CONTINUE")
-                                    last_continue = tokens[-1]
-                                    pass
-                                pass
-                            pass
-                    #     elif (
-                    #         last_continue is not None
-                    #         and tokens[-1].kind == "JUMP_LOOP"
-                    #         and last_continue.attr <= tokens[-1].attr
-                    #         and last_continue.offset > tokens[-1].attr
-                    #     ):
-                    #         # Handle mis-characterized "CONTINUE"
-                    #         # We have a situation like:
-                    #         # loop ... for or while)
-                    #         #   loop
-                    #         #     if ...:   # code below starts here
-                    #         #       break  # not continue
-                    #         #
-                    #         #   POP_JUMP_IF_FALSE_LOOP   # to outer loop
-                    #         #   JUMP_LOOP                # to inner loop
-                    #         #   ...
-                    #         #   JUMP_LOOP                # to outer loop
-                    #         tokens[-2].kind = sys.intern("BREAK_LOOP")
-                    #         pass
-
-                    # if last_op_was_break and opname == "CONTINUE":
-                    #     last_op_was_break = False
-                    #     continue
-                    pass
-                else:
-                    opname = "JUMP_FORWARD"
+                                # intern is used because we are changing the *previous* token
+                                tokens[-1].kind = sys.intern("CONTINUE")
+                    if last_op_was_break and opname == "CONTINUE":
+                        last_op_was_break = False
+                        continue
 
             elif inst.offset in self.load_asserts:
                 opname = "LOAD_ASSERT"
@@ -587,10 +535,9 @@ class Scanner37Base(Scanner):
             )
             pass
 
-        if show_asm in ("both", "after") and self.version < (3, 8):
+        if show_asm in ("both", "after"):
             print("\n# ---- tokenization:")
-            # FIXME: t.format() is changing tokens!
-            for t in tokens.copy():
+            for t in tokens:
                 print(t.format(line_prefix=""))
             print()
         return tokens, customize
@@ -610,17 +557,17 @@ class Scanner37Base(Scanner):
         self.structs = [{"type": "root", "start": 0, "end": n - 1}]
 
         # All loop entry points
-        self.loops: List[int] = []
+        self.loops = []
 
         # Map fixed jumps to their real destination
-        self.fixed_jumps: Dict[int, int] = {}
+        self.fixed_jumps = {}
         self.except_targets = {}
-        self.ignore_if: Set[int] = set()
+        self.ignore_if = set()
         self.build_statement_indices()
 
         # Containers filled by detect_control_flow()
-        self.not_continue: Set[int] = set()
-        self.return_end_ifs: Set[int] = set()
+        self.not_continue = set()
+        self.return_end_ifs = set()
         self.setup_loop_targets = {}  # target given setup_loop offset
         self.setup_loops = {}  # setup_loop offset given target
 
@@ -758,9 +705,7 @@ class Scanner37Base(Scanner):
         # Finish filling the list for last statement
         slist += [codelen] * (codelen - len(slist))
 
-    def detect_control_flow(
-        self, offset: int, targets: Dict[Any, Any], inst_index: int
-    ):
+    def detect_control_flow(self, offset, targets, inst_index):
         """
         Detect type of block structures and their boundaries to fix optimized jumps
         in python2.3+
@@ -771,9 +716,9 @@ class Scanner37Base(Scanner):
         op = inst.opcode
 
         # Detect parent structure
-        parent: Dict[str, Any] = self.structs[0]
-        start: int = parent["start"]
-        end: int = parent["end"]
+        parent = self.structs[0]
+        start = parent["start"]
+        end = parent["end"]
 
         # Pick inner-most parent for our offset
         for struct in self.structs:
@@ -1008,7 +953,6 @@ if __name__ == "__main__":
             print(t)
     else:
         print(
-            "Need to be Python 3.7..3.8 to demo; "
-            f"I am version {version_tuple_to_str()}."
+            "Need to be Python 3.7 to demo; I am version %s." % version_tuple_to_str()
         )
     pass

uncompyle6/scanners/scanner38.py

@@ -1,4 +1,4 @@
-#  Copyright (c) 2019-2022, 2024 by Rocky Bernstein
+#  Copyright (c) 2019-2022 by 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
@@ -22,15 +22,13 @@ This sets up opcodes Python's 3.8 and calls a generalized
 scanner routine for Python 3.7 and up.
 """
 
-from typing import Dict, Tuple
+from uncompyle6.scanners.tok import off2int
+from uncompyle6.scanners.scanner37 import Scanner37
+from uncompyle6.scanners.scanner37base import Scanner37Base
 
 # bytecode verification, verify(), uses JUMP_OPs from here
 from xdis.opcodes import opcode_38 as opc
 
-from uncompyle6.scanners.scanner37 import Scanner37
-from uncompyle6.scanners.scanner37base import Scanner37Base
-from uncompyle6.scanners.tok import off2int
-
 # bytecode verification, verify(), uses JUMP_OPS from here
 JUMP_OPs = opc.JUMP_OPS
 
@@ -45,7 +43,7 @@ class Scanner38(Scanner37):
 
     def ingest(
         self, bytecode, classname=None, code_objects={}, show_asm=None
-    ) -> Tuple[list, dict]:
+    ) -> tuple:
         """
         Create "tokens" the bytecode of an Python code object. Largely these
         are the opcode name, but in some cases that has been modified to make parsing
@@ -73,7 +71,7 @@ class Scanner38(Scanner37):
         # The value is where the loop ends. In current Python,
         # JUMP_BACKS are always to loops. And blocks are ordered so that the
         # JUMP_BACK with the highest offset will be where the range ends.
-        jump_back_targets: Dict[int, int] = {}
+        jump_back_targets = {}
         for token in tokens:
             if token.kind == "JUMP_BACK":
                 jump_back_targets[token.attr] = token.offset
@@ -92,7 +90,7 @@ class Scanner38(Scanner37):
             if offset == next_end:
                 loop_ends.pop()
                 if self.debug:
-                    print(f"{'  ' * len(loop_ends)}remove loop offset {offset}")
+                    print("%sremove loop offset %s" % (" " * len(loop_ends), offset))
                     pass
                 next_end = (
                     loop_ends[-1]
@@ -106,7 +104,8 @@ class Scanner38(Scanner37):
                 next_end = off2int(jump_back_targets[offset], prefer_last=False)
                 if self.debug:
                     print(
-                        f"{'  ' * len(loop_ends)}adding loop offset {offset} ending at {next_end}"
+                        "%sadding loop offset %s ending at %s"
+                        % ("  " * len(loop_ends), offset, next_end)
                     )
                 loop_ends.append(next_end)
 
@@ -121,26 +120,35 @@ class Scanner38(Scanner37):
                     new_tokens.append(token)
                     continue
 
-                j = i
-                while tokens[j - 1] in ("POP_TOP", "POP_BLOCK", "POP_EXCEPT"):
-                    j -= 1
-                    if tokens[j].linestart:
-                        break
-                token_with_linestart = tokens[j]
+                # We also want to avoid confusing BREAK_LOOPS with parts of the
+                # grammar rules for loops. (Perhaps we should change the grammar.)
+                # Try to find an adjacent JUMP_BACK which is part of the normal loop end.
 
-                if token_with_linestart.linestart:
+                if i + 1 < len(tokens) and tokens[i + 1] == "JUMP_BACK":
+                    # Sometimes the jump back is after the "break" instruction..
+                    jump_back_index = i + 1
+                else:
+                    # and sometimes, because of jump-to-jump optimization, it is before the
+                    # jump target instruction.
+                    jump_back_index = self.offset2tok_index[jump_target] - 1
+                    while tokens[jump_back_index].kind.startswith("COME_FROM_"):
+                        jump_back_index -= 1
+                        pass
+                    pass
+                jump_back_token = tokens[jump_back_index]
+
+                # Is this a forward jump not next to a JUMP_BACK ? ...
+                break_loop = token.linestart and jump_back_token != "JUMP_BACK"
+
+                # or if there is looping jump back, then that loop
+                # should start before where the "break" instruction sits.
+                if break_loop or (
+                    jump_back_token == "JUMP_BACK"
+                    and jump_back_token.attr < token.off2int()
+                ):
                     token.kind = "BREAK_LOOP"
-
                 pass
             new_tokens.append(token)
-
-        if show_asm in ("both", "after"):
-            print("\n# ---- tokenization:")
-            # FIXME: t.format() is changing tokens!
-            for t in new_tokens.copy():
-                print(t.format(line_prefix=""))
-            print()
-
         return new_tokens, customize
 
 
@@ -156,4 +164,4 @@ if __name__ == "__main__":
             print(t.format())
         pass
     else:
-        print(f"Need to be Python 3.8 to demo; I am version {version_tuple_to_str()}.")
+        print("Need to be Python 3.8 to demo; I am version %s." % version_tuple_to_str())

uncompyle6/scanners/tok.py

@@ -19,7 +19,6 @@ import re
 import sys
 
 intern = sys.intern
-from typing import Union
 
 
 def off2int(offset, prefer_last=True):
@@ -61,7 +60,7 @@ class Token:
         opname,
         attr=None,
         pattr=None,
-        offset: Union[int, str] = -1,
+        offset=-1,
         linestart=None,
         op=None,
         has_arg=None,
@@ -88,7 +87,7 @@ class Token:
             try:
                 from xdis.std import _std_api
             except KeyError as e:
-                print(f"I don't know about Python version {e} yet.")
+                print("I don't know about Python version %s yet." % e)
                 try:
                     version_tuple = tuple(int(i) for i in str(e)[1:-1].split("."))
                 except Exception:
@@ -97,7 +96,7 @@ class Token:
                     if version_tuple > (3, 9):
                         print("Python versions 3.9 and greater are not supported.")
                     else:
-                        print(f"xdis might need to be informed about version {e}")
+                        print("xdis might need to be informed about version {e}" % e)
                 return
 
             self.opc = _std_api.opc

uncompyle6/semantics/aligner.py

@@ -1,4 +1,4 @@
-#  Copyright (c) 2018, 2022-2024 by Rocky Bernstein
+#  Copyright (c) 2018, 2022-2023 by 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
@@ -18,14 +18,11 @@ import sys
 from spark_parser import DEFAULT_DEBUG as PARSER_DEFAULT_DEBUG
 from xdis import iscode
 
-from xdis.version_info import IS_PYPY, PYTHON_VERSION_TRIPLE
-
+from xdis.version_info import IS_PYPY
 from uncompyle6.scanner import get_scanner
-from uncompyle6.semantics.consts import  ASSIGN_DOC_STRING
-
 from uncompyle6.semantics.pysource import (
+    ASSIGN_DOC_STRING,
     RETURN_NONE,
-    TREE_DEFAULT_DEBUG,
     SourceWalker,
     SourceWalkerError,
     find_globals_and_nonlocals
@@ -41,7 +38,7 @@ class AligningWalker(SourceWalker, object):
         version,
         out,
         scanner,
-        showast=TREE_DEFAULT_DEBUG,
+        showast=False,
         debug_parser=PARSER_DEFAULT_DEBUG,
         compile_mode="exec",
         is_pypy=False,
@@ -51,7 +48,6 @@ class AligningWalker(SourceWalker, object):
         )
         self.desired_line_number = 0
         self.current_line_number = 0
-        self.showast = showast
 
     def println(self, *data):
         if data and not (len(data) == 1 and data[0] == ""):
@@ -117,12 +113,12 @@ class AligningWalker(SourceWalker, object):
             key = key[i]
             pass
 
-        if key.kind in table:
-            self.template_engine(table[key.kind], node)
+        if key.type in table:
+            self.template_engine(table[key.type], node)
             self.prune()
 
 
-DEFAULT_DEBUG_OPTS = {"asm": False, "tree": TREE_DEFAULT_DEBUG, "grammar": False}
+DEFAULT_DEBUG_OPTS = {"asm": False, "tree": False, "grammar": False}
 
 
 def code_deparse_align(
@@ -141,7 +137,7 @@ def code_deparse_align(
     assert iscode(co)
 
     if version is None:
-        version = PYTHON_VERSION_TRIPLE
+        version = float(sys.version[0:3])
     if is_pypy is None:
         is_pypy = IS_PYPY
 
@@ -160,11 +156,11 @@ def code_deparse_align(
         debug_parser["errorstack"] = True
 
     #  Build a parse tree from tokenized and massaged disassembly.
-    show_ast = debug_opts.get("ast", TREE_DEFAULT_DEBUG)
+    show_ast = debug_opts.get("ast", None)
     deparsed = AligningWalker(
         version,
-        out,
         scanner,
+        out,
         showast=show_ast,
         debug_parser=debug_parser,
         compile_mode=compile_mode,
@@ -214,4 +210,4 @@ if __name__ == "__main__":
         print(deparsed.text)
         return
 
-    deparse_test(deparse_test.func_code)
+    deparse_test(deparse_test.__code__)

uncompyle6/semantics/consts.py

@@ -44,7 +44,7 @@ maxint = sys.maxsize
 # children. For example, "call" has precedence 2 so we don't get
 # additional the additional parenthesis of: ".. op (call())".  However
 # for call's children, it parameters, we set the the precedence high,
-# say to 100, to make sure we avoid additional parenthesis in
+# say to 100, to make sure we avoid additional prenthesis in
 # call((.. op ..)).
 
 NO_PARENTHESIS_EVER = 100
@@ -57,8 +57,6 @@ PRECEDENCE = {
     "list_unpack":            38,  # *args
     "yield_from":             38,
     "tuple_list_starred":     38,  # *x, *y, *z - about at the level of yield?
-    "unpack":                 38,  # A guess. Used in "async with ... as ...
-                                   # This might also get used in tuple assignment?
 
     "_lambda_body":           30,
     "lambda_body":            32,  # lambda ... : lambda_body
@@ -132,7 +130,7 @@ LINE_LENGTH = 80
 # Some parse trees created below are used for comparing code
 # fragments (like "return None" at the end of functions).
 
-ASSIGN_DOC_STRING = lambda doc_string, doc_load: SyntaxTree(    # noqa
+ASSIGN_DOC_STRING = lambda doc_string, doc_load: SyntaxTree(
     "assign",
     [
         SyntaxTree(
@@ -158,7 +156,6 @@ NAME_MODULE = SyntaxTree(
     ],
 )
 
-NEWLINE = SyntaxTree("newline", [])
 NONE = SyntaxTree("expr", [NoneToken])
 
 RETURN_NONE = SyntaxTree("stmt", [SyntaxTree("return", [NONE, Token("RETURN_VALUE")])])
@@ -243,86 +240,149 @@ TABLE_DIRECT = {
     "UNARY_NOT":                ( "not ", ),
     "UNARY_POSITIVE":           ( "+",),
 
-    "and": ("%c and %c", 0, 2),
-    "and2": ("%c", 3),
+    # bin_op (formerly "binary_expr") is the Python AST BinOp
+    "bin_op": ("%c %c %c", 0, (-1, "binary_operator"), (1, "expr")),
+    # unary_op (formerly "unary_expr") is the Python AST UnaryOp
+    "unary_op": ("%c%c", (1, "unary_operator"), (0, "expr")),
+    "unary_not": ("not %c", (0, "expr")),
+    "unary_convert": ("`%c`", (0, "expr"),),
+    "get_iter": ("iter(%c)", (0, "expr"),),
 
-    "assert_expr_or": ("%c or %c", 0, 2),
-    "assert_expr_and": ("%c and %c", 0, 2),
+    "set_iter":        ( "%c", 0 ),
 
-    "assign": (
-        "%|%c = %p\n",
-        -1,
-        (0, ("expr", "branch_op"), PRECEDENCE["tuple_list_starred"] + 1)
+    "slice0": (
+        "%c[:]",
+        (0, "expr"),
+        ),
+    "slice1": (
+        "%c[%p:]",
+        (0, "expr"),
+        (1, NO_PARENTHESIS_EVER)
+        ),
+
+    "slice2": ( "%c[:%p]",
+        (0, "expr"),
+        (1, NO_PARENTHESIS_EVER)
+        ),
+
+    "slice3": (
+        "%c[%p:%p]",
+        (0, "expr"),
+        (1, NO_PARENTHESIS_EVER),
+        (2, NO_PARENTHESIS_EVER)
         ),
 
     "attribute": ("%c.%[1]{pattr}", (0, "expr")),
-
-    # This nonterminal we create on the fly in semantic routines
-    "attribute_w_parens": ("(%c).%[1]{pattr}", (0, "expr")),
-
-    # The 2nd parameter should have a = suffix.
-    # There is a rule with a 4th parameter "store"
-    # which we don't use here.
-    "aug_assign1": ("%|%c %c %c\n", 0, 2, 1),
-    "aug_assign2": ("%|%c.%[2]{pattr} %c %c\n", 0, -3, -4),
-
-    # bin_op (formerly "binary_expr") is the Python AST BinOp
-    "bin_op": ("%c %c %c", 0, (-1, "binary_operator"), (1, "expr")),
-
-    "break": ("%|break\n",),
-    "build_tuple2": (
-        "%P",
-        (0, -1, ", ", NO_PARENTHESIS_EVER)
-    ),
-
-    "call_stmt":	   ( "%|%p\n",
-                             # When a call statement contains only a named_expr (:=)
-                             # the named_expr should have parenthesis around it.
-                             (0, PRECEDENCE["named_expr"]-1)),
-
-    # "classdef": (), # handled by n_classdef()
-    # A custom rule in n_function def distinguishes whether to call this or
-    # function_def_async
-
-    "classdefdeco": ("\n\n%c", 0),
-    "classdefdeco1": ("%|@%c\n%c", 0, 1),
-
-    "comp_body": ("",),  # ignore when recusing
-    "comp_if": (" if %c%c", 0, 2),
-    "comp_if_not": (" if not %p%c", (0, "expr", PRECEDENCE["unary_not"]), 2),
-    "comp_iter": ("%c", 0),
-
-    "compare_single": ('%p %[-1]{pattr.replace("-", " ")} %p', (0, 19), (1, 19)),
-    "compare_chained": ("%p %p", (0, 29), (1, 30)),
-    "compared_chained_middle": ('%[3]{pattr.replace("-", " ")} %p %p', (0, 19), (-2, 19)),
-    "compare_chained_right": ('%[1]{pattr.replace("-", " ")} %p', (0, 19)),
-
-    "continue": ("%|continue\n",),
-
     "delete_subscript": (
         "%|del %p[%c]\n",
         (0, "expr", PRECEDENCE["subscript"]),
         (1, "expr"),
     ),
-    "designList": ("%c = %c", 0, -1),
-    "dict_comp_body": ("%c: %c", 1, 0),
 
-    "elifelifstmt": ("%|elif %c:\n%+%c%-%c", 0, 1, 3),
-    "elifelsestmt": ("%|elif %c:\n%+%c%-%|else:\n%+%c%-", 0, 1, 3),
-    "elifelsestmtr": ("%|elif %c:\n%+%c%-%|else:\n%+%c%-\n\n", 0, 1, 2),
-    "elifelsestmtr2": (
-        "%|elif %c:\n%+%c%-%|else:\n%+%c%-\n\n",
-        0,
-        1,
-        3,
-    ),  # has COME_FROM
-    "elifstmt": ("%|elif %c:\n%+%c%-", 0, 1),
+    "subscript": (
+        "%p[%p]",
+        (0, "expr", PRECEDENCE["subscript"]),
+        (1, "expr", NO_PARENTHESIS_EVER)
+    ),
+
+    "subscript2": (
+        "%p[%p]",
+        (0, "expr", PRECEDENCE["subscript"]),
+        (1, "expr", NO_PARENTHESIS_EVER)
+    ),
+
+    "store_subscript": ("%p[%c]", (0, "expr", PRECEDENCE["subscript"]), (1, "expr")),
+    "unpack": ("%C%,", (1, maxint, ", ")),
+    # This nonterminal we create on the fly in semantic routines
+    "unpack_w_parens": ("(%C%,)", (1, maxint, ", ")),
+    # This nonterminal we create on the fly in semantic routines
+    "attribute_w_parens": ("(%c).%[1]{pattr}", (0, "expr")),
+    # This nonterminal we create on the fly in semantic routines
+    "store_w_parens": ("(%c).%[1]{pattr}", (0, "expr")),
+    "unpack_list": ("[%C]", (1, maxint, ", ")),
+    "build_tuple2": ("%P", (0, -1, ", ", 100)),
+    "list_iter": ("%c", 0),
+    "list_for": (" for %c in %c%c", 2, 0, 3),
+    "list_if": (" if %p%c", (0, "expr", 27), 2),
+    "list_if_not": (" if not %p%c", (0, "expr", PRECEDENCE["unary_not"]), 2),
+    "lc_body": ("",),  # ignore when recursing
+    "comp_iter": ("%c", 0),
+    "comp_if": (" if %c%c", 0, 2),
+    "comp_if_not": (" if not %p%c", (0, "expr", PRECEDENCE["unary_not"]), 2),
+    "comp_body": ("",),  # ignore when recusing
+
+    "set_comp_body": ("%c", 0),
+    "gen_comp_body": ("%c", 0),
+    "dict_comp_body": ("%c: %c", 1, 0),
+    "assign": ("%|%c = %p\n", -1, (0, 200)),
+    # The 2nd parameter should have a = suffix.
+    # There is a rule with a 4th parameter "store"
+    # which we don't use here.
+    "aug_assign1": ("%|%c %c %c\n", 0, 2, 1),
+    "aug_assign2": ("%|%c.%[2]{pattr} %c %c\n", 0, -3, -4),
+    "designList": ("%c = %c", 0, -1),
+    "and": ("%c and %c", 0, 2),
+    "ret_and": ("%c and %c", 0, 2),
+    "and2": ("%c", 3),
+    "or": ("%p or %p", (0, PRECEDENCE["or"]), (1, PRECEDENCE["or"])),
+    "ret_or": ("%c or %c", 0, 2),
+    "if_exp": ("%p if %c else %c", (2, "expr", 27), 0, 4),
+    "if_exp_lambda": ("%p if %c else %c", (2, "expr", 27), (0, "expr"), 4),
+    "if_exp_true": ("%p if 1 else %c", (0, "expr", 27), 2),
+    "if_exp_ret": ("%p if %p else %p", (2, 27), (0, 27), (-1, 27)),
+    "if_exp_not": (
+        "%p if not %p else %p",
+        (2, 27),
+        (0, "expr", PRECEDENCE["unary_not"]),
+        (4, 27),
+    ),
+    "if_exp_not_lambda": ("%p if not %c else %c", (2, "expr", 27), 0, 4),
+    "compare_single": ('%p %[-1]{pattr.replace("-", " ")} %p', (0, 19), (1, 19)),
+    "compare_chained": ("%p %p", (0, 29), (1, 30)),
+    "compared_chained_middle": ('%[3]{pattr.replace("-", " ")} %p %p', (0, 19), (-2, 19)),
+    "compare_chained_right": ('%[1]{pattr.replace("-", " ")} %p', (0, 19)),
+    #   "classdef": 	(), # handled by n_classdef()
+    # A custom rule in n_function def distinguishes whether to call this or
+    # function_def_async
+
+    "function_def": ("\n\n%|def %c\n", -2),  # -2 to handle closures
+    "function_def_deco": ("\n\n%c", 0),
+    "mkfuncdeco": ("%|@%c\n%c", 0, 1),
+    # A custom rule in n_function def distinguishes whether to call this or
+    # function_def_async
+    "mkfuncdeco0": ("%|def %c\n", 0),
+    "classdefdeco": ("\n\n%c", 0),
+    "classdefdeco1": ("%|@%c\n%c", 0, 1),
+    "kwarg": ("%[0]{pattr}=%c", 1),  # Change when Python 2 does LOAD_STR
+    "kwargs": ("%D", (0, maxint, ", ")),
+    "kwargs1": ("%D", (0, maxint, ", ")),
+    "assert_expr_or": ("%c or %c", 0, 2),
+    "assert_expr_and": ("%c and %c", 0, 2),
+    "print_items_stmt": ("%|print %c%c,\n", 0, 2),  # Python 2 only
+    "print_items_nl_stmt": ("%|print %c%c\n", 0, 2),
+    "print_item": (", %c", 0),
+    "print_nl": ("%|print\n",),
+    "print_to": ("%|print >> %c, %c,\n", 0, 1),
+    "print_to_nl": ("%|print >> %c, %c\n", 0, 1),
+    "print_nl_to": ("%|print >> %c\n", 0),
+    "print_to_items": ("%C", (0, 2, ", ")),
+    # This is only generated by transform
+    # it is a string at the beginning of a function that is *not* a docstring
+    # 3.7 test_fstring.py tests for this kind of crap.
+    # For compatibility with older Python, we'll use "%" instead of
+    # a format string.
+    "string_at_beginning": ('%|"%%s" %% %c\n', 0),
+    "call_stmt":	   ( "%|%p\n",
+                             # When a call statement contains only a named_expr (:=)
+                             # the named_expr should have parenthesis around it.
+                             (0, PRECEDENCE["named_expr"]-1)),
+    "break": ("%|break\n",),
+    "continue": ("%|continue\n",),
 
     "except": ("%|except:\n%+%c%-", 3),
     "except_cond1": ("%|except %c:\n", 1),
     "except_cond2": ("%|except %c as %c:\n", (1, "expr"), (5, "store")),
     "except_suite": ("%+%c%-%C", 0, (1, maxint, "")),
-
     # In Python 3.6+, this is more complicated in the presence of "returns"
     "except_suite_finalize": ("%+%c%-%C", 1, (3, maxint, "")),
 
@@ -331,7 +391,7 @@ TABLE_DIRECT = {
         # When a statement contains only a named_expr (:=)
         # the named_expr should have parenthesis around it.
         (0, "expr", PRECEDENCE["named_expr"] - 1)
-    ),
+        ),
 
     # Note: Python 3.8+ changes this
     "for": ("%|for %c in %c:\n%+%c%-\n\n", (3, "store"), (1, "expr"), (4, "for_block")),
@@ -358,24 +418,24 @@ TABLE_DIRECT = {
         -2,
     ),
 
-    "function_def": ("\n\n%|def %c\n", -2),  # -2 to handle closures
-    "function_def_deco": ("\n\n%c", 0),
+    "raise_stmt0": ("%|raise\n",),
+    "raise_stmt1": ("%|raise %c\n", 0),
+    "raise_stmt3": ("%|raise %c, %c, %c\n", 0, 1, 2),
+    #    "yield":	        ( "yield %c", 0),
 
-    "gen_comp_body": ("%c", 0),
-    "get_iter": ("iter(%c)", (0, "expr"),),
+    # Note: we have a custom rule, which calls when we don't
+    # have "return None"
+    "return":	( "%|return %c\n", 0),
 
-    "if_exp": ("%p if %c else %c", (2, "expr", 27), 0, 4),
-    "if_exp_lambda": ("%p if %c else %c", (2, "expr", 27), (0, "expr"), 4),
-    "if_exp_true": ("%p if 1 else %c", (0, "expr", 27), 2),
-    "if_exp_ret": ("%p if %p else %p", (2, 27), (0, 27), (-1, 27)),
-    "if_exp_not": (
-        "%p if not %p else %p",
-        (2, 27),
-        (0, "expr", PRECEDENCE["unary_not"]),
-        (4, 27),
+    "return_if_stmt": ("return %c\n", 0),
+    "ifstmt": (
+        "%|if %c:\n%+%c%-",
+        0,  # "testexpr" or "testexpr_then"
+        1,  # "_ifstmts_jump" or "return_stmts"
     ),
-    "if_exp_not_lambda": ("%p if not %c else %c", (2, "expr", 27), 0, 4),
-
+    "iflaststmt": ("%|if %c:\n%+%c%-", 0, 1),
+    "iflaststmtl": ("%|if %c:\n%+%c%-", 0, 1),
+    "testtrue": ("not %p", (0, PRECEDENCE["unary_not"])),
     # Generally the args here are 0: (some sort of) "testexpr",
     #                             1: (some sort of) "cstmts_opt",
     #                             2 or 3: "else_suite"
@@ -385,21 +445,20 @@ TABLE_DIRECT = {
     "ifelsestmt": ("%|if %c:\n%+%c%-%|else:\n%+%c%-", 0, 1, 3),
     "ifelsestmtc": ("%|if %c:\n%+%c%-%|else:\n%+%c%-", 0, 1, 3),
     "ifelsestmtl": ("%|if %c:\n%+%c%-%|else:\n%+%c%-", 0, 1, 3),
-
-    #  This is created only via transformation.
+    #  These are created only via transformation
     "ifelifstmt": ("%|if %c:\n%+%c%-%c", 0, 1, 3),  # "testexpr" or "testexpr_then"
-
+    "elifelifstmt": ("%|elif %c:\n%+%c%-%c", 0, 1, 3),
+    "elifstmt": ("%|elif %c:\n%+%c%-", 0, 1),
+    "elifelsestmt": ("%|elif %c:\n%+%c%-%|else:\n%+%c%-", 0, 1, 3),
     "ifelsestmtr": ("%|if %c:\n%+%c%-%|else:\n%+%c%-", 0, 1, 2),
     "ifelsestmtr2": ("%|if %c:\n%+%c%-%|else:\n%+%c%-\n\n", 0, 1, 3),  # has COME_FROM
-    "iflaststmt": ("%|if %c:\n%+%c%-", 0, 1),
-
-    "iflaststmtl": ("%|if %c:\n%+%c%-", 0, 1),
-
-    "ifstmt": (
-        "%|if %c:\n%+%c%-",
-        0,  # "testexpr" or "testexpr_then"
-        1,  # "_ifstmts_jump" or "return_stmts"
-    ),
+    "elifelsestmtr": ("%|elif %c:\n%+%c%-%|else:\n%+%c%-\n\n", 0, 1, 2),
+    "elifelsestmtr2": (
+        "%|elif %c:\n%+%c%-%|else:\n%+%c%-\n\n",
+        0,
+        1,
+        3,
+    ),  # has COME_FROM
 
     "import": ("%|import %c\n", 2),
     "importlist": ("%C", (0, maxint, ", ")),
@@ -417,131 +476,8 @@ TABLE_DIRECT = {
 
     "kv": ("%c: %c", 3, 1),
     "kv2": ("%c: %c", 1, 2),
-
-    "kwarg": ("%[0]{pattr}=%c", 1),  # Change when Python 2 does LOAD_STR
-    "kwargs": ("%D", (0, maxint, ", ")),
-    "kwargs1": ("%D", (0, maxint, ", ")),
-
-    "lc_body": ("",),  # ignore when recursing
-    "list_iter": ("%c", 0),
-    "list_for": (" for %c in %c%c", 2, 0, 3),
-    "list_if": (" if %p%c", (0, "expr", 27), 2),
-    "list_if_not": (" if not %p%c", (0, "expr", PRECEDENCE["unary_not"]), 2),
-
-    "mkfuncdeco": ("%|@%c\n%c", (0, "expr"), 1),
-    # A custom rule in n_function def distinguishes whether to call this or
-    # function_def_async
-    "mkfuncdeco0": ("%|def %c\n", (0, ("mkfunc", "mkfunc_annotate"))),
-
-    # In cases where we desire an explicit new line.
-    # After docstrings which are followed by a "def" is
-    # one situations where Python formatting desires two newlines,
-    # and this is added, as a transformation rule.
-    "newline": ("\n"),
-
-    "or": ("%p or %p", (0, PRECEDENCE["or"]), (1, PRECEDENCE["or"])),
-
     "pass": ("%|pass\n",),
 
-    "print_item": (", %c", 0),
-    "print_items_nl_stmt": ("%|print %c%c\n", 0, 2),
-    "print_items_stmt": ("%|print %c%c,\n", 0, 2),  # Python 2 only
-    "print_nl": ("%|print\n",),
-    "print_nl_to": ("%|print >> %c\n", 0),
-    "print_to": ("%|print >> %c, %c,\n", 0, 1),
-    "print_to_items": ("%C", (0, 2, ", ")),
-    "print_to_nl": ("%|print >> %c, %c\n", 0, 1),
-
-    "raise_stmt0": ("%|raise\n",),
-    "raise_stmt1": ("%|raise %c\n", 0),
-    "raise_stmt3": ("%|raise %c, %c, %c\n", 0, 1, 2),
-
-    "ret_and": ("%c and %c", 0, 2),
-    "ret_or": ("%c or %c", 0, 2),
-
-    # Note: we have a custom rule, which calls when we don't
-    # have "return None"
-    "return":	( "%|return %c\n", 0),
-
-    "set_comp_body": ("%c", 0),
-
-    "set_iter":        ( "%c", 0 ),
-
-    "return_if_stmt": ("return %c\n", 0),
-    "slice0": (
-        "%c[:]",
-        (0, "expr"),
-        ),
-    "slice1": (
-        "%c[%p:]",
-        (0, "expr"),
-        (1, NO_PARENTHESIS_EVER)
-        ),
-
-    "slice2": ( "%c[:%p]",
-        (0, "expr"),
-        (1, NO_PARENTHESIS_EVER)
-        ),
-
-    "slice3": (
-        "%c[%p:%p]",
-        (0, "expr"),
-        (1, NO_PARENTHESIS_EVER),
-        (2, NO_PARENTHESIS_EVER)
-        ),
-
-    "store_subscript": (
-        "%p[%c]",
-        (0, "expr", PRECEDENCE["subscript"]), (1, "expr")
-    ),
-
-    # This nonterminal we create on the fly in semantic routines
-    "store_w_parens": (
-        "(%c).%[1]{pattr}",
-        (0, "expr")
-    ),
-
-    # This is only generated by transform
-    # it is a string at the beginning of a function that is *not* a docstring
-    # 3.7 test_fstring.py tests for this kind of crap.
-    # For compatibility with older Python, we'll use "%" instead of
-    # a format string.
-    "string_at_beginning": ('%|"%%s" %% %c\n', 0),
-
-    "subscript": (
-        "%p[%p]",
-        (0, "expr", PRECEDENCE["subscript"]),
-        (1, "expr", NO_PARENTHESIS_EVER)
-    ),
-
-    "subscript2": (
-        "%p[%p]",
-        (0, "expr", PRECEDENCE["subscript"]),
-        (1, "expr", NO_PARENTHESIS_EVER)
-    ),
-
-    "testtrue": ("not %p", (0, PRECEDENCE["unary_not"])),
-
-    # Note: this is generated generated by grammar rules but in this phase.
-    "tf_try_except": ("%c%-%c%+", 1, 3),
-    "tf_tryelsestmt": ("%c%-%c%|else:\n%+%c", 1, 3, 4),
-
-    "try_except": ("%|try:\n%+%c%-%c\n\n", 1, 3),
-    "tryelsestmt": ("%|try:\n%+%c%-%c%|else:\n%+%c%-\n\n", 1, 3, 4),
-    "tryelsestmtc": ("%|try:\n%+%c%-%c%|else:\n%+%c%-", 1, 3, 4),
-    "tryelsestmtl": ("%|try:\n%+%c%-%c%|else:\n%+%c%-", 1, 3, 4),
-    "tryfinallystmt": ("%|try:\n%+%c%-%|finally:\n%+%c%-\n\n", 1, 5),
-
-    # unary_op (formerly "unary_expr") is the Python AST UnaryOp
-    "unary_op": ("%c%c", (1, "unary_operator"), (0, "expr")),
-    "unary_not": ("not %c", (0, "expr")),
-    "unary_convert": ("`%c`", (0, "expr"),),
-
-    "unpack": ("%C%,", (1, maxint, ", ")),
-    "unpack_list": ("[%C]", (1, maxint, ", ")),
-    # This nonterminal we create on the fly in semantic routines
-    "unpack_w_parens": ("(%C%,)", (1, maxint, ", ")),
-
     "whileTruestmt": ("%|while True:\n%+%c%-\n\n", 1),
     "whilestmt": ("%|while %c:\n%+%c%-\n\n", 1, 2),
     "while1stmt": ("%|while 1:\n%+%c%-\n\n", 1),
@@ -559,10 +495,15 @@ TABLE_DIRECT = {
         (3, ("suite_stmts_opt", "suite_stmts")),
     ),
 
-    #    "yield":	        ( "yield %c", 0),
-
+    "try_except": ("%|try:\n%+%c%-%c\n\n", 1, 3),
+    "tryelsestmt": ("%|try:\n%+%c%-%c%|else:\n%+%c%-\n\n", 1, 3, 4),
+    "tryelsestmtc": ("%|try:\n%+%c%-%c%|else:\n%+%c%-", 1, 3, 4),
+    "tryelsestmtl": ("%|try:\n%+%c%-%c%|else:\n%+%c%-", 1, 3, 4),
+    # Note: this is generated generated by grammar rules but in this phase.
+    "tf_try_except": ("%c%-%c%+", 1, 3),
+    "tf_tryelsestmt": ("%c%-%c%|else:\n%+%c", 1, 3, 4),
+    "tryfinallystmt": ("%|try:\n%+%c%-%|finally:\n%+%c%-\n\n", 1, 5),
 }
-# fmt: on
 
 
 MAP_DIRECT = (TABLE_DIRECT,)
@@ -575,7 +516,7 @@ MAP = {
     "store": MAP_R,
 }
 
-ASSIGN_TUPLE_PARAM = lambda param_name: SyntaxTree(  # noqa
+ASSIGN_TUPLE_PARAM = lambda param_name: SyntaxTree(
     "expr", [Token("LOAD_FAST", pattr=param_name)]
 )
 

uncompyle6/semantics/customize.py

@@ -17,15 +17,15 @@
 """
 
 from uncompyle6.parsers.treenode import SyntaxTree
+from uncompyle6.scanners.tok import Token
 from uncompyle6.semantics.consts import (
     INDENT_PER_LEVEL,
     NO_PARENTHESIS_EVER,
     PRECEDENCE,
-    TABLE_R,
     TABLE_DIRECT,
+    TABLE_R,
 )
 from uncompyle6.semantics.helper import flatten_list
-from uncompyle6.scanners.tok import Token
 
 
 def customize_for_version(self, is_pypy, version):
@@ -87,7 +87,7 @@ def customize_for_version(self, is_pypy, version):
                     if line_number != self.line_number:
                         sep += "\n" + self.indent + INDENT_PER_LEVEL[:-1]
                         pass
-                    self.write(f"{sep}{value}")
+                    self.write("%s%s" % (sep, value))
                     sep = ", "
 
                 assert n >= len(kwargs_names)
@@ -101,7 +101,8 @@ def customize_for_version(self, is_pypy, version):
                     if line_number != self.line_number:
                         sep += "\n" + self.indent + INDENT_PER_LEVEL[:-1]
                         pass
-                    self.write(f"{sep}{kwargs_names[i]}={value}")
+                    self.write(sep)
+                    self.write("%s=%s" % (kwargs_names[i], value))
                     sep = ", "
                     pass
 

uncompyle6/semantics/customize25.py

@@ -33,7 +33,6 @@ def customize_for_version25(self, version):
             # Note: It is safe to put the variables after "as" in parenthesis,
             # and sometimes it is needed.
             "with": ("%|with %c:\n%+%c%-", 0, 3),
-            "and_then": ("%c and %c", (0, "expr"), (4, "expr")),
         }
     )
 

uncompyle6/semantics/customize36.py

@@ -1,4 +1,4 @@
-#  Copyright (c) 2019-2024 by Rocky Bernstein
+#  Copyright (c) 2019-2023 by 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
@@ -15,17 +15,16 @@
 """Isolate Python 3.6 version-specific semantic actions here.
 """
 
-from spark_parser.ast import GenericASTTraversalPruningException
 from xdis import iscode
-
+from spark_parser.ast import GenericASTTraversalPruningException
 from uncompyle6.scanners.tok import Token
+from uncompyle6.semantics.helper import flatten_list, escape_string, strip_quotes
 from uncompyle6.semantics.consts import (
     INDENT_PER_LEVEL,
     PRECEDENCE,
     TABLE_DIRECT,
     TABLE_R,
 )
-from uncompyle6.semantics.helper import escape_string, flatten_list, strip_quotes
 from uncompyle6.util import get_code_name
 
 
@@ -39,6 +38,7 @@ def escape_format(s):
 
 
 def customize_for_version36(self, version):
+
     # fmt: off
     PRECEDENCE["call_kw"]          =   0
     PRECEDENCE["call_kw36"]        =   1
@@ -276,7 +276,7 @@ def customize_for_version36(self, version):
         if value == "":
             fmt = "%c(%p)"
         else:
-            fmt = "%c" + ("(%s, " % value).replace("%", "%%") + "%p)"
+            fmt = "%%c(%s, %%p)" % value
 
         self.template_engine(
             (fmt, (0, "expr"), (2, "build_map_unpack_with_call", 100)), node
@@ -295,7 +295,7 @@ def customize_for_version36(self, version):
         if value == "":
             fmt = "%c(%p)"
         else:
-            fmt = "%c" + ("(%s, " % value).replace("%", "%%") + "%p)"
+            fmt = "%%c(%s, %%p)" % value
 
         self.template_engine(
             (fmt, (0, "expr"), (2, "build_map_unpack_with_call", 100)), node
@@ -707,7 +707,6 @@ def customize_for_version36(self, version):
             self.comprehension_walk_newer(node, iter_index=3, code_index=0)
         self.write("]")
         self.prune()
-
     self.n_list_comp_async = n_list_comp_async
 
     # def kwargs_only_36(node):

uncompyle6/semantics/customize37.py

@@ -20,7 +20,6 @@ import re
 from uncompyle6.semantics.consts import INDENT_PER_LEVEL, PRECEDENCE, TABLE_DIRECT
 from uncompyle6.semantics.helper import flatten_list
 
-# FIXME get from a newer xdis
 FSTRING_CONVERSION_MAP = {1: "!s", 2: "!r", 3: "!a", "X": ":X"}
 
 

uncompyle6/semantics/customize38.py

@@ -144,7 +144,7 @@ def customize_for_version38(self, version):
             "whilestmt38": (
                 "%|while %c:\n%+%c%-\n\n",
                 (1, ("bool_op", "testexpr", "testexprc")),
-                (2, ("_stmts", "l_stmts", "l_stmts_opt", "pass")),
+                (2, ("l_stmts", "l_stmts_opt", "pass")),
             ),
             "whileTruestmt38": (
                 "%|while True:\n%+%c%-\n\n",
@@ -339,7 +339,9 @@ def customize_for_version38(self, version):
             f_conversion = self.traverse(formatted_value, indent="")
             # Remove leaving "f" and quotes
             conversion = strip_quotes(f_conversion[1:])
-            f_str = "f%s" % escape_string(f"{value_equal}{conversion}" + post_str)
+            f_str = "f%s" % escape_string(
+                ("%s%s" % (value_equal, conversion)) + post_str
+            )
 
         self.write(f_str)
         self.in_format_string = old_in_format_string

uncompyle6/semantics/fragments.py

@@ -66,7 +66,6 @@ The node position 0 will be associated with "import".
 import re
 from bisect import bisect_right
 from collections import namedtuple
-from typing import Optional
 
 from spark_parser import DEFAULT_DEBUG as PARSER_DEFAULT_DEBUG
 from spark_parser.ast import GenericASTTraversalPruningException
@@ -1476,7 +1475,7 @@ class FragmentsWalker(pysource.SourceWalker, object):
         # as a custom rule
         start = len(self.f.getvalue())
         n = len(node) - 1
-        j = 0
+
         if node.kind != "expr":
             if node == "kwarg":
                 self.template_engine(("(%[0]{attr}=%c)", 1), node)
@@ -1520,9 +1519,9 @@ class FragmentsWalker(pysource.SourceWalker, object):
             self.write("(")
             if kwargs:
                 # Last arg is tuple of keyword values: omit
-                m = n - 1
+                l = n - 1
             else:
-                m = n
+                l = n
 
             if kwargs:
                 # 3.6+ does this
@@ -1534,7 +1533,7 @@ class FragmentsWalker(pysource.SourceWalker, object):
                     j += 1
 
                 j = 0
-                while i < m:
+                while i < l:
                     self.write(sep)
                     value = self.traverse(node[i])
                     self.write("%s=%s" % (kwargs[j], value))
@@ -1542,7 +1541,7 @@ class FragmentsWalker(pysource.SourceWalker, object):
                     j += 1
                     i += 1
             else:
-                while i < m:
+                while i < l:
                     value = self.traverse(node[i])
                     i += 1
                     self.write(sep, value)
@@ -1794,12 +1793,12 @@ class FragmentsWalker(pysource.SourceWalker, object):
 
     def template_engine(self, entry, startnode):
         """The format template interpretation engine.  See the comment at the
-        beginning of this module for how we interpret format
+        beginning of this module for the how we interpret format
         specifications such as %c, %C, and so on.
         """
 
         # print("-----")
-        # print(startnode.kind)
+        # print(startnode)
         # print(entry[0])
         # print('======')
 
@@ -1854,27 +1853,14 @@ class FragmentsWalker(pysource.SourceWalker, object):
 
                 index = entry[arg]
                 if isinstance(index, tuple):
-                    if isinstance(index[1], str):
-                        # if node[index[0]] != index[1]:
-                        #     from trepan.api import debug; debug()
-                        assert (
-                            node[index[0]] == index[1]
-                        ), "at %s[%d], expected '%s' node; got '%s'" % (
-                            node.kind,
-                            arg,
-                            index[1],
-                            node[index[0]].kind,
-                        )
-                    else:
-                        assert (
-                            node[index[0]] in index[1]
-                        ), "at %s[%d], expected to be in '%s' node; got '%s'" % (
-                            node.kind,
-                            arg,
-                            index[1],
-                            node[index[0]].kind,
-                        )
-
+                    assert (
+                        node[index[0]] == index[1]
+                    ), "at %s[%d], expected %s node; got %s" % (
+                        node.kind,
+                        arg,
+                        node[index[0]].kind,
+                        index[1],
+                    )
                     index = index[0]
                 assert isinstance(
                     index, int
@@ -1894,21 +1880,14 @@ class FragmentsWalker(pysource.SourceWalker, object):
                 assert isinstance(tup, tuple)
                 if len(tup) == 3:
                     (index, nonterm_name, self.prec) = tup
-                    if isinstance(tup[1], str):
-                        assert (
-                            node[index] == nonterm_name
-                        ), "at %s[%d], expected '%s' node; got '%s'" % (
-                            node.kind,
-                            arg,
-                            nonterm_name,
-                            node[index].kind,
-                        )
-                    else:
-                        assert node[tup[0]] in tup[1], (
-                            f"at {node.kind}[{tup[0]}], expected to be in '{tup[1]}' "
-                            f"node; got '{node[tup[0]].kind}'"
-                        )
-
+                    assert (
+                        node[index] == nonterm_name
+                    ), "at %s[%d], expected '%s' node; got '%s'" % (
+                        node.kind,
+                        arg,
+                        nonterm_name,
+                        node[index].kind,
+                    )
                 else:
                     assert len(tup) == 2
                     (index, self.prec) = entry[arg]
@@ -2119,7 +2098,6 @@ def code_deparse(
     # Build Syntax Tree from tokenized and massaged disassembly.
     # deparsed = pysource.FragmentsWalker(out, scanner, showast=showast)
     show_tree = debug_opts.get("tree", False)
-    linestarts = dict(scanner.opc.findlinestarts(co))
     deparsed = walker(
         version,
         scanner,
@@ -2191,7 +2169,7 @@ def code_deparse_around_offset(
     offset,
     co,
     out=StringIO(),
-    version: Optional[tuple] = None,
+    version=None,
     is_pypy: bool = False,
     debug_opts=DEFAULT_DEBUG_OPTS,
 ):
@@ -2339,7 +2317,7 @@ def deparsed_find(tup, deparsed, code):
 #     def test():
 #         import os, sys
 
-#     def get_dups(li: list) -> set:
+#     def get_dups(li: list):
 #         dups = {}
 #         for item in li:
 #             dups[item] = dups.get(item, -1) + 1

uncompyle6/semantics/gencomp.py

@@ -17,8 +17,6 @@ Generators and comprehension functions
 """
 
 
-from typing import Optional
-
 from xdis import co_flags_is_async, iscode
 
 from uncompyle6.parser import get_python_parser
@@ -101,10 +99,10 @@ class ComprehensionMixin:
     def comprehension_walk(
         self,
         node,
-        iter_index: Optional[int],
-        code_index: int = -5,
+        iter_index,
+        code_index=-5,
     ):
-        p: int = self.prec
+        p = self.prec
         self.prec = PRECEDENCE["lambda_body"] - 1
 
         # FIXME: clean this up
@@ -225,8 +223,8 @@ class ComprehensionMixin:
     def comprehension_walk_newer(
         self,
         node,
-        iter_index: Optional[int],
-        code_index: int = -5,
+        iter_index,
+        code_index=-5,
         collection_node=None,
     ):
         """Non-closure-based comprehensions the way they are done in Python3
@@ -547,7 +545,7 @@ class ComprehensionMixin:
             pass
         self.prec = p
 
-    def get_comprehension_function(self, node, code_index: int):
+    def get_comprehension_function(self, node, code_index):
         """
         Build the body of a comprehension function and then
         find the comprehension node buried in the tree which may

uncompyle6/semantics/linemap.py

@@ -108,4 +108,4 @@ if __name__ == "__main__":
         # assert linemap == linemap2
         return
 
-    deparse_test(deparse_test.func_code)
+    deparse_test(deparse_test.__code__)

uncompyle6/semantics/make_function1.py

@@ -17,17 +17,18 @@
 All the crazy things we have to do to handle Python functions in Python before 3.0.
 The saga of changes continues in 3.0 and above and in other files.
 """
-from typing import List, Tuple
-from uncompyle6.scanner import Code
-from uncompyle6.semantics.parser_error import ParserError
+from xdis import iscode
+
 from uncompyle6.parser import ParserError as ParserError2
+from uncompyle6.scanner import Code
 from uncompyle6.semantics.helper import (
-    print_docstring,
     find_all_globals,
     find_globals_and_nonlocals,
     find_none,
+    print_docstring,
 )
-from xdis import iscode
+from uncompyle6.semantics.parser_error import ParserError
+
 
 def make_function1(self, node, is_lambda, nested=1, code_node=None):
     """
@@ -35,10 +36,10 @@ def make_function1(self, node, is_lambda, nested=1, code_node=None):
     This code is specialied for Python 2.
     """
 
-    def build_param(tree, param_names: List[str]) -> Tuple[bool, List[str]]:
+    def build_param(tree, param_names: list) -> tuple:
         """build parameters:
-            - handle defaults
-            - handle format tuple parameters
+        - handle defaults
+        - handle format tuple parameters
         """
         # if formal parameter is a tuple, the parameter name
         # starts with a dot (eg. '.1', '.2')
@@ -187,5 +188,5 @@ def make_function1(self, node, is_lambda, nested=1, code_node=None):
         tree, code.co_name, code._customize, is_lambda=is_lambda, returnNone=rn
     )
 
-    code._tokens = None # save memory
+    code._tokens = None  # save memory
     code._customize = None  # save memory

uncompyle6/semantics/make_function2.py

@@ -22,7 +22,6 @@ from itertools import zip_longest
 
 from xdis import code_has_star_arg, code_has_star_star_arg, iscode
 
-from uncompyle6.parser import ParserError as ParserError2
 from uncompyle6.scanner import Code
 from uncompyle6.semantics.helper import (
     find_all_globals,