koleo-cli 0.2.137.16__py3-none-any.whl → 0.2.137.18__py3-none-any.whl

koleo/cli/station_board.py

@@ -0,0 +1,72 @@
+from asyncio import gather
+from datetime import datetime, timedelta
+
+from .base import BaseCli
+
+
+class StationBoard(BaseCli):
+    async def get_arrivals(self, station_id: int, date: datetime):
+        cache_id = f"arr-{station_id}-{date.strftime("%Y-%m-%d")}"
+        return self.storage.get_cache(cache_id) or self.storage.set_cache(
+            cache_id, await self.client.get_arrivals(station_id, date)
+        )
+
+    async def get_departures(self, station_id: int, date: datetime):
+        cache_id = f"dep-{station_id}-{date.strftime("%Y-%m-%d")}"
+        return self.storage.get_cache(cache_id) or self.storage.set_cache(
+            cache_id, await self.client.get_departures(station_id, date)
+        )
+
+    async def full_departures_view(self, station: str, date: datetime):
+        st = await self.get_station(station)
+        station_info = f"[bold blue][link=https://koleo.pl/dworzec-pkp/{st["name_slug"]}/odjazdy/{date.strftime("%Y-%m-%d")}]{st["name"]} at {date.strftime("%d-%m %H:%M")}[/bold blue] ID: {st["id"]}[/link]"
+        self.print(station_info)
+        trains = [
+            i
+            for i in await self.get_departures(st["id"], date)
+            if datetime.fromisoformat(i["departure"]).timestamp() > date.timestamp()  # type: ignore
+        ]
+        await self.trains_on_station_table(trains)
+
+    async def full_arrivals_view(self, station: str, date: datetime):
+        st = await self.get_station(station)
+        station_info = f"[bold blue][link=https://koleo.pl/dworzec-pkp/{st["name_slug"]}/przyjazdy/{date.strftime("%Y-%m-%d")}]{st["name"]} at {date.strftime("%d-%m %H:%M")}[/bold blue] ID: {st["id"]}[/link]"
+        self.print(station_info)
+        trains = [
+            i
+            for i in await self.get_arrivals(st["id"], date)
+            if datetime.fromisoformat(i["arrival"]).timestamp() > date.timestamp()  # type: ignore
+        ]
+        await self.trains_on_station_table(trains, type=2)
+
+    async def all_trains_view(self, station: str, date: datetime):
+        st = await self.get_station(station)
+        station_info = f"[bold blue][link=https://koleo.pl/dworzec-pkp/{st["name_slug"]}/odjazdy/{date.strftime("%Y-%m-%d")}]{st["name"]} at {date.strftime("%d-%m %H:%M")}[/bold blue] ID: {st["id"]}[/link]"
+        self.print(station_info)
+        departures, arrivals, brands = await gather(
+            self.get_departures(st["id"], date), self.get_arrivals(st["id"], date), self.get_brands()
+        )
+
+        trains = sorted(
+            [(i, 1) for i in departures] + [(i, 2) for i in arrivals],
+            key=lambda train: (
+                datetime.fromisoformat(train[0]["departure"]) + timedelta(microseconds=1)  # type: ignore
+                if train[1] == 1
+                else (datetime.fromisoformat(train[0]["arrival"]))  # type: ignore
+            ).timestamp(),
+        )
+        trains = [
+            (i, type)
+            for i, type in trains
+            if datetime.fromisoformat(i["departure"] if type == 1 else i["arrival"]).timestamp() > date.timestamp()  # type: ignore
+        ]
+        for train, type in trains:
+            time = (
+                f"[bold green]{train['departure'][11:16]}[/bold green]"  # type: ignore
+                if type == 1
+                else f"[bold yellow]{train['arrival'][11:16]}[/bold yellow]"  # type: ignore
+            )
+            brand = next(iter(i for i in brands if i["id"] == train["brand_id"]), {}).get("logo_text")
+            self.print(
+                f"{time} [red]{brand}[/red] {train["train_full_name"]}[purple] {train["stations"][0]["name"]} {self.format_position(train["platform"], train["track"])}[/purple]"
+            )

koleo/cli/stations.py

