Version in Readme angepasst

.gitignore

@@ -0,0 +1,3 @@
+python-3.*-embed-amd64.zip
+python-embed/*
+.vscode/launch.json

README.md

@@ -1,6 +1,6 @@
 
 # PPTX Image Compressor (CaesiumCLT only)
-**Version 1.0.0**
+**Version 1.1.2**
 
 Dieses Paket enthält:
 
@@ -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

install_and_run.bat

@@ -3,77 +3,91 @@
 setlocal EnableExtensions EnableDelayedExpansion
 
 rem ============================================
-rem  PPTX Image Compressor - Installer/Runner
+rem  PPTX Image Compressor - Installer/Runner (Batch-enabled)
-rem  - No admin rights required
+rem  Fix: caesiumclt.exe aus [ROOT]\bin; Python-Discovery ohne MS Store Alias
-rem  - Uses local CaesiumCLT and Python Embeddable
-rem  - Pass-through of all CLI args to the .py
 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) ----
+rem ---- Python Embeddable config ----
-set "PY_EMBED_VERSION=3.11.9"
+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 "%CAE_DIR%\%CAE_EXE%" (
-if exist "%BIN_DIR%%CAE_EXE%" (
+    set "PATH=%CAE_DIR%;%PATH%"
-    rem Prefer local caesiumclt.exe near the BAT
-    set "PATH=%BIN_DIR%;%PATH%"
 ) else (
-    where /q %CAE_EXE%
+    if exist "%SELF_DIR%%CAE_EXE%" (
-    if errorlevel 1 (
+        set "PATH=%SELF_DIR%;%PATH%"
-        echo [ERROR] ^> 'caesiumclt.exe' nicht gefunden.
+    ) else (
-        echo         Lege 'caesiumclt.exe' neben diese BAT (empfohlen)
+        where /q %CAE_EXE%
-        echo         oder sorge dafuer, dass es im PATH liegt.
+        if errorlevel 1 (
-        exit /b 2
+            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?
+rem 1) Prefer local embeddable first
-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?
 if exist "%PY_EXE%" (
     set "PY_CMD=%PY_EXE%"
     goto :have_python
 )
 
-rem 3) download embeddable python locally
+rem 2) Real python.exe in PATH (exclude WindowsApps alias)
-echo [INFO] Kein Python gefunden. Lade Embeddable Python %PY_EMBED_VERSION% ...
+for /f "delims=" %%P in ('where python.exe 2^>nul') do (
-powershell -NoLogo -NoProfile -Command ^
+    echo %%P | find /I "WindowsApps" >nul
- "try { Invoke-WebRequest -Uri '%PY_EMBED_URL%' -OutFile '%SELF_DIR%%PY_EMBED_ZIP%' -UseBasicParsing; exit 0 } catch { Write-Error $_; exit 1 }"
+    if errorlevel 1 (
-if errorlevel 1 (
+        set "PY_CMD=%%P"
-    echo [WARN] Automatischer Download fehlgeschlagen.
+        goto :have_python
-    echo        Bitte lade die Datei manuell herunter:
+    )
-    echo        %PY_EMBED_URL%
+)
-    echo        und speichere sie als:
+for /f "delims=" %%P in ('where python3.exe 2^>nul') do (
-    echo        %SELF_DIR%%PY_EMBED_ZIP%
+    echo %%P | find /I "WindowsApps" >nul
-    pause
+    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%.
 )

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)
+PPTX Grafik-Komprimier-Tool (nur CaesiumCLT, Multi-Thread, Batch, sauberes Cleanup)
-Version: 1.0.0
+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:
+Änderungen in 1.1.2:
-    python pptx_image_compress.py -i input.pptx [-o output.pptx] [-t THREADS] [--version]
+- 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.1.2"
-__version__ = "1.0.0"
 
-# -------------------- 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):
-def which(cmd: str) -> str | None:
     return shutil.which(cmd)
 
-
+def compress_with_caesium(original: Path, out_dir: Path, caesium_threads: int | None, quality: int) -> Path | None:
-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.
-    """
     exe = which("caesiumclt")
     if not exe:
-        raise RuntimeError(
+        raise RuntimeError("❌ 'caesiumclt' wurde nicht gefunden. Bitte CaesiumCLT installieren und in PATH verfügbar machen.")
-            "❌ '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
+        return None
-
+    cmd = [exe, "-q", str(quality), "-O", "bigger", "-o", str(out_dir)]
-    cmd = [
-        exe,
-        "-q", str(CAESIUM_QUALITY),
-        "-O", "bigger",        # <<< nur überschreiben, wenn Ziel größer ist
-        "-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
 
-
+# -------------------- Core per-deck processing --------------------
-def main():
+def process_single_deck(input_pptx: Path, output_pptx: Path, threads: int, quality: int) -> dict:
     start_time = time.perf_counter()
-
+    result = {
-    parser = argparse.ArgumentParser(
+        "input": str(input_pptx),
-        description="PPTX Grafik-Komprimier-Tool (nur CaesiumCLT, Multi-Thread, sauberes Cleanup)",
+        "output": str(output_pptx),
-        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        "ok": False,
-    )
+        "size_before": 0,
-    parser.add_argument("-i", "--input", help="Input-PPTX", required=False)
+        "size_after": 0,
-    parser.add_argument("-o", "--output", help="Output-PPTX", required=False)
+        "elapsed_sec": 0.0,
-    parser.add_argument(
+        "error": None,
-        "-t", "--threads",
+        "log_file": None,
-        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
 
     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.")
+            raise RuntimeError("'caesiumclt' nicht gefunden. Bitte installieren und in PATH verfügbar machen.")
-            sys.exit(3)
 
-        # Oversubscription vermeiden: viele Python-Threads -> caesium intern 1 Thread
+        caesium_threads = 1 if threads and threads > 1 else None
-        caesium_threads = 1 if args.threads and args.threads > 1 else None
-
-        # Thread-sichere Fortschritts- & Log-Verwaltung
         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 ---
+        # Safety cleanup inside work_dir
-        # 1) Entferne evtl. vorhandene caesium*-Ordner (aus alten Runs)
         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!")
+        savings_pct = 0.0 if size_before == 0 else round(100.0 * (size_before - size_after) / size_before, 2)
-        print("Summary")
+        print(f"✅ Fertig!  ({input_pptx.name})")
-        print("-------")
+        print("📋 Zusammenfassung ----------------")
-        print(f"Version:              {__version__}")
+        print("  Vorher:    ", human_mb(size_before), "MB")
-        print(f"Name:                 {output_pptx.name}")
+        print("  Nachher:   ", human_mb(size_after), "MB")
-        print(f"Datei-Größe vorher:   {human_mb(size_before)} MB")
+        print("  Ersparnis: ", f"{savings_pct}%")
-        print(f"Datei-Größe nachher:  {human_mb(size_after)} MB")
+        print("  Zeit:      ", format_duration(elapsed))
-        print(f"Ersparnis:            {savings_pct}%")
+        print("  Log:       ", log_file)
-        print(f"Zeit benötigt:        {format_duration(elapsed)}")
-        print(f"Log-Datei:            {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()