koleo-cli 0.2.137__py3-none-any.whl

koleo/__init__.py

@@ -0,0 +1,4 @@
+from .api import KoleoAPI
+
+
+__all__ = ["KoleoAPI"]

koleo/__main__.py

@@ -0,0 +1,5 @@
+from .cli import main
+
+
+if __name__ == "__main__":
+    main()

koleo/api.py

@@ -0,0 +1,150 @@
+import typing as t
+from datetime import datetime
+
+from requests import Session, PreparedRequest, Response
+
+from koleo.types import *
+
+
+class KoleoAPIException(Exception):
+    status: int
+    request: PreparedRequest
+    response: Response
+
+    def __init__(self, response: Response, *args: object) -> None:
+        super().__init__(*args)
+        self.status = response.status_code
+        self.request = response.request
+        self.response = response
+
+    @classmethod
+    def from_response(cls, response: Response) -> "KoleoAPIException":
+        if response.status_code == 404:
+            return KoleoNotFound(response)
+        elif response.status_code == 401:
+            return KoleoUnauthorized(response)
+        elif response.status_code == 403:
+            return KoleoForbidden(response)
+        elif response.status_code == 429:
+            return KoleoRatelimited(response)
+        else:
+            return KoleoAPIException(response)
+
+
+class KoleoNotFound(KoleoAPIException):
+    pass
+
+
+class KoleoForbidden(KoleoAPIException):
+    pass
+
+
+class KoleoUnauthorized(KoleoAPIException):
+    pass
+
+
+class KoleoRatelimited(KoleoAPIException):
+    pass
+
+
+class KoleoAPI:
+    def __init__(self) -> None:
+        self.session = Session()
+        self.base_url = "https://koleo.pl"
+        self.version = 2
+        self.base_headers = {
+            "x-koleo-version": str(self.version),
+            "User-Agent": "Koleo-CLI(https://pypi.org/project/koleo-cli)",
+        }
+
+    def _get(self, path, *args, **kwargs) -> Response:
+        headers = {**self.base_headers, **kwargs.get("headers", {})}
+        r = self.session.get(self.base_url + path, *args, headers=headers, **kwargs)
+        if not r.ok:
+            raise KoleoAPIException.from_response(r)
+        return r
+
+    def _get_json(self, path, *args, **kwargs) -> t.Any:
+        r = self._get(path, *args, **kwargs)
+        return r.json()
+
+    def _get_bytes(self, path, *args, **kwargs) -> bytes:
+        r = self._get(path, *args, **kwargs)
+        return r.content
+
+    def find_station(self, query: str, language: str = "pl") -> list[ExtendedStationInfo]:
+        # https://koleo.pl/ls?q=tere&language=pl
+        return self._get_json("/ls", query={"q": query, "language": language})
+
+    def get_station_by_slug(self, slug: str) -> ExtendedBaseStationInfo:
+        # https://koleo.pl/api/v2/main/stations/by_slug/inowroclaw
+        return self._get_json(
+            f"/api/v2/main/stations/by_slug/{slug}",
+        )
+
+    def get_station_info_by_slug(self, slug: str) -> StationDetails:
+        # https://koleo.pl/api/v2/main/station_info/inowroclaw
+        return self._get_json(
+            f"/api/v2/main/station_info/{slug}",
+        )
+
+    def get_departures(self, station_id: int, date: datetime) -> list[TrainOnStationInfo]:
+        # https://koleo.pl/api/v2/main/timetables/18705/2024-03-25/departures
+        return self._get_json(
+            f"/api/v2/main/timetables/{station_id}/{date.strftime("%Y-%m-%d")}/departures",
+        )
+
+    def get_arrivals(self, station_id: int, date: datetime) -> list[TrainOnStationInfo]:
+        # https://koleo.pl/api/v2/main/timetables/18705/2024-03-25/arrivals
+        return self._get_json(
+            f"/api/v2/main/timetables/{station_id}/{date.strftime("%Y-%m-%d")}/arrivals",
+        )
+
+    def get_train_calendars(self, brand_name: str, number: int, name: str | None = None) -> TrainCalendarResponse:
+        # https://koleo.pl/pl/train_calendars?brand=REG&nr=10417
+        # https://koleo.pl/pl/train_calendars?brand=IC&nr=1106&name=ESPERANTO ; WHY!!!! WHY!!!!!!1
+        params = {"brand": brand_name, "nr": number}
+        if name:
+            params["name"] = name.upper()  # WHY!!!!!!!!!
+        return self._get_json("/api/v2/main/train_calendars", params=params)
+
+    def get_train(self, id: int) -> TrainDetailResponse:
+        # https://koleo.pl/pl/trains/142821312
+        return self._get_json(f"/api/v2/main/trains/{id}")
+
+    def get_connections(
+        self,
+        start: str,
+        end: str,
+        brand_ids: list[int],
+        date: datetime,
+        direct: bool = False,
+        purchasable: bool = False
+    ) -> ...:
+        params = {
+            "query[date]": date.strftime("%d-%m-%Y %H:%M:%S"),
+            "query[start_station]": start,
+            "query[end_station]": end,
+            "query[only_purchasable]": purchasable,
+            "query[direct]": direct,
+            "query[brand_ids]": brand_ids
+        }
+        return self._get_json("/api/v2/main/connections", params=params)
+
+    def get_brands(self) -> list[ApiBrand]:
+        # https://koleo.pl/api/v2/main/brands
+        return self._get_json(
+            "/api/v2/main/brands",
+        )
+
+    def get_carriers(self) -> list[Carrier]:
+        # https://koleo.pl/api/v2/main/carriers
+        return self._get_json(
+            "/api/v2/main/carriers",
+        )
+
+    def get_discounts(self) -> list[DiscountInfo]:
+        # https://koleo.pl/api/v2/main/discounts
+        return self._get_json(
+            "/api/v2/main/discounts",
+        )

