stsgraph

def calc_simzeit(self) -> datetime.datetime:
    """
    Simulatorzeit ohne Serverabfrage abschätzen.

    Der `time_offset` muss vorher einmal mittels `request_simzeit` kalibriert worden sein.

    Der Rückgabewert enthält das aktuelle (Client-)Datum.
    Das ist nötig, damit mit der Uhrzeit gerechnet werden kann.
    Da der Simulator kein Datum kennt, sollten die Datumsfelder nach der Rechnung nicht beachtet werden.
    Der Fahrplan (in `FahrplanZeile`) enthält lediglich `datetime.time`-Objekte.
    Ein `datetime.time`-Objekt kann einfach über die `time`-Methode extrahiert werden.

    Returns:
        Extrapolierte Simulatorzeit
    """
    return datetime.datetime.now() + self.time_offset

def gleis_abgleichen(self, gleis_name: str) -> str:
    """
    Gleisnamen mit Bahnsteigliste abgleichen und ev. korrigieren

    Die Methode versucht, Gleisnamen, die in der Bahnsteigliste nicht enthalten sind,
    mittels des gleisabgleich-Dict aufzulösen,
    um Gross/Kleinschreibung und ggf. andere Schreibfehler im Zugfahrplan zu korrigieren.

    Args:
        gleis_name: Original-Gleisname

    Returns:
        abgeglichener Name
    """
    if gleis_name in self.bahnsteigliste:
        return gleis_name
    else:
        return self.gleisabgleich.get(gleis_name.lower(), gleis_name)

async def receiver(self, *, task_status=trio.TASK_STATUS_IGNORED):
    """
    Empfangsschleife: Antworten empfangen und verteilen

    Alle Antworten ausser Ereignisse werden in untangle.Element-Objekte gepackt
    und an die Antworten-Queue übergeben.
    Ereignisse werden als stskit.model.Ereignis-Objekte an die Ereignisse-Queue übergeben.

    Diese Coroutine muss explizit in einer trio.nursery gestartet werden
    und läuft, bis die Verbindung unterbrochen wird.
    """

    parser: Any = xml.sax.make_parser()
    handler = untangle.Handler()
    parser.setContentHandler(handler)
    ro = re.compile(r"&[a-z]+;")

    def resolve_char_ref(match) -> str:
        try:
            cp = html.entities.name2codepoint[match.group(0)[1:-1]]
            return f"&#{cp};"
        except (KeyError, IndexError):
            return "?"

    self._antwort_channel_in, self._antwort_channel_out = trio.open_memory_channel(0)
    self._ereignis_channel_in, self._ereignis_channel_out = trio.open_memory_channel(0)
    task_status.started()

    async with self.antwort_channel_in:
        async with self.ereignis_channel_in:
            async for bs in self.stream:
                for s in bs.decode().split('\n'):
                    logger.debug("empfang: " + s)
                    if not s:
                        continue

                    s = re.sub(ro, resolve_char_ref, s)
                    try:
                        parser.feed(s)
                    except xml.sax.SAXException:
                        logger.exception("error parsing xml: " + s)

                    # xml tag complete?
                    if len(handler.elements) == 0:
                        element = handler.root
                        try:
                            parser.close()
                        except xml.sax.SAXParseException as e:
                            # rare parse exception: unclosed element
                            logger.exception(e)
                            logger.error(f"offending string: {s}")
                            print(e.getMessage(), file=sys.stderr)
                            continue

                        handler.root = untangle.Element(None, None)
                        handler.root.is_root = True

                        try:
                            tag = dir(element)[0]
                        except IndexError:
                            # leeres element
                            continue
                        else:
                            if tag == "ereignis":
                                ereignis = Ereignis().update(getattr(element, tag))
                                ereignis.zeit = self.calc_simzeit()
                                await self.ereignis_channel_in.send(ereignis)
                            else:
                                await self.antwort_channel_in.send(element)

async def register(self) -> None:
    """
    Klient beim Simulator registrieren.

    Diese Funktion muss als erste nach dem Verbinden aufgerufen werden,
    da sie auch die Statusantwort nach der Verbindungsaufnahme auswertet.
    """
    status = await self.antwort_channel_out.receive()
    check_status(status)

    await self._send_request("register", name=self.name, autor=self.autor, version=self.version,
                             protokoll='1', text=self.text)
    status = await self.antwort_channel_out.receive()
    check_status(status)
    self.registered.set()

async def request_anlageninfo(self) -> None:
    """
    Anlageninfo anfordern.

    Die Antwort wird im anlageninfo-Attribut gespeichert.
    """
    await self._send_request(AnlagenInfo.tag)
    response = await self.antwort_channel_out.receive()
    self.anlageninfo = AnlagenInfo().update(response.anlageninfo)

