Merge pull request #51 from kurtmckee/py3.14

Support Python 3.14

Author: kurtmckee

README.rst

@@ -29,15 +29,16 @@ There are three steps required to start using static compression:
 -----------------------------
 
 At minimum, you'll need to install the pelican_precompress plugin.
-It will automatically generate gzip files because gzip is built into the
-Python standard library.
+It will automatically generate gzip files on all versions of Python,
+and zstandard files on Python 3.14 and higher,
+because those compression algorithms are built into the Python standard library.
 
 However, if you want better compression you'll need to install additional packages.
 pelican_precompress exposes each compression algorithm by name as a package extra:
 
 *   ``brotli``
 *   ``zopfli``
-*   ``zstandard``
+*   ``zstandard`` (for Python 3.13 and lower)
 
 These can be selected as a comma-separated list during install:
 
@@ -138,11 +139,12 @@ You set them in your Pelican configuration file.
     If you set this to ``True`` when the brotli module isn't installed
     then nothing will happen.
 
-*   ``PRECOMPRESS_ZSTANDARD`` (bool, default is True if pyzstd is installed)
+*   ``PRECOMPRESS_ZSTANDARD`` (bool, default is True if zstandard is available)
 
-    If the pyzstd module is installed this will default to ``True``.
+    When running on Python 3.14 or higher with zstandard support compiled in,
+    or if the pyzstd module is installed, this will default to ``True``.
     You might set this to ``False`` during development.
-    If you set this to ``True`` when the pyzstd module isn't installed
+    If you set this to ``True`` when the zstandard compression isn't available
     then nothing will happen.
 
 *   ``PRECOMPRESS_ZOPFLI`` (bool, default is True if zopfli is installed)

changelog.d/20250521_172903_kurtmckee_py3_14.rst

@@ -0,0 +1,12 @@
+Python support
+--------------
+
+*   Support Python 3.14.
+
+Changed
+-------
+
+*   zstandard support now uses ``compression.zstd`` on Python 3.14 and higher.
+
+    This means that zstandard is now enabled by default on Python 3.14 and higher.
+    ``pyzstd`` is still needed for Python 3.13 and lower.

pyproject.toml

