caplinks 0.0.2__py3-none-any.whl

caplinks/__init__.py

@@ -0,0 +1,46 @@
+"""Capability links: an unguessable token, an optional password gate, expiry, attempt limits.
+
+The parts every app needs to hand someone a link to one thing, with no account: the
+token is the permission, a password may gate it, it expires, it can be revoked, and
+password attempts are limited. Standard library only; no web framework. What a link
+reaches (its scope) and how it is served stay with the app.
+
+>>> links = CapabilityLinks()  # records in a dict; pass any MutableMapping to persist
+>>> rec = links.create({"doc": "report-1"}, password="open sesame", expires="7d")
+>>> state, stored = links.status(rec["token"])
+>>> state, links.check_password(stored, "open sesame")
+('ok', True)
+>>> cookie = links.unlock_value(stored)
+>>> links.unlocked(stored, cookie, max_age_s=3600)
+True
+"""
+
+from caplinks.expiry import is_expired, now_utc, parse_expires
+from caplinks.limits import RateLimiter, SlidingWindowLimiter
+from caplinks.links import (
+    DFLT_EXPIRES,
+    MIN_PASSWORD_LEN,
+    RECORD_FIELDS,
+    CapabilityLinks,
+    check_token,
+    new_token,
+    public_record,
+)
+from caplinks.passwords import PasswordHasher, ScryptHasher
+
+__all__ = [
+    "CapabilityLinks",
+    "DFLT_EXPIRES",
+    "MIN_PASSWORD_LEN",
+    "PasswordHasher",
+    "RECORD_FIELDS",
+    "RateLimiter",
+    "ScryptHasher",
+    "SlidingWindowLimiter",
+    "check_token",
+    "is_expired",
+    "new_token",
+    "now_utc",
+    "parse_expires",
+    "public_record",
+]

caplinks/expiry.py

@@ -0,0 +1,107 @@
+"""When a link stops working: reading an expiry the way a person writes one.
+
+An expiry is stored as an ISO UTC timestamp (or ``None`` for never). :func:`parse_expires`
+reads what a person types (``7d``, ``2026-11-01``, an ISO timestamp, ``never``);
+:func:`is_expired` checks a record against the clock and fails closed on a value it
+cannot read.
+"""
+
+from __future__ import annotations
+
+import re
+from datetime import datetime, timedelta, timezone
+
+#: duration suffixes accepted by :func:`parse_expires` (``30m``, ``12h``, ``7d``, ``2w``)
+DURATION_UNITS = {"m": "minutes", "h": "hours", "d": "days", "w": "weeks"}
+_DURATION_RE = re.compile(r"^(\d+)\s*([mhdw])$", re.I)
+_DATE_RE = re.compile(r"\d{4}-\d{2}-\d{2}")
+#: words that mean "no expiry"
+NEVER = frozenset({"never", "none", "no", ""})
+
+
+def now_utc() -> datetime:
+    """The current time, UTC, second precision (the clock every default reads)."""
+    return datetime.now(timezone.utc).replace(microsecond=0)
+
+
+def _as_utc(when: datetime) -> datetime:
+    when = when if when.tzinfo else when.replace(tzinfo=timezone.utc)
+    return when.astimezone(timezone.utc).replace(microsecond=0)
+
+
+def parse_expires(value, *, now: datetime | None = None) -> str | None:
+    """An expiry as an ISO UTC timestamp, or ``None`` for never.
+
+    ``None``, ``""`` and ``"never"`` mean never. Accepts a duration (``30m``, ``12h``,
+    ``7d``, ``2w``), a date (``2026-11-01``: the END of that day, UTC, so the link works
+    through the day named), an ISO timestamp (a naive one is UTC), or a ``datetime``.
+    A moment already past is refused.
+
+    >>> t0 = datetime(2026, 1, 1, tzinfo=timezone.utc)
+    >>> parse_expires("2d", now=t0)
+    '2026-01-03T00:00:00+00:00'
+    >>> parse_expires("2026-01-05", now=t0)
+    '2026-01-05T23:59:59+00:00'
+    >>> parse_expires("never") is None
+    True
+    """
+    now = now or now_utc()
+    if value is None or (isinstance(value, str) and value.strip().lower() in NEVER):
+        return None
+    if isinstance(value, datetime):
+        when = value
+    else:
+        s = str(value).strip()
+        m = _DURATION_RE.match(s)
+        if m:
+            n, unit = int(m.group(1)), DURATION_UNITS[m.group(2).lower()]
+            try:
+                when = now + timedelta(**{unit: n})
+            except OverflowError:
+                raise ValueError(f"expiry {value!r} is too far away") from None
+        elif _DATE_RE.fullmatch(s):
+            when = datetime.fromisoformat(s).replace(
+                hour=23, minute=59, second=59, tzinfo=timezone.utc
+            )
+        else:
+            try:
+                when = datetime.fromisoformat(s.replace("Z", "+00:00"))
+            except ValueError:
+                raise ValueError(
+                    f"not an expiry: {value!r}; give a duration (7d, 12h), a date "
+                    "(2026-11-01) or an ISO timestamp"
+                ) from None
+    try:
+        when = _as_utc(when)
+    except OverflowError:
+        raise ValueError(f"expiry {value!r} is too far away") from None
+    if when <= now:
+        raise ValueError(f"expiry {when.isoformat()} is already past")
+    return when.isoformat()
+
+
+def expires_at(record: dict) -> datetime | None:
+    """The record's expiry as a UTC ``datetime``, ``None`` for never.
+
+    Raises ``ValueError`` on a value that is not a timestamp.
+    """
+    exp = record.get("expires")
+    if exp is None:
+        return None
+    try:
+        return _as_utc(datetime.fromisoformat(exp))
+    except (TypeError, OverflowError):
+        raise ValueError(f"not a timestamp: {exp!r}") from None
+
+
+def is_expired(record: dict, *, now: datetime | None = None) -> bool:
+    """True when the record has an expiry and it is reached (a bad one counts as reached).
+
+    >>> is_expired({"expires": None}), is_expired({"expires": "garbage"})
+    (False, True)
+    """
+    try:
+        when = expires_at(record)
+    except ValueError:
+        return True  # fail closed
+    return when is not None and (now or now_utc()) >= when

