stsobj

def update(self, item: Mapping) -> AnlagenInfo:
    """
    Attribute vom xml-Dokument übernehmen.

    Args:
        item: Dictionary mit den Attributen aus dem xml-Tag.

    Returns:
        AnlagenInfo-Objekt
    """
    self.aid = int(item['aid'])
    self.name = str(item['name']).strip()
    self.build = int(item['simbuild'])
    self.region = item['region']
    self.online = str(item['online']).lower() == 'true'
    return self

def update(self, item: untangle.Element) -> BahnsteigInfo:
    """
    Attribute vom xml-Dokument übernehmen.

    Die Namen der Nachbarbahnsteige werden in `nachbarn_namen` gespeichert.
    Die `nachbarn` und `zuege` Attribute sind möglicherweise veraltet.

    Args:
        item: Dictionary mit den Attributen aus dem xml-Tag.

    Returns:
        Self
    """

    self.name = str(item['name']).strip()
    self.haltepunkt = str(item['haltepunkt']).lower() == 'true'
    try:
        self.nachbarn_namen = sorted([str(n['name']).strip() for n in item.n])
    except AttributeError:
        self.nachbarn_namen = []

    return self

def __eq__(self, other: Ereignis) -> bool:
    """
    Gleichheit zweier Ereignisse

    Ereignisse werden als gleich erachtet, wenn art, zid und gleis gleich sind.
    Dies kann dazu benutzt werden, wiederholte Ereignismeldungen zu filtern.
    (Die Pluginschnittstelle schickt gewisse ereignismeldungen wie rothalt und abfahrt wiederholt.)
    """
    return self.art == other.art and self.zid == other.zid and self.gleis == other.gleis

def __hash__(self) -> int:
    """
    hash-Funktion basierend auf Gleichheitsklasse.

    Ereignisse werden als gleich erachtet, wenn art, zid und gleis gleich sind.
    Für solchermassen "gleiche" Ereignisse generiert diese Funktion den gleichen hash-Wert.
    Dies kann dazu benutzt werden, wiederholte Ereignismeldungen zu filtern.
    (Die Pluginschnittstelle schickt gewisse ereignismeldungen wie rothalt und abfahrt wiederholt.)
    """
    return hash((self.art, self.zid, self.gleis))

def find_fahrplan(self,
                  gleis: str | None = None,
                  plan: str | None = None,
                  zeit: datetime.time | None = None,
                  ) -> tuple[int | None, FahrplanZeile | None]:
    """
    Index und Fahrplanzeile nach Gleis und/oder Zeit suchen

    Alle angegebenen Kriterien müssen zutreffen.
    Die Zeit muss grösser oder gleich der Ankunftszeit (wenn bekannt)
    und kleiner oder gleich der Abfahrtszeit (wenn bekannt) sein.
    Wenn eine der Zeiten nicht bekannt ist, wird das entsprechende Kriterium als erfüllt gewertet.

    Args:
        gleis: Gleiskriterium (Gross-/Kleinschreibung egal)
        plan: Plangleiskriterium (Gross-/Kleinschreibung egal)
        zeit: Zeitkriterium, wahr, wenn der Wert zwischen Ankunft und Abfahrt des Eintrags liegt

    Returns:
        Listenindex im Fahrplan und FahrplanZeile-Objekt.
        Beide Resultate sind None, wenn kein passender Eintrag gefunden wurde.
    """

    gleis = gleis.casefold() if gleis else None
    plan = plan.casefold() if plan else None

    for index, zeile in enumerate(self.fahrplan):
        if gleis and gleis != zeile.gleis.casefold():
            continue
        if plan and plan != zeile.plan.casefold():
            continue
        if zeit and zeile.an and zeit < zeile.an:
            continue
        if zeit and zeile.ab and zeit > zeile.ab:
            continue
        return index, zeile

    return None, None