koleo/cli.py

@@ -0,0 +1,231 @@
+from datetime import datetime
+from argparse import ArgumentParser
+
+from rich.console import Console
+from rich.traceback import install
+
+from .api import KoleoAPI
+from .types import TrainOnStationInfo, TrainDetailResponse
+from .utils import name_to_slug, parse_datetime, time_dict_to_dt
+from .storage import Storage, DEFAULT_CONFIG_PATH
+
+install(show_locals=True)
+
+
+class CLI:
+    def __init__(
+        self,
+        no_color: bool = False,
+        client: KoleoAPI | None = None,
+        storage: Storage | None = None,
+    ) -> None:
+        self._client = client
+        self._storage = storage
+        self.console = Console(color_system="standard", no_color=no_color)
+
+    @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
+
+    def list_stations(self, name: str): ...
+
+    def get_departures(self, station_id: int, date: datetime):
+        trains = self.client.get_departures(station_id, date)
+        trains = [
+            i
+            for i in trains
+            if datetime.fromisoformat(i["departure"]).timestamp() > date.timestamp()  # type: ignore
+        ]
+        table = self.trains_on_station_table(trains)
+        self.console.print(table)
+        return table
+
+    def get_arrivals(self, station_id: int, date: datetime):
+        trains = self.client.get_arrivals(station_id, date)
+        trains = [
+            i
+            for i in trains
+            if datetime.fromisoformat(i["arrival"]).timestamp() > date.timestamp()  # type: ignore
+        ]
+        table = self.trains_on_station_table(trains, type=2)
+        self.console.print(table)
+        return table
+
+    def full_departures(self, station: str, date: datetime):
+        slug = name_to_slug(station)
+        st = self.storage.get_cache(f"st-{slug}") or self.storage.set_cache(
+            f"st-{slug}", self.client.get_station_by_slug(slug)
+        )
+        station_info = f"[bold blue]{st["name"]}[/bold blue] ID: {st["id"]}"
+        self.console.print(station_info)
+        self.get_departures(st["id"], date)
+
+    def full_arrivals(self, station: str, date: datetime):
+        slug = name_to_slug(station)
+        st = self.storage.get_cache(f"st-{slug}") or self.storage.set_cache(
+            f"st-{slug}", self.client.get_station_by_slug(slug)
+        )
+        station_info = f"[bold blue]{st["name"]}[/bold blue] ID: {st["id"]}"
+        self.console.print(station_info)
+        self.get_arrivals(st["id"], date)
+
+    def train_info(self, brand: str, name: str, date: datetime):
+        brand = brand.upper().strip()
+        name = name.upper().strip()
+        cache_id = f"tc-{brand}-{name}"
+        if name.isnumeric():
+            number = int(name)
+            name = ""
+        elif len(parts := name.split(" ")) == 2 or len(parts := name.split("-")) == 2:
+            number, name = parts
+            number = int(number)
+        else:
+            raise ValueError("Invalid train name!")
+        train_calendars = self.storage.get_cache(cache_id) or self.storage.set_cache(
+            cache_id, self.client.get_train_calendars(brand, number, name)
+        )
+        brands = self.storage.get_cache("brands") or self.storage.set_cache("brands", self.client.get_brands())
+        train_id = train_calendars["train_calendars"][0]["date_train_map"][date.strftime("%Y-%m-%d")]
+        train_details = self.client.get_train(train_id)
+        brand = next(iter(i for i in brands if i["id"] == train_details["train"]["brand_id"]), {}).get("name", "")
+        data = f"{brand} {train_details["train"]["train_full_name"]}\n"
+        vehicle_types: dict[str, str] = {
+            stop["station_display_name"]: stop["vehicle_type"]
+            for stop in train_details["stops"]
+            if stop["vehicle_type"]
+        }
+        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]:
+                    data += f"[bold green]  {start} - {keys[i]}:[/bold green] {vehicle_types[start]}\n"
+                    start = keys[i]
+            data += f"[bold green]  {start} - {keys[-1]}:[/bold green] {vehicle_types[start]}"
+        self.console.print(data)
+        self.console.print(self.train_route_table(train_details))
+
+    def route(self, start: str, end: str, date: datetime, direct: bool = False, purchasable: bool = False):
+        slug = name_to_slug(station)
+        st = self.storage.get_cache(f"st-{slug}") or self.storage.set_cache(
+            f"st-{slug}", self.client.get_station_by_slug(slug)
+        )
+        station_info = f"[bold blue]{st["name"]}[/bold blue] ID: {st["id"]}"
+        self.console.print(station_info)
+        self.get_arrivals(st["id"], date)
+
+    def trains_on_station_table(self, trains: list[TrainOnStationInfo], type: int = 1):
+        parts = []
+        brands = self.storage.get_cache("brands") or self.storage.set_cache("brands", self.client.get_brands())
+        for train in trains:
+            time = train["departure"] if type == 1 else train["arrival"]
+            assert time
+            brand = next(iter(i for i in brands if i["id"] == train["brand_id"]), {}).get("name")
+            parts.append(
+                f"[bold green]{time[11:16]}[/bold green] {brand} {train["train_full_name"]}[purple] {train["stations"][0]["name"]} [/purple]"
+            )
+        return "\n".join(parts)
+
+    def train_route_table(self, train: TrainDetailResponse):
+        parts = []
+        for stop in train["stops"]:
+            arr = time_dict_to_dt(stop["arrival"])
+            dep = time_dict_to_dt(stop["departure"])
+            parts.append(
+                f"[white underline]{stop["distance"] / 1000:0.4}km[/white underline] [bold green]{arr.strftime("%H:%M")}[/bold green] - [bold red]{dep.strftime("%H:%M")}[/bold red] [purple] {stop["station_display_name"]} {stop["platform"]} [/purple]"
+            )
+        return "\n".join(parts)
+
+
+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", action="store_true", default=False)
+    subparsers = parser.add_subparsers(title="actions", required=False)
+
+    departures = subparsers.add_parser("departures", aliases=["d", "dep"], help="Allows you to list station departures")
+    departures.add_argument(
+        "station",
+        help="The station name",
+        default=None,
+        nargs="?",
+    )
+    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, pass_=["station", "date"])
+
+    arrivals = subparsers.add_parser("arrivals", aliases=["a", "arr"], help="Allows you to list station departures")
+    arrivals.add_argument(
+        "station",
+        help="The station name",
+        default=None,
+        nargs="?",
+    )
+    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, pass_=["station", "date"])
+
+    train_route = subparsers.add_parser(
+        "trainroute",
+        aliases=["r", "tr", "t"],
+        help="Allows you to show the train's route",
+    )
+    train_route.add_argument("brand", help="The brand name", type=str)
+    train_route.add_argument("name", help="The train name", type=str)
+    train_route.add_argument(
+        "-d",
+        "--date",
+        help="the date",
+        type=lambda s: parse_datetime(s),
+        default=datetime.now(),
+    )
+    train_route.set_defaults(func=cli.train_info, pass_=["brand", "name", "date"])
+
+    args = parser.parse_args()
+
+    storage = Storage.load(path=args.config)
+    client = KoleoAPI()
+    cli.client, cli.storage = client, storage
+    cli.console.no_color = args.nocolor
+    if hasattr(args, "station") and args.station is None:
+        args.station = storage.favourite_station
+    elif hasattr(args, "station") and args.save:
+        storage.favourite_station = args.station
+        storage.save()
+    if not hasattr(args, "func"):
+        if storage.favourite_station:
+            cli.full_departures(storage.favourite_station, datetime.now())
+        else:
+            raise ValueError("favourite station not set!")
+    else:
+        args.func(**{k: v for k, v in args.__dict__.items() if k in getattr(args, "pass_", [])})