@@ -0,0 +1,37 @@
+from .base import BaseCli
+from .utils import COUNTRY_MAP
+
+
+class Stations(BaseCli):
+    async def find_station_view(self, query: str | None, type: str | None, country: str | None):
+        if query:
+            stations = await self.client.find_station(query)
+        else:
+            stations = self.storage.get_cache("stations") or self.storage.set_cache(
+                "stations", await self.client.get_stations()
+            )
+        for st in stations:
+            result_info = ""
+            if "country" in st:
+                if country:
+                    c_info = COUNTRY_MAP[st["country"]]
+                    if not c_info[0] == country:
+                        continue
+                else:
+                    c_info = COUNTRY_MAP[st["country"]]
+                    result_info += c_info[1] if self.storage.use_country_flags_emoji else c_info[0]
+            if type:
+                if not st["type"].startswith(type):
+                    continue
+            else:
+                if st["type"] == "Quay":
+                    result_info += "🚏" if self.storage.use_station_type_emoji else "BUS"
+                elif st["type"] == "TopographicalPlace":
+                    result_info += "🏛️" if self.storage.use_station_type_emoji else "GROUP"
+                else:
+                    result_info += "🚉" if self.storage.use_station_type_emoji else "RAIL"
+            if result_info:
+                result_info += " "
+            self.print(
+                f"[bold blue][link=https://koleo.pl/dworzec-pkp/{st["name_slug"]}]{result_info}{st["name"]}[/bold blue] ID: {st["id"]}[/link]"
+            )

koleo/cli/train_info.py