def find_fahrplan_index(self,
                        gleis: str | None = None,
                        plan: str | None = None,
                        zeit: datetime.time | None = None,
                        ) -> int | None:
    """
    Fahrplanzeilenindex nach Gleis und/oder Zeit suchen

    Alle angegebenen Kriterien müssen zutreffen.
    Die Zeit muss grösser oder gleich der Ankunftszeit (wenn bekannt)
    und kleiner oder gleich der Abfahrtszeit (wenn bekannt) sein.
    Wenn eine der Zeiten nicht bekannt ist, wird das entsprechende Kriterium als erfüllt gewertet.

    Diese Methode ist ein Wrapper von find_fahrplan, der nur den Index zurückgibt.

    Args:
        gleis: Gleiskriterium (Gross-/Kleinschreibung egal)
        plan: Plangleiskriterium (Gross-/Kleinschreibung egal)
        zeit: Zeitkriterium, wahr, wenn der Wert zwischen Ankunft und Abfahrt des Eintrags liegt

    Returns:
        Listenindex in Fahrplan oder None.
        Vorsicht, 0 ist ein gültiges Resultat!
    """

    index, _ = self.find_fahrplan(gleis=gleis, plan=plan, zeit=zeit)
    return index

def find_fahrplanzeile(self,
                       gleis: str | None = None,
                       plan: str | None = None,
                       zeit: datetime.time | None = None,
                       ) -> FahrplanZeile | None:
    """
    Fahrplanzeile nach Gleis und/oder Zeit suchen.

    Alle angegebenen Kriterien müssen zutreffen.
    Die Zeit muss grösser oder gleich der Ankunftszeit (wenn bekannt)
    und kleiner oder gleich der Abfahrtszeit (wenn bekannt) sein.
    Wenn eine der Zeiten nicht bekannt ist, wird das entsprechende Kriterium als erfüllt gewertet.

    Diese Methode ist ein Wrapper von find_fahrplan, der nur das Fahrplanobjekt zurückgibt.

    Args:
        gleis: Gleiskriterium (Gross-/Kleinschreibung egal)
        plan: Plangleiskriterium (Gross-/Kleinschreibung egal)
        zeit: Zeitkriterium, wahr, wenn der Wert zwischen Ankunft und Abfahrt des Eintrags liegt

    Returns:
        FahrplanZeile-Objekt oder None.
    """

    _, zeile = self.find_fahrplan(gleis=gleis, plan=plan, zeit=zeit)
    return zeile

def graph(self) -> nx.DiGraph:
    """
    Fahrplan im networkx directed Graph Format

    Die Knoten sind Anschluss- oder Gleisnamen und haben folgende Attribute:

    - typ: 'anschluss' oder 'gleis'
    - an: Ankunftszeit als datetime.time (kann fehlen)
    - ab: Ankunftszeit als datetime.time (kann fehlen)
    - aufenthalt: Aufenthaltszeit in sekunden (kann fehlen)

    Die Kanten haben folgende Attribute:

    - fahrzeit: Planmässige Fahrzeit in sekunden (kann fehlen)

    Returns:
        networkx-Graph
    """
    graph = nx.DiGraph()

    start = self.von
    startzeit = np.nan
    if start:
        graph.add_node(start, typ='anschluss')

    for zeile in self.fahrplan:
        ziel = zeile.gleis
        try:
            ankunftszeit = time_to_seconds(zeile.an)
        except AttributeError:
            ankunftszeit = np.nan
        try:
            abfahrtszeit = time_to_seconds(zeile.ab)
        except AttributeError:
            abfahrtszeit = np.nan

        if ziel:
            aufenthalt = abfahrtszeit - ankunftszeit if not zeile.durchfahrt() else 0
            graph.add_node(ziel, typ='gleis')
            if zeile.an:
                graph.nodes[ziel]['an'] = zeile.an
            if zeile.ab:
                graph.nodes[ziel]['ab'] = zeile.ab
            if not np.isnan(aufenthalt):
                graph.nodes[ziel]['aufenthalt'] = aufenthalt

            if start:
                fahrzeit = ankunftszeit - startzeit
                graph.add_edge(start, ziel)
                if not np.isnan(fahrzeit):
                    graph.edges[start][ziel]['fahrzeit'] = fahrzeit

        start = ziel
        startzeit = abfahrtszeit

    ziel = self.nach
    if ziel:
        graph.add_node(ziel, typ='anschluss')
        if start:
            graph.add_edge(start, ziel)

    return graph

