pirateface 0.1.0__py3-none-any.whl

pirateface/__init__.py

@@ -0,0 +1 @@
+

pirateface/_boot.py

@@ -0,0 +1,47 @@
+"""Runs at every Python startup via pirateface.pth, so it must be cheap and never raise.
+Patches huggingface_hub lazily, when something imports it."""
+
+import sys
+
+from pirateface.config import flag
+
+TARGETS = {"huggingface_hub.file_download"}
+
+
+def _install(name, module):
+    try:
+        from pirateface import huggingface
+
+        huggingface.install(module)
+    except Exception as e:
+        print(f"[pirateface] hook disabled: {e}", file=sys.stderr)
+
+
+class _PatchOnImport:
+    def find_spec(self, name, path=None, target=None):
+        if name not in TARGETS:
+            return None
+        sys.meta_path.remove(self)
+        try:
+            import importlib.util
+
+            spec = importlib.util.find_spec(name)
+        finally:
+            sys.meta_path.insert(0, self)
+        if spec is None or spec.loader is None:
+            return None
+        exec_module = spec.loader.exec_module
+
+        def exec_and_patch(module):
+            exec_module(module)
+            _install(name, module)
+
+        spec.loader.exec_module = exec_and_patch
+        return spec
+
+
+if not flag("PF_DISABLE"):
+    sys.meta_path.insert(0, _PatchOnImport())
+    for name in TARGETS:
+        if name in sys.modules:
+            _install(name, sys.modules[name])

pirateface/cli.py

@@ -0,0 +1,16 @@
+import argparse
+
+import pirateface._boot  # noqa: F401  # uv tools skip .pth files
+
+
+def main():
+    p = argparse.ArgumentParser(prog="pf")
+    sub = p.add_subparsers(dest="cmd", required=True)
+    d = sub.add_parser("download", help="download a model into the Hugging Face cache")
+    d.add_argument("repo_id")
+    d.add_argument("--revision")
+    args = p.parse_args()
+
+    from huggingface_hub import snapshot_download
+
+    print(snapshot_download(args.repo_id, revision=args.revision, max_workers=1))

pirateface/client/api.py

@@ -0,0 +1,63 @@
+"""Everything that talks to pirateface.co."""
+
+import atexit
+import contextlib
+import functools
+import json
+import threading
+import urllib.error
+import urllib.parse
+import urllib.request
+
+from pirateface.config import API, flag
+
+NOT_LISTED = object()
+
+
+@functools.cache
+def _lookup(repo_id):
+    """Pirate Face's entry for the repo, NOT_LISTED, or None if unknown (network error)."""
+    url = f"{API}/api/torrents?" + urllib.parse.urlencode({"repo": repo_id})
+    try:
+        with urllib.request.urlopen(url, timeout=10) as r:
+            return json.load(r)
+    except urllib.error.HTTPError as e:
+        return NOT_LISTED if e.code == 404 else None
+    except Exception:
+        return None
+
+
+def lookup_magnet(repo_id):
+    """The magnet, NOT_LISTED, or None if unknown (network error, or license terms to accept first)."""
+    entry = _lookup(repo_id)
+    return entry.get("magnet") if isinstance(entry, dict) else entry
+
+
+_rescues = []
+
+
+def _send_rescue(repo_id):
+    req = urllib.request.Request(
+        f"{API}/api/rescue",
+        data=json.dumps({"repoId": repo_id}).encode(),
+        headers={"Content-Type": "application/json"},
+        method="POST",
+    )
+    with contextlib.suppress(Exception):
+        urllib.request.urlopen(req, timeout=10).close()
+
+
+def request_rescue(repo_id):
+    """Ask Pirate Face to add a model it doesn't have yet, in the background."""
+    if flag("PF_NO_RESCUE"):
+        return False
+    t = threading.Thread(target=_send_rescue, args=(repo_id,), daemon=True)
+    t.start()
+    _rescues.append(t)
+    return True
+
+
+@atexit.register
+def _wait_for_rescues():
+    for t in _rescues:
+        t.join(timeout=2)

pirateface/client/torrent.py

