3.15: solved link issues

Author: sba72

library/functions.po

@@ -2129,12 +2129,12 @@ msgid ""
 "``-`` (with no space in between), have leading zeros, be surrounded by "
 "whitespace, and have single underscores interspersed between digits."
 msgstr ""
-"Wenn das Argument keine Zahl ist oder wenn *base* angegeben wird, muss es "
-"sich um eine :class:`str`, :class:`bytes` oder :class:`bytearray` Instanz "
-"handeln, die eine Ganzzahl zur Basis *base* darstellt. Optional kann der "
+"Ist das Argument keine Zahl oder wird *base* angegeben, muss es eine "
+"Zeichenkette oder eine Instanz von :class:`bytes` oder :class:`bytearray` "
+"sein, die eine Ganzzahl zur Basis *base* darstellt. Optional kann der "
 "Zeichenkette ein ``+`` oder ``-`` vorangestellt sein (ohne Leerzeichen "
-"dazwischen); zudem kann sie führende Nullen aufweisen, von Leerzeichen "
-"umgeben sein und einzelne Unterstriche zwischen den Ziffern enthalten."
+"dazwischen), sie kann führende Nullen haben, von Whitespace umgeben sein "
+"und einzelne Unterstriche zwischen den Ziffern eingestreut haben."
 
 #: ../../library/functions.rst:1074
 msgid ""
@@ -3151,15 +3151,16 @@ msgstr ""
 "Operandentypen handelt, gelten die Regeln zur Typanpassung für binäre "
 "arithmetische Operatoren. Bei Operanden vom Typ :class:`int` hat das "
 "Ergebnis denselben Typ wie die Operanden (nach der Typanpassung), es sei "
-"denn, das zweite Argument ist negativ; in diesem Fall werden alle Argumente "
-"in :class:`float` umgewandelt und das Ergebnis ist vom Typ :class:`float`. "
-"So liefert beispielsweise ``pow(10, 2)`` den Wert ``100``, während ``pow(10, "
+"denn, das zweite Argument ist negativ; in diesem Fall werden alle "
+"Argumente in float umgewandelt und ein float-Ergebnis geliefert. So "
+"liefert beispielsweise ``pow(10, 2)`` den Wert ``100``, während ``pow(10, "
 "-2)`` den Wert ``0.01`` ergibt. Bei einer negativen Basis vom Typ :class:"
-"`int` oder :class:`float` und einem nicht ganzzahligen Exponenten wird ein "
-"komplexes Ergebnis geliefert. Zum Beispiel liefert ``pow(-9, 0.5)`` einen "
-"Wert nahe ``3j``. Ist die Basis hingegen negativ (vom Typ :class:`int` oder :"
-"class:`float`) und der Exponent ganzzahlig, so wird ein Ergebnis vom Typ :"
-"class:`float` geliefert. So ergibt ``pow(-9, 2.0)`` beispielsweise ``81.0``."
+"`int` oder :class:`float` und einem nicht ganzzahligen Exponenten wird "
+"ein komplexes Ergebnis geliefert. Zum Beispiel liefert ``pow(-9, 0.5)`` "
+"einen Wert nahe ``3j``. Ist die Basis hingegen negativ (vom Typ :class:"
+"`int` oder :class:`float`) und der Exponent ganzzahlig, so wird ein "
+"float-Ergebnis geliefert. So ergibt ``pow(-9, 2.0)`` beispielsweise "
+"``81.0``."
 
 #: ../../library/functions.rst:1609
 msgid ""
@@ -4277,15 +4278,16 @@ msgid ""
 "__dict__` attribute. The following two statements create identical :class:`!"
 "type` objects:"
 msgstr ""
-"Gibt bei Angabe von drei Argumenten ein neues Typobjekt zurück. Dies ist im "
-"Wesentlichen eine dynamische Form der :keyword:`class`-Anweisung. Die "
-"Zeichenkette *name* ist der Klassenname und wird zum Attribut :attr:`~type."
-"__name__`. Das Tupel *bases* enthält die Basisklassen und wird zum Attribut :"
-"attr:`~type.__bases__`; ist es leer, wird :class:`object` – die gemeinsame "
-"Basisklasse aller Klassen – hinzugefügt. Das Dictionary *dict* enthält "
-"Attribut- und Methodendefinitionen für den Klassenkörper; es kann kopiert "
-"oder gekapselt werden, bevor es zum Attribut :attr:`~type.__dict__` wird. "
-"Die folgenden beiden Anweisungen erzeugen identische :class:`type`-Objekte:"
+"Gibt bei Angabe von drei Argumenten ein neues Typobjekt zurück. Dies ist "
+"im Wesentlichen eine dynamische Form der :keyword:`class`-Anweisung. Die "
+"Zeichenkette *name* ist der Klassenname und wird zum Attribut :attr:"
+"`~type.__name__`. Das Tupel *bases* enthält die Basisklassen und wird "
+"zum Attribut :attr:`~type.__bases__`; ist es leer, wird :class:`object` "
+"– die gemeinsame Basisklasse aller Klassen – hinzugefügt. Das Dictionary "
+"*dict* enthält Attribut- und Methodendefinitionen für den Klassenkörper; "
+"es kann kopiert oder gekapselt werden, bevor es zum Attribut :attr:"
+"`~type.__dict__` wird. Die folgenden beiden Anweisungen erzeugen "
+"identische :class:`!type`-Objekte:"
 
 #: ../../library/functions.rst:2172
 msgid "See also:"
