gaeb-cli 0.5.2__py3-none-any.whl

gaeb_cli/__init__.py

@@ -0,0 +1,3 @@
+"""GAEB CLI – Command-line tool for GAEB files."""
+
+__version__ = "0.5.2"

gaeb_cli/main.py

@@ -0,0 +1,430 @@
+"""gaeb-cli – Kommandozeilen-Tool für GAEB-Dateien."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+import typer
+from gaeb.io.excel.reader import read as read_excel
+from gaeb.io.excel.writer import write as write_excel
+from gaeb.io.gaeb90.reader import read as read_gaeb90
+from gaeb.io.gaeb90.writer import write as write_gaeb90
+from gaeb.io.gaeb2000.reader import read as read_gaeb2000
+from gaeb.io.gaeb2000.writer import write as write_gaeb2000
+from gaeb.io.xml.reader import read as read_xml
+from gaeb.io.xml.writer import write as write_xml
+from rich import box
+from rich.console import Console
+from rich.table import Table
+
+import gaeb
+
+
+def _fmt_feldwert(wert: object) -> str:
+    """Formatiert einen Diff-Feldwert für die Tabellenausgabe."""
+    if isinstance(wert, list):
+        zeilen = [str(z) for z in wert]
+        if len(zeilen) <= 2:
+            return " / ".join(zeilen)
+        return " / ".join(zeilen[:2]) + f" … (+{len(zeilen) - 2})"
+    return str(wert)
+
+
+app = typer.Typer(
+    name="gaeb",
+    help="Lesen, Schreiben und Konvertieren von GAEB-Dateien (AVA).",
+    no_args_is_help=True,
+)
+console = Console()
+err = Console(stderr=True, style="bold red")
+
+# Bekannte Dateiendungen
+_GAEB90_EXT = {
+    ".d80", ".d81", ".d82", ".d83", ".d84", ".d85", ".d86",
+    ".d87", ".d88", ".d89",
+}
+_GAEB2000_EXT = {
+    ".p80", ".p81", ".p82", ".p83", ".p84", ".p85", ".p86",
+    ".p87", ".p88", ".p89",
+}
+_XML_EXT = {
+    # Mengenermittlung / Kosten
+    ".x31", ".x50", ".x51", ".x52",
+    # Procurement
+    ".x80", ".x81", ".x82", ".x83", ".x84", ".x85", ".x86",
+    ".x87", ".x88", ".x89",
+    # Trade
+    ".x93", ".x94", ".x95", ".x96", ".x97",
+}
+
+
+def _detect_format(path: Path) -> str:
+    ext = path.suffix.lower()
+    if ext in _GAEB90_EXT:
+        return "gaeb90"
+    if ext in _GAEB2000_EXT:
+        return "gaeb2000"
+    if ext in _XML_EXT:
+        return "xml"
+    if ext == ".xlsx":
+        return "excel"
+    err.print(f"[red]Unbekannte Dateiendung: {ext}[/red]")
+    raise typer.Exit(1)
+
+
+def _read(path: Path, encoding: str | None = None) -> gaeb.Leistungsverzeichnis:
+    if not path.exists():
+        err.print(f"Datei nicht gefunden: {path}")
+        raise typer.Exit(1)
+    fmt = _detect_format(path)
+    try:
+        if fmt == "excel":
+            return read_excel(path)
+        if fmt == "gaeb90":
+            return read_gaeb90(path, encoding=encoding)
+        if fmt == "gaeb2000":
+            return read_gaeb2000(path)
+        return read_xml(path)
+    except PermissionError:
+        err.print(f"Keine Leseberechtigung: {path}")
+        raise typer.Exit(1)
+    except Exception as exc:
+        err.print(f"Fehler beim Lesen von {path.name}: {type(exc).__name__}: {exc}")
+        raise typer.Exit(1)
+
+
+# ------------------------------------------------------------------ #
+# gaeb info <datei>
+# ------------------------------------------------------------------ #
+
+@app.command()
+def info(
+    datei: Path = typer.Argument(..., help="GAEB-Datei (.d83, .x83, ...)"),
+    encoding: str | None = typer.Option(None, "--encoding", "-e", help="Zeichenkodierung (z.B. cp850, cp1252). Nur für GAEB 90."),
+):
+    """Zeigt Metadaten einer GAEB-Datei."""
+    lv = _read(datei, encoding=encoding)
+
+    ext = datei.suffix.lower()
+    if ext in _GAEB90_EXT:
+        fmt = "GAEB 90"
+    elif ext in _GAEB2000_EXT:
+        fmt = "GAEB 2000"
+    else:
+        fmt = f"GAEB DA XML{f' {lv.xml_version}' if lv.xml_version else ''}"
+
+    console.print()
+    console.print(f"[bold]Datei:[/bold]         {datei.name}")
+    fmt_enc = f"{fmt}  [dim](Encoding: {lv.encoding})[/dim]" if lv.encoding else fmt
+    console.print(f"[bold]Format:[/bold]        {fmt_enc}")
+    console.print(f"[bold]Phase:[/bold]         {lv.phase.value if lv.phase else '—'}  ({lv.phase.name if lv.phase else '—'})")
+    console.print(f"[bold]LV-Titel:[/bold]      {lv.titel_lv or '—'}")
+    console.print(f"[bold]Projekt:[/bold]       {lv.projekt or '—'}")
+    console.print(f"[bold]Auftraggeber:[/bold]  {lv.auftraggeber or '—'}")
+    if lv.auftragnehmer:
+        console.print(f"[bold]Auftragnehmer:[/bold] {lv.auftragnehmer}")
+    console.print(f"[bold]Währung:[/bold]       {lv.waehrung}")
+    console.print(f"[bold]Titel:[/bold]         {len(lv.titel)} (top-level)")
+    console.print(f"[bold]Positionen:[/bold]    {len(lv.alle_positionen)} gesamt")
+    if lv.vorbemerkungen:
+        nicht_leer = [z for z in lv.vorbemerkungen if z.strip()]
+        console.print(f"[bold]Vorbemerkungen:[/bold] {len(nicht_leer)} Zeilen")
+    gs = lv.gesamtsumme
+    if gs is not None:
+        console.print(f"[bold]Gesamtsumme:[/bold]   {gs:,.2f} {lv.waehrung}")
+    console.print()
+
+
+# ------------------------------------------------------------------ #
+# gaeb show <datei>
+# ------------------------------------------------------------------ #
+
+@app.command()
+def show(
+    datei: Path = typer.Argument(..., help="GAEB-Datei (.d83, .x83, ...)"),
+    langtext: bool = typer.Option(False, "--langtext", "-l", help="Langtext anzeigen"),
+    encoding: str | None = typer.Option(None, "--encoding", "-e", help="Zeichenkodierung (z.B. cp850, cp1252). Nur für GAEB 90."),
+):
+    """Zeigt alle Positionen als Tabelle."""
+    lv = _read(datei, encoding=encoding)
+
+    # Zeitvertrag-Felder nur anzeigen wenn mindestens eine Position sie hat
+    hat_z_felder = any(
+        p.periodqty is not None or p.min_menge is not None or p.max_menge is not None
+        for p in lv.alle_positionen
+    )
+
+    table = Table(
+        title=f"{lv.titel_lv or datei.name}  [dim](Phase {lv.phase.value if lv.phase else '?'})[/dim]",
+        box=box.SIMPLE_HEAD,
+        show_lines=langtext,
+    )
+    table.add_column("OZ", style="cyan", no_wrap=True)
+    table.add_column("Kurztext")
+    table.add_column("Menge", justify="right", style="yellow")
+    table.add_column("Einheit", justify="center")
+    if hat_z_felder:
+        table.add_column("PeriodQty", justify="right", style="dim yellow")
+        table.add_column("MinQty", justify="right", style="dim yellow")
+        table.add_column("MaxQty", justify="right", style="dim yellow")
+    table.add_column("EP", justify="right", style="green")
+    table.add_column("GP", justify="right", style="bold green")
+
+    for pos in lv.alle_positionen:
+        ep = f"{pos.einheitspreis:,.3f}" if pos.einheitspreis is not None else "—"
+        gp = f"{pos.gesamtpreis:,.2f}" if pos.gesamtpreis is not None else "—"
+        menge = f"{pos.menge:,}" if pos.menge is not None else "—"
+        kurztext = pos.kurztext
+        if langtext and pos.langtext:
+            kurztext += "\n[dim]" + "\n".join(pos.langtext[:3]) + "[/dim]"
+        zeile = [pos.oz, kurztext, menge, pos.einheit]
+        if hat_z_felder:
+            zeile.append(f"{pos.periodqty:,}" if pos.periodqty is not None else "—")
+            zeile.append(f"{pos.min_menge:,}" if pos.min_menge is not None else "—")
+            zeile.append(f"{pos.max_menge:,}" if pos.max_menge is not None else "—")
+        zeile.extend([ep, gp])
+        table.add_row(*zeile)
+
+    console.print()
+    console.print(table)
+    gs = lv.gesamtsumme
+    if gs is not None:
+        console.print(f"  [bold]Gesamtsumme: {gs:,.2f} {lv.waehrung}[/bold]")
+    console.print()
+
+
+# ------------------------------------------------------------------ #
+# gaeb convert <quelle> <ziel>
+# ------------------------------------------------------------------ #
+
+@app.command()
+def convert(
+    quelle: Path = typer.Argument(..., help="Quelldatei"),
+    ziel: Path = typer.Argument(..., help="Zieldatei (Format aus Endung abgeleitet)"),
+    phase: str | None = typer.Option(
+        None, "--phase", "-p",
+        help="Zielphase überschreiben (z.B. 84 für Angebotsabgabe)"
+    ),
+    lese_encoding: str | None = typer.Option(None, "--lese-encoding", help="Lesekodierung für GAEB-90-Quelldatei (z.B. cp850, cp1252)."),
+    schreib_encoding: str | None = typer.Option(None, "--schreib-encoding", help="Schreibkodierung für GAEB-90-Zieldatei (Standard: cp850)."),
+):
+    """Konvertiert eine GAEB-Datei in ein anderes Format oder eine andere Phase."""
+    lv = _read(quelle, encoding=lese_encoding)
+
+    # Phase überschreiben (z.B. D83 → D84)
+    if phase:
+        try:
+            lv.phase = gaeb.Phase(phase)
+        except ValueError:
+            gueltig = ", ".join(p.value for p in gaeb.Phase)
+            err.print(f"Unbekannte Phase: {phase}. Gültig: {gueltig}")
+            raise typer.Exit(1)
+    else:
+        # Phase aus Zieldatei-Endung ableiten
+        ziel_ext = ziel.suffix.lower()
+        # Extrahiere 2 Ziffern aus der Endung (z.B. "83" aus ".d83", ".x83", ".p83")
+        match = re.search(r"(\d{2})", ziel_ext)
+        if match:
+            ziel_phase = match.group(1)
+            try:
+                lv.phase = gaeb.Phase(ziel_phase)
+            except ValueError:
+                pass
+
+    ziel_fmt = _detect_format(ziel)
+    try:
+        if ziel_fmt == "gaeb90":
+            write_gaeb90(lv, ziel, encoding=schreib_encoding or "cp850")
+        elif ziel_fmt == "gaeb2000":
+            write_gaeb2000(lv, ziel, encoding=schreib_encoding or "cp1252")
+        elif ziel_fmt == "excel":
+            write_excel(lv, ziel)
+        else:
+            write_xml(lv, ziel)
+    except ImportError as exc:
+        err.print(f"{exc}")
+        raise typer.Exit(1)
+    except PermissionError:
+        err.print(f"Keine Schreibberechtigung: {ziel}")
+        raise typer.Exit(1)
+    except Exception as exc:
+        err.print(f"Fehler beim Schreiben von {ziel.name}: {type(exc).__name__}: {exc}")
+        raise typer.Exit(1)
+
+    console.print(f"[green]✓[/green] Konvertiert: {quelle.name} → {ziel.name}  (Phase {lv.phase.value if lv.phase else '?'})")
+
+
+# ------------------------------------------------------------------ #
+# gaeb struktur <datei>
+# ------------------------------------------------------------------ #
+
+@app.command()
+def struktur(
+    datei: Path = typer.Argument(..., help="GAEB-Datei"),
+    encoding: str | None = typer.Option(None, "--encoding", "-e", help="Zeichenkodierung (z.B. cp850, cp1252). Nur für GAEB 90."),
+):
+    """Zeigt die Titelstruktur (Hierarchie) eines LV."""
+    lv = _read(datei, encoding=encoding)
+
+    def _drucke(titel, tiefe: int = 0) -> None:
+        prefix = "  " * tiefe
+        marker = "├─" if tiefe > 0 else "●"
+        pos_info = f"  [dim]({len(titel.positionen)} Pos.)[/dim]" if titel.positionen else ""
+        console.print(f"{prefix}{marker} [bold cyan]{titel.nummer}[/bold cyan]  {titel.kurztext}{pos_info}")
+        for ut in titel.untertitel:
+            _drucke(ut, tiefe + 1)
+
+    console.print()
+    console.print(f"[bold]{lv.titel_lv or datei.name}[/bold]  [dim]– {len(lv.alle_positionen)} Positionen gesamt[/dim]")
+    for t in lv.titel:
+        _drucke(t)
+    console.print()
+
+
+# ------------------------------------------------------------------ #
+# gaeb validate <datei>
+# ------------------------------------------------------------------ #
+
+@app.command()
+def validate(
+    datei: Path = typer.Argument(..., help="GAEB-DA-XML-Datei (.x83, .x84, ...)"),
+    phase: str | None = typer.Option(None, "--phase", "-p", help="Phase manuell angeben (z.B. 83, 84). Sonst aus Datei ermittelt."),
+):
+    """Validiert eine GAEB-DA-XML-Datei gegen das offizielle XSD-Schema."""
+    if not datei.exists():
+        err.print(f"Datei nicht gefunden: {datei}")
+        raise typer.Exit(1)
+
+    try:
+        fehler = gaeb.validate(datei, phase=phase)
+    except FileNotFoundError as exc:
+        err.print(str(exc))
+        err.print("XSD-Schemas können von gaeb.de heruntergeladen werden (siehe gaeb/schemas/README.md).")
+        raise typer.Exit(2)
+    except ValueError as exc:
+        err.print(str(exc))
+        raise typer.Exit(1)
+    except Exception as exc:
+        err.print(f"Fehler bei der Validierung: {type(exc).__name__}: {exc}")
+        raise typer.Exit(1)
+
+    if fehler:
+        console.print(f"\n[bold red]✗ {len(fehler)} Validierungsfehler in {datei.name}:[/bold red]")
+        for f in fehler:
+            console.print(f"  [red]•[/red] {f}")
+        console.print()
+        raise typer.Exit(1)
+    else:
+        console.print(f"\n[bold green]✓ {datei.name} ist XSD-valide.[/bold green]\n")
+
+
+# ------------------------------------------------------------------ #
+# gaeb export <datei> <ausgabe.xlsx>
+# ------------------------------------------------------------------ #
+
+@app.command()
+def export(
+    datei: Path = typer.Argument(..., help="GAEB-Quelldatei (.d83, .x83, ...)"),
+    ausgabe: Path = typer.Argument(..., help="Ziel-Excel-Datei (.xlsx)"),
+    langtext: bool = typer.Option(False, "--langtext", "-l", help="Langtext-Spalte einschließen."),
+    encoding: str | None = typer.Option(None, "--encoding", "-e", help="Zeichenkodierung (nur GAEB 90)."),
+):
+    """Exportiert ein Leistungsverzeichnis als Excel-Datei (.xlsx)."""
+    lv = _read(datei, encoding=encoding)
+    try:
+        write_excel(lv, ausgabe, langtext=langtext)
+    except ImportError as exc:
+        err.print(str(exc))
+        raise typer.Exit(1)
+    except PermissionError:
+        err.print(f"Keine Schreibberechtigung: {ausgabe}")
+        raise typer.Exit(1)
+    except Exception as exc:
+        err.print(f"Fehler beim Excel-Export: {type(exc).__name__}: {exc}")
+        raise typer.Exit(1)
+    console.print(f"[green]✓[/green] Exportiert: {datei.name} → {ausgabe.name}")
+
+
+# ------------------------------------------------------------------ #
+# gaeb diff <alt> <neu>
+# ------------------------------------------------------------------ #
+
+@app.command()
+def diff(
+    alt: Path = typer.Argument(..., help="Ältere GAEB-Datei"),
+    neu: Path = typer.Argument(..., help="Neuere GAEB-Datei"),
+    encoding: str | None = typer.Option(None, "--encoding", "-e", help="Zeichenkodierung (nur GAEB 90)."),
+):
+    """Vergleicht zwei GAEB-Dateien und zeigt Unterschiede."""
+    lv_alt = _read(alt, encoding=encoding)
+    lv_neu = _read(neu, encoding=encoding)
+
+    ergebnis = gaeb.compare(lv_alt, lv_neu)
+
+    if not ergebnis.has_changes:
+        console.print("\n[green]Keine Unterschiede gefunden.[/green]\n")
+        return
+
+    console.print()
+
+    if ergebnis.only_in_old:
+        console.print(f"[bold red]Entfernte Positionen ({len(ergebnis.only_in_old)}):[/bold red]")
+        for oz in ergebnis.only_in_old:
+            console.print(f"  [red]−[/red] {oz}")
+        console.print()
+
+    if ergebnis.only_in_new:
+        console.print(f"[bold green]Neue Positionen ({len(ergebnis.only_in_new)}):[/bold green]")
+        for oz in ergebnis.only_in_new:
+            console.print(f"  [green]+[/green] {oz}")
+        console.print()
+
+    if ergebnis.title_changes:
+        console.print(f"[bold yellow]Titeländerungen ({len(ergebnis.title_changes)}):[/bold yellow]")
+        for tc in ergebnis.title_changes:
+            if tc.change_type == "removed":
+                console.print(f"  [red]− Titel {tc.oz}[/red] [dim]{tc.alt_name or ''}[/dim]")
+            elif tc.change_type == "added":
+                console.print(f"  [green]+ Titel {tc.oz}[/green] {tc.neu_name or ''}")
+            elif tc.change_type == "name":
+                console.print(f"  [yellow]~ Titel {tc.oz}[/yellow] [red]{tc.alt_name or ''}[/red] → [green]{tc.neu_name or ''}[/green]")
+            elif tc.change_type == "langtext":
+                console.print(f"  [yellow]~ Titel {tc.oz} Langtext geändert[/yellow]")
+        console.print()
+
+    if ergebnis.changed:
+        table = Table(box=box.SIMPLE_HEAD)
+        table.add_column("OZ", style="cyan", no_wrap=True)
+        table.add_column("Kurztext")
+        table.add_column("Feld")
+        table.add_column("Alt", style="red")
+        table.add_column("Neu", style="green")
+        for pa in ergebnis.changed:
+            first = True
+            for fa in pa.changes:
+                table.add_row(
+                    pa.oz if first else "",
+                    pa.kurztext[:40] if first else "",
+                    fa.field,
+                    _fmt_feldwert(fa.alt),
+                    _fmt_feldwert(fa.neu),
+                )
+                first = False
+        console.print(f"[bold yellow]Geänderte Positionen ({len(ergebnis.changed)}):[/bold yellow]")
+        console.print(table)
+
+    gs_alt = ergebnis.gesamtsumme_alt
+    gs_neu = ergebnis.gesamtsumme_neu
+    gs_diff = ergebnis.gesamtsumme_diff
+    if gs_alt is not None or gs_neu is not None:
+        console.print(f"  Gesamtsumme alt: {gs_alt:,.2f}" if gs_alt else "  Gesamtsumme alt: —")
+        console.print(f"  Gesamtsumme neu: {gs_neu:,.2f}" if gs_neu else "  Gesamtsumme neu: —")
+        if gs_diff is not None:
+            farbe = "green" if gs_diff <= 0 else "red"
+            console.print(f"  Differenz: [{farbe}]{gs_diff:+,.2f}[/{farbe}]")
+    console.print()
+
+
+if __name__ == "__main__":
+    app()

gaeb_cli-0.5.2.dist-info/METADATA

@@ -0,0 +1,141 @@
+Metadata-Version: 2.3
+Name: gaeb-cli
+Version: 0.5.2
+Summary: Command-line tool for reading, writing, converting and diffing GAEB files (AVA data exchange format)
+Keywords: gaeb,ava,construction,cli
+Author: Attackwave
+Author-email: Attackwave <attackwave@gmail.com>
+License: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Office/Business
+Requires-Dist: gaeb>=0.5.2
+Requires-Dist: typer>=0.12
+Requires-Dist: rich>=13.0
+Requires-Python: >=3.10
+Project-URL: Homepage, https://github.com/Attackwave/gaeb-python
+Project-URL: Repository, https://github.com/Attackwave/gaeb-python
+Project-URL: Issues, https://github.com/Attackwave/gaeb-python/issues
+Project-URL: Changelog, https://github.com/Attackwave/gaeb-python/blob/main/CHANGELOG.md
+Description-Content-Type: text/markdown
+
+# gaeb-cli
+
+Kommandozeilen-Tool zum Lesen, Anzeigen, Konvertieren und Vergleichen von **GAEB-Dateien** (AVA – Ausschreibung, Vergabe, Abrechnung im deutschen Bauwesen).
+
+Basiert auf der [`gaeb`](../gaeb/)-Bibliothek.
+
+## Installation
+
+```bash
+pip install gaeb-cli
+
+# Mit Excel-Export
+pip install gaeb-cli "gaeb[excel]"
+```
+
+## Befehle
+
+### `gaeb info` – Metadaten anzeigen
+
+```bash
+gaeb info ausschreibung.d83
+gaeb info ausschreibung.x83         # zeigt xml_version
+gaeb info ausschreibung.d83 --encoding cp1252
+```
+
+Gibt Dateiname, Format (inkl. DA XML-Version), Phase, LV-Titel, Projekt, Auftraggeber, Anzahl Positionen und Gesamtsumme aus.
+
+### `gaeb show` – Positionen als Tabelle
+
+```bash
+gaeb show ausschreibung.d83
+gaeb show ausschreibung.d83 --langtext      # mit Langtext
+gaeb show ausschreibung.d83 --encoding cp850
+```
+
+### `gaeb struktur` – Titelhierarchie
+
+```bash
+gaeb struktur ausschreibung.d83
+```
+
+Gibt die Gliederung des LV als Baum aus (Titel und Untertitel).
+
+### `gaeb convert` – Konvertieren
+
+```bash
+# GAEB 90 → GAEB DA XML
+gaeb convert ausschreibung.d83 ausschreibung.x83
+
+# GAEB DA XML → GAEB 2000
+gaeb convert ausschreibung.x83 ausschreibung.p83
+
+# → Excel
+gaeb convert ausschreibung.x83 ausgabe.xlsx
+
+# Phase wechseln
+gaeb convert anfrage.d83 angebot.d84
+
+# Phase explizit angeben
+gaeb convert ausschreibung.d83 ausgabe.x84 --phase 84
+
+# Encoding angeben (nur GAEB 90 / GAEB 2000)
+gaeb convert quelle.d83 ziel.d83 --lese-encoding cp1252 --schreib-encoding cp850
+```
+
+Zielformat wird aus der Dateiendung abgeleitet:
+
+| Endung | Format |
+|--------|--------|
+| `.d8x`, `.d87`–`.d89` | GAEB 90 |
+| `.p8x` | GAEB 2000 |
+| `.x31`, `.x50`–`.x52`, `.x8x`, `.x93`–`.x97` | GAEB DA XML |
+| `.xlsx` | Excel |
+
+### `gaeb export` – Excel-Export
+
+```bash
+gaeb export ausschreibung.x83 ausgabe.xlsx
+gaeb export ausschreibung.d83 ausgabe.xlsx --langtext
+gaeb export ausschreibung.d83 ausgabe.xlsx --encoding cp850
+```
+
+Exportiert ein LV als strukturierte Excel-Datei mit Deckblatt und Positionstabelle.
+Erfordert `pip install gaeb[excel]`.
+
+### `gaeb diff` – Zwei LVs vergleichen
+
+```bash
+gaeb diff ausschreibung.x83 angebot.x84
+gaeb diff alt.d83 neu.d83 --encoding cp850
+```
+
+Zeigt gelöschte, neue und geänderte Positionen mit Feldvergleich und finanzieller Zusammenfassung.
+
+### `gaeb validate` – XSD-Validierung
+
+```bash
+gaeb validate ausschreibung.x83
+gaeb validate ausschreibung.x83 --phase 83
+```
+
+Validiert eine GAEB-DA-XML-Datei gegen das offizielle XSD-Schema.
+
+> **Hinweis:** Die XSD-Schemas müssen separat heruntergeladen werden.
+> Siehe [`gaeb/schemas/README.md`](../gaeb/schemas/README.md).
+
+## Unterstützte Phasen
+
+| Bereich | Codes |
+|---------|-------|
+| Mengenermittlung | 31 |
+| Kostenermittlung | 50, 51, 52 |
+| Vergabe (Procurement) | 80–89, 83Z, 84Z, 86ZR, 86ZE |
+| Handel / Handwerk | 93–97 |
+
+## Lizenz
+
+MIT – siehe [LICENSE](../LICENSE)

gaeb_cli-0.5.2.dist-info/RECORD

@@ -0,0 +1,6 @@
+gaeb_cli/__init__.py,sha256=97xBNXgQC35T36yKFmjm7ixxWtW9akVoUdDmv9QTffA,76
+gaeb_cli/main.py,sha256=afQ4ZMWGNfX7WBIFR4n8anGHN5ruw3nEC7cgmC4cH_A,16893
+gaeb_cli-0.5.2.dist-info/WHEEL,sha256=wGHOIGFfyqJ_mvPzL8rbdQzrAWETnDIh93qRV-Ucyms,80
+gaeb_cli-0.5.2.dist-info/entry_points.txt,sha256=2ZyNnPTcMRXicjPtxA1Xvbrg606c6UPmXqGSiwGvSo0,44
+gaeb_cli-0.5.2.dist-info/METADATA,sha256=8FcNqJmnh_Vzanuq92F1VGPDjEIXari7EYz4TWtVnSU,3847
+gaeb_cli-0.5.2.dist-info/RECORD,,

gaeb_cli-0.5.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.11.1
+Root-Is-Purelib: true
+Tag: py3-none-any

gaeb_cli-0.5.2.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+gaeb = gaeb_cli.main:app
+