用 Python 生成可复现的 gzip：固定时间戳、移除文件名并验证哈希

python3 - <<'PY_HEADER'
import gzip
from io import BytesIO

payload = b"id,value\n1,alpha\n"

def pack(name, stamp):
    buffer = BytesIO()
    with gzip.GzipFile(filename=name, mode="wb", fileobj=buffer,
                       mtime=stamp, compresslevel=9) as file:
        file.write(payload)
    return buffer.getvalue()

a = pack("a.csv", 1700000000)
b = pack("a.csv", 1700000001)
c = pack("b.csv", 1700000000)
assert a != b and a != c
assert gzip.decompress(a) == gzip.decompress(b) == gzip.decompress(c) == payload
print("OK: same content, different gzip bytes")
PY_HEADER

python3 --version
python3 -c 'import platform, zlib; print(platform.python_version(), zlib.ZLIB_RUNTIME_VERSION)'
mkdir reproducible-gzip-demo
cd reproducible-gzip-demo
printf 'id,value\n1,alpha\n2,beta\n' > first.csv
cp first.csv second.csv

"""Create a reproducible gzip in a new file. Python 3.9+."""
import argparse
import gzip
from pathlib import Path
import shutil
import sys
import zlib


def compress_file(source, target):
    created = False
    try:
        with source.open("rb") as src:
            with target.open("xb") as raw:
                created = True
                with gzip.GzipFile(
                    filename="", mode="wb", fileobj=raw,
                    mtime=0, compresslevel=9,
                ) as packed:
                    shutil.copyfileobj(src, packed, length=1024 * 1024)
    except BaseException:
        if created:
            target.unlink(missing_ok=True)
        raise


def main():
    parser = argparse.ArgumentParser(description=__doc__, allow_abbrev=False)
    parser.add_argument("source", type=Path)
    parser.add_argument("target", type=Path)
    args = parser.parse_args()
    try:
        compress_file(args.source, args.target)
    except (OSError, zlib.error) as exc:
        print(f"ERROR: {exc}", file=sys.stderr)
        return 1
    print("OK: gzip complete")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

python3 reproducible_gzip.py --help
python3 reproducible_gzip.py first.csv first.gz
python3 reproducible_gzip.py second.csv second.gz
sha256sum first.gz second.gz

python3 - <<'PY_CHECK'
import gzip
import hashlib
from pathlib import Path

first = Path("first.gz").read_bytes()
second = Path("second.gz").read_bytes()
assert first == second
assert first[:3] == b"\x1f\x8b\x08"
assert first[3] & 0x08 == 0  # No FNAME field.
assert first[4:8] == b"\x00" * 4  # MTIME = 0.
assert gzip.decompress(first) == Path("first.csv").read_bytes()
assert gzip.decompress(second) == Path("second.csv").read_bytes()
print("OK: equal gzip bytes, zero timestamp, no filename, exact round trip")
print("sha256:", hashlib.sha256(first).hexdigest())
PY_CHECK

if python3 reproducible_gzip.py first.csv first.gz; then
  printf 'UNEXPECTED: existing output was accepted\n' >&2
else
  printf 'exit=%s\n' "$?"
fi

"""Run beside reproducible_gzip.py, using only disposable test files."""
import gzip
from pathlib import Path
import subprocess
import sys
from tempfile import TemporaryDirectory

script = Path("reproducible_gzip.py").resolve()

def run(source, target):
    return subprocess.run(
        [sys.executable, str(script), str(source), str(target)],
        capture_output=True, text=True, timeout=30,
    )

with TemporaryDirectory(prefix="gzip-check-") as directory:
    root = Path(directory)
    for number, payload in enumerate((b"", "中文\n".encode("utf-8"),
                                      bytes(range(256)) * 9000)):
        source = root / f"input {number}.bin"
        target = root / f"output {number}.gz"
        other = root / f"other {number}.gz"
        source.write_bytes(payload)
        assert run(source, target).returncode == 0
        assert run(source, other).returncode == 0
        saved = target.read_bytes()
        assert saved == other.read_bytes()
        assert gzip.decompress(saved) == payload
        assert source.read_bytes() == payload
        result = run(source, target)
        assert result.returncode == 1 and not result.stdout
        assert target.read_bytes() == saved
        result = run(source, source)
        assert result.returncode == 1
        assert source.read_bytes() == payload
    missing = root / "missing.bin"
    output = root / "missing.gz"
    result = run(missing, output)
    assert result.returncode == 1 and not output.exists()
    assert "ERROR:" in result.stderr
print("OK: empty, Unicode, multi-chunk binary, overwrite and missing-input checks")