koleo-cli 0.2.137.12__tar.gz → 0.2.137.25__tar.gz

koleo_cli-0.2.137.25/MANIFEST.in

@@ -0,0 +1 @@
+include requirements.txt

koleo_cli-0.2.137.25/PKG-INFO

@@ -0,0 +1,103 @@
+Metadata-Version: 2.4
+Name: koleo-cli
+Version: 0.2.137.25
+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!
+```

koleo_cli-0.2.137.25/README.md

@@ -0,0 +1,70 @@
+# 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!
+```

{koleo_cli-0.2.137.12 → koleo_cli-0.2.137.25}/koleo/__init__.py

@@ -1,2 +1,2 @@
 from .api import KoleoAPI
-from .types import *
+from .api.types import *

{koleo_cli-0.2.137.12 → koleo_cli-0.2.137.25}/koleo/__main__.py

@@ -1,4 +1,4 @@
-from .cli import main
+from .args import main
 
 
 if __name__ == "__main__":

koleo_cli-0.2.137.25/koleo/api/__init__.py

@@ -0,0 +1,2 @@
+from .client import KoleoAPI
+from .types import *

koleo_cli-0.2.137.25/koleo/api/base.py

@@ -0,0 +1,70 @@
+from asyncio import sleep as asleep
+
+from aiohttp import (
+    ClientConnectorError,
+    ClientOSError,
+    ClientResponse,
+    ClientResponseError,
+    ClientSession,
+)
+from orjson import loads
+
+from .logging import LoggingMixin
+
+
+class JsonableData(bytes):
+    response: ClientResponse
+
+    def __new__(cls, *args, response: ClientResponse, **kwargs):
+        obj = super().__new__(cls, *args, **kwargs)
+        obj.response = response
+        return obj
+
+    def json(self):
+        if "_json" not in self.__dict__:
+            self._json = loads(bytes(self))
+        return self._json
+
+
+class BaseAPIClient(LoggingMixin):
+    _session: ClientSession
+
+    exc = ClientResponseError
+
+    @property
+    def session(self) -> "ClientSession":
+        if not hasattr(self, "_session"):
+            self._session = ClientSession()
+        return self._session
+
+    async def close(self):
+        return await self.session.close()
+
+    async def exc_getter(self, r: ClientResponse) -> Exception | None:
+        return
+
+    async def request(self, method, url: str, *args, retries: int = 4, fail_wait: float = 8, **kwargs) -> JsonableData:
+        try:
+            async with self.session.request(method, url, *args, **kwargs) as r:
+                if not r.ok:
+                    self.dl(r.headers)
+                    try:
+                        self.dl(await r.text())
+                    except UnicodeDecodeError:
+                        self.dl("Response is not text!")
+                    if exc := (await self.exc_getter(r)):
+                        raise exc
+                    r.raise_for_status()
+                return JsonableData(await r.read(), response=r)
+        except (ClientConnectorError, ClientOSError) as e:
+            if retries > 0:
+                await asleep(fail_wait)
+                return await self.request(
+                    method,
+                    url,
+                    *args,
+                    retries=retries - 1,
+                    fail_wait=fail_wait,
+                    **kwargs,
+                )
+            raise e

koleo_cli-0.2.137.25/koleo/api/client.py