@@ -0,0 +1,206 @@
+import atexit
+import os
+import shutil
+import sys
+import threading
+import time
+from importlib.metadata import version
+from pathlib import Path
+
+import libtorrent as lt
+
+from pirateface import config, ui
+from pirateface.client import api
+
+CACHE_DIR = Path(config.CACHE_DIR)
+_lock = threading.Lock()
+_session = None
+_handles = {}  # repo_id -> handle, or None if not on Pirate Face
+_wanted = {}
+
+
+class Unavailable(Exception):
+    pass
+
+
+def _get_session():
+    global _session
+    if _session is None:
+        debug = config.flag("PF_DEBUG")
+        _session = lt.session(
+            {
+                "listen_interfaces": config.LISTEN,
+                "user_agent": f"pirateface/{version('pirateface')}",
+                "alert_mask": lt.alert.category_t.all_categories if debug else lt.alert.category_t.storage_notification,
+                # The torrent goes "finished" between files and drops the web seed; reconnect in 2s, not 30s.
+                # Keep close_redundant_connections on: idle web seeds otherwise never request the next file.
+                "urlseed_wait_retry": 2,
+            }
+        )
+        threading.Thread(target=_pump_alerts, args=(_session, debug), daemon=True).start()
+    return _session
+
+
+# libtorrent reports pieces done before they're written, so files can read as zeros until flushed.
+# cache_flushed_alert doesn't say which flush it answers, so only one runs at a time.
+_flush = threading.Condition()
+_flush_one_at_a_time = threading.Lock()
+_flush_done = {}
+
+
+def _pump_alerts(session, debug):
+    """The only reader of libtorrent's alerts."""
+    noisy = ("PIECE", "HAVE", "REQUEST", "picker", "ALLOWED_FAST", "dht", "portmap", "stats", "block")
+    while True:
+        session.wait_for_alert(1000)
+        for a in session.pop_alerts():
+            if isinstance(a, lt.cache_flushed_alert):
+                with _flush:
+                    key = str(a.handle.info_hashes().v1)
+                    _flush_done[key] = _flush_done.get(key, 0) + 1
+                    _flush.notify_all()
+            if debug:
+                msg = a.message()
+                if not any(k in msg or k in type(a).__name__ for k in noisy):
+                    print(f"[lt] {msg[:220]}", file=sys.stderr, flush=True)
+
+
+@atexit.register
+def _cleanup():
+    for h in _handles.values():
+        if h is None:
+            continue
+        path = Path(h.status().save_path) / h.torrent_file().name()
+        _session.remove_torrent(h)
+        if path.is_dir():
+            shutil.rmtree(path, ignore_errors=True)
+        else:
+            path.unlink(missing_ok=True)
+
+
+def _flush_to_disk(h, timeout=30):
+    key = str(h.info_hashes().v1)
+    with _flush_one_at_a_time, _flush:
+        before = _flush_done.get(key, 0)
+        h.flush_cache()
+        if not _flush.wait_for(lambda: _flush_done.get(key, 0) > before, timeout):
+            raise TimeoutError("libtorrent didn't confirm the file was written to disk")
+
+
+def _handle(repo_id):
+    with _lock:
+        if repo_id in _handles:
+            return _handles[repo_id]
+        magnet = api.lookup_magnet(repo_id)
+        if magnet is api.NOT_LISTED:
+            ui.not_on_pirateface(repo_id, api.request_rescue(repo_id))
+            _handles[repo_id] = None
+            return None
+        if not magnet:
+            ui.not_on_pirateface(repo_id)
+            _handles[repo_id] = None
+            return None
+        atp = lt.parse_magnet_uri(magnet)
+        atp.save_path = str(CACHE_DIR)
+        atp.flags |= lt.torrent_flags.default_dont_download
+        # Cache the file list: a magnet alone needs a live peer to get it.
+        saved = CACHE_DIR / "torrents" / f"{atp.info_hashes.v1}.torrent"
+        if saved.exists():
+            atp.ti = lt.torrent_info(str(saved))
+        h = _get_session().add_torrent(atp)
+        deadline = time.monotonic() + config.METADATA_TIMEOUT
+        while not h.status().has_metadata:
+            if time.monotonic() > deadline:
+                _get_session().remove_torrent(h)
+                _handles[repo_id] = None
+                raise TimeoutError("no peer sent the file list in time")
+            time.sleep(0.2)
+        if not saved.exists():
+            saved.parent.mkdir(parents=True, exist_ok=True)
+            saved.write_bytes(lt.bencode({"info": lt.bdecode(h.torrent_file().info_section())}))
+        _handles[repo_id] = h
+        threading.Thread(target=_show_status, args=(repo_id, h), daemon=True).start()
+        fs = h.torrent_file().files()
+        real = [i for i in range(fs.num_files()) if not fs.file_flags(i) & fs.flag_pad_file]
+        ui.banner(repo_id, len(real), sum(fs.file_size(i) for i in real))
+        return h
+
+
+def _show_status(repo_id, h, every=0.5, recent=3.0):
+    """Sources = who sent bytes recently, not who is connected: the web seed reconnects per file and flickers."""
+    fs = h.torrent_file().files()
+    sent = {}
+    last_seen = {}
+    bar = None
+    while True:
+        time.sleep(every)
+        with _lock:
+            wanted = list(_wanted.get(repo_id, ()))
+        progress = h.file_progress(lt.torrent_handle.piece_granularity)
+        total = sum(fs.file_size(i) for i in wanted)
+        done = sum(min(progress[i], fs.file_size(i)) for i in wanted)
+        files_done = sum(progress[i] >= fs.file_size(i) for i in wanted)
+        if not wanted or files_done == len(wanted):
+            if bar is not None:
+                bar.close()
+                bar = None
+            continue
+        now = time.monotonic()
+        for p in h.get_peer_info():
+            conn = tuple(p.ip)
+            if p.total_download > sent.get(conn, 0):
+                last_seen[(conn[0], p.connection_type != lt.peer_info.standard_bittorrent)] = now
+            sent[conn] = p.total_download
+        active = [web for (_, web), t in last_seen.items() if now - t < recent]
+        label = ui.sources_label(any(active), active.count(False))
+        if bar is None:
+            bar = ui.repo_progress(repo_id)
+        bar.total, bar.n = total, done
+        ui.set_status(
+            bar,
+            f"{files_done}/{len(wanted)} files · {done / 1e6:.1f}/{total / 1e6:.1f} MB · {label} · {h.status().download_rate / 1e6:.1f} MB/s",
+        )
+
+
+def _file_index(ti, filename):
+    fs = ti.files()
+    for i in range(fs.num_files()):
+        path = fs.file_path(i).replace(os.sep, "/")
+        rel = path.split("/", 1)[1] if fs.num_files() > 1 and "/" in path else path
+        if rel == filename:
+            return i
+    return None
+
+
+def fetch_file(repo_id, filename):
+    h = _handle(repo_id)
+    if h is None:
+        raise Unavailable()
+    ti = h.torrent_file()
+    i = _file_index(ti, filename)
+    if i is None:
+        raise Unavailable("not in the torrent")
+    size = ti.files().file_size(i)
+    path = Path(h.status().save_path) / ti.files().file_path(i)
+    # Set all priorities in one call (all-skipped for a moment drops the web seed), from our own set:
+    # libtorrent applies them lazily, so reading them back across threads loses updates.
+    with _lock:
+        wanted = _wanted.setdefault(repo_id, set())
+        wanted.add(i)
+        h.prioritize_files([4 if f in wanted else 0 for f in range(ti.num_files())])
+
+    last_done, last_change = -1, time.monotonic()
+    while True:
+        done = h.file_progress(lt.torrent_handle.piece_granularity)[i]
+        if done >= size:
+            break
+        st = h.status()
+        if st.errc.value():
+            raise RuntimeError(f"torrent error: {st.errc.message()}")
+        if done != last_done:
+            last_done, last_change = done, time.monotonic()
+        elif time.monotonic() - last_change > config.STALL_TIMEOUT:
+            raise TimeoutError(f"stalled for {config.STALL_TIMEOUT:.0f}s")
+        time.sleep(0.25)
+    _flush_to_disk(h)
+    return path

