gaeb 0.5.2__py3-none-any.whl

gaeb/__init__.py

@@ -0,0 +1,84 @@
+"""gaeb – Python library for reading and writing GAEB files (AVA).
+
+Note on language
+----------------
+GAEB is a German construction-industry standard (Gemeinsamer Ausschuss
+Elektronik im Bauwesen). A mixed naming convention is used:
+
+- **Methods and functions** use English names (``read_xml``, ``write_gaeb90``,
+  ``validate``, ``compare``).
+- **Domain fields** on model classes use German identifiers that directly mirror
+  the official GAEB specification:
+
+    Leistungsverzeichnis  –  bill of quantities (BoQ)
+    Titel                 –  section / chapter
+    Position              –  line item
+    Kurztext              –  short description
+    Langtext              –  long description
+    Einheit               –  unit of measure
+    Menge                 –  quantity
+    Einheitspreis         –  unit price
+    Gesamtpreis           –  total price
+    Phase                 –  exchange phase (e.g. 83 = tender, 84 = bid)
+"""
+
+from .builder import BoQBuilder
+from .diff import DiffResult, FieldChange, PositionChange, compare
+from .io.excel.reader import read as read_excel
+from .io.excel.writer import write as write_excel
+from .io.gaeb90.reader import read as read_gaeb90
+from .io.gaeb90.writer import write as write_gaeb90
+from .io.gaeb2000.reader import read as read_gaeb2000
+from .io.gaeb2000.writer import write as write_gaeb2000
+from .io.xml.reader import read as read_xml
+from .io.xml.validator import ValidationError, validate, validate_or_raise
+from .io.xml.writer import write as write_xml
+from .models import (
+    Bieter,
+    BieterEP,
+    BoQBkdn,
+    Leistungsverzeichnis,
+    Phase,
+    Position,
+    PositionTyp,
+    Preisspiegel,
+    Raum,
+    Raumbuch,
+    Raumgruppe,
+    RaumPosition,
+    Titel,
+)
+
+__all__ = [
+    "Bieter",
+    "BieterEP",
+    "BoQBkdn",
+    "BoQBuilder",
+    "DiffResult",
+    "FieldChange",
+    "Leistungsverzeichnis",
+    "Phase",
+    "Position",
+    "PositionChange",
+    "PositionTyp",
+    "Preisspiegel",
+    "Raum",
+    "RaumPosition",
+    "Raumbuch",
+    "Raumgruppe",
+    "Titel",
+    "ValidationError",
+    "compare",
+    "read_excel",
+    "read_gaeb90",
+    "read_gaeb2000",
+    "read_xml",
+    "validate",
+    "validate_or_raise",
+    "write_excel",
+    "write_gaeb90",
+    "write_gaeb2000",
+    "write_xml",
+]
+
+__version__ = "0.5.2"

gaeb/builder.py

