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

koleo/args.py

@@ -0,0 +1,279 @@
+from argparse import ArgumentParser
+from datetime import datetime
+from asyncio import run
+from inspect import isawaitable
+
+from .api import KoleoAPI
+from .cli import CLI
+from .storage import DEFAULT_CONFIG_PATH, Storage
+from .utils import RemainderString, parse_datetime
+
+
+def main():
+    cli = CLI()
+
+    parser = ArgumentParser("koleo", description="Koleo CLI")
+    parser.add_argument("-c", "--config", help="Custom config path.", default=DEFAULT_CONFIG_PATH)
+    parser.add_argument("--nocolor", help="Disable color output and formatting", action="store_true", default=False)
+    subparsers = parser.add_subparsers(title="actions", required=False)  # type: ignore
+
+    departures = subparsers.add_parser(
+        "departures", aliases=["d", "dep", "odjazdy", "o"], help="Allows you to list station departures"
+    )
+    departures.add_argument(
+        "station",
+        help="The station name",
+        default=None,
+        nargs="*",
+        action=RemainderString,
+    )
+    departures.add_argument(
+        "-d",
+        "--date",
+        help="the departure date",
+        type=lambda s: parse_datetime(s),
+        default=datetime.now(),
+    )
+    departures.add_argument("-s", "--save", help="save the station as your default one", action="store_true")
+    departures.set_defaults(func=cli.full_departures_view, pass_=["station", "date"])
+
+    arrivals = subparsers.add_parser(
+        "arrivals", aliases=["a", "arr", "przyjazdy", "p"], help="Allows you to list station departures"
+    )
+    arrivals.add_argument(
+        "station",
+        help="The station name",
+        default=None,
+        nargs="*",
+        action=RemainderString,
+    )
+    arrivals.add_argument(
+        "-d",
+        "--date",
+        help="the arrival date",
+        type=lambda s: parse_datetime(s),
+        default=datetime.now(),
+    )
+    arrivals.add_argument("-s", "--save", help="save the station as your default one", action="store_true")
+    arrivals.set_defaults(func=cli.full_arrivals_view, pass_=["station", "date"])
+
+    all_trains = subparsers.add_parser(
+        "all", aliases=["w", "wszystkie", "all_trains", "pociagi"], help="Allows you to list all station trains"
+    )
+    all_trains.add_argument(
+        "station",
+        help="The station name",
+        default=None,
+        nargs="*",
+        action=RemainderString,
+    )
+    all_trains.add_argument(
+        "-d",
+        "--date",
+        help="the date",
+        type=lambda s: parse_datetime(s),
+        default=datetime.now(),
+    )
+    all_trains.add_argument("-s", "--save", help="save the station as your default one", action="store_true")
+    all_trains.set_defaults(func=cli.all_trains_view, pass_=["station", "date"])
+
+    train_route = subparsers.add_parser(
+        "trainroute",
+        aliases=["r", "tr", "t", "poc", "pociąg"],
+        help="Allows you to check the train's route",
+    )
+    train_route.add_argument("brand", help="The brand name", type=str)
+    train_route.add_argument("name", help="The train name", nargs="+", action=RemainderString)
+    train_route.add_argument(
+        "-d",
+        "--date",
+        help="the date",
+        type=lambda s: parse_datetime(s),
+        default=datetime.now(),
+    )
+    train_route.add_argument(
+        "-c",
+        "--closest",
+        help="ignores date, fetches closest date from the train calendar",
+        action="store_true",
+        default=False,
+    )
+    train_route.add_argument(
+        "-s", "--show_stations", help="limit the result to A->B", action="extend", nargs=2, type=str, default=None
+    )
+    train_route.set_defaults(func=cli.train_info_view, pass_=["brand", "name", "date", "closest", "show_stations"])
+
+    train_calendar = subparsers.add_parser(
+        "traincalendar",
+        aliases=["kursowanie", "tc", "k"],
+        help="Allows you to check what days the train runs on",
+    )
+    train_calendar.add_argument("brand", help="The brand name", type=str)
+    train_calendar.add_argument("name", help="The train name", nargs="+", action=RemainderString)
+    train_calendar.set_defaults(func=cli.train_calendar_view, pass_=["brand", "name"])
+
+    train_detail = subparsers.add_parser(
+        "traindetail",
+        aliases=["td", "tid", "id", "idpoc"],
+        help="Allows you to show the train's route given it's koleo ID",
+    )
+    train_detail.add_argument(
+        "-s", "--show_stations", help="limit the result to A->B", action="extend", nargs=2, type=str, default=None
+    )
+    train_detail.add_argument("train_id", help="The koleo ID", type=int)
+    train_detail.set_defaults(func=cli.train_detail_view, pass_=["train_id", "show_stations"])
+
+    stations = subparsers.add_parser(
+        "stations", aliases=["s", "find", "f", "stacje", "ls", "q"], help="Allows you to find stations by their name"
+    )
+    stations.add_argument(
+        "query",
+        help="The station name",
+        default=None,
+        nargs="*",
+        action=RemainderString,
+    )
+    stations.add_argument(
+        "-t",
+        "--type",
+        help="filter results by type[rail, bus, group]",
+        type=str,
+        default=None,
+    )
+    stations.add_argument(
+        "-c",
+        "--country",
+        help="filter results by country code[pl, de, ...]",
+        type=str,
+        default=None,
+    )
+    stations.set_defaults(func=cli.find_station_view, pass_=["query", "type", "country"])
+
+    connections = subparsers.add_parser(
+        "connections",
+        aliases=["do", "z", "szukaj", "path"],
+        help="Allows you to search for connections from a to b",
+    )
+    connections.add_argument("start", help="The starting station", type=str)
+    connections.add_argument("end", help="The end station", type=str)
+    connections.add_argument(
+        "-d",
+        "--date",
+        help="the date",
+        type=lambda s: parse_datetime(s),
+        default=datetime.now(),
+    )
+    connections.add_argument(
+        "-b", "--brands", help="Brands to include", action="extend", nargs="+", type=str, default=[]
+    )
+    connections.add_argument(
+        "-n",
+        "--direct",
+        help="whether or not the result should only include direct trains",
+        action="store_true",
+        default=False,
+    )
+    connections.add_argument(
+        "-p",
+        "--include_prices",
+        help="whether or not the result should include the price",
+        action="store_true",
+        default=False,
+    )
+    connections.add_argument(
+        "--only_purchasable",
+        help="whether or not the result should include only purchasable connections",
+        action="store_true",
+        default=False,
+    )
+    connections.add_argument(
+        "-l",
+        "--length",
+        help="fetch at least n connections",
+        type=int,
+        default=1,
+    )
+    connections.set_defaults(
+        func=cli.connections_view,
+        pass_=["start", "end", "brands", "date", "direct", "include_prices", "only_purchasable", "length"],
+    )
+
+    train_passenger_stats = subparsers.add_parser(
+        "trainstats",
+        aliases=["ts", "tp", "miejsca", "frekwencja"],
+        help="Allows you to check seat allocation info for a train.",
+    )
+    train_passenger_stats.add_argument("brand", help="The brand name", type=str)
+    train_passenger_stats.add_argument("name", help="The train name", nargs="+", action=RemainderString)
+    train_passenger_stats.add_argument(
+        "-d",
+        "--date",
+        help="the date",
+        type=lambda s: parse_datetime(s),
+        default=datetime.now(),
+    )
+    train_passenger_stats.add_argument(
+        "-s", "--stations", help="A->B", action="extend", nargs=2, type=str, default=None
+    )
+    train_passenger_stats.add_argument(
+        "-t", "--type", help="limit the result to seats of a given type", type=str, required=False
+    )
+    train_passenger_stats.set_defaults(
+        func=cli.train_passenger_stats_view, pass_=["brand", "name", "date", "stations", "type"]
+    )
+
+    train_connection_stats = subparsers.add_parser(
+        "trainconnectionstats",
+        aliases=["tcs"],
+        help="Allows you to check the seat allocations on the train connection given it's koleo ID",
+    )
+    train_connection_stats.add_argument(
+        "-t", "--type", help="limit the result to seats of a given type", type=str, required=False
+    )
+    train_connection_stats.add_argument("connection_id", help="The koleo ID", type=int)
+    train_connection_stats.set_defaults(func=cli.train_connection_stats_view, pass_=["connection_id", "type"])
+
+    aliases = subparsers.add_parser("aliases", help="Save quick aliases for station names!")
+    aliases.set_defaults(func=cli.alias_list_view)
+    aliases_subparser = aliases.add_subparsers()
+    aliases_add = aliases_subparser.add_parser("add", aliases=["a"], help="add an alias")
+    aliases_add.add_argument("alias", help="The alias")
+    aliases_add.add_argument(
+        "station",
+        help="The station name",
+        nargs="*",
+        action=RemainderString,
+    )
+    aliases_add.set_defaults(func=cli.alias_add_view, pass_=["alias", "station"])
+
+    aliases_remove = aliases_subparser.add_parser("remove", aliases=["r", "rm"], help="remove an alias")
+    aliases_remove.add_argument("alias", help="The alias")
+    aliases_remove.set_defaults(func=cli.alias_remove_view, pass_=["alias"])
+
+    args = parser.parse_args()
+
+    storage = Storage.load(path=args.config)
+    client = KoleoAPI()
+
+    async def run_view(func, *args, **kwargs):
+        res = func(*args, **kwargs)
+        if isawaitable(res):
+            await res
+        await client.close()
+
+    cli.client, cli.storage = client, storage
+    cli.console.no_color = args.nocolor
+    cli.no_color = args.nocolor
+    if hasattr(args, "station") and args.station is None:
+        args.station = storage.favourite_station
+    elif hasattr(args, "station") and getattr(args, "save", False):
+        storage.favourite_station = args.station
+    if not hasattr(args, "func"):
+        if storage.favourite_station:
+            run(run_view(cli.full_departures_view, storage.favourite_station, datetime.now()))
+        else:
+            parser.print_help()
+    else:
+        run(run_view(args.func, **{k: v for k, v in args.__dict__.items() if k in getattr(args, "pass_", [])}))
+    if storage.dirty:
+        storage.save()