@@ -0,0 +1,275 @@
+import typing as t
+from datetime import datetime
+
+from aiohttp import ClientResponse
+
+from koleo.api.types import *
+
+from .base import BaseAPIClient
+from .errors import errors
+
+
+class KoleoAPI(BaseAPIClient):
+    errors = errors
+
+    def __init__(self, auth: dict[str, str] | None = None) -> None:
+        self.base_url = "https://api.koleo.pl"
+        self.version = 2
+        self.base_headers = {
+            "x-koleo-version": str(self.version),
+            "x-koleo-client": "Nuxt-1",
+            "User-Agent": "Koleo-CLI(https://pypi.org/project/koleo-cli)",
+        }
+        self._auth: dict[str, str] | None = auth
+        self._auth_valid: bool | None = None
+
+    async def get(self, path: str, use_auth: bool = False, *args, **kwargs):
+        headers = {**self.base_headers, **kwargs.pop("headers", {})}
+        if self._auth and use_auth:
+            headers["cookie"] = "; ".join([f"{k}={v}" for k, v in self._auth.items()])
+        r = await self.request(
+            "GET", self.base_url + path if not path.startswith("http") else path, headers=headers, *args, **kwargs
+        )
+        if len(r) == 0:
+            raise self.errors.KoleoNotFound(r.response)
+        return r
+
+    async def post(self, path, use_auth: bool = False, *args, **kwargs):
+        headers = {**self.base_headers, **kwargs.pop("headers", {})}
+        if self._auth and use_auth:
+            headers["cookie"] = ("; ".join([f"{k}={v}" for k, v in self._auth.items()]),)
+        r = await self.request(
+            "POST", self.base_url + path if not path.startswith("http") else path, headers=headers, *args, **kwargs
+        )
+        if len(r) == 0:
+            raise self.errors.KoleoNotFound(r.response)
+        return r
+
+    async def put(self, path, use_auth: bool = False, *args, **kwargs):
+        headers = {**self.base_headers, **kwargs.pop("headers", {})}
+        if self._auth and use_auth:
+            headers["cookie"] = ("; ".join([f"{k}={v}" for k, v in self._auth.items()]),)
+        r = await self.request("PUT", self.base_url + path, headers=headers, *args, **kwargs)
+        if len(r) == 0:
+            raise self.errors.KoleoNotFound(r.response)
+        return r
+
+    async def exc_getter(self, r: ClientResponse) -> Exception | None:
+        return await self.errors.from_response(r)
+
+    async def _require_auth(self) -> t.Literal[True]:
+        if self._auth is None:
+            raise errors.AuthRequired()
+        if self._auth_valid is None:
+            await self.get_current_session()
+            self._auth_valid = True
+        return True
+
+    async def get_stations(self) -> list[ExtendedStationInfo]:
+        return (await self.get("/v2/main/stations")).json()
+
+    async def find_station(self, query: str, language: str = "pl") -> list[SearchStationInfo]:
+        # https://koleo.pl/ls?q=tere&language=pl
+        return (await self.get("/ls", params={"q": query, "language": language})).json()["stations"]
+
+    async def get_station_by_id(self, id: int) -> ExtendedStationInfo:
+        # https://koleo.pl/api/v2/main/stations/by_id/24000
+        return (
+            await self.get(
+                f"/v2/main/stations/by_id/{id}",
+            )
+        ).json()
+
+    async def get_station_by_slug(self, slug: str) -> ExtendedStationInfo:
+        # https://koleo.pl/api/v2/main/stations/by_slug/inowroclaw
+        return (
+            await self.get(
+                f"/v2/main/stations/by_slug/{slug}",
+            )
+        ).json()
+
+    async def get_station_info_by_slug(self, slug: str) -> StationDetails:
+        # https://koleo.pl/api/v2/main/station_info/inowroclaw
+        return (
+            await self.get(
+                f"/v2/main/station_info/{slug}",
+            )
+        ).json()
+
+    async def get_departures(self, station_id: int, date: datetime) -> list[TrainOnStationInfo]:
+        # https://koleo.pl/api/v2/main/timetables/18705/2024-03-25/departures
+        return (
+            await self.get(
+                f"/v2/main/timetables/{station_id}/{date.strftime("%Y-%m-%d")}/departures",
+            )
+        ).json()
+
+    async def get_arrivals(self, station_id: int, date: datetime) -> list[TrainOnStationInfo]:
+        # https://koleo.pl/api/v2/main/timetables/18705/2024-03-25/arrivals
+        return (
+            await self.get(
+                f"/v2/main/timetables/{station_id}/{date.strftime("%Y-%m-%d")}/arrivals",
+            )
+        ).json()
+
+    async 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 (await self.get("https://koleo.pl/pl/train_calendars", params=params)).json()
+
+    async def get_train(self, id: int) -> TrainDetailResponse:
+        # https://koleo.pl/pl/trains/142821312
+        return (await self.get(f"https://koleo.pl/pl/trains/{id}")).json()
+
+    async def get_connections(
+        self,
+        start: str,
+        end: str,
+        brand_ids: list[int],
+        date: datetime,
+        direct: bool = False,
+        purchasable: bool = False,
+    ) -> list[ConnectionDetail]:
+        params = {
+            "query[date]": date.strftime("%d-%m-%Y %H:%M:%S"),
+            "query[start_station]": start,
+            "query[end_station]": end,
+            "query[only_purchasable]": str(purchasable).lower(),
+            "query[only_direct]": str(direct).lower(),
+            "query[brand_ids][]": brand_ids,
+        }
+        return (await self.get("/v2/main/connections", params=params)).json()["connections"]
+
+    async def get_connection(self, id: int) -> ConnectionDetail:
+        return (
+            await self.get(
+                f"/v2/main/connections/{id}",
+            )
+        ).json()
+
+    async def get_brands(self) -> list[ApiBrand]:
+        # https://koleo.pl/api/v2/main/brands
+        return (
+            await self.get(
+                "/v2/main/brands",
+            )
+        ).json()
+
+    async def get_carriers(self) -> list[Carrier]:
+        # https://koleo.pl/api/v2/main/carriers
+        return (
+            await self.get(
+                "/v2/main/carriers",
+            )
+        ).json()
+
+    async def get_discounts(self) -> list[DiscountInfo]:
+        # https://koleo.pl/api/v2/main/discounts
+        return (
+            await self.get(
+                "/v2/main/discounts",
+            )
+        ).json()
+
+    async def get_nested_train_place_types(self, connection_id: int) -> SeatsAvailabilityResponse:
+        # https://koleo.pl/api/v2/main/seats_availability/connection_id/train_nr/place_type
+        await self._require_auth()
+        if self._auth and "_koleo_token" not in self._auth:
+            res = await self.post(f"/prices/{connection_id}/passengers")
+            self._auth["_koleo_token"] = koleo_token = res.response.cookies["_koleo_token"].value
+        return (
+            await self.get(
+                f"/v2/main/nested_train_place_types/{connection_id}",
+                headers={"Authorization": f"Bearer {koleo_token}"},
+                use_auth=True,
+            )
+        ).json()
+
+    async def get_seats_availability(
+        self, connection_id: int, train_nr: int, place_type: int
+    ) -> SeatsAvailabilityResponse:
+        # https://koleo.pl/api/v2/main/seats_availability/connection_id/train_nr/place_type
+        return (
+            await self.get(
+                f"/v2/main/seats_availability/{connection_id}/{train_nr}/{place_type}",
+            )
+        ).json()
+
+    async def get_train_composition(
+        self, connection_id: int, train_nr: int, place_type: int
+    ) -> SeatsAvailabilityResponse:
+        # https://koleo.pl/api/v2/main/train_composition/connection_id/train_nr/place_type
+        return (
+            await self.get(
+                f"/v2/main/train_composition/{connection_id}/{train_nr}/{place_type}",
+            )
+        ).json()
+
+    async def get_carriage_type(self, id: int) -> CarriageType:
+        # https://koleo.pl/api/v2/main/carriage_types/id
+        return (
+            await self.get(
+                f"/v2/main/carriage_types/{id}",
+            )
+        ).json()
+
+    async def get_carriage_types(self) -> list[CarriageType]:
+        return (await self.get("/v2/main/carriage_types")).json()
+
+    async def get_station_keywoards(self) -> list[StationKeyword]:
+        return (await self.get("/v2/main/station_keywords")).json()
+
+    async def get_price(self, connection_id: int) -> Price | None:
+        res = await self.get(
+            f"https://koleo.pl/pl/prices/{connection_id}",
+        )
+        return res.json().get("price")
+
+    async def get_current_session(self) -> CurrentSession:
+        return (await self.get("/sessions/current", use_auth=True)).json()
+
+    async def get_current_user(self) -> CurrentUser:
+        return (await self.get("/users/current", use_auth=True)).json()
+
+    async def v3_connection_search(
+        self,
+        start_station_id: int,
+        end_station_id: int,
+        brand_ids: list[int],
+        date: datetime,
+        direct: bool = False,
+    ) -> list[V3ConnectionResult]:
+        data = {
+            "start_id": start_station_id,
+            "end_id": end_station_id,
+            "departure_after": date.isoformat(),
+            "only_direct": direct,
+        }
+        if brand_ids:
+            data["allowed_brands"] = brand_ids
+        return (
+            await self.post("/v2/main/eol_connections/search", json=data, headers={"accept-eol-response-version": "1"})
+        ).json()
+
+    async def v3_get_price(self, id: str) -> V3Price | None:
+        try:
+            return (await self.get(f"/v2/main/eol_connections/{id}/price")).json()
+        except self.errors.KoleoNotFound:
+            return None
+
+    async def get_carrier_lines(self, carrier_slug: str) -> list[CarrierLine]:
+        return (await self.get(f"/v2/main/carrier_lines/{carrier_slug}")).json()["list"]
+
+    async def v3_get_connection_id(self, id: str) -> int:
+        return (await self.put(f"/v2/main/eol_connections/{id}/connection_id")).json()["connection_id"]
+
+    async def get_train_attributes(self) -> list[TrainAttribute]:
+        # https://koleo.pl/api/v2/main/train_atributes
+        return (
+            await self.get(
+                "/v2/main/train_attributes",
+            )
+        ).json()