pirateface/config.py

@@ -0,0 +1,12 @@
+import os
+
+
+def flag(name):
+    return os.environ.get(name, "") not in ("", "0")
+
+
+API = os.environ.get("PF_API", "https://pirateface.co")
+CACHE_DIR = os.environ.get("PF_CACHE") or os.path.expanduser("~/.cache/pirateface")  # noqa: PTH111  # pathlib slows every Python startup
+LISTEN = os.environ.get("PF_LISTEN", "0.0.0.0:0,[::]:0")
+METADATA_TIMEOUT = float(os.environ.get("PF_METADATA_TIMEOUT", "30"))
+STALL_TIMEOUT = float(os.environ.get("PF_STALL_TIMEOUT", "60"))

pirateface/huggingface.py

@@ -0,0 +1,111 @@
+"""Swap huggingface_hub's file download for a torrent download, checked against Hugging Face's fingerprint."""
+
+import contextvars
+import functools
+import hashlib
+import inspect
+import shutil
+import sys
+from pathlib import Path
+
+from pirateface import ui
+from pirateface.client import torrent
+
+FUNC = "_download_to_tmp_and_move"
+# FUNC isn't passed the repo id, so the outer functions record it here.
+OUTER = ("_hf_hub_download_to_cache_dir", "_hf_hub_download_to_local_dir")
+_repo = contextvars.ContextVar("pirateface_repo", default=None)
+
+
+def log(msg):
+    print(f"[pirateface] {msg}", file=sys.stderr, flush=True)
+
+
+def install(file_download):
+    original = getattr(file_download, FUNC, None)
+    if original is None:
+        log(f"huggingface_hub has no {FUNC}; torrent downloads disabled")
+        return
+
+    signature = inspect.signature(original)
+
+    @functools.wraps(original)
+    def patched(*args, **kwargs):
+        bound = signature.bind(*args, **kwargs).arguments
+        dest = Path(bound["destination_path"])
+        if dest.exists() and not bound.get("force_download"):
+            return original(*args, **kwargs)
+        name = bound["filename"]
+        try:
+            if _from_torrent(name, bound["etag"], dest):
+                return None
+        except torrent.Unavailable as e:
+            ui.from_hf(name, str(e) or None)
+        except Exception as e:
+            ui.from_hf(name, str(e) or type(e).__name__)
+        return original(*args, **kwargs)
+
+    setattr(file_download, FUNC, patched)
+    _hide_token_nag()
+    for name in OUTER:
+        setattr(file_download, name, _remember_repo(getattr(file_download, name)))
+
+
+def _hide_token_nag():
+    """Silence the "set a HF_TOKEN" server warning only; other server warnings still show."""
+    try:
+        from huggingface_hub.utils import _http
+
+        _http._WARNED_TOPICS.add("unauthenticated")
+    except (ImportError, AttributeError):
+        pass
+
+
+def _remember_repo(outer):
+    @functools.wraps(outer)
+    def wrapper(*args, **kwargs):
+        token = _repo.set((kwargs.get("repo_type"), kwargs.get("repo_id")))
+        try:
+            return outer(*args, **kwargs)
+        finally:
+            _repo.reset(token)
+
+    return wrapper
+
+
+def _from_torrent(filename, etag, dest):
+    repo_type, repo_id = _repo.get() or (None, None)
+    if repo_id is None or repo_type not in (None, "model"):
+        return False
+    src = torrent.fetch_file(repo_id, filename)
+    if not _matches(src, etag):
+        raise ValueError("torrent copy didn't match Hugging Face's fingerprint")
+    _place(src, dest)
+    ui.from_swarm(filename, src.stat().st_size)
+    return True
+
+
+def _matches(path, etag):
+    """HF etags are SHA-256 for LFS files, git blob SHA-1 otherwise."""
+    etag = (etag or "").removeprefix("W/").strip('"')
+    if len(etag) == 64:
+        h = hashlib.sha256()
+    elif len(etag) == 40:
+        h = hashlib.sha1(b"blob %d\0" % path.stat().st_size)
+    else:
+        return False
+    with path.open("rb") as f:
+        while chunk := f.read(1 << 20):
+            h.update(chunk)
+    return h.hexdigest() == etag
+
+
+def _place(src, dest):
+    """Copy, not hard-link: HF makes its blobs read-only, which would lock libtorrent out of a shared inode."""
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    tmp = dest.with_name(dest.name + ".pf.incomplete")
+    try:
+        shutil.copyfile(src, tmp)
+        tmp.replace(dest)
+    finally:
+        tmp.unlink(missing_ok=True)