@@ -0,0 +1,142 @@
+from .base import BaseCli
+from asyncio import gather
+
+from datetime import datetime, timedelta
+from koleo.api.types import TrainCalendar, TrainDetailResponse, TrainStop
+from koleo.utils import koleo_time_to_dt
+
+
+class TrainInfo(BaseCli):
+    async def get_train_calendars(self, brand: str, name: str) -> list[TrainCalendar]:
+        brand = brand.upper().strip()
+        name_parts = name.split(" ")
+        if len(name_parts) == 1 and name_parts[0].isnumeric():
+            number = int(name_parts[0])
+            train_name = ""
+        elif len(name) > 1:
+            number = int(name_parts.pop(0))
+            train_name = " ".join(name_parts)
+        else:
+            raise ValueError("Invalid train name!")
+        brands = await self.get_brands()
+        if brand not in [i["name"] for i in brands]:
+            res = {i["logo_text"]: i["name"] for i in brands}.get(brand)
+            if not res:
+                raise ValueError("Invalid brand name!")
+            brand = res
+        cache_id = f"tc-{brand}-{number}-{name}"
+        try:
+            train_calendars = self.storage.get_cache(cache_id) or self.storage.set_cache(
+                cache_id, await self.client.get_train_calendars(brand, number, train_name)
+            )
+        except self.client.errors.KoleoNotFound:
+            await self.error_and_exit(f"Train not found: [underline]nr={number}, name={train_name}[/underline]")
+        return train_calendars["train_calendars"]
+
+    async def train_calendar_view(self, brand: str, name: str):
+        train_calendars = await self.get_train_calendars(brand, name)
+        brands = await self.get_brands()
+        for calendar in train_calendars:
+            brand_obj = next(iter(i for i in brands if i["id"] == calendar["trainBrand"]), {})
+            link = f"https://koleo.pl/pociag/{brand_obj["name"]}/{name.replace(" ", "-")}"
+            brand = brand_obj.get("logo_text", "")
+            self.print(
+                f"[red][link={link}]{brand}[/red] [bold blue]{calendar['train_nr']}{" "+ v if (v:=calendar.get("train_name")) else ""}[/bold blue]:[/link]"
+            )
+            for k, v in sorted(calendar["date_train_map"].items(), key=lambda x: datetime.strptime(x[0], "%Y-%m-%d")):
+                self.print(f"  [bold green]{k}[/bold green]: [purple]{v}[/purple]")
+
+    async def train_info_view(
+        self, brand: str, name: str, date: datetime, closest: bool, show_stations: tuple[str, str] | None = None
+    ):
+        train_calendars = await self.get_train_calendars(brand, name)
+        if closest:
+            dates = sorted([datetime.strptime(i, "%Y-%m-%d") for i in train_calendars[0]["dates"]])
+            date = next(iter(i for i in dates if i > date)) or next(iter(i for i in reversed(dates) if i < date))
+        if not (train_id := train_calendars[0]["date_train_map"].get(date.strftime("%Y-%m-%d"))):
+            await self.error_and_exit(
+                f"This train doesn't run on the selected date: [underline]{date.strftime("%Y-%m-%d")}[/underline]"
+            )
+        await self.train_detail_view(train_id, date=date.strftime("%Y-%m-%d"), show_stations=show_stations)
+
+    async def train_detail_view(
+        self, train_id: int, date: str | None = None, show_stations: tuple[str, str] | None = None
+    ):
+        train_details = await self.client.get_train(train_id)
+
+        if show_stations:
+            first_stop_slug, last_stop_slug = [
+                i["name_slug"] for i in await gather(*(self.get_station(i) for i in show_stations))
+            ]
+            train_stops_slugs = [i["station_slug"] for i in train_details["stops"]]
+            if first_stop_slug not in train_stops_slugs:
+                await self.error_and_exit(
+                    f"Train [underline]{train_details["train"]["train_name"]}[/underline] doesn't stop at [underline]{first_stop_slug}[/underline]"
+                )
+            elif last_stop_slug not in train_stops_slugs:
+                await self.error_and_exit(
+                    f"Train [underline]{train_details["train"]["train_name"]}[/underline] doesn't stop at [underline]{last_stop_slug}[/underline]"
+                )
+            first_stop, first_stop_index = next(
+                iter((i, n) for n, i in enumerate(train_details["stops"]) if i["station_slug"] == first_stop_slug)
+            )
+            last_stop, last_stop_index = next(
+                iter((i, n + 1) for n, i in enumerate(train_details["stops"]) if i["station_slug"] == last_stop_slug)
+            )
+            if first_stop_index >= last_stop_index:
+                await self.error_and_exit("Station B has to be after station A (-s / --show_stations)")
+        else:
+            first_stop, last_stop = train_details["stops"][0], train_details["stops"][-1]
+            first_stop_index, last_stop_index = 0, len(train_details["stops"]) + 1
+
+        await self.show_train_header(train_details, first_stop, last_stop, date)
+        self.train_route_table(train_details["stops"][first_stop_index:last_stop_index])
+
+    async def show_train_header(
+        self, train_details: TrainDetailResponse, first_stop: TrainStop, last_stop: TrainStop, date: str | None = None
+    ):
+        brands = await self.get_brands()
+        brand_obj = next(iter(i for i in brands if i["id"] == train_details["train"]["brand_id"]), {})
+        brand = brand_obj.get("logo_text", "")
+
+        link = (
+            f"https://koleo.pl/pociag/{brand_obj["name"]}/{train_details["train"]["train_full_name"].replace(" ", "-")}"
+        )
+        if date:
+            link += f"/{date}"
+        self.print(
+            f"[link={link}][red]{brand}[/red] [bold blue]{train_details["train"]["train_full_name"]}[/bold blue][/link]"
+        )
+
+        if train_details["train"]["run_desc"]:
+            self.print(f"  {train_details["train"]["run_desc"]}")
+
+        route_start = koleo_time_to_dt(first_stop["departure"])
+        route_end = koleo_time_to_dt(last_stop["arrival"])
+
+        if route_start.day == route_end.day and (
+            route_end.hour < route_start.hour
+            or (route_end.hour == route_start.hour and route_end.minute < route_end.minute)
+        ):
+            route_end += timedelta(days=1)
+
+        travel_time = route_end - route_start
+        speed = (last_stop["distance"] - first_stop["distance"]) / 1000 / travel_time.seconds * 3600
+        self.print(
+            f"[white]  {travel_time.seconds//3600}h{(travel_time.seconds % 3600)/60:.0f}m {speed:^4.1f}km/h [/white]"
+        )
+
+        vehicle_types: dict[str, str] = {
+            stop["station_display_name"]: stop["vehicle_type"]
+            for stop in train_details["stops"]
+            if stop["vehicle_type"]
+            and (koleo_time_to_dt(stop["departure"]) >= route_start and koleo_time_to_dt(stop["arrival"]) <= route_end)
+        }
+        if vehicle_types:
+            keys = list(vehicle_types.keys())
+            start = keys[0]
+            for i in range(1, len(keys)):
+                if vehicle_types[keys[i]] != vehicle_types[start]:
+                    self.print(f"  {start} - {keys[i]}: [bold green]{vehicle_types[start]}[/bold green]")
+                    start = keys[i]
+            self.print(f"  {start} - {keys[-1]}: [bold green]{vehicle_types[start]}[/bold green]")

