It's 2025; use Ruff.

Author: psobot

.github/workflows/python-package.yml

@@ -1,7 +1,7 @@
 # This workflow will install Python dependencies, run tests and lint with a variety of Python versions
 # For more information see: https://help.github.com/actions/language-and-framework-guides/using-python-with-github-actions
 
-name: PyTest & Flake8
+name: PyTest & Ruff
 
 on:
   push:
@@ -16,7 +16,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: [3.7, 3.8, 3.9, "3.10", "3.11"]
+        python-version: ["3.9", "3.10", "3.11", "3.12", "3.13"]
     steps:
     - uses: actions/checkout@v2
     - name: Set up Python ${{ matrix.python-version }}
@@ -32,19 +32,13 @@ jobs:
         echo "::set-env name=PATH::$PATH:$PWD/protoc/bin/"
         sudo apt-get install -qq libsnappy-dev
         python -m pip install --upgrade pip
-        pip install flake8 pytest
+        pip install ruff pytest
         pip install -r requirements.txt
       env:
         ACTIONS_ALLOW_UNSECURE_COMMANDS: 'true'
     - name: Build package
       run: make
-    - name: Lint with flake8
-      run: |
-        # stop the build if there are Python syntax errors or undefined names
-        flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics --exclude keynote_parser/generated
-        # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide
-        flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics --exclude keynote_parser/generated
+    - name: Lint with ruff
+      run: ruff check . --exclude keynote_parser/generated
     - name: Test with pytest
-      run: |
-        export PYTHONPATH=$PYTHONPATH:$(pwd)
-        pytest --cov=keynote_parser
+      run: PYTHONPATH=$PYTHONPATH:$(pwd) pytest --cov=keynote_parser

Makefile

@@ -19,8 +19,7 @@ keynote_parser/generated/%_pb2.py: protos/%.proto keynote_parser/generated
 
 keynote_parser/generated/__init__.py: keynote_parser/generated $(PROTO_CLASSES)
 	touch $@