koleo/cli/__init__.py

@@ -0,0 +1,9 @@
+from .aliases import Aliases
+from .station_board import StationBoard
+from .connections import Connections
+from .train_info import TrainInfo
+from .seats import Seats
+from .stations import Stations
+
+
+class CLI(Aliases, StationBoard, Connections, Seats, Stations): ...

koleo/cli/aliases.py

@@ -0,0 +1,15 @@
+from .base import BaseCli
+
+
+class Aliases(BaseCli):
+    def alias_list_view(self):
+        self.print(f"[bold][green]alias[/green] → [red]station[/red][/bold]:")
+        for n, (k, v) in enumerate(self.storage.aliases.items()):
+            self.print(f"{n}. [bold][green]{k}[/green] → [red]{v}[/red][/bold]")
+
+    async def alias_add_view(self, alias: str, station: str):
+        station_obj = await self.get_station(station)
+        self.storage.add_alias(alias, station_obj["name_slug"])
+
+    def alias_remove_view(self, alias: str):
+        self.storage.remove_alias(alias)

koleo/cli/base.py

@@ -0,0 +1,103 @@
+from koleo.api import KoleoAPI
+from koleo.storage import Storage
+from koleo.api.types import ExtendedStationInfo, TrainOnStationInfo, TrainStop
+from koleo.utils import koleo_time_to_dt, name_to_slug, convert_platform_number
+
+from rich.console import Console
+import re
+
+
+class BaseCli:
+    def __init__(
+        self,
+        no_color: bool = False,
+        client: KoleoAPI | None = None,
+        storage: Storage | None = None,
+    ) -> None:
+        self._client = client
+        self._storage = storage
+        self.no_color = no_color
+        self.console = Console(color_system="standard", no_color=no_color, highlight=False)
+
+    def print(self, text: str, *args, **kwargs):
+        if not text.strip():
+            return
+        if self.no_color:
+            result = re.sub(r"\[[^\]]*\]", "", text)
+            print(result)
+        else:
+            self.console.print(text, *args, **kwargs)
+
+    async def error_and_exit(self, text: str, *args, **kwargs):
+        self.print(f"[bold red]{text}[/bold red]", *args, **kwargs)
+        await self.client.close()
+        exit(2)
+
+    @property
+    def client(self) -> KoleoAPI:
+        if not self._client:
+            raise ValueError("Client not set!")
+        return self._client
+
+    @client.setter
+    def client(self, client: KoleoAPI):
+        self._client = client
+
+    @property
+    def storage(self) -> Storage:
+        if not self._storage:
+            raise ValueError("Storage not set!")
+        return self._storage
+
+    @storage.setter
+    def storage(self, storage: Storage):
+        self._storage = storage
+
+    async def trains_on_station_table(
+        self, trains: list[TrainOnStationInfo], type: int = 1, show_connection_id: bool | None = None
+    ):
+        show_connection_id = self.storage.show_connection_id if show_connection_id is None else show_connection_id
+        brands = await self.get_brands()
+        for train in trains:
+            time, color = (train["departure"], "green") if type == 1 else (train["arrival"], "yellow")
+            assert time
+            brand = next(iter(i for i in brands if i["id"] == train["brand_id"]), {}).get("logo_text")
+            tid = (f"{train["stations"][0]["train_id"]} ") if show_connection_id else ""
+            self.print(
+                f"{tid}[bold {color}]{time[11:16]}[/bold {color}] [red]{brand}[/red] {train["train_full_name"]}[purple] {train["stations"][0]["name"]} {self.format_position(train["platform"], train["track"])}[/purple]"
+            )
+
+    def train_route_table(self, stops: list[TrainStop]):
+        last_real_distance = stops[0]["distance"]
+        for stop in stops:
+            arr = koleo_time_to_dt(stop["arrival"])
+            dep = koleo_time_to_dt(stop["departure"])
+            distance = stop["distance"] - last_real_distance
+            self.print(
+                f"[white underline]{distance / 1000:^5.1f}km[/white underline] [bold green]{arr.strftime("%H:%M")}[/bold green] - [bold red]{dep.strftime("%H:%M")}[/bold red] [purple]{stop["station_display_name"]} {self.format_position(stop["platform"])} [/purple]"
+            )
+
+    def format_position(self, platform: str, track: str | None = None):
+        res = str(convert_platform_number(platform) or "" if not self.storage.use_roman_numerals else platform)
+        if track is not None and track != "":
+            res += f"/{track}"
+        return res
+
+    async def get_station(self, station: str) -> ExtendedStationInfo:
+        if station in self.storage.aliases:
+            slug = self.storage.aliases[station]
+        else:
+            slug = name_to_slug(station)
+        try:
+            return self.storage.get_cache(f"st-{slug}") or self.storage.set_cache(
+                f"st-{slug}", await self.client.get_station_by_slug(slug)
+            )
+        except self.client.errors.KoleoNotFound:
+            await self.error_and_exit(f"Station not found: [underline]{station}[/underline]")
+
+    async def get_brands(self):
+        return self.storage.get_cache("brands") or self.storage.set_cache("brands", await self.client.get_brands())
+
+    async def get_station_by_id(self, id: int):
+        key = f"st-{id}"
+        return self.storage.get_cache(key) or self.storage.set_cache(key, await self.client.get_station_by_id(id))