koleo/storage.py

@@ -0,0 +1,71 @@
+import typing as t
+from time import time
+from dataclasses import dataclass, asdict, field
+from sys import platform
+from json import dump, load
+from os import makedirs, path as ospath
+
+
+def get_adequate_config_path():
+    if platform == "darwin":
+        # i dont fucking know nor want to
+        return "~/Library/Preferences/koleo-cli/data.json"
+    elif "win" in platform:
+        # same with this
+        return "%USERPROFILE%\\AppData\\Local\\koleo-cli\\data.json"
+    else:
+        return "~/.config/koleo-cli.json"
+
+
+DEFAULT_CONFIG_PATH = get_adequate_config_path()
+
+
+T = t.TypeVar("T")
+
+
+@dataclass
+class Storage:
+    favourite_station: str | None = None
+    last_searched_connections: list[tuple[str, str]] = field(default_factory=list)
+    last_searched_stations: list[str] = field(default_factory=list)
+    cache: dict[str, tuple[int, t.Any]] = field(default_factory=dict)
+
+    def __post_init__(self):
+        self._path: str
+
+    @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)
+        else:
+            data = {}
+        storage = cls(**data)
+        storage._path = path
+        return storage
+
+    def get_cache(self, id: str) -> t.Any | None:
+        cache_result = self.cache.get(id)
+        if not cache_result:
+            return
+        expiry, item = cache_result
+        if expiry > time():
+            return item
+        else:
+            self.cache.pop(id)
+            self.save()
+
+    def set_cache(self, id: str, item: T, ttl: int = 86400) -> T:
+        self.cache[id] = (int(time() + ttl), item)
+        self.save()
+        return item
+
+    def save(self):
+        expanded = ospath.expanduser(self._path)
+        dir = ospath.dirname(expanded)
+        if dir:
+            if not ospath.exists(dir):
+                makedirs(dir)
+        with open(expanded, "w+") as f:
+            dump(asdict(self), f)