async def request_ereignis(self, art: str, zids: Iterable[int]) -> None:
    """
    Ereignismeldung anfordern

    Nach Nummernwechsel muss man Ereignismeldungen neu anfordern.
    Ausser für "Einfahrt" schicken wir daher Anforderungen nur, wenn der Zug sichtbar ist.

    Anforderungen werden in `registrierte_ereignisse` notiert,
    damit sie nicht wiederholt gesendet werden.

    Args:
        art: art des ereignisses, cf. model.Ereignis.arten
        zids: menge oder sequenz von zug-id-nummern
    """
    zids = set(zids).difference(self.registrierte_ereignisse[art])
    for zid in zids:
        if zid in self.zugliste and (art == "einfahrt" or self.zugliste[zid].sichtbar):
            await self._send_request("ereignis", art=art, zid=zid)
            self.registrierte_ereignisse[art].add(zid)

async def request_simzeit(self) -> datetime.datetime:
    """
    Simulatorzeit anfragen.

    Die Funktion fragt die aktuelle Simulatorzeit an und liefert sie in einem `datetime.time`-Objekt.

    Basierend auf der Antwort setzt sie ausserdem `client_datetime`, `server_datetime` und `time_offset`.
    Diese Attribute können benutzt werden, um die Simulatorzeit zu berechnen (`calc_simzeit`-Funktion),
    ohne dass eine erneute Anfrage geschickt werden muss.

    Info:
        `client_datetime` und `server_datetime` enthalten das aktuelle Datum.
        Das ist nötig, um den `time_offset` als `timedelta` zu berechnen.
        Da der Simulator kein Datum kennt, sollten die Datumsfelder nicht beachtet werden.
        Die `datetime.datetime.time`-Methode ist ein schneller Weg, ein `datetime.time`-Objekt zu erhalten.

    Returns:
        Aktuelle Simulatorzeit
    """
    self.client_datetime = datetime.datetime.now()
    await self._send_request("simzeit", sender=0)
    simzeit = await self.antwort_channel_out.receive()
    secs, msecs = divmod(int(simzeit.simzeit['zeit']), 1000)
    mins, secs = divmod(secs, 60)
    hrs, mins = divmod(mins, 60)
    t = datetime.time(hour=hrs, minute=mins, second=secs, microsecond=msecs * 1000)
    self.server_datetime = datetime.datetime.combine(self.client_datetime, t)
    self.time_offset = (self.server_datetime - self.client_datetime)
    return self.server_datetime

async def request_zug(self, zid: int) -> ZugDetails | None:
    """
    Einzelnen Zug und Fahrplan anfragen.

    Der Zug wird in die Zugliste eingetragen bzw. aktualisiert und als `ZugDetails`-Objekt zurückgegeben.

    Args:
        zid: einzelne zug-id

    Returns:
        `ZugDetails` inkl. Fahrplan.
        None, wenn der Zug nicht verzeichnet ist.
    """
    zid = int(zid)
    if zid:
        await self.request_zugdetails(zid)
        await self.request_zugfahrplan(zid)
    else:
        return None

    try:
        zug = self.zugliste[zid]
        return zug
    except KeyError:
        return None

async def request_zugdetails(self, zid: int | Iterable[int] | None = None) -> None:
    """
    ZugDetails eines, mehrerer oder aller Züge anfragen.

    Wenn ein ZugDetails-Objekt mit der zid bereits in der Zugliste angelegt ist,
    wird es aktualisiert, andernfalls neu angelegt.
    Wenn ein Fehler auftritt (weil z.B. der Zug nicht mehr im Stellwerk ist),
    wird der Zug aus der Zugliste gelöscht.

    Args:
        zid: Einzelne Zug-ID, Iterable von Zug-IDs, oder None (alle in der Zugliste).
    """

    if zid is not None:
        if isinstance(zid, Iterable):
            zids = list(iter(zid))
        else:
            zids = [int(zid)]
    else:
        zids = list(self.zugliste.keys())

    for zid in sorted(map(int, zids)):
        await self.request_zugdetails_einzeln(zid)

async def request_zugfahrplan(self, zid: int | Iterable[int] | None = None):
    """
    Fahrplan eines, mehrerer oder aller Züge anfragen.

    Das ZugDetails-Objekt muss in der Zugliste bereits existieren.

    Abgefahrene Wegpunkte sind im Fahrplan nicht mehr vorhanden.

    Args:
        zid: einzelne zug-id, iterable von zug-ids, oder None (alle in der liste).
    """

    if zid is not None:
        zids = [zid]
    else:
        zids = self.zugliste.keys()
    for zid in sorted(map(int, zids)):
        if zid in self.zugliste:
            await self.request_zugfahrplan_einzeln(zid)

