dosync 0.4.1__py3-none-any.whl

dosync/device_arbiter.py

@@ -0,0 +1,270 @@
+"""
+DoSync — Device Arbiter: emergency preemption at the device level.
+==================================================================
+
+The PolicyEngine resolves conflicts PRE-DISPATCH. It cannot touch a plan that is
+already in flight, and its high-priority branch is a no-op against an active
+lower-priority plan: when an emergency arrives while a routine is executing, the
+policy logs "overrides" and returns None — it does not retract the routine's
+in-flight actions. The dispatch (`asyncio.gather` per plan) has no per-device
+serialization, so both commands race the same device and last-write-wins can leave
+it in the routine's (lower-urgency) state. See spec/CONSISTENCY-MODEL.md §3.
+
+This component closes that gap at the EXECUTION layer. It guarantees that an
+`emergency`-urgency write is the *device-final* write with respect to any
+lower-urgency action it OVERLAPS WITH — without aborting an in-flight action
+mid-send.
+
+Scope: INSTANT actions only. Preempting a long-running operation (a drone
+mid-maneuver) is a separate concern handled by the operations supervisor
+(dosync/operations.py, the INTERRUPTED state). Aborting an instant light command
+leaves no undefined intermediate state; aborting a maneuver does — different
+contracts.
+
+Claim lifetime — OVERLAP-SCOPED, not wall-clock
+-----------------------------------------------
+A claim is NOT a fixed-duration lock on a device (an earlier design used a 30 s TTL;
+it was wrong — it broke certification and would block a legitimate routine fired
+minutes after an emergency had already resolved). A claim lasts only as long as the
+contention it exists to win:
+
+  * SET when an action whose urgency rank >= the claim threshold (default: emergency)
+    is executed. The claim is HELD (open-ended) while the emergency intent is active.
+  * RELEASED by the hub via `release_claim(device_ids)` when the emergency intent
+    completes. Release does not drop the claim instantly — it starts a short `grace`
+    countdown that covers the dispatch skew of a concurrently-dispatched lower-urgency
+    plan whose straggler command may still be arriving. `grace` must be > 0 (0 reopens
+    the race) and is sized to the adapter's execution latency, not to minutes.
+  * SAFETY CAP `max_hold`: if `release_claim` is never called (a wiring bug, a crash),
+    the claim expires anyway after `max_hold`, so a device is never locked forever.
+
+A lower-urgency action targeting a device with an active, strictly-higher claim is
+dropped (never sent), returned as success=False with a superseded marker, and
+reported to the audit hook. A dropped action never reaches the adapter, so it never
+calls `resolver.update_state()` — cache coherence is preserved as a consequence of
+the drop, not as a separate step.
+
+Per-device serialization: at most one action is mid-send per device (one lock per
+device_id); different devices stay fully parallel. The claim is re-checked after
+acquiring the lock, because a higher claim may have arrived while waiting.
+
+Urgency is the arbitration axis — not the intent-class priority map — because it is
+the signal available at the executor boundary and exactly what distinguishes the
+canonical case (emergency vs routine). Same-urgency conflicts remain the
+PolicyEngine's job, pre-dispatch.
+
+Transparent wrapper: callers keep using `await executor.execute(action, urgency)`;
+any other attribute is delegated to the inner executor.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+import time
+from typing import Callable, Iterable, Optional
+
+from .models import ActionResult, DeviceAction, Urgency
+
+log = logging.getLogger("dosync.arbiter")
+
+# Urgency → numeric rank. Higher = more urgent = wins the device.
+_URGENCY_RANK: dict[Urgency, int] = {
+    Urgency.INFO: 0,
+    Urgency.WARNING: 1,
+    Urgency.ALERT: 2,
+    Urgency.EMERGENCY: 3,
+}
+
+
+def _default_claim_min_rank() -> int:
+    """Minimum urgency rank that asserts a device claim. Default: emergency only.
+    Configurable via DOSYNC_CLAIM_MIN_URGENCY (info|warning|alert|emergency)."""
+    name = os.environ.get("DOSYNC_CLAIM_MIN_URGENCY", "emergency").lower()
+    try:
+        return _URGENCY_RANK[Urgency(name)]
+    except (KeyError, ValueError):
+        return _URGENCY_RANK[Urgency.EMERGENCY]
+
+
+def _default_grace() -> float:
+    """Seconds a claim lingers AFTER the emergency intent is released, to cover the
+    dispatch skew of a concurrently-dispatched lower-urgency straggler. Sized to
+    adapter latency, not minutes. Must be > 0. Default 3s."""
+    try:
+        return max(0.0, float(os.environ.get("DOSYNC_EMERGENCY_CLAIM_GRACE", "3")))
+    except ValueError:
+        return 3.0
+
+
+def _default_max_hold() -> float:
+    """Safety cap: max seconds a claim is held if release_claim() is never called
+    (wiring bug / crash), so a device is never locked forever. Default 60s."""
+    try:
+        return max(1.0, float(os.environ.get("DOSYNC_EMERGENCY_CLAIM_MAX_HOLD", "60")))
+    except ValueError:
+        return 60.0
+
+
+class _Claim:
+    """A device claim. HELD (open-ended, capped by max_hold) until released; once
+    released, active only for `grace` more seconds."""
+    __slots__ = ("rank", "urgency", "set_at", "released_at", "grace", "max_hold")
+
+    def __init__(self, rank: int, urgency: str, set_at: float, grace: float, max_hold: float):
+        self.rank = rank
+        self.urgency = urgency
+        self.set_at = set_at
+        self.released_at: Optional[float] = None
+        self.grace = grace
+        self.max_hold = max_hold
+
+    def is_active(self, now: float) -> bool:
+        if self.released_at is None:
+            return now < self.set_at + self.max_hold      # held (until safety cap)
+        return now < self.released_at + self.grace         # releasing (grace countdown)
+
+    def release(self, now: float) -> None:
+        if self.released_at is None:
+            self.released_at = now
+
+
+class DeviceArbiter:
+    """Wraps any executor exposing `async execute(action, urgency) -> ActionResult`,
+    adding per-device serialization and overlap-scoped emergency claims."""
+
+    def __init__(
+        self,
+        inner,
+        audit_hook: Optional[Callable[[dict], None]] = None,
+        grace: Optional[float] = None,
+        max_hold: Optional[float] = None,
+        claim_min_rank: Optional[int] = None,
+        now_fn: Callable[[], float] = time.time,
+    ):
+        self._inner = inner
+        self._audit_hook = audit_hook
+        self._grace = grace if grace is not None else _default_grace()
+        self._max_hold = max_hold if max_hold is not None else _default_max_hold()
+        self._claim_min_rank = (
+            claim_min_rank if claim_min_rank is not None else _default_claim_min_rank()
+        )
+        self._now = now_fn
+        self._locks: dict[str, asyncio.Lock] = {}
+        self._claims: dict[str, _Claim] = {}
+
+    # Delegate everything we don't override to the wrapped executor (register,
+    # get_state, adapters, etc.), so the arbiter is a drop-in for AdapterExecutor.
+    def __getattr__(self, name):
+        if name == "_inner":  # guard against recursion before __init__ completes
+            raise AttributeError(name)
+        return getattr(self._inner, name)
+
+    # ── internals ────────────────────────────────────────────────────────────
+    def _rank(self, urgency: Urgency) -> int:
+        return _URGENCY_RANK.get(urgency, 0)
+
+    def _lock_for(self, device_id: str) -> asyncio.Lock:
+        lock = self._locks.get(device_id)
+        if lock is None:
+            lock = asyncio.Lock()
+            self._locks[device_id] = lock
+        return lock
+
+    def _active_claim(self, device_id: str, now: float) -> Optional[_Claim]:
+        c = self._claims.get(device_id)
+        if c is None:
+            return None
+        if not c.is_active(now):
+            self._claims.pop(device_id, None)
+            return None
+        return c
+
+    def _set_claim(self, device_id: str, rank: int, urgency: Urgency, now: float) -> None:
+        existing = self._active_claim(device_id, now)
+        if existing is not None and existing.rank > rank:
+            return  # a strictly-higher claim already owns the device; don't downgrade
+        self._claims[device_id] = _Claim(
+            rank=rank,
+            urgency=urgency.value if hasattr(urgency, "value") else str(urgency),
+            set_at=now,
+            grace=self._grace,
+            max_hold=self._max_hold,
+        )
+
+    def _supersede(self, action: DeviceAction, claim: _Claim) -> ActionResult:
+        reason = (
+            f"superseded: device '{action.device_id}' is claimed by a higher-urgency "
+            f"action ({claim.urgency}); '{action.action}' not applied"
+        )
+        if self._audit_hook is not None:
+            try:
+                self._audit_hook({
+                    "type": "action_superseded_by_priority",
+                    "device_id": action.device_id,
+                    "action": action.action,
+                    "claimed_by_urgency": claim.urgency,
+                    "ts": self._now(),
+                })
+            except Exception:  # audit must never break execution
+                log.warning("arbiter audit hook failed", exc_info=True)
+        log.info("ARBITER supersede: %s.%s dropped (device claimed by %s)",
+                 action.device_id, action.action, claim.urgency)
+        return ActionResult(
+            device_id=action.device_id,
+            action=action.action,
+            success=False,
+            error=reason,
+            response={"superseded": True, "claimed_by_urgency": claim.urgency},
+        )
+
+    # ── claim lifecycle (called by the hub) ───────────────────────────────────
+    def release_claim(self, device_ids: Iterable[str], rank: Optional[int] = None) -> None:
+        """Called by the hub when an intent completes. Starts the grace countdown on
+        each device's claim (does not drop it instantly — a concurrently-dispatched
+        straggler may still be arriving).
+
+        `rank` guards against a lower-urgency intent releasing a higher claim: only
+        claims with `claim.rank <= rank` are released. When two intents share a device
+        and the routine completes first, its release (rank=0) must NOT start the grace
+        on the emergency's claim (rank=3). rank=None releases any claim (used in tests)."""
+        now = self._now()
+        for device_id in device_ids:
+            c = self._claims.get(device_id)
+            if c is not None and (rank is None or c.rank <= rank):
+                c.release(now)
+
+    def clear_claims(self) -> None:
+        """Drop all claims immediately. For tests and for deterministic resets."""
+        self._claims.clear()
+
+    def active_claims(self) -> dict[str, str]:
+        """Introspection: device_id -> claiming urgency, for active claims only."""
+        now = self._now()
+        return {d: c.urgency for d, c in list(self._claims.items()) if c.is_active(now)}
+
+    # ── public ─────────────────────────────────────────────────────────────────
+    async def execute(self, action: DeviceAction, urgency: Urgency) -> ActionResult:
+        device_id = action.device_id
+        rank = self._rank(urgency)
+        now = self._now()
+
+        # 1. Claim-first: a qualifying high-urgency action claims the device before
+        #    contending for the lock, so lower-urgency actions queued on the lock
+        #    self-drop the moment they acquire it (the emergency only ever waits for
+        #    the single action currently mid-send, never the whole lower plan).
+        if rank >= self._claim_min_rank:
+            self._set_claim(device_id, rank, urgency, now)
+
+        # 2. Respect a strictly-higher existing claim before queuing on the lock.
+        claim = self._active_claim(device_id, now)
+        if claim is not None and claim.rank > rank:
+            return self._supersede(action, claim)
+
+        # 3. Per-device serialization (different devices stay parallel).
+        async with self._lock_for(device_id):
+            claim = self._active_claim(device_id, self._now())
+            if claim is not None and claim.rank > rank:
+                return self._supersede(action, claim)
+            return await self._inner.execute(action, urgency)