koleo/cli/connections.py

@@ -0,0 +1,142 @@
+from asyncio import gather
+
+from .base import BaseCli
+from .utils import format_price
+
+from datetime import datetime, timedelta
+from koleo.api.types import ConnectionDetail
+from koleo.utils import koleo_time_to_dt
+
+
+class Connections(BaseCli):
+    async def connections_view(
+        self,
+        start: str,
+        end: str,
+        date: datetime,
+        brands: list[str],
+        direct: bool,
+        include_prices: bool,
+        only_purchasable: bool,
+        length: int = 1,
+    ):
+        start_station, end_station, api_brands = await gather(
+            self.get_station(start), self.get_station(end), self.get_brands()
+        )
+        brands = [i.lower().strip() for i in brands]
+        if not brands:
+            connection_brands = {i["name"]: i["id"] for i in api_brands}
+        else:
+            connection_brands = {
+                i["name"]: i["id"]
+                for i in api_brands
+                if i["name"].lower().strip() in brands or i["logo_text"].lower().strip() in brands
+            }
+            if not connection_brands:
+                await self.error_and_exit(f'No brands match: [underline]{', '.join(brands)}[/underline]')
+        results: list[ConnectionDetail] = []
+        fetch_date = date
+        while len(results) < length:
+            connections = await self.client.get_connections(
+                start_station["name_slug"],
+                end_station["name_slug"],
+                list(connection_brands.values()),
+                fetch_date,
+                direct,
+                only_purchasable,
+            )
+            if connections:
+                fetch_date = koleo_time_to_dt(connections[-1]["departure"]) + timedelta(seconds=(30 * 60) + 1)  # wtf
+                results.extend(connections)
+            else:
+                break
+        if include_prices:
+            res = await gather(
+                *(self.client.get_price(i["id"]) for i in results),
+            )
+            price_dict = {k: v for k, v in zip((i["id"] for i in results), res)}
+        else:
+            price_dict = {}
+        link = (
+            f"https://koleo.pl/rozklad-pkp/{start_station["name_slug"]}/{end_station["name_slug"]}"
+            + f"/{date.strftime("%d-%m-%Y_%H:%M")}"
+            + f"/{"all" if not direct else "direct"}/{"-".join(connection_brands.keys()) if brands else "all"}"
+        )
+        parts = [
+            f"[bold blue][link={link}]{start_station["name"]} → {end_station["name"]} at {date.strftime("%H:%M %d-%m")}[/link][/bold blue]"
+        ]
+
+        for i in results:
+            arr = koleo_time_to_dt(i["arrival"])
+            dep = koleo_time_to_dt(i["departure"])
+            travel_time = (arr - dep).seconds
+            date_part = f"{arr.strftime("%d-%m")} " if arr.date() != date.date() else ""
+            if price := price_dict.get(i["id"]):
+                price_str = f" [bold red]{format_price(price)}[/bold red]"
+            else:
+                price_str = ""
+            parts.append(
+                f"[bold green][link=https://koleo.pl/travel-options/{i["id"]}]{date_part}{dep.strftime("%H:%M")} - {arr.strftime("%H:%M")}[/bold green] {travel_time//3600}h{(travel_time % 3600)/60:.0f}m {i['distance']}km{price_str}:[/link]"
+            )
+            if len(i["trains"]) == 1:
+                train = i["trains"][0]
+                brand = next(iter(i for i in api_brands if i["id"] == train["brand_id"]), {}).get("logo_text")
+
+                fs = next(iter(i for i in train["stops"] if i["station_id"] == train["start_station_id"]), {})
+                fs_station = (
+                    start_station
+                    if fs["station_id"] == start_station["id"]
+                    else await self.get_station_by_id(fs["station_id"])
+                )
+
+                ls = next(iter(i for i in train["stops"] if i["station_id"] == train["end_station_id"]), {})
+                ls_station = (
+                    start_station
+                    if ls["station_id"] == start_station["id"]
+                    else await self.get_station_by_id(ls["station_id"])
+                )
+
+                parts[-1] += (
+                    f" [red]{brand}[/red] {train["train_full_name"]}[purple] {fs_station['name']} {self.format_position(fs["platform"], fs["track"])}[/purple] - [purple]{ls_station['name']} {self.format_position(ls["platform"], ls["track"])}[/purple]"
+                )
+                for constriction in i["constriction_info"]:
+                    parts.append(f" [bold red]- {constriction}[/bold red]")
+            else:
+                for constriction in i["constriction_info"]:
+                    parts.append(f" [bold red]- {constriction}[/bold red]")
+                previous_arrival: datetime | None = None
+                for train in i["trains"]:
+                    brand = next(iter(i for i in api_brands if i["id"] == train["brand_id"]), {}).get("logo_text")
+
+                    # first stop
+
+                    fs = next(iter(i for i in train["stops"] if i["station_id"] == train["start_station_id"]), {})
+                    fs_station = (
+                        start_station
+                        if fs["station_id"] == start_station["id"]
+                        else await self.get_station_by_id(fs["station_id"])
+                    )
+                    # fs_arr = arr_dep_to_dt(fs["arrival"])
+                    fs_dep = koleo_time_to_dt(fs["departure"])
+                    fs_info = f"[bold green]{fs_dep.strftime("%H:%M")} [/bold green][purple]{fs_station['name']} {self.format_position(fs["platform"], fs["track"])}[/purple]"
+
+                    # last stop
+
+                    ls = next(iter(i for i in train["stops"] if i["station_id"] == train["end_station_id"]), {})
+                    ls_station = (
+                        start_station
+                        if ls["station_id"] == start_station["id"]
+                        else self.storage.get_cache(f"st-{ls['station_id']}")
+                        or await self.get_station_by_id(ls["station_id"])
+                    )
+                    ls_arr = koleo_time_to_dt(ls["arrival"])
+                    # ls_dep = arr_dep_to_dt(ls["departure"])
+                    ls_info = f"[bold green]{ls_arr.strftime("%H:%M")} [/bold green][purple]{ls_station['name']} {self.format_position(ls["platform"], ls["track"])}[/purple]"
+                    connection_time = (fs_dep - previous_arrival).seconds if previous_arrival else ""
+                    previous_arrival = ls_arr
+                    if connection_time:
+                        parts.append(
+                            f"  {connection_time//3600}h{(connection_time % 3600)/60:.0f}m at [purple]{fs_station['name']}[/purple]"
+                        )
+                    parts.append(f"  [red]{brand}[/red] {train["train_full_name"]} {fs_info} - {ls_info}")
+        self.print("\n".join(parts))