pirateface/ui.py

@@ -0,0 +1,112 @@
+import os
+import sys
+import threading
+
+from tqdm.auto import tqdm
+
+from pirateface.config import flag
+
+QUIET = flag("PF_QUIET")
+_color = sys.stderr.isatty() and "NO_COLOR" not in os.environ
+_lock = threading.Lock()
+_announced = set()
+
+SPLASH = r'''
+          _.-""""-._
+     __.-'   (xx)   '-.__
+    '-.________________.-'
+      /                \
+     |   ^      (###)===|
+      \    \______/    /
+       '-.__________.-'
+'''[1:].splitlines()
+TAGLINE = ("pirateface", "  Open-weight model downloads, from the swarm")
+
+
+def _c(code, text):
+    return f"\033[{code}m{text}\033[0m" if _color else text
+
+
+def _print(line):
+    if not QUIET:
+        tqdm.write(line, file=sys.stderr)
+
+
+def _bar():
+    return _c("35", "┃")
+
+
+def mb(n):
+    return f"{n / 1e6:.1f} MB" if n >= 1e5 else f"{n / 1e3:.1f} kB"
+
+
+def splash():
+    if _announced or not sys.stderr.isatty():
+        return
+    pad = " " * ((len("".join(TAGLINE)) - max(map(len, SPLASH))) // 2)
+    art = [pad + (_c("1", line) if i < 3 else _c("33", line)) for i, line in enumerate(SPLASH)]
+    _print("\n".join(art) + "\n" + _c("1;35", TAGLINE[0]) + _c("2", TAGLINE[1]) + "\n")
+
+
+def banner(repo_id, files, size):
+    with _lock:
+        if repo_id in _announced:
+            return
+        splash()
+        _announced.add(repo_id)
+    _print(
+        _bar()
+        + " "
+        + _c("1;35", "🏴‍☠️ pirateface")
+        + f"  {repo_id} is on Pirate Face ({files} files, {mb(size)}), downloading from the swarm"
+    )
+
+
+def not_on_pirateface(repo_id, rescue_requested=False):
+    with _lock:
+        if repo_id in _announced:
+            return
+        _announced.add(repo_id)
+    line = _bar() + " " + _c("1;35", "🏴‍☠️ pirateface") + f"  {repo_id} isn't on Pirate Face yet, using Hugging Face"
+    if rescue_requested:
+        line += _c("2", " · requested a rescue (turn off: PF_NO_RESCUE=1)")
+    _print(line)
+
+
+def repo_progress(repo_id):
+    return tqdm(
+        total=1,
+        leave=False,
+        file=sys.stderr,
+        disable=QUIET or not sys.stderr.isatty(),
+        desc=f"{_bar()}  🏴‍☠️ {repo_id}",
+        bar_format="{desc}  {bar:20}",
+        colour="magenta",
+    )
+
+
+def set_status(bar, text):
+    # Not tqdm's postfix: it always prepends ", ".
+    bar.bar_format = "{desc}  {bar:20}  " + text.replace("{", "{{").replace("}", "}}")
+    bar.refresh()
+
+
+def sources_label(webseed, peers):
+    if webseed and peers:
+        return f"web seed + {peers} peer{'s' * (peers > 1)}"
+    if webseed:
+        return "web seed"
+    if peers:
+        return f"{peers} peer{'s' * (peers > 1)}"
+    return "finding sources…"
+
+
+def from_swarm(filename, size):
+    _print(
+        f"{_bar()}  {_c('32', '✔')} {filename}  {_c('2', mb(size) + ' from the swarm, fingerprint matches Hugging Face')}"
+    )
+
+
+def from_hf(filename, reason=None):
+    if reason:
+        _print(f"{_bar()}  {_c('33', '↩')} {filename}  {_c('2', 'from Hugging Face (' + reason + ')')}")

pirateface-0.1.0.dist-info/METADATA

@@ -0,0 +1,89 @@
+Metadata-Version: 2.5
+Name: pirateface
+Version: 0.1.0
+Summary: Download Hugging Face models over BitTorrent from Pirate Face seeders. No code changes.
+Project-URL: Homepage, https://pirateface.co
+Project-URL: Source, https://github.com/pirateface/pirateface_hub
+Project-URL: Issues, https://github.com/pirateface/pirateface_hub/issues
+License-Expression: MIT
+License-File: LICENSE
+Keywords: bittorrent,download,huggingface,libtorrent,models
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.12
+Requires-Dist: huggingface-hub>=2.0
+Requires-Dist: libtorrent>=2.0
+Requires-Dist: tqdm>=4.42
+Description-Content-Type: text/markdown
+
+# Pirate Face Hub
+
+**Plug and play torrent downloads for Hugging Face models.** Add one package. Change nothing else.
+
+```sh
+uv run --with pirateface python your_script.py
+```
+
+or install it once and forget about it:
+
+```sh
+pip install pirateface
+```
+
+That's the whole setup. No code changes, no config, no new API. Your script still calls transformers or
+`huggingface_hub` like it always did, and the files now come from [Pirate Face](https://pirateface.co)
+seeders over BitTorrent:
+
+```python
+from transformers import AutoModelForCausalLM
+
+model = AutoModelForCausalLM.from_pretrained("org/model")  # unchanged, now from the swarm
+```
+
+The same goes for anything that downloads through `huggingface_hub`: diffusers, sentence-transformers,
+`hf_hub_download`, `snapshot_download` and the `hf download` CLI.
+
+Every file is checked against Hugging Face's own fingerprint (SHA-256 for large files, git SHA-1 for the
+rest) before it goes into the normal Hugging Face cache. If Pirate Face doesn't have the model, a peer is
+missing, or a check fails, that file comes from Hugging Face as usual. Uninstall it and your code
+runs exactly as before.
+
+There's also a small CLI:
+
+```sh
+pf download org/model [--revision REV]
+```
+
+## How it hooks in
+
+The package installs `pirateface.pth`, which Python runs at startup. It does nothing until something
+imports `huggingface_hub`, then fetches each file's bytes from the swarm. Hugging Face still answers
+which commit and fingerprint to expect, and every file from the swarm is checked against it. If Pirate
+Face has no torrent, or no peer sends the file list within 30 s, the file comes from Hugging Face as usual.
+Cache layout, symlinks and locks stay with `huggingface_hub`.
+
+## Settings
+
+| Variable | Default | |
+|---|---|---|
+| `PF_DISABLE` | off | Turn the hook off |
+| `PF_QUIET` | off | Print nothing |
+| `PF_NO_RESCUE` | off | Don't ask Pirate Face to add models it doesn't have yet |
+| `PF_DEBUG` | off | Print libtorrent's log |
+| `PF_CACHE` | `~/.cache/pirateface` | Where torrent data and file lists are kept |
+| `PF_API` | `https://pirateface.co` | Pirate Face server |
+| `PF_LISTEN` | any free port | libtorrent listen interfaces |
+| `PF_METADATA_TIMEOUT` | `30` | Seconds to wait for a peer to send the file list |
+| `PF_STALL_TIMEOUT` | `60` | Seconds without progress before falling back to Hugging Face |
+
+Flags are on for any value except empty or `0`.
+
+Needs Python 3.12 or 3.13 (libtorrent has no wheels for 3.14 yet).
+
+## Development
+
+```sh
+uv run --group dev ruff check
+```

pirateface-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+pirateface/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+pirateface/_boot.py,sha256=KE2q3VjrPA5Fr06cyol-08GcbbH_HNoxQg_T8lUm5Yg,1254
+pirateface/cli.py,sha256=3pNChsiZ10UcOa_NBLBEG0-THLxG_qjewcVp0D7ASyw,505
+pirateface/config.py,sha256=CO518BToBT4_zh2O8FLrPNFyxYNruLsUpw4vgzy6-_o,468
+pirateface/huggingface.py,sha256=ZXOwqJSDWO7TLTxyavdWfZP-bdX_QvBtaf25VXpVg-U,3468
+pirateface/ui.py,sha256=PumXsIDNDEC66truEZOW7FJeOYDNuwPtRNKZpeiL0xk,2954
+pirateface/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pirateface/client/api.py,sha256=uBbsIPrgeoxrbKq7h9Lg8k70y8plA1FqN7X00RUKfXQ,1655
+pirateface/client/torrent.py,sha256=lJuSrEqUy1HgRVB3ibbwdcL9EDK1i8DoYpqrxjQtlZo,7773
+pirateface.pth,sha256=td-k_oJyYi0LmTbM21u12-JJznkRxyw-KyKYUxKSEWk,24
+pirateface-0.1.0.dist-info/METADATA,sha256=vFA8j7KOlKeRrtoZxe4Aex_dBp2ohFzXxW46V5iE1ik,3340
+pirateface-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+pirateface-0.1.0.dist-info/entry_points.txt,sha256=QZGSjlOv0Ei3LVt2XIUddorqA5iyzSsRjCUMdRfzqaI,43
+pirateface-0.1.0.dist-info/licenses/LICENSE,sha256=C5oOi3ki7RFP562DUN0iOTYaV7XHDr6fBao5NMM5djw,1068
+pirateface-0.1.0.dist-info/RECORD,,

pirateface-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

pirateface-0.1.0.dist-info/entry_points.txt

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

pirateface-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Pirate Face
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pirateface.pth

@@ -0,0 +1 @@
+import pirateface._boot