heathrow 0.2__py3-none-any.whl

heathrow/bencode.py

@@ -0,0 +1,92 @@
+Bencodable = dict | str | int | bytes | tuple
+def bencode(data: Bencodable) -> bytes:
+    if isinstance(data, bytes):
+        return f"{len(data)}:".encode() + data
+    if isinstance(data, str):
+        return f"{len(data.encode())}:{data}".encode()
+    if isinstance(data, int):
+        return f"i{str(data)}e".encode()
+    if isinstance(data, tuple):
+        list_string = b"l"
+        for i in data:
+            list_string += bencode(i)
+        list_string += b"e"
+        return list_string
+    if isinstance(data, dict):
+        keys = sorted(data.keys())
+        dict_string = b"d"
+        for key in keys:
+            dict_string += bencode(key)
+            dict_string += bencode(data[key])
+        dict_string += b"e"
+        return dict_string
+
+def _bdecode_string(raw: bytes) -> tuple[bytes, int]:
+    strlen = int(raw.split(b":", 1)[0])
+    length = strlen + 1 + raw.find(b":")
+    result = raw[raw.find(b":")+1:raw.find(b":")+1+strlen]
+    return result, length
+
+def _bdecode_int(raw: bytes) -> tuple[int, int]:
+    if raw.startswith(b"i0") and not raw.startswith(b"i0e"):
+        raise ValueError("Cannot parse leading zero in integer")
+    if raw.startswith(b"i-0"):
+        raise ValueError("Cannot parse negative zero in integer")
+    result = int(raw[1:raw.find(b"e")])
+    return result, raw.find(b"e") + 1
+
+def _bdecode_list(raw: bytes) -> tuple[tuple, int]:
+    result = []
+    wip_raw = raw[1:]
+    total_strlen = 1
+    while wip_raw[0:1] != b"e":
+        step, strlen = _bdecode(wip_raw)
+        wip_raw = wip_raw[strlen:]
+        result.append(step)
+        total_strlen += strlen
+    return tuple(result), total_strlen + 1
+
+def _bdecode_dict(raw: bytes) -> tuple[dict, int]:
+    result = {}
+    wip_raw = raw[1:]
+    total_strlen = 1
+    keys_list = []
+    while wip_raw[0:1] != b"e":
+        key, strlen = _bdecode(wip_raw)
+        keys_list.append(key)
+        wip_raw = wip_raw[strlen:]
+        total_strlen += strlen
+        val, strlen = _bdecode(wip_raw)
+        wip_raw = wip_raw[strlen:]
+        total_strlen += strlen
+        result[key] = val
+    if keys_list != sorted(keys_list):
+        raise ValueError(f"Bencoded dictionary {raw[:total_strlen+1]} not sorted")
+    return result, total_strlen + 1
+
+def _bdecode(raw: bytes) -> tuple[Bencodable, int]:
+    if raw[0] in b"1234567890":
+        return _bdecode_string(raw)
+    elif raw[0:1] == b"i":
+        return _bdecode_int(raw)
+    elif raw[0:1] == b"l":
+        return _bdecode_list(raw)
+    elif raw[0:1] == b"d":
+        return _bdecode_dict(raw)
+    else:
+        raise ValueError(f"Unknown header in byte string b\"{chr(raw[0])}\"")
+
+def bdecode_start(raw: bytes) -> tuple[Bencodable, bytes]:
+    """Decode a bencoded bytestring, possibly with some data attached to the tail.
+
+    Return a tuple (decoded, tail).
+    """
+    res, length = _bdecode(raw)
+    return res, raw[length:]
+
+def bdecode(raw: bytes) -> Bencodable:
+    """Decode a bencoded bytestring."""
+    res, length = _bdecode(raw)
+    if length != len(raw):
+        raise ValueError("Malformed bencoded data")
+    return res

heathrow/bitset.py