caplinks/limits.py

@@ -0,0 +1,74 @@
+"""Limiting password attempts: the ``allow(key) -> bool`` protocol and an in-memory default.
+
+A host decides what to count (one client on one link, every wrong password a link
+takes, ...) and keys the limiter accordingly. The protocol is the shape of
+``heed.security``'s limiters, so its ``RedisRateLimiter`` (one count shared by every
+worker) fits wherever a :class:`RateLimiter` is asked for.
+"""
+
+from __future__ import annotations
+
+import threading
+import time
+from collections import OrderedDict, deque
+from typing import Callable, Protocol, runtime_checkable
+
+#: attempts one key may make in each window, by default
+DFLT_MAX_PER_WINDOW = 10
+DFLT_WINDOW_S = 300.0
+#: keys tracked at most, so a flood of addresses cannot exhaust memory
+DFLT_MAX_KEYS = 50_000
+
+
+@runtime_checkable
+class RateLimiter(Protocol):
+    """Decide whether one more attempt keyed by ``key`` is allowed now."""
+
+    def allow(self, key: str) -> bool: ...
+
+
+class SlidingWindowLimiter:
+    """At most ``max_per_window`` hits per key per window; in memory, per process.
+
+    Each worker counts alone (two workers allow twice the attempts); pass a shared
+    limiter when that matters. The least recently seen keys are dropped past
+    ``max_keys``.
+
+    >>> t = [0.0]
+    >>> lim = SlidingWindowLimiter(max_per_window=2, window_s=10, clock=lambda: t[0])
+    >>> [lim.allow("a"), lim.allow("a"), lim.allow("a"), lim.allow("b")]
+    [True, True, False, True]
+    >>> t[0] = 10.0; lim.allow("a")
+    True
+    """
+
+    def __init__(
+        self,
+        *,
+        max_per_window: int = DFLT_MAX_PER_WINDOW,
+        window_s: float = DFLT_WINDOW_S,
+        max_keys: int = DFLT_MAX_KEYS,
+        clock: Callable[[], float] = time.monotonic,
+    ):
+        if max_per_window < 1 or max_keys < 1:
+            raise ValueError("max_per_window and max_keys must be at least 1")
+        self.max_per_window = max_per_window
+        self.window_s = window_s
+        self.max_keys = max_keys
+        self._clock = clock
+        self._hits: OrderedDict[str, deque] = OrderedDict()
+        self._lock = threading.Lock()  # web hosts call limiters from a threadpool
+
+    def allow(self, key: str) -> bool:
+        with self._lock:
+            now = self._clock()
+            hits = self._hits.setdefault(key, deque())
+            self._hits.move_to_end(key)
+            while len(self._hits) > self.max_keys:
+                self._hits.popitem(last=False)
+            while hits and hits[0] <= now - self.window_s:
+                hits.popleft()
+            if len(hits) >= self.max_per_window:
+                return False
+            hits.append(now)
+            return True