koleo/cli/seats.py

@@ -0,0 +1,103 @@
+from .train_info import TrainInfo
+from datetime import datetime
+from asyncio import gather
+
+from koleo.api import SeatsAvailabilityResponse, SeatState
+
+from koleo.utils import BRAND_SEAT_TYPE_MAPPING, koleo_time_to_dt
+from .utils import CLASS_COLOR_MAP
+
+
+class Seats(TrainInfo):
+    async def train_passenger_stats_view(
+        self,
+        brand: str,
+        name: str,
+        date: datetime,
+        stations: tuple[str, str] | None = None,
+        type: str | None = None,
+    ):
+        train_calendars = await self.get_train_calendars(brand, name)
+        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]"
+            )
+        train_details = await self.client.get_train(train_id)
+        if train_details["train"]["brand_id"] not in BRAND_SEAT_TYPE_MAPPING:
+            await self.error_and_exit(f"Brand [underline]{brand}[/underline] is not supported.")
+        train_stops_slugs = [i["station_slug"] for i in train_details["stops"]]
+        train_stops_by_slug = {i["station_slug"]: i for i in train_details["stops"]}
+        if stations:
+            first_station, last_station = [
+                i["name_slug"] for i in await gather(*(self.get_station(i) for i in stations))
+            ]
+            if first_station not in train_stops_slugs:
+                await self.error_and_exit(
+                    f"Train [underline]{name}[/underline] doesn't stop at [underline]{first_station}[/underline]"
+                )
+            elif last_station not in train_stops_slugs:
+                await self.error_and_exit(
+                    f"Train [underline]{name}[/underline] doesn't stop at [underline]{last_station}[/underline]"
+                )
+        else:
+            first_station, last_station = train_stops_slugs[0], train_stops_slugs[-1]
+        connections = await self.client.get_connections(
+            first_station,
+            last_station,
+            brand_ids=[train_details["train"]["brand_id"]],
+            direct=True,
+            date=koleo_time_to_dt(train_stops_by_slug[first_station]["departure"], base_date=date),
+        )
+        connection = next(iter(i for i in connections if i["trains"][0]["train_id"] == train_details["train"]["id"]))
+        connection_train = connection["trains"][0]
+        if connection_train["brand_id"] not in BRAND_SEAT_TYPE_MAPPING:
+            await self.error_and_exit(f"Brand [underline]{connection_train["brand_id"]}[/underline] is not supported.")
+        await self.show_train_header(
+            train_details, train_stops_by_slug[first_station], train_stops_by_slug[last_station]
+        )
+        await self.train_seat_info(connection["id"], type, connection_train["brand_id"], connection_train["train_nr"])
+
+    async def train_connection_stats_view(self, connection_id: int, type: str | None):
+        connection = await self.client.get_connection(connection_id)
+        train = connection["trains"][0]
+        if train["brand_id"] not in BRAND_SEAT_TYPE_MAPPING:
+            await self.error_and_exit(f'Brand [underline]{train["brand_id"]}[/underline] is not supported.')
+        print(connection)
+        train_details = await self.client.get_train(train["train_id"])
+        first_stop = next(iter(i for i in train_details["stops"] if i["station_id"] == connection["start_station_id"]))
+        last_stop = next(iter(i for i in train_details["stops"] if i["station_id"] == connection["end_station_id"]))
+        await self.show_train_header(train_details, first_stop, last_stop)
+        await self.train_seat_info(connection_id, type, train["brand_id"], train["train_nr"])
+
+    async def train_seat_info(self, connection_id: int, type: str | None, brand_id: int, train_nr: int):
+        seat_name_map = BRAND_SEAT_TYPE_MAPPING[brand_id]
+        if type is not None:
+            if type.isnumeric() and int(type) in seat_name_map:
+                types = [int(type)]
+            elif type_id := {v: k for k, v in seat_name_map.items()}.get(type):
+                types = [type_id]
+            else:
+                await self.error_and_exit(f"Invalid seat type [underline]{type}[/underline].")
+        else:
+            types = seat_name_map.keys()
+        res: dict[int, SeatsAvailabilityResponse] = {}
+        for seat_type in types:
+            res[seat_type] = await self.client.get_seats_availability(connection_id, train_nr, seat_type)
+        total_seats = sum(len(i["seats"]) for i in res.values())
+        for seat_type, result in res.items():
+            counters: dict[SeatState, int] = {"FREE": 0, "RESERVED": 0, "BLOCKED": 0}
+            for seat in result["seats"]:
+                counters[seat["state"]] += 1
+            color = CLASS_COLOR_MAP.get(seat_name_map[seat_type], "")
+            self.print(f"[bold {color}]{seat_name_map[seat_type]}: [/bold {color}]")
+            total = sum(i for i in counters.values())
+            not_available = counters["BLOCKED"] + counters["RESERVED"]
+            self.print(
+                f"  Free: [{color}]{counters["FREE"]}/{total}, ~{counters["FREE"]/total*100:.1f}%[/{color}]"
+            )
+            self.print(
+                f"  Reserved: [{color}]{counters["RESERVED"]}[/{color}]"
+            )
+            self.print(
+                f"  Blocked: [underline {color}]{counters["BLOCKED"]}[/underline {color}]"
+            )