def route(self, plan: bool = False) -> Generator[str, None, None]:
    """
    Route (Reihe von Stationen) des Zuges als Generator

    Die Route ist eine Liste von Stationen (Gleisen, inkl. Ein- und Ausfahrt) in der Reihenfolge des Fahrplans.
    Ein- und Ausfahrten können bei Ersatzzügen o.ä. fehlen.
    Durchfahrtsgleise sind auch enthalten.

    Ein etwaiges Präfix 'Gleis' bei Nummernwechsel wird entfernt.

    Args:
        plan: Plangleise statt effektive Gleise melden

    Returns:
        Generator von Gleisnamen.
    """
    if self.von:
        yield self.von.replace("Gleis ", "")
    for fpz in self.fahrplan:
        if plan:
            yield fpz.plan.replace("Gleis ", "")
        else:
            yield fpz.gleis.replace("Gleis ", "")
    if self.nach:
        yield self.nach.replace("Gleis ", "")

def update(self, ereignis: Mapping) -> Ereignis:
    """
    Attributwerte vom xml-Dokument übernehmen.

    Args:
        ereignis: Mapping mit den Attributen aus dem xml-Tag.
    """
    super().update(ereignis)
    self.art = str(ereignis['art'])

    return self

def __eq__(self, other: FahrplanZeile) -> bool:
    """
    Gleichheit von zwei Fahrplanzeilen feststellen.

    Gleichheit bedeutet: gleicher Zug und gleiches Plangleis.
    Jedes plangleis kommt im sts-Fahrplan nur einmal vor.

    Args:
        other: zu vergleichendes FahrplanZeile-Objekt

    Returns:
        True, wenn Zug und Plangleis übereinstimmen, sonst False
    """
    return self.zug.zid == other.zug.zid and self.plan == other.plan

def __hash__(self) -> int:
    """
    Zugziel-Hash

    Der Hash basiert auf der `fid`.

    Returns:
        Hash-Wert
    """

    return hash(self.fid)

def durchfahrt(self) -> bool:
    """
    Durchfahrt-Flag
    """
    return 'D' in self.flags

def ersatz_zid(self) -> int | None:
    """
    zid aus dem Ersatz-Flag
    """
    mo = re.search(r"E[0-9]?\(([0-9]+)\)", self.flags)
    if mo:
        return int(mo.group(1))
    else:
        return None

def fluegel_zid(self) -> int | None:
    """
    zid aus dem Fluegeln-Flag
    """
    mo = re.search(r"F[0-9]?\(([0-9]+)\)", self.flags)
    if mo:
        return int(mo.group(1))
    else:
        return None

def kuppel_zid(self) -> int | None:
    """
    zid aus dem Kuppel-Flag
    """
    mo = re.search(r"K[0-9]?\(([0-9]+)\)", self.flags)
    if mo:
        return int(mo.group(1))
    else:
        return None

def lokumlauf(self) -> bool:
    """
    Lokumlauf-Flag
    """
    return 'L' in self.flags

def lokwechsel(self) -> tuple[int, int] | None:
    """
    Lokwechsel-Flag

    Returns:
        Elementnummern der Ein- und Ausfahrgleise oder None.
        Die Gleise können in einer beliebigen Reihenfolge auftreten.
        Einfahrt/Ausfahrt kann aus dem Elementtyp bestimmt werden.
    """
    mo = re.search(r"W\[([0-9]+)]\[([0-9]+)]", self.flags)
    if mo:
        return int(mo.group(1)), int(mo.group(2))
    else:
        return None

def richtungswechsel(self) -> bool:
    """
    Richtungswechsel-Flag
    """
    return 'R' in self.flags