caplinks/links.py

@@ -0,0 +1,244 @@
+"""Capability links: a record behind an unguessable token, with an optional password gate.
+
+Knowing the token is the permission. A record is a plain dict, stored in any
+``MutableMapping`` keyed by token; the generic fields are :data:`RECORD_FIELDS`, and a
+host puts what the link reaches (its scope) in fields of its own beside them::
+
+    {"token": "<22 url-safe chars, 128 random bits>",
+     "created": "<iso>", "expires": "<iso>" | None,
+     "password": "scrypt$..." | None,     # a hash; the password is never stored
+     "revoked": "<iso>" | None,           # a tombstone: a revoked link is missing
+     ...the host's fields...}
+
+A correct password earns an unlock value (a cookie, for a web host): an HMAC keyed by
+the stored hash, so a new password, or a revoke, which clears the hash, ends every open
+session at once.
+
+The store contract: a store that cannot vouch for a record (unreadable, damaged, or
+missing the host's own fields) raises ``KeyError``, ``ValueError`` or ``OSError`` when
+it is read, and the link is then missing. A record whose generic fields have the wrong
+types is missing too: every failure closes the link.
+
+>>> links = CapabilityLinks()
+>>> rec = links.create({"what": "report-1"}, password="open sesame", expires="7d")
+>>> links.status(rec["token"])[0], rec["protected"], "password" in rec
+('ok', True, False)
+"""
+
+from __future__ import annotations
+
+import hashlib
+import hmac
+import re
+import secrets
+from collections.abc import Callable, Mapping, MutableMapping
+from datetime import datetime
+
+from caplinks.expiry import expires_at, is_expired, now_utc, parse_expires
+from caplinks.passwords import PasswordHasher, ScryptHasher
+
+TOKEN_BYTES = 16  # 128 bits
+TOKEN_RE = re.compile(r"^[A-Za-z0-9_-]{20,64}$")
+#: the fields every record has; a host's own fields may not reuse these names
+RECORD_FIELDS = ("token", "created", "expires", "password", "revoked")
+#: fields the owner's view of a record adds (:func:`public_record`, ``list``)
+_VIEW_FIELDS = ("protected", "active")
+#: a link lasts this long unless told otherwise (``"never"`` for no expiry)
+DFLT_EXPIRES = "7d"
+#: the shortest link password accepted (a gate tried from anywhere must not be guessable)
+MIN_PASSWORD_LEN = 8
+#: an unlock value issued this far in the future still counts (clock skew between workers)
+_UNLOCK_SKEW_S = 60
+
+
+def new_token() -> str:
+    """A fresh link token: 128 random bits, url-safe."""
+    return secrets.token_urlsafe(TOKEN_BYTES)
+
+
+def check_token(token: str) -> str:
+    """Return ``token``; raise ``ValueError`` on anything that could not be one.
+
+    >>> check_token("../../etc/passwd")
+    Traceback (most recent call last):
+    ...
+    ValueError: not a link token
+    """
+    if not isinstance(token, str) or not TOKEN_RE.match(token):
+        raise ValueError("not a link token")
+    return token
+
+
+def public_record(record: dict) -> dict:
+    """A record without its password hash; ``protected`` says whether it has one."""
+    out = {k: v for k, v in record.items() if k != "password"}
+    out["protected"] = bool(record.get("password"))
+    return out
+
+
+class CapabilityLinks:
+    """Create, read, list and revoke capability links, and gate them on a password.
+
+    ``store`` maps token to record (a ``dict`` by default, in process); ``hasher``
+    hashes link passwords (stdlib scrypt by default); ``clock`` returns the current UTC
+    ``datetime`` (tests pin it); ``min_password_len`` is the shortest password accepted.
+    """
+
+    def __init__(
+        self,
+        store: MutableMapping[str, dict] | None = None,
+        *,
+        hasher: PasswordHasher | None = None,
+        clock: Callable[[], datetime] = now_utc,
+        min_password_len: int = MIN_PASSWORD_LEN,
+    ):
+        self.store = {} if store is None else store
+        self.hasher = hasher or ScryptHasher()
+        self.clock = clock
+        self.min_password_len = min_password_len
+
+    # -- create / read / list / revoke --
+
+    def create(
+        self,
+        fields: Mapping | None = None,
+        *,
+        password: str | None = None,
+        expires=DFLT_EXPIRES,
+    ) -> dict:
+        """Make a link carrying the host's ``fields``; return its record without the hash.
+
+        ``expires`` is anything :func:`caplinks.expiry.parse_expires` reads, 7 days by
+        default (``"never"`` for none); ``password`` gates the link.
+        """
+        fields = dict(fields or {})
+        clash = sorted(set(fields) & {*RECORD_FIELDS, *_VIEW_FIELDS})
+        if clash:
+            raise ValueError(f"fields {clash} are the link's own; name yours otherwise")
+        if password is not None and len(password) < self.min_password_len:
+            raise ValueError(
+                f"a link password needs at least {self.min_password_len} characters "
+                "(anyone can try it); omit it for no password"
+            )
+        now = self.clock()
+        record = {
+            "token": new_token(),
+            "created": now.isoformat(),
+            **fields,
+            "expires": parse_expires(expires, now=now),
+            "password": self.hasher.hash(password) if password else None,
+            "revoked": None,
+        }
+        self.store[record["token"]] = record
+        return public_record(record)
+
+    def record(self, token: str) -> dict | None:
+        """A copy of the stored record (hash included), revoked or not; ``None`` if none."""
+        try:
+            rec = self.store[check_token(token)]
+        except (KeyError, ValueError, OSError):
+            return None
+        if not _well_formed(rec, token):
+            return None  # damaged, or filed under another name: grants nothing
+        return dict(rec)
+
+    def status(self, token: str) -> tuple[str, dict | None]:
+        """``("ok" | "expired" | "missing", record)``; a revoked link is ``missing``."""
+        rec = self.record(token)
+        if rec is None or rec.get("revoked"):
+            return "missing", None
+        if is_expired(rec, now=self.clock()):
+            return "expired", rec
+        return "ok", rec
+
+    def list(self, *, include_inactive: bool = False) -> list[dict]:
+        """Every live link, newest first, without hashes; ``include_inactive`` adds
+        revoked and expired ones.
+
+        Each record gains ``active`` (neither revoked nor expired).
+        """
+        now = self.clock()
+        out = []
+        for token in list(self.store):
+            rec = self.record(token)
+            if rec is None:
+                continue
+            rec = public_record(rec)
+            rec["active"] = not rec.get("revoked") and not is_expired(rec, now=now)
+            if include_inactive or rec["active"]:
+                out.append(rec)
+        return sorted(out, key=lambda r: r["created"], reverse=True)
+
+    def revoke(self, token: str) -> dict:
+        """End a link now (idempotent). The record stays, as a tombstone."""
+        rec = self.record(token)
+        if rec is None:
+            raise KeyError(token)
+        if not rec.get("revoked"):
+            rec = {**rec, "revoked": self.clock().isoformat(), "password": None}
+            self.store[token] = rec  # no hash left: nothing to guess, no session lives
+        return public_record(rec)
+
+    # -- the password gate --
+
+    def check_password(self, record: dict, password: str) -> bool:
+        """Whether ``password`` opens ``record`` (constant time inside the hasher)."""
+        hashed = record.get("password")
+        return bool(hashed) and self.hasher.verify(hashed, password)
+
+    def unlock_value(self, record: dict) -> str:
+        """What a correct password earns, to send back on later requests: ``<epoch>.<mac>``."""
+        issued = int(self.clock().timestamp())
+        return f"{issued}.{_unlock_mac(record, issued)}"
+
+    def unlocked(self, record: dict, value: str | None, *, max_age_s: int) -> bool:
+        """Whether ``value`` is a live unlock of ``record`` (no password: always).
+
+        A revoked record is never unlocked, whatever the caller checked before.
+        """
+        if record.get("revoked"):
+            return False
+        if not record.get("password"):
+            return True
+        if not value or "." not in value:
+            return False
+        issued_s, _, mac = value.partition(".")
+        try:
+            issued = int(issued_s)
+        except ValueError:
+            return False
+        now = int(self.clock().timestamp())
+        if not (now - max_age_s <= issued <= now + _UNLOCK_SKEW_S):
+            return False
+        expected = _unlock_mac(record, issued)
+        return hmac.compare_digest(mac.encode("utf-8"), expected.encode("ascii"))
+
+    def unlock_max_age(self, record: dict, *, max_age_s: int) -> int:
+        """How long an unlock should last, in seconds: ``max_age_s``, never past expiry."""
+        try:
+            ends = expires_at(record)
+        except ValueError:
+            return 1
+        if ends is None:
+            return max_age_s
+        left = int((ends - self.clock()).total_seconds())
+        return max(1, min(max_age_s, left))
+
+
+def _well_formed(rec, token: str) -> bool:
+    """The generic fields have the types every method relies on."""
+    optional_str = lambda v: v is None or isinstance(v, str)  # noqa: E731
+    return (
+        isinstance(rec, dict)
+        and rec.get("token") == token
+        and isinstance(rec.get("created"), str)
+        and all(optional_str(rec.get(k)) for k in ("expires", "password", "revoked"))
+    )
+
+
+def _unlock_mac(record: dict, issued: int) -> str:
+    # Keyed by the password hash: it holds a random salt and never leaves the server, and
+    # a new password (or a revoke, which clears it) invalidates every unlock at once.
+    key = (record.get("password") or "").encode("utf-8")
+    msg = f"{record['token']}:{issued}".encode("ascii")
+    return hmac.new(key, msg, hashlib.sha256).hexdigest()

