webp-convert 1.0.0__tar.gz

webp_convert-1.0.0/MANIFEST.in

@@ -0,0 +1,3 @@
+include README.md
+include pyproject.toml
+recursive-include webp_convert *.py

webp_convert-1.0.0/PKG-INFO

@@ -0,0 +1,148 @@
+Metadata-Version: 2.4
+Name: webp-convert
+Version: 1.0.0
+Summary: Automatically convert PNG/JPG images to WebP with responsive sizes. CLI, file watcher, and Python API.
+License: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: Pillow>=10.0.0
+Requires-Dist: watchdog>=4.0.0
+Requires-Dist: click>=8.1.0
+Requires-Dist: rich>=13.0.0
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+
+# webp-convert (Python)
+
+> Automatically convert PNG/JPG/GIF/TIFF images to WebP with responsive size variants.
+> Zero-config CLI, file watcher, and programmatic Python API.
+
+---
+
+## Install
+
+```bash
+pip3 install webp-convert
+```
+
+Requires Python 3.8+. Uses [Pillow](https://pillow.readthedocs.io/) — no external binaries required.
+
+---
+
+## Quick start
+
+```bash
+# Convert everything in assets/images (default)
+webp-convert
+
+# Custom dir + quality
+webp-convert src/img -q 90
+
+# Watch mode — auto-converts on file change
+webp-convert src/img --watch
+
+# Custom responsive sizes
+webp-convert src/img --sizes 1200,800,400
+
+# Write outputs to a separate directory
+webp-convert src/img -o dist/img
+```
+
+---
+
+## CLI reference
+
+```
+Usage: webp-convert [INPUT_DIR] [OPTIONS]
+
+  Convert PNG/JPG images to WebP with responsive size variants.
+
+Options:
+  -o, --output TEXT       Output directory (default: same as source)
+  -q, --quality INT       WebP quality 0-100  [default: 80]
+      --lossless          Lossless encoding
+      --sizes W,W,...     Responsive widths e.g. 1200,800,400 (0=full)
+      --no-full           Skip full-size, only responsive variants
+  -r, --recursive         Recurse into subdirectories
+      --no-overwrite      Skip files that already have a .webp counterpart
+  -w, --watch             Watch mode
+      --silent            Suppress all output
+  -h, --help              Show this message and exit
+```
+
+---
+
+## Programmatic API
+
+```python
+from webp_convert import convert, watch, convert_file, ConvertConfig, SizeSpec
+
+# --- Convert a directory (keyword args shortcut) ---
+results = convert(input="src/images", quality=85)
+
+# --- Convert with a config object ---
+cfg = ConvertConfig(
+    input="src/images",
+    output="public/images",  # omit to write next to originals
+    quality=85,
+    lossless=False,
+    recursive=True,
+    overwrite=True,
+    sizes=[
+        SizeSpec(width=0,    suffix=""),       # full size
+        SizeSpec(width=1200, suffix="-1200"),
+        SizeSpec(width=800,  suffix="-800"),
+        SizeSpec(width=400,  suffix="-400"),
+    ],
+    on_file=lambda r: print(f"{r.src} → {r.dest} ({r.size_bytes} bytes)"),
+)
+results = convert(cfg)
+
+# --- Convert a single file ---
+results = convert_file("hero.png", cfg)
+
+# --- Watch mode (context manager) ---
+import time
+watcher = watch(ConvertConfig(input="src/images")).start()
+try:
+    while True:
+        time.sleep(1)
+except KeyboardInterrupt:
+    watcher.stop()
+```
+
+---
+
+## Output structure
+
+Given `hero.jpg` in `src/images/`:
+
+```
+src/images/
+├── hero.jpg          (original, kept by default)
+├── hero.webp         (full size)
+├── hero-800.webp     (800px wide, aspect-ratio preserved)
+└── hero-400.webp     (400px wide)
+```
+
+---
+
+## HTML usage
+
+```html
+<picture>
+  <source
+    type="image/webp"
+    srcset="hero-400.webp 400w, hero-800.webp 800w, hero.webp 1600w"
+    sizes="(max-width: 400px) 400px, (max-width: 800px) 800px, 1600px"
+  />
+  <img src="hero.jpg" alt="Hero image" />
+</picture>
+```
+
+---
+
+## License
+
+MIT

webp_convert-1.0.0/README.md

@@ -0,0 +1,133 @@
+# webp-convert (Python)
+
+> Automatically convert PNG/JPG/GIF/TIFF images to WebP with responsive size variants.
+> Zero-config CLI, file watcher, and programmatic Python API.
+
+---
+
+## Install
+
+```bash
+pip3 install webp-convert
+```
+
+Requires Python 3.8+. Uses [Pillow](https://pillow.readthedocs.io/) — no external binaries required.
+
+---
+
+## Quick start
+
+```bash
+# Convert everything in assets/images (default)
+webp-convert
+
+# Custom dir + quality
+webp-convert src/img -q 90
+
+# Watch mode — auto-converts on file change
+webp-convert src/img --watch
+
+# Custom responsive sizes
+webp-convert src/img --sizes 1200,800,400
+
+# Write outputs to a separate directory
+webp-convert src/img -o dist/img
+```
+
+---
+
+## CLI reference
+
+```
+Usage: webp-convert [INPUT_DIR] [OPTIONS]
+
+  Convert PNG/JPG images to WebP with responsive size variants.
+
+Options:
+  -o, --output TEXT       Output directory (default: same as source)
+  -q, --quality INT       WebP quality 0-100  [default: 80]
+      --lossless          Lossless encoding
+      --sizes W,W,...     Responsive widths e.g. 1200,800,400 (0=full)
+      --no-full           Skip full-size, only responsive variants
+  -r, --recursive         Recurse into subdirectories
+      --no-overwrite      Skip files that already have a .webp counterpart
+  -w, --watch             Watch mode
+      --silent            Suppress all output
+  -h, --help              Show this message and exit
+```
+
+---
+
+## Programmatic API
+
+```python
+from webp_convert import convert, watch, convert_file, ConvertConfig, SizeSpec
+
+# --- Convert a directory (keyword args shortcut) ---
+results = convert(input="src/images", quality=85)
+
+# --- Convert with a config object ---
+cfg = ConvertConfig(
+    input="src/images",
+    output="public/images",  # omit to write next to originals
+    quality=85,
+    lossless=False,
+    recursive=True,
+    overwrite=True,
+    sizes=[
+        SizeSpec(width=0,    suffix=""),       # full size
+        SizeSpec(width=1200, suffix="-1200"),
+        SizeSpec(width=800,  suffix="-800"),
+        SizeSpec(width=400,  suffix="-400"),
+    ],
+    on_file=lambda r: print(f"{r.src} → {r.dest} ({r.size_bytes} bytes)"),
+)
+results = convert(cfg)
+
+# --- Convert a single file ---
+results = convert_file("hero.png", cfg)
+
+# --- Watch mode (context manager) ---
+import time
+watcher = watch(ConvertConfig(input="src/images")).start()
+try:
+    while True:
+        time.sleep(1)
+except KeyboardInterrupt:
+    watcher.stop()
+```
+
+---
+
+## Output structure
+
+Given `hero.jpg` in `src/images/`:
+
+```
+src/images/
+├── hero.jpg          (original, kept by default)
+├── hero.webp         (full size)
+├── hero-800.webp     (800px wide, aspect-ratio preserved)
+└── hero-400.webp     (400px wide)
+```
+
+---
+
+## HTML usage
+
+```html
+<picture>
+  <source
+    type="image/webp"
+    srcset="hero-400.webp 400w, hero-800.webp 800w, hero.webp 1600w"
+    sizes="(max-width: 400px) 400px, (max-width: 800px) 800px, 1600px"
+  />
+  <img src="hero.jpg" alt="Hero image" />
+</picture>
+```
+
+---
+
+## License
+
+MIT

webp_convert-1.0.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "webp-convert"
+version = "1.0.0"
+description = "Automatically convert PNG/JPG images to WebP with responsive sizes. CLI, file watcher, and Python API."
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.8"
+dependencies = [
+    "Pillow>=10.0.0",
+    "watchdog>=4.0.0",
+    "click>=8.1.0",
+    "rich>=13.0.0",
+]
+
+[project.scripts]
+webp-convert = "webp_convert.cli:main"
+
+[project.optional-dependencies]
+dev = ["pytest", "pytest-asyncio"]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["webp_convert*"]

webp_convert-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

webp_convert-1.0.0/webp_convert/__init__.py

@@ -0,0 +1,10 @@
+"""
+webp-convert — Python package
+Convert PNG/JPG/GIF/TIFF images to WebP with responsive size variants.
+"""
+
+from .converter import convert, convert_file, convert_dir, DEFAULT_CONFIG
+from .watcher import watch
+
+__all__ = ["convert", "convert_file", "convert_dir", "watch", "DEFAULT_CONFIG"]
+__version__ = "1.0.0"

webp_convert-1.0.0/webp_convert/cli.py

@@ -0,0 +1,89 @@
+"""
+webp_convert.cli
+Click-based CLI entry point.
+
+Usage:
+    webp-convert [INPUT_DIR] [options]
+"""
+
+import sys
+import time
+import click
+from pathlib import Path
+from .converter import ConvertConfig, SizeSpec, convert
+from .watcher import watch as do_watch
+
+
+def _parse_sizes(sizes_str: str):
+    """Parse '1200,800,400' → list of SizeSpec."""
+    specs = []
+    for part in sizes_str.split(","):
+        w = int(part.strip())
+        specs.append(SizeSpec(width=w, suffix="" if w == 0 else f"-{w}"))
+    return specs
+
+
+@click.command(context_settings={"help_option_names": ["-h", "--help"]})
+@click.argument("input_dir", default="assets/images", metavar="[INPUT_DIR]")
+@click.option("-o", "--output",    default=None,  help="Output directory (default: same as source)")
+@click.option("-q", "--quality",   default=80,    show_default=True, help="WebP quality 0-100")
+@click.option("--lossless",        is_flag=True,  help="Lossless encoding")
+@click.option(
+    "--sizes", "sizes_str",
+    default=None,
+    metavar="W,W,...",
+    help="Responsive widths e.g. 1200,800,400 (0=full). Default: 0,800,400",
+)
+@click.option("--no-full",         is_flag=True,  help="Skip full-size, only responsive variants")
+@click.option("-r", "--recursive", is_flag=True,  help="Recurse into subdirectories")
+@click.option("--no-overwrite",    is_flag=True,  help="Skip files that already have a .webp")
+@click.option("-w", "--watch",     "watch_mode",  is_flag=True, help="Watch mode")
+@click.option("--silent",          is_flag=True,  help="Suppress all output")
+def main(input_dir, output, quality, lossless, sizes_str, no_full, recursive,
+         no_overwrite, watch_mode, silent):
+    """
+    Convert PNG/JPG images to WebP with responsive size variants.
+
+    \b
+    Examples:
+      webp-convert
+      webp-convert src/img -q 90 -o dist/img
+      webp-convert src/img --sizes 1200,800,400
+      webp-convert src/img --watch
+    """
+
+    # Build sizes list
+    if sizes_str:
+        sizes = _parse_sizes(sizes_str)
+        if not no_full and not any(s.width == 0 for s in sizes):
+            sizes.insert(0, SizeSpec(width=0, suffix=""))
+    else:
+        sizes = [SizeSpec(0, ""), SizeSpec(800, "-800"), SizeSpec(400, "-400")]
+        if no_full:
+            sizes = [s for s in sizes if s.width != 0]
+
+    cfg = ConvertConfig(
+        input=input_dir,
+        output=output,
+        quality=quality,
+        lossless=lossless,
+        sizes=sizes,
+        overwrite=not no_overwrite,
+        recursive=recursive,
+        silent=silent,
+    )
+
+    if watch_mode:
+        watcher = do_watch(cfg).start()
+        try:
+            while True:
+                time.sleep(1)
+        except KeyboardInterrupt:
+            click.echo("\n stopping watcher...")
+            watcher.stop()
+    else:
+        convert(cfg)
+
+
+if __name__ == "__main__":
+    main()

webp_convert-1.0.0/webp_convert/converter.py

@@ -0,0 +1,206 @@
+"""
+webp_convert.converter
+Core image conversion logic using Pillow.
+"""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Callable, List, Optional, Union
+
+from PIL import Image
+
+# ─── Config ───────────────────────────────────────────────────────────────────
+
+@dataclass
+class SizeSpec:
+    width: int          # 0 = full size (no resize)
+    suffix: str         # e.g. "-800", "" for full-size
+
+
+DEFAULT_SIZES = [
+    SizeSpec(width=0,   suffix=""),
+    SizeSpec(width=800, suffix="-800"),
+    SizeSpec(width=400, suffix="-400"),
+]
+
+DEFAULT_EXTENSIONS = {".png", ".jpg", ".jpeg", ".gif", ".tiff", ".bmp", ".webp"}
+
+@dataclass
+class ConvertConfig:
+    input: Union[str, List[str]] = "assets/images"
+    output: Optional[str] = None          # None = same folder as source
+    quality: int = 80
+    lossless: bool = False
+    sizes: List[SizeSpec] = field(default_factory=lambda: list(DEFAULT_SIZES))
+    keep_originals: bool = True
+    overwrite: bool = True
+    recursive: bool = False
+    extensions: set = field(default_factory=lambda: set(DEFAULT_EXTENSIONS))
+    on_file: Optional[Callable] = None    # called with ConvertResult per output
+    on_done: Optional[Callable] = None    # called with list[ConvertResult] when batch finishes
+    silent: bool = False
+
+
+DEFAULT_CONFIG = ConvertConfig()
+
+
+# ─── Result ───────────────────────────────────────────────────────────────────
+
+@dataclass
+class ConvertResult:
+    src: Path
+    dest: Path
+    width: Union[int, str]   # int or "original"
+    size_bytes: int
+
+
+# ─── Helpers ──────────────────────────────────────────────────────────────────
+
+def _get_output_path(src: Path, suffix: str, cfg: ConvertConfig) -> Path:
+    if cfg.output:
+        base_dir = Path(cfg.output)
+    else:
+        base_dir = src.parent
+    return base_dir / f"{src.stem}{suffix}.webp"
+
+
+def _log(cfg: ConvertConfig, *args):
+    if not cfg.silent:
+        print(*args)
+
+
+# ─── Single-file conversion ───────────────────────────────────────────────────
+
+def convert_file(src: Union[str, Path], cfg: Optional[ConvertConfig] = None) -> List[ConvertResult]:
+    """
+    Convert a single image file to all configured WebP sizes.
+    Returns a list of ConvertResult objects.
+
+    Example::
+
+        from webp_convert import convert_file, ConvertConfig
+        results = convert_file("hero.jpg", ConvertConfig(quality=90))
+    """
+    cfg = cfg or ConvertConfig()
+    src = Path(src)
+    results = []
+
+    if cfg.output:
+        Path(cfg.output).mkdir(parents=True, exist_ok=True)
+
+    with Image.open(src) as img:
+        # Ensure RGB(A) for proper WebP encoding
+        if img.mode not in ("RGB", "RGBA"):
+            img = img.convert("RGBA" if img.mode == "P" and "transparency" in img.info else "RGB")
+
+        for spec in cfg.sizes:
+            dest = _get_output_path(src, spec.suffix, cfg)
+
+            if not cfg.overwrite and dest.exists():
+                _log(cfg, f"  skip  {dest} (exists)")
+                continue
+
+            if spec.width > 0:
+                ratio = spec.width / img.width
+                # Don't enlarge
+                if ratio < 1.0:
+                    new_h = int(img.height * ratio)
+                    resized = img.resize((spec.width, new_h), Image.LANCZOS)
+                else:
+                    resized = img
+            else:
+                resized = img
+
+            save_kwargs = {"format": "WEBP", "quality": cfg.quality}
+            if cfg.lossless:
+                save_kwargs["lossless"] = True
+
+            resized.save(dest, **save_kwargs)
+            size_bytes = dest.stat().st_size
+            result = ConvertResult(
+                src=src,
+                dest=dest,
+                width=spec.width if spec.width > 0 else "original",
+                size_bytes=size_bytes,
+            )
+
+            _log(cfg, f"  → {dest}  ({size_bytes / 1024:.1f} KB)")
+
+            if cfg.on_file:
+                cfg.on_file(result)
+
+            results.append(result)
+
+    return results
+
+
+# ─── Directory conversion ─────────────────────────────────────────────────────
+
+def convert_dir(input_dir: Union[str, Path], cfg: Optional[ConvertConfig] = None) -> List[ConvertResult]:
+    """
+    Convert all matching images in a directory.
+    """
+    cfg = cfg or ConvertConfig()
+    input_dir = Path(input_dir)
+    all_results: List[ConvertResult] = []
+
+    pattern = "**/*" if cfg.recursive else "*"
+    for path in input_dir.glob(pattern):
+        if not path.is_file():
+            continue
+        if path.suffix.lower() not in cfg.extensions:
+            continue
+        if path.suffix.lower() == ".webp":
+            continue
+
+        _log(cfg, f"processing {path}")
+        try:
+            results = convert_file(path, cfg)
+            all_results.extend(results)
+        except Exception as exc:
+            print(f"  error: {path}: {exc}")
+
+    return all_results
+
+
+# ─── Batch (multi-dir) ────────────────────────────────────────────────────────
+
+def convert(cfg: Optional[ConvertConfig] = None, **kwargs) -> List[ConvertResult]:
+    """
+    Main entry point. Convert all images in one or more input directories.
+
+    Can be called with a ConvertConfig object or keyword arguments::
+
+        # Using a config object
+        from webp_convert import convert, ConvertConfig
+        results = convert(ConvertConfig(input="src/images", quality=85))
+
+        # Using keyword args (creates a ConvertConfig internally)
+        results = convert(input="src/images", quality=85)
+    """
+    if cfg is None:
+        cfg = ConvertConfig(**kwargs)
+    elif kwargs:
+        # Merge kwargs into a copy of cfg
+        cfg_dict = cfg.__dict__.copy()
+        cfg_dict.update(kwargs)
+        cfg = ConvertConfig(**cfg_dict)
+
+    inputs = cfg.input if isinstance(cfg.input, list) else [cfg.input]
+    all_results: List[ConvertResult] = []
+
+    _log(cfg, "\n webp-convert — starting...\n")
+
+    for d in inputs:
+        results = convert_dir(d, cfg)
+        all_results.extend(results)
+
+    _log(cfg, f"\n ✓ done — converted {len(all_results)} file(s)")
+
+    if cfg.on_done:
+        cfg.on_done(all_results)
+
+    return all_results

webp_convert-1.0.0/webp_convert/watcher.py

@@ -0,0 +1,102 @@
+"""
+webp_convert.watcher
+File watching support using watchdog.
+"""
+
+from __future__ import annotations
+
+import time
+from pathlib import Path
+from typing import Optional, Union, List
+
+from watchdog.events import FileSystemEventHandler, FileCreatedEvent, FileModifiedEvent
+from watchdog.observers import Observer
+
+from .converter import ConvertConfig, convert_file
+
+
+class _ImageEventHandler(FileSystemEventHandler):
+    def __init__(self, cfg: ConvertConfig):
+        self.cfg = cfg
+
+    def _handle(self, src_path: str):
+        path = Path(src_path)
+        if path.suffix.lower() not in self.cfg.extensions:
+            return
+        if path.suffix.lower() == ".webp":
+            return
+        if not self.cfg.silent:
+            print(f"\n changed: {path}")
+        try:
+            convert_file(path, self.cfg)
+        except Exception as exc:
+            print(f"  error: {exc}")
+
+    def on_created(self, event):
+        if not event.is_directory:
+            self._handle(event.src_path)
+
+    def on_modified(self, event):
+        if not event.is_directory:
+            self._handle(event.src_path)
+
+
+class Watcher:
+    """
+    Wraps a watchdog Observer. Call .start() to begin watching, .stop() to end.
+    The context manager interface handles start/stop automatically.
+    """
+
+    def __init__(self, cfg: ConvertConfig):
+        self.cfg = cfg
+        self._observer = Observer()
+        inputs = cfg.input if isinstance(cfg.input, list) else [cfg.input]
+        handler = _ImageEventHandler(cfg)
+        for d in inputs:
+            self._observer.schedule(handler, str(d), recursive=cfg.recursive)
+
+    def start(self):
+        self._observer.start()
+        if not self.cfg.silent:
+            inputs = self.cfg.input if isinstance(self.cfg.input, list) else [self.cfg.input]
+            print("\n webp-convert — watching...")
+            for d in inputs:
+                print(f"  watching: {d}")
+        return self
+
+    def stop(self):
+        self._observer.stop()
+        self._observer.join()
+
+    def __enter__(self):
+        return self.start()
+
+    def __exit__(self, *_):
+        self.stop()
+
+
+def watch(cfg: Optional[ConvertConfig] = None, **kwargs) -> Watcher:
+    """
+    Watch input directories and auto-convert images on change.
+    Returns a Watcher instance. Call .start() to begin (or use as context manager).
+
+    Example::
+
+        from webp_convert import watch, ConvertConfig
+
+        # Context manager (blocks until Ctrl-C)
+        with watch(ConvertConfig(input="src/images")).start():
+            try:
+                while True:
+                    import time; time.sleep(1)
+            except KeyboardInterrupt:
+                pass
+
+        # Manual control
+        watcher = watch(input="src/images").start()
+        # ... later:
+        watcher.stop()
+    """
+    if cfg is None:
+        cfg = ConvertConfig(**kwargs)
+    return Watcher(cfg)

webp_convert-1.0.0/webp_convert.egg-info/PKG-INFO

@@ -0,0 +1,148 @@
+Metadata-Version: 2.4
+Name: webp-convert
+Version: 1.0.0
+Summary: Automatically convert PNG/JPG images to WebP with responsive sizes. CLI, file watcher, and Python API.
+License: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: Pillow>=10.0.0
+Requires-Dist: watchdog>=4.0.0
+Requires-Dist: click>=8.1.0
+Requires-Dist: rich>=13.0.0
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+
+# webp-convert (Python)
+
+> Automatically convert PNG/JPG/GIF/TIFF images to WebP with responsive size variants.
+> Zero-config CLI, file watcher, and programmatic Python API.
+
+---
+
+## Install
+
+```bash
+pip3 install webp-convert
+```
+
+Requires Python 3.8+. Uses [Pillow](https://pillow.readthedocs.io/) — no external binaries required.
+
+---
+
+## Quick start
+
+```bash
+# Convert everything in assets/images (default)
+webp-convert
+
+# Custom dir + quality
+webp-convert src/img -q 90
+
+# Watch mode — auto-converts on file change
+webp-convert src/img --watch
+
+# Custom responsive sizes
+webp-convert src/img --sizes 1200,800,400
+
+# Write outputs to a separate directory
+webp-convert src/img -o dist/img
+```
+
+---
+
+## CLI reference
+
+```
+Usage: webp-convert [INPUT_DIR] [OPTIONS]
+
+  Convert PNG/JPG images to WebP with responsive size variants.
+
+Options:
+  -o, --output TEXT       Output directory (default: same as source)
+  -q, --quality INT       WebP quality 0-100  [default: 80]
+      --lossless          Lossless encoding
+      --sizes W,W,...     Responsive widths e.g. 1200,800,400 (0=full)
+      --no-full           Skip full-size, only responsive variants
+  -r, --recursive         Recurse into subdirectories
+      --no-overwrite      Skip files that already have a .webp counterpart
+  -w, --watch             Watch mode
+      --silent            Suppress all output
+  -h, --help              Show this message and exit
+```
+
+---
+
+## Programmatic API
+
+```python
+from webp_convert import convert, watch, convert_file, ConvertConfig, SizeSpec
+
+# --- Convert a directory (keyword args shortcut) ---
+results = convert(input="src/images", quality=85)
+
+# --- Convert with a config object ---
+cfg = ConvertConfig(
+    input="src/images",
+    output="public/images",  # omit to write next to originals
+    quality=85,
+    lossless=False,
+    recursive=True,
+    overwrite=True,
+    sizes=[
+        SizeSpec(width=0,    suffix=""),       # full size
+        SizeSpec(width=1200, suffix="-1200"),
+        SizeSpec(width=800,  suffix="-800"),
+        SizeSpec(width=400,  suffix="-400"),
+    ],
+    on_file=lambda r: print(f"{r.src} → {r.dest} ({r.size_bytes} bytes)"),
+)
+results = convert(cfg)
+
+# --- Convert a single file ---
+results = convert_file("hero.png", cfg)
+
+# --- Watch mode (context manager) ---
+import time
+watcher = watch(ConvertConfig(input="src/images")).start()
+try:
+    while True:
+        time.sleep(1)
+except KeyboardInterrupt:
+    watcher.stop()
+```
+
+---
+
+## Output structure
+
+Given `hero.jpg` in `src/images/`:
+
+```
+src/images/
+├── hero.jpg          (original, kept by default)
+├── hero.webp         (full size)
+├── hero-800.webp     (800px wide, aspect-ratio preserved)
+└── hero-400.webp     (400px wide)
+```
+
+---
+
+## HTML usage
+
+```html
+<picture>
+  <source
+    type="image/webp"
+    srcset="hero-400.webp 400w, hero-800.webp 800w, hero.webp 1600w"
+    sizes="(max-width: 400px) 400px, (max-width: 800px) 800px, 1600px"
+  />
+  <img src="hero.jpg" alt="Hero image" />
+</picture>
+```
+
+---
+
+## License
+
+MIT

webp_convert-1.0.0/webp_convert.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+MANIFEST.in
+README.md
+pyproject.toml
+webp_convert/__init__.py
+webp_convert/cli.py
+webp_convert/converter.py
+webp_convert/watcher.py
+webp_convert.egg-info/PKG-INFO
+webp_convert.egg-info/SOURCES.txt
+webp_convert.egg-info/dependency_links.txt
+webp_convert.egg-info/entry_points.txt
+webp_convert.egg-info/requires.txt
+webp_convert.egg-info/top_level.txt

webp_convert-1.0.0/webp_convert.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

webp_convert-1.0.0/webp_convert.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+webp-convert = webp_convert.cli:main

webp_convert-1.0.0/webp_convert.egg-info/requires.txt

@@ -0,0 +1,8 @@
+Pillow>=10.0.0
+watchdog>=4.0.0
+click>=8.1.0
+rich>=13.0.0
+
+[dev]
+pytest
+pytest-asyncio

webp_convert-1.0.0/webp_convert.egg-info/top_level.txt

@@ -0,0 +1 @@
+webp_convert