From 7294486446afacb543255403ebb3a08ab130cf5d Mon Sep 17 00:00:00 2001 From: Frank Conrads Date: Wed, 10 Sep 2025 15:46:25 +0200 Subject: [PATCH] Vorbereitung Batch-Mode und Anpassung der Scripte und Readme --- .gitignore | 3 + README.md | 16 +- install_and_run.bat | 111 ++++++------- pptx_image_compress.py | 364 +++++++++++++++++++++++++---------------- 4 files changed, 294 insertions(+), 200 deletions(-) create mode 100644 .gitignore diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..b450d13 --- /dev/null +++ b/.gitignore @@ -0,0 +1,3 @@ +python-3.*-embed-amd64.zip +python-embed/* +.vscode/launch.json diff --git a/README.md b/README.md index cb4be8e..f98cd50 100644 --- a/README.md +++ b/README.md @@ -18,15 +18,21 @@ PPTX-Image-Compressor-1.0.0/ ## Schnellstart (ohne Admin-Rechte) 1) Doppelklicke `install_and_run.bat` **oder** rufe es in CMD/PowerShell auf, z. B.: +**Single** ```bat -install_and_run.bat -i "C:\Slides\Deck.pptx" -t 8 +install_and_run.bat -i "C:\Slides\Deck.pptx" -t 8 -q 90 +``` +**Batch** +```bat +install_and_run.bat -i "C:\Slides\*.pptx" -O "C:\Slides\out" -t 8 -q 85 +install_and_run.bat --input-dir "C:\Slides" --recursive -O "C:\Slides\out" -q 80 ``` Die Batch lädt bei Bedarf automatisch das **Windows Embeddable Python Package**, entpackt es lokal und führt das Tool aus. ## Was das Tool macht - Entpackt die PPTX in einen Temp‑Ordner -- Komprimiert **JPG/JPEG, PNG, WebP** mit **CaesiumCLT** (`-q 90`, `-O bigger`) +- Komprimiert **JPG/JPEG, PNG, WebP** mit **CaesiumCLT** (Default `-q 90`, `-O bigger`) - Ersetzt Bilder nur, wenn die komprimierte Datei kleiner ist - Schreibt ein CSV‑Log (`.log` neben der Output‑PPTX) - Baut eine neue PPTX und zeigt eine Summary (Name, Größe vorher/nachher, Ersparnis %, Zeit) @@ -34,7 +40,9 @@ Die Batch lädt bei Bedarf automatisch das **Windows Embeddable Python Package** ## Hinweise - **GIF** wird übersprungen (keine Rekodierung). -- `-t` steuert die Parallelität (Python‑Threads); intern wird `caesiumclt --threads 1` gesetzt, sobald `-t > 1`, um Oversubscription zu vermeiden. +- `-t` steuert die Parallelität der Python‑Threads; intern wird `caesiumclt --threads 1` gesetzt, sobald `-t > 1`, um Oversubscription zu vermeiden. Default ist 16 +- `-q` steuert das Qualitätslevel; intern wird `caesiumclt -q` mit diesem Wert von `0..100` benutzt, Default ist 90 +- Die Batch **verwendet bevorzugt das Embeddable Python** neben der BAT; ansonsten sucht sie echte `python.exe`/`py.exe` im PATH, **ignoriert** aber die Microsoft‑Store‑Alias‑Pfade (`WindowsApps`). ## Manuelle Nutzung des .py (falls Python vorhanden) ```bat @@ -43,4 +51,4 @@ python pptx_image_compress.py -i "C:\Pfad\input.pptx" -t 8 ## Quellen & Tools - CaesiumCLT – Projekt/Downloads: https://github.com/Lymphatus/caesium-clt -- Windows Embeddable Python Package – Doku/Downloads: https://docs.python.org/3/using/windows.html +- Windows Embeddable Python Package – Doku/Downloads: https://docs.python.org/3/using/windows.html \ No newline at end of file diff --git a/install_and_run.bat b/install_and_run.bat index 0a22aa6..ad71bf0 100644 --- a/install_and_run.bat +++ b/install_and_run.bat @@ -3,77 +3,91 @@ setlocal EnableExtensions EnableDelayedExpansion rem ============================================ -rem PPTX Image Compressor - Installer/Runner -rem - No admin rights required -rem - Uses local CaesiumCLT and Python Embeddable -rem - Pass-through of all CLI args to the .py +rem PPTX Image Compressor - Installer/Runner (Batch-enabled) +rem Fix: caesiumclt.exe aus [ROOT]\bin; Python-Discovery ohne MS Store Alias rem ============================================ set "APP_NAME=PPTX Image Compressor" set "SELF_DIR=%~dp0" -set "BIN_DIR=%SELF_DIR%\bin\" set "SCRIPT=%SELF_DIR%pptx_image_compress.py" -rem ---- Python Embeddable config (adjust if needed) ---- -set "PY_EMBED_VERSION=3.11.9" +rem ---- Python Embeddable config ---- +set "PY_EMBED_VERSION=3.13.7" set "PY_EMBED_ZIP=python-%PY_EMBED_VERSION%-embed-amd64.zip" set "PY_EMBED_URL=https://www.python.org/ftp/python/%PY_EMBED_VERSION%/%PY_EMBED_ZIP%" set "PY_DIR=%SELF_DIR%python-embed" set "PY_EXE=%PY_DIR%\python.exe" -rem ---- CaesiumCLT discovery ---- +rem ---- CaesiumCLT discovery (prefer [ROOT]\bin) ---- +set "CAE_DIR=%SELF_DIR%bin" set "CAE_EXE=caesiumclt.exe" - -if exist "%BIN_DIR%%CAE_EXE%" ( - rem Prefer local caesiumclt.exe near the BAT - set "PATH=%BIN_DIR%;%PATH%" +if exist "%CAE_DIR%\%CAE_EXE%" ( + set "PATH=%CAE_DIR%;%PATH%" ) else ( - where /q %CAE_EXE% - if errorlevel 1 ( - echo [ERROR] ^> 'caesiumclt.exe' nicht gefunden. - echo Lege 'caesiumclt.exe' neben diese BAT (empfohlen) - echo oder sorge dafuer, dass es im PATH liegt. - exit /b 2 + if exist "%SELF_DIR%%CAE_EXE%" ( + set "PATH=%SELF_DIR%;%PATH%" + ) else ( + where /q %CAE_EXE% + if errorlevel 1 ( + echo [ERROR] ^> 'caesiumclt.exe' nicht gefunden. + echo Lege 'caesiumclt.exe' in '%CAE_DIR%' oder neben diese BAT, + echo oder sorge dafuer, dass es im PATH liegt. + exit /b 2 + ) ) ) -rem ---- Python discovery / installation ---- +rem ---- Determine ESC for ANSI (green check) ---- +for /f "delims=" %%A in ('echo prompt $E^| cmd') do set "ESC=%%A" + +rem ---- Python discovery (avoid MS Store alias) ---- set "PY_CMD=" +set "USE_PY_LAUNCHER=" -rem 1) existing python in PATH? -where /q python -if %errorlevel%==0 ( - for /f "delims=" %%P in ('where python 2^>nul') do ( - set "PY_CMD=%%P" - goto :have_python - ) -) - -rem 2) local embeddable python present? +rem 1) Prefer local embeddable first if exist "%PY_EXE%" ( set "PY_CMD=%PY_EXE%" goto :have_python ) -rem 3) download embeddable python locally -echo [INFO] Kein Python gefunden. Lade Embeddable Python %PY_EMBED_VERSION% ... -powershell -NoLogo -NoProfile -Command ^ - "try { Invoke-WebRequest -Uri '%PY_EMBED_URL%' -OutFile '%SELF_DIR%%PY_EMBED_ZIP%' -UseBasicParsing; exit 0 } catch { Write-Error $_; exit 1 }" -if errorlevel 1 ( - echo [WARN] Automatischer Download fehlgeschlagen. - echo Bitte lade die Datei manuell herunter: - echo %PY_EMBED_URL% - echo und speichere sie als: - echo %SELF_DIR%%PY_EMBED_ZIP% - pause +rem 2) Real python.exe in PATH (exclude WindowsApps alias) +for /f "delims=" %%P in ('where python.exe 2^>nul') do ( + echo %%P | find /I "WindowsApps" >nul + if errorlevel 1 ( + set "PY_CMD=%%P" + goto :have_python + ) +) +for /f "delims=" %%P in ('where python3.exe 2^>nul') do ( + echo %%P | find /I "WindowsApps" >nul + if errorlevel 1 ( + set "PY_CMD=%%P" + goto :have_python + ) ) +rem 3) Python launcher py.exe (exclude WindowsApps) +for /f "delims=" %%P in ('where py.exe 2^>nul') do ( + echo %%P | find /I "WindowsApps" >nul + if errorlevel 1 ( + set "PY_CMD=%%P" + set "USE_PY_LAUNCHER=1" + goto :have_python + ) +) + +rem 4) Download embeddable locally +if not exist "%SELF_DIR%%PY_EMBED_ZIP%" ( + echo [INFO] Kein Python gefunden. Lade Embeddable Python %PY_EMBED_VERSION% ... + powershell -NoLogo -NoProfile -Command ^ + "try { Invoke-WebRequest -Uri '%PY_EMBED_URL%' -OutFile '%SELF_DIR%%PY_EMBED_ZIP%' -UseBasicParsing; exit 0 } catch { Write-Error $_; exit 1 }" +) if not exist "%SELF_DIR%%PY_EMBED_ZIP%" ( echo [ERROR] Embeddable-Python ZIP nicht vorhanden. Abbruch. exit /b 3 ) -echo [INFO] Entpacke Embeddable Python nach "%PY_DIR%" ... +echo [INFO] Entpacke nach "%PY_DIR%" ... if exist "%PY_DIR%" rmdir /s /q "%PY_DIR%" mkdir "%PY_DIR%" >nul 2>&1 powershell -NoLogo -NoProfile -Command ^ @@ -82,7 +96,6 @@ if errorlevel 1 ( echo [ERROR] Konnte ZIP nicht entpacken. Abbruch. exit /b 4 ) - set "PY_CMD=%PY_EXE%" :have_python @@ -91,21 +104,9 @@ if not defined PY_CMD ( exit /b 5 ) -rem ---- Optional: 'import site' im Embeddable aktivieren ---- -if exist "%PY_DIR%" ( - for /f "delims=" %%F in ('dir /b "%PY_DIR%\python3*.pth" 2^>nul') do ( - set "PTH_FILE=%PY_DIR%\%%F" - ) - if defined PTH_FILE ( - powershell -NoLogo -NoProfile -Command ^ - "(Get-Content -Raw '%PTH_FILE%') -replace '^\s*#\s*import site','import site' | Set-Content -Encoding ASCII '%PTH_FILE%'" - ) -) - rem ---- Verify script presence ---- if not exist "%SCRIPT%" ( echo [ERROR] Script nicht gefunden: "%SCRIPT%" - echo Lege 'pptx_image_compress.py' neben diese BAT. exit /b 6 ) @@ -118,7 +119,7 @@ set "RC=%ERRORLEVEL%" echo. if "%RC%"=="0" ( - echo [OK] Fertig. + echo Fertig. ) else ( echo [ERROR] Prozess endete mit Code %RC%. ) diff --git a/pptx_image_compress.py b/pptx_image_compress.py index d5e628d..1bb4cea 100644 --- a/pptx_image_compress.py +++ b/pptx_image_compress.py @@ -1,8 +1,9 @@ #!/usr/bin/env python3 # -*- coding: utf-8 -*- """ -PPTX Grafik-Komprimier-Tool (nur CaesiumCLT, Multi-Thread, sauberes Cleanup) -Version: 1.0.0 +PPTX Grafik-Komprimier-Tool (nur CaesiumCLT, Multi-Thread, Batch, sauberes Cleanup) +Version: 1.1.2 + Highlights: - Caesium-Scratch außerhalb des PPTX-Arbeitsverzeichnisses -> keine Tempfiles in finaler PPTX @@ -11,8 +12,9 @@ Highlights: - Log: image_name,size_before,size_after,saving,saving_percent - Summary inkl. Zeit benötigt -Benutzung: - python pptx_image_compress.py -i input.pptx [-o output.pptx] [-t THREADS] [--version] +Änderungen in 1.1.2: +- Batch Mode hinzugefügt +- Shellscript-Fix (Store-Alias vermeiden) und Doku-Anpassungen """ import argparse @@ -23,17 +25,16 @@ import tempfile import shutil import subprocess import time +import fnmatch +from glob import glob from pathlib import Path from datetime import timedelta from concurrent.futures import ThreadPoolExecutor, as_completed from threading import Lock -# -------------------- Version -------------------- -__version__ = "1.0.0" +__version__ = "1.1.2" -# -------------------- Konfiguration -------------------- ALLOWED_EXT = {".jpg", ".jpeg", ".png", ".webp", ".gif"} # GIF wird übersprungen -CAESIUM_QUALITY = 90 # -q 90 PROGRESS_BAR_LEN = 40 TEMP_PREFIX = "pptx_compress_" @@ -42,7 +43,6 @@ TEMP_PREFIX = "pptx_compress_" def human_mb(nbytes: int) -> float: return round(nbytes / (1024 * 1024), 2) - def ensure_clean_file(path: Path): if path.exists(): try: @@ -53,7 +53,6 @@ def ensure_clean_file(path: Path): except Exception: pass - def cleanup_old_temps(): tmp_root = Path(tempfile.gettempdir()) for p in tmp_root.glob(f"{TEMP_PREFIX}*"): @@ -65,7 +64,6 @@ def cleanup_old_temps(): except Exception: pass - def print_progress(i: int, total: int): if total <= 0: return @@ -74,7 +72,6 @@ def print_progress(i: int, total: int): pct = int(i * 100 / total) print(f"\rBilder: |{bar}| {i}/{total} ({pct}%)", end="", flush=True) - def zip_dir_to_pptx(src_dir: Path, out_pptx: Path): with zipfile.ZipFile(out_pptx, "w", compression=zipfile.ZIP_DEFLATED) as z: for root, _, files in os.walk(src_dir): @@ -83,53 +80,32 @@ def zip_dir_to_pptx(src_dir: Path, out_pptx: Path): rel = full.relative_to(src_dir) z.write(full, arcname=str(rel)) - -def which(cmd: str) -> str | None: +def which(cmd: str): return shutil.which(cmd) - -def compress_with_caesium(original: Path, out_dir: Path, caesium_threads: int | None) -> Path | None: - """ - Ruft caesiumclt auf, um eine komprimierte Version zu erzeugen. - Output wird ins out_dir geschrieben (gleicher Filename). - Gibt Pfad zur erzeugten Datei zurück oder None bei Fehler. - """ +def compress_with_caesium(original: Path, out_dir: Path, caesium_threads: int | None, quality: int) -> Path | None: exe = which("caesiumclt") if not exe: - raise RuntimeError( - "❌ 'caesiumclt' wurde nicht gefunden. Bitte CaesiumCLT installieren und in PATH verfügbar machen." - ) - + raise RuntimeError("❌ 'caesiumclt' wurde nicht gefunden. Bitte CaesiumCLT installieren und in PATH verfügbar machen.") out_dir.mkdir(parents=True, exist_ok=True) - - # Nur Formate an Caesium geben, die es unterstützt: JPG/JPEG, PNG, WEBP ext = original.suffix.lower() if ext not in {".jpg", ".jpeg", ".png", ".webp"}: - return None # GIF & andere werden übersprungen - - cmd = [ - exe, - "-q", str(CAESIUM_QUALITY), - "-O", "bigger", # <<< nur überschreiben, wenn Ziel größer ist - "-o", str(out_dir), - ] + return None + cmd = [exe, "-q", str(quality), "-O", "bigger", "-o", str(out_dir)] if caesium_threads is not None: cmd += ["--threads", str(caesium_threads)] cmd += [str(original)] - try: r = subprocess.run(cmd, capture_output=True, text=True) if r.returncode != 0: - sys.stderr.write(f"\n[caesiumclt] Fehler bei {original.name}:\n{r.stderr}\n") + sys.stderr.write(f"[caesiumclt] Fehler bei {original.name}:{r.stderr}") return None - out_file = out_dir / original.name return out_file if out_file.exists() else None except Exception as ex: - sys.stderr.write(f"\n[caesiumclt] Ausnahme bei {original.name}: {ex}\n") + sys.stderr.write(f"[caesiumclt] Ausnahme bei {original.name}: {ex}") return None - def format_duration(seconds: float) -> str: total_ms = int(round(seconds * 1000)) td = timedelta(milliseconds=total_ms) @@ -139,61 +115,37 @@ def format_duration(seconds: float) -> str: return f"{hms}.{frac[:2]}" return base - -def main(): +# -------------------- Core per-deck processing -------------------- +def process_single_deck(input_pptx: Path, output_pptx: Path, threads: int, quality: int) -> dict: start_time = time.perf_counter() - - parser = argparse.ArgumentParser( - description="PPTX Grafik-Komprimier-Tool (nur CaesiumCLT, Multi-Thread, sauberes Cleanup)", - formatter_class=argparse.ArgumentDefaultsHelpFormatter, - ) - parser.add_argument("-i", "--input", help="Input-PPTX", required=False) - parser.add_argument("-o", "--output", help="Output-PPTX", required=False) - parser.add_argument( - "-t", "--threads", - type=int, - default=min(32, os.cpu_count() or 4), - help="Anzahl paralleler Threads für die Bildverarbeitung" - ) - parser.add_argument( - "--version", - action="version", - version=f"%(prog)s {__version__}" - ) - - args = parser.parse_args() - - if not args.input: - parser.print_help() - sys.exit(1) - - input_pptx = Path(args.input).resolve() - if not input_pptx.exists() or input_pptx.suffix.lower() != ".pptx": - print("❌ Eingabedatei existiert nicht oder ist keine .pptx") - sys.exit(2) - - if args.output: - output_pptx = Path(args.output).resolve() - else: - output_pptx = input_pptx.with_name(f"{input_pptx.stem}_compressed.pptx") - - # Vorherige Temp-Files & existierendes Output löschen - cleanup_old_temps() - ensure_clean_file(output_pptx) - - # --- Zwei getrennte Temp-Verzeichnisse --- - work_dir = Path(tempfile.mkdtemp(prefix=TEMP_PREFIX + "work_")) # entpackte PPTX - scratch_dir = Path(tempfile.mkdtemp(prefix=TEMP_PREFIX + "scratch_")) # Caesium-Ausgaben (außerhalb!) - - # Logdatei neben Output - log_file = output_pptx.with_suffix(".log") - ensure_clean_file(log_file) - log_lines = ["image_name,size_before,size_after,saving,saving_percent\n"] - - size_before = input_pptx.stat().st_size + result = { + "input": str(input_pptx), + "output": str(output_pptx), + "ok": False, + "size_before": 0, + "size_after": 0, + "elapsed_sec": 0.0, + "error": None, + "log_file": None, + } try: - # Entpacken + if not input_pptx.exists() or input_pptx.suffix.lower() != ".pptx": + raise ValueError("Eingabedatei existiert nicht oder ist keine .pptx") + + cleanup_old_temps() + ensure_clean_file(output_pptx) + + work_dir = Path(tempfile.mkdtemp(prefix=TEMP_PREFIX + "work_")) + scratch_dir = Path(tempfile.mkdtemp(prefix=TEMP_PREFIX + "scratch_")) + + log_file = output_pptx.with_suffix(".log") + ensure_clean_file(log_file) + log_lines = ["image_name,size_before,size_after,saving,saving_percent"] + + size_before = input_pptx.stat().st_size + result["size_before"] = size_before + with zipfile.ZipFile(input_pptx, "r") as z: z.extractall(work_dir) @@ -205,18 +157,13 @@ def main(): images.append(f) total = len(images) - print(f"🔧 Finde Bilder in {media_dir} ... {total} Kandidaten") + print(f"🔧 {input_pptx.name}: {total} Bild(er) gefunden") print_progress(0, total) - # Vorab prüfen, ob caesiumclt verfügbar ist if not which("caesiumclt"): - print("\n❌ 'caesiumclt' nicht gefunden. Bitte installieren und in PATH verfügbar machen.") - sys.exit(3) + raise RuntimeError("'caesiumclt' nicht gefunden. Bitte installieren und in PATH verfügbar machen.") - # Oversubscription vermeiden: viele Python-Threads -> caesium intern 1 Thread - caesium_threads = 1 if args.threads and args.threads > 1 else None - - # Thread-sichere Fortschritts- & Log-Verwaltung + caesium_threads = 1 if threads and threads > 1 else None lock = Lock() done_count = 0 @@ -224,52 +171,42 @@ def main(): nonlocal done_count ext = img_path.suffix.lower() orig_size = img_path.stat().st_size - - # GIF überspringen if ext == ".gif": with lock: done_count += 1 - log_lines.append(f"{img_path.name},{orig_size},{orig_size},0,0.0\n") + log_lines.append(f"{img_path.name},{orig_size},{orig_size},0,0.0") print_progress(done_count, total) return - chosen_size = orig_size try: - # Eigener Output-Unterordner pro Bild, um Kollisionen zu vermeiden out_sub = scratch_dir / f"img_{idx:06d}" - caesium_out = compress_with_caesium(img_path, out_sub, caesium_threads) - + caesium_out = compress_with_caesium(img_path, out_sub, caesium_threads, quality) if caesium_out and caesium_out.exists(): s = caesium_out.stat().st_size if s < orig_size: - # kleineren ersetzen (atomar) tmp_target = img_path.with_suffix(img_path.suffix + ".tmp") shutil.copy2(caesium_out, tmp_target) tmp_target.replace(img_path) chosen_size = s - except Exception: - chosen_size = orig_size # Original beibehalten - + chosen_size = orig_size finally: saving = orig_size - chosen_size saving_percent = round((saving / orig_size) * 100, 2) if orig_size > 0 else 0.0 with lock: - log_lines.append(f"{img_path.name},{orig_size},{chosen_size},{saving},{saving_percent}\n") + log_lines.append(f"{img_path.name},{orig_size},{chosen_size},{saving},{saving_percent}") done_count += 1 print_progress(done_count, total) - # Parallel ausführen if total > 0: - with ThreadPoolExecutor(max_workers=max(1, args.threads)) as ex: + with ThreadPoolExecutor(max_workers=max(1, threads)) as ex: futures = [ex.submit(worker, i, p) for i, p in enumerate(images, start=1)] for _ in as_completed(futures): - pass # Fortschritt wird im Worker gezeichnet + pass - print() # newline nach Progressbar + print() # newline - # --- Safety-Cleanup innerhalb des Arbeitsverzeichnisses --- - # 1) Entferne evtl. vorhandene caesium*-Ordner (aus alten Runs) + # Safety cleanup inside work_dir for p in work_dir.rglob("*"): try: if p.is_dir() and p.name.lower().startswith("caesium"): @@ -277,8 +214,6 @@ def main(): except Exception: pass - # 2) Lösche eventuelle .tmp-Dateien in ppt/media - media_dir = work_dir / "ppt" / "media" if media_dir.exists(): for f in media_dir.iterdir(): if f.is_file() and f.suffix.lower() == ".tmp": @@ -287,47 +222,194 @@ def main(): except Exception: pass - # Neue PPTX bauen (nur work_dir -> scratch_dir liegt außerhalb und ist damit sicher ausgeschlossen) zip_dir_to_pptx(work_dir, output_pptx) size_after = output_pptx.stat().st_size + result["size_after"] = size_after - # Log schreiben try: with open(log_file, "w", encoding="utf-8") as f: f.writelines(log_lines) except Exception: pass - # Summary - savings_pct = 0.0 - if size_before > 0: - savings_pct = round(100.0 * (size_before - size_after) / size_before, 2) elapsed = time.perf_counter() - start_time + result["elapsed_sec"] = elapsed + result["log_file"] = str(log_file) + result["ok"] = True - print("\n✅ Fertig!") - print("Summary") - print("-------") - print(f"Version: {__version__}") - print(f"Name: {output_pptx.name}") - print(f"Datei-Größe vorher: {human_mb(size_before)} MB") - print(f"Datei-Größe nachher: {human_mb(size_after)} MB") - print(f"Ersparnis: {savings_pct}%") - print(f"Zeit benötigt: {format_duration(elapsed)}") - print(f"Log-Datei: {log_file}") + savings_pct = 0.0 if size_before == 0 else round(100.0 * (size_before - size_after) / size_before, 2) + print(f"✅ Fertig! ({input_pptx.name})") + print("📋 Zusammenfassung ----------------") + print(" Vorher: ", human_mb(size_before), "MB") + print(" Nachher: ", human_mb(size_after), "MB") + print(" Ersparnis: ", f"{savings_pct}%") + print(" Zeit: ", format_duration(elapsed)) + print(" Log: ", log_file) + except Exception as e: + result["error"] = str(e) finally: - # Aufräumen ALLER temporären Dateien/Ordner try: - shutil.rmtree(work_dir, ignore_errors=True) + shutil.rmtree(work_dir, ignore_errors=True) # type: ignore[name-defined] except Exception: pass try: - shutil.rmtree(scratch_dir, ignore_errors=True) + shutil.rmtree(scratch_dir, ignore_errors=True) # type: ignore[name-defined] except Exception: pass - # Zusätzlich: ältere Reste entfernen cleanup_old_temps() + return result -if __name__ == "__main__": +# -------------------- Input helpers -------------------- +def expand_inputs(inputs: list[str]) -> list[Path]: + files: list[Path] = [] + for inp in inputs: + p = Path(inp) + if any(ch in inp for ch in ['*', '?']): + for g in glob(inp): + if g.lower().endswith('.pptx'): + files.append(Path(g).resolve()) + else: + if p.is_dir(): + for g in p.glob('*.pptx'): + files.append(g.resolve()) + else: + if p.suffix.lower() == '.pptx': + files.append(p.resolve()) + seen = set() + uniq = [] + for f in files: + if str(f) not in seen: + uniq.append(f) + seen.add(str(f)) + return uniq + + +def collect_from_dir(input_dir: Path, pattern: str, recursive: bool) -> list[Path]: + files: list[Path] = [] + if recursive: + for root, _, names in os.walk(input_dir): + for n in names: + if fnmatch.fnmatch(n, pattern): + p = Path(root) / n + if p.suffix.lower() == '.pptx': + files.append(p.resolve()) + else: + for p in input_dir.glob(pattern): + if p.suffix.lower() == '.pptx': + files.append(p.resolve()) + seen = set() + out = [] + for f in files: + s = str(f) + if s not in seen: + out.append(f) + seen.add(s) + return out + +# -------------------- CLI -------------------- +def main(): + parser = argparse.ArgumentParser( + description="PPTX Grafik-Komprimier-Tool (nur CaesiumCLT, Multi-Thread, Batch, sauberes Cleanup)", + formatter_class=argparse.ArgumentDefaultsHelpFormatter, + ) + parser.add_argument('-i','--input', nargs='*', help='Input-PPTX (eine oder mehrere, Wildcards erlaubt). Bei mehreren: -O erforderlich.') + parser.add_argument('-o','--output', help='Output-PPTX (nur Single-Mode)') + parser.add_argument('-O','--output-dir', help='Output-Verzeichnis (erforderlich für Batch)') + parser.add_argument('--input-dir', help='Eingabe-Verzeichnis (optional, für Batch)') + parser.add_argument('--pattern', default='*.pptx', help='Dateimuster für --input-dir') + parser.add_argument('--recursive', action='store_true', help='Rekursiv in --input-dir suchen') + #parser.add_argument('-t','--threads', type=int, default=min(32, os.cpu_count() or 4), help='Anzahl paralleler Threads pro Datei') + parser.add_argument('-t','--threads', type=int, default=16, help='Anzahl paralleler Threads pro Datei') + parser.add_argument('-q','--quality', type=int, default=90, help='Qualität für caesiumclt (0..100), höher = bessere Qualität / größere Datei') + parser.add_argument('--version', action='version', version=f'%(prog)s {__version__}') + + args = parser.parse_args() + + print("Threads used: ", args.threads," Threads") + + if args.quality < 0 or args.quality > 100: + print('❌ Ungültige Qualität. Erlaubt: 0..100') + sys.exit(1) + + input_files: list[Path] = [] + if args.input: + input_files.extend(expand_inputs(args.input)) + if args.input_dir: + input_files.extend(collect_from_dir(Path(args.input_dir), args.pattern, args.recursive)) + + if len(input_files) == 0: + parser.print_help() + sys.exit(1) + + batch_mode = len(input_files) > 1 + + if batch_mode and not args.output_dir: + print('❌ Batch-Modus erkannt. Bitte -O/--output-dir angeben.') + sys.exit(2) + + if not which('caesiumclt'): + print("❌ 'caesiumclt' nicht gefunden. Bitte installieren und in PATH verfügbar machen.") + sys.exit(3) + + overall_before = 0 + overall_after = 0 + successes = 0 + failures = 0 + + if batch_mode: + out_dir = Path(args.output_dir).resolve() + out_dir.mkdir(parents=True, exist_ok=True) + print(f"🗂️ Batch: {len(input_files)} Datei(en). Output-Verzeichnis: {out_dir}") + for src in input_files: + if not src.exists(): + print(f"- Übersprungen (nicht gefunden): {src}") + failures += 1 + continue + dst = out_dir / f"{src.stem}_compressed.pptx" + res = process_single_deck(src, dst, args.threads, args.quality) + if res['ok']: + successes += 1 + overall_before += res['size_before'] + overall_after += res['size_after'] + else: + failures += 1 + print(f" Fehler: {src.name} -> {res['error']}") + else: + src = input_files[0] + if args.output_dir: + Path(args.output_dir).mkdir(parents=True, exist_ok=True) + dst = Path(args.output_dir) / f"{src.stem}_compressed.pptx" + else: + dst = Path(args.output).resolve() if args.output else src.with_name(f"{src.stem}_compressed.pptx") + res = process_single_deck(src, dst, args.threads, args.quality) + if res['ok']: + successes += 1 + overall_before += res['size_before'] + overall_after += res['size_after'] + else: + failures += 1 + print(f" Fehler: {src.name} -> {res['error']}") + + if batch_mode: + + print(f"====== 📊 Gesamt-Summary ======") + print(f"✅ Dateien erfolgreich: {successes}") + + if failures > 0: + print(f"❌Dateien fehlgeschlagen: {failures}") + + if overall_before > 0: + pct = round(100.0 * (overall_before - overall_after) / overall_before, 2) + else: + pct = 0.0 + print(f"Gesamtgröße vorher: {human_mb(overall_before)} MB") + print(f"Gesamtgröße nachher: {human_mb(overall_after)} MB") + print(f"Gesamt-Ersparnis: {pct}%") + + + + +if __name__ == '__main__': main()