caplinks/passwords.py

@@ -0,0 +1,74 @@
+"""Password hashing for a link's password gate: a protocol and a stdlib default.
+
+A link password is a gate, not an account: it is hashed once when the link is made and
+checked on each unlock. :class:`ScryptHasher` needs nothing beyond the standard library;
+anything with the same two methods (an argon2id adapter, say) fits the ``hasher`` seam
+of :class:`caplinks.CapabilityLinks`.
+
+>>> h = ScryptHasher(n=2**4)  # tiny cost, for the example only
+>>> stored = h.hash("correct horse")
+>>> stored.startswith("scrypt$"), h.verify(stored, "correct horse"), h.verify(stored, "x")
+(True, True, False)
+"""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import hmac
+import secrets
+from dataclasses import dataclass
+from typing import Protocol, runtime_checkable
+
+
+@runtime_checkable
+class PasswordHasher(Protocol):
+    """What a link needs to gate on a password: ``verify`` returns a bool, never raises."""
+
+    def hash(self, password: str) -> str: ...
+
+    def verify(self, hashed: str, password: str) -> bool: ...
+
+
+@dataclass(frozen=True)
+class ScryptHasher:
+    """Stdlib ``hashlib.scrypt``, stored as ``scrypt$n$r$p$salt$hash`` (base64).
+
+    The parameters travel with the hash, so raising ``n`` later still verifies old
+    hashes. ``n=2**14, r=8`` costs ~16 MB and tens of ms per check, which a host's
+    attempt limit (:mod:`caplinks.limits`) bounds.
+    """
+
+    n: int = 2**14
+    r: int = 8
+    p: int = 1
+    salt_bytes: int = 16
+    dklen: int = 32
+
+    def _derive(self, password: str, salt: bytes, n: int, r: int, p: int) -> bytes:
+        return hashlib.scrypt(
+            password.encode("utf-8"),
+            salt=salt,
+            n=n,
+            r=r,
+            p=p,
+            dklen=self.dklen,
+            maxmem=2 * 128 * r * n + 2**20,
+        )
+
+    def hash(self, password: str) -> str:
+        salt = secrets.token_bytes(self.salt_bytes)
+        dk = self._derive(password, salt, self.n, self.r, self.p)
+        b64 = lambda b: base64.b64encode(b).decode("ascii")  # noqa: E731
+        return f"scrypt${self.n}${self.r}${self.p}${b64(salt)}${b64(dk)}"
+
+    def verify(self, hashed: str, password: str) -> bool:
+        try:
+            scheme, n, r, p, salt, dk = hashed.split("$")
+            if scheme != "scrypt":
+                return False
+            expected = base64.b64decode(dk)
+            got = self._derive(password, base64.b64decode(salt), int(n), int(r), int(p))
+        except (ValueError, TypeError, AttributeError):
+            return False
+        return hmac.compare_digest(got, expected)

