frank.conrads/pptx-image-compress
1
0
Fork 0
Code Actions Packages Activity

Compare commits

base: frank.conrads:1.0.0
Branches Tags
frank.conrads:main
frank.conrads:1.1.6 frank.conrads:1.1.5 frank.conrads:1.1.4 frank.conrads:1.1.3 frank.conrads:1.1.2 frank.conrads:1.0.0
..
compare: frank.conrads:1.1.2
Branches Tags
frank.conrads:main
frank.conrads:1.1.6 frank.conrads:1.1.5 frank.conrads:1.1.4 frank.conrads:1.1.3 frank.conrads:1.1.2 frank.conrads:1.0.0

3 Commits
1.0.0 ... 1.1.2

Author SHA1 Message Date
Frank Conrads
e6f2805ccb Remove Version in tree 2025-09-10 15:51:01 +02:00
Frank Conrads
f2c80d9b63 Version in Readme angepasst 2025-09-10 15:49:54 +02:00
Frank Conrads
7294486446 Vorbereitung Batch-Mode und Anpassung der Scripte und Readme 2025-09-10 15:46:25 +02:00
4 changed files with 296 additions and 202 deletions
Expand all files Collapse all files

3
.gitignore vendored Normal file
View File

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

18
README.md
View File

@@ -1,11 +1,11 @@
# PPTX Image Compressor (CaesiumCLT only)
**Version 1.0.0**
**Version 1.1.2**
Dieses Paket enthält:
```
PPTX-Image-Compressor-1.0.0/
PPTX-Image-Compressor/
├─ README.md
├─ install_and_run.bat
├─ pptx_image_compress.py
@@ -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

97
install_and_run.bat
View File

@@ -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 (
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' neben diese BAT (empfohlen)
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
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 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
)
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%.
)

344
pptx_image_compress.py
View File

@@ -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()
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,
}
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()
try:
if not input_pptx.exists() or input_pptx.suffix.lower() != ".pptx":
print("❌ Eingabedatei existiert nicht oder ist keine .pptx")
sys.exit(2)
raise ValueError("Eingabedatei existiert nicht oder ist keine .pptx")
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!)
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")
ensure_clean_file(log_file)
log_lines = ["image_name,size_before,size_after,saving,saving_percent\n"]
log_lines = ["image_name,size_before,size_after,saving,saving_percent"]
size_before = input_pptx.stat().st_size
result["size_before"] = size_before
try:
# Entpacken
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()