sitemap-tracker 2.13.1__py3-none-any.whl

sitemap_tracker/__init__.py

@@ -0,0 +1,5 @@
+"""Sitemap Tracker - Crawlt Websites, erzeugt sitemap.xml, trackt Dead-Links."""
+
+__version__ = "2.13.1"
+__author__ = "Michael Blaess"
+__year__ = "2026"

sitemap_tracker/__main__.py

@@ -0,0 +1,389 @@
+"""Entry Point fuer Sitemap Tracker."""
+
+from __future__ import annotations
+
+import argparse
+import contextlib
+import os
+import sys
+from typing import TYPE_CHECKING, TextIO
+
+if TYPE_CHECKING:
+    from sys import UnraisableHookArgs
+
+# Frozen-EXE Erkennung (PyInstaller UND Nuitka):
+# PLAYWRIGHT_BROWSERS_PATH muss gesetzt werden BEVOR playwright importiert wird,
+# damit das gebundelte Chromium im "browsers"-Unterordner gefunden wird.
+# PyInstaller setzt sys.frozen, Nuitka setzt stattdessen __compiled__.
+_is_frozen = getattr(sys, "frozen", False) or "__compiled__" in globals()
+if _is_frozen:
+    _exe_dir = os.path.dirname(sys.executable)
+    _browsers_dir = os.path.join(_exe_dir, "browsers")
+    if os.path.isdir(_browsers_dir):
+        os.environ["PLAYWRIGHT_BROWSERS_PATH"] = _browsers_dir
+
+from textual_widgets import reset_terminal_title, set_terminal_title
+
+# Log-Handle offen halten, solange der Prozess laeuft - faulthandler schreibt
+# beim fatalen Signal direkt hinein. Ohne Referenz wuerde der GC es schliessen.
+_fault_log: TextIO | None = None
+
+from sitemap_tracker import __version__
+from sitemap_tracker.i18n import load_locale, t
+from sitemap_tracker.models.settings import Settings
+
+
+def _migrate_user_data() -> None:
+    """Kopiert ``~/.sitemap-generator/`` einmalig nach ``~/.sitemap-tracker/``.
+
+    Das Tool hiess bis v1.x ``sitemap-generator`` und legte Settings sowie
+    History unter ``~/.sitemap-generator/`` ab. Beim ersten Start unter dem
+    neuen Namen ``sitemap-tracker`` werden Bestandskunden-Daten kopiert,
+    damit History und Einstellungen nicht verloren gehen.
+
+    Markiert das alte Verzeichnis mit ``.migrated_to_tracker``, damit die
+    Kopie nicht erneut ueberschreibt — der User kann das alte Verzeichnis
+    danach gefahrlos selbst loeschen.
+    """
+    import shutil
+    from pathlib import Path
+
+    old_dir = Path.home() / ".sitemap-generator"
+    new_dir = Path.home() / ".sitemap-tracker"
+    marker = old_dir / ".migrated_to_tracker"
+    if not old_dir.is_dir() or new_dir.exists() or marker.exists():
+        return
+    try:
+        shutil.copytree(old_dir, new_dir)
+        marker.write_text("Daten kopiert nach ~/.sitemap-tracker/\n", encoding="utf-8")
+    except Exception:
+        # Im Zweifel still abbrechen — fehlende Migration ist kein Fehlerfall,
+        # der User startet einfach mit Default-Settings.
+        pass
+
+
+def _silence_windows_teardown_noise() -> None:
+    """Blendet die bekannten asyncio/playwright-Teardown-Meldungen aus.
+
+    Drei Quellen, drei Filter:
+
+    1. ``ResourceWarning: unclosed transport`` aus den ``__del__``-Methoden
+       der Proactor-Pipes (Windows asyncio + Playwright-Subprozess) — via
+       ``warnings.filterwarnings``.
+    2. ``Exception ignored in: <function _ProactorBasePipeTransport.__del__>``
+       mit ``ValueError: I/O operation on closed pipe`` — via
+       ``sys.unraisablehook``.
+    3. ``Future exception was never retrieved`` (z.B.
+       ``net::ERR_ABORTED; maybe frame was detached?``) aus internen
+       Playwright-Tasks, die nach dem Browser-Close noch eine Antwort
+       erwarten — via ``loop.set_exception_handler``. Tritt vor allem im
+       Nuitka-Compilat auf, wo das Timing leicht anders ist.
+    """
+    import asyncio
+    import warnings
+
+    warnings.filterwarnings("ignore", category=ResourceWarning, message=".*unclosed transport.*")
+    warnings.filterwarnings("ignore", category=ResourceWarning, message=".*subprocess.*")
+
+    prev = sys.unraisablehook
+
+    def _hook(unraisable: UnraisableHookArgs) -> None:
+        exc = unraisable.exc_value
+        if isinstance(exc, ValueError) and "closed pipe" in str(exc):
+            return
+        if isinstance(exc, ResourceWarning):
+            return
+        prev(unraisable)
+
+    sys.unraisablehook = _hook
+
+    def _loop_exc_handler(loop: asyncio.AbstractEventLoop, context: dict) -> None:
+        msg = str(context.get("message", ""))
+        exc = context.get("exception")
+        exc_msg = str(exc) if exc is not None else ""
+        if "never retrieved" in msg or "net::ERR_ABORTED" in exc_msg or "frame was detached" in exc_msg:
+            return  # bekannte playwright/cleanup-Reste — ignorieren
+        loop.default_exception_handler(context)
+
+    # Asyncio nutzt den Event-Loop-Exception-Handler fuer
+    # "Future exception was never retrieved". Wir installieren ihn pro
+    # Loop, sobald ein Loop existiert — beim Programmstart ist meist
+    # noch keiner aktiv, deshalb haengen wir uns in den Policy-Loop-
+    # Factory-Mechanismus.
+    base_policy = asyncio.get_event_loop_policy()
+
+    class _PatchedPolicy(type(base_policy)):  # type: ignore[misc]
+        def new_event_loop(self) -> asyncio.AbstractEventLoop:
+            loop = super().new_event_loop()
+            loop.set_exception_handler(_loop_exc_handler)
+            return loop
+
+    with contextlib.suppress(Exception):
+        asyncio.set_event_loop_policy(_PatchedPolicy())
+
+
+def _preinit_graphics() -> None:
+    """Initialisiert textual-image vor dem App-Start.
+
+    textual-image sendet beim Import Terminal-Queries (DA1, Cell-Size).
+    Diese muessen laufen, bevor Textual stdin uebernimmt - sonst landen die
+    Antworten als Muell-Input in Textual-Widgets.
+    """
+    try:
+        import textual_image.renderable  # noqa: F401
+        import textual_image.widget  # noqa: F401
+        from textual_image._terminal import get_cell_size
+
+        get_cell_size()
+    except Exception:
+        pass
+
+
+def main() -> None:
+    """Haupteinstiegspunkt fuer die CLI."""
+    _enable_faulthandler()
+    # Einmalige Migration der User-Daten vom alten Tool-Namen
+    # (sitemap-generator) — muss VOR ``Settings.load()`` laufen.
+    _migrate_user_data()
+
+    # Sprache aus Settings laden (fuer CLI-Hilfe)
+    settings = Settings.load()
+
+    # Vorab --lang aus sys.argv parsen (vor argparse),
+    # damit Banner und Hilfetexte uebersetzt sind
+    lang = settings.language
+    for i, arg in enumerate(sys.argv[1:]):
+        if arg == "--lang" and i + 1 < len(sys.argv[1:]):
+            lang = sys.argv[i + 2]
+            break
+        if arg.startswith("--lang="):
+            lang = arg.split("=", 1)[1]
+            break
+
+    load_locale(lang)
+
+    # Sprache in Settings persistieren
+    if lang != settings.language:
+        settings.language = lang
+        settings.save()
+
+    parser = argparse.ArgumentParser(
+        prog="sitemap-tracker",
+        description=t("cli.banner", version=__version__),
+        epilog=t("cli.examples"),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+
+    parser.add_argument(
+        "url",
+        nargs="?",
+        default="",
+        metavar="URL",
+        help=t("cli.url_help"),
+    )
+    parser.add_argument(
+        "--output",
+        "-o",
+        default="",
+        metavar="PATH",
+        help=t("cli.output_help"),
+    )
+    parser.add_argument(
+        "--max-depth",
+        "-d",
+        type=int,
+        default=None,
+        metavar="N",
+        help=t("cli.max_depth_help"),
+    )
+    parser.add_argument(
+        "--concurrency",
+        "-c",
+        type=int,
+        default=None,
+        metavar="N",
+        help=t("cli.concurrency_help"),
+    )
+    parser.add_argument(
+        "--timeout",
+        "-t",
+        type=int,
+        default=None,
+        metavar="SEC",
+        help=t("cli.timeout_help"),
+    )
+    parser.add_argument(
+        "--render",
+        action="store_true",
+        default=False,
+        help=t("cli.render_help"),
+    )
+    parser.add_argument(
+        "--no-headless",
+        action="store_true",
+        default=False,
+        help=t("cli.no_headless_help"),
+    )
+    parser.add_argument(
+        "--rate-limit",
+        type=int,
+        default=None,
+        metavar="N",
+        help=t("cli.rate_limit_help"),
+    )
+    parser.add_argument(
+        "--ignore-robots",
+        action="store_true",
+        default=False,
+        help=t("cli.ignore_robots_help"),
+    )
+    parser.add_argument(
+        "--user-agent",
+        default="",
+        metavar="UA",
+        help=t("cli.user_agent_help"),
+    )
+    parser.add_argument(
+        "--cookie",
+        action="append",
+        default=[],
+        metavar="NAME=VALUE",
+        help=t("cli.cookie_help"),
+    )
+    parser.add_argument(
+        "--lang",
+        default=lang,
+        choices=["de", "en"],
+        help="Sprache / Language (de, en)",
+    )
+
+    args = parser.parse_args()
+
+    # Cookies parsen: "NAME=VALUE" -> {"name": "NAME", "value": "VALUE"}
+    cookies = []
+    for cookie_str in args.cookie:
+        if "=" not in cookie_str:
+            print(t("cli.invalid_cookie", cookie=cookie_str))
+            sys.exit(1)
+        name, value = cookie_str.split("=", 1)
+        cookies.append({"name": name.strip(), "value": value.strip()})
+
+    # Pruefen ob das Argument eine lokale XML-Datei ist
+    sitemap_file = ""
+    start_url = args.url
+    if start_url and os.path.isfile(start_url) and start_url.lower().endswith(".xml"):
+        sitemap_file = os.path.abspath(start_url)
+        start_url = ""  # Wird aus der XML-Datei ermittelt
+
+    # Teardown-Rauschen aus playwright/asyncio auf Windows ausblenden.
+    _silence_windows_teardown_noise()
+
+    # textual-image vor App-Start initialisieren — IMMER, nicht nur bei
+    # aktivierter Vorschau. Das `PreviewPanel`-Widget wird im DOM auch dann
+    # erzeugt, wenn die Vorschau aus ist (nur unsichtbar), und sein
+    # __init__ kann textual-image lazy nachladen, sobald der User die
+    # Vorschau spaeter einschaltet. Wenn der Import erst nach Textual-
+    # Stdin-Hijack passiert, blutet die DA1/Cell-Size-Antwort des Terminals
+    # ins Eingabefeld. Einmal vorab importieren, fertig.
+    _preinit_graphics()
+
+    from sitemap_tracker.app import SitemapTrackerApp
+
+    # Terminal-Tab-Titel setzen - Textual macht das nicht selbst.
+    set_terminal_title(f"sitemap-tracker v{__version__}")
+    try:
+        app = SitemapTrackerApp(
+            start_url=start_url,
+            sitemap_file=sitemap_file,
+            output_path=args.output,
+            max_depth=args.max_depth,
+            concurrency=args.concurrency,
+            rate_per_minute=args.rate_limit,
+            timeout=args.timeout,
+            render=args.render,
+            headless=not args.no_headless,
+            respect_robots=not args.ignore_robots,
+            user_agent=args.user_agent,
+            cookies=cookies,
+        )
+        app.run()
+    finally:
+        reset_terminal_title()
+        _reset_mouse_tracking()
+
+
+def _enable_faulthandler() -> None:
+    """Faengt HARTE Abstuerze ab, die an Pythons Exception-Handling UND am
+    finally-Block vorbeilaufen: native Access Violation, Stack-Overflow, fataler
+    Interpreter-Fehler.
+
+    faulthandler schreibt den Traceback aller Threads in fault.log - separat vom
+    Terminal, das der Maus-Tracking-Muell sonst unlesbar macht. CrashGuard und
+    _persist_crash greifen nur bei normalen Python-Exceptions, dieser Handler bei
+    allem darunter. Die Startzeile ist die zweite Haelfte der Diagnose: steht
+    danach nichts weiter in der Datei, wurde der Prozess von aussen abgeraeumt.
+    """
+    import atexit
+    import contextlib
+    import faulthandler
+    from datetime import datetime
+
+    from .models.settings import SETTINGS_FILE
+
+    global _fault_log
+    with contextlib.suppress(Exception):
+        verzeichnis = SETTINGS_FILE.parent
+        verzeichnis.mkdir(parents=True, exist_ok=True)
+        # Bewusst offen lassen (Prozess-Lebensdauer) - faulthandler schreibt
+        # beim fatalen Signal direkt in dieses Handle.
+        _fault_log = open(verzeichnis / "fault.log", "a", encoding="utf-8")  # noqa: SIM115
+        stamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        _fault_log.write(f"\n===== Start {stamp} - v{__version__} =====\n")
+        _fault_log.flush()
+        faulthandler.enable(file=_fault_log, all_threads=True)
+        # Gegenstueck zur Startzeile - siehe _write_fault_end.
+        atexit.register(_write_fault_end)
+
+
+def _reset_mouse_tracking() -> None:
+    """Schaltet alle Maus-Tracking-Modi des Terminals ab (idempotent).
+
+    Schreibt bewusst nach sys.__stdout__, NICHT sys.stdout: Textual kapert
+    sys.stdout zur Laufzeit, ein Reset dorthin landet im Nichts und das Terminal
+    bleibt im Maus-Tracking-Modus haengen. Der garantierte Reset passiert im
+    Shell-Wrapper run.ps1 (laeuft auch nach einem harten Crash) - das hier ist
+    der zusaetzliche In-Prozess-Pfad.
+    """
+    stream = sys.__stdout__
+    if stream is None or not stream.isatty():
+        return
+    stream.write("\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1006l\x1b[?1015l")
+    stream.flush()
+
+
+def _write_fault_end() -> None:
+    """Schreibt die Endzeile der Sitzungsklammer (ueber atexit registriert).
+
+    Erst dieses Gegenstueck zur Startzeile macht die Datei aussagekraeftig:
+
+      Start + Ende            -> sauber beendet
+      Start + Traceback       -> Python-Fehler (der Handler hat ihn gesehen)
+      Start und sonst nichts  -> Prozess hart abgeraeumt
+
+    Unter Windows hilft ein Signalhandler dabei nicht: ein Abbruch von aussen
+    laeuft dort ueber TerminateProcess und liefert dem Ziel kein abfangbares
+    Signal. Die FEHLENDE Endzeile ist der einzige Beleg.
+    """
+    import contextlib
+    from datetime import datetime
+
+    if _fault_log is None:
+        return
+    with contextlib.suppress(Exception):
+        stamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        _fault_log.write(f"===== Ende {stamp} =====\n")
+        _fault_log.flush()
+
+
+if __name__ == "__main__":
+    main()