koleo_cli-0.2.137.25/koleo/api/errors.py

@@ -0,0 +1,46 @@
+from typing import TYPE_CHECKING
+
+
+if TYPE_CHECKING:
+    from aiohttp import ClientResponse, RequestInfo
+
+
+class errors:
+    class KoleoAPIException(Exception):
+        status: int
+        request: "RequestInfo"
+        response: "ClientResponse"
+
+        def __init__(self, response: "ClientResponse", *args: object) -> None:
+            super().__init__(*args)
+            self.status = response.status
+            self.request = response.request_info
+            self.response = response
+
+    @staticmethod
+    async def from_response(response: "ClientResponse") -> "KoleoAPIException":
+        if response.status == 404:
+            return errors.KoleoNotFound(response)
+        elif response.status == 401:
+            return errors.KoleoUnauthorized(response)
+        elif response.status == 403:
+            return errors.KoleoForbidden(response)
+        elif response.status == 429:
+            return errors.KoleoRatelimited(response)
+        else:
+            return errors.KoleoAPIException(response, await response.text())
+
+    class KoleoNotFound(KoleoAPIException):
+        pass
+
+    class KoleoForbidden(KoleoAPIException):
+        pass
+
+    class KoleoUnauthorized(KoleoAPIException):
+        pass
+
+    class KoleoRatelimited(KoleoAPIException):
+        pass
+
+    class AuthRequired(Exception):
+        pass