@@ -4600,14 +4602,15 @@ msgid ""
 "implementation is in use.  Direct use of :func:`__import__` is also "
 "discouraged in favor of :func:`importlib.import_module`."
 msgstr ""
-"Diese Funktion wird durch die :keyword:`import`-Anweisung aufgerufen. Sie "
-"kann ersetzt werden (durch Importieren des Moduls :mod:`builtins` und "
-"Zuweisung an ``builtins.__import__``), um die Semantik der :keyword:`import`-"
-"Anweisung zu ändern; davon wird jedoch **dringend** abgeraten. Es ist meist "
-"einfacher, Import-Hooks (siehe :pep:`302`) zu verwenden, um dieselben Ziele "
-"zu erreichen, ohne Probleme bei Code zu verursachen, der von der Standard-"
-"Importimplementierung ausgeht. Auch von der direkten Verwendung von :func:"
-"`__import__` wird zugunsten von :func:`importlib.import_module` abgeraten."
+"Diese Funktion wird durch die :keyword:`import`-Anweisung aufgerufen. "
+"Sie kann ersetzt werden (durch Importieren des Moduls :mod:`builtins` "
+"und Zuweisung an ``builtins.__import__``), um die Semantik der :keyword:"
+"`!import`-Anweisung zu ändern; davon wird jedoch **dringend** "
+"abgeraten. Es ist meist einfacher, Import-Hooks (siehe :pep:`302`) zu "
+"verwenden, um dieselben Ziele zu erreichen, ohne Probleme bei Code zu "
+"verursachen, der von der Standard-Importimplementierung ausgeht. Auch "
+"von der direkten Verwendung von :func:`__import__` wird zugunsten von "
+":func:`importlib.import_module` abgeraten."
 
 #: ../../library/functions.rst:2336
 msgid ""
@@ -4635,11 +4638,12 @@ msgid ""
 "directory of the module calling :func:`__import__` (see :pep:`328` for the "
 "details)."
 msgstr ""
-"*level* gibt an, ob absolute oder relative Importe verwendet werden sollen. "
-"``0`` (der Standard) bedeutet, dass nur absolute Importe durchgeführt "
-"werden. Positive Werte für „level“ geben die Anzahl der übergeordneten "
-"Verzeichnisse an, die ausgehend vom Verzeichnis des Moduls, das __import__() "
-"aufruft, durchsucht werden sollen. (siehe :pep:`328` für mehr Details)."
+"*level* gibt an, ob absolute oder relative Importe verwendet werden "
+"sollen. ``0`` (der Standard) bedeutet, dass nur absolute Importe "
+"durchgeführt werden. Positive Werte für *level* geben die Anzahl der "
+"übergeordneten Verzeichnisse an, die ausgehend vom Verzeichnis des "
+"Moduls, das :func:`__import__` aufruft, durchsucht werden sollen (siehe "
+":pep:`328` für die Details)."
 
 #: ../../library/functions.rst:2349
 msgid ""

library/string.po

@@ -1807,7 +1807,7 @@ msgstr ""
 
 #: ../../library/string.rst:911
 msgid "Here is an example of how to use a Template::"
-msgstr "Hier ist ein Beispiel für die Verwendung von :class:`Template`::"
+msgstr "Hier ist ein Beispiel für die Verwendung eines Template::"
 
 #: ../../library/string.rst:913
 msgid ""

po_status.py