@@ -30,7 +30,7 @@ dependencies = [
 [project.optional-dependencies]
 brotli = ["brotli"]
 zopfli = ["zopfli"]
-zstandard = ["pyzstd"]
+zstandard = ["pyzstd; python_version<'3.14'"]
 
 [project.urls]
 Source = "https://github.com/kurtmckee/pelican-precompress"

src/pelican/plugins/precompress/__init__.py

@@ -5,7 +5,6 @@
 from __future__ import annotations
 
 import functools
-import gzip
 import logging
 import multiprocessing
 import pathlib
@@ -15,6 +14,8 @@
 import blinker
 import pelican.plugins.granular_signals
 
+from .compat import compression
+
 log = logging.getLogger(__name__)
 
 # brotli support is optional.
@@ -32,13 +33,6 @@
     log.debug("Note: pelican_precompress only targets zopfli, not zopflipy.")
     zopfli = None
 
-# zstandard support is optional.
-try:
-    import pyzstd
-except ModuleNotFoundError:
-    log.debug("pyzstd is not installed.")
-    pyzstd = None
-
 
 DEFAULT_TEXT_EXTENSIONS: set[str] = {
     ".atom",
@@ -77,7 +71,7 @@ def get_settings(instance) -> dict[str, bool | pathlib.Path | set[str]]:
         "PRECOMPRESS_GZIP": instance.settings.get("PRECOMPRESS_GZIP", True),
         "PRECOMPRESS_ZOPFLI": instance.settings.get("PRECOMPRESS_ZOPFLI", bool(zopfli)),
         "PRECOMPRESS_ZSTANDARD": instance.settings.get(
-            "PRECOMPRESS_ZSTANDARD", bool(pyzstd)
+            "PRECOMPRESS_ZSTANDARD", bool(compression.zstd)
         ),
         "PRECOMPRESS_OVERWRITE": instance.settings.get("PRECOMPRESS_OVERWRITE", False),
         "PRECOMPRESS_MIN_SIZE": instance.settings.get("PRECOMPRESS_MIN_SIZE", 20),
@@ -103,7 +97,7 @@ def get_settings(instance) -> dict[str, bool | pathlib.Path | set[str]]:
         settings["PRECOMPRESS_GZIP"] = False
 
     # If zstandard is enabled, it must be installed.
-    if settings["PRECOMPRESS_ZSTANDARD"] and not pyzstd:
+    if settings["PRECOMPRESS_ZSTANDARD"] and not compression.zstd:
         log.error("Disabling zstandard pre-compression because it is not installed.")
         settings["PRECOMPRESS_ZSTANDARD"] = False
 
@@ -248,7 +242,7 @@ def decompress_with_gzip(path: pathlib.Path) -> bytes | None:
     """Decompress a file using gzip decompression."""
 
     try:
-        return gzip.decompress(path.read_bytes())
+        return compression.gzip.decompress(path.read_bytes())
     except OSError:
         return None
 
@@ -257,7 +251,7 @@ def decompress_with_gzip(path: pathlib.Path) -> bytes | None:
 def compress_with_gzip(data: bytes) -> bytes:
     """Compress binary data using gzip compression."""
 
-    compressor = zlib.compressobj(level=9, wbits=16 + zlib.MAX_WBITS)
+    compressor = compression.zlib.compressobj(level=9, wbits=16 + zlib.MAX_WBITS)
     return compressor.compress(data) + compressor.flush()
 
 
@@ -272,16 +266,16 @@ def decompress_with_zstandard(path: pathlib.Path) -> bytes | None:
     """Decompress a file using zstandard decompression."""
 
     try:
-        return pyzstd.decompress(path.read_bytes())
-    except pyzstd.ZstdError:
+        return compression.zstd.decompress(path.read_bytes())
+    except compression.zstd.ZstdError:
         return None
 
 
 @validate_file_sizes
 def compress_with_zstandard(data: bytes) -> bytes:
     """Compress binary data using zstandard compression."""
 
-    return pyzstd.compress(data)
+    return compression.zstd.compress(data)
 
 
 def register():

src/pelican/plugins/precompress/compat.py

@@ -0,0 +1,32 @@
+# This file is part of the pelican-precompress plugin.
+# Copyright 2019-2025 Kurt McKee <[email protected]>
+# Released under the MIT license.
+
+from __future__ import annotations
+
+import logging
+import types
+
+log = logging.getLogger(__name__)
+
+compression: types.SimpleNamespace | types.ModuleType
+
+try:
+    import compression.gzip
+    import compression.zlib
+    import compression.zstd
+except ModuleNotFoundError:
+    import gzip
+    import zlib
+
+    # zstandard support is optional.
+    try:
+        import pyzstd
+    except ModuleNotFoundError:
+        log.debug("pyzstd is not installed.")
+        pyzstd = None
+
+    compression = types.SimpleNamespace()
+    compression.gzip = gzip
+    compression.zlib = zlib
+    compression.zstd = pyzstd

tests/test_pelican_precompress.py

@@ -58,7 +58,7 @@ def apply_async_mock(fn, args, *extra_args, **kwargs):
             },
         ),
         (
-            {"pyzstd"},
+            {"compression.zstd"},
             {
                 "PRECOMPRESS_GZIP": True,
                 "PRECOMPRESS_BROTLI": False,
@@ -67,7 +67,7 @@ def apply_async_mock(fn, args, *extra_args, **kwargs):
             },
         ),
         (
-            {"brotli", "zopfli", "pyzstd"},
+            {"brotli", "zopfli", "compression.zstd"},
             {
                 "PRECOMPRESS_GZIP": False,
                 "PRECOMPRESS_BROTLI": True,
@@ -83,7 +83,7 @@ def test_get_settings_compression_support(installed_modules, expected_settings):
 
     patches = [
         patch(f"pelican.plugins.precompress.{module}", module in installed_modules)
-        for module in {"brotli", "zopfli", "pyzstd"}
+        for module in {"brotli", "zopfli", "compression.zstd"}
     ]
     [patch_.start() for patch_ in patches]
 
@@ -111,7 +111,7 @@ def test_get_settings_compression_validation():
     patches = [
         patch("pelican.plugins.precompress.brotli", None),
         patch("pelican.plugins.precompress.zopfli", None),
-        patch("pelican.plugins.precompress.pyzstd", None),
+        patch("pelican.plugins.precompress.compression.zstd", None),
         patch("pelican.plugins.precompress.log", log),
     ]
     [patch_.start() for patch_ in patches]
@@ -192,14 +192,14 @@ def test_compress_with_gzip_exception():
         pp.compress_with_gzip(b"")
 
 
+@pytest.mark.skipif(pp.compression.zstd is None, reason="zstandard is unavailable")
 def test_compress_with_zstandard():
-    zstandard = pytest.importorskip("pyzstd")
     data = b"a" * 100
-    assert zstandard.decompress(pp.compress_with_zstandard(data)) == data
+    assert pp.compression.zstd.decompress(pp.compress_with_zstandard(data)) == data
 
 
+@pytest.mark.skipif(pp.compression.zstd is None, reason="zstandard is unavailable")
 def test_compress_with_zstandard_error():
-    pytest.importorskip("pyzstd")
     with pytest.raises(pp.FileSizeIncrease):
         pp.compress_with_zstandard(b"")
 
@@ -334,8 +334,8 @@ def test_compress_files_overwrite_gz(fs, multiprocessing):
         assert gzip.decompress(file.read()) == b"a" * 100
 
 
+@pytest.mark.skipif(pp.compression.zstd is None, reason="zstandard is unavailable")
 def test_compress_files_overwrite_zst(fs, multiprocessing):
-    zstandard = pytest.importorskip("pyzstd")
     with open("/test.txt", "wb") as file:
         file.write(b"a" * 100)
     with open("/test.txt.zst", "wb") as file:
@@ -353,7 +353,7 @@ def test_compress_files_overwrite_zst(fs, multiprocessing):
         pp.compress_files(instance)
     log.warning.assert_called_once()
     with pathlib.Path("/test.txt.zst").open("rb") as file:
-        assert zstandard.decompress(file.read()) == b"a" * 100
+        assert pp.compression.zstd.decompress(file.read()) == b"a" * 100
 
 
 def test_compress_files_file_size_increase(fs, multiprocessing):
@@ -421,10 +421,10 @@ def test_compress_files_overwrite_erase_existing_file(fs, multiprocessing):
     assert not pathlib.Path("/test.txt.gz").exists()
 
 
+@pytest.mark.skipif(pp.compression.zstd is None, reason="zstandard is unavailable")
 def test_compress_files_success_all_algorithms(fs, multiprocessing):
     pytest.importorskip("brotli")
     pytest.importorskip("zopfli")
-    pytest.importorskip("pyzstd")
     with open("/test.txt", "wb") as file:
         file.write(b"a" * 100)
     instance = Mock()