update favicon

feat: priority list
forgot to include de.yaml
2026-09-17 16:52:47 +00:00 · 2026-08-23 17:57:01 +02:00 · 2026-08-23 17:21:22 +02:00 · 2026-08-23 16:10:11 +02:00 · 2026-08-23 16:09:52 +02:00 · 2026-08-23 13:39:48 +02:00
28 changed files with 1472 additions and 708 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,179 +1,213 @@
 # Gleiswechsel
+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.

-## THIS BRANCH IS NO LONGER MAINTAINED
-## This is the code for the legacy Gleiswechsel bot, based on the much simpler dbf API. 
+![Example Channel](.github/preview_kanal.png)

-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.  
+## Features
+- [International support](https://transitous.org/sources/) for countries as well 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 Kanal](.github/preview_kanal.png) 
-
-Der Bot stellt außerdem den `/info` Befehl dar, welcher einem weitere Informationen zur Verbindung zurückgibt  
-
-![Beispiel info](.github/preview_info.png)
+![Example info](.github/preview_info.png)

 ## Setup
-```sh
-git clone https://github.com/kaaninchen/Gleiswechsel.git
+Follow [this guide](https://guide.pycord.dev/getting-started/creating-your-first-bot) to create your discord bot up until you have a token. 

-# Mit Python
-python -m venv venv 
+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
-pip install -r requirements.txt 
-
-# Mit uv
-uv venv venv
-source venv/bin/activate
-uv pip install -r requirements.txt

+# Install the required dependencies
+pip install -r requirements.txt
 ```

-### Config
+Next, you should configure the bot to your liking

-`$ cp config.json.example config.json`
-```jsonc
-{
-    "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
-}
+## Config
+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.  

+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>
-<summary>weitere Config Erklärungen</summary>
+The bot will also warn you if it couldn't find a station with the exact name as your input:

-#### 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:
-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. 
+but you can safely ignore this warning if you're fine with it. 

-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.
-
-#### 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.
+If not, I've created a tool which would help you to get the exact station name. You can use the tool by running

 ```sh
-$ sudo apt install ffmpeg # Debian/Ubuntu
-
-$ brew install ffmpeg # macOS (brew)
+$ python main.py stations
 ```

-##### Voice_announcements config:  
-
+Example output:
 ```json
-    "voice_announcements": [
-        {
-            "enabled": true,
-            "stations": {
-                "general": "general.aac",
-                "Hannover": "hannover.aac"
-            }
-        }
-    ],
+    "stations": {
+        "Amsterdam": [
+            "Amsterdam Zuid",
+            "Amsterdam RAI",
+            "Amsterdam Amstel",
+            "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`
+
+##### IDs
+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.
+
+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.
+
+##### priority
+You can define priorities of transport modes while selecting a connection. Leave empty to disable   
+
+The list should be descending, with "1" as the most important transport mode. For example, let's say, the bot should always choose Trains and other longer distance public transport modes. If it can't find any, then it should resort to Metros/Subways/Suburbans. If these are also missing at that station, then it should just use Busses/Trams:

 ```json
-"stations": {
-    "general": ""
+"priority": {
+    "HIGHSPEED_RAIL": 1,
+    "LONG_DISTANCE": 1,
+    "NIGHT_RAIL": 1,
+    "REGIONAL_RAIL": 1,
+    "COACH": 1,
+    "FERRY": 1,
+    "METRO": 2,
+    "SUBURBAN": 2,
+    "SUBWAY": 2,
+    "BUS": 3,
+    "TRAM": 3
 }
 ```
+A transport mode that isn't in the priority list would immediately get assigned the value of "99", making it near impossible to get that connection. Except when there are no other connections available, of course.

-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.
+You can find the MODE names either in the console log or the stations.json from [helper tool](#stations)

-```json
-"stations": {
-    "general": ["general_1.aac", "general_2.aac"]
-}
+##### blacklist
+You can blacklist specific types of transport, the bot would then skip them while selecting a connection. You can get the type in your console (mode)
+```sh
+22:44:47: INFO: Agency: GVB, mode: TRAM
 ```

-#### blacklist:  
-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"
-    ]
-}
-```  
+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

-Die Namen der einzelnen Zugtypen kann im Footer von `/info` oder im Terminal log erfahren.
+##### min_duration, max_duration, max_wait_time, timezone

-#### src/data 
-Es kann vorkommen, dass während dem `/info` Befehl das Logo und die Farbe des Bahnuntermehns fehlt.
+- `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.

-![Beispiel für fehlende Daten](.github/info_fehlende_daten.png)  
+- `max_duration` is the maximun duration of the connection in minutes. Set to `null` to disable

-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.  
+- `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

-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.
+- `timezone` is timezone in the IANA timezone format. You can [look it up here](https://www.addevent.com/c/documentation/tools/time-zone-lookup)

-Den Status, den sich der Bot alle 5 Minuten random auswählt, kann man in [src/data/status.py](src/data/status.py) anpassen.
+##### announcements

-</details>
+##### `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:

-### Running
+![end_of_trip](.github/end_of_trip_announcement.png)
+
+It will also send the `/info` embed at the start of a new connection with informations about your new trip.
+
+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 main.py
-# ODER
-python3 main.py
-
-# uv
-uv run main.py
+$ python main.py
 ```

-## Bekannte Bugs
-#### Stuttgart in Berlin
-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.   
+## src/data
+[src/data](src/data/) contains a few files/directories which may be interesting to customize. 

-```json
-{
-    "blacklist": [
-        "S "
-    ]
-}
+### [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

-```
+### [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
-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.
+If multiple agencys should use the same metadata, take a look at OPERATOR_ALIASES. 

-![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,35 @@
 {
+  "discord": {
    "token": "",
-    "stations": ["Hamburg Hbf", "München Hbf", "Köln Hbf", "Amsterdam Centraal"],
-    "dbf": "https://dbf.finalrewind.org",
-    "server": , 
+    "server": ,
    "vc": ,
-    "random": true,
-    "emojis": true,
+    "lang": "de",
    "formatting": "┇",
-    "announcements": true,
-    "voice_announcements: [
-        {
-            "enabled": false,
-            "stations": {
-                "general": ""
-            }
-        }
-    ]
-    "blacklist": []
+    "emojis": true
+  },
+  "connections": {
+    "stations": [
+      "Berlin Hauptbahnhof",
+      "Amsterdam",
+      "Helsinki"
+    ],
+    "IDs": [],
+    "priority: "{
+    }",
+    "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
-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
+import sys
+
 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)
-
-@tasks.loop(minutes=5)
-async def change_status():
-    status = random.choice(discord_status)
-    await bot.change_presence(activity=discord.Game(name=f"{status} • /info"))
-
+setup_commands(bot=bot)
 _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:
+        logger(f"{bot.user} is online")
        _bot_initialized = True
-        await rename_vc(bot)
-    else:
-        logger("Discord Reconnect, laufende Fahrt bleibt unangetastet")

-@bot.event
-async def on_application_command_error(ctx, error):
-    embed = build_error_embed(f"Ein Fehler ist aufgetreten: {error}")
-    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'])
+try:
+    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
@@ -20,4 +22,4 @@ requests==2.34.2
 six==1.17.0
 typing-extensions==4.16.0
 urllib3==2.7.0
-yarl==1.24.2
+yarl==1.24.2
@@ -0,0 +1,298 @@
+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())
+    chosen_stop_id = random.choice(stop_ids_list)
+    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")
+        logger(f"Selected station: {stop_ids[chosen_stop_id]}")
+
+    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")
+    params = {"stopId": stop_id, "n": 50, "time": now}
+
+    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")
+        return None
+
+    candidates = []
+    for entry in data.get("stopTimes", []):
+        if entry["mode"] in blacklist:
+            continue
+        candidates.append(entry)
+        
+    if not candidates:
+        logger("Couldn't find any connections", "error")
+        return None
+    
+    if config.connections.priority:
+        best_priority = None
+        for entry in candidates:
+            priority = config.connections.priority.get(entry["mode"], 99)
+            if best_priority is None or priority < best_priority:
+                best_priority = priority
+
+        best_candidates = []
+        for entry in candidates:
+            priority = config.connections.priority.get(entry["mode"], 99)
+            if priority == best_priority:
+                best_candidates.append(entry)
+
+        chosen = random.choice(best_candidates)
+    else:
+        chosen = random.choice(candidates)
+
+    return {
+        "trip_id": chosen["tripId"], 
+        "from_station": chosen.get("place", {}).get("name"),
+    }
+
+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,52 @@
 import json
+from dataclasses import dataclass
+from typing import Optional

-with open("config.json", "r") as file:
-    config = json.load(file)
+@dataclass
+class DiscordConfig:
+    token: str
+    server: int
+    vc: int
+    lang: str
+    formatting: str
+    emojis: bool
+
+@dataclass
+class ConnectionsConfig:
+    stations: list[str]
+    IDs: list[str]
+    priority: dict
+    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()
@@ -1,18 +1,12 @@
 emoji_list = {
-    "Fallback": "🚉",
-    "Nahverkehr": "🚃",
-    "Höchstgeschwindigkeit": "🚄",
-    "Bus": "🚎"
-}
-
-train_types = { # Unvollständig!
-    "ICE": emoji_list["Höchstgeschwindigkeit"],
-    "TGV": emoji_list["Höchstgeschwindigkeit"],
-
-    "RE": emoji_list["Nahverkehr"],
-    "RB": emoji_list["Nahverkehr"],
-    "ARV": emoji_list["Nahverkehr"],
-    "BRB": emoji_list["Nahverkehr"],
-
-    "Bus": emoji_list["Bus"]
+    "Fallback": "💺",
+    "BUS": "🚎",
+    "COACH": "🚎",
+    "TRAM": "🚈",
+    "REGIONAL_RAIL": "🚊",
+    "HIGHSPEED_RAIL": "🚅",
+    "LONG_DISTANCE": "🚅",
+    "METRO": "🚇",
+    "SUBWAY": "🚇",
+    "FERRY": "🚢"
 }
@@ -0,0 +1,17 @@
+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:
+  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,17 @@
+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:
+  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": {
-        "unknown": True,
-        "logo": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcQCVeC5E0mNNBKyQftQaFMzxIVkbDvEnSzWv07h_c8PdA&s=10",
-        "color": 0xFFFFFF
+OPERATORS = {
+    "Abellio Rail Mitteldeutschland GmbH": {
+        "logo": "https://upload.wikimedia.org/wikipedia/commons/thumb/e/e0/Abellio_logo.svg/1920px-Abellio_logo.svg.png",
+        "color": 0xD7002E,
+        "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": {
-        "logo": "https://upload.wikimedia.org/wikipedia/commons/thumb/f/f3/ODEG-Logo_Neu.svg/960px-ODEG-Logo_Neu.svg.png",
-        "color": 0x00745C
+    "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,
+        "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": {
-        "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"]
-    },
-    "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
+    "fallback": {
+        "logo": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcQCVeC5E0mNNBKyQftQaFMzxIVkbDvEnSzWv07h_c8PdA&s=10",
+        "color": 0xFFFFFF
    }
 }

+
 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(slogans):
+    footer_notice = f"https://transitous.org/sources/ • Maps (C) CARTO (C) OpenStreetMap.org contributors"
+    icon = "https://api.transitous.org/favicon.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(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(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,56 @@
+# generated by datamodel-codegen:
+#   filename:  en.yaml
+#   timestamp: 2026-08-23T14:08:25+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 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:
+    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
-import src.data.emojis as emojis
+from zoneinfo import ZoneInfo

-_operators_mtime = None
-dbf = config.get("dbf", "https://dbf.finalrewind.org")
+import src.data.operators as operators
+from src.data.emojis import emoji_list

-def _reload_operators_if_changed():
-    global _operators_mtime
+_operator_mtime = None
+LOCAL_TZ = ZoneInfo(config.connections.timezone)

-    path = operators_module.__file__
-    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"):
+def logger(msg, log_type="info") -> str:
    status = log_type.upper()
    current_time = datetime.now().strftime('%X')
    print(f"{current_time}: {status}: {msg}")
    if status == "FATAL":
-        os._exit(1)
+        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	21a279839d	update favicon	2026-08-23 17:57:01 +02:00
Kaaninchen	1c006731a4	feat: priority list	2026-08-23 17:21:22 +02:00
Kaaninchen	db43ee4279	forgot to include de.yaml	2026-08-23 16:10:11 +02:00
Kaaninchen	dc2f9dade0	move footer_notice from lang files to source code	2026-08-23 16:09:52 +02:00
Kaaninchen	10b6ee560e	README: rename python run file to python file	2026-08-23 13:39:48 +02:00
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