tinyfy 0.1.0__py3-none-any.whl

tinyfy/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

tinyfy/__main__.py

@@ -0,0 +1,3 @@
+from tinyfy.cli import main
+
+raise SystemExit(main())

tinyfy/cli.py

@@ -0,0 +1,224 @@
+"""tinyfy — compress any file, locally. Installed as `tiny` (and `tinyfy`).
+
+    tiny photo.jpg video.mov report.pdf
+    tiny -l high --max-dim 1920 photos/ --each
+    tiny project/ -f zst                 # pack a folder -> project.tar.zst
+    tiny report.pdf -o out/small.pdf     # write to an exact file
+    tiny -x project.tar.zst              # extract
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import shutil
+import sys
+import tempfile
+from concurrent.futures import ThreadPoolExecutor
+from dataclasses import dataclass
+from pathlib import Path
+
+from tinyfy import __version__
+from tinyfy.common import LEVELS, Options, Skip, human, path_size
+from tinyfy.handlers import generic, pick
+
+FORMATS = ("xz", "gz", "zst", "zip")
+
+
+@dataclass
+class Task:
+    src: Path
+    out_dir: Path
+    mirror: bool = False      # always leave a file in out_dir (copy the original if it can't be shrunk)
+    smart_only: bool = False  # --each: never turn unknown files into .xz
+    out_file: Path | None = None  # -o points at an exact file
+
+
+@dataclass
+class Result:
+    src: Path
+    status: str            # ok | copied | skip | error
+    before: int = 0
+    after: int = 0
+    out: Path | None = None
+    note: str = ""
+
+
+def _prog_name() -> str:
+    name = Path(sys.argv[0]).stem
+    return name if name in ("tiny", "tinyfy") else "tiny"
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog=_prog_name(),
+        description="Compress any file: images, PDFs, video, audio, Office documents, folders and everything else.",
+        epilog=__doc__.split("\n", 2)[2],
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    p.add_argument("paths", nargs="+", type=Path, help="files or folders to compress")
+    p.add_argument("-l", "--level", choices=LEVELS, default="medium",
+                   help="compression level: low (best quality), medium (default), high (smallest)")
+    p.add_argument("-o", "--output",
+                   help="output file (e.g. out/small.pdf) or output folder (e.g. out/ or an existing folder); "
+                        "default: next to the original with a .min suffix")
+    p.add_argument("-f", "--format", dest="fmt", choices=FORMATS,
+                   help="lossless format for other files/folders "
+                        "(default: taken from the -o extension if given, otherwise xz)")
+    p.add_argument("--lossless", action="store_true",
+                   help="lossless only: keep every byte, output is .xz/.zst/...")
+    p.add_argument("--each", action="store_true",
+                   help="for folders: compress each file inside instead of packing, into <name>.min/")
+    p.add_argument("--max-dim", type=int, metavar="PX", help="downscale images/videos so the longest side is <= PX")
+    p.add_argument("--codec", dest="video_codec", choices=("h264", "h265"), default="h264",
+                   help="video codec (h265 is smaller but slower and less compatible)")
+    p.add_argument("--in-place", action="store_true", help="replace the original (only when the result is smaller)")
+    p.add_argument("--force", action="store_true", help="keep the result even if it is not smaller")
+    p.add_argument("-j", "--jobs", type=int, default=min(4, os.cpu_count() or 1), help="files to process in parallel")
+    p.add_argument("-x", "--extract", action="store_true", help="extract .xz/.gz/.zst/.bz2/.zip/.tar.* files")
+    p.add_argument("-V", "--version", action="version", version=f"%(prog)s {__version__}")
+    return p
+
+
+def output_file(args: argparse.Namespace, parser: argparse.ArgumentParser) -> Path | None:
+    """-o is a file if it has an extension, doesn't end with '/' and isn't an existing folder."""
+    raw = args.output
+    args.output = Path(raw) if raw else None
+    out = args.output
+    if out is None or raw.endswith(("/", os.sep)) or out.is_dir() or not out.suffix:
+        return None
+    if len(args.paths) != 1 or args.each:
+        parser.error("when -o is a file, exactly one input is allowed (and no --each)")
+    if args.in_place:
+        parser.error("-o cannot be combined with --in-place")
+    return out
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    out_file = output_file(args, parser)
+    if args.extract:
+        return _extract(args, out_file)
+
+    fmt = args.fmt
+    if fmt is None and out_file is not None:
+        # -o project.tar.zst / log.gz -> take the format from the extension
+        fmt = {".tgz": "gz", ".tzst": "zst"}.get(out_file.suffix.lower(), out_file.suffix.lower().lstrip("."))
+    opts = Options(level=args.level, max_dim=args.max_dim, video_codec=args.video_codec,
+                   fmt=fmt if fmt in FORMATS else "xz", lossless=args.lossless)
+    tasks: list[Task] = []
+    missing = False
+    for p in args.paths:
+        if not p.exists():
+            print(f"✗ not found: {p}", file=sys.stderr)
+            missing = True
+            continue
+        if p.is_dir() and args.each:
+            root = args.output or p.parent / f"{p.name}.min"
+            if args.in_place:
+                root = p
+            for f in sorted(p.rglob("*")):
+                if f.is_file():
+                    tasks.append(Task(f, root / f.relative_to(p).parent, mirror=not args.in_place, smart_only=True))
+        else:
+            tasks.append(Task(p, args.output or p.parent, out_file=out_file))
+
+    if not tasks:
+        return 1
+
+    def work(t: Task) -> Result:
+        r = process(t, opts, in_place=args.in_place and not t.src.is_dir(), force=args.force)
+        report(r)
+        return r
+
+    with ThreadPoolExecutor(max(1, args.jobs)) as pool:
+        results = list(pool.map(work, tasks))
+    summary(results)
+    return 1 if missing or any(r.status == "error" for r in results) else 0
+
+
+def process(t: Task, opts: Options, in_place: bool, force: bool) -> Result:
+    src = t.src
+    before = path_size(src)
+    res = Result(src, "error", before=before)
+    try:
+        handler = pick(src, opts, smart_only=t.smart_only)
+        if handler is None:
+            raise Skip("no dedicated compressor for this type")
+        with tempfile.TemporaryDirectory(prefix="tinyfy-") as tmp:
+            produced = handler(src, Path(tmp), opts)
+            after = produced.stat().st_size
+            if after >= before and not force:
+                raise Skip(f"result is not smaller ({human(after)})")
+            dest = t.out_file or _destination(src, produced.name, t.out_dir, in_place)
+            if dest.is_dir():
+                raise IsADirectoryError(f"{dest} is a folder, refusing to overwrite it")
+            dest.parent.mkdir(parents=True, exist_ok=True)
+            shutil.move(produced, dest)  # overwrites a previous result
+            if in_place and dest != src:
+                src.unlink()  # extension changed (e.g. .mov -> .mp4): remove the original
+        res.status, res.after, res.out = "ok", after, dest
+    except Skip as e:
+        res.status, res.after, res.note = "skip", before, str(e)
+        if t.mirror:
+            dest = t.out_dir / src.name
+            dest.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(src, dest)
+            res.status, res.out = "copied", dest
+    except Exception as e:  # noqa: BLE001 — one bad file must not stop the whole run
+        res.note = f"{type(e).__name__}: {e}"
+    return res
+
+
+def _destination(src: Path, name: str, out_dir: Path, in_place: bool) -> Path:
+    if in_place:
+        return src.with_name(name)
+    dest = out_dir / name
+    if dest.resolve() == src.resolve():
+        # same folder, same name -> insert .min before the extension
+        stem, dot, ext = name.rpartition(".")
+        dest = out_dir / (f"{stem}.min.{ext}" if dot else f"{name}.min")
+    return dest
+
+
+def report(r: Result) -> None:
+    if r.status == "ok":
+        saved = 100 * (1 - r.after / r.before) if r.before else 0
+        print(f"✓ {r.src}  {human(r.before)} → {human(r.after)}  (-{saved:.0f}%)  ⇒ {r.out}")
+    elif r.status == "copied":
+        print(f"= {r.src}  copied unchanged ({r.note})")
+    elif r.status == "skip":
+        print(f"- {r.src}  skipped: {r.note}")
+    else:
+        print(f"✗ {r.src}  error: {r.note}", file=sys.stderr)
+
+
+def summary(results: list[Result]) -> None:
+    if len(results) < 2:
+        return
+    before = sum(r.before for r in results if r.status in ("ok", "copied"))
+    after = sum(r.after for r in results if r.status in ("ok", "copied"))
+    counts = {s: sum(r.status == s for r in results) for s in ("ok", "copied", "skip", "error")}
+    saved = 100 * (1 - after / before) if before else 0
+    print(f"\nTotal: {counts['ok']} compressed, {counts['copied'] + counts['skip']} unchanged/skipped, "
+          f"{counts['error']} failed — {human(before)} → {human(after)} (-{saved:.0f}%)")
+
+
+def _extract(args: argparse.Namespace, out_file: Path | None) -> int:
+    code = 0
+    for p in args.paths:
+        try:
+            if out_file:
+                out = generic.extract(p, out_file.parent, out_file)
+            else:
+                out = generic.extract(p, args.output or p.parent)
+            print(f"✓ {p} ⇒ {out}")
+        except Exception as e:  # noqa: BLE001
+            print(f"✗ {p}  error: {e}", file=sys.stderr)
+            code = 1
+    return code
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

tinyfy/common.py

@@ -0,0 +1,53 @@
+"""Shared types and helpers used by the CLI and all handlers."""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+
+LEVELS = ("low", "medium", "high")
+
+
+@dataclass(frozen=True)
+class Options:
+    level: str = "medium"          # low = best quality, high = smallest
+    max_dim: int | None = None     # longest side (px) for images/videos
+    video_codec: str = "h264"      # h264 | h265
+    fmt: str = "xz"                # lossless format: xz | gz | zst | zip
+    lossless: bool = False         # lossless compression only
+
+
+class Skip(Exception):
+    """The file should not or cannot be compressed (already compressed, missing tool, ...)."""
+
+
+def need_tool(name: str, *alternatives: str) -> str:
+    """Find an external program, trying alternative names (e.g. Ghostscript is gswin64c on Windows)."""
+    for candidate in (name, *alternatives):
+        path = shutil.which(candidate)
+        if path:
+            return path
+    raise Skip(f"install '{name}' to compress this file type")
+
+
+def run(cmd: list[str]) -> None:
+    proc = subprocess.run(cmd, capture_output=True, text=True)
+    if proc.returncode != 0:
+        msg = (proc.stderr or proc.stdout).strip().splitlines()
+        raise RuntimeError(msg[-1] if msg else f"{Path(cmd[0]).name} failed (exit code {proc.returncode})")
+
+
+def path_size(path: Path) -> int:
+    if path.is_dir():
+        return sum(f.stat().st_size for f in path.rglob("*") if f.is_file())
+    return path.stat().st_size
+
+
+def human(n: float) -> str:
+    for unit in ("B", "KB", "MB", "GB"):
+        if abs(n) < 1024:
+            return f"{n:.0f} {unit}" if unit == "B" else f"{n:.1f} {unit}"
+        n /= 1024
+    return f"{n:.1f} TB"

tinyfy/handlers/__init__.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Callable
+
+from tinyfy.common import Options
+from tinyfy.handlers import generic, image, media, office, pdf
+
+Handler = Callable[[Path, Path, Options], Path]
+
+_SMART: list[tuple[set[str], Handler]] = [
+    (image.EXTS, image.run),
+    (pdf.EXTS, pdf.run),
+    (media.EXTS, media.run),
+    (office.EXTS, office.run),
+]
+
+
+def pick(src: Path, opts: Options, smart_only: bool = False) -> Handler | None:
+    """Pick a handler by extension. smart_only: return None instead of falling back to lossless."""
+    if src.is_dir() or opts.lossless:
+        return generic.run
+    ext = src.suffix.lower()
+    for exts, handler in _SMART:
+        if ext in exts:
+            return handler
+    return None if smart_only else generic.run

tinyfy/handlers/generic.py

@@ -0,0 +1,133 @@
+"""Lossless compression for any file/folder: xz, gz, zst, zip (folders -> tar.*)."""
+
+from __future__ import annotations
+
+import gzip
+import lzma
+import shutil
+import tarfile
+import zipfile
+from pathlib import Path
+
+from tinyfy.common import Options, Skip, need_tool, run as run_cmd
+
+# Already compressed; compressing again gains almost nothing
+ALREADY_COMPRESSED = {
+    ".zip", ".gz", ".tgz", ".xz", ".txz", ".bz2", ".zst", ".7z", ".rar", ".lz4", ".br", ".lzma",
+    ".gif", ".heic", ".heif", ".avif", ".jxl", ".apk", ".jar", ".dmg", ".whl",
+}
+
+XZ_PRESET = {"low": 3, "medium": 6, "high": 9 | lzma.PRESET_EXTREME}
+GZ_LEVEL = {"low": 6, "medium": 9, "high": 9}
+ZST_LEVEL = {"low": 3, "medium": 12, "high": 19}
+ZIP_LEVEL = {"low": 6, "medium": 9, "high": 9}
+
+CHUNK = 1 << 20
+
+
+def run(src: Path, tmp: Path, opts: Options) -> Path:
+    if src.is_dir():
+        return _dir(src, tmp, opts)
+    if src.suffix.lower() in ALREADY_COMPRESSED:
+        raise Skip("already compressed")
+    return _file(src, tmp, opts)
+
+
+def _file(src: Path, tmp: Path, opts: Options) -> Path:
+    fmt, lvl = opts.fmt, opts.level
+    out = tmp / f"{src.name}.{fmt}"
+    if fmt == "xz":
+        with src.open("rb") as fi, lzma.open(out, "wb", preset=XZ_PRESET[lvl]) as fo:
+            shutil.copyfileobj(fi, fo, CHUNK)
+    elif fmt == "gz":
+        with src.open("rb") as fi, gzip.open(out, "wb", compresslevel=GZ_LEVEL[lvl]) as fo:
+            shutil.copyfileobj(fi, fo, CHUNK)
+    elif fmt == "zst":
+        _zstd(src, out, lvl)
+    elif fmt == "zip":
+        with zipfile.ZipFile(out, "w", zipfile.ZIP_DEFLATED, compresslevel=ZIP_LEVEL[lvl]) as z:
+            z.write(src, src.name)
+    else:
+        raise ValueError(fmt)
+    return out
+
+
+def _dir(src: Path, tmp: Path, opts: Options) -> Path:
+    fmt, lvl = opts.fmt, opts.level
+    if fmt == "zip":
+        out = tmp / f"{src.name}.zip"
+        with zipfile.ZipFile(out, "w", zipfile.ZIP_DEFLATED, compresslevel=ZIP_LEVEL[lvl]) as z:
+            for f in sorted(src.rglob("*")):
+                z.write(f, f.relative_to(src.parent))
+        return out
+    out = tmp / f"{src.name}.tar.{fmt}"
+    if fmt == "xz":
+        with tarfile.open(out, "w:xz", preset=XZ_PRESET[lvl]) as t:
+            t.add(src, src.name)
+    elif fmt == "gz":
+        with tarfile.open(out, "w:gz", compresslevel=GZ_LEVEL[lvl]) as t:
+            t.add(src, src.name)
+    elif fmt == "zst":
+        plain = tmp / f"{src.name}.tar"
+        with tarfile.open(plain, "w") as t:
+            t.add(src, src.name)
+        _zstd(plain, out, lvl)
+        plain.unlink()
+    else:
+        raise ValueError(fmt)
+    return out
+
+
+def _zstd(src: Path, out: Path, lvl: str) -> None:
+    zstd = need_tool("zstd")
+    run_cmd([zstd, "-q", "-f", "-T0", "--long=27", f"-{ZST_LEVEL[lvl]}", str(src), "-o", str(out)])
+
+
+# ---------- extraction ----------
+
+def extract(src: Path, dest: Path, out_file: Path | None = None) -> Path:
+    """Extract into folder dest (overwriting existing files). out_file: exact target for .xz/.gz/.zst/.bz2."""
+    name = src.name.lower()
+    dest.mkdir(parents=True, exist_ok=True)
+    is_archive = name.endswith((".tar.zst", ".tzst")) or tarfile.is_tarfile(src) or zipfile.is_zipfile(src)
+    if out_file and is_archive:
+        raise Skip("this archive holds multiple files, -o must be a folder")
+    if name.endswith((".tar.zst", ".tzst")):
+        zstd = need_tool("zstd")
+        plain = dest / (src.name.rsplit(".", 1)[0] + ".tmp.tar")
+        run_cmd([zstd, "-d", "-q", "-f", "--long=31", str(src), "-o", str(plain)])
+        try:
+            _untar(plain, dest)
+        finally:
+            plain.unlink()
+        return dest
+    if tarfile.is_tarfile(src):
+        _untar(src, dest)
+        return dest
+    if zipfile.is_zipfile(src):
+        with zipfile.ZipFile(src) as z:
+            z.extractall(dest)
+        return dest
+    out = out_file or dest / src.name.rsplit(".", 1)[0]
+    if out.is_dir():
+        raise IsADirectoryError(f"{out} is a folder, refusing to overwrite it")
+    if name.endswith(".zst"):
+        run_cmd([need_tool("zstd"), "-d", "-q", "-f", "--long=31", str(src), "-o", str(out)])
+        return out
+    opener = {".xz": lzma.open, ".lzma": lzma.open, ".gz": gzip.open}.get(src.suffix.lower())
+    if opener is None:
+        import bz2
+        if src.suffix.lower() != ".bz2":
+            raise Skip("unrecognized compression format")
+        opener = bz2.open
+    with opener(src, "rb") as fi, out.open("wb") as fo:
+        shutil.copyfileobj(fi, fo, CHUNK)
+    return out
+
+
+def _untar(src: Path, dest: Path) -> None:
+    with tarfile.open(src) as t:
+        try:
+            t.extractall(dest, filter="data")
+        except TypeError:  # Python < 3.10.12 has no filter argument
+            t.extractall(dest)

tinyfy/handlers/image.py

@@ -0,0 +1,61 @@
+"""Images: re-encode JPEG/WebP by quality, optimize PNG (lossy at high), BMP -> PNG, TIFF -> deflate."""
+
+from __future__ import annotations
+
+import io
+from pathlib import Path
+
+from tinyfy.common import Options, Skip
+
+EXTS = {".jpg", ".jpeg", ".jfif", ".png", ".webp", ".bmp", ".tif", ".tiff"}
+
+QUALITY = {"low": 85, "medium": 75, "high": 60}
+
+
+def _pil():
+    try:
+        from PIL import Image, ImageOps
+    except ImportError:
+        raise Skip("install Pillow (pip install Pillow) to compress images")
+    return Image, ImageOps
+
+
+def compress_bytes(data: bytes, ext: str, opts: Options) -> bytes:
+    """Compress an image in memory, keeping its format. Used for single files and images inside Office files."""
+    Image, ImageOps = _pil()
+    ext = ext.lower()
+    with Image.open(io.BytesIO(data)) as src:
+        if getattr(src, "n_frames", 1) > 1:
+            raise Skip("animated/multi-page image")
+        icc = src.info.get("icc_profile")
+        im = ImageOps.exif_transpose(src)
+        if opts.max_dim:
+            im.thumbnail((opts.max_dim, opts.max_dim), Image.LANCZOS)
+
+        out = io.BytesIO()
+        q = QUALITY[opts.level]
+        if ext in (".jpg", ".jpeg", ".jfif"):
+            if im.mode not in ("RGB", "L"):
+                im = im.convert("RGB")
+            im.save(out, "JPEG", quality=q, optimize=True, progressive=True, icc_profile=icc)
+        elif ext == ".webp":
+            im.save(out, "WEBP", quality=q, method=6, icc_profile=icc)
+        elif ext in (".png", ".bmp"):
+            if opts.level == "high" and im.mode not in ("P", "L", "1"):
+                if im.mode not in ("RGB", "RGBA"):
+                    im = im.convert("RGBA")
+                im = im.quantize(256, method=Image.Quantize.FASTOCTREE)
+            im.save(out, "PNG", optimize=True, icc_profile=icc)
+        elif ext in (".tif", ".tiff"):
+            im.save(out, "TIFF", compression="tiff_adobe_deflate", icc_profile=icc)
+        else:
+            raise Skip(f"unsupported image type {ext}")
+        return out.getvalue()
+
+
+def run(src: Path, tmp: Path, opts: Options) -> Path:
+    ext = src.suffix.lower()
+    # BMP is uncompressed -> save as PNG (lossless at low/medium)
+    out = tmp / (src.stem + ".png" if ext == ".bmp" else src.name)
+    out.write_bytes(compress_bytes(src.read_bytes(), ext, opts))
+    return out

tinyfy/handlers/media.py

@@ -0,0 +1,65 @@
+"""Video and audio through ffmpeg."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from tinyfy.common import Options, need_tool, run as run_cmd
+
+VIDEO_EXTS = {".mp4", ".mov", ".mkv", ".avi", ".wmv", ".flv", ".webm", ".m4v", ".mpg", ".mpeg", ".3gp", ".ts"}
+AUDIO_EXTS = {".mp3", ".wav", ".flac", ".aiff", ".aif", ".m4a", ".aac", ".ogg", ".opus", ".wma"}
+EXTS = VIDEO_EXTS | AUDIO_EXTS
+
+CRF = {
+    "h264": {"low": 23, "medium": 26, "high": 30},
+    "h265": {"low": 26, "medium": 28, "high": 32},
+}
+VIDEO_AUDIO_BITRATE = {"low": "160k", "medium": "128k", "high": "96k"}
+AUDIO_BITRATE = {"low": "192k", "medium": "128k", "high": "96k"}
+OPUS_BITRATE = {"low": "128k", "medium": "96k", "high": "64k"}
+
+
+def _ffmpeg(args: list[str]) -> None:
+    run_cmd([need_tool("ffmpeg"), "-hide_banner", "-loglevel", "error", "-y", *args])
+
+
+def run(src: Path, tmp: Path, opts: Options) -> Path:
+    if src.suffix.lower() in VIDEO_EXTS:
+        return _video(src, tmp, opts)
+    return _audio(src, tmp, opts)
+
+
+def _video(src: Path, tmp: Path, opts: Options) -> Path:
+    out = tmp / (src.stem + ".mp4")
+    # yuv420p needs even dimensions
+    vf = "scale=trunc(iw/2)*2:trunc(ih/2)*2"
+    if opts.max_dim:
+        d = opts.max_dim
+        vf = f"scale='min(iw,{d})':'min(ih,{d})':force_original_aspect_ratio=decrease," + vf
+    codec = ["-c:v", "libx264", "-preset", "slow"]
+    if opts.video_codec == "h265":
+        codec = ["-c:v", "libx265", "-preset", "medium", "-tag:v", "hvc1", "-x265-params", "log-level=error"]
+    _ffmpeg([
+        "-i", str(src),
+        "-map", "0:v:0", "-map", "0:a?", "-map_metadata", "0",
+        *codec, "-crf", str(CRF[opts.video_codec][opts.level]), "-pix_fmt", "yuv420p", "-vf", vf,
+        "-c:a", "aac", "-b:a", VIDEO_AUDIO_BITRATE[opts.level],
+        "-movflags", "+faststart", str(out),
+    ])
+    return out
+
+
+def _audio(src: Path, tmp: Path, opts: Options) -> Path:
+    ext = src.suffix.lower()
+    lvl = opts.level
+    if ext in (".wav", ".aiff", ".aif", ".flac") and lvl == "low":
+        out, codec = tmp / (src.stem + ".flac"), ["-c:a", "flac", "-compression_level", "12"]
+    elif ext in (".m4a", ".aac"):
+        out, codec = tmp / (src.stem + ".m4a"), ["-c:a", "aac", "-b:a", AUDIO_BITRATE[lvl]]
+    elif ext in (".ogg", ".opus"):
+        out, codec = tmp / src.name, ["-c:a", "libopus", "-b:a", OPUS_BITRATE[lvl]]
+    else:
+        # mp3 is the most compatible; wav/flac at medium/high also become mp3
+        out, codec = tmp / (src.stem + ".mp3"), ["-c:a", "libmp3lame", "-b:a", AUDIO_BITRATE[lvl]]
+    _ffmpeg(["-i", str(src), "-map", "0:a:0", "-map_metadata", "0", *codec, str(out)])
+    return out