koleo/types.py

@@ -0,0 +1,177 @@
+import typing as t
+
+
+class BaseStationInfo(t.TypedDict):
+    id: int
+    name: str
+    name_slug: str
+
+
+# i want to kms
+class ExtendedBaseStationInfo(BaseStationInfo):
+    hits: int
+    version: str  # "A", "B"
+    is_group: bool
+    region: str
+    country: str
+    latitude: float
+    longitued: float
+
+
+class ExtendedStationInfo(BaseStationInfo):
+    ibnr: int
+    localised_name: str
+    on_demand: bool
+
+
+class StationBannerClockHandsPositon(t.TypedDict):
+    x: float
+    y: float
+
+
+class StationBannerClockHands(t.TypedDict):
+    url: str | None
+    position: StationBannerClockHandsPositon
+
+
+class StationBannerClock(t.TypedDict):
+    visible: bool | None
+    hands: StationBannerClockHands
+
+
+class StationBanner(t.TypedDict):
+    url: str
+    clock: StationBannerClock
+
+
+class Address(t.TypedDict):
+    full: str
+    zip: str
+
+
+class Feature(t.TypedDict):
+    id: str
+    name: str
+    available: bool
+
+
+class StationOpeningHours(t.TypedDict):
+    day: int  # 0-6
+    open: str  # 00:00
+    close: str  # 24:00
+
+
+class StationDetails(t.TypedDict):
+    banner: StationBanner
+    address: Address
+    lat: float
+    lon: float
+    opening_hours: list[StationOpeningHours]
+    features: list[Feature]
+
+
+class StationLocalizedToTrain(BaseStationInfo):
+    train_id: int
+
+
+class ApiBrand(t.TypedDict):
+    id: int
+    name: str  # EIC, IC, IR, REG, ...
+    display_name: str
+    logo_text: str
+    color: str  # hex
+    carrier_id: int
+
+
+class Carrier(t.TypedDict):
+    id: int
+    name: str  # Koleje Dolnośląskie, POLREGIO
+    short_name: str  # KD, PR
+    slug: str
+    legal_name: str  # PKP Szybka Kolej Miejska w Trójmieście Sp.z o.o.
+
+
+class DiscountInfo(t.TypedDict):
+    id: int
+    passenger_percentage: int
+    display_passenger_percentage: float
+    flyer_second_class_percentage: int
+    flyer_first_class_percentage: int
+    express_second_class_percentage: int
+    express_first_class_percentage: int
+    dependent_on_ids: list[int]
+    name: str
+    rank: int
+    season_passenger_percentage: int
+    displayable: bool
+    is_company: bool
+
+
+class TrainOnStationInfo(t.TypedDict):
+    arrival: str | None  # first station
+    departure: str | None  # last station
+    stations: list[StationLocalizedToTrain]
+    train_full_name: str
+    brand_id: int
+    platform: str  # could be empty; some countries dont use arabic numerals or even tracks
+    track: str  # could be empty; some countries dont use arabic numerals or even tracks
+
+
+class TrainCalendar(t.TypedDict):
+    id: int
+    train_nr: int
+    train_name: str
+    trainBrand: int
+    dates: list[str]  # Y-M-D
+    train_ids: list[int]
+    date_train_map: dict[str, int]
+
+
+class TrainCalendarResponse(t.TypedDict):
+    train_calendars: list[TrainCalendar]
+
+
+class TimeDict(t.TypedDict):
+    hour: int
+    minute: int
+    second: int
+
+
+TrainAttribute = t.Tuple[int, str, str, str, bool, str]
+
+
+class TrainDetail(t.TypedDict):
+    id: int
+    train_nr: int
+    name: str | None
+    train_full_name: str
+    run_desc: str  # "09.09-15.09 - w pt - nd; 16.09-29.09, 14.10-03.11 - codziennie; 30.09-06.10 - w pn; 07.10-13.10 - we wt - nd; 04.11-10.11 - w pn - sb"
+    carrier_id: int
+    brand_id: int
+    train_name: int  # wtf
+    duration_offset: int  # wtf?
+    db_train_nr: int  # lol
+
+
+class TrainStop(t.TypedDict):
+    id: int
+    station_id: int
+    station_name: str
+    station_slug: str
+    train_id: int
+    arrival: TimeDict
+    departure: TimeDict
+    position: int  # the stop nr
+    train_nr: int | None
+    brand_id: int
+    distance: int  # meters
+    entry_only: bool
+    exit_only: bool
+    station_display_name: str
+    platform: str
+    vehicle_type: str | None  # ED161
+
+
+class TrainDetailResponse(t.TypedDict):
+    train: TrainDetail
+    stops: list[TrainStop]