caplinks-0.0.2.dist-info/METADATA

@@ -0,0 +1,66 @@
+Metadata-Version: 2.5
+Name: caplinks
+Version: 0.0.2
+Summary: Capability links: an unguessable token, an optional password gate, expiry, revocation and attempt limits. Standard library only.
+Project-URL: Homepage, https://github.com/i2mint/caplinks
+Project-URL: Repository, https://github.com/i2mint/caplinks
+Project-URL: Documentation, https://i2mint.github.io/caplinks
+Author: Thor Whalen
+License-Expression: MIT
+License-File: LICENSE
+Keywords: capability,expiry,password,rate limit,scrypt,share link,token
+Requires-Python: >=3.10
+Provides-Extra: dev
+Requires-Dist: pytest-cov>=4.0; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: sphinx-rtd-theme>=1.0; extra == 'docs'
+Requires-Dist: sphinx>=6.0; extra == 'docs'
+Description-Content-Type: text/markdown
+
+# caplinks
+
+Capability links: hand someone a link to one thing, with no account. The token is the permission; a password may gate it; it expires; it can be revoked; password attempts are limited. Standard library only, no web framework.
+
+```
+pip install caplinks
+```
+
+```python
+from caplinks import CapabilityLinks
+
+links = CapabilityLinks()  # records in a dict; pass any MutableMapping to persist them
+rec = links.create({"doc": "report-1"}, password="open sesame", expires="7d")
+url = f"https://example.com/s/{rec['token']}/"
+
+state, stored = links.status(rec["token"])   # "ok", "expired" or "missing"
+links.check_password(stored, "open sesame")  # True
+cookie = links.unlock_value(stored)          # what a correct password earns
+links.unlocked(stored, cookie, max_age_s=3600)  # True, until the password changes or the link is revoked
+links.revoke(rec["token"])                   # now "missing"
+```
+
+## What is in it
+
+- `CapabilityLinks`: create, read, list and revoke links, and gate them on a password. Records are plain dicts in any `MutableMapping` keyed by token: the generic fields are `token`, `created`, `expires`, `password` (a hash) and `revoked`; your own fields (what the link reaches) sit beside them.
+- `ScryptHasher` (stdlib scrypt) behind the `PasswordHasher` protocol (`hash`, `verify -> bool`): pass `hasher=` for argon2 or anything else.
+- `parse_expires` reads what people write (`30m`, `12h`, `7d`, `2w`, `2026-11-01` meaning the end of that day UTC, an ISO timestamp, `never`) and refuses the past; `is_expired` fails closed.
+- `SlidingWindowLimiter` behind the `RateLimiter` protocol (`allow(key) -> bool`): count password attempts per client, per link, or both. It is per process; a shared limiter of the same shape (Redis, say) fits where several workers serve the links.
+
+The unlock value is an HMAC keyed by the stored password hash, so changing the password or revoking the link (which clears the hash) ends every open session at once.
+
+## What stays with your app
+
+What a link reaches (its scope), how it is served (routes, cookie name, headers), and the attempt policy. `annals` (share links) is the first host.
+
+## Seams
+
+| keyword | default | for |
+|---|---|---|
+| `store` | `dict` | persistence: a dol store, a file-backed mapping, S3 |
+| `hasher` | `ScryptHasher()` | argon2id or another scheme |
+| `clock` | `now_utc` | tests that pin the time |
+| `min_password_len` | 8 | a stricter or laxer gate |
+
+A store that cannot vouch for a record raises `KeyError`, `ValueError` or `OSError` when it is read, and the link is then missing; so is a record whose generic fields have the wrong types. Every failure closes the link.

