Neue Sturktur

README.md

@@ -1,37 +1,47 @@
+
 # PPTX Image Compressor (CaesiumCLT only)
 **Version 1.0.0**
 
-Ein CLI‑Tool, das **PPTX-Dateien** entpackt, alle Bilder in `ppt/media` mit **CaesiumCLT** komprimiert und anschließend wieder zu einer PPTX packt.  
-Es ersetzt nur dann Bilder, **wenn die komprimierte Version kleiner ist**, schreibt ein **CSV-Log** und zeigt eine **Fortschrittsanzeige** sowie eine **Summary inkl. Laufzeit** an.
+Dieses Paket enthält:
 
----
-
-## Features
-- **Nur CaesiumCLT** als Bildkompressor (keine Pillow-Abhängigkeit).
-- Unterstützte Bildtypen: **JPG/JPEG, PNG, WebP** (GIF wird übersprungen).
-- **Overwrite-Policy:** `-O bigger` (nur überschreiben, wenn Ziel größer ist).
-- **Multi-Threading**: Parallele Bildverarbeitung.
-- **Log** (`.log` neben der Output-Datei) mit:  
-  `image_name,size_before,size_after,saving,saving_percent`.
-- **Sauberes Cleanup**: Keine Caesium-Tempdateien in der finalen PPTX.
-
----
-
-## Systemvoraussetzungen
-- **Windows 10/11 (64-bit)**
-- **Keine Admin-Rechte erforderlich**
-- **CaesiumCLT** (portabler Download)
-- **Python** (portabel, ohne Installation) **oder** fertige EXE
-
----
-
-## Installation & Setup
-
-### 1) CaesiumCLT installieren
-1. Lade **CaesiumCLT** von GitHub herunter:  
-   [https://github.com/Lymphatus/caesium-clt/releases](https://github.com/Lymphatus/caesium-clt)
-2. Entpacke `caesiumclt.exe` in einen Ordner, z. B. `C:\Tools\caesiumclt`.
-3. Füge den Ordner temporär zum PATH hinzu (optional):  
-   ```bat
-   set PATH=C:\Tools\caesiumclt;%PATH%
 ```
+PPTX-Image-Compressor-1.0.0/
+├─ README.md
+├─ install_and_run.bat
+├─ pptx_image_compress.py
+├─ bin/
+│  └─ PUT_caesiumclt_here.txt
+└─ samples/
+   └─ README.txt
+```
+
+## Schnellstart (ohne Admin-Rechte)
+1) Lege `caesiumclt.exe` in den Ordner `bin/` **oder** sorge dafür, dass es im `PATH` liegt.
+2) Doppelklicke `install_and_run.bat` **oder** rufe es in CMD/PowerShell auf, z. B.:
+
+```bat
+install_and_run.bat -i "C:\Slides\Deck.pptx" -t 8
+```
+
+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`)
+- 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)
+- Räumt alle temporären Dateien auf (keine Caesium‑Tempfiles in der finalen PPTX)
+
+## 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.
+
+## Manuelle Nutzung des .py (falls Python vorhanden)
+```bat
+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

bin/PUT_caesiumclt_here.txt

@@ -0,0 +1 @@
+Place caesiumclt.exe in this folder or ensure it is available on PATH.

install_and_run.bat

@@ -1,3 +1,4 @@
+
 @echo off
 setlocal EnableExtensions EnableDelayedExpansion
 
@@ -29,7 +30,7 @@ if exist "%SELF_DIR%%CAE_EXE%" (
     where /q %CAE_EXE%
     if errorlevel 1 (
         echo [ERROR] ^> 'caesiumclt.exe' nicht gefunden.
-        echo         Lege 'caesiumclt.exe' neben diese BAT ^(empfohlen^)
+        echo         Lege 'caesiumclt.exe' neben diese BAT (empfohlen)
         echo         oder sorge dafuer, dass es im PATH liegt.
         exit /b 2
     )
@@ -89,7 +90,7 @@ if not defined PY_CMD (
     exit /b 5
 )
 
-rem ---- Optional: 'import site' im Embeddable aktivieren (freundlich fuer spaetere Erweiterungen) ----
+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"
@@ -111,7 +112,6 @@ echo.
 echo [%APP_NAME%] Starte ...
 echo Command: "%PY_CMD%" "%SCRIPT%" %*
 echo.
-
 "%PY_CMD%" "%SCRIPT%" %*
 set "RC=%ERRORLEVEL%"
 

pptx_image_compress.py

@@ -28,21 +28,16 @@ from datetime import timedelta
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from threading import Lock
 
-# -------------------- Version --------------------
 __version__ = "1.0.0"
 
-# -------------------- Konfiguration --------------------
-ALLOWED_EXT = {".jpg", ".jpeg", ".png", ".webp", ".gif"}  # GIF wird übersprungen
-CAESIUM_QUALITY = 90  # -q 90
+ALLOWED_EXT = {".jpg", ".jpeg", ".png", ".webp", ".gif"}
+CAESIUM_QUALITY = 90
 PROGRESS_BAR_LEN = 40
 TEMP_PREFIX = "pptx_compress_"
 
-
-# -------------------- Utilities --------------------
 def human_mb(nbytes: int) -> float:
     return round(nbytes / (1024 * 1024), 2)
 
-
 def ensure_clean_file(path: Path):
     if path.exists():
         try:
@@ -53,7 +48,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,15 +59,13 @@ def cleanup_old_temps():
         except Exception:
             pass
 
-
 def print_progress(i: int, total: int):
     if total <= 0:
         return
     done = int(PROGRESS_BAR_LEN * i / total)
     bar = "█" * done + "-" * (PROGRESS_BAR_LEN - done)
     pct = int(i * 100 / total)
-    print(f"\rBilder: |{bar}| {i}/{total} ({pct}%)", end="", flush=True)
-
+    print(f"
 Bilder: |{bar}| {i}/{total} ({pct}%)", end="", flush=True)
 
 def zip_dir_to_pptx(src_dir: Path, out_pptx: Path):
@@ -83,53 +75,37 @@ def zip_dir_to_pptx(src_dir: Path, out_pptx: Path):
                 full = Path(root) / f
                 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)
-
 
-    """
-    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) -> Path | None:
     exe = which("caesiumclt")
-        raise RuntimeError(
-            "❌ 'caesiumclt' wurde nicht gefunden. Bitte CaesiumCLT installieren und in PATH verfügbar machen."
-        )
-
+    if not exe:
         raise RuntimeError("❌ 'caesiumclt' wurde nicht gefunden. Bitte CaesiumCLT installieren und in PATH verfügbar machen.")
-
-    # Nur Formate an Caesium geben, die es unterstützt: JPG/JPEG, PNG, WEBP
     out_dir.mkdir(parents=True, exist_ok=True)
     ext = original.suffix.lower()
-        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),
-    ]
+    if ext not in {".jpg", ".jpeg", ".png", ".webp"}:
+        return None
     cmd = [exe, "-q", str(CAESIUM_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)
-            sys.stderr.write(f"\n[caesiumclt] Fehler bei {original.name}:\n{r.stderr}\n")
+        if r.returncode != 0:
+            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
-        sys.stderr.write(f"\n[caesiumclt] Ausnahme bei {original.name}: {ex}\n")
+    except Exception as ex:
+        sys.stderr.write(f"
+[caesiumclt] Ausnahme bei {original.name}: {ex}
 ")
         return None
-
 
 def format_duration(seconds: float) -> str:
     total_ms = int(round(seconds * 1000))
@@ -139,27 +115,14 @@ def format_duration(seconds: float) -> str:
         hms, frac = base.split(".", 1)
         return f"{hms}.{frac[:2]}"
     return base
-
 
 def main():
     start_time = time.perf_counter()
-    parser = argparse.ArgumentParser(
-        description="PPTX Grafik-Komprimier-Tool (nur CaesiumCLT, Multi-Thread, sauberes Cleanup)",
-        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
-    )
+
     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(
-        "-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__}"
-    )
+    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()
@@ -172,28 +135,22 @@ def main():
     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")
+
     output_pptx = Path(args.output).resolve() if args.output else 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!)
+
+    work_dir = Path(tempfile.mkdtemp(prefix=TEMP_PREFIX + "work_"))
     scratch_dir = Path(tempfile.mkdtemp(prefix=TEMP_PREFIX + "scratch_"))
-    # Logdatei neben Output
 
     log_file = output_pptx.with_suffix(".log")
-    log_lines = ["image_name,size_before,size_after,saving,saving_percent\n"]
+    ensure_clean_file(log_file)
+    log_lines = ["image_name,size_before,size_after,saving,saving_percent
 "]
 
     size_before = input_pptx.stat().st_size
 
-        # Entpacken
     try:
         with zipfile.ZipFile(input_pptx, "r") as z:
             z.extractall(work_dir)
@@ -208,15 +165,13 @@ def main():
         total = len(images)
         print(f"🔧 Finde Bilder in {media_dir} ... {total} Kandidaten")
         print_progress(0, total)
-        # Vorab prüfen, ob caesiumclt verfügbar ist
 
-            print("\n❌ 'caesiumclt' nicht gefunden. Bitte installieren und in PATH verfügbar machen.")
+        if not which("caesiumclt"):
+            print("
 ❌ '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 args.threads and args.threads > 1 else None
-        # Thread-sichere Fortschritts- & Log-Verwaltung
 
         lock = Lock()
         done_count = 0
@@ -224,52 +179,43 @@ def main():
         def worker(idx: int, img_path: Path):
             nonlocal done_count
             ext = img_path.suffix.lower()
-
-            # GIF überspringen
             orig_size = img_path.stat().st_size
             if ext == ".gif":
                 with lock:
-                    log_lines.append(f"{img_path.name},{orig_size},{orig_size},0,0.0\n")
+                    done_count += 1
+                    log_lines.append(f"{img_path.name},{orig_size},{orig_size},0,0.0
 ")
                     print_progress(done_count, total)
-
                 return
             chosen_size = orig_size
-                # Eigener Output-Unterordner pro Bild, um Kollisionen zu vermeiden
             try:
                 out_sub = scratch_dir / f"img_{idx:06d}"
-
                 caesium_out = compress_with_caesium(img_path, out_sub, caesium_threads)
                 if caesium_out and caesium_out.exists():
                     s = caesium_out.stat().st_size
-                        # kleineren ersetzen (atomar)
                     if s < orig_size:
                         tmp_target = img_path.with_suffix(img_path.suffix + ".tmp")
                         shutil.copy2(caesium_out, tmp_target)
                         tmp_target.replace(img_path)
-
                         chosen_size = s
-                chosen_size = orig_size  # Original beibehalten
-
+            except Exception:
                 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
-                    log_lines.append(f"{img_path.name},{orig_size},{chosen_size},{saving},{saving_percent}\n")
+                with lock:
+                    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:
                 futures = [ex.submit(worker, i, p) for i, p in enumerate(images, start=1)]
-                    pass  # Fortschritt wird im Worker gezeichnet
+                for _ in as_completed(futures):
                     pass
-        print()  # newline nach Progressbar
+
         print()
-        # --- Safety-Cleanup innerhalb des Arbeitsverzeichnisses ---
-        # 1) Entferne evtl. vorhandene caesium*-Ordner (aus alten Runs)
 
         for p in work_dir.rglob("*"):
             try:
@@ -277,7 +223,6 @@ def main():
                     shutil.rmtree(p, ignore_errors=True)
             except Exception:
                 pass
-        # 2) Lösche eventuelle .tmp-Dateien in ppt/media
 
         media_dir = work_dir / "ppt" / "media"
         if media_dir.exists():
@@ -287,24 +232,23 @@ def main():
                         f.unlink(missing_ok=True)
                     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
-        # Log schreiben
 
         try:
             with open(log_file, "w", encoding="utf-8") as f:
                 f.writelines(log_lines)
         except Exception:
-        # Summary
+            pass
 
         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
-        print("\n✅ Fertig!")
+
+        print("
 ✅ Fertig!")
         print("Summary")
         print("-------")
@@ -316,7 +260,6 @@ def main():
         print(f"Zeit benötigt:        {format_duration(elapsed)}")
         print(f"Log-Datei:            {log_file}")
 
-        # Aufräumen ALLER temporären Dateien/Ordner
     finally:
         try:
             shutil.rmtree(work_dir, ignore_errors=True)
@@ -325,9 +268,7 @@ def main():
         try:
             shutil.rmtree(scratch_dir, ignore_errors=True)
         except Exception:
-        # Zusätzlich: ältere Reste entfernen
             pass
         cleanup_old_temps()
-
 
 if __name__ == "__main__":

samples/README.txt

@@ -0,0 +1 @@
+Place your PPTX files here for testing, or use -i with a full path.