-	# Huge hack for py3 support, see https://github.com/protocolbuffers/protobuf/issues/1491
-	futurize --no-diffs --nobackups --both-stages --processes 4 -w keynote_parser/generated/
+	python3 dumper/rewrite_imports.py keynote_parser/generated/*.py
 
 clean:
 	rm -rf keynote_parser/generated

dumper/protodump.py

@@ -249,7 +249,7 @@ def extract_proto_from_file(filename, descriptor_pool):
 
         try:
             name_length, new_pos = _DecodeVarint(data, marker_start)
-        except Exception as e:
+        except Exception:
             # Expected a VarInt here, so if not, continue
             offset = suffix_position + len(PROTO_MARKER)
             continue
@@ -279,7 +279,7 @@ def extract_proto_from_file(filename, descriptor_pool):
                 and proto_file.path != "google/protobuf/descriptor.proto"
             ):
                 yield proto_file
-        except Exception as e:
+        except Exception:
             pass
 
         offset = marker_start + descriptor_length

dumper/rewrite_imports.py

@@ -0,0 +1,22 @@
+import argparse
+import re
+
+REGEX = re.compile(r"^import (.*_pb2) as (.*__pb2)$")
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("files", nargs="+")
+    args = parser.parse_args()
+
+    for file in args.files:
+        with open(file, "r") as f:
+            content = f.read()
+        content = REGEX.sub(r"import keynote_parser.generated.\1 as \2", content)
+        with open(file, "w") as f:
+            f.write(content)
+        print(f"Rewrote {file}.")
+
+
+if __name__ == "__main__":
+    main()

keynote_parser/__init__.py

@@ -22,4 +22,3 @@
 __description__ = "A tool for manipulating Apple Keynote presentation files."
 __url__ = "https://github.com/psobot/keynote-parser"
 __new_issue_url__ = "https://github.com/psobot/keynote-parser/issues/new"
-__command_line_invocation__ = False

keynote_parser/bundle_utils.py

@@ -1,42 +1,46 @@
+import inspect
 import os
-import sys
-import warnings
 import plistlib
+import sys
 import urllib.parse
-from colorama import init as colorama_init
+import warnings
+
 from colorama import Fore
+from colorama import init as colorama_init
+
 from keynote_parser import (
-    __version__,
-    __supported_keynote_version__,
     __new_issue_url__,
-    __command_line_invocation__,
+    __supported_keynote_version__,
+    __version__,
 )
 from keynote_parser.macos_app_version import MacOSAppVersion
 
-DEFAULT_KEYNOTE_INSTALL_PATH = '/Applications/Keynote.app'
-VERSION_PLIST_PATH = 'Contents/version.plist'
+DEFAULT_KEYNOTE_INSTALL_PATH = "/Applications/Keynote.app"
+VERSION_PLIST_PATH = "Contents/version.plist"
 
 
 colorama_init()
 
 
 def get_installed_keynote_version():
     try:
-        fp = open(os.path.join(DEFAULT_KEYNOTE_INSTALL_PATH, VERSION_PLIST_PATH), 'rb')
+        fp = open(os.path.join(DEFAULT_KEYNOTE_INSTALL_PATH, VERSION_PLIST_PATH), "rb")
     except IOError:
         return None
     version_dict = plistlib.load(fp)
     return MacOSAppVersion(
-        version_dict['CFBundleShortVersionString'],
-        version_dict['CFBundleVersion'],
-        version_dict['ProductBuildVersion'],
+        version_dict["CFBundleShortVersionString"],
+        version_dict["CFBundleVersion"],
+        version_dict["ProductBuildVersion"],
     )
 
 
 class KeynoteVersionWarning(UserWarning):
     def __init__(self, installed_keynote_version):
         issue_title = "Please add support for Keynote %s" % installed_keynote_version
-        new_issue_url = __new_issue_url__ + "?" + urllib.parse.urlencode({"title": issue_title})
+        new_issue_url = (
+            __new_issue_url__ + "?" + urllib.parse.urlencode({"title": issue_title})
+        )
         super(UserWarning, self).__init__(
             (
                 "KeynoteVersionWarning: "
@@ -97,7 +101,9 @@ def warn_once_on_newer_keynote(installed_keynote_version=None):
     if DID_WARN:
         return False
 
-    installed_keynote_version = installed_keynote_version or get_installed_keynote_version()
+    installed_keynote_version = (
+        installed_keynote_version or get_installed_keynote_version()
+    )
     if not installed_keynote_version:
         return False
 
@@ -113,5 +119,9 @@ def warn_once_on_newer_keynote(installed_keynote_version=None):
     return DID_WARN
 
 
-if not __command_line_invocation__ and "pytest" not in sys.modules:
+IS_INVOKED_ON_COMMAND_LINE = any(
+    frame.function == "__main__" for frame in inspect.stack()
+)
+
+if not IS_INVOKED_ON_COMMAND_LINE and "pytest" not in sys.modules:
     warn_once_on_newer_keynote()

keynote_parser/command_line.py

@@ -1,66 +1,73 @@
-from __future__ import print_function
-from __future__ import absolute_import
-import argparse
+from __future__ import absolute_import, print_function
 
-import keynote_parser
+import argparse
+from collections import Counter
 
-keynote_parser.__command_line_invocation__ = True  # noqa
+from keynote_parser import __supported_keynote_version__, __version__
 
-from keynote_parser import __version__, __supported_keynote_version__
-from collections import Counter
-from .bundle_utils import warn_once_on_newer_keynote, get_installed_keynote_version
+from .bundle_utils import get_installed_keynote_version, warn_once_on_newer_keynote
 from .file_utils import process
 from .replacement import Replacement, parse_json
 
 
 def parse_replacements(**kwargs):
-    json_filename = kwargs.get('replacements')
+    json_filename = kwargs.get("replacements")
     if json_filename:
         return parse_json(json_filename)
     else:
         return []
 
 
 def unpack_command(input, output=None, **kwargs):
-    process(input, output or input.replace('.key', ''), replacements=parse_replacements(**kwargs))
+    process(
+        input,
+        output or input.replace(".key", ""),
+        replacements=parse_replacements(**kwargs),
+    )
 
 
 def pack_command(input, output=None, **kwargs):
-    process(input, output or (input + ".key"), replacements=parse_replacements(**kwargs))
+    process(
+        input, output or (input + ".key"), replacements=parse_replacements(**kwargs)
+    )
 
 
 def ls_command(input, **kwargs):
-    process(input, '-')
+    process(input, "-")
 
 
 def cat_command(input, filename, **kwargs):
     process(
         input,
-        '-',
+        "-",
         subfile=filename,
         replacements=parse_replacements(**kwargs),
-        raw=kwargs.get('raw'),
+        raw=kwargs.get("raw"),
     )
 
 
 def replace_command(input, **kwargs):
-    output = kwargs.get('output', None) or input
+    output = kwargs.get("output", None) or input
     replacements = parse_replacements(**kwargs)
-    find, _replace = kwargs.get('find'), kwargs.get('replace')
+    find, _replace = kwargs.get("find"), kwargs.get("replace")
     if find and _replace:
         replacements.append(Replacement(find, _replace))
     if not replacements:
         print("WARNING: No replacements passed. No change.")
         return
-    for ((old, new), count) in list(Counter(process(input, output, replacements)).items()):
+    for (old, new), count in list(
+        Counter(process(input, output, replacements)).items()
+    ):
         if count == 1:
             print("Replaced %s with %s." % (repr(old), repr(new)))
         else:
             print("Replaced %s with %s %d times." % (repr(old), repr(new), count))
 
 
 def add_replacement_arg(parser):
-    parser.add_argument("--replacements", help="apply replacements from a json or yaml file")
+    parser.add_argument(
+        "--replacements", help="apply replacements from a json or yaml file"
+    )
 
 
 def main():
@@ -76,38 +83,42 @@ def main():
         )
         % (__version__, __supported_keynote_version__, install_warning)
     )
-    parser.add_argument('-v', '--version', action='version', version=__version__)
+    parser.add_argument("-v", "--version", action="version", version=__version__)
 
     subparsers = parser.add_subparsers()
 
-    parser_unpack = subparsers.add_parser('unpack')
+    parser_unpack = subparsers.add_parser("unpack")
     parser_unpack.add_argument("input", help="a .key file")
     parser_unpack.add_argument("--output", "-o", help="a directory name to unpack into")
     add_replacement_arg(parser_unpack)
     parser_unpack.set_defaults(func=unpack_command)
 
-    parser_pack = subparsers.add_parser('pack')
+    parser_pack = subparsers.add_parser("pack")
     parser_pack.add_argument("input", help="a directory of an unpacked .key file")
-    parser_pack.add_argument("--output", "-o", help="a keynote file name to unpack into")
+    parser_pack.add_argument(
+        "--output", "-o", help="a keynote file name to unpack into"
+    )
     add_replacement_arg(parser_pack)
     parser_pack.set_defaults(func=pack_command)
 
-    parser_ls = subparsers.add_parser('ls')
+    parser_ls = subparsers.add_parser("ls")
     parser_ls.add_argument("input", help="a .key file")
     parser_ls.set_defaults(func=ls_command)
 
-    parser_cat = subparsers.add_parser('cat')
+    parser_cat = subparsers.add_parser("cat")
     parser_cat.add_argument("input", help="a .key file")
     parser_cat.add_argument(
         "filename", help="a file within that .key file to cat, decoding .iwa to .yaml"
     )
     parser_cat.add_argument(
-        "--raw", action='store_true', help="always return the original file with no decoding"
+        "--raw",
+        action="store_true",
+        help="always return the original file with no decoding",
     )
     add_replacement_arg(parser_cat)
     parser_cat.set_defaults(func=cat_command)
 
-    parser_replace = subparsers.add_parser('replace')
+    parser_replace = subparsers.add_parser("replace")
     parser_replace.add_argument("input", help="a .key file")
     parser_replace.add_argument("--output", "-o", help="a .key file to output to")
     parser_replace.add_argument("--find", help="a pattern to search for in text")
@@ -116,7 +127,7 @@ def main():
     parser_replace.set_defaults(func=replace_command)
 
     args = parser.parse_args()
-    if hasattr(args, 'func'):
+    if hasattr(args, "func"):
         warn_once_on_newer_keynote()
         args.func(**vars(args))
     else:

tests/test_bundle_utils.py

@@ -1,4 +1,6 @@
 # -*- coding: utf-8 -*-
+import warnings
+
 import pytest
 
 from keynote_parser import bundle_utils
@@ -10,6 +12,8 @@ def test_warn_on_old_version(capsys):
     with pytest.warns(bundle_utils.KeynoteVersionWarning):
         bundle_utils.warn_once_on_newer_keynote(installed_keynote_version=dummy_version)
 
-    # Second call/import should not warn
-    with pytest.warns(None):
+    # Second call/import should not warn:
+    with warnings.catch_warnings():
+        warnings.simplefilter("error")
+
         bundle_utils.warn_once_on_newer_keynote(installed_keynote_version=dummy_version)