@@ -0,0 +1,126 @@
+#!/usr/bin/env python3
+"""
+po_status.py — Listet alle .po-Dateien in einem Verzeichnisbaum mit
+Übersetzungsstand (x/y), Prozent, Dateigröße und Pfad und Status Gesamtübersetzung.
+"""
+import argparse
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+STATS_RE = re.compile(
+    r"(?:(\d+) translated messages?)?"
+    r"(?:, (\d+) fuzzy translations?)?"
+    r"(?:, (\d+) untranslated messages?)?"
+)
+
+
+def get_stats(po_file: Path):
+    """Ruft msgfmt --statistics auf und parst das Ergebnis."""
+    try:
+        result = subprocess.run(
+            ["msgfmt", "--statistics", "-o", "/dev/null", str(po_file)],
+            capture_output=True, text=True, timeout=15,
+        )
+    except FileNotFoundError:
+        sys.exit("Fehler: 'msgfmt' wurde nicht gefunden. Ist gettext installiert "
+                 "(z.B. 'brew install gettext' + PATH-Anpassung)?")
+
+    output = (result.stderr or "") + (result.stdout or "")
+    if "error" in output.lower() and "translated" not in output.lower():
+        return None  # Syntaxfehler in der Datei
+
+    m = STATS_RE.search(output)
+    if not m:
+        return {"translated": 0, "fuzzy": 0, "untranslated": 0}
+    translated, fuzzy, untranslated = (int(x) if x else 0 for x in m.groups())
+    return {"translated": translated, "fuzzy": fuzzy, "untranslated": untranslated}
+
+
+def human_size(num_bytes: int) -> str:
+    for unit in ("B", "KB", "MB"):
+        if num_bytes < 1024:
+            return f"{num_bytes:.0f} {unit}" if unit == "B" else f"{num_bytes:.1f} {unit}"
+        num_bytes /= 1024
+    return f"{num_bytes:.1f} GB"
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("path", nargs="?", default=".", help="Wurzelverzeichnis (Standard: .)")
+    parser.add_argument("--exclude", default="c-api,.venv,.git",
+                         help="Kommagetrennte Ordnernamen, die übersprungen werden")
+    parser.add_argument("--sort", choices=["path", "percent", "size"], default="percent")
+    parser.add_argument("--max-percent", type=float, default=100.1,
+                         help="Nur Dateien mit weniger als diesem Prozentwert anzeigen")
+    args = parser.parse_args()
+
+    root = Path(args.path).resolve()
+    excludes = {e.strip() for e in args.exclude.split(",") if e.strip()}
+
+    po_files = sorted(
+        p for p in root.rglob("*.po")
+        if not excludes.intersection(p.relative_to(root).parts)
+    )
+
+    if not po_files:
+        print(f"Keine .po-Dateien unter {root} gefunden.")
+        return
+
+    rows = []
+    for po_file in po_files:
+        stats = get_stats(po_file)
+        rel_path = po_file.relative_to(root)
+        size = po_file.stat().st_size
+        if stats is None:
+            rows.append((str(rel_path), "FEHLER (Syntax)", -1.0, size))
+            continue
+        total = stats["translated"] + stats["fuzzy"] + stats["untranslated"]
+        pct = (stats["translated"] / total * 100) if total else 100.0
+        label = f"{stats['translated']}/{total}"
+        if stats["fuzzy"]:
+            label += f" ({stats['fuzzy']} fuzzy)"
+        rows.append((str(rel_path), label, pct, size))
+
+    # Gesamtstatistik wird VOR dem --max-percent-Filter berechnet (über alle Dateien)
+    complete_count = sum(1 for r in rows if r[2] >= 100.0)
+    error_count = sum(1 for r in rows if r[2] < 0)
+    total_translated = sum(int(r[1].split("/")[0]) for r in rows if r[2] >= 0)
+    total_strings = sum(int(r[1].split("/")[1].split(" ")[0]) for r in rows if r[2] >= 0)
+    overall_pct = (total_translated / total_strings * 100) if total_strings else 0.0
+
+    rows = [r for r in rows if r[2] < args.max_percent or r[2] < 0]
+
+    if not rows:
+        print(f"Alle {len(po_files)} Dateien liegen bei/über --max-percent {args.max_percent} "
+              f"— nichts anzuzeigen.")
+        return
+
+    if args.sort == "percent":
+        rows.sort(key=lambda r: r[2], reverse=True)  # 100% -> 0%
+    elif args.sort == "size":
+        rows.sort(key=lambda r: -r[3])
+
+    path_w = max(len(r[0]) for r in rows) + 2
+    label_w = max(len(r[1]) for r in rows) + 2
+
+    print(f"{'Pfad':<{path_w}}{'Übersetzt':<{label_w}}{'%':>7}   {'Größe':>8}")
+    print("-" * (path_w + label_w + 20))
+    for rel_path, label, pct, size in rows:
+        pct_str = "  n/a" if pct < 0 else f"{pct:6.1f}%"
+        print(f"{rel_path:<{path_w}}{label:<{label_w}}{pct_str:>7}   {human_size(size):>8}")
+
+    print("-" * (path_w + label_w + 20))
+    print(f"{len(rows)} von {len(po_files)} Dateien angezeigt "
+          f"(Filter: --max-percent {args.max_percent})")
+    print()
+    print(f"Vollständig übersetzt (100%): {complete_count} von {len(po_files)} Dateien")
+    if error_count:
+        print(f"Dateien mit Syntaxfehler:      {error_count}")
+    print(f"Gesamtstand über alle Dateien:  {total_translated}/{total_strings} Strings "
+          f"({overall_pct:.2f}%)")
+
+
+if __name__ == "__main__":
+    main()