koleo_cli-0.2.137.25/koleo/api/logging.py

@@ -0,0 +1,56 @@
+import logging
+
+
+class LoggingMixin:
+    _l: logging.Logger
+    _l_name: str | None = None
+
+    def __init__(self, name: str | None = None) -> None:
+        if name:
+            self._l_name = name
+
+    @property
+    def logger(self) -> logging.Logger:
+        if not getattr(self, "_l", None):
+            self._l = logging.getLogger(self.logger_name)
+        return self._l
+
+    @property
+    def logger_name(self) -> str:
+        return getattr(self, "_l_name", None) or self.__class__.__name__.lower()
+
+    def dl(self, msg, *args, **kwargs):
+        self.logger.debug(msg, *args, **kwargs)
+
+    def error(self, msg, *args, **kwargs):
+        self.logger.error(msg, *args, **kwargs)
+
+    def warn(self, msg, *args, **kwargs):
+        self.logger.warning(msg, *args, **kwargs)
+
+    def info(self, msg, *args, **kwargs):
+        self.logger.info(msg, *args, **kwargs)
+
+    def create_logging_context(self, prefix: str) -> "ContextLogger":
+        return ContextLogger(self.logger, prefix)
+
+
+class ContextLogger:
+    def __init__(self, logger: logging.Logger, prefix: str) -> None:
+        self.logger = logger
+        self.prefix = prefix
+
+    def _make_msg(self, msg: str):
+        return f"{self.prefix}: {msg}"
+
+    def dl(self, msg, *args, **kwargs):
+        self.logger.debug(self._make_msg(msg), *args, **kwargs)
+
+    def info(self, msg, *args, **kwargs):
+        self.logger.info(self._make_msg(msg), *args, **kwargs)
+
+    def error(self, msg, *args, **kwargs):
+        self.logger.error(self._make_msg(msg), *args, **kwargs)
+
+    def warn(self, msg, *args, **kwargs):
+        self.logger.warning(self._make_msg(msg), *args, **kwargs)