pyp: drop support for python 3.8

Author: hauntsaninja

.github/workflows/tests.yml

@@ -26,7 +26,6 @@ jobs:
       fail-fast: false
       matrix:
         include:
-          - {python: '3.8', tox: py38}
           - {python: '3.9', tox: py39}
           - {python: '3.10', tox: py310}
           - {python: '3.11', tox: py311}

FAQ.md

@@ -64,15 +64,6 @@ ff = defaultdict(lambda: None, dict(enumerate(x.split())))
 d = defaultdict(list)
 ```
 
-#### What are pyp's dependencies?
-
-If run on Python 3.9 or later, pyp has no dependencies.
-
-On earlier Python versions, pyp is dependent on [astunparse](https://github.com/simonpercivall/astunparse)
-for `--explain`/`--script` to work as promised. Note you can use `pyp.py` as a Python script without
-installing `astunparse` and everything else will work. (In fact `--script` will still output a
-script that does what you want it to, but it won't be particularly readable...)
-
 #### Can I customise the shebang on the output of `--script`?
 
 Yes! Just add the shebang you want to your [config file](https://github.com/hauntsaninja/pyp#pyp-is-configurable).
@@ -81,10 +72,7 @@ of `--explain`/`--script`.
 
 #### The output of `--explain` is a little weirdly formatted
 
-Try running with Python 3.9 or later! The AST unparser that the standard library includes in 3.9
-and later fixes a lot of formatting nits that are present in third party AST unparsers.
-
-You can also pipe the output of `pyp --explain` to an autoformatter like [black](https://github.com/psf/black):
+You can pipe the output of `pyp --explain` to an autoformatter like [black](https://github.com/psf/black):
 
 ```
 $ pyp --explain x | black --quiet -
@@ -144,4 +132,4 @@ Benchmark #1: seq 1 999999 | pyp 'sum(map(int, lines))'
 You should be able to use PyPy! Tests currently pass against PyPy (run `tox -e pypy3`).
 You can install pyp using PyPy with something like `pypy3 -m pip install pypyp`.
 Running `pyp sys.version` will tell you whether it worked. Note that pyp requires at least
-Python 3.8; this constraint naturally applies when using PyPy as well.
+Python 3.9; this constraint naturally applies when using PyPy as well.

README.md

@@ -16,7 +16,7 @@ You can also install pyp in other ways:
 - [nixpkgs](https://search.nixos.org/packages?channel=unstable&show=pyp)
 - [AUR](https://aur.archlinux.org/packages/pyp)
 
-pyp requires Python 3.8 or above.
+pyp requires Python 3.9 or above.
 
 ## How it works
 

pyp.py

@@ -600,43 +600,12 @@ def build(self) -> ast.Module:
         return ast.fix_missing_locations(ret)
 
 
-def unparse(tree: ast.AST, short_fallback: bool = False) -> str:
-    """Returns Python code equivalent to executing ``tree``."""
-    if sys.version_info >= (3, 9):
-        return ast.unparse(tree)
-    try:
-        import astunparse  # type: ignore
-
-        return cast(str, astunparse.unparse(tree))
-    except ImportError:
-        pass
-    return (
-        fallback_unparse(tree)
-        if not short_fallback
-        else f"# {ast.dump(tree)}  # --explain has instructions to make this readable"
-    )
-
-
-def fallback_unparse(tree: ast.AST) -> str:
-    return f"""
-from ast import *
-tree = fix_missing_locations({ast.dump(tree)})
-
-# To see this in human readable form, run pyp with Python 3.9
-# Alternatively, install a third party ast unparser: `python3 -m pip install astunparse`
-# Once you've done that, simply re-run.
-# In the meantime, this script is fully functional, if not easily readable or modifiable...
-
-exec(compile(tree, filename="<ast>", mode="exec"), {{}})
-"""
-
-
 def run_pyp(args: argparse.Namespace) -> None:
     config = PypConfig()
     tree = PypTransform(args.before, args.code, args.after, args.define_pypprint, config).build()
     if args.explain:
         print(config.shebang)
-        print(unparse(tree))
+        print(ast.unparse(tree))
         return
     try:
         exec(compile(tree, filename="<pyp>", mode="exec"), {})
@@ -654,7 +623,7 @@ def code_for_line(lineno: int) -> str:
                 for _, value in ast.iter_fields(node):
                     if isinstance(value, list) and value and isinstance(value[0], ast.stmt):
                         value.clear()
-                return unparse(node, short_fallback=True).strip()
+                return ast.unparse(node).strip()
 
             # Time to commit several sins against CPython implementation details
             tb_except = traceback.TracebackException(

pyproject.toml

@@ -14,8 +14,8 @@ classifiers = [
     "Topic :: Software Development",
     "Topic :: Utilities",
 ]
-requires-python = ">=3.8"
-dependencies = ["astunparse; python_version<'3.9'"]
+requires-python = ">=3.9"
+dependencies = []
 
 [project.scripts]
 pyp = "pyp:main"

tests/test_find_names.py

@@ -146,18 +146,17 @@ def test_walrus():
     check_find_names("{(x := y): (y := 1) for _ in range(5)}", {"x", "y"}, {"y", "range"})
     check_find_names("{(x := 1): (y := x) for _ in range(5)}", {"x", "y"}, {"range"})
 
-    if sys.version_info >= (3, 9):
-        check_find_names(
-            "d1 = lambda i: i\n@(d2 := d1)\n@(d3 := d2)\ndef f(): ...",
-            {"d1", "d2", "d3", "f"},
-            set(),
-        )
-        check_find_names(
-            "d1 = id\n@(d3 := d2)\n@(d2 := d1)\ndef f(): ...", {"d1", "d2", "d3", "f"}, {"d2", "id"}
-        )
-        check_find_names(
-            "d1 = lambda i: i\n@(d2 := d1)\ndef f(x=d2): (x, d2)", {"d1", "d2", "f"}, set()
-        )
+    check_find_names(
+        "d1 = lambda i: i\n@(d2 := d1)\n@(d3 := d2)\ndef f(): ...",
+        {"d1", "d2", "d3", "f"},
+        set(),
+    )
+    check_find_names(
+        "d1 = id\n@(d3 := d2)\n@(d2 := d1)\ndef f(): ...", {"d1", "d2", "d3", "f"}, {"d2", "id"}
+    )
+    check_find_names(
+        "d1 = lambda i: i\n@(d2 := d1)\ndef f(x=d2): (x, d2)", {"d1", "d2", "f"}, set()
+    )
 
 
 def test_comprehensions():

tests/test_pyp.py

@@ -68,12 +68,7 @@ def compare_scripts(explain_output: str, script: str) -> None:
     """Tests whether two scripts are equivalent."""
     explain_output = explain_output.strip("\n")
     script = script.strip("\n")
-    if sys.version_info < (3, 9):
-        # astunparse seems to parenthesise things slightly differently, so filter through ast to
-        # hackily ensure that the scripts are the same.
-        assert pyp.unparse(ast.parse(explain_output)) == pyp.unparse(ast.parse(script))
-    else:
-        assert explain_output == script
+    assert explain_output == script
 
 
 # ====================