tinyfy/handlers/office.py

@@ -0,0 +1,38 @@
+"""Office/ODF/EPUB (zip containers): recompress embedded images and re-zip at maximum level."""
+
+from __future__ import annotations
+
+import zipfile
+from pathlib import Path, PurePosixPath
+
+from tinyfy.common import Options, Skip
+from tinyfy.handlers import image
+
+EXTS = {".docx", ".xlsx", ".pptx", ".odt", ".ods", ".odp", ".epub"}
+
+MIN_IMAGE_BYTES = 20 * 1024
+
+
+def run(src: Path, tmp: Path, opts: Options) -> Path:
+    out = tmp / src.name
+    with zipfile.ZipFile(src) as zin, zipfile.ZipFile(out, "w", zipfile.ZIP_DEFLATED, compresslevel=9) as zout:
+        infos = zin.infolist()
+        # ODF/EPUB require 'mimetype' to be the first entry, stored uncompressed
+        infos.sort(key=lambda i: i.filename != "mimetype")
+        for info in infos:
+            data = zin.read(info)
+            if info.filename == "mimetype":
+                zout.writestr(info, data, compress_type=zipfile.ZIP_STORED)
+                continue
+            ext = PurePosixPath(info.filename).suffix.lower()
+            if ext in image.EXTS and ext not in (".bmp", ".tif", ".tiff") and len(data) >= MIN_IMAGE_BYTES:
+                try:
+                    smaller = image.compress_bytes(data, ext, opts)
+                    if len(smaller) < len(data):
+                        data = smaller
+                except Skip:
+                    pass
+                except Exception:
+                    pass  # unreadable image: keep it as is
+            zout.writestr(info.filename, data, compress_type=zipfile.ZIP_DEFLATED)
+    return out