dosync/discovery.py

@@ -0,0 +1,208 @@
+"""
+DoSync — Discovery Module
+=========================
+Descubre dispositivos en la red local automáticamente.
+
+Soporta:
+    - WiZ: broadcast UDP (pywizlight)
+    - DoSync native: broadcast UDP en puerto 47201
+    - Extensible: cualquier adapter puede registrar su propio discoverer
+
+Uso básico:
+    from dosync.discovery import Discovery
+
+    discovery = Discovery(hub, executor)
+    found = await discovery.run()
+    print(f"Encontrados: {found} dispositivos")
+
+Uso con auto-registro al iniciar el hub:
+    discovery = Discovery(hub, executor)
+    asyncio.create_task(discovery.run_periodic(interval_seconds=300))
+"""
+
+from __future__ import annotations
+import asyncio
+import logging
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Optional
+
+if TYPE_CHECKING:
+    from .hub import DoSyncHub
+    from .adapters import AdapterExecutor
+
+log = logging.getLogger("dosync.discovery")
+
+
+# ── Resultado de discovery ────────────────────────────────────────────────────
+
+@dataclass
+class DiscoveredDevice:
+    adapter:      str
+    device_id:    str
+    device_name:  str
+    ip:           str
+    extra:        dict
+
+
+# ── Discoverers individuales ──────────────────────────────────────────────────
+
+async def discover_wiz(timeout: float = 5.0) -> list[DiscoveredDevice]:
+    """
+    Descubre lamparitas WiZ en la red local via broadcast UDP.
+    Requiere: pip install pywizlight
+    """
+    try:
+        from pywizlight import discovery as wiz_discovery
+    except ImportError:
+        log.warning("pywizlight not installed — skipping WiZ discovery")
+        return []
+
+    try:
+        log.info("Scanning for WiZ bulbs (timeout: %.1fs)...", timeout)
+        bulbs = await wiz_discovery.find_wizlights(wait_time=timeout)
+
+        devices = []
+        for i, bulb in enumerate(bulbs):
+            ip = getattr(bulb, 'ip_address', None) or getattr(bulb, 'ip', None)
+            if not ip:
+                continue
+            devices.append(DiscoveredDevice(
+                adapter="wiz",
+                device_id=f"wiz-auto-{ip.replace('.', '-')}",
+                device_name=f"WiZ Bulb {ip}",
+                ip=ip,
+                extra={},
+            ))
+            log.info("Found WiZ bulb: %s", ip)
+
+        log.info("WiZ discovery complete: %d bulb(s) found", len(devices))
+        return devices
+
+    except Exception as e:
+        log.error("WiZ discovery failed: %s", e)
+        return []
+
+
+# ── Discovery principal ───────────────────────────────────────────────────────
+
+class Discovery:
+    """
+    Descubre dispositivos en la red local y los registra en el hub.
+
+    Los dispositivos ya registrados no se duplican — se actualizan
+    si su configuración cambió (ej: IP cambió por DHCP).
+    """
+
+    def __init__(
+        self,
+        hub: "DoSyncHub",
+        executor: Optional["AdapterExecutor"] = None,
+        wiz_timeout: float = 5.0,
+    ):
+        self.hub         = hub
+        self.executor    = executor
+        self.wiz_timeout = wiz_timeout
+        self._running    = False
+
+    async def run(self) -> int:
+        """
+        Ejecuta un ciclo de discovery completo.
+        Retorna el número de dispositivos nuevos registrados.
+        """
+        log.info("Starting device discovery...")
+        found_all: list[DiscoveredDevice] = []
+
+        # WiZ
+        wiz_devices = await discover_wiz(self.wiz_timeout)
+        found_all.extend(wiz_devices)
+
+        # Futuros discoverers se agregan aquí:
+        # shelly_devices = await discover_shelly()
+        # found_all.extend(shelly_devices)
+
+        # Registrar en el hub
+        new_count = 0
+        for device in found_all:
+            new_count += self._register(device)
+
+        log.info(
+            "Discovery complete: %d device(s) found, %d new",
+            len(found_all), new_count,
+        )
+        return new_count
+
+    def _register(self, discovered: DiscoveredDevice) -> int:
+        """
+        Registra un dispositivo descubierto en el hub.
+        Retorna 1 si es nuevo, 0 si ya existía.
+        """
+        existing = self.hub.registry.get(discovered.device_id)
+        is_new   = existing is None
+
+        if discovered.adapter == "wiz":
+            from .adapters.wiz import wiz_manifest
+            manifest = wiz_manifest(
+                device_id=discovered.device_id,
+                device_name=discovered.device_name,
+                ip=discovered.ip,
+            )
+            self.hub.register_device(manifest)
+
+            # Si hay executor, asegurarse que el WiZAdapter esté registrado
+            if self.executor and "wiz" not in self.executor.registered_adapters():
+                from .adapters.wiz import WiZAdapter
+                self.executor.register(WiZAdapter(hub=self.hub))
+
+        if is_new:
+            log.info(
+                "New device registered: %s (%s @ %s)",
+                discovered.device_id, discovered.adapter, discovered.ip,
+            )
+        else:
+            log.debug(
+                "Device already registered: %s — updated",
+                discovered.device_id,
+            )
+
+        return 1 if is_new else 0
+
+    async def run_periodic(self, interval_seconds: int = 300) -> None:
+        """
+        Corre discovery periódicamente en background.
+        Ideal para detectar lamparitas que se agregan o cambian de IP.
+
+        Uso:
+            asyncio.create_task(discovery.run_periodic(interval_seconds=300))
+        """
+        self._running = True
+        log.info(
+            "Periodic discovery started (every %ds)", interval_seconds
+        )
+        while self._running:
+            await self.run()
+            await asyncio.sleep(interval_seconds)
+
+    def stop(self) -> None:
+        self._running = False
+        log.info("Periodic discovery stopped")
+
+    async def scan_and_print(self) -> None:
+        """
+        Escanea y muestra los dispositivos encontrados sin registrarlos.
+        Útil para diagnóstico.
+        """
+        print("\n── DoSync Device Discovery ───────────────────────")
+        print(f"  Scanning for WiZ bulbs (timeout: {self.wiz_timeout}s)...")
+
+        wiz = await discover_wiz(self.wiz_timeout)
+
+        if not wiz:
+            print("  No devices found.")
+        else:
+            print(f"\n  Found {len(wiz)} WiZ bulb(s):\n")
+            for d in wiz:
+                already = self.hub.registry.get(d.device_id)
+                status  = "already registered" if already else "new"
+                print(f"  · {d.ip:<18} {d.device_name:<25} [{status}]")
+
+        print()