@@ -0,0 +1,94 @@
+
+class Bitset:
+    """A bitset. Limited in length"""
+    def __init__(self, length: int):
+        self._bitset = 0
+        self._length = length
+
+    def __len__(self):
+        return self._length
+
+    def __setitem__(self, index: int, val: bool):
+        if index < 0:
+            index = self._length - index
+        if not 0 <= index < self._length:
+            raise IndexError
+        if val:
+            self._bitset |= (1 << (len(self) - 1 - index))
+        else:
+            self._bitset &= (1 << len(self)) - 1 - (1 << (len(self) - 1 - index))
+
+    def __getitem__(self, index: int | slice):
+        if isinstance(index, slice):
+            start = index.start if index.start is not None else 0
+            stop = index.stop if index.stop is not None else self._length
+            step = index.step if index.step is not None else 1
+
+            start = start if start >= 0 else self._length + start
+            stop = stop if stop >= 0 else self._length + stop
+
+            if start >= stop:
+                return Bitset(length=0)
+
+            # We don't need this
+            if step != 1:
+                raise IndexError("Cannot efficiently iterate with step not equal to 1")
+
+            result = Bitset(stop - start)
+            value = (self._bitset >> (self._length - stop)) & ((1 << (stop - start)) - 1)
+            result._bitset = value
+            return result
+
+        else:
+            if index < 0:
+                index = self._length - index
+            if not 0 <= index < self._length:
+                raise IndexError
+            return self._bitset & (1 << (len(self) - 1 - index)) > 0
+
+    def __invert__(self):
+        b = Bitset(self._length)
+        b._bitset = (1 << len(self)) - 1 - self._bitset
+        return b
+
+    def __and__(self, other):
+        if not isinstance(other, Bitset):
+            raise ValueError("Cannot operate on Bitset and non-Bitset")
+        if len(self) != len(other):
+            raise ValueError("Cannot operate on two Bitsets with different lengths")
+        b = Bitset(len(self))
+        b._bitset = self._bitset & other._bitset
+        return b
+
+    def __or__(self, other):
+        if not isinstance(other, Bitset):
+            raise ValueError("Cannot operate on Bitset and non-Bitset")
+        if len(self) != len(other):
+            raise ValueError("Cannot operate on two Bitsets with different lengths")
+        b = Bitset(len(self))
+        b._bitset = self._bitset | other._bitset
+        return b
+
+    def __hash__(self):
+        return hash(self._bitset, self._length)
+
+    def __bytes__(self):
+        padding = -self._length % 8
+        return (self._bitset << padding).to_bytes(length=(self._length + padding) // 8)
+
+    @property
+    def popcount(self):
+        return self._bitset.bit_count()
+
+    def to_indices(self):
+        return (i for i in range(len(self)) if self[i])
+
+    @classmethod
+    def from_bytes(cls, raw: bytes, length: int):
+        padding = -length % 8
+        b = cls(length)
+        b._bitset = int.from_bytes(raw) >> padding
+        return b
+
+    def __bool__(self):
+        return self._bitset > 0

heathrow/constants.py

@@ -0,0 +1 @@
+PROTOCOL_NAME = "aquarius"

heathrow/discovery/__init__.py

@@ -0,0 +1,8 @@
+from .base import AlreadySubscribedError, Discovery
+from .destination import DestinationDiscovery
+
+__all__ = (
+    "Discovery",
+    "DestinationDiscovery",
+    "AlreadySubscribedError",
+)

heathrow/discovery/base.py

@@ -0,0 +1,42 @@
+from abc import ABC, abstractmethod
+
+from heathrow.economy import Economy
+
+
+class AlreadySubscribedError(ValueError):
+    pass
+
+
+class Discovery(ABC):
+    """Class for "Discovery" modules.
+
+    Discovery module is responsible for getting Reticulum links at which potential peers may reside.
+
+    It exposes two methods to subscribe and unsubscribe economies to individual fileset IDs,
+    as well as two methods to start and stop discovery.
+    """
+
+    @abstractmethod
+    def start(self):
+        """Start any process loop(s) needed for the Discovery to run.
+
+        Do not block indefinitely.
+        """
+
+    @abstractmethod
+    def stop(self):
+        """Stop the Discovery's process loop(s)."""
+
+    @abstractmethod
+    def subscribe(self, fileset_id: str, economy: "Economy"):
+        """Attach an Economy as a listener for new peers for fileset fileset_id.
+
+        Attaching multiple Economies to the same fileset_id should not be allowed. Raise an AlreadySubscribedError.
+        """
+
+    @abstractmethod
+    def unsubscribe(self, fileset_id: str):
+        """Detach the current Economy from fileset_id.
+
+        Detaching a non-existent Economy from a fileset_id should not be allowed. Raise a KeyError.
+        """

heathrow/discovery/destination.py

@@ -0,0 +1,118 @@
+import logging
+from dataclasses import dataclass
+from functools import partial
+from threading import Condition, Thread
+from time import sleep
+
+import RNS
+
+from heathrow.discovery import AlreadySubscribedError, Discovery
+from heathrow.economy import Economy
+from heathrow.wire import Direction, ProtocolError, Wire, WireFactory
+
+
+logger = logging.getLogger(__name__)
+
+PROTOCOL_NAME = "aquarius-protocol-v0"  # From v0
+ANNOUNCEMENT_INTERVAL_SECONDS = 15
+
+
+class AnnounceHandler:
+    def __init__(self, fileset_id: str, discovery: "DestinationDiscovery"):
+        self.aspect_filter = f"{PROTOCOL_NAME}.{fileset_id}"
+        self.fileset_id = fileset_id
+        self.discovery = discovery
+
+    def received_announce(self, destination_hash, announced_identity, app_data):
+        if self.discovery.running:
+            logger.info(f"Received announce for fileset {self.fileset_id}.")
+            destination = RNS.Destination(announced_identity, RNS.Destination.OUT, RNS.Destination.SINGLE, PROTOCOL_NAME, self.fileset_id)
+            RNS.Link(destination, established_callback=partial(self.discovery._new_link, Direction.OUTGOING, self.fileset_id))
+    
+
+@dataclass
+class Subscription:
+    economy: Economy
+    destination: RNS.Destination
+    announce_handler: AnnounceHandler
+
+
+class DestinationDiscovery(Discovery):
+    """Destination-based discovery algorithm.
+
+    Announce a separate destination for every
+    fileset every ANNOUNCEMENT_INTERVAL_SECONDS.
+    Also listen to similar announcements for all destinations.
+    """
+
+    def __init__(self, identity: RNS.Identity, wirefactory: WireFactory):
+        self.identity = identity
+        self.subscriptions = {}
+        self._thread = None
+        self.running = False
+        self.wirefactory = wirefactory
+        self._early_stop_condition = Condition()
+
+    def _new_link_subthread(self, wire: Wire, fileset_id: str):
+        """Subthread for a new link. The library wants us to return fast, so we branch off."""
+        try:
+            fileset_id = wire.handshake()
+        except ProtocolError as exception:
+            logger.warning(f"Failed to establish a wire using {self.wirefactory} ({exception=})")
+        else:
+            self.subscriptions[fileset_id].economy.on_new_peer(wire)
+
+    def _new_link(self, direction: Direction, fileset_id: str, link: RNS.Link):
+        """Callback for a new link."""
+        if direction is Direction.OUTGOING:
+            wire = self.wirefactory.create_outgoing(link, self.identity, fileset_id)
+        else:
+            wire = self.wirefactory.create_incoming(link, self.identity, [fileset_id])
+        Thread(target=partial(self._new_link_subthread, wire, fileset_id)).start()
+
+    def subscribe(self, fileset_id: str, economy: Economy):
+        if fileset_id in self.subscriptions:
+            raise AlreadySubscribedError(f"Cannot subscribe to a second economy for fileset_id {fileset_id}")
+        self.subscriptions[fileset_id] = Subscription(
+            economy=economy,
+            destination=RNS.Destination(
+                self.identity,
+                RNS.Destination.IN,
+                RNS.Destination.SINGLE,
+                PROTOCOL_NAME,
+                fileset_id
+            ),
+            announce_handler=AnnounceHandler(fileset_id, self)
+        )
+        self.subscriptions[fileset_id].destination.set_link_established_callback(partial(self._new_link, Direction.INCOMING, fileset_id))
+        RNS.Transport.register_announce_handler(self.subscriptions[fileset_id].announce_handler)
+
+    def unsubscribe(self, fileset_id: str):
+        if fileset_id not in self.subscriptions:
+            raise KeyError(f"No economy to unsubscribe from fileset_id {fileset_id}")
+        logger.info(f"Unsubscribing from fileset {fileset_id}.")
+        RNS.Transport.deregister_announce_handler(self.subscriptions[fileset_id].announce_handler)
+        RNS.Transport.deregister_destination(self.subscriptions[fileset_id].destination)
+        del self.subscriptions[fileset_id]
+
+    def _run_announcements(self):
+        while self.running:
+            for fileset_id, subscription in self.subscriptions.items():
+                subscription.destination.announce()
+                logger.info(f"Announcing peer for fileset {fileset_id}.")
+            with self._early_stop_condition:
+                self._early_stop_condition.wait_for(lambda: not self.running, timeout=ANNOUNCEMENT_INTERVAL_SECONDS)
+
+
+    def start(self):
+        self.running = True
+        self._thread = Thread(target=self._run_announcements)
+        self._thread.start()
+
+    def stop(self):
+        self.running = False
+        with self._early_stop_condition:
+            self._early_stop_condition.notify()
+        if self._thread is not None:
+            self._thread.join()
+            self._thread = None

heathrow/driver/__init__.py

@@ -0,0 +1,9 @@
+from .base import Driver
+from .basic import BasicDriver
+from .heathrow import HeathrowDriver
+
+__all__ = (
+    "Driver",
+    "BasicDriver",
+    "HeathrowDriver",
+)

heathrow/driver/base.py

@@ -0,0 +1,13 @@
+from abc import ABC, abstractmethod
+
+class Driver(ABC):
+    """Class for the driver modules.
+
+    Driver modules are responsible for putting the program modules together.
+
+    It can be a TUI, a graphical application, or a daemon for example.
+    """
+    @classmethod
+    @abstractmethod
+    def main(cls):
+        """Runs when the program starts."""

heathrow/driver/basic.py

@@ -0,0 +1,39 @@
+import logging
+import os
+import time
+from pathlib import Path
+
+import RNS
+
+from heathrow.discovery import DestinationDiscovery
+from heathrow.economy import ProtoEconomy, ReferenceEconomy
+from heathrow.fileset import V1Fileset
+from heathrow.wire import BufferedWireFactory, ReticulatedWireFactory, ReticulatedV2WireFactory
+
+from .base import Driver
+
+
+class BasicDriver(Driver):
+    @classmethod
+    def main(cls):
+        level = logging.DEBUG if os.environ.get("HEATHROW_DEBUG", "0") == "1" else logging.INFO
+        logging.basicConfig(level=level, format="%(asctime)s [%(name)s:%(levelname)s] %(message)s")
+        metadata_dir = Path(os.environ.get("HEATHROW_METADATA_DIR", "./metadata"))
+        download_dir = Path(os.environ.get("HEATHROW_DOWNLOAD_DIR", "./download"))
+        fileset_id = bytes.fromhex(os.environ.get("HEATHROW_FILESET_ID", ""))
+
+        reticulum = RNS.Reticulum()
+
+        discovery = DestinationDiscovery(RNS.Identity(), BufferedWireFactory)
+        # economy = ProtoEconomy(V1Fileset(fileset_id, metadata_dir=metadata_dir, download_dir=download_dir))
+        economy = ReferenceEconomy(V1Fileset(fileset_id, metadata_dir=metadata_dir, download_dir=download_dir))
+        economy.start()
+        discovery.subscribe("urn:btih:" + fileset_id.hex(), economy)
+        discovery.start()
+        try:
+            while True:
+                time.sleep(1)
+        except KeyboardInterrupt:
+            print("Shutting down...")
+            economy.stop()
+            discovery.stop()

heathrow/driver/heathrow/__init__.py

@@ -0,0 +1,238 @@
+import argparse
+import curses
+import logging
+import os
+import time
+from collections import defaultdict
+from dataclasses import dataclass
+from importlib.metadata import version
+from pathlib import Path
+from threading import Condition, Thread
+
+import RNS
+
+import heathrow.discovery
+import heathrow.wire
+import heathrow.fileset
+import heathrow.economy
+from heathrow.bencode import bencode, bdecode
+
+from ..base import Driver
+from .constants import CONFIG_IDENTITY, CONFIG_METADATA, CONFIG_RESUME
+from .util import string_to_fileset
+from .windows import TUIWindow, SplashWindow
+
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class HeathrowDriverConfig:
+    config_dir: Path
+    tui: bool
+    debug: bool
+    discovery: type[heathrow.discovery.Discovery]
+    wirefactory: heathrow.wire.WireFactory
+    fileset: type[heathrow.fileset.Fileset]
+    economy: type[heathrow.economy.Economy]
+    targets: list[str]
+
+    @classmethod
+    def parse_args(cls):
+        parser = argparse.ArgumentParser()
+        parser.add_argument("-c", "--config-directory", help="Heathrow config directory", type=Path, default=Path(os.path.expanduser("~/.config/heathrow")))
+        parser.add_argument("--tui", help="Show the TUI", action=argparse.BooleanOptionalAction, default=True)
+        parser.add_argument("--debug", help="Show extra debug information", action=argparse.BooleanOptionalAction, default=True)
+        parser.add_argument("--discovery", help="Discovery module to use", choices=[i.removesuffix("Discovery") for i in heathrow.discovery.__all__ if i.endswith("Discovery") and i != "Discovery"], default="Destination")
+        parser.add_argument("--wire", help="Wire module to use", choices=[i.removesuffix("WireFactory") for i in heathrow.wire.__all__ if i.endswith("WireFactory") and i != "WireFactory"], default="LTEPBuffered")
+        parser.add_argument("--fileset", help="Fileset module to use", choices=[i.removesuffix("Fileset") for i in heathrow.fileset.__all__ if i.endswith("Fileset") and i != "Fileset"], default="V1")
+        parser.add_argument("--economy", help="Economy module to use", choices=[i.removesuffix("Economy") for i in heathrow.economy.__all__ if i.endswith("Economy") and i != "Economy"], default="Reference")
+        parser.add_argument("targets", help="Start downloading these magnet link / file URIs", nargs="*")
+        args = parser.parse_args()
+        discovery = getattr(heathrow.discovery, args.discovery + "Discovery")
+        wirefactory = getattr(heathrow.wire, args.wirefactory + "WireFactory")
+        fileset = getattr(heathrow.fileset, args.fileset + "Fileset")
+        economy = getattr(heathrow.economy, args.economy + "Economy")
+        return cls(config_dir=args.config_directory, tui=args.tui, debug=args.debug, discovery=discovery, wirefactory=wirefactory, fileset=fileset, economy=economy, targets=args.targets)
+
+
+TEXT_LOGO = """
+   ▄   ▄   ▄▄▄▄  ▄▄▄▄▄  ▄▄▄▄▄▄▄  ▄   ▄   ▄▄▄▄   ▄▄▄▄▄   ▄     ▄
+ ▄██▄▄█▀ ▄█▄▄  ▄██▄▄█▀   ▄█▀   ▄██▄▄█▀ ▄██▄ ▀ ▄█▀ ▄█▀ ▄█▀▄█ ▄█▀
+█▀  █▀ ▄█▄▄   █▀  █▀   ▄█▀    █▀  █▀  █▀  █▀ ██▄▄█▀  ██▄██▄█▀
+""".strip("\n")
+
+
+MIN_COLS = 80
+MIN_LINES = 24
+
+
+class ScreenSizeErrorWindow(TUIWindow):
+    def draw(self):
+        self._window.clear()
+        cursor_y = (curses.LINES - len(TEXT_LOGO.split("\n"))) // 2 - 1
+        cursor_x = (curses.COLS - max(len(i) for i in TEXT_LOGO.split("\n"))) // 2
+        try:
+            for y, line in enumerate(TEXT_LOGO.split("\n")):
+                self._window.addstr(y, 0, line)
+            self._window.addstr(len(TEXT_LOGO.split("\n")), 0, f"Screen size {MIN_COLS}x{MIN_LINES} or more required for TUI mode.")
+            self._window.addstr(len(TEXT_LOGO.split("\n")) + 1, 0, f"(F10 to quit)")
+        except curses.error:
+            pass
+        self._window.refresh()
+
+    def handle_key(self, key: str | None):
+        return True
+
+
+class HeathrowDriver(Driver):
+    @classmethod
+    def main(cls):
+        config = HeathrowDriverConfig.parse_args()
+        reticulum = RNS.Reticulum(loglevel=0)
+        self = cls(config)
+        self.run()
+
+    def create_resume_file(self, fileset: heathrow.fileset.Fileset):
+        resume_path = self.config.config_dir / CONFIG_RESUME / (fileset.fileset_id.replace(":", "_") + ".resume")
+        download_dir = fileset
+        if resume_path.exists():
+            pass  # We have it already
+        else:
+            with open(resume_path, "wb") as f:
+                f.write(bencode({b"destination": str(fileset.download_directory.absolute()).encode()}))
+
+    def load_fileset_from_resume_file(self, resume_path: Path):
+        try:
+            with open(resume_path, "rb") as f:
+                resume = f.read()
+                parsed_resume = bdecode(resume)
+                download_dir = parsed_resume[b"destination"]
+                resume_name = resume_path.name.removesuffix(".resume")
+                metadata_path = self.config.config_dir / CONFIG_METADATA / (resume_name + ".torrent")
+                try:
+                    fileset = self.config.fileset.from_file(metadata_path.read_bytes(), Path(download_dir.decode()), self.config.config_dir / CONFIG_METADATA)
+                except FileNotFoundError:
+                    inferred_id = resume_name.replace("_", ":")
+                    if not inferred_id.startswith("urn:"):
+                        # TODO fileset V2
+                        inferred_id = "urn:btih:" + inferred_id
+                    fileset = self.config.fileset.from_id(inferred_id, Path(download_dir.decode()), self.config.config_dir / CONFIG_METADATA)
+                return fileset
+        except Exception as e:
+            raise ValueError(f"Could not load resume file at path {resume_path}") from e
+
+    def load_tracked_filesets(self):
+        filesets = []
+        for path in (self.config.config_dir / CONFIG_RESUME).iterdir():
+            if path.name.endswith(".resume"):
+                try:
+                    filesets.append(self.load_fileset_from_resume_file(path))
+                except:
+                    logger.warning(f"Could not resume download at {path}", exc_info=True)
+        for cliarg in self.config.targets:
+            fs = string_to_fileset(cliarg, self.config.fileset, Path(os.path.expanduser("~/Downloads")), self.config.config_dir / CONFIG_METADATA)
+            if fs is not None:
+                self._driver.create_resume_file(fs)
+                self._driver.add_fileset(fs)
+        return filesets
+
+    def add_fileset(self, fileset):
+        if fileset.fileset_id in self._tracked_filesets:
+            return
+        self._tracked_filesets[fileset.fileset_id] = fileset
+        self._economies[fileset.fileset_id] = self.config.economy(fileset)
+        self._discovery.subscribe(fileset.fileset_id, self._economies[fileset.fileset_id])
+        self._economies[fileset.fileset_id].start()
+
+    def init_filesets_and_economies(self):
+        """Separate from init function to call during e.g. the splash screen."""
+        self._tracked_filesets = {i.fileset_id: i for i in self.load_tracked_filesets()}
+        self._economies = {k: self.config.economy(v) for k, v in self._tracked_filesets.items()}  # TODO add constructor to interface
+        for k, v in self._economies.items():
+            v.start()
+            self._discovery.subscribe(k, v)
+
+    def __init__(self, config):
+        self.config = config
+        (self.config.config_dir / CONFIG_METADATA).mkdir(parents=True, exist_ok=True)
+        (self.config.config_dir / CONFIG_RESUME).mkdir(parents=True, exist_ok=True)
+        logging.basicConfig(filename=self.config.config_dir / 'heathrow.log', level=logging.DEBUG, format="%(asctime)s [%(name)s:%(levelname)s] %(message)s")
+        if (identity := RNS.Identity.from_file(self.config.config_dir / CONFIG_IDENTITY)) is None:
+            identity = RNS.Identity()
+            identity.to_file(self.config.config_dir / CONFIG_IDENTITY)
+            (self.config.config_dir / CONFIG_IDENTITY).chmod(0o600)
+        self._identity = identity
+        self._discovery = self.config.discovery(self._identity, self.config.wirefactory)  # TODO add constructor to interface
+        self._tracked_filesets_loaded = False
+        self._tracked_filesets = {}
+        self._economies = {}
+        self._download_speeds = defaultdict(float)
+        self._upload_speeds = defaultdict(float)
+        self._speedtest_stop = False
+        self._speedtest_thread = Thread(target=self._speedtest_loop)
+        self._early_stop_condition = Condition()
+        self._windows = []
+
+    def _speedtest_loop(self):
+        CURRENT_EXP = 0.3
+        last_downloads = defaultdict(int)
+        last_uploads = defaultdict(int)
+        while not self._speedtest_stop:
+            for economy in list(self._economies.keys()):
+                observed_down = self._economies[economy].status.downloaded_bytes - last_downloads[economy]
+                observed_up = self._economies[economy].status.uploaded_bytes - last_uploads[economy]
+                self._download_speeds[economy] = observed_down * CURRENT_EXP + self._download_speeds[economy] * (1 - CURRENT_EXP)
+                self._upload_speeds[economy] = observed_up * CURRENT_EXP + self._upload_speeds[economy] * (1 - CURRENT_EXP)
+                last_downloads[economy] = self._economies[economy].status.downloaded_bytes
+                last_uploads[economy] = self._economies[economy].status.uploaded_bytes
+            with self._early_stop_condition:
+                self._early_stop_condition.wait_for(lambda: self._speedtest_stop, timeout=1)
+
+    def run(self):
+        self._discovery.start()
+        if self.config.tui:
+            curses.wrapper(self.curses_main)
+        else:
+            self.init_filesets_and_economies()
+            self._driver._tracked_filesets_loaded = True
+            try:
+                while True:
+                    time.sleep(1)
+            except KeyboardInterrupt:
+                pass
+        print(f"Thank you for using Heathrow {version('heathrow')}!")
+
+    def curses_main(self, stdscr):
+        stdscr.clear()
+        self._speedtest_thread.start()
+        self._windows.append(SplashWindow(stdscr, self))
+        size_error = ScreenSizeErrorWindow(stdscr, self)
+        curses.halfdelay(30)
+        curses.mousemask(curses.BUTTON1_CLICKED)
+        while True:
+            curses.update_lines_cols()
+            if self._windows:
+                if curses.COLS < MIN_COLS or curses.LINES < MIN_LINES:
+                    size_error.draw()
+                else:
+                    for window in self._windows:
+                        window.draw()
+                try:
+                    key = stdscr.getkey()
+                except curses.error:
+                    key = None
+                active_window = len(self._windows) - 1
+                val = self._windows[active_window].handle_key(key)
+                if not val:
+                    del self._windows[active_window]
+            else:
+                break
+
+        self._speedtest_stop = True
+        with self._early_stop_condition:
+            self._early_stop_condition.notify()
+        for economy in self._economies.values():
+            economy.stop()
+        self._discovery.stop()
+        self._speedtest_thread.join()

heathrow/driver/heathrow/constants.py

@@ -0,0 +1,5 @@
+# Subpaths of the config directory
+
+CONFIG_IDENTITY = "identity"
+CONFIG_METADATA = "torrents"
+CONFIG_RESUME = "resume"