koleo/cli/utils.py

@@ -0,0 +1,27 @@
+from koleo.api.types import Price
+
+CLASS_COLOR_MAP = {
+    "Klasa 2": "bright_green",
+    "Economy": "bright_green",
+    "Economy Plus": "bright_green",
+    "Klasa 1": "bright_cyan",
+    "Business": "bright_cyan",
+    "Premium": "bright_cyan",
+}
+
+
+COUNTRY_MAP = {
+    "Słowacja": ("sk", "🇸🇰"),
+    "Ukraina": ("ua ", "🇺🇦"),
+    "Niemcy": ("de", "🇩🇪"),
+    "Czechy": ("cz", "🇨🇿"),
+    "Polska": ("pl", "🇵🇱"),
+    "Litwa": ("lt", "🇱🇹"),
+    "": ("pl", "🇵🇱"),  # we have to assume...
+}
+
+
+def format_price(price: str | Price):
+    if isinstance(price, dict):
+        price = price["value"]
+    return f"{float(price):.2f} zł"

koleo/storage.py

@@ -1,21 +1,24 @@
 import typing as t
 from dataclasses import asdict, dataclass, field
-from json import dump, load
+from orjson import dumps, loads
 from os import makedirs
 from os import path as ospath
 from sys import platform
 from time import time
 
 
-def get_adequate_config_path():
+if t.TYPE_CHECKING:
+    from yt_dlp.cookies import YoutubeDLCookieJar
+
+
+def get_adequate_config_path() -> str:
     if platform == "darwin":
         # i dont fucking know nor want to
         return "~/Library/Preferences/koleo-cli/data.json"
-    elif "win" in platform:
+    if "win" in platform:
         # same with this
         return "%USERPROFILE%\\AppData\\Local\\koleo-cli\\data.json"
-    else:
-        return "~/.config/koleo-cli.json"
+    return "~/.config/koleo-cli.json"
 
 
 DEFAULT_CONFIG_PATH = get_adequate_config_path()
@@ -24,23 +27,69 @@ DEFAULT_CONFIG_PATH = get_adequate_config_path()
 T = t.TypeVar("T")
 
 
+@dataclass
+class Auth:
+    def __post_init__(self):
+        self._cache: dict | None = None
+
+    type: t.Literal["text", "command", "yt-dlp-browser"]
+    data: str
+
+    def get_auth(self) -> dict[str, str]:
+        if self._cache:
+            return self._cache
+        if self.type == "yt-dlp-browser":
+            try:
+                from yt_dlp.cookies import extract_cookies_from_browser
+            except ImportError as e:
+                raise ImportError(
+                    "This feature requires the 'yt-dlp' package. " "Please install it with 'pip install yt-dlp'."
+                ) from e
+            browser, _, profile = self.data.partition(",")
+            cookies: "YoutubeDLCookieJar" = extract_cookies_from_browser(browser, profile or None)
+            self._cache = {
+                cookie.name: cookie.value
+                for cookie in cookies
+                if (cookie.domain == "koleo.pl" or cookie.domain.endswith(".koleo.pl")) and cookie.value
+            }
+        elif self.type == "command":
+            from subprocess import run
+
+            process = run(self.data, capture_output=True)
+            self._cache = loads(process.stdout)
+        elif self.type == "str":
+            self._cache = t.cast(dict[str, str], loads(self.data))
+        else:
+            raise ValueError(f"invalid auth.type: {self.type}")
+        return self._cache  # type: ignore
+
+
 @dataclass
 class Storage:
-    favourite_station: str | None = None
     cache: dict[str, tuple[int, t.Any]] = field(default_factory=dict)