caplinks-0.0.2.dist-info/RECORD

@@ -0,0 +1,9 @@
+caplinks/__init__.py,sha256=mii9AgQoelgp_cYVPRl7rpLHUqc1nkfiefGx2Vuy6LM,1443
+caplinks/expiry.py,sha256=Pw_NSb9hQ6Kwm71_HMMkjL8J_HEhAS_tjb_mDFoPUv0,3986
+caplinks/limits.py,sha256=xAJwC-le0Zt9B-DIMeWXMlrH1xJWTpv7p68O0VU83fc,2639
+caplinks/links.py,sha256=gj96knz0Wc-rk-QN6BeffSY-0cIbHm6FZMGLndS7dQU,9827
+caplinks/passwords.py,sha256=nSbfIQsMotj2SkEic_-suNf4DDRg1A3z0PMuW8WzF2E,2556
+caplinks-0.0.2.dist-info/METADATA,sha256=8K3gft_Gh6FTFH_ugh-qcBdQlXVjDc6L3S0n9uQ6jRA,3508
+caplinks-0.0.2.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+caplinks-0.0.2.dist-info/licenses/LICENSE,sha256=ekE13yCE9fWWEJfP1NPnUJabZ_Wwrc6coKJV2ZZx27w,1068
+caplinks-0.0.2.dist-info/RECORD,,

caplinks-0.0.2.dist-info/WHEEL

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

caplinks-0.0.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Thor Whalen
+
+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.