async def resolve_zugflags(self, zid: int | Iterable[int] | None = None) -> None:
    """
    Folgezüge aus den Zugflags auflösen.

    Da `request_zugliste` die Folgezüge (Ersatz-, Flügel- und Kuppelzüge) nicht automatisch erhält,
    lesen wir diese aus den Zugflags aus und fragen ihre Details und Fahrpläne explizit an.
    Die Funktion arbeitet iterativ, bis alle Folgezüge aufgelöst sind.
    Die Züge werden in die Zugliste eingetragen und im Stammzug referenziert.

    Info:
        zids sind nicht geordnet. Ersatzzüge können eine tiefere zid als der Stammzug haben.

    Args:
        zid: Einzelne Zug-ID, Iterable von Zug-IDs, oder None (alle in der Liste).
    """
    if zid is not None:
        zids = [int(zid)]
    else:
        zids = list(self.zugliste.keys())

    erledigte_zids = []
    while zids:
        zid = zids.pop(0)
        if zid in erledigte_zids:
            continue  # unendliche rekursion verhindern
        else:
            erledigte_zids.append(zid)

        try:
            zug = self.zugliste[zid]
        except KeyError:
            continue

        for planzeile in zug.fahrplan:
            if zid2 := planzeile.ersatz_zid():
                logger.info(f"zid {zid2} als ersatz für {zid} anfragen")
                zug2 = await self.request_zug(zid2)
                if zug2 is not None:
                    planzeile.ersatzzug = zug2
                    zug2.stamm_zids.add(zug.zid)
                    zug2.verspaetung = zug.verspaetung
                    zids.append(zid2)
                else:
                    logger.warning(f"keine antwort für zug {zid2}")
            if zid2 := planzeile.fluegel_zid():
                logger.info(f"zid {zid2} als flügel für {zid} anfragen")
                zug2 = await self.request_zug(zid2)
                if zug2 is not None:
                    planzeile.fluegelzug = zug2
                    zug2.stamm_zids.add(zug.zid)
                    zug2.verspaetung = zug.verspaetung
                    zids.append(zid2)
                else:
                    logger.warning(f"keine antwort für zug {zid2}")
            if zid2 := planzeile.kuppel_zid():
                logger.info(f"zid {zid2} als kuppel für {zid} anfragen")
                zug2 = await self.request_zug(zid2)
                if zug2 is not None:
                    planzeile.kuppelzug = zug2
                    zug2.stamm_zids.add(zug.zid)
                    zids.append(zid2)
                else:
                    logger.warning(f"keine antwort für zug {zid2}")

def update_bahnsteig_zuege(self):
    """
    Züge in Bahnsteigliste eintragen.

    Im `zuege`-attribut der Bahnsteige werden die an den Bahnsteig disponierten Züge aufgelistet.
    `zuege` ist ein Dictionary und bildet zid auf ZugDetails ab.
    Die ZugDetails sind weak References.
    """

    for bahnsteig in self.bahnsteigliste.values():
        bahnsteig.zuege.clear()

    for zid in self.zugliste.keys():
        zug = self.zugliste[zid]
        for fahrplanzeile in zug.fahrplan:
            try:
                bahnsteig = self.bahnsteigliste[fahrplanzeile.gleis]
            except KeyError:
                pass
            else:
                bahnsteig.zuege[zid] = zug

def update_wege_zuege(self):
    """
    Züge in Wegelisten eintragen.

    Im Züge-Attribut der Wege und Knoten (Einfahrten, Ausfahrten, Haltepunkte)
    werden die fahrplanmässig daran vorbei kommenden Züge aufgelistet.
    """
    for knoten in self.wege.values():
        knoten.zuege.clear()

    einfahrten = {knoten.name: knoten for knoten in self.wege_nach_typ[6]}
    ausfahrten = {knoten.name: knoten for knoten in self.wege_nach_typ[7]}
    bahnsteige = {knoten.name: knoten for knoten in self.wege_nach_typ[5]}
    haltepunkte = {knoten.name: knoten for knoten in self.wege_nach_typ[12]}
    haltepunkte.update(bahnsteige)

    for zid in self.zugliste.keys():
        zug = self.zugliste[zid]

        try:
            einfahrten[zug.von].zuege[zid] = zug
        except KeyError:
            pass
        try:
            ausfahrten[zug.nach].zuege[zid] = zug
        except KeyError:
            pass
        for fahrplanzeile in zug.fahrplan:
            try:
                haltepunkte[fahrplanzeile.gleis].zuege[zid] = zug
            except KeyError:
                pass