def update(self, item: Mapping) -> FahrplanZeile:
    """
    Daten von untangle-Element oder anderer FahrplanZeile übernehmen.

    Es werden nur die Attribute übernommen, die von der Pluginschnittstelle geliefert werden.

    Args:
        item: eines von folgenden Objekten:

            - untangle.Element mit dem gleis-Tag von der Simulatorschnittstelle,
            - ein anderes FahrplanZeile-Objekt,
            - Dictionary mit Werten, die den Attributen dieser Klasse entsprechen.
    """

    if isinstance(item, self.__class__):
        item = item.__dict__

    if isinstance(item, untangle.Element):
        self.gleis = str(item['name']).strip()
    else:
        self.gleis = str(item['gleis']).strip()

    self.plan = str(item['plan']).strip()

    try:
        if item['an'] is None or isinstance(item['an'], datetime.time):
            self.an = item['an']
        else:
            self.an = datetime.time.fromisoformat(item['an'])
    except (TypeError, ValueError):
        self.an = None

    try:
        if item['an'] is None or isinstance(item['ab'], datetime.time):
            self.ab = item['ab']
        else:
            self.ab = datetime.time.fromisoformat(item['ab'])
    except (TypeError, ValueError):
        self.ab = None

    self.flags = str(item['flags']).strip()
    self.hinweistext = str(item['hinweistext'])

    return self

def vorzeitige_abfahrt(self) -> bool:
    """
    Vorzeitige-Abfahrt-Flag
    """
    return 'A' in self.flags

def update(self, shape: Mapping) -> Knoten:
    """
    Attributwerte vom xml-Dokument übernehmen.

    Args:
        shape: Mapping mit den Attributen aus dem xml-Tag.

    Returns:
        self
    """

    try:
        self.enr = int(shape['enr'])
    except TypeError:
        self.enr = None
    try:
        self.name = str(shape['name']).strip()
    except TypeError:
        self.name = None
    try:
        self.typ = int(shape['type'])
    except TypeError:
        self.typ = 0
    if self.enr is not None:
        self.key = self.enr
    else:
        self.key = self.name
    return self

def __str__(self) -> str:
    """
    Einfach lesbare Beschreibung

    Zeigt den Zugnamen, von/nach, das nächste Gleis, die Verspätung und Unsichtbarkeit an.

    Returns:
        Beschreibung als String.
    """
    if self.gleis:
        gleis = self.gleis
        if self.gleis != self.plangleis:
            gleis = gleis + '/' + self.plangleis + '/'
        if self.amgleis:
            gleis = '[' + gleis + ']'
    else:
        gleis = ''

    sichtbar = "" if self.sichtbar else " (unsichtbar)"

    return f"{self.name}: {self.von} - {gleis} - {self.nach} ({self.verspaetung:+}){sichtbar}"

def find_fahrplan(self,
                  gleis: str | None = None,
                  plan: str | None = None,
                  zeit: datetime.time | None = None,
                  ) -> tuple[int | None, FahrplanZeile | None]:
    """
    Index und Fahrplanzeile nach Gleis und/oder Zeit suchen

    Alle angegebenen Kriterien müssen zutreffen.
    Die Zeit muss grösser oder gleich der Ankunftszeit (wenn bekannt)
    und kleiner oder gleich der Abfahrtszeit (wenn bekannt) sein.
    Wenn eine der Zeiten nicht bekannt ist, wird das entsprechende Kriterium als erfüllt gewertet.

    Args:
        gleis: Gleiskriterium (Gross-/Kleinschreibung egal)
        plan: Plangleiskriterium (Gross-/Kleinschreibung egal)
        zeit: Zeitkriterium, wahr, wenn der Wert zwischen Ankunft und Abfahrt des Eintrags liegt

    Returns:
        Listenindex im Fahrplan und FahrplanZeile-Objekt.
        Beide Resultate sind None, wenn kein passender Eintrag gefunden wurde.
    """

    gleis = gleis.casefold() if gleis else None
    plan = plan.casefold() if plan else None

    for index, zeile in enumerate(self.fahrplan):
        if gleis and gleis != zeile.gleis.casefold():
            continue
        if plan and plan != zeile.plan.casefold():
            continue
        if zeit and zeile.an and zeit < zeile.an:
            continue
        if zeit and zeile.ab and zeit > zeile.ab:
            continue
        return index, zeile

    return None, None