@@ -0,0 +1,307 @@
+"""BoQ Builder – programmatischer Aufbau von Leistungsverzeichnissen.
+
+Beispiel::
+
+    from decimal import Decimal
+    import gaeb
+
+    lv = (
+        gaeb.BoQBuilder(phase=gaeb.Phase.ANGEBOTSAUFFORDERUNG, titel_lv="Testprojekt")
+        .titel("Erdarbeiten")
+            .position("Bodenaushub", einheit="m³", menge=100, ep="12.50")
+            .position("Bodentransport", einheit="m³", menge=100, ep="8.00")
+        .end()
+        .build()
+    )
+"""
+
+from __future__ import annotations
+
+import warnings
+from decimal import Decimal, InvalidOperation
+
+from .models import BoQBkdn, Leistungsverzeichnis, Phase, Position, PositionTyp, Titel
+
+# Phasen in denen Einheitspreise sinnvoll sind
+_PREIS_PHASEN = {
+    "84", "84Z", "85", "86", "86ZR", "86ZE",
+    "87", "88", "89",
+    "94", "95", "96", "97",
+}
+
+_DEFAULT_SCHEMA = [
+    BoQBkdn(typ="BoQLevel", laenge=2),
+    BoQBkdn(typ="BoQLevel", laenge=2),
+    BoQBkdn(typ="Item", laenge=4),
+]
+
+
+def _to_decimal(wert: float | str | Decimal | None) -> Decimal | None:
+    if wert is None:
+        return None
+    if isinstance(wert, Decimal):
+        return wert
+    try:
+        return Decimal(str(wert))
+    except InvalidOperation as exc:
+        raise ValueError(f"Ungültiger Dezimalwert: {wert!r}") from exc
+
+
+def _to_langtext(wert: str | list[str] | None) -> list[str]:
+    if wert is None:
+        return []
+    if isinstance(wert, list):
+        return wert
+    return wert.splitlines()
+
+
+def _oz_pad(nummer: int, laenge: int) -> str:
+    return str(nummer).zfill(laenge)
+
+
+class TitelBuilder:
+    """Builder für einen einzelnen Titel (Kapitel/Unterkapitel)."""
+
+    def __init__(
+        self,
+        parent: BoQBuilder | TitelBuilder,
+        kurztext: str,
+        oz: str,
+        langtext: str | list[str] = "",
+    ) -> None:
+        self._parent = parent
+        self._kurztext = kurztext
+        self._oz = oz
+        self._langtext = _to_langtext(langtext)
+        self._positionen: list[Position] = []
+        self._untertitel: list[TitelBuilder] = []
+        self._pos_zaehler = 0
+        self._ut_zaehler = 0
+
+    # ------------------------------------------------------------------
+    # Positions-OZ generieren
+    # ------------------------------------------------------------------
+
+    def _naechste_pos_oz(self) -> str:
+        """Generiert die OZ der nächsten Position basierend auf dem Schema.
+
+        Fehlende Zwischenebenen werden mit '0' aufgefüllt, sodass die OZ
+        immer die volle Schema-Länge hat.
+        """
+        self._pos_zaehler += 1
+        schema = self._root._schema
+        item_ebene = schema[-1]
+        # Gesamtlänge aller BoQLevel-Ebenen
+        boqlevel_laenge = sum(e.laenge for e in schema if e.typ == "BoQLevel")
+        # Titel-OZ auf BoQLevel-Gesamtlänge mit '0' auffüllen
+        oz_prefix = self._oz.ljust(boqlevel_laenge, "0")
+        return oz_prefix + _oz_pad(self._pos_zaehler, item_ebene.laenge)
+
+    def _naechste_ut_oz(self) -> str:
+        """Generiert die OZ des nächsten Untertitels.
+
+        Bestimmt die eigene Tiefe anhand der OZ-Länge und sucht die nächste
+        BoQLevel-Ebene im Schema. Nutzt ``enumerate`` um bei mehreren Ebenen
+        gleicher Länge den richtigen Index zu finden.
+        """
+        self._ut_zaehler += 1
+        schema = self._root._schema
+        eigene_laenge = len(self._oz)
+        kumuliert = 0
+        for idx, ebene in enumerate(schema):
+            kumuliert += ebene.laenge
+            if kumuliert == eigene_laenge:
+                if idx + 1 < len(schema) and schema[idx + 1].typ == "BoQLevel":
+                    naechste_laenge = schema[idx + 1].laenge
+                    return self._oz + _oz_pad(self._ut_zaehler, naechste_laenge)
+                break
+        # Fallback: 2 Zeichen
+        return self._oz + _oz_pad(self._ut_zaehler, 2)
+
+    @property
+    def _root(self) -> BoQBuilder:
+        node: TitelBuilder | BoQBuilder = self
+        while isinstance(node, TitelBuilder):
+            node = node._parent
+        return node  # type: ignore[return-value]
+
+    # ------------------------------------------------------------------
+    # Fluent API
+    # ------------------------------------------------------------------
+
+    def position(
+        self,
+        kurztext: str,
+        *,
+        oz: str | None = None,
+        einheit: str = "",
+        menge: float | str | Decimal | None = None,
+        ep: float | str | Decimal | None = None,
+        einheitspreis: float | str | Decimal | None = None,
+        langtext: str | list[str] = "",
+        typ: PositionTyp = PositionTyp.NORMAL,
+        pauschale: bool = False,
+        stundenlohn: bool = False,
+        entfaellt: bool = False,
+        nicht_angeboten: bool = False,
+        schwerpunkt: bool = False,
+        provis: bool = False,
+        # Zeitvertrag-Felder (nur Z-Phasen)
+        periodqty: float | str | Decimal | None = None,
+        min_menge: float | str | Decimal | None = None,
+        max_menge: float | str | Decimal | None = None,
+    ) -> TitelBuilder:
+        """Fügt eine Position zu diesem Titel hinzu. Gibt ``self`` zurück."""
+        # ep ist Alias für einheitspreis
+        ep_wert = _to_decimal(ep if ep is not None else einheitspreis)
+        pos_oz = oz if oz is not None else self._naechste_pos_oz()
+        pos = Position(
+            oz=pos_oz,
+            kurztext=kurztext,
+            langtext=_to_langtext(langtext),
+            einheit=einheit,
+            menge=_to_decimal(menge),
+            einheitspreis=ep_wert,
+            typ=typ,
+            pauschale=pauschale,
+            stundenlohn=stundenlohn,
+            entfaellt=entfaellt,
+            nicht_angeboten=nicht_angeboten,
+            schwerpunkt=schwerpunkt,
+            provis=provis,
+            periodqty=_to_decimal(periodqty),
+            min_menge=_to_decimal(min_menge),
+            max_menge=_to_decimal(max_menge),
+        )
+        self._positionen.append(pos)
+        return self
+
+    def untertitel(
+        self,
+        kurztext: str,
+        *,
+        oz: str | None = None,
+        langtext: str | list[str] = "",
+    ) -> TitelBuilder:
+        """Fügt einen Untertitel hinzu und gibt dessen Builder zurück."""
+        ut_oz = oz if oz is not None else self._naechste_ut_oz()
+        ut = TitelBuilder(parent=self, kurztext=kurztext, oz=ut_oz, langtext=langtext)
+        self._untertitel.append(ut)
+        return ut
+
+    def end(self) -> BoQBuilder | TitelBuilder:
+        """Closes this Titel and returns to the parent builder."""
+        return self._parent
+
+    def _build(self) -> Titel:
+        return Titel(
+            nummer=self._oz,
+            kurztext=self._kurztext,
+            langtext=self._langtext,
+            positionen=self._positionen,
+            untertitel=[ut._build() for ut in self._untertitel],
+        )
+
+
+class BoQBuilder:
+    """Builder für ein vollständiges Leistungsverzeichnis.
+
+    Parameters
+    ----------
+    phase:
+        Datenaustauschphase. Beeinflusst Warnungen bei Preisangaben.
+    titel_lv:
+        Kurzbezeichnung des LV.
+    projekt:
+        Projektname / Bauvorhaben.
+    auftraggeber:
+        Name des Auftraggebers.
+    waehrung:
+        Währungscode (Standard: ``"EUR"``).
+    vorbemerkungen:
+        Allgemeine Vorbemerkungen (Liste von Zeilen oder einzelner String).
+    boq_bkdn:
+        OZ-Schema. Standard: 2 BoQLevel-Ebenen (je 2 Zeichen) + 1 Item-Ebene (4 Zeichen).
+    """
+
+    def __init__(
+        self,
+        *,
+        phase: Phase | str | None = None,
+        titel_lv: str = "",
+        projekt: str = "",
+        auftraggeber: str = "",
+        auftragnehmer: str = "",
+        waehrung: str = "EUR",
+        vorbemerkungen: str | list[str] = "",
+        boq_bkdn: list[BoQBkdn] | None = None,
+    ) -> None:
+        if isinstance(phase, str) and not isinstance(phase, Phase):
+            phase = Phase(phase)
+        self._phase = phase
+        self._titel_lv = titel_lv
+        self._projekt = projekt
+        self._auftraggeber = auftraggeber
+        self._auftragnehmer = auftragnehmer
+        self._waehrung = waehrung
+        self._vorbemerkungen = _to_langtext(vorbemerkungen)
+        self._schema: list[BoQBkdn] = boq_bkdn if boq_bkdn is not None else list(_DEFAULT_SCHEMA)
+        self._titel_builder: list[TitelBuilder] = []
+        self._titel_zaehler = 0
+
+    def _naechste_titel_oz(self) -> str:
+        self._titel_zaehler += 1
+        # Erste BoQLevel-Ebene
+        erste_laenge = next(
+            (e.laenge for e in self._schema if e.typ == "BoQLevel"), 2
+        )
+        return _oz_pad(self._titel_zaehler, erste_laenge)
+
+    def titel(
+        self,
+        kurztext: str,
+        *,
+        oz: str | None = None,
+        langtext: str | list[str] = "",
+    ) -> TitelBuilder:
+        """Fügt einen obersten Titel hinzu und gibt dessen Builder zurück."""
+        t_oz = oz if oz is not None else self._naechste_titel_oz()
+        tb = TitelBuilder(parent=self, kurztext=kurztext, oz=t_oz, langtext=langtext)
+        self._titel_builder.append(tb)
+        return tb
+
+    def build(self) -> Leistungsverzeichnis:
+        """Erzeugt das fertige :class:`~gaeb.models.Leistungsverzeichnis`.
+
+        Gibt eine Warnung aus wenn Einheitspreise in einer Phase gesetzt wurden,
+        in der sie nicht üblich sind.
+        """
+        if self._phase is not None:
+            phase_wert = self._phase.value if isinstance(self._phase, Phase) else str(self._phase)
+            if phase_wert not in _PREIS_PHASEN:
+                # Prüfe ob irgendwo EPs gesetzt wurden
+                lv_tmp = Leistungsverzeichnis(
+                    phase=self._phase,
+                    titel=[tb._build() for tb in self._titel_builder],
+                )
+                if any(
+                    p.einheitspreis is not None for p in lv_tmp.alle_positionen
+                ):
+                    warnings.warn(
+                        f"Einheitspreise wurden gesetzt, aber Phase {phase_wert!r} "
+                        "ist keine Angebotsphase. Einheitspreise werden beim "
+                        "Schreiben möglicherweise ignoriert.",
+                        stacklevel=2,
+                    )
+
+        return Leistungsverzeichnis(
+            phase=self._phase,
+            titel_lv=self._titel_lv,
+            projekt=self._projekt,
+            auftraggeber=self._auftraggeber,
+            auftragnehmer=self._auftragnehmer,
+            waehrung=self._waehrung,
+            vorbemerkungen=self._vorbemerkungen,
+            boq_bkdn=self._schema,
+            titel=[tb._build() for tb in self._titel_builder],
+        )

