fix: actually intercept voice_channel status error

fix: make the bot API conform
i am SO sorry transitous team I only saw the notice now
2026-09-17 16:52:47 +00:00 · 2026-08-22 23:38:21 +02:00 · 2026-08-21 23:48:45 +02:00 · 2026-08-21 18:40:44 +02:00 · 2026-08-20 22:29:46 +02:00 · 2026-08-20 22:26:35 +02:00
29 changed files with 1473 additions and 707 deletions
@@ -1,5 +1,7 @@
 venv/
 __pycache__/
 src/data/announcements/*
 src/data/assets/current_map.png
 !src/data/announcements/.gitkeep
 config.json
 stations.json
@@ -1,175 +1,190 @@
 # Gleiswechsel
-Gleiswechel ist ein Discord Bot, welcher einen Sprachkanal zu einer real-existierenden, aktuell befahrenden Zugverbindung umbenennt. Diesen Namen behält der Kanal so lange, wie die Verbindung in echt dauert.  
+Gleiswechsel [ˈɡlaɪsvɛksəl] (german for "platform change") is a selfhostable discord bot which regularly changes the name of a voice chat to a real public transport connection. The channel will keep the name until the connection arrived at its last stop, after that it will automatically select a new one.
-![Beispiel Kanal](.github/preview_kanal.png) 
+![Example Channel](.github/preview_kanal.png)
-Der Bot stellt außerdem den `/info` Befehl dar, welcher einem weitere Informationen zur Verbindung zurückgibt  
+## Features
 - [International support](https://transitous.org/sources/) for countries aswell as and cities
 - Support for various types of transportations, including but not limited to Subways, Busses, Funiculars, Trams and Trains
 - Multi language support (+ option to easily add more languages)
 - Announcements, including the option to join the voice chat and play an audio file while arriving at a specific station
 - Highly customizable
 - pretty `/info` embed with some details about your current ride
-![Beispiel info](.github/preview_info.png)
+![Example info](.github/preview_info.png)
 ## Setup
-```sh
+Follow [this guide](https://guide.pycord.dev/getting-started/creating-your-first-bot) to create your discord bot up until you have a token. 
 git clone https://github.com/kaaninchen/Gleiswechsel.git
-# Mit Python
+Make sure that you have [Python](https://www.python.org/) installed! 
 Download the repo (either with git or by clicking the big "Code" button at the start on this page, downloading the zip and extracting it) and run:
 ```sh
 # Create a virtual environment so that the bot won't cluster your system with dependencies
 python -m venv venv
 # Activate your venv, you should have gotten instructions after running the first command, e.g.:
 source venv/bin/activate
 # Install the required dependencies
 pip install -r requirements.txt
 # Mit uv
 uv venv venv
 source venv/bin/activate
 uv pip install -r requirements.txt
 ```
-### Config
+Next, you should configure the bot to your liking
-`$ cp config.json.example config.json`
+## Config
-```jsonc
+Even if it seems a bit tedious, I highly recommend going through the entire config and checking if there's something that you would like to customize.  
 {
    "token": "", // Token des Bots
    "stations": [ "Berlin Hbf", "Hamburg Hbf", "München Hbf", "Amsterdam Centraal"], // Bahnhöfe, von denen die Anzeigetafelns gelesen werden. Namen kann man auf https://dbf.finalrewind.org/ nachschlagen.
    "dbf": "https://dbf.finalrewind.org", // Die DBF Instanz. Normalerweise müsste man hier nichts ändern
    "server": , // Discord Server ID
    "vc": , // Server VC ID
    "random": true, // Random Zug aus der Anzeigetafel (true) oder erster Zug, der angezeigt wird (false)
    "emojis": true, // Emoji Namen beim Channel-Namen (true) oder nicht (false),
    "formatting": "┇", // VC Name. Davor steht der Emoji, danach der Zug.
    "announcemenents": true, // Announcements zur aktuellen Zugreise im VC-Kanal ja (true) oder nein (false)
    "voice_announcements": [ // siehe weitere config erklärungen in der README, benötigt extra setup
        {
            "enabled": false,
            "stations": {
                "general": ""
            }
        }
    ],
    "blacklist": [] // Blacklist für bestimmte Zug-Typen
 }
 I added an [example config](config.json.example). Rename `config.json.example` to `config.json` and fill it out.
 ### Config explanations
 #### discord
 - `"token"` is for the discord bot token. You should have copied it earlier
 - `"server"` and `"vc"` are the ID's for the server and the voice chat that the bot should use. Follow [this guide](https://support.discord.com/hc/en-us/articles/206346498-Where-can-I-find-my-User-Server-Message-ID) to get them.
 - `"lang"` is for the language that the bot should use within discord. The relevant language files are located in [src/data/locales/](src/data/locales). Current available languages are english ("en") and german ("de"). Feel free to add your language if you miss it! 
 - `"formatting"` and `"emojis"` are for the channel name. Set `emojis` to `False` and `"formatting"` to `null` if you just want the connection as the channel's name without any decor.
 #### connections
 ##### stations
 You can add your desired stations that the bot should search connections from there. The bot will choose one of the stations at random. 
 The bot will also search for similar named stations if it couldn't find an exact match to your input. This is really handy if you'd just like to ride around in a city with various stations. For example, if you just input "Amsterdam" as a station, the bot would randomly choose one of these stations:
 ```json
 "Amsterdam": [
    "Amsterdam Zuid",
    "Amsterdam RAI",
    "Amsterdam Amstel",
    "Amsterdam, Gein",
    "Amsterdam Centraal",
    "Amsterdam, Noord",
    "Amsterdam, Rokin",
    "Amsterdam Lelylaan",
    "Amsterdam Sloterdijk"
 ]
 ```
-<details>
+The bot will also warn you if it couldn't find a station with the exact name as your input:
 <summary>weitere Config Erklärungen</summary>
-#### dbf:
+```
-Falls, aus irgendwelchem Gründen, man nicht die [offizielle DBF Instanz](https://dbf.finalrewind.org) nutzen möchte, hat man die Möglichkeiten seine eigene zu hosten. Instruction dazu gibts auf dem [zuständigen Repo](https://github.com/derf/db-fakedisplay). Dafür kann man das Feld in der config mit der eigenen URL austauschen. 
+22:44:46: INFO: No station associated as 'Amsterdam', choosing random from similar named stations
 ```
-#### random:
+but you can safely ignore this warning if you're fine with it. 
 Bei kleineren Bahnhöfen stehen an den Anzeigetafeln öfters die Züge lange vor Abfahrt da, weil sonst der Bahnhof leer steht. Dadurch wird auch der Name des VC sehr lange gleich bleiben.   
 Sollte man `random = false` setzen, würde immer der erste Zug an der Anzeigetafel genommen werden, welcher auch der wäre welcher am frühesten losfährt. Wenn man viele Bahnhöfe hat besteht darin keine Gefahr. 
-Wenn man nur einen Bahnhof hat ist es stark empfohlen random zu nutzen. Sonst könnte der Bot bei unvollständigen Einträgen in einer Schleife immer wieder vergeblich den selben unvollständigen Zug probieren.
+If not, I've created a tool which would help you to get the exact station name. You can use the tool by running
 #### announcements:
 Der Bot kann während der Zugreise Ankündigungen in den Textkanal vom Sprachkanal schicken. Das würde er aber auch nur machen wenn sich dort mindestens eine Person aufhält. Aktuelle Announcements:
 - 3-5 Min vor Umstieg gibt es eine Ankündigung dafür
 - Info Embed bei Umstieg
 - voice_announcements
 #### voice_announcements:
 ⚠️ Announcements muss aktiviert sein
 Der Bot kann 3-5 Min vor Umstieg den VC joinen und eine Audiodatei abspielen. Dafür braucht der Bot ffmpeg.
 ```sh
-$ sudo apt install ffmpeg # Debian/Ubuntu
+$ python run main.py stations
 $ brew install ffmpeg # macOS (brew)
 ```
-##### Voice_announcements config:  
+Example output:
 ```json
-    "voice_announcements": [
+    "stations": {
-        {
+        "Amsterdam": [
-            "enabled": true,
+            "Amsterdam Zuid",
-            "stations": {
+            "Amsterdam RAI",
-                "general": "general.aac",
+            "Amsterdam Amstel",
-                "Hannover": "hannover.aac"
+            "Amsterdam, Gein",
-            }
+            "Amsterdam Centraal",
-        }
+            "Amsterdam, Noord",
-    ],
+            "Amsterdam, Rokin",
            "Amsterdam Lelylaan",
            "Amsterdam Sloterdijk"
        ],
        "Berlin": [
            "Berlin Hbf",
            "Berlin ZOB",
            "Berlin Ostbf",
            "Berlin-Spandau",
            "Berlin Südkreuz",
            "U Rudow (Berlin)",
            "S Buch (Berlin)",
            "U Hönow (Berlin)"
        ]
      }
 ```
-Audiodateien werden in [src/data/announcements](src/data/announcements) platziert. In der Config wird der Name der Station (z.B. Hannover) zu dem Namen der Audiodatei (z.B. hannover.aac) zugewiesen. Die Audiodatei braucht keinen Path.  
+The tool will also ask if it should save a .json file with more informations for every similar station. If you're unsure about what which station is, then it can be really helpful! It would give you data like which types of transports arrive at every similar station, in which country they are and also their coordinates. 
-Der Eintrag `general` meint die allgemeine Audiodatei, welche bei jeder Endstation (mit Ausnahme der zugewiesenen) spielt. Sollte man nur Audios bei zugewiesenen Endstationen abspielen wollen kann man `general` leerlassen, der bot skipped das ganze dann:  
+If you choose to generate the json, then you'll find the file as `stations.json` in the same directory as `main.py`
-```json
+##### IDs
-"stations": {
+For every station inside of the `stations.json` you'll find an ID. You can add that ID to `"IDs"` to really specify that you would like to use THAT station, and not a different one.
-    "general": ""
+
-}
+This is especially useful if you want to add a station whose name isn't unique and also used by other stations. The bot would falsely use the first station with the same name and consider it an exact match, even if you wanted a different one. This won't happen with the ID, as every ID is uniquely assigned to only one station.
 ##### blacklist
 You can blacklist specific types of transport, the bot would then skip them while selecting a connection. You can get the type either in your console (mode)
 ```sh
 22:44:47: INFO: Agency: GVB, mode: TRAM
 ```
 or in the `/info` embed. 
-Es gibt außerdem die Möglichkeit, mehrere Audiodateien zu einer Endstation durch Listen zuzuweisen. Der Bot sucht sich dann jedes mal wenn er den vc joined eine davon aus.
+I highly recommend keeping `"OTHER"` blacklisted, if the API doesn't know what that is then we probably shouldn't use it. Also, it would probably a good idea to keep `"RIDE_SHARING"` blacklisted as they have weird timetables
-```json
+##### min_duration, max_duration, max_wait_time, timezone
 "stations": {
    "general": ["general_1.aac", "general_2.aac"]
 }
 ```
-#### blacklist:  
+- `min_duration` is the minimal duration of the connection in minutes. It is HIGHLY recommended to set it to atleast 10, as discord only allows to change the name of a voice chat twice every 10 minutes.
 Die Blacklist ist dafür gedacht, ganze Zugtypen zu ignorieren. Beispielsweise möchte man, dass der Bot keine ICE's, keine NightJets und keine European Sleepers auswählt, da diese sehr lange Strecken fahren und der VC somit lange unverändert bleibt:
 ```json
 {
    "blacklist": [
        "ICE",
        "NJ",
        "ES"
    ]
 }
 ```  
-Die Namen der einzelnen Zugtypen kann im Footer von `/info` oder im Terminal log erfahren.
+- `max_duration` is the maximun duration of the connection in minutes. Set to `null` to disable
-#### src/data 
+- `max_wait_time` is the maximun wait time for a connection in hours. Don't set that one too low, as the bot may have some issues finding a suitable connection at night, or at stations that aren't frequently used. Set to `null` to disable
 Es kann vorkommen, dass während dem `/info` Befehl das Logo und die Farbe des Bahnuntermehns fehlt.
-![Beispiel für fehlende Daten](.github/info_fehlende_daten.png)  
+- `timezone` is timezone in the IANA timezone format. You can [look it up here](https://www.addevent.com/c/documentation/tools/time-zone-lookup)
-Die zugehörigen Daten lassen sich innerhalb [src/data/operators.py](src/data/operators.py) ergänzen. Der Aufbau dabei sollte selbsterklärend sein, dennoch habe ich eine kleine Beschreibung in die Datei hinzugefügt. Bei Änderungen sind PR's willkommen.  
+##### announcements
-Emojis für die Formattierung werden dynamisch anhand des Zugtypens gepulled. Dabei wird zwischen Nahverkehr und Fernverkehr unterschieden. Bei einem Zugtyp, welcher zu keiner der Kategorie assigned ist, wird ein Fallback Emoji eingesetzt. Sollte man einen Zugtypen hinzufügen wollen oder die Emojis ändern/deaktivieren wollen ist dies in [src/data/emojis.py](src/data/emojis.py) möglich. Die Namen der einzelnen Zugtypen kann im Footer von `/info` oder im Terminal log erfahren.
+##### `text_announcements:`
 The bot can send a text announcement in the voice chat at the start/end of a trip. 
 At the end of a trip, it would send this embed:
-Den Status, den sich der Bot alle 5 Minuten random auswählt, kann man in [src/data/status.py](src/data/status.py) anpassen.
+![end_of_trip](.github/end_of_trip_announcement.png)
-</details>
+It will also send the `/info` embed at the start of a new connection with informations about your new trip.
-### Running
+To reduce spam, the bot will only send announcements if someone is in the voice chat
 ##### `voice_announcements:`
 The bot can join the voice chat, play an audio file, and disconnect from the voice chat, at various points of your trip. You have to have [FFmpeg](https://www.ffmpeg.org/) installed for this to work.
 Place the audio file of your desired station in [src/data/announcements](src/data/announcements/) with the EXACT name of the station. The bot will automatically check if an audio file with the stations name exists, and if it does, play it. 
 #### http
 - `"user_agent"`: The user agent of the bot for the API. If you don't know what that is, then you shouldn't have to change that. Modify the contact URL (in my case, the github repo) if you change a lot of the code, so that transitous can contact you in case of any issues
 ## Running
 After you've set everything up, you're ready to start the bot!
 ```sh
-# Python
+$ python run main.py
 python main.py
 # ODER
 python3 main.py
 # uv
 uv run main.py
 ```
-## Bekannte Bugs
+## src/data
-#### Stuttgart in Berlin
+[src/data](src/data/) contains a few files/directories which may be interesting to customize. 
 Ich weiß nicht ganz wieso, aber die API vertauscht manchmal die S-Bahn von Berlin mit der S-Bahn von Stuttgart. Es scheint eher ein API-Issue zu sein, weswegen ich da leider mit dem Bot nicht viel ändern kann.   
 Der Bug führt dazu, dass bei manchen S-Bahn Verbindungen `DB Regio AG S-Bahn Stuttgart` als Betreiber der Berlin S-Bahn angezeigt wird. Außerdem gibt die API dem Bot die Ankunftszeiten einer S-Bahn Verbindung von Stuttgart wieder, während die Route von der aus Berlin stammt (Die Route und die Ankunftszeiten werden von zwei verschiedenen Endpoints gepulled: Route: `{dbf}/Berlin%20Hbf.json`, Ankunftszeit: `{dbf}/z/S%20{ID}/Berlin Hbf.json`).  
 Falls das einem zu sehr stört kann man S-Bahns auf die Blacklist packen.   
-```json
+### [emojis.py](src/data/emojis.py)
-{
+if `emojis` is enabled in the config, the bot will use that file to determine the right emoji for the voice chats name according to the current mode. You can add missing modes there or customize the emojis
    "blacklist": [
        "S "
    ]
 }
-```
+### [operators.py](src/data/operators.py)
 Metadata for the `/info` embed. You can assign an agency a logo, color and (optionally) some slogans. The agency name is visible in the console log and the `/info` embed.
-#### Nahreisezug
+If multiple agencys should use the same metadata, take a look at OPERATOR_ALIASES. 
 Der Bot empfängt durch die dbf API ein Operator Field, wo der Betreiber des Züges angezeigt wird. Dadurch kann im `/info` Embed das Logo durch [src/data/operators.py](src/data/operators.py) zugewiesen werden. Manchmal schmeißt die API aber als Operator "Nahreisezug" aus.
-![Beispiel für Nahreisezug](.github/info_nahreisezug.png)  
+You don't have to restart the bot after editing this file.
-Wenn mehrere Betreiber angezeigt werden (bspw `["SBB", "Nahreisezug"]`) versucht der Bot immer, den Embed den bekannten Betreiber (in dem Fall SBB) zuzuweisen. Sollte allerdings nur Nahreisezug angezeigt werden, kann damit nicht gearbeitet werden, wodurch die Fallback Metadaten genutzt werden.  
+### [locales/](src/data/locales/)
 Covered in [locales](#locales)
-Die Fallback Metadaten können in [src/data/operators.py](src/data/operators.py) angepasst werden.
+### [announcements/](src/data/announcements/)
 Covered in [voice announcements](#voice)
 ### [assets](src/data/assets/)
 Assets (such as images) which the bot uses. You shouldn't have to change anything there
@@ -1,20 +1,33 @@
 {
  "discord": {
    "token": "",
    "stations": ["Hamburg Hbf", "München Hbf", "Köln Hbf", "Amsterdam Centraal"],
    "dbf": "https://dbf.finalrewind.org",
    "server": ,
    "vc": ,
-    "random": true,
+    "lang": "de",
    "emojis": true,
    "formatting": "┇",
-    "announcements": true,
+    "emojis": true
-    "voice_announcements: [
+  },
-        {
+  "connections": {
-            "enabled": false,
+    "stations": [
-            "stations": {
+      "Berlin Hauptbahnhof",
-                "general": ""
+      "Amsterdam",
-            }
+      "Helsinki"
-        }
+    ],
-    ]
+    "IDs": [],
-    "blacklist": []
+    "blacklist": [
      "OTHER",
      "RIDE_SHARING"
    ],
    "min_duration": 10,
    "max_duration": null,
    "max_wait_time": null,
    "timezone": "Europe/Berlin"
  },
  "announcements": {
    "text_announcements": true,
    "voice_announcements": false
  },
  "http": {
    "user_agent": "Gleiswechsel-Discord-Bot/1.0 (https://github.com/kaaninchen/Gleiswechsel)"
  }
 }
@@ -1,40 +1,43 @@
 import discord
-import random
+import sys
-from discord.ext import tasks
+
 from src.config import config
 from src.handlers import rename_vc
 from src.commands import setup_commands
 from src.embeds import build_error_embed
 from src.utils import logger
-from src.data.status import discord_status
+from src.config import config
 from src.dc.handlers import rename_vc
 from src.dc.helpers import validate_channel
 from src.dc.commands import setup_commands
 from src.api.transitous import check_stations
 bot = discord.Bot(intents=discord.Intents.all())
-setup_commands(bot)
+setup_commands(bot=bot)
@tasks.loop(minutes=5)
 async def change_status():
    status = random.choice(discord_status)
    await bot.change_presence(activity=discord.Game(name=f"{status} • /info"))
 _bot_initialized = False
 if len(sys.argv) > 1:
    if sys.argv[1] == "stations":
        check_stations()
        sys.exit(0)
@bot.event
 async def on_ready():
    global _bot_initialized
    print(f"{bot.user} ist online")
    if not change_status.is_running():
        change_status.start()
    if not _bot_initialized:
        _bot_initialized = True
        await rename_vc(bot)
    else:
        logger("Discord Reconnect, laufende Fahrt bleibt unangetastet")
-@bot.event
+    if not _bot_initialized:
-async def on_application_command_error(ctx, error):
+        logger(f"{bot.user} is online")
-    embed = build_error_embed(f"Ein Fehler ist aufgetreten: {error}")
+        _bot_initialized = True
-    await ctx.respond(embed=embed)
+
        server_id = config.discord.server
        server_vc_id = config.discord.vc
        channel = validate_channel(bot=bot, server_id=server_id, channel_id=server_vc_id)
        await rename_vc(bot, voice_channel=channel)
 try:
-    bot.run(config['token'])
+    bot.run(config.discord.token)
 except:
-    logger("Fehler beim parsen des token", "fatal")
+    logger("An error occured while parsing the token", "fatal")
 '''
 TODO
 - discord status
 - multi language support
 - README
 '''
@@ -13,6 +13,8 @@ numpy==2.5.1
 pandas==3.0.3
 propcache==0.5.2
 py-cord==2.8.0
 py-staticmaps[cairo]==0.5.0
 pyyaml==6.0.3
 pycparser==3.0
 pynacl==1.6.2
 python-dateutil==2.9.0.post0
@@ -0,0 +1,310 @@
 import requests
 import random
 import json
 from datetime import datetime, timezone
 from src.utils import logger, get_train_name, validate_connection, parse_iso
 from src.config import config
 from src.lang.locales import lang
 station_names = config.connections.stations
 station_IDs = config.connections.IDs
 blacklist = config.connections.blacklist
 user_agent = config.http.user_agent
 headers = {
    "User-Agent": f"{user_agent}"
 }
 endpoint = "https://api.transitous.org"
 def check_stations():
    logger(f"Testing {len(station_names)} stations...")
    all_stations_output = {}
    minimal_overview = {}
    for station in station_names:
        req = f"{endpoint}/api/v1/geocode"
        try:
            response = requests.get(req, params={"text": station}, headers=headers)
            response.raise_for_status()
            data = response.json()
        except requests.RequestException as e:
            logger(f"An error occured while checking for station {station}: {e}")
            continue
        stops_dict = {}
        aliases_list = []
        exact_match = False
        for entry in data:
            if entry.get("type") != "STOP":
                continue
            station_id = entry.get("id") 
            stop_name = entry.get("name")
            coords = f"{entry.get("lat")}, {entry.get("lon")}"
            modes = entry.get("modes")
            stop_details = {
                "tz": entry.get("tz"),
                "country": entry.get("country"),
                "coords": coords,
                "id": station_id,
                "modes": modes,
            }
            if stop_name:
                stops_dict[stop_name] = stop_details
                aliases_list.append(stop_name)
            if stop_name == station:
                if not exact_match:
                    exact_match = True
        if not stops_dict:
            logger("Failed to grab ID from 'search_name'", "error")
            continue
        all_stations_output[station] = {
            "exact_match": exact_match,
            "associated": stops_dict
        }
        minimal_overview[station] = {
            "exact_match": exact_match,
            "names": aliases_list
        }
    logger(json.dumps(minimal_overview, indent=4, ensure_ascii=False))
    print(f"\nIf you want, I can save a more detailed version directly as a json file to disk.")
    print("The json would provide informations like coords, country and transport modes that are from every specific associated station.")
    prompt = input("This would help you to identify the associated stations more accurately (y/n): ")
    if prompt == "y" or prompt == "yes":
        with open('stations.json', 'w') as f:
            json.dump(all_stations_output, f, indent=4, ensure_ascii=False)
            logger("stations.json generated")
    else:
        logger("okay :(")
 def get_random_stop_id() -> str | None:
    stations = {}
    if len(station_names) > 0:
        for entry in station_names:
            if entry != "":
                stations[entry] = "name"
    if len(station_IDs) > 0:
        for entry in station_IDs:
            if entry != "":
                stations[entry] = "ID"
    if not stations:
        logger("Both stations and IDs are empty...", "FATAL")
    assigned_station = random.choice(list(stations.keys()))
    if stations[assigned_station] == "ID":
        return assigned_station
    req = f"{endpoint}/api/v1/geocode"
    try:
        response = requests.get(req, params={"text": assigned_station}, headers=headers)
        response.raise_for_status()
        data = response.json()
    except requests.RequestException as e:
        logger(f"An error occured while searching for a connection: {e}", "error")
        return None
    stop_ids = {}
    for entry in data:
        if entry.get("type") != "STOP":
            continue
        stop_name = entry.get("name")
        stop_id = entry.get("id", None)
        stop_ids[stop_id] = stop_name
        if stop_name == assigned_station:
            stop_ids.clear()
            stop_ids[stop_id] = stop_name
            break
    if stop_ids is None:
        logger(f"Failed to grab ID from '{assigned_station}'", "error")
        return None
    stop_ids_list = list(stop_ids.keys())
    if len(stop_ids_list) > 1:
        logger(f"No station associated as '{assigned_station}', choosing random from similar named stations")
        logger(f"Run `python run main.py stations` to get exact station names")
    chosen_stop_id, chosen_station = random.choice(list(stop_ids.items()))
    return chosen_stop_id
 def get_random_connection(stop_id: str) -> str | None:
    if stop_id is None:
        return None
    now = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
    cursor = None
    max_pages = 5
    min_results = 5
    trip_ids = []
    all_stop_times = []
    for _ in range(max_pages):
        params = {
            "stopId": stop_id,
            "n": 20,
            "time": now,
        }
        if cursor:
            params["pageCursor"] = cursor
        try:
            response = requests.get(f"{endpoint}/api/v5/stoptimes", params=params, headers=headers)
            response.raise_for_status()
            data = response.json()
        except requests.RequestException as e:
            logger(e, "Error")
            break
        stop_times = data.get("stopTimes", [])
        all_stop_times.extend(stop_times)
        for entry in stop_times:
            trip_id = entry["tripId"]
            if entry["mode"] in blacklist:
                continue
            else:
                trip_ids.append(entry["tripId"])
        if len(trip_ids) >= min_results:
            break
        cursor = data.get("nextPageCursor")
        if not cursor:
            break
    if not trip_ids:
            logger("Couldn't find any connections", "error")
            return None
    trip_id = random.choice(trip_ids)
    from_station = None
    for entry in all_stop_times:
        if entry.get("tripId") == trip_id:
            from_station = entry.get("place", {}).get("name")
            break
    return {
        "trip_id": trip_id, 
        "from_station": from_station
    }
 def get_trip_details(random_connection: dict | None) -> dict | None:
    if random_connection is None:
        return None
    req = f"{endpoint}/api/v2/trip"
    try:
        response = requests.get(req, params={"tripId": random_connection["trip_id"]}, headers=headers)
        response.raise_for_status()
        data = response.json()
    except requests.RequestException as e:
        logger(f"An error occured while trying to get the route details: {e}", "error")
        return None
    legs = data["legs"][0]
    end_time = legs["endTime"]
    from_station = random_connection["from_station"]
    display_name = legs["displayName"]
    train_from = legs["from"]["name"]
    goes_to = legs["to"]["name"]
    start_time = legs["startTime"]
    mode = legs["mode"]
    if goes_to == train_from:
        logger(f"Bot doesn't know what to do with round trips, I'll have to implement this some day", "error")
        return None # TODO actually handel this 
    all_stop_names = [train_from] + [stop["name"] for stop in legs["intermediateStops"]] + [goes_to]
    if len(all_stop_names) != len(set(all_stop_names)):
        logger("Route reuses station names! Skipping, to be safe...", "error")
        return None # TODO this too
    arrival_dt = parse_iso(end_time)
    departure_dt = parse_iso(start_time)
    train_name = get_train_name(display_name, mode) # used by lang
    if len(lang.channel.long_name.train_from()) >= 100:
        channel_name = lang.channel.short_name
    else:
        if train_from == from_station:
            channel_name = lang.channel.long_name.train_from()
        else:
            channel_name = lang.channel.long_name.train_via()
    trip_details = {
        "channel_name": channel_name,
        "station": from_station,
        "from": train_from,
        "to": goes_to,
        "agency": legs["agencyName"],
        "route_color": legs.get("routeColor"),
        "departure": departure_dt.strftime("%H:%M"),
        "departure_dt": departure_dt,
        "arrival": arrival_dt.strftime("%H:%M"),
        "arrival_dt": arrival_dt,
        "mode": mode,
        "stops": {}
    }  
    train_from_importance = legs["from"]["importance"]
    trip_details["stops"][train_from] = {
        "arrival": departure_dt,
        "importance": train_from_importance,
        "lat": legs["from"]["lat"],
        "lon": legs["from"]["lon"]
    }
    departure_time_iso = start_time
    for stop in legs["intermediateStops"]:
        stop_arrival_dt = parse_iso(stop["arrival"])
        stop_importance = stop["importance"]
        stop_details = {
            "arrival": stop_arrival_dt,
            "importance": stop_importance,
            "lat": stop["lat"],
            "lon": stop["lon"]
        }
        trip_details["stops"][stop["name"]] = stop_details 
        if stop.get("name") == from_station:
            departure_time_iso = stop["departure"]
            trip_details["departure"] = parse_iso(departure_time_iso).strftime("%H:%M")
    train_to_importance = legs["to"]["importance"]
    trip_details["stops"][goes_to] = {
        "arrival": arrival_dt,
        "importance": train_to_importance,
        "lat": legs["to"]["lat"],
        "lon": legs["to"]["lon"]
    }
    valid = validate_connection(start_time, end_time, departure_time_iso)
    if not valid:
        return None
    return trip_details    
@@ -1,12 +0,0 @@
 import discord
 from discord.ext import commands
 from src.embeds import build_info_embed, build_error_embed
 def setup_commands(bot: discord.Bot):
    @bot.slash_command(description="Informationen über die aktuelle Fahrt")
    async def info(ctx):
        embed = build_info_embed()
        if embed is None:
            await build_error_embed("Noch keine Verbindung gesetzt.")
            return
        await ctx.respond(embed=embed)
@@ -1,4 +1,51 @@
 import json
 from dataclasses import dataclass, field
 from typing import Optional
-with open("config.json", "r") as file:
+@dataclass
-    config = json.load(file)
+class DiscordConfig:
    token: str
    server: int
    vc: int
    lang: str
    formatting: str
    emojis: bool
@dataclass
 class ConnectionsConfig:
    stations: list[str]
    IDs: list[str]
    blacklist: list[str]
    min_duration: int
    timezone: str
    max_wait_time: Optional[int] = None
    max_duration: Optional[int] = None
@dataclass
 class AnnouncementConfig:
    text_announcements: bool
    voice_announcements: bool
@dataclass
 class HttpConfig:
    user_agent: str
@dataclass
 class Config:
    discord: DiscordConfig
    connections: ConnectionsConfig
    announcements: AnnouncementConfig
    http: HttpConfig
 def _load_config() -> Config:
    with open("config.json", "r") as file:
        raw = json.load(file)
    return Config(
        discord=DiscordConfig(**raw["discord"]),
        connections=ConnectionsConfig(**raw["connections"]),
        announcements=AnnouncementConfig(**raw["announcements"]),
        http=HttpConfig(**raw["http"]),
    )
 config = _load_config()
@@ -0,0 +1,2 @@
 SPDX-FileCopyrightText: 2024 Mathis Brüchert <[email protected]>
 SPDX-License-Identifier: CC-BY-SA-4.0
@@ -1,18 +1,12 @@
 emoji_list = {
-    "Fallback": "🚉",
+    "Fallback": "💺",
-    "Nahverkehr": "🚃",
+    "BUS": "🚎",
-    "Höchstgeschwindigkeit": "🚄",
+    "COACH": "🚎",
-    "Bus": "🚎"
+    "TRAM": "🚈",
-}
+    "REGIONAL_RAIL": "🚊",
-
+    "HIGHSPEED_RAIL": "🚅",
-train_types = { # Unvollständig!
+    "LONG_DISTANCE": "🚅",
-    "ICE": emoji_list["Höchstgeschwindigkeit"],
+    "METRO": "🚇",
-    "TGV": emoji_list["Höchstgeschwindigkeit"],
+    "SUBWAY": "🚇",
-
+    "FERRY": "🚢"
    "RE": emoji_list["Nahverkehr"],
    "RB": emoji_list["Nahverkehr"],
    "ARV": emoji_list["Nahverkehr"],
    "BRB": emoji_list["Nahverkehr"],
    "Bus": emoji_list["Bus"]
 }
@@ -0,0 +1,19 @@
 channel:
  long_name: 
    train_from: "{train_name} nach {goes_to} von {train_from}"
    train_via: "{train_name} nach {goes_to} über {from_station}"
  short_name: "{train_name} nach {goes_to}"
 embeds:
  footer:
    notice: "https://transitous.org/sources/ • Maps (C) CARTO (C) OpenStreetMap.org contributors"
  info:
    description: "Abfahrt von {station} um {departure}. Ankunft um {arrival}"
    via: "Über"
    "via_and": "und"
    "next_stop": "Nächster Halt"
  announcement:
    title: "Informationen zu ihrer Fahrt"
    "end_of_connection":
      message: "Sehr geehrte Fahrgäste,\nIn wenigen Minuten erreichen wir {destination}. Unsere Reise endet dort\n\nWir wünschen Ihnen eine angenehme Weiterreise.\n\nVielen Dank für ihr Vertrauen und auf Wiedersehen."
 rich_presence:
  arrival: "Ankunft um {arrival} • /info"
@@ -0,0 +1,19 @@
 channel:
  long_name: 
    train_from: "{train_name} to {goes_to} from {train_from}"
    train_via: "{train_name} to {goes_to} via {from_station}"
  short_name: "{train_name} to {goes_to}"
 embeds:
  footer:
    notice: "Data provided by https://transitous.org/sources/ • Maps (C) CARTO (C) OpenStreetMap.org contributors"
  info:
    description: "Departure from {station} at {departure}. Arrival by {arrival}"
    via: "via"
    "via_and": "and"
    "next_stop": "Next stop"
  announcement:
    title: "Information about your trip"
    "end_of_connection":
      message: "Dear Passengers,\nwe will be arriving at {destination} in a few minutes. Our journey ends there.\n\nWe wish you a pleasant onward journey.\n\nThank you for your patronage, and goodbye."
 rich_presence:
  arrival: "Arrival by {arrival} • /info"
@@ -1,107 +1,164 @@
 ''''
 Die Datei gibt dem Embed zugehörige Metadaten der Zugbetreiber. Identifiziert wird dabei durch die genauen Namen der Unternehmen. 
 Diese werden sowohl im /info Embed als auch in der Konsole angezeigt. 
 | Feld    | Optional | Wert  | Beschreibung                                                          |
 |---------|----------|-------|-----------------------------------------------------------------------|
 | Unknown | Ja       | Bool  | Eigentlich nur für fallback relevant, sollte man weglassen            |
 | Logo    | Nein     | URL   | Das Logo in der Ecke des Embeds. Am besten PNG, SVG geht leider nicht |
 | Color   | Nein     | HEX   | HEX Color Code des Streifen vom Embed, muss mit 0x anfangen           |
 | Slogan  | Ja       | Liste | Zufälliger Text aus der Liste im Footer                               |
 Sollte es dazu kommen, dass mehrere Anbieter die selben Metadaten nutzen sollen, kann man einen Eintrag für alle in OPERATORS setzen und 
 die zugehörigen Anbieternamen in OPERATOR_ALIASES auf den Eintrag lenken lassen. db_bawü ist dafür ein gutes Beispiel.
 Nachdem diese Datei editiert wurde muss der Bot nicht neugestartet werden.
 '''
 OPERATORS = {
-    "fallback": {
+    "Abellio Rail Mitteldeutschland GmbH": {
-        "unknown": True,
+        "logo": "https://upload.wikimedia.org/wikipedia/commons/thumb/e/e0/Abellio_logo.svg/1920px-Abellio_logo.svg.png",
-        "logo": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcQCVeC5E0mNNBKyQftQaFMzxIVkbDvEnSzWv07h_c8PdA&s=10",
+        "color": 0xD7002E,
-        "color": 0xFFFFFF
+        "slogan": ["Freie Bahn für deine Ziele!"]
    },
    "Agilis": {
        "logo": "https://upload.wikimedia.org/wikipedia/commons/thumb/a/a3/Agilis_Logo.svg/960px-Agilis_Logo.svg.png",
        "color": 0xCAE15B,
        "slogan": ["Reinsetzen, zurücklehnen", "Fahren Sie mit uns. Nehmen Sie Platz."]
    },
    "Aktiv Bus Flensburg GmbH": {
        "logo": "https://upload.wikimedia.org/wikipedia/commons/thumb/2/26/Aktiv_Bus_Flensburg_GmbH_logo.svg/960px-Aktiv_Bus_Flensburg_GmbH_logo.svg.png?utm_source=de.wikipedia.org&utm_campaign=index&utm_content=thumbnail",
        "color": 0xFFC331
    },
    "Arverio Bayern": {
        "logo": "https://cdn.discordapp.com/attachments/1383843132906537023/1528006572805062776/Arverio_Avi_Bayern_blau_RGB.png?ex=6a5cba83&is=6a5b6903&hm=5781ae6c372c92ab4f52409c6fc91e5014ac34ccf24db665ade052e8135bdde0&animated=true",
        "color": 0x0083BE,
        "slogan": ["Dein Weg ist unser Ziel."]
    },
    "Berliner Verkehrsbetriebe": {
        "logo": "https://upload.wikimedia.org/wikipedia/commons/thumb/b/bf/BVG_Logo_07.2021.svg/960px-BVG_Logo_07.2021.svg.png",
        "color": 0xEFD13C,
        "slogan": ["Weil wir dich lieben"]
    },
    "DSB": {
        "logo": "https://upload.wikimedia.org/wikipedia/commons/thumb/8/87/DSB_company_logo.svg/960px-DSB_company_logo.svg.png",
        "color": 0xB22B32,
        "slogan": ["Tak for at vise hensyn"]
    },
    "enno": {
        "logo": "https://upload.wikimedia.org/wikipedia/commons/thumb/a/a5/Enno_logo.svg/960px-Enno_logo.svg.png",
        "color": 0x88216F,
        "slogan": ["enno fährt bunt"]
    },
    "Erfurter Bahn": {
        "logo": "https://upload.wikimedia.org/wikipedia/commons/thumb/a/ac/Erfurter_Bahn_logo.svg/960px-Erfurter_Bahn_logo.svg.png",
        "color": 0x009133,
        "slogan": ["Kommt gut an."]
    },
    "eurobahn": {
        "logo": "https://cdn.discordapp.com/attachments/1383843132906537023/1528405390260179146/Eurpnajm.png?ex=6a5e2df1&is=6a5cdc71&hm=d73fc3458f59f8942a5a0f51311308b12567b35b55b64aab0726bf6be92b3b0e&animated=true",
        "color": 0x005a9b,
        "slogan": ["Echte Menschen. Echt schöne Ziele."]
    },
    "European Sleeper": {
        "logo": "https://upload.wikimedia.org/wikipedia/commons/thumb/3/3d/European_Sleeper_Logo.svg/960px-European_Sleeper_Logo.svg.png",
        "color": 0xEB4A27,
        "slogan": ["The Good Night Train", "Travel while you sleep"]
    },
    "Flixbus": {
        "logo": "https://upload.wikimedia.org/wikipedia/commons/thumb/9/9e/Flixbus_201x_logo.svg/1280px-Flixbus_201x_logo.svg.png",
        "color": 0x8CD541,
        "slogan": ["Einfach Busfahren.", "Fahr grün!", "FLIX it", "Mehr Leben im echten Leben"]
    },
    "GoVolta": {
        "logo": "https://upload.wikimedia.org/wikipedia/commons/thumb/5/5b/GoVolta_logo.svg/1280px-GoVolta_logo.svg.png",
        "color": 0x0B70F6,
        "slogan": ["Internationale Züge, endlich erschwinglich!", "International trains, finally affordable!"]
    },
    "GVB": {
        "logo": "https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/BSicon_LOGO_GVB.svg/960px-BSicon_LOGO_GVB.svg.png",
        "color": 0x2B62AF,
    },
    "Jenaer Nahverkehr GmbH": {
        "logo": "https://www.stadtwerke-jena.de/dam/jcr:74dc9d81-0447-4864-973b-7e395f1d6948/JNV_Bildmarke_322px.png",
        "color": 0x0075BD 
    },
    "Nordbahn Eisenbahngesellschaft": {
        "logo": "https://upload.wikimedia.org/wikipedia/commons/b/b5/Logo_Nordbahn_NAH.SH_Blau_positiv_final.png",
        "color": 0x1A2848,
        "slogan": ["nordbahn kommt von Norden", "Bringt den Norden näher", "Wir transportieren das Biest"]
    },
    "NS": {
        "logo": "https://upload.wikimedia.org/wikipedia/commons/thumb/3/3d/Logo_NS.svg/960px-Logo_NS.svg.png",
        "color": 0x00337F,
        "slogan": ["Goed op weg", "Welkom in de trein van morgen", "Veilig, Vlug, Voordelig", "we haben een serious probleem", "Neuken in de keuken"]
    },
    "Ostdeutsche Eisenbahn GmbH": {
        "logo": "https://upload.wikimedia.org/wikipedia/commons/thumb/f/f3/ODEG-Logo_Neu.svg/960px-ODEG-Logo_Neu.svg.png",
        "color": 0x00745C,
        "slogan": ["Rücksicht kommt gut", "Benimm dich, als wäre Mutti dabei.", "Sicher mit der Sachsenschleuder"]
    },
    "Regionalverkehre Start Deutschland GmbH (Start Mitteldeutschland)": {
        "logo": "https://upload.wikimedia.org/wikipedia/commons/thumb/0/0b/Logo_der_Regionalverkehre_Start_Deutschland.svg/960px-Logo_der_Regionalverkehre_Start_Deutschland.svg.png",
        "color": 0x61A731,
    },
    "S-Bahn": {
        "logo": "https://upload.wikimedia.org/wikipedia/commons/thumb/e/e7/S-Bahn-Logo.svg/500px-S-Bahn-Logo.svg.png",
        "color": 0x3E8B55
    },
    "S-Bahn Hannover (Transdev)": {
        "logo": "https://cdn.discordapp.com/attachments/1526274436523888732/1528470315234234520/sbahn.png?ex=6a5e6a68&is=6a5d18e8&hm=c9f630c6f0c646eafeccef9b4d591ce8fcf8856b2b45f14e72fbf25e32edb017&animated=true",
        "color": 0x1A4389,
        "slogan": ["Wir geben alles", "Wir bringen dich", "Wir bringen Respekt"]
    },
    "SBB": {
        "logo": "https://upload.wikimedia.org/wikipedia/commons/thumb/2/23/SBB_logo_simplified.svg/960px-SBB_logo_simplified.svg.png",
        "color": 0xEB0000,
        "slogan": ["Der Kluge reist im Zuge", "SBB schafft Verbindungen", "Unterwegs zuhause"]
    },
    "SNCF": {
        "logo": "https://upload.wikimedia.org/wikipedia/en/thumb/f/f4/Sncf-logo.svg/960px-Sncf-logo.svg.png",
        "color": 0x812B6D,
        "slogan": ["Pour nous tous", "Donner au train des idées d'avance"]
    },
    "Stadtverkehr Tübingen GmbH": {
        "logo": "https://upload.wikimedia.org/wikipedia/commons/thumb/1/14/Stadtwerke_T%C3%BCbingen_logo.svg/330px-Stadtwerke_T%C3%BCbingen_logo.svg.png",
        "color": 0x439669
    },
    "Südwestdeutsche Verkehrs-AG": {
        "logo": "https://upload.wikimedia.org/wikipedia/commons/thumb/3/30/SWEG_Logo.svg/330px-SWEG_Logo.svg.png?utm_source=de.wikipedia.org&utm_campaign=index&utm_content=thumbnail",
        "color": 0x1A509A
    },
    "Tallink Grupp AS": {
        "logo": "https://upload.wikimedia.org/wikipedia/commons/thumb/9/9e/Tallink_logo.svg/330px-Tallink_logo.svg.png",
        "color": 0x225197
    },
    "Verkehrsbetrieb Potsdam GmbH": {
        "logo": "https://upload.wikimedia.org/wikipedia/commons/thumb/8/8b/Verkehrsbetrieb_Potsdam_logo.svg/330px-Verkehrsbetrieb_Potsdam_logo.svg.png",
        "color": 0x000000
    },
    "Vr": {
        "logo": "https://upload.wikimedia.org/wikipedia/commons/thumb/1/18/Vr_Logo.png/330px-Vr_Logo.png",
        "color": 0x00B451,
        "slogan": ["Aikaa yhteisellä matkalla"]
    },
    "Westbahn Management GmbH": {
        "logo": "https://corporate.westbahn.at/uploads/Logos/westbahn2025-logo-signet-small.png",
        "color": 0x1D4A83,
        "slogan": ["Immer ein guter Zug", "Da steig ich ein", "Jetzt aber Westbahn"]
    },
    "WestfalenBahn": {
        "logo": "https://upload.wikimedia.org/wikipedia/commons/thumb/2/2e/Westfalenbahn_logo.svg/330px-Westfalenbahn_logo.svg.png",
        "color": 0x48A1DD,
        "slogan": ["Weil's meine Region ist", "Hier bin ich daheim!"]
    },
    "db_allgemein": {
        "logo": "https://marketingportal.extranet.deutschebahn.com/resource/blob/13602522/c53f806b9df966e144010b276af72dd2/Bild_09-data.png",
        "color": 0xEC0016,
        "slogan": ["Senk ju vor träwelling wis Deutsche Bahn.", "Bitte beachten Sie die umgekehrte Wagenreihung.", "Zurückbleiben bitte!", "Alle reden vom Wetter. Wir nicht.", "Die Bahn macht mobil.", "Grün abgefahren"]
    },
    "db_bayern": {
        "logo": "https://upload.wikimedia.org/wikipedia/commons/thumb/5/5b/Bahnland_Bayern_Logo_2021.svg/500px-Bahnland_Bayern_Logo_2021.svg.png",
        "color": 0x0095DB
    },
    "db_bawü": {
        "logo": "https://upload.wikimedia.org/wikipedia/commons/thumb/4/4f/Bwegt_Logo.svg/960px-Bwegt_Logo.svg.png",
        "color": 0xFFBF34,
        "slogan": ["Nett hier", "Aber waren Sie schon mal in Baden-Württemberg?", "Bwegt euch!"]
    },
-    "Ostdeutsche Eisenbahn GmbH": {
+    "db_bayern": {
-        "logo": "https://upload.wikimedia.org/wikipedia/commons/thumb/f/f3/ODEG-Logo_Neu.svg/960px-ODEG-Logo_Neu.svg.png",
+        "logo": "https://upload.wikimedia.org/wikipedia/commons/thumb/5/5b/Bahnland_Bayern_Logo_2021.svg/500px-Bahnland_Bayern_Logo_2021.svg.png",
-        "color": 0x00745C
+        "color": 0x0095DB,
        "slogan": ["Zeit für dich", "Bringt dich vorwärts", "Wir bewegen das Bahnland Bayern", "Ey, i muas da ehrlich sogen i wünimma mit dir zaum sein, weil i a eif agrod gmerkt hob das i nix ernstes grod will und es liegt wirkli ned an dir oba es passt halt ned sound du müsstest holt a nü des abhoin wos du bei mir vergessen host"]
    },
-    "Nederlandse Spoorwegen": {
+    "fallback": {
-        "logo": "https://upload.wikimedia.org/wikipedia/commons/thumb/3/3d/Logo_NS.svg/960px-Logo_NS.svg.png",
+        "logo": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcQCVeC5E0mNNBKyQftQaFMzxIVkbDvEnSzWv07h_c8PdA&s=10",
-        "color": 0X00337F,
+        "color": 0xFFFFFF
        "slogan": ["Goed op weg", "Welkom in de trein van morgen", "Veilig, Vlug, Voordelig", "we haben een serious probleem", "Neuken in de keuken"]
    },
    "eurobahn": {
        "logo": "https://cdn.discordapp.com/attachments/1383843132906537023/1528405390260179146/Eurpnajm.png?ex=6a5e2df1&is=6a5cdc71&hm=d73fc3458f59f8942a5a0f51311308b12567b35b55b64aab0726bf6be92b3b0e&animated=true",
        "color": 0x005a9b,
    },
    "Arverio Bayern": {
        "logo": "https://cdn.discordapp.com/attachments/1383843132906537023/1528006572805062776/Arverio_Avi_Bayern_blau_RGB.png?ex=6a5cba83&is=6a5b6903&hm=5781ae6c372c92ab4f52409c6fc91e5014ac34ccf24db665ade052e8135bdde0&animated=true", # alternative nötig!
        "color": 0x0083BE
    },
    "Abellio Rail Mitteldeutschland GmbH": {
        "logo": "https://upload.wikimedia.org/wikipedia/commons/thumb/e/e0/Abellio_logo.svg/1920px-Abellio_logo.svg.png",
        "color": 0xD7002E
    },
    "SBB": {
        "logo": "https://upload.wikimedia.org/wikipedia/commons/thumb/2/23/SBB_logo_simplified.svg/960px-SBB_logo_simplified.svg.png",
        "color": 0xEB0000
    },
    "Nordbahn Eisenbahngesellschaft": {
        "logo": "https://upload.wikimedia.org/wikipedia/commons/b/b5/Logo_Nordbahn_NAH.SH_Blau_positiv_final.png",
        "color": 0x1A2848
    },
    "Erfurter Bahn GmbH": {
        "logo": "https://upload.wikimedia.org/wikipedia/commons/thumb/a/ac/Erfurter_Bahn_logo.svg/960px-Erfurter_Bahn_logo.svg.png",
        "color": 0x009133
    },
    "S-Bahn Hannover (Transdev)": {
        "logo": "https://cdn.discordapp.com/attachments/1526274436523888732/1528470315234234520/sbahn.png?ex=6a5e6a68&is=6a5d18e8&hm=c9f630c6f0c646eafeccef9b4d591ce8fcf8856b2b45f14e72fbf25e32edb017&animated=true",
        "color": 0x1A4389
    },
    "Regionalverkehre Start Deutschland GmbH (Start Mitteldeutschland)": {
        "logo": "https://upload.wikimedia.org/wikipedia/commons/thumb/0/0b/Logo_der_Regionalverkehre_Start_Deutschland.svg/960px-Logo_der_Regionalverkehre_Start_Deutschland.svg.png",
        "color": 0x61A731
    },
    "Westbahn Management GmbH": {
        "logo": "https://corporate.westbahn.at/uploads/Logos/westbahn2025-logo-signet-small.png",
        "color": 0x1D4A83
    },
    "European Sleeper": {
        "logo": "https://upload.wikimedia.org/wikipedia/commons/thumb/3/3d/European_Sleeper_Logo.svg/960px-European_Sleeper_Logo.svg.png",
        "color": 0xEB4A27
    },
    "GoVolta": {
        "logo": "https://upload.wikimedia.org/wikipedia/commons/thumb/5/5b/GoVolta_logo.svg/1280px-GoVolta_logo.svg.png",
        "color": 0x0B70F6
    },
    "SNCF": {
        "logo": "https://upload.wikimedia.org/wikipedia/en/thumb/f/f4/Sncf-logo.svg/960px-Sncf-logo.svg.png",
        "color": 0x812B6D
    },
    "Agilis": {
        "logo": "https://upload.wikimedia.org/wikipedia/commons/thumb/a/a3/Agilis_Logo.svg/960px-Agilis_Logo.svg.png",
        "color": 0xCAE15B
    },
    "enno": {
        "logo": "https://upload.wikimedia.org/wikipedia/commons/thumb/a/a5/Enno_logo.svg/960px-Enno_logo.svg.png",
        "color": 0x88216F
    }
 }
 OPERATOR_ALIASES = {
    "Arverio Bayern GmbH": OPERATORS["Arverio Bayern"],
    "DB Regio AG Baden-Württemberg": OPERATORS["db_bawü"],
    "DB Regio Stuttgart GmbH": OPERATORS["db_bawü"],
    "Arverio Baden-Württemberg": OPERATORS["db_bawü"],
@@ -109,10 +166,19 @@ OPERATOR_ALIASES = {
    "DB Regio AG Bayern": OPERATORS["db_bayern"],
    "DB Fernverkehr AG": OPERATORS["db_allgemein"],
    "DB Regio AG NRW": OPERATORS["db_allgemein"],
    "DB Regio AG Nord": OPERATORS["db_allgemein"],
    "DB Regio AG Südost": OPERATORS["db_allgemein"],
    "DB Regio AG Nordost": OPERATORS["db_allgemein"],
    "DB Regio AG Nord": OPERATORS["db_allgemein"],
    "DB Regio AG Mitte": OPERATORS["db_allgemein"],
    "NS International": OPERATORS["NS"],
    "SBB GmbH": OPERATORS["SBB"],
    "Schweizerische Bundesbahnen SBB": OPERATORS["SBB"],
    "Dänische Staatsbahnen": OPERATORS["DSB"],
    "VR": OPERATORS["Vr"],
    "FlixBus-gb": OPERATORS["Flixbus"],
    "FlixBus-eu": OPERATORS["Flixbus"],
    "S-Bahn Berlin GmbH": OPERATORS["S-Bahn"]
 }
@@ -1,16 +0,0 @@
 discord_status = [
    "Tschu-Tschu!",
    "Heute ca. 15 Minuten später",
    "Heute ohne Halt in Hamburg-Altona",
    "Störung an der Weiche",
    "Heute ohne Bordbistro",
    "SEV ist eingerichtet",
    "Gleiswechsel!",
    "Zug entgleist :(",
    "Die Bundespolizei ist informiert",
    "Dieser Zug endet hier",
    "Außerplanmäßiger Halt in Oberhausen Hbf",
    "Verspätung aus vorheriger Fahrt",
    "Der Zug hat keine Bremsen",
    "Heute ohne Klimatisierung",
 ]
@@ -0,0 +1,9 @@
 import discord
 from src.dc.embeds import build_info_embed
 def setup_commands(bot: discord.Bot):
    @bot.slash_command(description="Informationen über die aktuelle Fahrt")
    async def info(ctx):
        await ctx.defer()
        image = discord.File("src/data/assets/current_map.png", filename="ride.png")
        await ctx.respond(file=image, embed=build_info_embed())
@@ -0,0 +1,84 @@
 import discord
 import random
 from src.utils import get_operator_metadata, get_next_station, format_via_list, format_stop_list
 from src.dc.helpers import format_timestamp_to_dc
 from src.lang.locales import lang
 lang_embed = lang.embeds
 def build_embed_footer(mode: str, slogans):
    footer_notice = f"{lang.embeds.footer.notice()} • mode: {mode}"
    icon = "https://raw.githubusercontent.com/kaaninchen/Gleiswechsel/refs/heads/main/src/data/assets/transitous-logo.png"
    if slogans is not None:
        footer_text = f"{random.choice(slogans)} • {footer_notice}"
    else:
        footer_text = footer_notice
    return {
        "text": footer_text,
        "icon": icon
    }
 def build_info_embed() -> discord.Embed:
    from src.dc.handlers import trip
    station = trip["station"]
    agency = trip["agency"]
    metadata = get_operator_metadata(agency, trip["route_color"], trip["mode"])
    departure = format_timestamp_to_dc(trip["departure"])
    arrival = format_timestamp_to_dc(trip["arrival"])
    embed = discord.Embed(
        title = trip["channel_name"],
        description=lang_embed.info.description(),
        color = metadata["color"]
    )
    stops = trip["stops"]
    next_stop = get_next_station(trip["stops"], trip["from"])
    next_stop_station = None
    if next_stop:
        next_stop_station = next_stop.get("name")
    via = format_via_list(stops, lang_embed.info.via_and())
    if via:
        embed.add_field(name=lang_embed.info.via(), value=via, inline=False)
    if next_stop:
        embed.add_field(name=lang_embed.info.next_stop(), value=f"__{next_stop_station}__", inline=False)
    route_fields = format_stop_list(stops, next_stop_station)
    for field_name, field_value in route_fields:
        embed.add_field(name=field_name, value=field_value, inline=False)
    footer = build_embed_footer(trip["mode"], metadata["slogans"])
    embed.set_footer(text=footer["text"], icon_url=footer["icon"])
    embed.set_author(name=agency)
    embed.set_thumbnail(url=metadata["logo"])
    embed.set_image(url="attachment://ride.png")
    return embed
 def build_announcement_embed(msg):
    from src.dc.handlers import trip
    agency = trip["agency"]
    metadata = get_operator_metadata(agency, trip["route_color"], trip["mode"])
    embed = discord.Embed(
        title = lang_embed.announcement.title(),
        description=msg,
        color=metadata["color"]
    )
    embed.set_author(name=agency)
    embed.set_thumbnail(url=metadata["logo"])
    footer = build_embed_footer(trip["mode"], metadata.get("slogan"))
    embed.set_footer(text=footer["text"], icon_url=footer["icon"])
    return embed
@@ -0,0 +1,172 @@
 import discord
 import asyncio
 import aiohttp
 import random
 from datetime import datetime, timedelta
 from src.utils import logger, channel_formatting, choose_connection, get_sound_path, LOCAL_TZ, get_next_station, generate_static_map
 from src.config import config
 from src.lang.locales import lang
 _scheduled_task: asyncio.Task | None = None
 _next_stop_task: asyncio.Task | None = None
 channel_lang = lang.channel
 async def rename_vc(bot: discord.Bot, voice_channel, from_scheduler: bool = False):
    global trip, _scheduled_task
    if not from_scheduler and _scheduled_task and not _scheduled_task.done():
        _scheduled_task.cancel()
    attempt = 0
    max_attempt = 15
    trip = choose_connection()
    while trip is None and attempt < max_attempt:
        attempt += 1
        trip = choose_connection()
    if trip is None:
        logger(f"Failed to select route after {max_attempt} attempts", "fatal")
        return False
    generate_static_map(trip["stops"], trip["mode"], trip["agency"], trip["route_color"])
    arrival = trip["arrival"]
    channel_name = trip["channel_name"]
    mode = trip["mode"]
    print("-----------------")
    logger(f"Transfer: {channel_name}; Arrival: {arrival}")
    logger(f"Agency: {trip["agency"]}, mode: {mode}")
    logger(f"Trying to change the channels name. If nothing happens, then the bot is in cooldown... (automatically resolves after up to 10min)")
    formatting = channel_formatting(mode)
    await voice_channel.edit(name=f"{formatting}{channel_name}")
    await voice_channel.set_status(None)
    start_next_stop_updates(voice_channel)
    logger(f"Updated channel name!")
    await bot.change_presence(activity=discord.Game(name=lang.rich_presence.arrival()))
    await announcer("transfer", voice_channel)
    _scheduled_task = asyncio.create_task(_schedule_next_transfer(bot,  trip["arrival_dt"], voice_channel, trip["to"]))
 async def announcer(announcement: str, voice_channel: discord.VoiceChannel, destination = None):
    from src.dc.embeds import build_info_embed, build_announcement_embed
    announcements_enabled = config.announcements.text_announcements
    if announcements_enabled:
        image = None
        if len(voice_channel.members) > 0:
            match announcement:
                case "end_of_connection":
                        embed = build_announcement_embed(lang.embeds.announcement.end_of_connection.message())
                case "transfer":
                    embed = build_info_embed()
                    image = discord.File("src/data/assets/current_map.png", filename="ride.png")
                case _:
                    logger(f"Unknown announcement: {announcement}")
                    embed = None
            if embed:
                if image:
                    await voice_channel.send(file=image, embed=embed)
                else:
                    await  voice_channel.send(embed=embed)
 async def voice_announcer(station: str, voice_channel: discord.VoiceChannel) -> bool:
    sound_path = get_sound_path(station=station)
    if sound_path is None:
        return False
    if voice_channel.guild.voice_client:
        logger(f"Already in vc, skipping this announcement to be safe")
        return False
    logger(f"Joining vc, playing {sound_path}")
    connect_task = asyncio.create_task(voice_channel.connect(timeout=15, reconnect=True))
    audio_source = discord.FFmpegPCMAudio(sound_path)
    vc = await connect_task
    loop = asyncio.get_running_loop()
    if not vc.is_playing():
        def after_playing(error):
            if error:
                logger(f"Player error: {error}", "error")
            loop.create_task(vc.disconnect())
            logger("Leaving vc")
        vc.play(audio_source, after=after_playing)
        return True
 async def _schedule_next_transfer(bot: discord.Bot, arrival_dt: datetime, voice_channel: discord.VoiceChannel, destination: str):
    now = datetime.now(LOCAL_TZ)
    wait_seconds = (arrival_dt - now).total_seconds()
    announcement_countdown = random.randrange(180, 300)
    if wait_seconds > 0:
        remaining = str(timedelta(seconds=wait_seconds))
        logger(f"Next transfer in {remaining.split('.')[0]} ({arrival_dt.strftime('%H:%M')})")
        if wait_seconds > announcement_countdown:
            wait_until_end_announcement = wait_seconds - announcement_countdown
            await asyncio.sleep(wait_until_end_announcement)
            await announcer("end_of_connection", voice_channel, destination)
            await asyncio.sleep(announcement_countdown)
        else:
            await asyncio.sleep(wait_seconds)
        logger("Train arrived, searching for a new connection....")
        await rename_vc(bot, voice_channel, from_scheduler=True)
 async def _update_next_loop(voice_channel: discord.VoiceChannel):
    global trip
    try:
        if trip is None:
            return
        now = datetime.now(LOCAL_TZ)
        departure_dt = trip["departure_dt"]
        if departure_dt > now:
                wait_seconds = (departure_dt - now).total_seconds() + 10
                await asyncio.sleep(wait_seconds)
        while True:
            next_stop = get_next_station(trip["stops"], trip["from"])
            if next_stop is None:
                return
            next_stop_str = next_stop["name"]
            status_text = f"{lang.embeds.info.next_stop()}: {next_stop_str}"
            try:
                await voice_channel.set_status(status_text, reason="Next stop status")
            except aiohttp.ClientConnectorDNSError as e:
                logger(F"Failed to set the channel status (network error?): {e}", "error")
            if config.announcements.voice_announcements:
                if len(voice_channel.members) > 0:
                    await voice_announcer(next_stop_str, voice_channel)
            wait_seconds = (next_stop["arrival"] - datetime.now(LOCAL_TZ)).total_seconds()
            if wait_seconds > 0:
                await asyncio.sleep(wait_seconds)
    except asyncio.CancelledError:
        raise
 def start_next_stop_updates(voice_channel: discord.VoiceChannel):
    global _next_stop_task
    if _next_stop_task is not None and not _next_stop_task.done():
        _next_stop_task.cancel()
    _next_stop_task = asyncio.create_task(_update_next_loop(voice_channel))
@@ -0,0 +1,32 @@
 import discord
 from datetime import datetime, timedelta
 from  src.utils import logger
 def validate_channel(bot: discord.bot, server_id: int, channel_id: int):
    guild = bot.get_guild(server_id)
    if guild is None:
        logger(f"Couldn't find server with ID '{server_id}', is the bot invited?", "fatal")
        return False
    channel = guild.get_channel(channel_id)
    if not isinstance(channel, discord.VoiceChannel):
        logger(f"Couldn't find vc with '{channel_id}'", "fatal")
        return False
    return channel
 def format_timestamp_to_dc(timestr):
    parsed_time = datetime.strptime(timestr, "%H:%M")
    now = datetime.now()
    final_datetime = datetime.now().replace(
        hour=parsed_time.hour,
        minute=parsed_time.minute,
        second=0,
        microsecond=0
    )
    if final_datetime <= now:
        final_datetime += timedelta(days=1)
    return discord.utils.format_dt(final_datetime, style="t")
@@ -1,109 +0,0 @@
 import random
 import discord
 from datetime import datetime, timedelta
 import src.handlers as handlers
 from src.config import config
 from src.utils import operator_metadata, format_via_list, resolve_operator, logger
 def format_timestamp(timestr):
    parsed_time = datetime.strptime(timestr, "%H:%M")
    now = datetime.now()
    final_datetime = datetime.now().replace(
        hour=parsed_time.hour,
        minute=parsed_time.minute,
        second=0,
        microsecond=0
    )
    if final_datetime <= now:
        final_datetime += timedelta(days=1)
    return discord.utils.format_dt(final_datetime, style="t")
 def format_iso_timestamp(isostr):
    parsed_time = discord.utils.parse_time(isostr)
    return discord.utils.format_dt(parsed_time, style="t")
 def build_embed_footer(operator_slogans):
    dbf = config.get("dbf", "https://dbf.finalrewind.org")
    footer_notice = f"Daten großzügig bereitgestellt von {dbf} • Typ: {handlers.train_type}"
    footer_text = (
        f"{random.choice(operator_slogans)} • {footer_notice}"
        if operator_slogans else
        footer_notice
    )
    icon = f"{dbf}/static/icons/icon-96x96.png"
    return {
        "text": footer_text,
        "icon": icon
    }
 def build_info_embed() -> discord.Embed | None:
    conn = handlers.current
    info = handlers.train_info
    if handlers.current is None and handlers.train_info is None:
        return None
    current_operator = resolve_operator(info["operators"])
    arrival = format_iso_timestamp(info["arrival"])
    departure = format_timestamp(conn['departure'])
    operator_infos = operator_metadata(current_operator)
    embed = discord.Embed(
        title=handlers.train_name,
        description=f"Abfahrt von {conn['station']} um {departure}. Ankunft um {arrival}",
        color=operator_infos["color"]
    )
    if len(conn['via']) > 0:
        embed.add_field(name="Über", value=format_via_list(conn['via']), inline=False)
    if operator_infos.get("unknown"): 
        logger(f"Metadaten für {current_operator} konten in operators.py nicht gefunden werden")
    embed.set_author(name=current_operator)
    embed.set_thumbnail(url=operator_infos["logo"])
    route_lines = []
    for stop in conn['route']:
        stop_name = stop["name"]
        if stop_name == conn['station']:
            route_lines.append(f"• **{stop_name}**")
        else:
            route_lines.append(f"• {stop_name}")
    embed.add_field(name="Route", value="\n".join(route_lines))
    footer = build_embed_footer(operator_infos.get("slogan"))
    embed.set_footer(text=footer["text"], icon_url=footer["icon"])
    return embed
 def build_announcement_embed(msg):
    current_operator = resolve_operator(handlers.train_info["operators"])
    operator_infos = operator_metadata(current_operator)
    embed = discord.Embed(
        title = "Informationen zu Ihrer Fahrt",
        description=msg,
        color=operator_infos["color"]
    )
    embed.set_author(name=current_operator)
    embed.set_thumbnail(url=operator_infos["logo"])
    footer = build_embed_footer(operator_infos.get("slogan"))
    embed.set_footer(text=footer["text"], icon_url=footer["icon"])
    return embed
 def build_error_embed(errormsg) -> discord.Embed:
    embed = discord.Embed(
        title="Ein Fehler ist aufgetreten!",
        description=errormsg,
        color=discord.Colour.red()
    )
    return embed
@@ -1,154 +0,0 @@
 import discord
 from datetime import datetime, timedelta
 import asyncio
 import random
 from pathlib import Path
 from src.config import config
 from src.utils import random_connection, get_train_info, get_channel_formatting, logger
 from src.embeds import build_announcement_embed, build_info_embed
 current = None
 _scheduled_task: asyncio.Task | None = None
 async def announcer(bot, announcement):
    voice_channel = bot.get_channel(config["vc"])
    if len(voice_channel.members) > 0:
        match announcement:
            case "ende":
                destination = current['destination']
                embed = build_announcement_embed(
                    f'Sehr geehrte Fahrgäste,\nIn wenigen Minuten erreichen wir {destination}. Dieser Zug endet dort.\n\nWir wünschen Ihnen eine angenehme Weiterreise.\n\nVielen Dank für Ihr Vertrauen und auf Wiedersehen.')
                if config["voice_announcements"][0]["enabled"]:
                    await voice_announcer(bot, destination, voice_channel)
            case "umstieg":
                embed = build_info_embed()
            case _:
                embed = None
        if embed is None:
            logger(f"Unbekanntes Announcement: {announcement}")
        else:
            await voice_channel.send(embed=embed)
    else:
        logger(f"Announcement {announcement} wird geskipped, keiner da")
        return
 async def voice_announcer(bot: discord.Bot, destination, voice_channel):
    voice_announcement_config = config["voice_announcements"][0]
    voice_stations = voice_announcement_config["stations"]
    if destination in voice_stations:
        announcement_for = destination
    else:
        if voice_stations.get("general", "") == "":
            return
        announcement_for = "general"
    if voice_stations.values() == list:
        sound_file = random.choice(voice_stations.get(announcement_for))
    else:
        sound_file = voice_stations.get(announcement_for)
    sound_path = f"src/data/announcements/{sound_file}"
    if Path(sound_path).is_file() is False:
        logger(f"Konnte Datei {sound_path} nicht finden", "error")
        return
    logger(f"VC wird betreten, spiele {sound_path}")
    vc = await voice_channel.connect(timeout=15, reconnect=True)
    audio_source = discord.FFmpegPCMAudio(sound_path)
    if not vc.is_playing():
        def after_playing(error):
            if error:
                logger(f"Player error: {error}", "error")
            bot.loop.create_task(vc.disconnect())
            logger("VC wird verlassen")
        vc.play(audio_source, after=after_playing)
 async def rename_vc(bot: discord.Bot, from_scheduler: bool = False):
    global current, train_name, train_info, train_type, _scheduled_task
    guild = bot.get_guild(int(config["server"]))
    if guild is None:
        logger(f"Es konnte kein Server mit der ID {config['server']} gefunden werden! Ist der Bot ein Member?", "fatal")
        return False
    channel = guild.get_channel(int(config["vc"]))
    if not isinstance(channel, discord.VoiceChannel):
        logger(f"Es konnte kein VC mit der ID {config['vc']} auf dem Server gefunden werden", "fatal")
        return False
    if not from_scheduler and _scheduled_task and not _scheduled_task.done():
        _scheduled_task.cancel()
    attempt = 0
    while True:
        if attempt == 20:
            logger("Zu viele Fehlversuche. Füge einen anderen Bahnhof hinzu.", "fatal")
            return "Es konnte kein Zug gefunden werden."
        attempt += 1
        current = random_connection()
        if current == None:
            return None
        parts = current['train'].split()
        train_type = parts[0]
        if parts[1].isdigit():
            train = current['train']
            train_ID = parts[1]
        else:
            train = parts[1]
            train_ID = current['train_number']
        station = current['station']
        train_info = get_train_info(station=station, train_ID=train_ID, train_type=train_type)
        if train_info and train_info.get('operators') and train_info.get('arrival'):
            break
        logger(f"Versuch {attempt}: Fehler bei {current['train']} von {station}, versuche neue Verbindung...")
    train_name = f"{train} nach {current['destination']} von {current['station']}"
    logger(f"Vorbereitung auf {train_name} (typ: {train_type})")
    arrival = datetime.fromisoformat((train_info["arrival"]))
    formatting = get_channel_formatting(train_type)
    print("-----------------------------------------")
    logger(f"Umstieg: {train_name}")
    logger(f"Betreiber: {''.join(train_info['operators'])}")
    logger(f"Train-Type: {train_type}")
    logger(f"Wenn der Name nicht geändert wird bin ich im Cooldown")
    await channel.edit(name=f"{formatting}{train_name}")
    await channel.set_status(f"Ankunft um {arrival.strftime('%H:%M')}")
    logger(f"Name geändert!")
    if config.get("announcements", True):
        await announcer(bot, "umstieg")
    _scheduled_task = asyncio.create_task(_schedule_next_umstieg(bot, arrival))
    return True
 async def _schedule_next_umstieg(bot, arrival):
    announcement = config.get("announcements", True)
    announcement_countdown = random.randrange(180, 300)  # letzte station announcement ist meistens 3-5min vor ankunft
    wait_seconds = (arrival - datetime.now()).total_seconds()
    if wait_seconds > 0:
        remaining = str(timedelta(seconds=wait_seconds))
        logger(f"Nächster Umstieg in {remaining.split('.')[0]} ({arrival.strftime('%H:%M:%S')} Uhr)")
        if announcement and wait_seconds > announcement_countdown:
            wait_until_end_announcement = wait_seconds - announcement_countdown
            await asyncio.sleep(wait_until_end_announcement)
            await announcer(bot, "ende")
            await asyncio.sleep(announcement_countdown)
        else:
            await asyncio.sleep(wait_seconds)
    logger("Zug angekommen, wähle neue Verbindung...")
    await rename_vc(bot, from_scheduler=True)
@@ -0,0 +1,62 @@
 # generated by datamodel-codegen:
 #   filename:  en.yaml
 #   timestamp: 2026-08-20T10:40:43+00:00
 from __future__ import annotations
 from dataclasses import dataclass
@dataclass
 class LongName:
    train_from: str
    train_via: str
@dataclass
 class Channel:
    long_name: LongName
    short_name: str
@dataclass
 class Footer:
    notice: str
@dataclass
 class Info:
    description: str
    via: str
    via_and: str
    next_stop: str
@dataclass
 class EndOfConnection:
    message: str
@dataclass
 class Announcement:
    title: str
    end_of_connection: EndOfConnection
@dataclass
 class Embeds:
    footer: Footer
    info: Info
    announcement: Announcement
@dataclass
 class RichPresence:
    arrival: str
@dataclass
 class Model:
    channel: Channel
    embeds: Embeds
    rich_presence: RichPresence
@@ -0,0 +1,34 @@
 import yaml
 import sys
 from src.utils import logger
 from src.config import config
 from src.lang.language_models import Model
 class AutoFormatStr(str):
    def __call__(self):
        frame = sys._getframe(1)
        context = {**frame.f_globals, **frame.f_locals}
        return self.format(**context)
 class LanguageObject:
    def __init__(self, dictionary: dict):
        for key, value in dictionary.items():
            if isinstance(value, dict):
                setattr(self, key, LanguageObject(value))
            elif isinstance(value, str):
                setattr(self, key, AutoFormatStr(value))
            else:
                setattr(self, key, value)
 def load_language(lang_code):
    path = f"src/data/locales/{lang_code}.yaml"
    try:
        with open(path, "r", encoding="utf-8") as file:
            data = yaml.safe_load(file)
            return LanguageObject(data)
    except Exception as e:
        logger(f"Failed loading language file: {e}", "FATAL")
 lang: Model = load_language(config.discord.lang)
@@ -1,149 +1,321 @@
 import requests
 import random
 import os
 import importlib
-from datetime import datetime
+from pathlib import Path
 from datetime import datetime, timedelta, timezone
 import staticmaps
 from src.config import config
-import src.data.operators as operators_module
+from zoneinfo import ZoneInfo
 import src.data.emojis as emojis
-_operators_mtime = None
+import src.data.operators as operators
-dbf = config.get("dbf", "https://dbf.finalrewind.org")
+from src.data.emojis import emoji_list
-def _reload_operators_if_changed():
+_operator_mtime = None
-    global _operators_mtime
+LOCAL_TZ = ZoneInfo(config.connections.timezone)
-    path = operators_module.__file__
+def logger(msg, log_type="info") -> str:
    current_mtime = os.path.getmtime(path)
    if _operators_mtime is None:
        _operators_mtime = current_mtime
        return
    if current_mtime != _operators_mtime:
        importlib.reload(operators_module)
        _operators_mtime = current_mtime
        logger("operators.py wurde automatisch neu geladen (Änderungen erkannt)")
 def random_connection():
    available_stations = config["stations"].copy()
    while True:
        if not available_stations:
            logger("Keine validen Bahnhöfe. Schlag den richtigen Bahnhofsnamen auf {dbf} nach", "fatal")
        station = random.choice(available_stations)
        url = f"{dbf}/{station}.json"
        blacklist = config.get("blacklist", [])
        try:
            response = requests.get(url)
            response.raise_for_status()
            data = response.json()
        except requests.RequestException as e:
            logger(f"Fehler beim aussuchen der Verbindung: {e}", "fatal")
            return
        if response.status_code == 300:
            logger(f"Bahnhof '{station}' konnte nicht gefunden werden ({url})", "error")
            available_stations.remove(station)
            continue
        departures = [
            d for d in data.get("departures", [])
            if d.get("scheduledDeparture") and d.get("destination") != station
            and not d.get("train", "").startswith(tuple(blacklist))
        ]
        if not departures:
            continue
        if not config['random']:
            dep = departures[0]
        else:
            dep = random.choice(departures)
        return {
            "train": dep['train'], 
            "destination": dep['destination'], 
            "route": dep['route'], 
            "departure": dep['scheduledDeparture'], 
            "via": dep['via'], 
            "station": station,
            "train_number": dep['trainNumber']
        }
 def get_train_info(station, train_ID, train_type):
    url = f"{dbf}/z/{train_type}%20{train_ID}/{station}.json"
    logger(f"Fetche {url}")
    try:
        response = requests.get(url)
        response.raise_for_status()
        data = response.json()
    except requests.RequestException as e:
        logger(f"ReqestException Fehler: {e}")
        return None
    dep = data.get("departure", [])
    if not dep:
        logger("Kein departure Feld gefunden", "error")
        return None
    route_post = dep.get("route_post_diff")
    if not route_post:
        logger("Kein route_post_diff Feld gefunden", "error")
        return None
    arrival_iso = route_post[-1].get("sched_arr")
    if not arrival_iso:
        logger("Keine Ankunftszeit gefunden", "error")
        return None
    return {
        "arrival": arrival_iso,
        "operators": dep.get("operators"),
    }
 def format_via_list(via: list[str]):
    if not via:
        return ""
    if len(via) == 1:
        return via[0]
    return ", ".join(via[:-1]) + " und " + via[-1] 
 def resolve_operator(operators):
    if not operators:
        return None
    for op in operators:
        if op in operators_module.OPERATOR_ALIASES or op in operators_module.OPERATORS:
            return op
    return operators[0]
 def operator_metadata(operator):
    _reload_operators_if_changed()
    if not operator:
        return operators_module.OPERATORS["fallback"]
    if operator in operators_module.OPERATOR_ALIASES:
        return operators_module.OPERATOR_ALIASES[operator]
    return operators_module.OPERATORS.get(operator, operators_module.OPERATORS["fallback"])
 def get_channel_formatting(train_type):
    formatting = config.get("formatting", "")
    train_emoji = ""
    if config.get("emojis", True):
        train_emoji = emojis.train_types.get(train_type)
        if train_emoji is None:
            train_emoji = emojis.emoji_list.get("Fallback", "")
    return f"{train_emoji}{formatting}"
 def logger(msg, log_type="info"):
    status = log_type.upper()
    current_time = datetime.now().strftime('%X')
    print(f"{current_time}: {status}: {msg}")
    if status == "FATAL":
        os._exit(1)
 def choose_connection() -> dict | None:
    from src.api import transitous
    station_id = transitous.get_random_stop_id()
    connection = transitous.get_random_connection(station_id)
    trip = transitous.get_trip_details(connection)
    return trip
 def validate_connection(start_time: str, end_time: str, departure_time_iso: str) -> bool:
    now = datetime.now(timezone.utc)
    start_dt = datetime.fromisoformat(start_time.replace("Z", "+00:00"))
    start_local = start_dt.astimezone(LOCAL_TZ).strftime('%H:%M')
    end_dt = datetime.fromisoformat(end_time.replace("Z", "+00:00"))
    if end_dt < now:
        logger(f"Connection is from the past: {start_local}", "error")
        return False
    max_wait_time = config.connections.max_wait_time
    if max_wait_time:
        if start_dt > now + timedelta(hours=max_wait_time):
            logger(f"Connection is way too far in the future: {start_local} (max_wait_time: {max_wait_time}h), retrying...", "error")
            return False
    departure_time_iso_dt = datetime.fromisoformat(departure_time_iso.replace("Z", "+00:00"))
    trip_duration = (end_dt - departure_time_iso_dt).total_seconds()
    trip_duration_minutes = str(timedelta(seconds=trip_duration))
    min_duration = config.connections.min_duration
    min_duration_seconds = min_duration * 60
    if trip_duration < min_duration_seconds:
        logger(f"Connection is with {trip_duration_minutes} minutes too short (configured to {min_duration} minutes or more), retrying...", "error")
        return False
    max_duration = config.connections.max_duration
    if max_duration:
        max_duration_seconds = max_duration * 60
        if max_duration_seconds < trip_duration:
            logger(f"Connection is with {trip_duration_minutes} too long (configured to {max_duration} minutes at most), retrying...", "error")
            return False
    return True
 def parse_iso(iso_str: str) -> datetime:
    dt = datetime.fromisoformat(iso_str.replace("Z", "+00:00"))
    return dt.astimezone(LOCAL_TZ)
 def channel_formatting(mode: str) -> str:
    formatting = config.discord.formatting
    emoji = ""
    if config.discord.emojis:
        emoji = emoji_list.get(mode)
        if emoji is None:
            emoji = emoji_list.get("Fallback")
    return f"{emoji}{formatting}"
 def get_train_name(train_name: str, mode: str) -> str:
    if train_name.isdigit():
        train = f"{mode.capitalize()} {train_name}"
    elif "(" in train_name:
        train = train_name.split(" (")[0]
    else:
        train = train_name
    return train
 def _reload_operators_if_changed():
    global _operator_mtime
    path = operators.__file__
    current_mtime = os.path.getmtime(path)
    if _operator_mtime is None:
        _operator_mtime = current_mtime
        return
    if current_mtime != _operator_mtime:
        importlib.reload(operators)
        _operator_mtime = current_mtime
 def get_operator_metadata(agency: str, route_color: str, mode: str) -> dict:
    _reload_operators_if_changed()
    op_data = operators.OPERATOR_ALIASES.get(agency) or operators.OPERATORS.get(agency) or operators.OPERATORS["fallback"]
    logo = op_data.get("logo", operators.OPERATORS["fallback"]["logo"])
    slogans = op_data.get("slogan")
    color = op_data.get("color")
    if color is None or color == operators.OPERATORS["fallback"]["color"]:
        if route_color is not None:
            try:
                color = int(route_color, 16)
            except ValueError:
                color = operators.OPERATORS["fallback"]["color"]
        else:
            color = operators.OPERATORS["fallback"]["color"]
    return {
        "logo": logo,
        "color": color,
        "slogans": slogans
    }
 def get_sound_path(station: str) -> str | None:
    announcement_dir = Path("src/data/announcements")
    for file in announcement_dir.iterdir():
        if file.is_file():
            if station.lower() in file.stem.lower():
                sound_file = file.resolve()
                return sound_file
 def get_next_station(stops: dict, train_from: str) -> dict | None:
    now = datetime.now(LOCAL_TZ)
    for name, info in stops.items():
        arrival_dt = info["arrival"]
        if arrival_dt >= now:
            if name == train_from:
                return None
            else:
                return {
                    "name": name,
                    "arrival": arrival_dt
                 }
    return None
 def format_via_list(stops: dict, via_and: str) -> str:
     if len(stops) > 2:
            stations = list(stops.keys())
            trip_from = stations[0]
            trip_to = stations[-1]
            important_stops = sort_stations_by_importance(stops)[:3]
            if trip_from in important_stops:
                important_stops.remove(trip_from)
            if trip_to in important_stops:
                important_stops.remove(trip_to)
            if len(important_stops) > 1:
                via = f"{', '.join(important_stops[:-1])} {via_and} {important_stops[-1]}"
            else:
                via = important_stops[0]
            return via
     return None
 def sort_stations_by_importance(stops: dict) -> list:
    sorted_stations_dict = dict(
    sorted(
        [(name, info["importance"]) for name, info in stops.items()],
        key=lambda x: x[1],
        reverse=True)
    )
    sorted_stations = list(sorted_stations_dict.keys())
    return sorted_stations
 def format_stop_list(stops: dict, next_stop: str | None) -> list[tuple[str, str]]:
    fields = []
    field_lines, field_length, part = [], 0, 1
    for name, info in stops.items():
        if name == next_stop:
            stop_arrival = info["arrival"]
            line = f"• __{name}__ ({stop_arrival.strftime("%H:%M")})"
        else:
            stop_arrival = info["arrival"]
            line = f"• {name} ({stop_arrival.strftime("%H:%M")})"
        if field_length + len(line) + 1 > 1024:
            route_page_name = "Route" if part == 1 else "Route (Fortsetzung)"
            fields.append((route_page_name, "\n".join(field_lines)))
            field_lines, field_length, part = [], 0, part + 1
        field_lines.append(line)
        field_length += len(line) + 1
    if field_lines:
        route_page_name = "Route" if part == 1 else "Route (Fortsetzung)"
        fields.append((route_page_name, "\n".join(field_lines)))
    return fields
 def generate_static_map(stops: dict, mode: str, operator: str, route_color: str):
    logger("Generating a new route map..")
    operator_metadata = get_operator_metadata(operator, route_color, mode)
    operator_color = operator_metadata["color"]
    if operator_color == 0xFFFFFF:
        stop_color = staticmaps.Color(105, 105, 105, 255)
    else:
        stop_color = staticmaps.parse_color(f"#{operator_color:06x}")
    white = staticmaps.Color(255, 255, 255, 255)
    context = staticmaps.Context()
    context.set_tile_provider(
        staticmaps.TileProvider(
            "carto-voyager",
            url_pattern=(
                "https://$s.basemaps.cartocdn.com/"
                "rastertiles/voyager/$z/$x/$y.png"
            ),
            shards=["a", "b", "c", "d"],
            attribution="",
        )
        # It is against the law (and against your morals...) to not give
        # OSM and carto credits for their great work
        # I only removed the attribution text because I really dislike the
        # ugly white box that py-staticmaps adds. Credits are still visible in the
        # embeds footer
    )
    stop_coords = [
        staticmaps.create_latlng(
            stop["lat"],
            stop["lon"],
        )
        for stop in stops.values()
    ]
    context.add_object(
        staticmaps.Line(
            stop_coords,
            color=white,
            width=20,
        )
    )
    context.add_object(
        staticmaps.Line(
            stop_coords,
            color=stop_color,
            width=8,
        )
    )
    last_index = len(stop_coords) - 1
    for i, point in enumerate(stop_coords):
        if i == 0 or i == last_index:
            context.add_object(
                staticmaps.Circle(
                    point,
                    radius_km=0.1,
                    fill_color=white,
                    color=stop_color,
                    width=12
                )
            )
            if i == last_index:
                context.add_object(
                    staticmaps.Marker(
                        point,
                        color=stop_color,
                        size=12
                    )
                )
    lats = [c.lat().degrees for c in stop_coords]
    lons = [c.lng().degrees for c in stop_coords]
    lat_span = max(lats) - min(lats)
    lon_span = max(lons) - min(lons)
    MIN_SPAN = 0.01 
    if lat_span < MIN_SPAN or lon_span < MIN_SPAN:
        center_lat = (max(lats) + min(lats)) / 2
        center_lon = (max(lons) + min(lons)) / 2
        pad = MIN_SPAN / 2
        context.add_object(
            staticmaps.Circle(
                staticmaps.create_latlng(center_lat + pad, center_lon + pad),
                radius_km=0.01,
                fill_color=staticmaps.TRANSPARENT,
                color=staticmaps.TRANSPARENT,
                width=0,
            )
        )
        context.add_object(
            staticmaps.Circle(
                staticmaps.create_latlng(center_lat - pad, center_lon - pad),
                radius_km=0.01,
                fill_color=staticmaps.TRANSPARENT,
                color=staticmaps.TRANSPARENT,
                width=0,
            )
        )
    try:
        image = context.render_cairo(400, 300)
        image.write_to_png("src/data/assets/current_map.png")
    except RuntimeError:
        logger(f"You don't have cairo installed! Because of that I can only give you a low-res png of the route...")
        image = context.render_pillow(400, 300)
        image.save("src/data/assets/current_map.png")
    logger("Map generated!")
Author	SHA1	Message	Date
Kaaninchen	53ded15209	fix: actually intercept voice_channel status error	2026-08-22 23:38:21 +02:00
Kaaninchen	c24749383b	fix: make the bot API conform i am SO sorry transitous team I only saw the notice now	2026-08-21 23:48:45 +02:00
Kaaninchen	5609a3c425	fix: intercept voice_channel status error	2026-08-21 18:40:44 +02:00
Kaaninchen	8dfa092229	fix: no attribute strftime	2026-08-20 22:29:46 +02:00
Kaaninchen	62d5569bcc	fix: return raw departure if start name == from_station (fixes min_duration)	2026-08-20 22:26:35 +02:00
Kaaninchen	f716b770dc	fix: config.json.example (2)	2026-08-20 21:41:51 +02:00
Kaaninchen	9e7c645724	fix: config.json.example	2026-08-20 21:41:24 +02:00
Kaaninchen	8c4e78c493	operators.py: S-Bahn Berlin GmbH	2026-08-20 21:40:09 +02:00
Kaaninchen	7e47874f78	remove circles on layovers in the embed map they were ugly and also took forever to generate	2026-08-20 17:53:22 +02:00
Kaaninchen	1069879680	operators.py: Flixbus-eu	2026-08-20 17:49:19 +02:00
Kaaninchen	a4ae134ca0	fix: end_of_connection announcement	2026-08-20 17:46:47 +02:00
Kaaninchen	054ab7fc42	fix: shorten channel name if it's too long for discords limit	2026-08-20 13:22:14 +02:00
Kaaninchen	999fe141b9	operators.py: Aktivbus Flensburg GmbH	2026-08-20 10:35:19 +02:00
Kaaninchen	595e7160df	fix next_status_loop	2026-08-19 22:48:19 +02:00
Kaaninchen	ead53f2f75	operators.py: Verkehrsbetrieb Potsdam GmbH	2026-08-19 22:44:33 +02:00
Kaaninchen	ed7ae614cc	operators.py: Erfurter Bahn	2026-08-19 22:17:54 +02:00
Kaaninchen	714841df22	feat: map of route in /info embed	2026-08-19 22:16:56 +02:00
Kaaninchen	cd2d968545	operators.py: slogans	2026-08-19 11:48:29 +02:00
Kaaninchen	2e62355db9	operators.py: Westfalenbahn	2026-08-18 22:34:17 +02:00
Kaaninchen	e6013a437f	arrival as discord rpc	2026-08-18 22:17:45 +02:00
Kaaninchen	d46a04af0c	some logging improvements	2026-08-18 20:44:54 +02:00
Kaaninchen	6006a561b2	only run voice_announcements if there's someone in the vc	2026-08-18 20:33:31 +02:00
Kaaninchen	881d2e865b	update config	2026-08-18 20:25:39 +02:00
Kaaninchen	66ec499c27	rewrite audio announcements feature to be simpler to setup	2026-08-18 20:20:30 +02:00
Kaaninchen	7a3902b7d3	add exact match notice on stations helper function	2026-08-18 18:47:51 +02:00
Kaaninchen	bd506ff9da	remove 'uhr'	2026-08-18 14:53:55 +02:00
Kaaninchen	59b2ccd64a	Update example output in stations helper	2026-08-18 14:48:49 +02:00
martinandGitHub	768da0ee4d	Merge pull request #1 from kaaninchen/transitous_rewrite The bot has been (almost) completely rewritten to use the https://transitous.org/ API. Take a look at the README for all the changes!	2026-08-18 14:41:00 +02:00
Kaaninchen	637a1f19a0	transitous rewrite: set default min_duration to 10	2026-08-18 14:36:59 +02:00
Kaaninchen	3dcf1e8626	transitous rewrite: only show next_stop if its actually stop and not the beginn of the route	2026-08-18 14:27:47 +02:00
Kaaninchen	729f350924	transitous rewrite: add IDs	2026-08-18 14:14:10 +02:00
Kaaninchen	a6342ca039	transitous rewrite: fix next_stop	2026-08-18 13:39:00 +02:00
Kaaninchen	260ab043f4	transitous rewrite: fix image in README	2026-08-18 13:27:01 +02:00
Kaaninchen	9f566a5bf3	transitous rewrite: change json to sh in README	2026-08-18 13:26:35 +02:00
Kaaninchen	000492f320	transitous rewrite: update example config in README	2026-08-18 13:25:47 +02:00
Kaaninchen	4a73ec6ef2	transitous rewrite: update README	2026-08-18 13:24:08 +02:00
Kaaninchen	5886c747fe	transitous rewrite: voice_announcements on stops	2026-08-18 11:41:15 +02:00
Kaaninchen	b608656bc7	transitous rewrite: forgot to commit them	2026-08-18 00:24:02 +02:00
Kaaninchen	ee51e85786	transitous rewrite: set vc status to next_station	2026-08-18 00:21:58 +02:00
Kaaninchen	a6e15f5cd6	transitous rewrite: multiple languages support	2026-08-17 21:04:47 +02:00
Kaaninchen	bbc2be89e9	transitous rewrite: rewrite all logs into english	2026-08-17 19:45:37 +02:00
Kaaninchen	d4971ab95b	transitous rewrite: retry on roundtrip connections	2026-08-17 19:35:04 +02:00
Kaaninchen	9cd1f54258	transitous rewrite: fix validate_connection	2026-08-17 18:29:06 +02:00
Kaaninchen	60d4936dda	transitous rewrite: only send announcement embed when no voice announcement	2026-08-17 17:14:43 +02:00
Kaaninchen	f990a55da9	transitous rewrite: minor cleanup	2026-08-17 15:52:12 +02:00
Kaaninchen	842c944faa	transitous rewrite: improved via	2026-08-17 15:33:14 +02:00
Kaaninchen	21146fff86	transitous rewrite: fix transfer	2026-08-17 14:08:08 +02:00
Kaaninchen	59af14e6ff	transitous rewrite: next_stop improvements	2026-08-17 12:49:35 +02:00
Kaaninchen	27f8ef2cbc	transitous rewrite: /info improvements	2026-08-16 23:29:03 +02:00
Kaaninchen	36a1db0647	transitous rewrite: add check_stations() function	2026-08-16 23:15:38 +02:00
Kaaninchen	8e9fa7c2f2	transitous rewrite: refactor config	2026-08-16 21:09:28 +02:00
Kaaninchen	41e185a211	transitous rewrite: code cleanup	2026-08-16 20:18:16 +02:00
Kaaninchen	66289e8572	transitous rewrite: next_stop functionality	2026-08-16 19:43:53 +02:00
Kaaninchen	ff8c2f55db	transitous rewrite: improved station selection	2026-08-16 19:12:20 +02:00
Kaaninchen	ca3f93f4cd	transitous rewrite: split /info embed if more than 1024 characters	2026-08-16 18:05:31 +02:00
Kaaninchen	cdceeb4e44	transitous rewrite: fix default duration values	2026-08-16 17:46:46 +02:00
Kaaninchen	2ec38c1874	transitous rewrite: announcer improvements	2026-08-16 17:33:18 +02:00
Kaaninchen	c563062b9a	transitous rewrite: announcements	2026-08-16 17:22:50 +02:00
Kaaninchen	a75b12ea31	transitous rewrite: via	2026-08-16 15:59:08 +02:00
Kaaninchen	1b0546ff4d	transitous rewrite: add max_duration	2026-08-16 15:20:07 +02:00
Kaaninchen	4598dcdc08	transitous rewrite: add logo license	2026-08-16 14:51:28 +02:00
Kaaninchen	10e1ea8ade	transitous rewrite: minimal route length	2026-08-16 14:50:11 +02:00
Kaaninchen	a4d9cb36f0	transitous rewrite: fix color from API	2026-08-16 14:23:56 +02:00
Kaaninchen	5a2d0bf8d6	transitous rewrite: bug fixes don't know anymore :(	2026-08-16 14:04:55 +02:00
Kaaninchen	1b0b10dc45	transitous rewrite: validate connections	2026-08-16 13:11:05 +02:00
Kaaninchen	1892c734cd	transitous rewrite: fix params string	2026-08-16 11:00:31 +02:00
Kaaninchen	f3d9a25f95	transitous rewrite: make sure to only use connections in the future	2026-08-16 10:43:38 +02:00
Kaaninchen	53358c08b1	transitous rewrite: remove wtf.json	2026-08-15 22:58:32 +02:00
Kaaninchen	46fe9eb61e	transitous rewrite: bug fixes in the info embed	2026-08-15 22:55:57 +02:00
Kaaninchen	697a0f6218	transitous rewrite: some minor info embed improvements	2026-08-15 22:13:58 +02:00
Kaaninchen	cf696df5f5	transitous rewrite: remove ID from some german regional trains the API gave a name like RB69 (IDNUMBERS) for RE and RB trains	2026-08-15 20:06:47 +02:00
Kaaninchen	f2a686edca	transitous rewrite: fix tram emoji	2026-08-15 20:06:04 +02:00
Kaaninchen	8770d03bb6	transitous rewrite: channel formatting	2026-08-15 19:48:15 +02:00
Kaaninchen	826b543347	transitous: basic rename_vc functionality	2026-08-15 19:12:30 +02:00
Kaaninchen	adfa0a0440	transitous: add api functions	2026-08-15 17:47:40 +02:00
Kaaninchen	5f6c3a223b	transitous: add bruno	2026-08-15 14:19:57 +02:00
		`@@ -0,0 +1,2 @@`
							`SPDX-FileCopyrightText: 2024 Mathis Brüchert <[email protected]>`
							`SPDX-License-Identifier: CC-BY-SA-4.0`