+    favourite_station: str | None = None
     disable_cache: bool = False
     use_roman_numerals: bool = False
+    aliases: dict[str, str] = field(default_factory=dict)
+    show_connection_id: bool = False
+    use_country_flags_emoji: bool = True
+    use_station_type_emoji: bool = True
+    auth: Auth | None = None
 
     def __post_init__(self):
         self._path: str
         self._dirty = False
 
+    @property
+    def dirty(self) -> bool:
+        return self._dirty
+
     @classmethod
     def load(cls, *, path: str = DEFAULT_CONFIG_PATH) -> t.Self:
         expanded = ospath.expanduser(path)
         if ospath.exists(expanded):
-            with open(expanded, "r") as f:
-                data = load(f)
+            with open(expanded) as f:
+                data = {k: v for k, v in loads(f.read()).items() if k in cls.__dataclass_fields__}
         else:
             data = {}
         storage = cls(**data)
@@ -49,10 +98,10 @@ class Storage:
 
     def get_cache(self, id: str) -> t.Any | None:
         if self.disable_cache:
-            return
+            return None
         cache_result = self.cache.get(id)
         if not cache_result:
-            return
+            return None
         expiry, item = cache_result
         if expiry > time():
             return item
@@ -67,18 +116,26 @@ class Storage:
         self._dirty = True
         return item
 
+    def clean_cache(self):
+        now = time()
+        copy = self.cache.copy()
+        self.cache = {k: data for k, data in copy.items() if data[0] > now}
+        if copy != self.cache:
+            self._dirty = True
+
     def save(self):
         dir = ospath.dirname(self._path)
         if dir:
             if not ospath.exists(dir):
                 makedirs(dir)
-        with open(self._path, "w+") as f:
-            self.clean()
-            dump(asdict(self), f, indent=True)
+        with open(self._path, "wb") as f:
+            self.clean_cache()
+            f.write(dumps(asdict(self)))
 
-    def clean(self):
-        now = time()
-        copy = self.cache.copy()
-        self.cache = {k: data for k, data in copy.items() if data[0] > now}
-        if copy != self.cache:
-            self._dirty = True
+    def add_alias(self, alias: str, station: str):
+        self.aliases[alias] = station
+        self._dirty = True
+
+    def remove_alias(self, alias: str):
+        self.aliases.pop(alias, None)
+        self._dirty = True

koleo/utils.py

@@ -1,7 +1,7 @@
 from argparse import Action
 from datetime import datetime, time, timedelta
 
-from .types import TimeDict
+from .api.types import TimeDict, SeatsAvailabilityResponse, TrainComposition, CarriageType
 
 
 def parse_datetime(s: str):
@@ -15,22 +15,47 @@ def parse_datetime(s: str):
         return datetime.strptime(s, "%Y-%m-%d").replace(hour=0, minute=0)
     except ValueError:
         pass
-    if s[0] == "+":
-        return datetime.now().replace(hour=0, minute=0) + timedelta(days=int(s[1:]))
+    if s[0] in "+-":
+        to_zero = []
+        num = int("".join([i for i in s if i.isnumeric()]))
+        if s[-1] == "h":
+            to_zero = ["minute"]
+            td = timedelta(hours=num)
+        elif s[-1] == "m":
+            td = timedelta(minutes=num)
+        else:
+            to_zero = ["hour", "minute"]
+            td = timedelta(days=num)
+        start = datetime.now()
+        if s[0] != s[1]:
+            start = start.replace(**{k: 0 for k in to_zero})  # type: ignore
+        if s[0] == "+":
+            return start + td
+        if s[0] == "-":
+            return start - td
+    if s[0] == "-":
+        return datetime.now().replace(hour=0, minute=0) - timedelta(days=int(s[1:]))
     try:
         now = datetime.now()
         dt = datetime.strptime(s, "%d-%m %H:%M")
         return dt.replace(year=now.year)
     except ValueError:
         pass
-    return datetime.combine(datetime.now(), datetime.strptime(s, "%H:%M").time())
+    try:
+        now = datetime.now()
+        dt = datetime.strptime(s, "%H:%M %d-%m")
+        return dt.replace(year=now.year)
+    except ValueError:
+        pass
+    return datetime.combine(datetime.today(), datetime.strptime(s, "%H:%M").time())
 
 
-def arr_dep_to_dt(i: TimeDict | str):
+def koleo_time_to_dt(i: TimeDict | str, *, base_date: datetime | None = None):
     if isinstance(i, str):
         return datetime.fromisoformat(i)