def find_fahrplan_index(self,
                        gleis: str | None = None,
                        plan: str | None = None,
                        zeit: datetime.time | None = None,
                        ) -> int | None:
    """
    Fahrplanzeilenindex nach Gleis und/oder Zeit suchen

    Alle angegebenen Kriterien müssen zutreffen.
    Die Zeit muss grösser oder gleich der Ankunftszeit (wenn bekannt)
    und kleiner oder gleich der Abfahrtszeit (wenn bekannt) sein.
    Wenn eine der Zeiten nicht bekannt ist, wird das entsprechende Kriterium als erfüllt gewertet.

    Diese Methode ist ein Wrapper von find_fahrplan, der nur den Index zurückgibt.

    Args:
        gleis: Gleiskriterium (Gross-/Kleinschreibung egal)
        plan: Plangleiskriterium (Gross-/Kleinschreibung egal)
        zeit: Zeitkriterium, wahr, wenn der Wert zwischen Ankunft und Abfahrt des Eintrags liegt

    Returns:
        Listenindex in Fahrplan oder None.
        Vorsicht, 0 ist ein gültiges Resultat!
    """

    index, _ = self.find_fahrplan(gleis=gleis, plan=plan, zeit=zeit)
    return index

def find_fahrplanzeile(self,
                       gleis: str | None = None,
                       plan: str | None = None,
                       zeit: datetime.time | None = None,
                       ) -> FahrplanZeile | None:
    """
    Fahrplanzeile nach Gleis und/oder Zeit suchen.

    Alle angegebenen Kriterien müssen zutreffen.
    Die Zeit muss grösser oder gleich der Ankunftszeit (wenn bekannt)
    und kleiner oder gleich der Abfahrtszeit (wenn bekannt) sein.
    Wenn eine der Zeiten nicht bekannt ist, wird das entsprechende Kriterium als erfüllt gewertet.

    Diese Methode ist ein Wrapper von find_fahrplan, der nur das Fahrplanobjekt zurückgibt.

    Args:
        gleis: Gleiskriterium (Gross-/Kleinschreibung egal)
        plan: Plangleiskriterium (Gross-/Kleinschreibung egal)
        zeit: Zeitkriterium, wahr, wenn der Wert zwischen Ankunft und Abfahrt des Eintrags liegt

    Returns:
        FahrplanZeile-Objekt oder None.
    """

    _, zeile = self.find_fahrplan(gleis=gleis, plan=plan, zeit=zeit)
    return zeile

def graph(self) -> nx.DiGraph:
    """
    Fahrplan im networkx directed Graph Format

    Die Knoten sind Anschluss- oder Gleisnamen und haben folgende Attribute:

    - typ: 'anschluss' oder 'gleis'
    - an: Ankunftszeit als datetime.time (kann fehlen)
    - ab: Ankunftszeit als datetime.time (kann fehlen)
    - aufenthalt: Aufenthaltszeit in sekunden (kann fehlen)

    Die Kanten haben folgende Attribute:

    - fahrzeit: Planmässige Fahrzeit in sekunden (kann fehlen)

    Returns:
        networkx-Graph
    """
    graph = nx.DiGraph()

    start = self.von
    startzeit = np.nan
    if start:
        graph.add_node(start, typ='anschluss')

    for zeile in self.fahrplan:
        ziel = zeile.gleis
        try:
            ankunftszeit = time_to_seconds(zeile.an)
        except AttributeError:
            ankunftszeit = np.nan
        try:
            abfahrtszeit = time_to_seconds(zeile.ab)
        except AttributeError:
            abfahrtszeit = np.nan

        if ziel:
            aufenthalt = abfahrtszeit - ankunftszeit if not zeile.durchfahrt() else 0
            graph.add_node(ziel, typ='gleis')
            if zeile.an:
                graph.nodes[ziel]['an'] = zeile.an
            if zeile.ab:
                graph.nodes[ziel]['ab'] = zeile.ab
            if not np.isnan(aufenthalt):
                graph.nodes[ziel]['aufenthalt'] = aufenthalt

            if start:
                fahrzeit = ankunftszeit - startzeit
                graph.add_edge(start, ziel)
                if not np.isnan(fahrzeit):
                    graph.edges[start][ziel]['fahrzeit'] = fahrzeit

        start = ziel
        startzeit = abfahrtszeit

    ziel = self.nach
    if ziel:
        graph.add_node(ziel, typ='anschluss')
        if start:
            graph.add_edge(start, ziel)

    return graph