493 lines
19 KiB
Python
493 lines
19 KiB
Python
#!/usr/bin/env python3
|
|
# -*- coding: utf-8 -*-
|
|
"""
|
|
tro_overrides.py - manuelle Korrekturen an der abgeleiteten TRO-Liste.
|
|
|
|
`tro_flow.py` leitet die TROs allein aus dem mechanischen Layout (CSV-Export)
|
|
ab. Manches steht dort aber nicht drin: eine Weiche, die im Export fehlt, ein
|
|
Scanner, der den Typ auf `1Sep_SSCC` hebt, oder eine Stelle, die vor Ort als
|
|
eigener TRO erkannt wurde. Solche Erkenntnisse kommen aus der Begehung bzw.
|
|
aus dem Review der erzeugten Diagramme.
|
|
|
|
Damit sie den naechsten Lauf ueberleben, stehen sie in einer INI-Datei
|
|
(`%SKEL_CFG%/tro_overrides.ini`) statt in den erzeugten Dateien. `tro_flow.py`
|
|
und `tro_annotate.py` lesen sie und wenden sie nach der Ableitung an; die Doku
|
|
weist jede angewandte Korrektur getrennt aus, damit abgeleitet und behauptet
|
|
unterscheidbar bleiben.
|
|
|
|
Aufbau der INI (Sektionsnamen mit dem CSV-Dateinamen als Praefix, damit
|
|
mehrere Anlagen in einer Datei stehen koennen):
|
|
|
|
[<csv>.tro.<TRO-ID>] Korrektur an einem abgeleiteten TRO
|
|
type = 1Sep1Swi neuer Katalogtyp
|
|
reason = ... Begruendung (kommt in die Doku)
|
|
confidence = bestaetigt Vertrauensangabe (Default: bestaetigt)
|
|
|
|
[<csv>.openpoint.<Name>] offener Punkt - noch KEIN TRO
|
|
x = 529.95 Anlagenkoordinate in mm
|
|
y = -3895.27
|
|
z = 1468
|
|
expect = 1Sep1Swi hier erwarteter TRO-Typ
|
|
belongs_to = TRO10 TRO, der das Bauteil heute enthaelt
|
|
note = ... Erlaeuterung
|
|
|
|
Offene Punkte aendern die TRO-Struktur ausdruecklich **nicht**. Sie werden nur
|
|
in der Doku und in der annotierten Zeichnung markiert, damit sie in BricsCAD
|
|
geprueft werden koennen, bevor daraus ein TRO wird.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import configparser
|
|
import os
|
|
from dataclasses import dataclass, field
|
|
from pathlib import Path
|
|
|
|
from tro_catalog import get_tro
|
|
|
|
OVERRIDE_FILE = "tro_overrides.ini"
|
|
|
|
# Vertrauensangabe fuer manuell gesetzte Typen. Bewusst ein eigener Wert - so
|
|
# ist in der Doku sichtbar, dass der Typ nicht aus dem Layout stammt.
|
|
DEFAULT_CONFIDENCE = "bestaetigt"
|
|
|
|
|
|
@dataclass
|
|
class TroOverride:
|
|
"""Korrektur an einem abgeleiteten TRO.
|
|
|
|
Adressiert entweder ueber die TRO-ID (`TRO03`) oder - stabiler - ueber die
|
|
Nummer eines seiner Separatoren (`SEP0011`). Die TRO-IDs sind laufende
|
|
Nummern eines Laufs und verschieben sich, sobald TROs dazukommen oder
|
|
wegfallen; die Separator-Nummer aus dem CSV-Export tut das nicht.
|
|
"""
|
|
|
|
key: str
|
|
by_separator: bool = False
|
|
type_name: str = ""
|
|
reason: str = ""
|
|
confidence: str = ""
|
|
|
|
def matches(self, tro) -> bool:
|
|
if self.by_separator:
|
|
return self.key in tro.separators
|
|
return self.key == tro.tro_id
|
|
|
|
|
|
@dataclass
|
|
class SplitSpec:
|
|
"""Ein neuer TRO, herausgeloest aus einem bereits abgeleiteten.
|
|
|
|
Fuer Uebergabestellen, die die Ableitung nicht als eigenstaendig erkennt,
|
|
weil die "Zuordnung" des Separators auf ein Transportobjekt zeigt (Strecke,
|
|
Gefaellestrecke) statt auf die Kreisel-Bahn, an der er tatsaechlich
|
|
schaltet. Die genannten Separatoren/Scanner werden ihrem bisherigen TRO
|
|
entnommen und bilden einen neuen.
|
|
"""
|
|
|
|
name: str
|
|
type_name: str
|
|
separators: list[str] = field(default_factory=list)
|
|
scanners: list[str] = field(default_factory=list)
|
|
host: str = ""
|
|
label: str = ""
|
|
reason: str = ""
|
|
confidence: str = DEFAULT_CONFIDENCE
|
|
|
|
|
|
@dataclass
|
|
class ConnectionSpec:
|
|
"""Eine vor Ort bestaetigte Verbindung zwischen zwei TROs."""
|
|
|
|
src: str
|
|
dst: str
|
|
kind: str = ""
|
|
|
|
|
|
@dataclass
|
|
class MergeSpec:
|
|
"""Mehrere abgeleitete TROs zu einem Steuerobjekt zusammenfassen.
|
|
|
|
Fuer Stellen, die mechanisch aus mehreren Bauteilgruppen bestehen,
|
|
steuerungstechnisch aber eine einzige Uebergabestelle sind - etwa zwei
|
|
Sperren beiderseits eines Kreisel-Beruehrpunkts. Adressiert wird ueber die
|
|
Separatoren, weil deren Nummern ueber Exporte hinweg stabiler sind als die
|
|
laufenden TRO-Nummern.
|
|
"""
|
|
|
|
name: str
|
|
type_name: str
|
|
separators: list[str] = field(default_factory=list)
|
|
host: str = ""
|
|
label: str = ""
|
|
reason: str = ""
|
|
confidence: str = DEFAULT_CONFIDENCE
|
|
|
|
|
|
@dataclass
|
|
class OpenPoint:
|
|
"""Eine im Review gemeldete Stelle, die noch kein eigener TRO ist."""
|
|
|
|
name: str
|
|
x: float
|
|
y: float
|
|
z: float | None = None
|
|
expect: str = ""
|
|
belongs_to: str = ""
|
|
note: str = ""
|
|
|
|
def describe_position(self) -> str:
|
|
return f"{self.x:.0f}, {self.y:.0f}"
|
|
|
|
|
|
@dataclass
|
|
class Overrides:
|
|
"""Alle Korrekturen zu einer CSV-Datei."""
|
|
|
|
source: Path | None = None
|
|
tros: dict[str, TroOverride] = field(default_factory=dict)
|
|
splits: list[SplitSpec] = field(default_factory=list)
|
|
merges: list[MergeSpec] = field(default_factory=list)
|
|
# Gesetzte Topologie: ersetzt die abgeleiteten Kanten vollstaendig
|
|
connections: list[ConnectionSpec] = field(default_factory=list)
|
|
open_points: list[OpenPoint] = field(default_factory=list)
|
|
# Protokoll der tatsaechlich angewandten Korrekturen (fuer die Doku)
|
|
applied: list[str] = field(default_factory=list)
|
|
warnings: list[str] = field(default_factory=list)
|
|
|
|
def __bool__(self) -> bool:
|
|
return bool(self.tros or self.splits or self.merges or self.connections
|
|
or self.open_points)
|
|
|
|
|
|
def override_path(cfg_dir: Path | None = None) -> Path:
|
|
"""Pfad zur Override-Datei: %SKEL_CFG%, sonst <projekt>/cfg."""
|
|
if cfg_dir is not None:
|
|
return cfg_dir / OVERRIDE_FILE
|
|
env = os.environ.get("SKEL_CFG")
|
|
if env:
|
|
return Path(env) / OVERRIDE_FILE
|
|
return Path(__file__).resolve().parent.parent / "cfg" / OVERRIDE_FILE
|
|
|
|
|
|
def _as_float(raw: str, where: str, warnings: list[str]) -> float | None:
|
|
try:
|
|
return float(str(raw).strip())
|
|
except (TypeError, ValueError):
|
|
warnings.append(f"{where}: '{raw}' ist keine Zahl - Eintrag ignoriert")
|
|
return None
|
|
|
|
|
|
def load_overrides(csv_name: str, cfg_dir: Path | None = None) -> Overrides:
|
|
"""Korrekturen zu `csv_name` laden (leeres Ergebnis, wenn es keine gibt)."""
|
|
path = override_path(cfg_dir)
|
|
result = Overrides()
|
|
if not path.is_file():
|
|
return result
|
|
result.source = path
|
|
|
|
parser = configparser.ConfigParser(inline_comment_prefixes=(";",))
|
|
# Schluessel sind Kleinschreibung, Sektionsnamen bleiben wie geschrieben.
|
|
parser.read(path, encoding="utf-8")
|
|
|
|
prefix = csv_name.lower()
|
|
for section in parser.sections():
|
|
# [<csv>.connections] - gesetzte Topologie, eigene Form ohne <name>
|
|
if section.lower() == f"{prefix}.connections":
|
|
for key, raw in parser[section].items():
|
|
pfeil, _, rest = str(raw).partition("|")
|
|
src, sep, dst = (t.strip() for t in pfeil.partition("->"))
|
|
if not sep or not src or not dst:
|
|
result.warnings.append(
|
|
f"[{section}] {key}: '{raw}' ist keine Verbindung "
|
|
f"'<von> -> <nach>'"
|
|
)
|
|
continue
|
|
result.connections.append(
|
|
ConnectionSpec(src=src, dst=dst, kind=rest.strip())
|
|
)
|
|
continue
|
|
|
|
parts = section.split(".")
|
|
# <csv>.<art>.<name> - der CSV-Name kann selbst einen Punkt enthalten
|
|
if len(parts) < 3:
|
|
continue
|
|
kind, name = parts[-2].lower(), parts[-1]
|
|
owner = ".".join(parts[:-2]).lower()
|
|
if owner != prefix:
|
|
continue
|
|
values = parser[section]
|
|
|
|
if kind == "tro":
|
|
type_name = values.get("type", "").strip()
|
|
if type_name and get_tro(type_name) is None:
|
|
result.warnings.append(
|
|
f"[{section}]: Typ '{type_name}' steht nicht im TRO-Katalog "
|
|
f"- Korrektur ignoriert"
|
|
)
|
|
continue
|
|
key = name.upper()
|
|
by_sep = key.startswith("SEP")
|
|
result.tros[key] = TroOverride(
|
|
key=key[3:] if by_sep else key,
|
|
by_separator=by_sep,
|
|
type_name=type_name,
|
|
reason=values.get("reason", "").strip(),
|
|
confidence=values.get("confidence", "").strip() or DEFAULT_CONFIDENCE,
|
|
)
|
|
elif kind == "split":
|
|
type_name = values.get("type", "").strip()
|
|
if get_tro(type_name) is None:
|
|
result.warnings.append(
|
|
f"[{section}]: Typ '{type_name}' steht nicht im TRO-Katalog "
|
|
f"- neuer TRO nicht angelegt"
|
|
)
|
|
continue
|
|
seps = [s.strip() for s in values.get("separators", "").split(",") if s.strip()]
|
|
if not seps:
|
|
result.warnings.append(
|
|
f"[{section}]: 'separators' fehlt - ohne Separator kein TRO"
|
|
)
|
|
continue
|
|
result.splits.append(
|
|
SplitSpec(
|
|
name=name,
|
|
type_name=type_name,
|
|
separators=seps,
|
|
scanners=[s.strip() for s in values.get("scanners", "").split(",")
|
|
if s.strip()],
|
|
host=values.get("host", "").strip(),
|
|
label=values.get("label", "").strip(),
|
|
reason=values.get("reason", "").strip(),
|
|
confidence=values.get("confidence", "").strip() or DEFAULT_CONFIDENCE,
|
|
)
|
|
)
|
|
elif kind == "merge":
|
|
type_name = values.get("type", "").strip()
|
|
if get_tro(type_name) is None:
|
|
result.warnings.append(
|
|
f"[{section}]: Typ '{type_name}' steht nicht im TRO-Katalog "
|
|
f"- Zusammenfassung nicht durchgefuehrt"
|
|
)
|
|
continue
|
|
seps = [s.strip() for s in values.get("separators", "").split(",") if s.strip()]
|
|
if len(seps) < 2:
|
|
result.warnings.append(
|
|
f"[{section}]: 'separators' braucht mindestens zwei Nummern"
|
|
)
|
|
continue
|
|
result.merges.append(
|
|
MergeSpec(
|
|
name=name,
|
|
type_name=type_name,
|
|
separators=seps,
|
|
host=values.get("host", "").strip(),
|
|
label=values.get("label", "").strip(),
|
|
reason=values.get("reason", "").strip(),
|
|
confidence=values.get("confidence", "").strip() or DEFAULT_CONFIDENCE,
|
|
)
|
|
)
|
|
elif kind == "openpoint":
|
|
x = _as_float(values.get("x", ""), f"[{section}] x", result.warnings)
|
|
y = _as_float(values.get("y", ""), f"[{section}] y", result.warnings)
|
|
if x is None or y is None:
|
|
continue
|
|
z_raw = values.get("z", "").strip()
|
|
expect = values.get("expect", "").strip()
|
|
if expect and get_tro(expect) is None:
|
|
result.warnings.append(
|
|
f"[{section}]: erwarteter Typ '{expect}' steht nicht im "
|
|
f"TRO-Katalog"
|
|
)
|
|
result.open_points.append(
|
|
OpenPoint(
|
|
name=name,
|
|
x=x,
|
|
y=y,
|
|
z=_as_float(z_raw, f"[{section}] z", result.warnings)
|
|
if z_raw
|
|
else None,
|
|
expect=expect,
|
|
belongs_to=values.get("belongs_to", "").strip(),
|
|
note=values.get("note", "").strip(),
|
|
)
|
|
)
|
|
else:
|
|
result.warnings.append(
|
|
f"[{section}]: unbekannte Art '{kind}' - erwartet 'tro' oder "
|
|
f"'openpoint'"
|
|
)
|
|
|
|
result.open_points.sort(key=lambda p: p.name)
|
|
return result
|
|
|
|
|
|
def apply_splits(tros, overrides: Overrides, make_tro) -> list:
|
|
"""Neue TROs aus bestehenden herausloesen (vor der Nummernvergabe).
|
|
|
|
`make_tro(spec, hosts, label)` erzeugt das projektspezifische Tro-Objekt -
|
|
so bleibt dieses Modul frei von einem Import aus tro_flow (das umgekehrt
|
|
schon von hier importiert).
|
|
"""
|
|
for spec in overrides.splits:
|
|
quellen = [t for t in tros if set(spec.separators) & set(t.separators)]
|
|
if not quellen:
|
|
overrides.warnings.append(
|
|
f"Split '{spec.name}': keiner der Separatoren "
|
|
f"{', '.join(spec.separators)} kommt in diesem Lauf vor - "
|
|
f"nicht angelegt"
|
|
)
|
|
continue
|
|
|
|
hosts: list[str] = []
|
|
for quelle in quellen:
|
|
quelle.separators = [s for s in quelle.separators
|
|
if s not in spec.separators]
|
|
quelle.scanners = [s for s in quelle.scanners if s not in spec.scanners]
|
|
hosts.extend(quelle.hosts)
|
|
if not quelle.separators and quelle.type_name not in ("Vario",):
|
|
overrides.warnings.append(
|
|
f"Split '{spec.name}': {quelle.label} hat danach keinen "
|
|
f"Separator mehr - bitte pruefen"
|
|
)
|
|
|
|
ziel_hosts = [spec.host] if spec.host else sorted(set(hosts))[:1]
|
|
label = spec.label or (
|
|
f"Separator {', '.join(spec.separators)} "
|
|
f"(manuell aus {quellen[0].label} herausgeloest)"
|
|
)
|
|
tros.append(make_tro(spec, ziel_hosts, label))
|
|
overrides.applied.append(
|
|
f"neu {spec.name}: {spec.type_name} auf {', '.join(ziel_hosts)} "
|
|
f"mit Separator {', '.join(spec.separators)}, herausgeloest aus "
|
|
f"{', '.join(sorted({q.label for q in quellen}))} "
|
|
f"({spec.reason or 'manuelle Ergaenzung'})"
|
|
)
|
|
return tros
|
|
|
|
|
|
def apply_merges(tros, overrides: Overrides) -> list:
|
|
"""Mehrere TROs zu einem zusammenfassen (nach den Splits, vor der Nummer).
|
|
|
|
Der erste betroffene TRO bleibt bestehen und uebernimmt Bauteile, Hosts und
|
|
Typ; die uebrigen werden aus der Liste entfernt.
|
|
"""
|
|
for spec in overrides.merges:
|
|
betroffen = [t for t in tros if set(spec.separators) & set(t.separators)]
|
|
if len(betroffen) < 2:
|
|
gefunden = ", ".join(t.tro_id or t.label for t in betroffen) or "keiner"
|
|
overrides.warnings.append(
|
|
f"Merge '{spec.name}': nur {len(betroffen)} der Separatoren "
|
|
f"{', '.join(spec.separators)} gefunden ({gefunden}) - "
|
|
f"nicht zusammengefasst"
|
|
)
|
|
continue
|
|
|
|
ziel = betroffen[0]
|
|
quellen = betroffen[1:]
|
|
for quelle in quellen:
|
|
ziel.separators = sorted(set(ziel.separators) | set(quelle.separators))
|
|
ziel.scanners = sorted(set(ziel.scanners) | set(quelle.scanners))
|
|
ziel.hosts = sorted(set(ziel.hosts) | set(quelle.hosts))
|
|
tros.remove(quelle)
|
|
|
|
if spec.host:
|
|
# Ein Host bestimmt, wo der zusammengefasste TRO im Fluss haengt;
|
|
# die uebrigen Bahnen bleiben als weitere Hosts erhalten, damit die
|
|
# Verknuepfung beide Seiten des Uebergangs sieht.
|
|
ziel.hosts = [spec.host] + [h for h in ziel.hosts if h != spec.host]
|
|
ziel.type_name = spec.type_name
|
|
ziel.confidence = spec.confidence
|
|
ziel.label = spec.label or ziel.label
|
|
grund = spec.reason or "manuell zusammengefasst"
|
|
ziel.reason = f"{ziel.reason}; manuell zusammengefasst ({grund})"
|
|
overrides.applied.append(
|
|
f"merge {spec.name}: {len(betroffen)} TROs -> ein {spec.type_name} "
|
|
f"mit Separatoren {', '.join(ziel.separators)} ({grund})"
|
|
)
|
|
return tros
|
|
|
|
|
|
def apply_connections(tros, overrides: Overrides):
|
|
"""Gesetzte Topologie an die Stelle der abgeleiteten Kanten setzen.
|
|
|
|
Ersetzt vollstaendig, nicht ergaenzend: wenn die Verbindungen vor Ort
|
|
aufgenommen wurden, sind die abgeleiteten damit erledigt - sonst blieben
|
|
genau die Kanten stehen, die korrigiert werden sollten. Was dabei wegfaellt
|
|
bzw. hinzukommt, steht anschliessend in overrides.applied.
|
|
|
|
Rueckgabe: (edges, edge_kinds) wie von link_tros.
|
|
"""
|
|
bekannt = {t.tro_id for t in tros}
|
|
edges: list[tuple[str, str]] = []
|
|
kinds: dict[tuple[str, str], str] = {}
|
|
for spec in overrides.connections:
|
|
for seite, wert in (("von", spec.src), ("nach", spec.dst)):
|
|
if wert not in bekannt:
|
|
overrides.warnings.append(
|
|
f"Verbindung {spec.src} -> {spec.dst}: {seite} '{wert}' ist "
|
|
f"kein TRO dieses Laufs - Verbindung ignoriert"
|
|
)
|
|
break
|
|
else:
|
|
paar = (spec.src, spec.dst)
|
|
if paar in kinds:
|
|
continue
|
|
edges.append(paar)
|
|
kinds[paar] = spec.kind or "gesetzt"
|
|
|
|
for tro in tros:
|
|
tro.successors = sorted(d for s, d in edges if s == tro.tro_id)
|
|
tro.predecessors = sorted(s for s, d in edges if d == tro.tro_id)
|
|
tro.colocated = []
|
|
|
|
ohne = [t.tro_id for t in tros if not t.successors and not t.predecessors]
|
|
if ohne:
|
|
overrides.warnings.append(
|
|
"ohne Verbindung in der gesetzten Topologie: " + ", ".join(sorted(ohne))
|
|
)
|
|
overrides.applied.append(
|
|
f"Topologie gesetzt: {len(edges)} Verbindungen aus der Override-Datei "
|
|
f"ersetzen die abgeleiteten"
|
|
)
|
|
return sorted(edges), kinds
|
|
|
|
|
|
def apply_overrides(tros, overrides: Overrides) -> None:
|
|
"""Typkorrekturen auf die abgeleitete TRO-Liste anwenden.
|
|
|
|
Wird aufgerufen, nachdem die TRO-IDs vergeben sind (die Korrekturen sind
|
|
ueber die ID adressiert) und bevor FB-Baustein und Bauteilliste aus dem
|
|
Katalog gezogen werden - der Typwechsel zieht beides mit.
|
|
"""
|
|
if not overrides.tros:
|
|
return
|
|
for section_key, override in sorted(overrides.tros.items()):
|
|
treffer = [t for t in tros if override.matches(t)]
|
|
if not treffer:
|
|
wie = "Separator" if override.by_separator else "TRO-ID"
|
|
overrides.warnings.append(
|
|
f"[{section_key}]: kein TRO mit {wie} '{override.key}' in diesem "
|
|
f"Lauf - Korrektur nicht angewandt"
|
|
+ ("" if override.by_separator else
|
|
" (Nummerierung geaendert? Besser ueber SEP<Nummer> adressieren)")
|
|
)
|
|
continue
|
|
if len(treffer) > 1:
|
|
overrides.warnings.append(
|
|
f"[{section_key}]: trifft {len(treffer)} TROs "
|
|
f"({', '.join(t.tro_id for t in treffer)}) - auf alle angewandt"
|
|
)
|
|
for tro in treffer:
|
|
if not override.type_name or override.type_name == tro.type_name:
|
|
continue
|
|
vorher = tro.type_name
|
|
tro.type_name = override.type_name
|
|
tro.confidence = override.confidence
|
|
grund = override.reason or "manuelle Korrektur"
|
|
tro.reason = (f"{tro.reason}; manuell auf {override.type_name} "
|
|
f"gesetzt ({grund})")
|
|
overrides.applied.append(
|
|
f"{tro.tro_id}: {vorher} -> {override.type_name} ({grund})"
|
|
)
|