-    now = datetime.today()
-    return datetime.combine(now, time(i["hour"], i["minute"], i["second"]))
+    if not base_date:
+        base_date = datetime.today()
+    return datetime.combine(base_date, time(i["hour"], i["minute"], i["second"]))
 
 
 TRANSLITERATIONS = {
@@ -69,7 +94,7 @@ NUMERAL_TO_ARABIC = {
 }
 
 
-def convert_platform_number(number: str | None) -> int | None | str:
+def convert_platform_number(number: str) -> int | None | str:
     if number and number[-1] in "abcdefghi":  # just to be safe...
         arabic = NUMERAL_TO_ARABIC.get(number[:-1])
         return f"{arabic}{number[-1]}" if arabic else None
@@ -79,3 +104,65 @@ def convert_platform_number(number: str | None) -> int | None | str:
 class RemainderString(Action):
     def __call__(self, _, namespace, values: list[str], __):
         setattr(namespace, self.dest, " ".join(values) if values else self.default)
+
+
+BRAND_SEAT_TYPE_MAPPING = {
+    45: {30: "Klasa 2", 31: "Z rowerem"},  # kd premium
+    28: {4: "Klasa 1", 5: "Klasa 2"},  # ic
+    1: {4: "Klasa 1", 5: "Klasa 2"},  # tlk
+    29: {4: "Klasa 1", 5: "Klasa 2"},  # eip
+    2: {4: "Klasa 1", 5: "Klasa 2"},  # eic
+    43: {  # łs
+        11: "Klasa 2",
+    },
+    47: {  # leo
+        17: "Economy",
+        18: "Business",
+        19: "Premium",
+        20: "Economy Plus",
+    },
+}
+
+
+def find_empty_compartments(seats: SeatsAvailabilityResponse, composition: TrainComposition) -> list[tuple[int, int]]:
+    num_taken_seats_in_group: dict[tuple[int, int], int] = {}
+    for seat in seats["seats"]:
+        key = (int(seat["carriage_nr"]), int(seat["seat_nr"][:-1]))
+        num_taken_seats_in_group.setdefault(key, 0)
+        if seat["state"] != "FREE":
+            num_taken_seats_in_group[key] += 1
+    return [k for k, v in num_taken_seats_in_group.items() if v == 0]
+
+
+SEAT_GROUPS = {
+    1: 1,
+    3: 1,
+    2: 2,
+    8: 2,
+    5: 3,
+    7: 3,
+    4: 4,
+    6: 4,
+}
+
+
+def get_double_key(seat: int) -> tuple[int, int]:
+    # x1, x3 -> x, 1
+    # x2, x8 -> x, 2
+    # x5, x7 -> x, 3
+    # x4, x6 -> x, 4
+    # x0, x9 nie istnieją!
+    seat_nr = str(seat)
+    return int(seat_nr[:-1]), SEAT_GROUPS[int(seat_nr[-1])]
+
+
+def find_empty_doubles(
+    seats: SeatsAvailabilityResponse,
+):
+    num_taken_seats_in_double: dict[tuple[int, int, int], int] = {}
+    for seat in seats["seats"]:
+        key = (int(seat["carriage_nr"]), *get_double_key(int(seat["seat_nr"])))
+        num_taken_seats_in_double.setdefault(key, 0)
+        if seat["state"] != "FREE":
+            num_taken_seats_in_double[key] += 1
+    return [k for k, v in num_taken_seats_in_double.items() if v == 0]

koleo_cli-0.2.137.18.dist-info/METADATA

@@ -0,0 +1,103 @@
+Metadata-Version: 2.4
+Name: koleo-cli
+Version: 0.2.137.18
+Summary: Koleo CLI
+Home-page: https://github.com/lzgirlcat/koleo-cli
+Author: Zoey !
+Maintainer-email: cb98uzhd@duck.com
+License: GNU General Public License v3.0
+Project-URL: Source (GitHub), https://github.com/lzgirlcat/koleo-cli
+Project-URL: Issue Tracker, https://github.com/lzgirlcat/koleo-cli/issues
+Keywords: koleo,timetable,trains,rail,poland
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: rich~=14.0.0
+Requires-Dist: aiohttp~=3.12.13
+Requires-Dist: orjson~=3.10.18
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: maintainer-email
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Koleo CLI
+[![PyPI - Version](https://img.shields.io/pypi/v/koleo-cli.svg)](https://pypi.org/project/koleo-cli)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/koleo-cli.svg)](https://pypi.org/project/koleo-cli)
+
+## Installation
+**install via pip by running** `pip install koleo-cli`
+
+
+![gif showcasing the functionality](https://github.com/lzgirlcat/koleo-cli/blob/main/koleo-cli.gif?raw=true)
+
+## it currently allows you to:
+ - get departures/arrival list for a station
+ - get train info given its number and name(pull requests are welcome if you know how to get a train object by just the number)
+ - find a station or list all known stations
+ - find a connection from station a to b, with filtering by operators
+ - save a station as your favourite to quickly check it's departures
+ - add station aliases to query them more easily
+ - check seat allocation statistics
+
+### coming soon™️:
+ - TUI ticket purchase interface
+ - ticket display
+ - your previous tickets + stats
+ - find empty compartments 
+additionally you can also use the KoleoAPI wrapper directly in your own projects, all returns are fully typed using `typing.TypedDict`
+
+## MY(possibly controversial) design choices:
+ - platforms and track numbers are shown using arabic numerals instead of roman
+   - you can change it by adding `use_roman_numerals: true` to your `koleo-cli.json` config file
+ - most api queries are cached for 24h
+   - you can change it by adding `disable_cache: true` to your `koleo-cli.json` config file
+ - stations/ls uses emojis by default
+   - you can disable them by adding `use_country_flags_emoji: false` and `use_country_flags_emoji: false` to your `koleo-cli.json` config file
+pull requests are welcome!!
+
+```
+usage: koleo [-h] [-c CONFIG] [--nocolor]
+             {departures,d,dep,odjazdy,o,arrivals,a,arr,przyjazdy,p,all,w,wszystkie,all_trains,pociagi,trainroute,r,tr,t,poc,pociąg,traincalendar,kursowanie,tc,k,traindetail,td,tid,id,idpoc,stations,s,find,f,stacje,ls,q,connections,do,z,szukaj,path,trainstats,ts,tp,miejsca,frekwencja,trainconnectionstats,tcs,aliases} ...
+
+Koleo CLI
+
+options:
+  -h, --help            show this help message and exit
+  -c, --config CONFIG   Custom config path.
+  --nocolor             Disable color output and formatting
+
+actions:
+  {departures,d,dep,odjazdy,o,arrivals,a,arr,przyjazdy,p,all,w,wszystkie,all_trains,pociagi,trainroute,r,tr,t,poc,pociąg,traincalendar,kursowanie,tc,k,traindetail,td,tid,id,idpoc,stations,s,find,f,stacje,ls,q,connections,do,z,szukaj,path,trainstats,ts,tp,miejsca,frekwencja,trainconnectionstats,tcs,aliases}
+    departures (d, dep, odjazdy, o)
+                        Allows you to list station departures
+    arrivals (a, arr, przyjazdy, p)
+                        Allows you to list station departures
+    all (w, wszystkie, all_trains, pociagi)
+                        Allows you to list all station trains
+    trainroute (r, tr, t, poc, pociąg)
+                        Allows you to check the train's route
+    traincalendar (kursowanie, tc, k)
+                        Allows you to check what days the train runs on
+    traindetail (td, tid, id, idpoc)
+                        Allows you to show the train's route given it's koleo ID
+    stations (s, find, f, stacje, ls, q)
+                        Allows you to find stations by their name
+    connections (do, z, szukaj, path)
+                        Allows you to search for connections from a to b
+    trainstats (ts, tp, miejsca, frekwencja)
+                        Allows you to check seat allocation info for a train.
+    trainconnectionstats (tcs)
+                        Allows you to check the seat allocations on the train connection given it's koleo ID
+    aliases             Save quick aliases for station names!
+```