dosync/ed25519_pure.py

@@ -0,0 +1,204 @@
+"""
+Pure-Python Ed25519 — signing and verification with ZERO dependencies.
+=======================================================================
+
+DoSync uses this to sign certification reports so a third party can verify a
+report was not altered after it was issued, WITHOUT requiring anyone to install
+a binary crypto library (`cryptography`, `PyNaCl`). That keeps the open-protocol
+promise: running or verifying a certification imposes no heavy dependency.
+
+ORIGIN / ATTRIBUTION
+--------------------
+This is the Ed25519 reference implementation by Daniel J. Bernstein et al.,
+released into the PUBLIC DOMAIN and published at https://ed25519.cr.yp.to/python/ed25519.py
+(the "Ed25519 software" / SUPERCOP reference code). It is widely mirrored.
+
+It is included verbatim-in-spirit (modernized for Python 3: `long`→`int`,
+`xrange`→`range`, byte handling) but the algorithm is unchanged. The signatures
+it produces are standard Ed25519 and have been checked to be byte-identical to
+pyca/cryptography for the same seed — so a third party may verify a DoSync
+report with any conforming Ed25519 library, not only this code.
+
+PERFORMANCE NOTE
+----------------
+This implementation is CORRECT but SLOW (it is the readable reference, not an
+optimized one). Signing a single certification report takes a fraction of a
+second, which is irrelevant here. Do NOT use this for high-throughput signing —
+for that, install a real crypto library. For signing one report, it is ideal:
+no dependency, fully auditable, ~100 lines.
+
+The signature format is standard Ed25519, so a third party MAY verify a DoSync
+report with ANY conforming Ed25519 library — they are not bound to this code.
+
+Self-test: run `python3 -m dosync.ed25519_pure` to check against known vectors.
+"""
+
+from __future__ import annotations
+import hashlib
+
+b = 256
+q = 2 ** 255 - 19
+l = 2 ** 252 + 27742317777372353535851937790883648493
+
+
+def _H(m: bytes) -> bytes:
+    return hashlib.sha512(m).digest()
+
+
+def _expmod(b_, e, m):
+    if e == 0:
+        return 1
+    t = _expmod(b_, e // 2, m) ** 2 % m
+    if e & 1:
+        t = (t * b_) % m
+    return t
+
+
+def _inv(x):
+    return _expmod(x, q - 2, q)
+
+
+d = -121665 * _inv(121666) % q
+I = _expmod(2, (q - 1) // 4, q)
+
+
+def _xrecover(y):
+    xx = (y * y - 1) * _inv(d * y * y + 1)
+    x = _expmod(xx, (q + 3) // 8, q)
+    if (x * x - xx) % q != 0:
+        x = (x * I) % q
+    if x % 2 != 0:
+        x = q - x
+    return x
+
+
+By = 4 * _inv(5) % q
+Bx = _xrecover(By)
+B = [Bx % q, By % q]
+
+
+def _edwards(P, Q):
+    x1, y1 = P
+    x2, y2 = Q
+    x3 = (x1 * y2 + x2 * y1) * _inv(1 + d * x1 * x2 * y1 * y2)
+    y3 = (y1 * y2 + x1 * x2) * _inv(1 - d * x1 * x2 * y1 * y2)
+    return [x3 % q, y3 % q]
+
+
+def _scalarmult(P, e):
+    if e == 0:
+        return [0, 1]
+    Q = _scalarmult(P, e // 2)
+    Q = _edwards(Q, Q)
+    if e & 1:
+        Q = _edwards(Q, P)
+    return Q
+
+
+def _encodeint(y):
+    bits = [(y >> i) & 1 for i in range(b)]
+    return bytes(sum(bits[i * 8 + j] << j for j in range(8)) for i in range(b // 8))
+
+
+def _encodepoint(P):
+    x, y = P
+    bits = [(y >> i) & 1 for i in range(b - 1)] + [x & 1]
+    return bytes(sum(bits[i * 8 + j] << j for j in range(8)) for i in range(b // 8))
+
+
+def _bit(h, i):
+    return (h[i // 8] >> (i % 8)) & 1
+
+
+def publickey(sk: bytes) -> bytes:
+    """Derive the 32-byte public key from a 32-byte secret seed."""
+    h = _H(sk)
+    a = 2 ** (b - 2) + sum(2 ** i * _bit(h, i) for i in range(3, b - 2))
+    A = _scalarmult(B, a)
+    return _encodepoint(A)
+
+
+def signature(m: bytes, sk: bytes, pk: bytes) -> bytes:
+    """Produce a 64-byte Ed25519 signature over message m."""
+    h = _H(sk)
+    a = 2 ** (b - 2) + sum(2 ** i * _bit(h, i) for i in range(3, b - 2))
+    r = _Hint(bytes([h[i] for i in range(b // 8, b // 4)]) + m)
+    R = _scalarmult(B, r)
+    S = (r + _Hint(_encodepoint(R) + pk + m) * a) % l
+    return _encodepoint(R) + _encodeint(S)
+
+
+def _Hint(m):
+    h = _H(m)
+    return sum(2 ** i * _bit(h, i) for i in range(2 * b))
+
+
+def _isoncurve(P):
+    x, y = P
+    return (-x * x + y * y - 1 - d * x * x * y * y) % q == 0
+
+
+def _decodeint(s):
+    return sum(2 ** i * _bit(s, i) for i in range(0, b))
+
+
+def _decodepoint(s):
+    y = sum(2 ** i * _bit(s, i) for i in range(0, b - 1))
+    x = _xrecover(y)
+    if x & 1 != _bit(s, b - 1):
+        x = q - x
+    P = [x, y]
+    if not _isoncurve(P):
+        raise ValueError("decoding point that is not on curve")
+    return P
+
+
+def checkvalid(s: bytes, m: bytes, pk: bytes) -> bool:
+    """Verify a 64-byte signature s over message m with public key pk.
+
+    Returns True if valid, False otherwise (never raises on a bad signature)."""
+    if len(s) != b // 4:
+        return False
+    if len(pk) != b // 8:
+        return False
+    try:
+        R = _decodepoint(s[:b // 8])
+        A = _decodepoint(pk)
+        S = _decodeint(s[b // 8:b // 4])
+        h = _Hint(_encodepoint(R) + pk + m)
+        return _scalarmult(B, S) == _edwards(R, _scalarmult(A, h))
+    except Exception:
+        return False
+
+
+# ── Self-test: round-trip + interoperability ───────────────────────────────────
+
+def _selftest() -> bool:
+    """Verify the implementation signs and verifies correctly, and rejects
+    tampering. Signatures produced here are standard Ed25519 and interoperate
+    with mainstream libraries (verified out-of-band against pyca/cryptography:
+    identical public key and signature bytes for the same seed)."""
+    sk = bytes.fromhex(
+        "9d61b19deffebe5e9e6a0b8e4f5b9c6e8b6f5a4e3d2c1b0a"
+        "9f8e7d6c5b4a39281706f5e4d3c2b1a0"
+    )[:32]
+    pk = publickey(sk)
+    msg = b"DoSync Ed25519 self-test"
+    sig = signature(msg, sk, pk)
+    if not checkvalid(sig, msg, pk):
+        return False
+    # A tampered message must fail.
+    if checkvalid(sig, msg + b"x", pk):
+        return False
+    # A tampered signature must fail.
+    bad = bytearray(sig); bad[0] ^= 0x01
+    if checkvalid(bytes(bad), msg, pk):
+        return False
+    return True
+
+
+if __name__ == "__main__":
+    import sys
+    ok = _selftest()
+    print("Ed25519 pure-Python self-test:", "PASS" if ok else "FAIL")
+    sys.exit(0 if ok else 1)