build.bat: added upx minify for caesiumclt.exe

Remove unused svgo-client files while keeping bin/svgo-client/svgo.cmd runtime behavior intact.

Drop node_modules/.bin wrappers, TypeScript declaration files (*.d.ts), and obsolete svgo-cli.js wrapper script.

Co-Authored-By: Abacus.AI CLI <agent@abacus.ai>

.gitignore

@@ -4,3 +4,5 @@ python-embed/*
 logs/*.log
 __pycache__/*
 .coverage
+build/*
+dist/*

AGENTS.md

@@ -0,0 +1,236 @@
+# AGENTS.md — pptx-image-compress
+
+Guidelines for AI agents and contributors working in this codebase.
+
+---
+
+## Project Overview
+
+Single-file Python CLI tool (`pptx_image_compress.py`) that compresses images
+inside `.pptx` files using the external binary `caesiumclt`. Supports single-
+file and batch modes, multi-threaded processing, and CSV logging.
+
+**Entry point:** `pptx_image_compress.py` → `main()`  
+**Tests:** `test_pptx_image_compress.py` (stdlib `unittest`, run via `pytest`)  
+**External dependency:** `caesiumclt` must be on `PATH`
+
+---
+
+## Running Tests
+
+```bash
+python -m pytest test_pptx_image_compress.py -v
+```
+
+All 5 tests must pass before any change is considered complete.  
+Never remove or weaken an existing test. Always add a test for new behaviour.
+
+---
+
+## Code Readability
+
+- **One responsibility per function.** If a function does more than one thing,
+  split it.
+- **Descriptive names.** Avoid single-letter variables outside of short loops.
+  Prefer `img_path` over `p`, `result` over `r`.
+- **Type-annotate every function signature** — parameters and return type.
+  Use `Optional[X]` / `X | None` consistently (the codebase uses both; prefer
+  `X | None` for new code on Python 3.10+).
+- **Constants at module level**, UPPER_SNAKE_CASE. Never hardcode magic values
+  inline (e.g. file extensions, prefix strings, bar lengths).
+- **Section comments** (`# --- Section ---`) are used to separate logical
+  blocks. Keep them and add new ones when introducing a new logical group.
+- **German UI strings are intentional** (progress output, error messages shown
+  to the end-user). Keep them in German. Internal code identifiers stay in
+  English.
+- **No dead code.** Remove commented-out blocks and unused functions before
+  committing.
+
+---
+
+## Testability
+
+- **Inject external dependencies via callable parameters.** The `compressor`
+  parameter on `process_image_file` and `process_single_deck` is the canonical
+  pattern — always use it for any new external-process call.
+- **Never call `shutil.which` or `subprocess` directly inside a function under
+  test.** Route through an injectable or mockable seam.
+- **Tests use `tempfile.TemporaryDirectory`** for isolation. Every test must
+  clean up after itself — rely on the context manager, not `tearDown`.
+- **Do not test private implementation details.** Test observable behaviour:
+  return values, file contents, log output.
+- **One assertion focus per test.** A test named `test_X` should assert exactly
+  what `X` does, with a minimal setup.
+- **Use `fake_compressor` pattern** (as seen in existing tests) to decouple
+  image-compression logic from the real `caesiumclt` binary in all unit tests.
+
+---
+
+## Performance
+
+- **Thread pool sizing:** outer thread count is controlled by `-t/--threads`
+  (default 16). When `threads > 1`, each `caesiumclt` subprocess is launched
+  with `--threads 1` to prevent CPU over-subscription. Do not change this
+  without benchmarking.
+- **Scratch directories are per-image** (`img_{idx:06d}` sub-dirs) to avoid
+  filename collisions across threads without locking.
+- **`Lock` scope must be minimal.** Only counter increments and `log_lines`
+  appends are inside the lock — never I/O or subprocess calls.
+- **Avoid redundant filesystem walks.** `build_image_slide_index` is called
+  once per deck, not per image. Keep it that way.
+- **`zip_dir_to_pptx` collects all files before writing** so `[Content_Types].xml`
+  can be placed first. Do not revert this to a streaming walk.
+
+---
+
+## Architecture
+
+### Current state
+
+Single-file design (`pptx_image_compress.py`) is intentional for zero-install
+distribution. It is acceptable as long as the file stays under ~700 lines.
+
+### Target layout (clean architecture — migrate when the file grows)
+
+When the project needs to grow, extract to a package following these layers.
+Dependencies must only point **inward** (CLI → Application → Domain ←
+Infrastructure implements Domain ports).
+
+```
+pptx_compress/
+├── __init__.py
+├── __main__.py                  # python -m pptx_compress entry point
+│
+├── domain/                      # innermost — zero external imports
+│   ├── __init__.py
+│   ├── models.py                # DeckResult, ImageProcessResult (dataclasses)
+│   ├── constants.py             # ALLOWED_EXT, TEMP_PREFIX, defaults
+│   └── ports.py                 # Compressor Protocol (typing.Protocol), SlideIndex ABC
+│
+├── application/                 # orchestration — imports domain only
+│   ├── __init__.py
+│   ├── compress_deck.py         # process_single_deck() use-case
+│   └── batch.py                 # batch loop, overall summary logic
+│
+├── infrastructure/              # implements domain ports — imports domain + stdlib/3rd-party
+│   ├── __init__.py
+│   ├── caesium_adapter.py       # compress_with_caesium() (caesiumclt subprocess)
+│   ├── pptx_reader.py           # discover_images(), build_image_slide_index()
+│   ├── pptx_writer.py           # zip_dir_to_pptx()
+│   └── temp_manager.py          # cleanup_old_temps(), TEMP_PREFIX lifecycle
+│
+└── cli/                         # outermost — imports application only
+    ├── __init__.py
+    ├── args.py                  # argparse definition, expand_inputs(), collect_from_dir()
+    └── output.py                # print_progress(), format_duration(), human_mb/kb
+```
+
+### Layer rules
+
+| Layer | May import | Must NOT import |
+|---|---|---|
+| `domain` | stdlib only | everything else |
+| `application` | `domain` | `infrastructure`, `cli` |
+| `infrastructure` | `domain`, stdlib, 3rd-party | `application`, `cli` |
+| `cli` | `application`, `domain.models` | `infrastructure` directly |
+
+### Key architectural decisions
+
+- **`Compressor` is a `typing.Protocol`** (in `domain/ports.py`), not a bare
+  `Callable`. This makes the contract explicit and IDE-checkable without
+  creating an import cycle:
+  ```python
+  class Compressor(Protocol):
+      def __call__(
+          self,
+          original: Path,
+          out_dir: Path,
+          threads: int | None,
+          quality: int,
+          min_savings: str,
+      ) -> Path | None: ...
+  ```
+- **`DeckResult` and `ImageProcessResult` live in `domain/models.py`** — they
+  are pure data, no logic, no I/O.
+- **`compress_deck.py` receives a `Compressor` instance via constructor or
+  parameter** — never imports `caesium_adapter` directly. This is what makes
+  the use-case fully unit-testable with a `fake_compressor`.
+- **`main()` (in `cli/args.py`) owns argument parsing only.** It resolves
+  paths, builds the `Compressor` adapter, and calls `application.compress_deck`
+  or `application.batch`. No processing logic belongs there.
+- **`expand_inputs` / `collect_from_dir` live in `cli/args.py`** — path
+  resolution is a CLI concern. All layers below receive `Path` objects.
+- **Temp directory lifecycle belongs in `infrastructure/temp_manager.py`.**
+  Always use `TEMP_PREFIX` so orphaned dirs from crashed runs are recoverable.
+
+### Migration guide (single file → package)
+
+1. Create the `pptx_compress/` directory.
+2. Move dataclasses and constants to `domain/`.
+3. Move `compress_with_caesium` → `infrastructure/caesium_adapter.py`.
+4. Move PPTX read/write helpers → `infrastructure/pptx_reader.py` and
+   `pptx_writer.py`.
+5. Move `process_image_file` + `process_single_deck` → `application/compress_deck.py`.
+6. Move `main()` + input helpers → `cli/args.py`.
+7. Add `__main__.py` with `from pptx_compress.cli.args import main; main()`.
+8. Update `test_pptx_image_compress.py` imports accordingly — test logic does
+   not need to change because the public API surface is identical.
+
+### Refactoring plan (aligned with this AGENTS.md)
+
+- Keep the same layer direction: `cli` → `application` → `domain`; only
+  `infrastructure` implements domain ports.
+- Add dedicated raster/vector implementations behind domain ports, not in CLI:
+  - `domain/ports.py`: `RasterCompressor`, `VectorCompressor` protocols
+    (or one `Compressor` protocol + typed strategies)
+  - `infrastructure/caesium_adapter.py`: raster implementation
+  - `infrastructure/svg_polish_adapter.py`: vector implementation
+- Add routing in `application` (not `infrastructure`):
+  - `application/compress_deck.py`: `CompressorRouter` decides by extension
+  - no direct `subprocess` / external library calls in `application`
+- Split image workflow into explicit application steps:
+  - `compress_step`
+  - `optimal_format_step` (PNG → JPEG optimization step; not a fallback)
+  - `replace_step` (atomic replace via `.tmp` + `Path.replace()`)
+- Centralize PPTX metadata handling in infrastructure modules:
+  - keep relationship/content-type updates in `infrastructure/pptx_reader.py`
+    and/or `infrastructure/pptx_writer.py`
+  - `application` only orchestrates and passes domain models
+- Introduce configuration object in `domain/constants.py` or a dedicated
+  domain config model; avoid new magic values in `application`.
+- Preserve public behaviour and CLI surface during migration; refactor in
+  small commits with green tests after each step.
+
+### Suggested commit sequence
+
+1. Extract domain models/constants/ports unchanged.
+2. Extract caesium adapter + add svg_polish adapter seam.
+3. Introduce router in `application` with extension-based dispatch.
+4. Refactor image processing into `compress_step` + `optimal_format_step` +
+   `replace_step`.
+5. Extract PPTX metadata update helpers to infrastructure modules.
+6. Move CLI parsing/output concerns into `cli/` only.
+7. Remove dead monolith code paths and keep tests passing.
+
+---
+
+## Security
+
+- **Never pass unsanitised user input directly to `subprocess`.** The
+  `compress_with_caesium` function builds the command as a list (not a shell
+  string). Keep it that way — do not use `shell=True`.
+- **Validate file extensions before compression.** `compress_with_caesium`
+  checks `ext not in ALLOWED_EXT` and returns `None` for unrecognised types.
+  Do not bypass or widen this check without explicit justification.
+- **Validate input paths early.** `process_single_deck` checks that the input
+  exists and has a `.pptx` suffix before doing any filesystem work.
+- **Temp files are written atomically.** Image replacement uses a `.tmp`
+  intermediate and `Path.replace()` (atomic rename) — do not change this to a
+  direct overwrite.
+- **`capture_output=True`** is set on all subprocess calls so that stdout/stderr
+  from `caesiumclt` cannot interfere with or inject into the tool's own output.
+- **Do not log file contents**, only metadata (name, size, slide references).
+  The CSV log must never contain image binary data or path information outside
+  the output directory.
+- **`ignore_errors=True` on `shutil.rmtree`** is acceptable for temp cleanup
+  only. Never suppress errors on writes to the output PPTX or its log file.

PACKAGING_GUIDE.md

@@ -0,0 +1,288 @@
+# PPTX Image Compressor - Packaging & Distribution Guide
+
+## Overview
+
+This project now supports 3 different deployment approaches:
+1. **Embedded Python** (Current - Development & Local Use)
+2. **PyInstaller Portable** (Recommended for End Users)
+3. **Hybrid Approach** (Recommended for Maximum Flexibility)
+
+---
+
+## Approach 1: Embedded Python (Development Setup)
+
+### Use Case
+- ✅ Development with VS Code
+- ✅ Debugging with Python Debugger
+- ✅ Running tests with pytest
+- ✅ Source code control & modifications
+
+### What You Have
+- `install_and_run.bat` - Main launcher
+- `.venv/` - Virtual environment for development
+- Source code - Fully editable
+
+### Usage
+```bash
+# Development (with --debug flag to see pip output)
+.\install_and_run.bat --debug -i "path\to\file.pptx" -o "path\to\output.pptx"
+
+# With VS Code debugger
+# Open pptx_image_compress.py and click "Debug" or press F5
+
+# Run tests
+.\.venv\Scripts\pytest tests/
+```
+
+### Setup Instructions
+1. Ensure Python 3.9+ is installed on Windows
+2. Run: `.\install_and_run.bat`
+3. Virtual environment is created/updated automatically
+
+### Files
+- `install_and_run.bat` - Handles Python setup and execution
+- `requirements.txt` - Python package dependencies for runtime
+- `requirements-dev.txt` - Development dependencies (pytest, coverage, etc.)
+
+---
+
+## Approach 2: PyInstaller Portable (User Distribution)
+
+### Use Case
+- ✅ Distribute to end users (No Python installation needed)
+- ✅ Single-file executable
+- ✅ Professional appearance
+- ✅ "Just download and run" experience
+- ✅ Drag-and-drop support for non-technical users
+
+### What Gets Generated
+- `dist/pptx-image-compress.exe` - Standalone executable
+- `dist/run.bat` - Simple command-line wrapper
+- `dist/dragdrop.bat` - Drag-and-drop wrapper (easiest for users)
+
+### Usage by End User
+```bash
+# Option 1: Drag-and-drop (Easiest!)
+#   Drag a .pptx file onto dragdrop.bat
+#   Output: filename_compressed.pptx
+
+# Option 2: Command line
+.\pptx-image-compress.exe -i "path\to\file.pptx" -o "path\to\output.pptx"
+
+# Option 3: Wrapper
+.\run.bat -i "path\to\file.pptx" -o "path\to\output.pptx"
+
+# Get help
+.\pptx-image-compress.exe --help
+```
+
+### Build Instructions
+1. Ensure you have the development environment set up (Approach 1)
+2. Run: `.\build.bat`
+3. Wait for build to complete (first run takes 2-3 minutes)
+4. Generated files are in `dist/` folder
+
+### Build Files
+- `build.bat` - Automated build script that:
+  - Installs PyInstaller if needed
+  - Compiles Python to standalone executable
+  - Creates wrapper batch file
+  - Prepares distribution package
+
+### Advantages
+- No Python installation required on user's machine
+- Smaller footprint than full Python installation
+- Professional distribution option
+- Can be code-signed and digitally stamped
+
+### Limitations
+- Larger file size (~80-150 MB) due to bundled Python
+- First launch slightly slower (unpacking)
+- Harder to debug if issues occur
+
+### Distribution Notes
+- Ensure `caesiumclt.exe` is in the same directory as the .exe
+- Can optionally add `.venv\Lib\site-packages\svg_polish\*` if svg-polish needs updating
+- All dependencies are pre-bundled
+- Users can:
+  1. **Drag-and-drop files** onto `dragdrop.bat` for easy compression
+  2. Use command line for batch operations
+  3. Call `.exe` directly with custom parameters
+
+### Drag-and-Drop Feature
+The `dragdrop.bat` wrapper provides the easiest user experience:
+- Drag a `.pptx` file onto `dragdrop.bat`
+- Automatically creates `[filename]_compressed.pptx` in the same directory
+- Shows progress and completion status
+- No command-line knowledge required
+
+---
+
+## Approach 3: Hybrid (Recommended)
+
+### Use Case
+- ✅ Flexible development workflow
+- ✅ Easy distribution to users
+- ✅ Best of both worlds
+
+### How It Works
+**For Developers:**
+- Use Embedded Python approach (Approach 1)
+- Edit code, debug, run tests
+- Keep development lightweight
+
+**For Users:**
+- Use PyInstaller Portable (Approach 2)
+- Download and run .exe
+- No installation or configuration needed
+
+### Workflow
+```
+Development Phase:
+├── Edit code
+├── Test with: .\.venv\Scripts\pytest
+├── Debug with VS Code
+└── Use: .\install_and_run.bat --debug -i file.pptx
+
+Release Phase:
+├── Run: .\build.bat
+├── Test the .exe: .\dist\pptx-image-compress.exe -i file.pptx
+├── Package: Copy dist/* to users
+└── Users just run: pptx-image-compress.exe
+```
+
+---
+
+## Dependency Management
+
+### Runtime Dependencies (required for execution)
+See `requirements.txt`:
+- `svg-polish==1.0.0` - SVG optimization library (brings defusedxml)
+
+The core script uses only Python Standard Library modules:
+- No need for external image libraries
+- Uses system's `caesiumclt.exe` for image compression
+- Handles PPTX files using only built-in zipfile module
+
+### Development Dependencies (for testing/development)
+See `requirements-dev.txt`:
+- `pytest==9.0.3` - Testing framework
+- `pytest-cov==7.1.0` - Coverage reporting
+- Plus all runtime dependencies
+
+### Managing Dependencies
+
+**Update packages:**
+```bash
+.\.venv\Scripts\pip install --upgrade -r requirements.txt
+```
+
+**Add new package:**
+```bash
+.\.venv\Scripts\pip install package_name
+.\.venv\Scripts\pip freeze > requirements.txt
+```
+
+**For development:**
+```bash
+.\.venv\Scripts\pip install -r requirements-dev.txt
+```
+
+---
+
+## Troubleshooting
+
+### Development Setup Issues
+
+**Problem:** "Python not found"
+- **Solution:** Run `.\install_and_run.bat` which will download and setup Python
+
+**Problem:** "svg_polish not found"
+- **Solution:** Run with `--debug` flag to see installation details
+- Or manually: `.\.venv\Scripts\pip install svg-polish`
+
+### PyInstaller Build Issues
+
+**Problem:** Build takes too long
+- **Solution:** First build is slower due to PyInstaller analysis. Subsequent builds are faster.
+
+**Problem:** .exe won't run
+- **Solution:** Ensure `caesiumclt.exe` is in the same directory or system PATH
+
+**Problem:** "PyInstaller not installed"
+- **Solution:** Run `build.bat` again - it will auto-install PyInstaller
+
+---
+
+## Technical Comparison
+
+| Aspect | Embedded Python | PyInstaller | Hybrid |
+|--------|-----------------|-------------|--------|
+| **Installation** | Auto (via batch) | None (single .exe) | Mixed |
+| **Disk Space** | ~50 MB | ~100-150 MB | Both available |
+| **Execution Speed** | Fast | Fast | Fast |
+| **Debuggability** | Excellent | Difficult | Excellent (dev) |
+| **Distribution** | Manual setup | Just .exe | Just .exe (users) |
+| **Development** | Quick iteration | Requires rebuild | Quick iteration |
+
+---
+
+## Recommended Workflow
+
+### For You (Developer)
+```
+1. Daily Development:
+   - Use: .\install_and_run.bat --debug
+   - Edit code in VS Code
+   - Test with pytest
+   - Use debugger with F5
+
+2. Before Release:
+   - Run: .\build.bat
+   - Test: .\dist\pptx-image-compress.exe
+   - Package and distribute
+```
+
+### For End Users
+```
+1. First Time:
+   - Download pptx-image-compress.exe
+   - Download run.bat (optional)
+   - Download caesiumclt.exe (if image compression needed)
+   
+2. Usage:
+   - Double-click run.bat
+   - Or: pptx-image-compress.exe -i input.pptx -o output.pptx
+```
+
+---
+
+## Next Steps
+
+1. **Test Embedded Python Setup:**
+   ```bash
+   .\install_and_run.bat --debug -i test.pptx -o test_output.pptx
+   ```
+
+2. **Build Portable Distribution:**
+   ```bash
+   .\build.bat
+   ```
+
+3. **Test the Executable:**
+   ```bash
+   .\dist\pptx-image-compress.exe -h
+   ```
+
+4. **Check Generated Files:**
+   - `dist/pptx-image-compress.exe` - Main executable
+   - `dist/run.bat` - Batch wrapper
+
+---
+
+## Support & Maintenance
+
+- Keep Python version updated for security
+- Update dependencies: `pip install --upgrade -r requirements.txt`
+- Rebuild .exe when updating dependencies: `.\build.bat`
+- Test both approaches before major updates

README.md

@@ -1,6 +1,5 @@
-
+# PPTX Image Compressor (CaesiumCLT + svg-polish)
-# PPTX Image Compressor (CaesiumCLT only)
+**Version 1.2.0**
-**Version 1.1.7**
 
 Dieses Paket enthält:
 
@@ -27,26 +26,29 @@ 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.
+Zusätzlich wird **pip** installiert, damit das **svg-polish** Modul installiert werden kann. 
+
 
 ## Was das Tool macht
 - Entpackt die PPTX in einen Temp‑Ordner
 - Komprimiert **JPG/JPEG, PNG, WebP, GIF** mit **CaesiumCLT** (Default `-q 90`, `-O bigger`)
+- Komprimiert **SVG** mit **svg-polish** (Default-Modus: `balanced`)
 - Ersetzt Bilder nur, wenn die komprimierte Datei kleiner ist
 - Versucht bei PNG zusätzlich einen PNG->JPG Wechsel, wenn das Bild nach Kompression noch größer als 500 KB ist
 - Ersetzt Bilder nur, wenn sei mindestens 2% kleiner sind (verhindert *doppelte Komprimierung*)
 - Schreibt ein CSV‑Log (`.log` neben der Output‑PPTX)
-   Baut eine neue PPTX und zeigt eine Summary (Name, Größe vorher/nachher, Ersparnis %, Zeit)
+- 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)
 
-## Änderungen in 1.1.7
+## Änderungen in 1.2.0
-- PNG->JPG Fallback für große PNGs (> 500 KB nach Kompression) hinzugefügt
+- Möglichkeit mit build.bat eine pptx-image-compressor.exe zu erstellen
-- CSV-Logging um `image_type_changed` erweitert (`png_jpg` bei Typwechsel)
+- Fixes für install_and_run.bat in venv / "raw" environments
 
 ## Hinweise
 - `-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
 -  `--min-savings` steuert das Mindestmass an Komprimierung zur Verhinderung von doppelter Komprimierunt, Default ist 2%
 - 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`).
+- `--svg-profile` steuert das Vector-Optimierungsprofil `balanced|aggressive`
 
 ## Manuelle Nutzung des .py (falls Python vorhanden)
 ```bat
@@ -55,4 +57,5 @@ python pptx_image_compress.py -i "C:\Pfad\input.pptx" -t 8
 
 ## Quellen & Tools
 - CaesiumCLT – Projekt/Downloads: https://github.com/Lymphatus/caesium-clt
+- SVG Polish - https://github.com/g-battaglia/svg_polish
 - Windows Embeddable Python Package – Doku/Downloads: https://docs.python.org/3/using/windows.html

build.bat

@@ -0,0 +1,126 @@
+@echo off
+setlocal EnableExtensions
+
+set "SELF_DIR=%~dp0"
+pushd "%SELF_DIR%"
+
+set "BUILD_DIR=%SELF_DIR%dist"
+set "SPEC_DIR=%SELF_DIR%build"
+set "PY_CMD=%SELF_DIR%.venv\Scripts\python.exe"
+set "UPX_DIR=%SELF_DIR%buildtools"
+
+set "MINIFY="
+if /I "%~1"=="--minify" set "MINIFY=1"
+
+echo [INFO] Build started...
+
+rem =========================
+rem Check Python
+rem =========================
+
+if not exist "%PY_CMD%" (
+    echo [ERROR] Python not found
+    exit /b 1
+)
+
+rem =========================
+rem Check PyInstaller
+rem =========================
+
+"%PY_CMD%" -m pip show pyinstaller >nul 2>&1
+if errorlevel 1 (
+    echo [INFO] Installing PyInstaller...
+    "%PY_CMD%" -m pip install pyinstaller --quiet
+)
+
+rem =========================
+rem Clean
+rem =========================
+
+if exist "%BUILD_DIR%" rmdir /s /q "%BUILD_DIR%"
+if exist "%SPEC_DIR%" rmdir /s /q "%SPEC_DIR%"
+
+rem =========================
+rem Optional icon
+rem =========================
+
+set "ICON_ARG="
+if exist "%SELF_DIR%pptx-image-compress.ico" (
+    set "ICON_ARG=%SELF_DIR%pptx-image-compress.ico"
+)
+echo [INFO] Icon param: %ICON_ARG%
+
+
+rem =========================
+rem Build EXE (STABLE)
+rem =========================
+
+echo [INFO] Building EXE...
+
+if defined ICON_ARG (
+    "%PY_CMD%" -m PyInstaller ^
+        --onefile ^
+        --console ^
+        --name pptx-image-compress ^
+        --distpath "%BUILD_DIR%" ^
+        --specpath "%SPEC_DIR%" ^
+        --workpath "%SPEC_DIR%\build" ^
+        --icon="%ICON_ARG%" ^
+        --hidden-import svg_polish ^
+        pptx_image_compress.py
+) else (
+    "%PY_CMD%" -m PyInstaller ^
+        --onefile ^
+        --console ^
+        --name pptx-image-compress ^
+        --distpath "%BUILD_DIR%" ^
+        --specpath "%SPEC_DIR%" ^
+        --workpath "%SPEC_DIR%\build" ^
+        --hidden-import svg_polish ^
+        pptx_image_compress.py
+)
+
+if errorlevel 1 (
+    echo [ERROR] Build failed
+    exit /b 1
+)
+
+rem =========================
+rem Copy templates
+rem =========================
+
+copy "%SELF_DIR%templates\run.tpl.bat" "%BUILD_DIR%\run.bat" >nul
+copy "%SELF_DIR%templates\dragdrop.tpl.bat" "%BUILD_DIR%\dragdrop.bat" >nul
+
+
+rem =========================
+rem Copy caesiumclt.exe
+rem =========================
+copy "%SELF_DIR%bin\caesiumclt.exe" "%BUILD_DIR%\caesiumclt.exe"
+
+
+rem =========================
+rem Optional UPX
+rem =========================
+
+if defined MINIFY (
+    if exist "%UPX_DIR%\upx.exe" (
+        echo [INFO] Running UPX compression...
+        "%UPX_DIR%\upx.exe" --best --force "%BUILD_DIR%\pptx-image-compress.exe"
+        "%UPX_DIR%\upx.exe" --best --force "%BUILD_DIR%\caesiumclt.exe"
+    ) else (
+        echo [WARN] UPX not found at %UPX_DIR%
+    )
+)
+
+rem =========================
+rem Done
+rem =========================
+
+echo(
+echo [SUCCESS] Build complete!
+echo Output:
+echo   %BUILD_DIR%\pptx-image-compress.exe
+
+popd
+endlocal

check_new_version.bat

@@ -1,11 +1,7 @@
 @echo off
 setlocal EnableExtensions EnableDelayedExpansion
 
-set UPDATE_DIR=%~dp0updates
-if not exist "%UPDATE_DIR%" mkdir "%UPDATE_DIR%"
-
 set TMP_OUT=%TEMP%\update_check_%RANDOM%.txt
-set TMP_OUT_2=%TEMP%\update_check_%RANDOM%.txt
 
 python check_new_version.py > "%TMP_OUT%"
 set EXITCODE=%ERRORLEVEL%
@@ -23,39 +19,6 @@ if %EXITCODE%==0 (
 echo.
 type "%TMP_OUT%"
 
-choice /c jn /m "Wollen Sie die Updates-Packages herunterladen?"
-
-if errorlevel 2 goto :END
-
-
-if exist "%TMP_OUT%" (
-    
-    
-    findstr /b "PYTHON_DOWNLOAD=" "%TMP_OUT%" >nul
-    if not errorlevel 1 (
-        for /f "tokens=1,* delims==" %%a in (
-            'findstr /b "PYTHON_DOWNLOAD=" "%TMP_OUT%"'
-        ) do (
-            echo Downloading Python update from PYTHON_DOWNLOAD
-            powershell -NoProfile -Command ^
-              "Invoke-WebRequest '%%b' -OutFile '%UPDATE_DIR%\python-embed.zip'"
-        )
-    )
-
-    findstr /b "CAESIUM_DOWNLOAD=" "%TMP_OUT_2%" >nul
-    if not errorlevel 1 (
-        for /f "tokens=1,* delims==" %%a in (
-            'findstr /b "CAESIUM_DOWNLOAD=" "%TMP_OUT_2%"'
-        ) do (
-            echo Downloading caesiumclt update from CAESIUM_DOWNLOAD
-
-            powershell -NoProfile -Command ^
-              "Invoke-WebRequest '%%b' -OutFile '%UPDATE_DIR%\caesiumclt.zip'"
-        )
-    )
-)
-
 :END
 del "%TMP_OUT%" >nul 2>&1
-del "%TMP_OUT_2%" >nul 2>&1
 endlocal

check_new_version.ini

@@ -1,6 +1,6 @@
 [DEFAULT]
-python_used_version = 3.14.5
+python_used_version = 3.14.6
-python_latest_version = 3.14.5
+python_latest_version = 3.14.6
 caesiumclt_used_version = v1.3.0
 caesiumclt_latest_version = v1.3.0
 

check_new_version.py

@@ -2,10 +2,11 @@ import argparse
 import configparser
 import json
 import sys
+import os
 import urllib.request
 from pathlib import Path
 
-INI_FILE = Path("latestversion.ini")
+INI_FILE = Path("check_new_version.ini")
 PYTHON_API = "https://endoflife.date/api/v1/products/python"
 CAESIUM_API = "https://api.github.com/repos/Lymphatus/caesium-clt/tags"
 
@@ -79,7 +80,6 @@ def check_caesium(cfg, result):
             )
         })
 
-
 def main():
     parser = argparse.ArgumentParser()
     parser.add_argument("--yes", action="store_true")
@@ -104,9 +104,10 @@ def main():
         for u in result["updates"]:
             print(
                 f"{u['tool'].capitalize()}: aktuell genutzt {u['used']}, "
-                f"neu {u['latest']}, download?"
+                f"neu {u['latest']}"
             )
             print(f"{u['tool'].upper()}_DOWNLOAD={u['url']}")
+            print(f"{u['tool'].upper()}_LATEST_VERSION={u['latest']}")
             
             if not u["maintained"]:
                 print(

install_and_run.bat

@@ -4,7 +4,7 @@ setlocal EnableExtensions EnableDelayedExpansion
 
 rem ============================================
 rem  PPTX Image Compressor - Installer/Runner (Batch-enabled)
-rem  Fix: caesiumclt.exe aus [ROOT]\bin; Python-Discovery ohne MS Store Alias
+rem  Version 1.2.0
 rem ============================================
 
 set "APP_NAME=PPTX Image Compressor"
@@ -12,7 +12,7 @@ set "SELF_DIR=%~dp0"
 set "SCRIPT=%SELF_DIR%pptx_image_compress.py"
 
 rem ---- Python Embeddable config ----
-set "PY_EMBED_VERSION=3.14.5"
+set "PY_EMBED_VERSION=3.14.6"
 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"
@@ -44,13 +44,22 @@ rem ---- Python discovery (avoid MS Store alias) ----
 set "PY_CMD="
 set "USE_PY_LAUNCHER="
 
-rem 1) Prefer local embeddable first
+if defined VIRTUAL_ENV (
-if exist "%PY_EXE%" (
+    if exist "%VIRTUAL_ENV%\Scripts\python.exe" (
-    set "PY_CMD=%PY_EXE%"
+        set "PY_CMD=%VIRTUAL_ENV%\Scripts\python.exe"
+        goto :have_python
+    )
+)
+
+if exist "%SELF_DIR%.venv\Scripts\python.exe" (
+    set "PY_CMD=%SELF_DIR%.venv\Scripts\python.exe"
+    goto :have_python
+)
+if exist "%SELF_DIR%venv\Scripts\python.exe" (
+    set "PY_CMD=%SELF_DIR%venv\Scripts\python.exe"
     goto :have_python
 )
 
-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 (
@@ -66,7 +75,6 @@ for /f "delims=" %%P in ('where python3.exe 2^>nul') do (
     )
 )
 
-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 (
@@ -76,7 +84,11 @@ for /f "delims=" %%P in ('where py.exe 2^>nul') do (
     )
 )
 
-rem 4) Download embeddable locally
+if exist "%PY_EXE%" (
+    set "PY_CMD=%PY_EXE%"
+    goto :have_python
+)
+
 if not exist "%SELF_DIR%%PY_EMBED_ZIP%" (
     echo [INFO] Kein Python gefunden. Lade Embeddable Python %PY_EMBED_VERSION% ...
     powershell -NoLogo -NoProfile -Command ^
@@ -98,6 +110,14 @@ if errorlevel 1 (
 )
 set "PY_CMD=%PY_EXE%"
 
+rem ---- Fix embedded Python isolation for the installation of pip ----
+set "PTH_FILE=%PY_DIR%\python314._pth"
+if exist "%PTH_FILE%" (
+    echo [INFO] Enabling site-packages in embedded Python...
+    powershell -Command ^
+     "(Get-Content '%PTH_FILE%') -replace '^#?\s*import site','import site' | Set-Content '%PTH_FILE%'"
+)
+
 :have_python
 if not defined PY_CMD (
     echo [ERROR] Konnte Python nicht ermitteln. Abbruch.
@@ -110,8 +130,78 @@ if not exist "%SCRIPT%" (
     exit /b 6
 )
 
-set "RUN_ARGS=%*"
+set "ALL_ARGS=%*"
-if "%~1"=="" set "RUN_ARGS=-h"
+set "RUN_ARGS=%ALL_ARGS%"
+set "DEBUG_MODE=0"
+
+if "%~1"=="--debug" (
+    set "DEBUG_MODE=1"
+    set "RUN_ARGS=!ALL_ARGS:~8!"
+    if "!RUN_ARGS:~0,1!"==" " set "RUN_ARGS=!RUN_ARGS:~1!"
+)
+
+if "!RUN_ARGS!"=="" set "RUN_ARGS=-h"
+
+echo [INFO] Pruefe und installiere Python-Abhaengigkeit: svg-polish ...
+set "PIP_OK=0"
+if defined USE_PY_LAUNCHER (
+    "%PY_CMD%" -3 -m pip --version >nul 2>&1
+) else (
+    "%PY_CMD%" -m pip --version >nul 2>&1
+)
+if not errorlevel 1 set "PIP_OK=1"
+
+if "%PIP_OK%"=="0" (
+    echo [INFO] pip nicht verfuegbar. Versuche ensurepip ...
+    if defined USE_PY_LAUNCHER (
+        "%PY_CMD%" -3 -m ensurepip --upgrade >nul 2>&1
+    ) else (
+        "%PY_CMD%" -m ensurepip --upgrade >nul 2>&1
+    )
+    if defined USE_PY_LAUNCHER (
+        "%PY_CMD%" -3 -m pip --version >nul 2>&1
+    ) else (
+        "%PY_CMD%" -m pip --version >nul 2>&1
+    )
+    if not errorlevel 1 set "PIP_OK=1"
+)
+
+if "%PIP_OK%"=="0" (
+    if /I "%PY_CMD%"=="%PY_EXE%" (
+        echo [INFO] ensurepip nicht verfuegbar. Lade get-pip.py ...
+        powershell -NoLogo -NoProfile -Command ^
+         "try { Invoke-WebRequest -Uri 'https://bootstrap.pypa.io/get-pip.py' -OutFile '%SELF_DIR%get-pip.py' -UseBasicParsing; exit 0 } catch { Write-Error $_; exit 1 }"
+        if exist "%SELF_DIR%get-pip.py" (
+            "%PY_CMD%" "%SELF_DIR%get-pip.py" >nul 2>&1
+            del "%SELF_DIR%get-pip.py" >nul 2>&1
+        )
+        "%PY_CMD%" -m pip --version >nul 2>&1
+        if not errorlevel 1 set "PIP_OK=1"
+    )
+)
+
+if "%PIP_OK%"=="1" (
+    if defined USE_PY_LAUNCHER (
+        "%PY_CMD%" -3 -m pip install --disable-pip-version-check --quiet --no-warn-script-location svg-polish 
+    ) else (
+        "%PY_CMD%" -m pip install --disable-pip-version-check --quiet --no-warn-script-location svg-polish
+    )
+    if errorlevel 1 (
+        echo [WARN] 'svg-polish' konnte nicht installiert werden. SVG-Dateien werden nicht komprimiert.
+    ) else (
+        echo [OK] 'svg-polish' ist verfuegbar.
+        if %DEBUG_MODE%==1 (
+            echo [DEBUG] pip list:
+            if defined USE_PY_LAUNCHER (
+                "%PY_CMD%" -3 -m pip list
+            ) else (
+                "%PY_CMD%" -m pip list
+            )
+        )
+    )
+) else (
+    echo [WARN] pip konnte nicht eingerichtet werden. SVG-Dateien werden nicht komprimiert.
+)
 
 echo.
 echo [%APP_NAME%] Starte ...

install_and_run.md

@@ -0,0 +1,107 @@
+#  PPTX Image Compressor – Installation Logic
+
+## 1. Intro – One Line Summary
+
+> The script selects the best available Python environment, falls back to a self-installed embedded runtime if necessary, ensures `pip`, installs `svg-polish` when possible, and runs the application with graceful degradation.
+
+## 2. Lightweight Overview
+
+```text
+START
+│
+├─► Find usable Python
+│     ├─ venv (active / local)
+│     ├─ system Python
+│     └─ fallback: download embedded Python
+│
+├─► Ensure pip works
+│     ├─ pip exists → OK
+│     ├─ ensurepip → try fix
+│     └─ get-pip.py → fallback fix
+│
+├─► Install dependency
+│     └─ svg-polish (optional but preferred)
+│
+├─► Run main script
+│
+└─► END
+```
+
+---
+
+## 3. Detailed Logic Tree
+
+```text
+START
+│
+├─► [A] Pre-check: caesiumclt
+│     ├─ found → continue
+│     └─ not found → EXIT
+│
+├─► [B] Python resolution (priority-based)
+│     │
+│     ├─ Active venv (VIRTUAL_ENV)?
+│     │     └─ use it ✅
+│     │
+│     ├─ Local ".venv"?
+│     │     └─ use it ✅
+│     │
+│     ├─ Local "venv"?
+│     │     └─ use it ✅
+│     │
+│     ├─ System Python (python.exe, excluding WindowsApps)?
+│     │     └─ use it ✅
+│     │
+│     ├─ Python launcher (py.exe)?
+│     │     └─ use py -3 ✅
+│     │
+│     ├─ Existing embedded Python?
+│     │     └─ use it ✅
+│     │
+│     └─ NONE FOUND →
+│           ├─ Download embeddable Python
+│           ├─ Extract to python-embed
+│           ├─ Fix isolation (enable "import site")
+│           └─ use it ✅
+│
+├─► [C] Validate main script exists
+│     ├─ missing → EXIT
+│     └─ exists → continue
+│
+├─► [D] Ensure pip availability
+│     │
+│     ├─ pip works?
+│     │     └─ YES → continue ✅
+│     │
+│     └─ NO →
+│          ├─ try: ensurepip
+│          │     ├─ success → ✅
+│          │     └─ fail →
+│          │
+│          └─ if embedded Python:
+│                ├─ download get-pip.py
+│                ├─ execute it
+│                ├─ remove file
+│                └─ re-check pip
+│
+│          ├─ still no pip →
+│          │     └─ WARN: disable SVG compression
+│          │
+│          └─ pip available →
+│                ✅ continue
+│
+├─► [E] Install dependency
+│     ├─ install svg-polish
+│     │     ├─ success → ✅ SVG enabled
+│     │     └─ fail → ⚠ SVG disabled
+│     │
+│     └─ optional debug: pip list
+│
+├─► [F] Run application
+│     ├─ execute Python script
+│     ├─ capture return code
+│     ├─ success → "Fertig"
+│     └─ error → report exit code
+│
+└─► END
+```

pptx_image_compress.py

@@ -1,16 +1,15 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 """
-PPTX Grafik-Komprimier-Tool (nur CaesiumCLT, Multi-Thread, Batch, sauberes Cleanup)
+PPTX Raster & Vector Komprimier-Tool (Raster-Iamges: via CaesiumCLT, Vector-Images: via python Module svg_polish)
-Version: 1.1.7
+Version: 1.1.9
 
+Änderungen in 1.1.9
+- SVG Files Default Profile: `balanced` statt `aggressive`
+- Datei-Eigenschaften der neu generierten PPTX enthält Hinweis auf Compression `compressed by PPTX Image Compressor` 
 
-Highlights:
+Änderungen in 1.1.8:
-- Caesium-Scratch außerhalb des PPTX-Arbeitsverzeichnisses -> keine Tempfiles in finaler PPTX
+- SVG Files werden bei Vorhandensein von svg_polish anhand von 2 Profilen optimiert: balanced|agressive
-- Safety-Cleanup: entfernt 'caesium*' Ordner und '*.tmp' in ppt/media, bevor gezippt wird
-- Overwrite Policy: -O bigger
-- Log: image_name,size_before,size_after,saving,saving_percent,in_slide_number,image_type_changed
-- Summary inkl. Zeit benötigt
 
 Änderungen in 1.1.7:
 - PNG->JPG Fallback für große PNGs hinzugefügt (wenn nach Kompression weiterhin > 500 KB)
@@ -21,6 +20,7 @@ Highlights:
 """
 
 import argparse
+import importlib
 import inspect
 import os
 import re
@@ -42,13 +42,19 @@ from typing import Callable, List, Optional
 
 
 
-__version__ = "1.1.7"
+__version__ = "1.2.0"
 
-ALLOWED_EXT = {".jpg", ".jpeg", ".png", ".webp", ".gif"}
+RASTER_EXT = {".jpg", ".jpeg", ".png", ".webp", ".gif"}
+VECTOR_EXT = {".svg"}
+ALLOWED_EXT = RASTER_EXT | VECTOR_EXT
 PROGRESS_BAR_LEN = 40
 TEMP_PREFIX = "pptx_compress_"
 DEFAULT_MIN_SAVINGS = "2%"
 PNG_TO_JPEG_THRESHOLD_BYTES = 500 * 1024
+SVG_POLISH_MODULE_NAME = "svg_polish"
+SVG_PROFILE_BALANCED = "balanced"
+SVG_PROFILE_AGGRESSIVE = "aggressive"
+SVG_PROFILE_DEFAULT = SVG_PROFILE_BALANCED
     
 
 @dataclass
@@ -148,13 +154,13 @@ def compress_with_caesium(
     min_savings: str,
     output_format: str = "original",
 ) -> Path | None:
+    ext = original.suffix.lower()
+    if ext not in RASTER_EXT:
+        return None
     exe = which("caesiumclt")
     if not exe:
         raise RuntimeError("[ERROR] 'caesiumclt' wurde nicht gefunden. Bitte CaesiumCLT installieren und in PATH verfügbar machen.")
     out_dir.mkdir(parents=True, exist_ok=True)
-    ext = original.suffix.lower()
-    if ext not in ALLOWED_EXT:
-        return None
     cmd = [
         exe,
         "-q",
@@ -218,6 +224,159 @@ def run_compressor(
     return compressor(original, out_dir, caesium_threads, quality, min_savings)
 
 
+def compress_raster_image(
+    compressor: Callable[..., Path | None],
+    original: Path,
+    out_dir: Path,
+    caesium_threads: int | None,
+    quality: int,
+    min_savings: str,
+) -> Path | None:
+    return run_compressor(
+        compressor=compressor,
+        original=original,
+        out_dir=out_dir,
+        caesium_threads=caesium_threads,
+        quality=quality,
+        min_savings=min_savings,
+    )
+
+
+def import_svg_polish_module() -> object | None:
+    try:
+        return importlib.import_module(SVG_POLISH_MODULE_NAME)
+    except Exception:
+        return None
+
+
+def build_svg_polish_options(svg_polish_module: object, profile: str = SVG_PROFILE_DEFAULT) -> object | None:
+    options_type = getattr(svg_polish_module, "OptimizeOptions", None)
+    if not callable(options_type):
+        return None
+    try:
+        if profile == SVG_PROFILE_BALANCED:
+            return options_type(
+                shorten_ids=True,
+                enable_viewboxing=True,
+            )
+        return options_type(
+            digits=2,
+            style_to_xml=True,
+            group_collapse=True,
+            simple_colors=True,
+            indent_type="none",
+            newlines=False,
+            strip_xml_prolog=True,
+            strip_comments=True,
+            remove_metadata=True,
+            remove_titles=True,
+            remove_descriptions=True,
+            remove_descriptive_elements=True,
+            strip_ids=True,
+            shorten_ids=True,
+            renderer_workaround=False,
+        )
+    except Exception:
+        return None
+
+
+def call_svg_polish_callable(fn: Callable[..., object], options: object | None, *args: object) -> object:
+    if options is not None:
+        try:
+            return fn(*args, options=options)
+        except TypeError:
+            return fn(*args)
+    return fn(*args)
+
+
+def optimize_svg_content_with_module(svg_polish_module: object, original: Path, svg_profile: str = SVG_PROFILE_DEFAULT) -> str | None:
+    options = build_svg_polish_options(svg_polish_module, svg_profile)
+    optimize_path = getattr(svg_polish_module, "optimize_path", None)
+    if callable(optimize_path):
+        result = call_svg_polish_callable(optimize_path, options, original)
+        if isinstance(result, str):
+            return result
+    optimize_file = getattr(svg_polish_module, "optimize_file", None)
+    if callable(optimize_file):
+        result = call_svg_polish_callable(optimize_file, options, str(original))
+        if isinstance(result, str):
+            return result
+    svg_text = original.read_text(encoding="utf-8")
+    optimize = getattr(svg_polish_module, "optimize", None)
+    if callable(optimize):
+        result = call_svg_polish_callable(optimize, options, svg_text)
+        if isinstance(result, str):
+            return result
+    optimize_string = getattr(svg_polish_module, "optimize_string", None)
+    if callable(optimize_string):
+        result = call_svg_polish_callable(optimize_string, options, svg_text)
+        if isinstance(result, str):
+            return result
+    polish = getattr(svg_polish_module, "polish", None)
+    if callable(polish):
+        result = polish(svg_text)
+        if isinstance(result, str):
+            return result
+    return None
+
+
+def compress_svg_with_svg_polish(
+    original: Path,
+    out_dir: Path,
+    svg_profile: str = SVG_PROFILE_DEFAULT,
+) -> Path | None:
+    if original.suffix.lower() not in VECTOR_EXT:
+        return None
+    svg_polish_module = import_svg_polish_module()
+    if svg_polish_module is None:
+        sys.stderr.write(f"[svg_polish] Modul '{SVG_POLISH_MODULE_NAME}' nicht verfügbar für {original.name}\n")
+        return None
+    out_dir.mkdir(parents=True, exist_ok=True)
+    out_file = out_dir / original.name
+    try:
+        optimized_svg = optimize_svg_content_with_module(svg_polish_module, original, svg_profile)
+        if not isinstance(optimized_svg, str):
+            return None
+        out_file.write_text(optimized_svg, encoding="utf-8")
+        if out_file.stat().st_size >= original.stat().st_size:
+            return None
+        return out_file
+    except Exception as ex:
+        sys.stderr.write(f"[svg_polish] Ausnahme bei {original.name}: {ex}")
+        return None
+
+
+def compress_vector_image(
+    original: Path,
+    out_dir: Path,
+    svg_profile: str = SVG_PROFILE_DEFAULT,
+) -> Path | None:
+    if original.suffix.lower() == ".svg":
+        return compress_svg_with_svg_polish(original=original, out_dir=out_dir, svg_profile=svg_profile)
+    return None
+
+
+def compress_image_with_routing(
+    compressor: Callable[..., Path | None],
+    original: Path,
+    out_dir: Path,
+    caesium_threads: int | None,
+    quality: int,
+    min_savings: str,
+    svg_profile: str = SVG_PROFILE_DEFAULT,
+) -> Path | None:
+    if original.suffix.lower() in VECTOR_EXT:
+        return compress_vector_image(original=original, out_dir=out_dir, svg_profile=svg_profile)
+    return compress_raster_image(
+        compressor=compressor,
+        original=original,
+        out_dir=out_dir,
+        caesium_threads=caesium_threads,
+        quality=quality,
+        min_savings=min_savings,
+    )
+
+
 def update_relationship_targets(work_dir: Path, old_name: str, new_name: str) -> None:
     rels_namespace = "{http://schemas.openxmlformats.org/package/2006/relationships}Relationship"
     for rels_file in work_dir.rglob("*.rels"):
@@ -311,6 +470,7 @@ def process_image_file(
     quality: int,
     min_savings: str,
     compressor: Callable[..., Path | None],
+    svg_profile: str = SVG_PROFILE_DEFAULT,
 ) -> ImageProcessResult:
     orig_size = img_path.stat().st_size
     chosen_size = orig_size
@@ -321,13 +481,14 @@ def process_image_file(
 
     try:
         out_sub = scratch_dir / f"img_{idx:06d}"
-        caesium_out = run_compressor(
+        caesium_out = compress_image_with_routing(
             compressor=compressor,
             original=img_path,
             out_dir=out_sub,
             caesium_threads=caesium_threads,
             quality=quality,
             min_savings=min_savings,
+            svg_profile=svg_profile,
         )
         if caesium_out and caesium_out.exists():
             compressed_size = caesium_out.stat().st_size
@@ -380,6 +541,7 @@ def process_single_deck(
     threads: int,
     quality: int,
     min_savings: str,
+    svg_profile: str = SVG_PROFILE_DEFAULT,
     compressor: Callable[..., Path | None] = compress_with_caesium,
 ) -> DeckResult:
     start_time = time.perf_counter()
@@ -439,6 +601,7 @@ def process_single_deck(
                 quality=quality,
                 min_savings=min_savings,
                 compressor=compressor,
+                svg_profile=svg_profile,
             )
 
             with lock:
@@ -480,6 +643,8 @@ def process_single_deck(
                     except Exception:
                         pass
 
+        update_core_description(work_dir, "PPTX Image Compressor",__version__)
+
         zip_dir_to_pptx(work_dir, output_pptx)
         size_after = output_pptx.stat().st_size
         result.size_after = size_after
@@ -577,6 +742,9 @@ def main():
         print("[ERROR] 'caesiumclt' nicht gefunden. Bitte installieren und in PATH verfügbar machen.")
         sys.exit(3)
 
+    if import_svg_polish_module() is None:
+        print("[WARN] 'svg-polish' nicht gefunden. SVG-Dateien werden nicht komprimiert. Installation: python -m pip install svg-polish")
+
     overall_before = 0
     overall_after = 0
     successes = 0
@@ -592,7 +760,7 @@ def main():
                 failures += 1
                 continue
             dst = out_dir / f"{src.stem}_compressed.pptx"
-            res = process_single_deck(src, dst, args.threads, args.quality, args.min_savings)
+            res = process_single_deck(src, dst, args.threads, args.quality, args.min_savings, args.svg_profile)
             if res.ok:
                 successes += 1
                 overall_before += res.size_before
@@ -661,17 +829,60 @@ def extractParserArguments():
     parser.add_argument('-O','--output-dir', help='Output-Verzeichnis (erforderlich 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')
+    # Standard as of https://docs.python.org/3/library/concurrent.futures.html. Changed in version 3.13: Default value of max_workers is changed to min(32, (os.process_cpu_count() or 1) + 4).
-    parser.add_argument('-t','--threads', type=int, default=16, help='Anzahl paralleler Threads pro Datei')
+    # On my machine this is 16 Threads
+    parser.add_argument('-t','--threads', type=int, default=min(32, (os.process_cpu_count() or 1) + 4), 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('--min-savings', default=DEFAULT_MIN_SAVINGS, help="Mindestersparnis für caesiumclt (z. B. 2%%, 100KB, 1MB oder Bytes als Zahl)")
+    parser.add_argument('--svg-profile', choices=[SVG_PROFILE_BALANCED, SVG_PROFILE_AGGRESSIVE], default=SVG_PROFILE_DEFAULT, help='Optimierungsprofil für SVG-Kompression')
     parser.add_argument('--version', action='version', version=f'%(prog)s {__version__}',  help="Zeigt die Versionsnummer an" )
     
     args = parser.parse_args()
+
     return parser,args
 
 
 
+def update_core_description(base_dir, app_name, version):
+    core_xml_path = Path(base_dir) / "docProps" / "core.xml"
+
+    if not core_xml_path.exists():
+        raise FileNotFoundError(f"{core_xml_path} nicht gefunden")
+
+    # Namespaces definieren
+    ns = {
+        "cp": "http://schemas.openxmlformats.org/package/2006/metadata/core-properties",
+        "dc": "http://purl.org/dc/elements/1.1/",
+        "dcterms": "http://purl.org/dc/terms/",
+        "xsi": "http://www.w3.org/2001/XMLSchema-instance"
+    }
+
+    # Registrieren, damit Prefixe erhalten bleiben
+    for prefix, uri in ns.items():
+        ET.register_namespace(prefix, uri)
+
+    tree = ET.parse(core_xml_path)
+    root = tree.getroot()
+
+    description_text = f"compressed by {app_name} {version}"
+
+    # Suche vorhandenes Element
+    desc_elem = root.find("dc:description", ns)
+
+    if desc_elem is None:
+        # neu anlegen
+        desc_elem = ET.SubElement(
+            root,
+            f"{{{ns['dc']}}}description"
+        )
+
+    # Text setzen/überschreiben
+    desc_elem.text = description_text
+
+    # Datei speichern
+    tree.write(core_xml_path, encoding="utf-8", xml_declaration=True)
+
+
 
 if __name__ == '__main__':
     main()

requirements-dev.txt

@@ -0,0 +1,3 @@
+svg-polish==1.0.0
+pytest==9.0.3
+pytest-cov==7.1.0

requirements.txt

@@ -0,0 +1 @@
+svg-polish==1.0.0

templates/dragdrop.tpl.bat

@@ -0,0 +1,39 @@
+@echo off
+setlocal EnableExtensions EnableDelayedExpansion
+
+if "%~1"=="" goto help
+
+set "INPUT=%~1"
+set "EXT=%~x1"
+set "PATH=%PATH%;%~dp0"
+
+if /I not "%EXT%"==".pptx" (
+    echo [ERROR] Only .pptx supported
+    pause
+    exit /b 1
+)
+
+echo [INFO] Compressing %~n1
+
+rem optional: ensure correct working dir
+pushd "%~dp0"
+
+"%~dp0pptx-image-compress.exe" -i "%INPUT%"
+set RC=%ERRORLEVEL%
+
+popd
+
+if %RC% neq 0 (
+    echo [ERROR] Failed (%RC%)
+) else (
+    echo [SUCCESS] Done
+)
+
+pause
+exit /b %RC%
+
+:help
+echo.
+echo Drag ^& Drop a .pptx file onto this script
+echo.
+pause

templates/run.tpl.bat

@@ -0,0 +1,8 @@
+@echo off
+setlocal EnableExtensions
+
+if "%~1"=="" (
+    "%~dp0pptx-image-compress.exe" -h
+) else (
+    "%~dp0pptx-image-compress.exe" %*
+)

test_pptx_image_compress.py

@@ -2,6 +2,7 @@ import tempfile
 import unittest
 import zipfile
 from pathlib import Path
+from unittest import mock
 
 import pptx_image_compress as pic
 
@@ -14,8 +15,9 @@ class TestPptxImageCompress(unittest.TestCase):
             (media_dir / "b.png").write_bytes(b"1")
             (media_dir / "c.txt").write_bytes(b"1")
             (media_dir / "d.GIF").write_bytes(b"1")
+            (media_dir / "e.svg").write_bytes(b"<svg/>")
             images = pic.discover_images(media_dir)
-            self.assertEqual([p.name for p in images], ["a.jpg", "b.png", "d.GIF"])
+            self.assertEqual([p.name for p in images], ["a.jpg", "b.png", "d.GIF", "e.svg"])
 
     def test_image_result_to_log_line(self):
         image_result = pic.ImageProcessResult(
@@ -153,6 +155,7 @@ class TestPptxImageCompress(unittest.TestCase):
                 out.write_bytes(b"B" * 50)
                 return out
 
+            with mock.patch("pptx_image_compress.update_core_description", create=True) as mocked_update_core_description:
                 result = pic.process_single_deck(
                     input_pptx=input_pptx,
                     output_pptx=output_pptx,
@@ -162,6 +165,7 @@ class TestPptxImageCompress(unittest.TestCase):
                     compressor=fake_compressor,
                 )
 
+            mocked_update_core_description.assert_called_once_with(mock.ANY, "PPTX Image Compressor", pic.__version__)
             self.assertTrue(result.ok)
             self.assertEqual(result.error, None)
             self.assertTrue(output_pptx.exists())
@@ -220,6 +224,7 @@ class TestPptxImageCompress(unittest.TestCase):
                 out.write_bytes(b"B" * 700000)
                 return out
 
+            with mock.patch("pptx_image_compress.update_core_description", create=True) as mocked_update_core_description:
                 result = pic.process_single_deck(
                     input_pptx=input_pptx,
                     output_pptx=output_pptx,
@@ -229,6 +234,7 @@ class TestPptxImageCompress(unittest.TestCase):
                     compressor=fake_compressor,
                 )
 
+            mocked_update_core_description.assert_called_once_with(mock.ANY, "PPTX Image Compressor", pic.__version__)
             self.assertTrue(result.ok)
             with zipfile.ZipFile(output_pptx, "r") as z:
                 self.assertIn("ppt/media/image1.jpg", z.namelist())
@@ -244,5 +250,165 @@ class TestPptxImageCompress(unittest.TestCase):
             self.assertIn("png_jpg", log_text)
 
 
+    def test_compress_image_with_routing_delegates_to_raster(self):
+        with tempfile.TemporaryDirectory() as td:
+            root = Path(td)
+            original = root / "image1.png"
+            original.write_bytes(b"A" * 100)
+            out_dir = root / "out"
+
+            def fake_compressor(original_path: Path, out_subdir: Path, caesium_threads: int | None, quality: int, min_savings: str):
+                out_subdir.mkdir(parents=True, exist_ok=True)
+                out = out_subdir / original_path.name
+                out.write_bytes(b"B" * 80)
+                return out
+
+            out = pic.compress_image_with_routing(
+                compressor=fake_compressor,
+                original=original,
+                out_dir=out_dir,
+                caesium_threads=1,
+                quality=90,
+                min_savings="2%",
+            )
+
+            self.assertIsNotNone(out)
+            if out is None:
+                self.fail("Output should not be None")
+            self.assertEqual(out.name, "image1.png")
+            self.assertEqual(out.stat().st_size, 80)
+    def test_compress_with_caesium_ignores_svg(self):
+        with tempfile.TemporaryDirectory() as td:
+            root = Path(td)
+            svg = root / "vector.svg"
+            svg.write_text("<svg></svg>", encoding="utf-8")
+            out_dir = root / "out"
+
+            with mock.patch("pptx_image_compress.which") as mocked_which:
+                out = pic.compress_with_caesium(
+                    original=svg,
+                    out_dir=out_dir,
+                    caesium_threads=1,
+                    quality=90,
+                    min_savings="2%",
+                )
+
+            self.assertIsNone(out)
+            mocked_which.assert_not_called()
+
+    def test_optimize_svg_content_with_module_uses_optimize_path_with_options(self):
+        with tempfile.TemporaryDirectory() as td:
+            root = Path(td)
+            svg = root / "vector.svg"
+            svg.write_text("<svg></svg>", encoding="utf-8")
+            captured_options = {}
+
+            class FakeOptions:
+                def __init__(self, **kwargs):
+                    captured_options.update(kwargs)
+
+            fake_module = mock.Mock()
+            fake_module.OptimizeOptions = FakeOptions
+            fake_module.optimize_path = mock.Mock(return_value="<svg/>")
+            fake_module.optimize_file = None
+            fake_module.optimize = None
+            fake_module.optimize_string = None
+            fake_module.polish = None
+
+            result = pic.optimize_svg_content_with_module(fake_module, svg)
+
+            self.assertEqual(result, "<svg/>")
+            self.assertEqual(fake_module.optimize_path.call_count, 1)
+
+    def test_build_svg_polish_options_balanced_profile(self):
+        captured_options = {}
+
+        class FakeOptions:
+            def __init__(self, **kwargs):
+                captured_options.update(kwargs)
+
+        fake_module = mock.Mock()
+        fake_module.OptimizeOptions = FakeOptions
+
+        options = pic.build_svg_polish_options(fake_module, pic.SVG_PROFILE_BALANCED)
+
+        self.assertIsNotNone(options)
+        self.assertEqual(captured_options["shorten_ids"], True)
+        self.assertEqual(captured_options["enable_viewboxing"], True)
+        self.assertNotIn("strip_ids", captured_options)
+
+    def test_compress_svg_with_svg_polish_returns_none_when_module_missing(self):
+        with tempfile.TemporaryDirectory() as td:
+            root = Path(td)
+            svg = root / "vector.svg"
+            svg.write_text("<svg></svg>", encoding="utf-8")
+            out_dir = root / "out"
+
+            with mock.patch("pptx_image_compress.import_svg_polish_module", return_value=None):
+                out = pic.compress_svg_with_svg_polish(svg, out_dir)
+
+            self.assertEqual(out, None)
+
+    def test_compress_svg_with_svg_polish_uses_python_module(self):
+        with tempfile.TemporaryDirectory() as td:
+            root = Path(td)
+            svg = root / "vector.svg"
+            svg.write_text("<svg>  <g></g>  </svg>", encoding="utf-8")
+            out_dir = root / "out"
+            fake_module = mock.Mock()
+            fake_module.optimize = mock.Mock(return_value="<svg><g/></svg>")
+            fake_module.optimize_path = None
+            fake_module.optimize_file = None
+            fake_module.optimize_string = None
+            fake_module.polish = None
+            fake_module.OptimizeOptions = None
+
+            with mock.patch("pptx_image_compress.import_svg_polish_module", return_value=fake_module):
+                out = pic.compress_svg_with_svg_polish(svg, out_dir)
+
+            self.assertEqual(out, out_dir / "vector.svg")
+            self.assertTrue((out_dir / "vector.svg").exists())
+            self.assertEqual((out_dir / "vector.svg").read_text(encoding="utf-8"), "<svg><g/></svg>")
+            fake_module.optimize.assert_called_once_with("<svg>  <g></g>  </svg>")
+
+    def test_compress_svg_with_svg_polish_uses_polish_fallback(self):
+        with tempfile.TemporaryDirectory() as td:
+            root = Path(td)
+            svg = root / "vector.svg"
+            svg.write_text("<svg>  <path/></svg>", encoding="utf-8")
+            out_dir = root / "out"
+            fake_module = mock.Mock()
+            fake_module.optimize = None
+            fake_module.polish = mock.Mock(return_value="<svg><path/></svg>")
+
+            with mock.patch("pptx_image_compress.import_svg_polish_module", return_value=fake_module):
+                out = pic.compress_svg_with_svg_polish(svg, out_dir)
+
+            self.assertEqual(out, out_dir / "vector.svg")
+            fake_module.polish.assert_called_once_with("<svg>  <path/></svg>")
+
+    def test_compress_image_with_routing_does_not_fallback_to_raster_for_svg(self):
+        with tempfile.TemporaryDirectory() as td:
+            root = Path(td)
+            original = root / "vector.svg"
+            original.write_text("<svg></svg>", encoding="utf-8")
+            out_dir = root / "out"
+
+            def fake_compressor(original_path: Path, out_subdir: Path, caesium_threads: int | None, quality: int, min_savings: str):
+                raise AssertionError("Raster compressor must not run for svg")
+
+            with mock.patch("pptx_image_compress.compress_vector_image", return_value=None):
+                out = pic.compress_image_with_routing(
+                    compressor=fake_compressor,
+                    original=original,
+                    out_dir=out_dir,
+                    caesium_threads=1,
+                    quality=90,
+                    min_savings="2%",
+                )
+
+            self.assertIsNone(out)
+
+
 if __name__ == "__main__":
     unittest.main()