gaeb/diff.py

@@ -0,0 +1,208 @@
+"""GAEB Leistungsverzeichnis Diff.
+
+Compares two :class:`Leistungsverzeichnis` objects and returns structural,
+content-related and financial differences.
+"""
+
+from __future__ import annotations
+
+import warnings
+from collections import Counter
+from dataclasses import dataclass, field
+from decimal import Decimal
+from typing import Any
+
+from .models.lv import Leistungsverzeichnis, Titel
+
+# Skalare Felder die beim Positionsvergleich direkt verglichen werden
+_COMPARE_FIELDS = (
+    "kurztext", "einheit", "menge", "einheitspreis",
+    "typ", "entfaellt", "pauschale", "stundenlohn",
+    "schwerpunkt", "provis", "nicht_angeboten",
+    "periodqty", "min_menge", "max_menge",
+)
+
+# Felder mit Listen-Werten (werden über Gleichheit verglichen, aber separat formatiert)
+_LIST_FIELDS = ("langtext",)
+
+
+@dataclass
+class FieldChange:
+    """A single field change on a position."""
+    field: str
+    old: Any
+    new: Any
+
+
+@dataclass
+class PositionChange:
+    """Changes on a specific position (identified by OZ)."""
+    oz: str
+    kurztext: str
+    changes: list[FieldChange] = field(default_factory=list)
+    financial_diff: Decimal | None = None
+    """Difference of the total price (new − old). None if not calculable."""
+
+
+@dataclass
+class TitleChange:
+    """Changes to a title (name, hierarchy, or structure)."""
+    oz: str
+    alt_name: str | None = None
+    neu_name: str | None = None
+    change_type: str = ""  # "name", "removed", "added"
+    changes: list[FieldChange] = field(default_factory=list)
+
+
+@dataclass
+class DiffResult:
+    """Result of a Leistungsverzeichnis comparison."""
+    only_in_old: list[str] = field(default_factory=list)
+    """OZ numbers of positions only present in the older LV (deleted)."""
+
+    only_in_new: list[str] = field(default_factory=list)
+    """OZ numbers of positions only present in the newer LV (added)."""
+
+    changed: list[PositionChange] = field(default_factory=list)
+    """Positions present in both LVs but with differences."""
+
+    title_changes: list[TitleChange] = field(default_factory=list)
+    """Title name or structure changes between the two LVs."""
+
+    gesamtsumme_alt: Decimal | None = None
+    gesamtsumme_neu: Decimal | None = None
+
+    @property
+    def gesamtsumme_diff(self) -> Decimal | None:
+        """Difference of the totals (new − old)."""
+        if self.gesamtsumme_alt is not None and self.gesamtsumme_neu is not None:
+            return self.gesamtsumme_neu - self.gesamtsumme_alt
+        return None
+
+    @property
+    def has_changes(self) -> bool:
+        return bool(self.only_in_old or self.only_in_new or self.changed)
+
+
+def _sammle_titel(titel_liste: list[Titel]) -> dict[str, Titel]:
+    """Sammelt alle Titel mit ihrer OZ als Key."""
+    ergebnis: dict[str, Titel] = {}
+    def _rekursiv(t: Titel) -> None:
+        ergebnis[t.nummer] = t
+        for ut in t.untertitel:
+            _rekursiv(ut)
+    for t in titel_liste:
+        _rekursiv(t)
+    return ergebnis
+
+
+def compare(
+    lv_alt: Leistungsverzeichnis,
+    lv_neu: Leistungsverzeichnis,
+) -> DiffResult:
+    """Compares two Leistungsverzeichnisse by their OZ numbers.
+
+    Args:
+        lv_alt: The older / original Leistungsverzeichnis.
+        lv_neu: The newer / changed Leistungsverzeichnis.
+
+    Returns:
+        :class:`DiffResult` with deleted, new and changed positions.
+    """
+    alt_pos_list = lv_alt.alle_positionen
+    neu_pos_list = lv_neu.alle_positionen
+
+    # Duplicate OZ detection
+    alt_oz_counter = Counter(p.oz for p in alt_pos_list)
+    neu_oz_counter = Counter(p.oz for p in neu_pos_list)
+    for oz, count in alt_oz_counter.items():
+        if count > 1:
+            warnings.warn(f"Duplicate OZ '{oz}' in old LV ({count} occurrences). Later entries will overwrite earlier ones.", UserWarning)
+    for oz, count in neu_oz_counter.items():
+        if count > 1:
+            warnings.warn(f"Duplicate OZ '{oz}' in new LV ({count} occurrences). Later entries will overwrite earlier ones.", UserWarning)
+
+    alt_pos = {p.oz: p for p in alt_pos_list}
+    neu_pos = {p.oz: p for p in neu_pos_list}
+
+    only_in_old = sorted(set(alt_pos) - set(neu_pos))
+    only_in_new = sorted(set(neu_pos) - set(alt_pos))
+    changed: list[PositionChange] = []
+
+    for oz in sorted(set(alt_pos) & set(neu_pos)):
+        p_alt = alt_pos[oz]
+        p_neu = neu_pos[oz]
+        field_changes: list[FieldChange] = []
+
+        for f in _COMPARE_FIELDS:
+            v_alt = getattr(p_alt, f)
+            v_neu = getattr(p_neu, f)
+            if v_alt != v_neu:
+                field_changes.append(FieldChange(field=f, old=v_alt, new=v_neu))
+
+        for f in _LIST_FIELDS:
+            v_alt = getattr(p_alt, f)
+            v_neu = getattr(p_neu, f)
+            if v_alt != v_neu:
+                field_changes.append(FieldChange(field=f, old=v_alt, new=v_neu))
+
+        if field_changes:
+            gp_alt = p_alt.gesamtbetrag if p_alt.gesamtbetrag is not None else p_alt.gesamtpreis
+            gp_neu = p_neu.gesamtbetrag if p_neu.gesamtbetrag is not None else p_neu.gesamtpreis
+            fin = (gp_neu - gp_alt) if (gp_alt is not None and gp_neu is not None) else None
+            changed.append(PositionChange(
+                oz=oz,
+                kurztext=p_neu.kurztext,
+                changes=field_changes,
+                financial_diff=fin,
+            ))
+
+    # Title comparison
+    alt_titel = _sammle_titel(lv_alt.titel)
+    neu_titel = _sammle_titel(lv_neu.titel)
+    title_changes: list[TitleChange] = []
+
+    # Removed titles
+    for oz in sorted(set(alt_titel) - set(neu_titel)):
+        title_changes.append(TitleChange(
+            oz=oz,
+            alt_name=alt_titel[oz].kurztext,
+            change_type="removed",
+        ))
+
+    # Added titles
+    for oz in sorted(set(neu_titel) - set(alt_titel)):
+        title_changes.append(TitleChange(
+            oz=oz,
+            neu_name=neu_titel[oz].kurztext,
+            change_type="added",
+        ))
+
+    # Changed title names
+    for oz in sorted(set(alt_titel) & set(neu_titel)):
+        t_alt = alt_titel[oz]
+        t_neu = neu_titel[oz]
+        if t_alt.kurztext != t_neu.kurztext:
+            title_changes.append(TitleChange(
+                oz=oz,
+                alt_name=t_alt.kurztext,
+                neu_name=t_neu.kurztext,
+                change_type="name",
+            ))
+        if t_alt.langtext != t_neu.langtext:
+            title_changes.append(TitleChange(
+                oz=oz,
+                alt_name=t_alt.kurztext,
+                neu_name=t_neu.kurztext,
+                change_type="langtext",
+                changes=[FieldChange(field="langtext", old=t_alt.langtext, new=t_neu.langtext)],
+            ))
+
+    return DiffResult(
+        only_in_old=only_in_old,
+        only_in_new=only_in_new,
+        changed=changed,
+        title_changes=title_changes,
+        gesamtsumme_alt=lv_alt.gesamtsumme,
+        gesamtsumme_neu=lv_neu.gesamtsumme,
+    )