koleo/utils.py

@@ -0,0 +1,41 @@
+from datetime import datetime, time
+
+from .types import TimeDict
+
+
+def parse_datetime(s: str):
+    now = datetime.today()
+    try:
+        dt = datetime.strptime(s, "%d-%m")
+        return dt.replace(year=now.year, hour=0, minute=0)
+    except ValueError:
+        pass
+    try:
+        return datetime.strptime(s, "%Y-%m-%d").replace(hour=0, minute=0)
+    except ValueError:
+        pass
+    return datetime.combine(now, datetime.strptime(s, "%H:%M").time())
+
+
+def time_dict_to_dt(s: TimeDict):
+    now = datetime.today()
+    return datetime.combine(now, time(s["hour"], s["minute"], s["second"]))
+
+
+TRANSLITERATIONS = {
+    "ł": "l",
+    "ń": "n",
+    "ą": "a",
+    "ę": "e",
+    "ś": "s",
+    "ć": "c",
+    "ó": "o",
+    "ź": "z",
+    "ż": "z",
+    " ": "-",
+    "_": "-",
+}
+
+
+def name_to_slug(name: str) -> str:
+    return "".join([TRANSLITERATIONS.get(char, char) for char in name.lower()])

koleo_cli-0.2.137.dist-info/METADATA

