Cleanup SVGO

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>

README.md

@@ -1,6 +1,6 @@
 
 # PPTX Image Compressor (CaesiumCLT only)
-**Version 1.1.7**
+**Version 1.1.8**
 
 Dieses Paket enthält:
 
@@ -27,26 +27,28 @@ 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: `agressive`)
 - 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.1.8
-- PNG->JPG Fallback für große PNGs (> 500 KB nach Kompression) hinzugefügt
+- SVG Files werden bei Vorhandensein von svg-polish anhand von 2 Profilen optimiert: balanced|agressive
-- CSV-Logging um `image_type_changed` erweitert (`png_jpg` bei Typwechsel)
 
 ## 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|agressive`
 
 ## 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

install_and_run.bat

@@ -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 ^
@@ -113,6 +125,59 @@ if not exist "%SCRIPT%" (
 set "RUN_ARGS=%*"
 if "%~1"=="" 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 svg-polish
+    ) else (
+        "%PY_CMD%" -m pip install --disable-pip-version-check --quiet 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.
+    )
+) else (
+    echo [WARN] pip konnte nicht eingerichtet werden. SVG-Dateien werden nicht komprimiert.
+)
+
 echo.
 echo [%APP_NAME%] Starte ...
 echo Command: "%PY_CMD%" "%SCRIPT%" %RUN_ARGS%

pptx_image_compress.py

@@ -1,16 +1,11 @@
 #!/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.8
 
-
+Änderungen in 1.1.8:
-Highlights:
+- SVG Files werden bei Vorhandensein von svg_polish anhand von 2 Profilen optimiert: balanced|agressive
-- Caesium-Scratch außerhalb des PPTX-Arbeitsverzeichnisses -> keine Tempfiles in finaler PPTX
-- 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 +16,7 @@ Highlights:
 """
 
 import argparse
+import importlib
 import inspect
 import os
 import re
@@ -42,14 +38,20 @@ from typing import Callable, List, Optional
 
 
 
-__version__ = "1.1.7"
+__version__ = "1.1.8"
 
-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_AGGRESSIVE
+    
 
 @dataclass
 class DeckResult:
@@ -148,13 +150,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 +220,168 @@ 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(
+                digits=3,
+                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,
+            )
+        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 +475,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 +486,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 +546,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 +606,7 @@ def process_single_deck(
                 quality=quality,
                 min_savings=min_savings,
                 compressor=compressor,
+                svg_profile=svg_profile,
             )
 
             with lock:
@@ -577,6 +745,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 +763,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
@@ -665,9 +836,11 @@ def extractParserArguments():
     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('--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
 
 

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(
@@ -244,5 +246,172 @@ 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(captured_options["digits"], 2)
+            self.assertEqual(captured_options["indent_type"], "none")
+            self.assertEqual(captured_options["newlines"], False)
+            self.assertEqual(captured_options["strip_xml_prolog"], True)
+            self.assertEqual(captured_options["strip_comments"], True)
+            self.assertEqual(captured_options["strip_ids"], True)
+            self.assertEqual(captured_options["renderer_workaround"], False)
+            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["digits"], 3)
+        self.assertEqual(captured_options["group_collapse"], 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()