tinyfy/handlers/pdf.py

@@ -0,0 +1,24 @@
+"""PDF: rewrite through Ghostscript, downsampling embedded images by level."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from tinyfy.common import Options, need_tool, run as run_cmd
+
+EXTS = {".pdf"}
+
+PRESET = {"low": "/printer", "medium": "/ebook", "high": "/screen"}
+
+
+def run(src: Path, tmp: Path, opts: Options) -> Path:
+    gs = need_tool("gs", "gswin64c", "gswin32c")
+    out = tmp / src.name
+    run_cmd([
+        gs, "-sDEVICE=pdfwrite", "-dCompatibilityLevel=1.5",
+        f"-dPDFSETTINGS={PRESET[opts.level]}",
+        "-dDetectDuplicateImages=true", "-dCompressFonts=true", "-dSubsetFonts=true",
+        "-dNOPAUSE", "-dBATCH", "-dQUIET", "-dSAFER",
+        f"-sOutputFile={out}", str(src),
+    ])
+    return out

tinyfy-0.1.0.dist-info/METADATA

@@ -0,0 +1,100 @@
+Metadata-Version: 2.4
+Name: tinyfy
+Version: 0.1.0
+Summary: Compress any file locally: images, PDFs, video, audio, Office documents, folders and more
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/khanhle-dev/tinyfy
+Project-URL: Source, https://github.com/khanhle-dev/tinyfy
+Project-URL: Issues, https://github.com/khanhle-dev/tinyfy/issues
+Keywords: compress,compression,image,pdf,video,ffmpeg,ghostscript,cli
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: System :: Archiving :: Compression
+Classifier: Topic :: Multimedia :: Graphics
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Pillow>=9.1
+Dynamic: license-file
+
+# tinyfy
+
+Compress any file from the command line, entirely on your machine. Each file type gets the method that suits it best:
+
+| Type | Extensions | How |
+| --- | --- | --- |
+| Images | jpg, png, webp, bmp, tiff | Re-encode with Pillow, optimize PNG (palette reduction at `high`), BMP → PNG |
+| PDF | pdf | Ghostscript (`/printer`, `/ebook`, `/screen`) |
+| Video | mp4, mov, mkv, avi, webm, ... | ffmpeg → MP4 H.264 (or H.265 with `--codec h265`) |
+| Audio | mp3, wav, flac, m4a, ogg, ... | ffmpeg (wav/flac → FLAC at `low`, MP3 otherwise) |
+| Office | docx, xlsx, pptx, odt, epub, ... | Recompress embedded images and re-zip at maximum level |
+| Everything else | any file or folder | Lossless: xz (default), gz, zst, zip; folders → `tar.*` |
+
+If the compressed result is **not smaller** than the original, the original is kept (unless you pass `--force`).
+Originals are never overwritten unless you pass `--in-place`.
+
+## Installation
+
+```bash
+pipx install tinyfy        # recommended
+pip install tinyfy         # or inside a virtualenv
+```
+
+This installs the `tiny` command (`tinyfy` also works as an alias).
+
+Requires Python 3.10+. Images and lossless compression work out of the box. Other formats need these programs on your `PATH`:
+
+| Program | Needed for | Debian/Ubuntu | macOS | Windows |
+| --- | --- | --- | --- | --- |
+| ffmpeg | video, audio | `sudo apt install ffmpeg` | `brew install ffmpeg` | `winget install Gyan.FFmpeg` |
+| Ghostscript | PDF | `sudo apt install ghostscript` | `brew install ghostscript` | installer from [ghostscript.com](https://ghostscript.com/releases/gsdnld.html) |
+| zstd | `-f zst` | `sudo apt install zstd` | `brew install zstd` | release from [facebook/zstd](https://github.com/facebook/zstd/releases) |
+
+If a program is missing, files that need it are skipped with a message; everything else still runs.
+
+## Usage
+
+```bash
+tiny photo.jpg video.mov report.pdf           # → photo.min.jpg, video.mp4, report.min.pdf
+tiny -l high --max-dim 1920 *.jpg -o small/   # stronger compression, downscale, save into small/
+tiny report.pdf -o out/small.pdf              # write to an exact file
+tiny project/                                 # pack a folder → project.tar.xz
+tiny project/ -o project.tar.zst              # format taken from the extension
+tiny photos/ --each                           # compress each file → photos.min/ (same structure)
+tiny report.docx --lossless                   # keep every byte → report.docx.xz
+tiny -x project.tar.zst                       # extract
+```
+
+### Options
+
+| Option | Description |
+| --- | --- |
+| `-l, --level low\|medium\|high` | `low` keeps the best quality, `high` gives the smallest files. Default: `medium`. |
+| `-o PATH` | A path with an extension (`out/small.pdf`, `project.tar.zst`) is written as that exact file. A path ending in `/`, or an existing folder, is used as the output folder. |
+| `-f xz\|gz\|zst\|zip` | Lossless format for other files and folders. Defaults to the `-o` extension, otherwise `xz`. |
+| `--lossless` | Use lossless compression for every file, so the original can be restored byte for byte. |
+| `--each` | For folders: compress each file inside instead of packing them into one archive. Files without a dedicated compressor are copied unchanged. |
+| `--max-dim PX` | Downscale images and videos so the longest side is at most `PX`. |
+| `--codec h264\|h265` | Video codec. H.265 is smaller but slower to encode and less widely supported. |
+| `--in-place` | Replace the original when the result is smaller. |
+| `--force` | Keep the result even when it is not smaller. |
+| `-j N` | Number of files processed in parallel. |
+| `-x, --extract` | Extract `.xz`, `.gz`, `.zst`, `.bz2`, `.zip` and `.tar.*` files. |
+
+Re-running a command overwrites the previous output.
+
+## Development
+
+```bash
+python3 -m venv .venv && .venv/bin/pip install -e .
+.venv/bin/python -m unittest discover tests
+```
+
+## License
+
+MIT

tinyfy-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+tinyfy/__init__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+tinyfy/__main__.py,sha256=WcYZdNF2k1mDP7E0omUDLbKbzUPuFjrJ0dapwJwSznA,54
+tinyfy/cli.py,sha256=4yFDxgdLECUR0zCNu2FpchfDU3AzH3bQcJgtOqfNIBM,9395
+tinyfy/common.py,sha256=VYkxkF2p65TOcXCOx5-qf9s7tKOELxUy_UB3VgnZMRs,1748
+tinyfy/handlers/__init__.py,sha256=1t_-rVU3AjyFqknqtt1bJWj0p8NSaCW1HM9jjlS-7Gc,803
+tinyfy/handlers/generic.py,sha256=gn-vp0FtUk9S8hKHn4gCZxcTMllX3V1qwcf5PrS4_rI,4762
+tinyfy/handlers/image.py,sha256=qmt1bH7Ob4E5oxsZOWRF1ZsxrE8H8pPKf3CylaBkE8Y,2334
+tinyfy/handlers/media.py,sha256=0rAMYMkY0cgum7Cj8itaxcS0DBta8u5J18PnhPJ9sVM,2654
+tinyfy/handlers/office.py,sha256=RVPLGkR8k_hvRtMhqr1F8aAzITnQUFYZhvtkc-K_cjk,1524
+tinyfy/handlers/pdf.py,sha256=OV_H7MQLAEwMioWweip1SMFOhuwkGnVyyNh2uzMY0eA,744
+tinyfy-0.1.0.dist-info/licenses/LICENSE,sha256=H3Yr_8eANaPDcTjGbL7xXzW3VTuJTZG0bekjXjLHzkY,1071
+tinyfy-0.1.0.dist-info/METADATA,sha256=2egKDClocqgNnD8A6R1tK3KlSMsrb93sSJ7lBPSw8tg,4915
+tinyfy-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+tinyfy-0.1.0.dist-info/entry_points.txt,sha256=hurkb74K60_I16X2hfQHl1GGKkib6UvBh1DF4FFBVP0,66
+tinyfy-0.1.0.dist-info/top_level.txt,sha256=SRWK7J4GDdvRCxDTIPK10Jy2KgcikaAt9ImQsbzx8QM,7
+tinyfy-0.1.0.dist-info/RECORD,,

tinyfy-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

tinyfy-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+tiny = tinyfy.cli:main
+tinyfy = tinyfy.cli:main

tinyfy-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 tinyfy authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

tinyfy-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+tinyfy