@@ -0,0 +1,18 @@
+Metadata-Version: 2.1
+Name: koleo-cli
+Version: 0.2.137
+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
+Requires-Dist: rich==13.7.1
+Requires-Dist: requests==2.31.0
+

koleo_cli-0.2.137.dist-info/RECORD

@@ -0,0 +1,12 @@
+koleo/__init__.py,sha256=ChPpKyc4vrcgWj-Uk_ZlDw32s_7iFpE3f1FTAd6zxPY,51
+koleo/__main__.py,sha256=wu5N2wk8mvBgyvr2ghmQf4prezAe0_i-p123VVreyYc,62
+koleo/api.py,sha256=8aYn4SsavjOx9cPHLgSlwVmbZaZWJNYpIL3lZPuvdTk,5070
+koleo/cli.py,sha256=fd1O_gO5EF-7BrrLe79j7fn7SEKr5yLgWu33UIjLghM,9230
+koleo/storage.py,sha256=uCh6edwizAuw1z_Ti5AXvDan2pJAJBSobCVmYw096F8,2015
+koleo/types.py,sha256=8mAsRdNh3jMJwAV5KnHVvDQAekhs0N70EVem4p_w18o,3760
+koleo/utils.py,sha256=MYfeQkk9spT2lmlFVsHlpzgnAf0hqN-gKEbgYASqW6U,904
+koleo_cli-0.2.137.dist-info/METADATA,sha256=-PLG8A9e3iD-az9tyrdJEitqThaZrBkOhiWHWuMSPXk,624
+koleo_cli-0.2.137.dist-info/WHEEL,sha256=cVxcB9AmuTcXqmwrtPhNK88dr7IR_b6qagTj0UvIEbY,91
+koleo_cli-0.2.137.dist-info/entry_points.txt,sha256=LtCidkVDq8Zd7-fxpRbys1Xa9LTHMZwXVbdcQEscdes,41
+koleo_cli-0.2.137.dist-info/top_level.txt,sha256=AlWdXotkRYzHpFfOBYi6xOXl1H0zq4-tqtZ2XivoWB4,6
+koleo_cli-0.2.137.dist-info/RECORD,,

koleo_cli-0.2.137.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (74.1.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

koleo_cli-0.2.137.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+koleo = koleo.cli:main

koleo_cli-0.2.137.dist-info/top_level.txt

@@ -0,0 +1 @@
+koleo