capyy 0.3.0__py3-none-any.whl

capy/__init__.py

@@ -0,0 +1,275 @@
+# capy : mini-API en TCP, une ligne JSON par requête / réponse, chiffrée (TLS)
+
+import json as jsonlib  # "json" est pris par capy.json()
+import socket
+import threading
+
+from . import _tls
+from ._tls import SecurityError  # noqa: F401  (capy.SecurityError)
+
+
+# Serveur : @server.action("nom") pour déclarer une action, server.run() pour lancer
+# Le port se donne à Server(port) ou à run(port), au choix
+# Chiffré (TLS) par défaut ; tls=False pour parler en clair (le client aussi doit mettre tls=False)
+class Server:
+    def __init__(self, port=None, tls=True):
+        self.port, self.tls = port, tls
+        self.actions = {}
+        self.listening = False  # True une fois le serveur prêt
+        self._context = None
+
+    def action(self, name):
+        def decorator(function):
+            self.actions[name] = function
+            return function
+        return decorator
+
+    # {"action": "get", "id": 2} -> get(id=2)
+    def handle(self, line):
+        try:
+            request = jsonlib.loads(line)
+            function = self.actions[request.pop("action")]
+        except (ValueError, AttributeError, TypeError):  # pas du JSON, ou pas un objet {...}
+            return {"erreur": "JSON invalide"}
+        except KeyError:
+            return {"erreur": "action inconnue"}
+        try:
+            return function(**request)
+        except Exception as e:
+            return {"erreur": str(e)}
+
+    def client(self, conn, addr):
+        if self._context:
+            conn = _tls.accept(self._context, conn)
+            if conn is None:  # Le client ne parle pas en chiffré -> on raccroche
+                return
+        else:
+            conn.settimeout(10)
+        with conn:
+            try:
+                line = conn.makefile(encoding="utf-8").readline()
+                if not line.strip():  # Connexion ouverte puis fermée sans rien demander
+                    return
+                conn.sendall((jsonlib.dumps(self.handle(line), ensure_ascii=False) + "\n").encode())
+            except (OSError, ValueError):
+                return
+            print(f"{addr[0]} → {line.strip()}")
+
+    # port 0 -> le système choisit un port libre
+    def run(self, port=None):
+        self.port = self.port if port is None else port
+        if self.port is None:
+            raise ValueError("capy: aucun port, utilise Server(port) ou run(port)")
+        if self.tls:
+            self._context, empreinte = _tls.server_context("server")
+        with socket.create_server(("", self.port)) as server:
+            self.port = server.getsockname()[1]
+            self.listening = True
+            if self.tls:
+                print(f"API en écoute sur le port {self.port}, chiffrée (TLS) · empreinte : {empreinte}")
+            else:
+                print(f"API en écoute sur le port {self.port} (pas chiffrée)")
+            while True:
+                conn, addr = server.accept()
+                threading.Thread(target=self.client, args=(conn, addr), daemon=True).start()
+
+
+# Renvoyer du JSON écrit en texte depuis une action
+# Ex : return capy.json('{"text": "Hello"}')
+def json(text):
+    try:
+        return jsonlib.loads(text)
+    except ValueError as e:
+        raise ValueError(f"capy.json : JSON invalide ({e})") from None
+
+
+# ============================================================
+#  EXTRAIRE UNE VALEUR
+# ============================================================
+
+_NOTHING = object()  # Pour savoir si default a été donné (None est une vraie valeur)
+
+
+# Extraire une valeur d'un JSON (dict, liste, ou texte JSON) avec un chemin "a.b.0.c"
+# Ex : get('{"text": "Hello"}', "text") -> "Hello"
+#      get(reponse, "users.0.name") -> "Izac"  (0 = 1er élément d'une liste)
+#      get(reponse, "age", default=0) -> 0 si "age" n'existe pas (au lieu d'une erreur)
+def get(data, path, default=_NOTHING):
+    value = json(data) if isinstance(data, str) else data
+    for key in str(path).split("."):
+        if isinstance(value, dict) and key in value:
+            value = value[key]
+        elif isinstance(value, list) and key.lstrip("-").isdigit() and -len(value) <= int(key) < len(value):
+            value = value[int(key)]
+        elif default is not _NOTHING:
+            return default
+        elif isinstance(value, dict):
+            raise ValueError(f"capy.get : clé {key!r} introuvable dans {path!r} (clés : {', '.join(map(str, value)) or 'aucune'})")
+        elif isinstance(value, list):
+            raise ValueError(f"capy.get : {key!r} pas valable dans {path!r} (liste de {len(value)} éléments, 0 à {len(value) - 1})")
+        else:
+            raise ValueError(f"capy.get : impossible d'aller dans {key!r} de {path!r}, la valeur est un {type(value).__name__}")
+    return value
+
+
+# ============================================================
+#  CONVERSIONS
+# ============================================================
+#  Pour transformer une valeur reçue (réponse de capy.call, paramètre d'une action...)
+#  Si ça ne marche pas -> ValueError avec un message clair
+#  (dans une action, le client reçoit alors {"erreur": "..."})
+#  key (optionnel) : extraire d'abord une valeur, comme get()  ->  to_int(reponse, "age")
+
+# Erreur commune : "capy.to_int : impossible de transformer 'abc' (str) en int"
+def _error(name, data, target):
+    text = repr(data)
+    if len(text) > 60:
+        text = text[:60] + "…"
+    return ValueError(f"capy.{name} : impossible de transformer {text} ({type(data).__name__}) en {target}")
+
+
+# Du JSON (dict, liste...) -> texte JSON sur une ligne (un texte reste tel quel)
+# Ex : to_str({"text": "Hello"}) -> '{"text": "Hello"}'
+#      to_str('{"text": "Hello"}', "text") -> "Hello"
+def to_str(data, key=None):
+    if key is not None:
+        data = get(data, key)
+    if isinstance(data, str):
+        return data
+    try:
+        return jsonlib.dumps(data, ensure_ascii=False)
+    except (TypeError, ValueError):
+        raise _error("to_str", data, "texte JSON") from None
+
+
+# -> entier. Accepte 42, 42.0, "42", " 42 "
+# Ex : to_int("42") -> 42 / to_int("abc") -> ValueError
+def to_int(data, key=None):
+    if key is not None:
+        data = get(data, key)
+    if isinstance(data, bool):  # True est un int pour Python, mais pas pour nous
+        raise _error("to_int", data, "int")
+    if isinstance(data, int):
+        return data
+    if isinstance(data, float) and data.is_integer():
+        return int(data)
+    if isinstance(data, str):
+        try:
+            return to_int(float(data)) if "." in data else int(data)
+        except ValueError:
+            pass
+    raise _error("to_int", data, "int")
+
+
+# -> nombre à virgule. Accepte 4.5, 4, "4.5"
+# Ex : to_float("4.5") -> 4.5
+def to_float(data, key=None):
+    if key is not None:
+        data = get(data, key)
+    if not isinstance(data, bool) and isinstance(data, (int, float, str)):
+        try:
+            return float(data)
+        except ValueError:
+            pass
+    raise _error("to_float", data, "float")
+
+
+# -> True / False. Accepte true/false, 1/0, "true"/"false", "oui"/"non", "1"/"0"
+# Ex : to_bool("oui") -> True
+def to_bool(data, key=None):
+    if key is not None:
+        data = get(data, key)
+    if isinstance(data, bool):
+        return data
+    if data in (0, 1):
+        return bool(data)
+    if isinstance(data, str):
+        text = data.strip().lower()
+        if text in ("true", "oui", "yes", "1"):
+            return True
+        if text in ("false", "non", "no", "0"):
+            return False
+    raise _error("to_bool", data, "bool")
+
+
+# -> liste. Accepte une liste, un tuple, ou du texte JSON '[1, 2]'
+# Ex : to_list("[1, 2]") -> [1, 2]
+def to_list(data, key=None):
+    if key is not None:
+        data = get(data, key)
+    if isinstance(data, (list, tuple)):
+        return list(data)
+    if isinstance(data, str):
+        try:
+            value = jsonlib.loads(data)
+        except ValueError:
+            value = None
+        if isinstance(value, list):
+            return value
+    raise _error("to_list", data, "list")
+
+
+# -> dict. Accepte un dict, ou du texte JSON '{"a": 1}'
+# Ex : to_dict('{"a": 1}') -> {"a": 1}
+def to_dict(data, key=None):
+    if key is not None:
+        data = get(data, key)
+    if isinstance(data, dict):
+        return data
+    if isinstance(data, str):
+        try:
+            value = jsonlib.loads(data)
+        except ValueError:
+            value = None
+        if isinstance(value, dict):
+            return value
+    raise _error("to_dict", data, "dict")
+
+
+# Client : capy.call("127.0.0.1", 4000, "get", id=2) -> dict
+# Lève ConnectionError si le serveur ne répond pas, SecurityError si ce n'est pas le bon serveur
+# tls=False : pour un serveur pas chiffré (Server(..., tls=False))
+def call(host, port, action, /, tls=True, **params):
+    return _call(host, port, action, params, tls, label=f"{host}:{port}")
+
+
+# Envoyer une demande et lire la réponse
+# label : sous quel nom retenir l'empreinte du serveur ("ip:port", "wifi:salon"...)
+def _call(host, port, action, params, tls, label, who="capy"):
+    if not isinstance(host, str) or isinstance(port, bool) or not isinstance(port, int):
+        raise TypeError(
+            f"capy.call : l'ordre est call(host, port, action), ex : call(\"localhost\", 4000, \"get\")"
+            f" -> reçu call({host!r}, {port!r}, {action!r})"
+        )
+    if "://" in host:  # capy parle en TCP, pas en HTTP
+        raise ValueError(f"capy.call : host est un nom ou une IP, pas une URL -> {host.split('://', 1)[1].strip('/')!r}")
+    connected = False
+    hint = " — il est peut-être chiffré : enlève tls=False" if not tls else ""
+    try:
+        if tls:
+            conn = _tls.connect(host, port, label, timeout=3, who=who)
+        else:
+            conn = socket.create_connection((host, port), timeout=3)
+        connected = True
+        with conn:
+            conn.sendall((jsonlib.dumps({"action": action, **params}) + "\n").encode())
+            line = conn.makefile(encoding="utf-8").readline()
+        if not line:
+            raise ConnectionError(f"{who} : le serveur {host}:{port} n'a rien répondu{hint}")
+        return jsonlib.loads(line)
+    except ConnectionError as e:
+        if str(e).startswith(who):  # Message déjà clair (ex : chiffrement impossible)
+            raise
+        error = e
+    except (OSError, ValueError) as e:
+        error = e
+    if connected:  # Il a décroché puis coupé : souvent un serveur chiffré appelé en clair
+        raise ConnectionError(f"{who} : le serveur {host}:{port} a coupé la connexion sans répondre{hint}") from None
+    raise ConnectionError(f"{who} : le serveur {host}:{port} ne répond pas ({type(error).__name__})") from None
+
+
+# Empreinte du certificat des serveurs capy de cette machine (à donner aux clients qui veulent vérifier)
+# Ex : capy.fingerprint() -> "9dfa7b98…"
+def fingerprint():
+    _tls.server_context("server")  # Crée le certificat s'il n'existe pas encore
+    return _tls.my_fingerprint("server")

capy/_tls.py

@@ -0,0 +1,139 @@
+# capy._tls : le chiffrement (TLS) commun à capy, capy.wifi et capy.network
+#
+# Chaque machine qui fait tourner un serveur crée son certificat tout seul (dans ~/.capy, avec openssl).
+# Comme SSH, un client retient l'empreinte d'un serveur à la 1re connexion (~/.capy/known_hosts.json) ;
+# si elle change ensuite -> SecurityError (quelqu'un se fait peut-être passer pour le serveur).
+
+import hashlib
+import hmac
+import json
+import os
+import pathlib as pth
+import socket
+import ssl
+import subprocess
+import threading
+
+CAPY_DIR = pth.Path.home() / ".capy"
+KNOWN_FILE = CAPY_DIR / "known_hosts.json"
+LOCAL_HOSTS = ("127.0.0.1", "localhost", "::1")
+_lock = threading.Lock()
+
+
+# L'empreinte d'un serveur ne correspond pas : on refuse de lui parler
+class SecurityError(Exception):
+    pass
+
+
+# Empreinte d'un certificat (64 caractères)
+def fingerprint(der):
+    return hashlib.sha256(der).hexdigest()
+
+
+# Certificat de cette machine : créé une fois avec openssl, puis réutilisé
+# kind : "server" (capy, capy.wifi) ou "relay" (capy.network)
+def _certificate(kind):
+    cert, key = CAPY_DIR / f"{kind}-cert.pem", CAPY_DIR / f"{kind}-key.pem"
+    with _lock:
+        if not (cert.exists() and key.exists()):
+            CAPY_DIR.mkdir(exist_ok=True)
+            try:
+                subprocess.run(
+                    ["openssl", "req", "-x509", "-newkey", "rsa:2048", "-nodes", "-days", "3650",
+                     "-subj", f"/CN=capy-{kind}", "-keyout", str(key), "-out", str(cert)],
+                    check=True, capture_output=True,
+                )
+            except (OSError, subprocess.CalledProcessError) as e:
+                raise RuntimeError(f"capy : impossible de créer le certificat avec openssl ({e})") from None
+            os.chmod(key, 0o600)  # Clé privée lisible par toi seul
+    return cert, key
+
+
+# Empreinte du certificat de cette machine (None s'il n'existe pas encore)
+def my_fingerprint(kind="server"):
+    cert = CAPY_DIR / f"{kind}-cert.pem"
+    try:
+        return fingerprint(ssl.PEM_cert_to_DER_cert(cert.read_text()))
+    except (OSError, ValueError):
+        return None
+
+
+# Contexte TLS côté serveur -> (contexte, empreinte)
+def server_context(kind="server"):
+    cert, key = _certificate(kind)
+    context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+    context.minimum_version = ssl.TLSVersion.TLSv1_2
+    context.load_cert_chain(cert, key)
+    return context, my_fingerprint(kind)
+
+
+# Chiffrer une connexion qui arrive sur un serveur (None si le client ne parle pas en TLS)
+def accept(context, raw, timeout=10):
+    try:
+        raw.settimeout(timeout)
+        conn = context.wrap_socket(raw, server_side=True)
+        conn.settimeout(timeout)
+        return conn
+    except (OSError, ValueError):
+        raw.close()
+        return None
+
+
+# Se connecter en chiffré, et vérifier que c'est bien le bon serveur (empreinte)
+# label : sous quel nom retenir l'empreinte ("ip:port", "wifi:salon"...)
+# pinned : empreinte attendue (sinon : celle retenue la 1re fois)
+def connect(host, port, label, timeout=10, pinned=None, who="capy", kind="serveur"):
+    context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+    context.minimum_version = ssl.TLSVersion.TLSv1_2
+    context.check_hostname = False       # Certificat fait maison :
+    context.verify_mode = ssl.CERT_NONE  # on le vérifie nous-mêmes avec l'empreinte juste après
+    raw = socket.create_connection((host, port), timeout=timeout)
+    try:
+        conn = context.wrap_socket(raw)
+    except (ssl.SSLError, OSError):
+        raw.close()
+        raise ConnectionError(
+            f"{who} : connexion chiffrée impossible avec {host}:{port}"
+            f" — le {kind} n'est peut-être pas chiffré (tls=False des deux côtés pour s'en passer)"
+        ) from None
+    try:
+        check(label, fingerprint(conn.getpeercert(binary_form=True)), pinned, who, kind, local=host in LOCAL_HOSTS)
+    except SecurityError:
+        conn.close()
+        raise
+    return conn
+
+
+# Comparer une empreinte avec celle attendue, ou celle retenue la 1re fois
+def check(label, seen, pinned=None, who="capy", kind="serveur", local=False):
+    wanted = (pinned or "").replace(":", "").lower()
+    if wanted:
+        if not hmac.compare_digest(wanted, seen):
+            raise SecurityError(f"{who} : l'empreinte du {kind} {label} n'est pas celle attendue (reçu {seen})")
+        return
+    if local and seen == my_fingerprint("server"):  # Ce Mac lui-même : rien à vérifier
+        return
+    with _lock:
+        known = _known()
+        if label not in known:
+            CAPY_DIR.mkdir(exist_ok=True)
+            known[label] = seen
+            KNOWN_FILE.write_text(json.dumps(known, indent=4))
+            print(f"{who} : nouveau {kind} {label}, empreinte retenue {seen}", flush=True)
+            return
+    if not hmac.compare_digest(known[label], seen):
+        raise SecurityError(
+            f"{who} : l'empreinte du {kind} {label} a CHANGÉ ! Quelqu'un se fait peut-être passer pour lui.\n"
+            f"  Si tu as réinstallé le {kind} (normal), supprime sa ligne dans {KNOWN_FILE}"
+        )
+
+
+# Les empreintes retenues (reprend l'ancien fichier known_relays.json s'il existe)
+def _known():
+    old = CAPY_DIR / "known_relays.json"
+    if not KNOWN_FILE.exists() and old.exists():
+        old.rename(KNOWN_FILE)
+    try:
+        return json.loads(KNOWN_FILE.read_text())
+    except (OSError, ValueError):
+        return {}

capy/network.py

@@ -0,0 +1,502 @@
+# capy.network : capy à travers tout internet, grâce à un relais, le tout chiffré (TLS)
+# Le relais tourne sur une machine avec une IP publique (un VPS).
+# Les serveurs s'y connectent (même derrière une box) et s'enregistrent sous un nom,
+# les clients appellent un nom : le relais fait passer la demande et la réponse.
+#
+#   Sur le VPS     : python3 -m capy.network 3879 motdepasse
+#   Partout ailleurs :
+#       capy.network.use("mon-vps.fr:3879", key="motdepasse")
+#       capy.network.Server("maison").run()       /  capy.network.call("maison", "test")
+#
+# Chiffrement : le relais crée son certificat tout seul (dans ~/.capy).
+# Comme SSH, la 1re connexion retient son empreinte (~/.capy/known_hosts.json) ;
+# si elle change ensuite -> SecurityError (quelqu'un se fait peut-être passer pour le relais).
+
+import hmac
+import json as jsonlib
+import queue
+import select
+import socket
+import sys
+import threading
+import time
+
+import capy
+from capy import _tls
+from capy._tls import SecurityError  # noqa: F401  (capy.network.SecurityError)
+
+PING_EVERY = 25  # Secondes sans rien avant un "je suis toujours là" (sinon la box coupe la connexion)
+_config = {"relay": None, "key": None, "fingerprint": None}
+_print_lock = threading.Lock()
+
+
+# print() qui ne se mélange pas entre threads
+def _log(text):
+    with _print_lock:
+        print(text, flush=True)
+
+
+# Choisir le relais une fois pour toutes (pour Server et call)
+# fingerprint (optionnel) : l'empreinte affichée par le relais au démarrage, pour être sûr dès la 1re fois
+# Ex : use("mon-vps.fr:3879", key="motdepasse")
+def use(relay, key=None, fingerprint=None):
+    _config.update(relay=relay, key=key, fingerprint=fingerprint)
+    _close_pipes()
+
+
+# "mon-vps.fr:3879" -> ("mon-vps.fr", 3879)
+def _address(relay):
+    relay = relay or _config["relay"]
+    if not relay:
+        raise ValueError('capy.network : aucun relais, utilise capy.network.use("ip:port")')
+    host, _, port = str(relay).rpartition(":")
+    if not host or not port.isdigit():
+        raise ValueError(f'capy.network : relais invalide {relay!r}, attendu "ip:port" (ex : "mon-vps.fr:3879")')
+    return host, int(port)
+
+
+# ============================================================
+#  ENVOYER / RECEVOIR
+# ============================================================
+
+def _encode(message):
+    return (jsonlib.dumps(message, ensure_ascii=False) + "\n").encode()
+
+
+# Envoyer un dict sur une ligne JSON
+def _send(sock, message):
+    sock.sendall(_encode(message))
+
+
+# Lire une ligne -> (ligne, ce qui a été reçu après)
+def _recv_line(sock, buffer=b""):
+    while b"\n" not in buffer:
+        data = sock.recv(65536)
+        if not data:
+            raise ConnectionError("connexion fermée")
+        buffer += data
+    line, rest = buffer.split(b"\n", 1)
+    return line, rest
+
+
+# Connexion qui reste ouverte (serveur <-> relais)
+# OpenSSL ne supporte pas 2 threads sur la même connexion chiffrée :
+# un seul thread lit ET écrit, les autres déposent leurs messages dans une file
+class _Channel:
+    def __init__(self, sock, on_message, buffer=b""):
+        self.sock, self.on_message, self.buffer = sock, on_message, buffer
+        self.outbox = queue.Queue()
+        self.wake_r, self.wake_w = socket.socketpair()  # Pour réveiller le thread quand il y a un message à envoyer
+        self.closing = False
+
+    # Envoyer un message (depuis n'importe quel thread)
+    def send(self, message):
+        if self.closing:
+            raise ConnectionError("connexion fermée")
+        self.outbox.put(_encode(message))
+        self._wake()
+
+    # Fermer (depuis n'importe quel thread)
+    def close(self):
+        self.closing = True
+        self._wake()
+
+    def _wake(self):
+        try:
+            self.wake_w.send(b"!")
+        except OSError:
+            pass
+
+    # Boucle du thread qui lit et écrit (rend la main quand la connexion se ferme)
+    def run(self, on_idle=None):
+        try:
+            self._lines()  # Ce qui était déjà arrivé avec le "bonjour"
+            while not self.closing:
+                ready = [self.sock] if self.sock.pending() else select.select([self.sock, self.wake_r], [], [], PING_EVERY)[0]
+                if not ready and on_idle:
+                    on_idle()
+                if self.wake_r in ready:
+                    self.wake_r.recv(4096)
+                while not self.outbox.empty():
+                    self.sock.sendall(self.outbox.get_nowait())
+                if self.sock in ready:
+                    data = self.sock.recv(65536)
+                    if not data:
+                        break
+                    self.buffer += data
+                    self._lines()
+        except (OSError, ValueError):
+            pass
+        finally:
+            self.closing = True
+            for s in (self.sock, self.wake_r, self.wake_w):
+                s.close()
+
+    def _lines(self):
+        while b"\n" in self.buffer:
+            line, self.buffer = self.buffer.split(b"\n", 1)
+            try:
+                self.on_message(jsonlib.loads(line))
+            except (ValueError, AttributeError):
+                pass
+
+
+# ============================================================
+#  CHIFFREMENT (code commun dans capy/_tls.py)
+# ============================================================
+
+# Certificat du relais (le sien, différent de celui des serveurs capy de la même machine)
+def _relay_context():
+    return _tls.server_context("relay")
+
+
+# Se connecter au relais en chiffré, et vérifier que c'est bien lui (empreinte)
+def _connect(host, port, timeout=10):
+    return _tls.connect(host, port, f"{host}:{port}", timeout, pinned=_config["fingerprint"], who="capy.network", kind="relais")
+
+
+# ============================================================
+#  RELAIS (sur le VPS)
+# ============================================================
+
+# Un serveur connecté au relais
+class _Link:
+    def __init__(self, name):
+        self.name = name
+        self.channel = None
+        self.lock = threading.Lock()
+        self.waiting = {}  # id de la demande -> [Event, réponse]
+        self.next_id = 0
+
+    # Faire passer une demande au serveur et attendre sa réponse
+    def ask(self, request, timeout):
+        done = threading.Event()
+        with self.lock:
+            self.next_id += 1
+            ask_id = self.next_id
+            self.waiting[ask_id] = [done, None]
+        self.channel.send({"id": ask_id, "request": request})
+        if not done.wait(timeout):
+            self.waiting.pop(ask_id, None)
+            raise TimeoutError(f"{self.name!r} n'a pas répondu en {timeout} s")
+        return self.waiting.pop(ask_id)[1]
+
+    # Une réponse du serveur arrive
+    def receive(self, message):
+        slot = self.waiting.get(message.get("id"))
+        if slot:
+            slot[1] = message.get("response")
+            slot[0].set()
+
+
+# Relais : à lancer sur une machine joignable depuis internet
+# Ex : capy.network.Relay(3879, key="motdepasse").run()
+class Relay:
+    def __init__(self, port, key=None):
+        self.port, self.key = port, key
+        self.links = {}  # nom -> _Link
+
+    def _key_ok(self, key):
+        return self.key is None or hmac.compare_digest(str(key or ""), self.key)
+
+    def _client(self, raw, addr):
+        try:
+            raw.settimeout(10)
+            conn = self.context.wrap_socket(raw, server_side=True)
+            line, rest = _recv_line(conn)
+            hello = jsonlib.loads(line)
+            kind = hello.get("capy")
+        except (OSError, ValueError, AttributeError):
+            raw.close()
+            return
+        with conn:
+            if kind == "call":  # La clé est vérifiée à chaque demande
+                self._calls(hello, conn, rest)
+            elif not self._key_ok(hello.get("key")):
+                _send(conn, {"capy": "erreur", "message": "capy.network : mauvaise clé pour ce relais"})
+            elif kind == "register":
+                self._register(hello.get("name"), conn, rest, addr)
+
+    # Un serveur s'enregistre : on garde sa connexion ouverte
+    def _register(self, name, conn, rest, addr):
+        if not isinstance(name, str) or not name:
+            _send(conn, {"capy": "erreur", "message": "capy.network : nom invalide"})
+            return
+        old = self.links.get(name)
+        if old and self._alive(old):  # Nom pris par un serveur qui répond encore -> refusé
+            _send(conn, {"capy": "erreur", "message": f"capy.network : nom déjà utilisé, un autre serveur est connecté au relais sous le nom {name!r}"})
+            _log(f"! {name} refusé ({addr[0]}) : nom déjà utilisé")
+            return
+        _send(conn, {"capy": "ok"})
+        conn.settimeout(None)
+        link = _Link(name)
+        link.channel = _Channel(conn, link.receive, rest)
+        self.links[name] = link  # L'ancien ne répondait plus (connexion morte) -> le nouveau le remplace
+        if old:
+            old.channel.close()
+        _log(f"+ {name} connecté ({addr[0]})")
+        link.channel.run()
+        if self.links.get(name) is link:
+            del self.links[name]
+        for slot in list(link.waiting.values()):  # Demandes en cours -> erreur
+            slot[1] = {"erreur": f"capy.network : {name!r} s'est déconnecté"}
+            slot[0].set()
+        _log(f"- {name} déconnecté")
+
+    # Le serveur connecté sous ce nom répond-il encore ? (3 s max, sinon sa connexion est morte)
+    def _alive(self, link):
+        try:
+            link.ask({"action": "__capy_ping__"}, timeout=3)
+        except (TimeoutError, OSError):
+            return False
+        return not link.channel.closing
+
+    # Un client appelle des serveurs par leur nom
+    # La connexion reste ouverte : il peut envoyer d'autres demandes (en parallèle, chacune avec son id)
+    def _calls(self, hello, conn, rest):
+        conn.settimeout(None)
+        idle = []
+
+        def on_message(message):
+            idle.clear()
+            self._call_async(channel, message)
+
+        def on_idle():  # Client parti sans prévenir (plus de "je suis toujours là") -> on ferme
+            idle.append(1)
+            if len(idle) >= 3:
+                channel.close()
+
+        channel = _Channel(conn, on_message, rest)
+        self._call_async(channel, hello)
+        channel.run(on_idle=on_idle)
+
+    # Chaque demande dans un thread à part (pour ne pas bloquer les autres)
+    def _call_async(self, channel, message):
+        if message.get("capy") == "call":
+            threading.Thread(target=self._call, args=(channel, message), daemon=True).start()
+
+    # Faire passer une demande au serveur, et renvoyer sa réponse au client (avec l'id de la demande)
+    def _call(self, channel, message):
+        name, request = message.get("to"), message.get("request")
+        reply = {"capy": "erreur", "id": message.get("id")}
+        link = self.links.get(name)
+        if not self._key_ok(message.get("key")):
+            reply["message"] = "capy.network : mauvaise clé pour ce relais"
+        elif link is None:
+            connected = ", ".join(self.links) or "aucun"
+            reply["message"] = f"capy.network : aucun serveur {name!r} sur le relais (connectés : {connected})"
+        else:
+            try:
+                reply.update(capy="ok", response=link.ask(request, timeout=10))
+            except (TimeoutError, OSError) as e:
+                reply["message"] = f"capy.network : {e}"
+        try:
+            channel.send(reply)
+        except ConnectionError:
+            return
+        if reply["capy"] == "ok":
+            _log(f"  {name} ← {jsonlib.dumps(request, ensure_ascii=False)}")
+
+    def run(self):
+        self.context, fingerprint = _relay_context()
+        with socket.create_server(("", self.port)) as server:
+            _log(f"Relais capy.network en écoute sur le port {self.port}, chiffré (TLS)"
+                 + (", avec clé" if self.key else ", SANS clé : ouvert à tous"))
+            _log(f"Empreinte : {fingerprint}")
+            try:
+                while True:
+                    conn, addr = server.accept()
+                    threading.Thread(target=self._client, args=(conn, addr), daemon=True).start()
+            except KeyboardInterrupt:
+                _log("\nRelais arrêté")
+
+
+# ============================================================
+#  SERVEUR (n'importe où, même derrière une box)
+# ============================================================
+
+# Serveur joignable depuis tout internet sous un nom, via le relais
+# Ex : api = capy.network.Server("maison") puis api.run()
+class Server(capy.Server):
+    def __init__(self, name, relay=None, key=None):
+        super().__init__()
+        self.name, self.relay, self.key = name, relay, key
+
+    # Se connecter au relais et répondre aux demandes (se reconnecte tout seul si ça coupe)
+    def run(self):
+        host, port = _address(self.relay)
+        key = self.key if self.key is not None else _config["key"]
+        while True:
+            try:
+                conn = _connect(host, port)
+                _send(conn, {"capy": "register", "name": self.name, "key": key})
+                line, rest = _recv_line(conn)
+                hello = jsonlib.loads(line)
+                if hello.get("capy") != "ok":
+                    conn.close()
+                    raise PermissionError(hello.get("message", "capy.network : le relais a refusé la connexion"))
+                conn.settimeout(None)
+                _log(f"Connecté au relais {host}:{port} sous le nom {self.name!r} (chiffré)")
+                channel = _Channel(conn, lambda message: self._request(channel, message), rest)
+                channel.run(on_idle=lambda: channel.send({"ping": True}))
+                _log("Connexion au relais perdue, reconnexion dans 3 s")
+            except PermissionError:
+                raise
+            except (OSError, ValueError) as e:
+                _log(f"Relais {host}:{port} injoignable ({e}), nouvel essai dans 3 s")
+            except KeyboardInterrupt:
+                _log("\nServeur arrêté")
+                return
+            time.sleep(3)
+
+    # Une demande arrive : on y répond dans un thread à part (pour ne pas bloquer les autres)
+    def _request(self, channel, message):
+        if (message.get("request") or {}).get("action") == "__capy_ping__":  # Le relais vérifie qu'on est vivant
+            channel.send({"id": message.get("id"), "response": {"pong": True}})
+        elif "request" in message:
+            threading.Thread(target=self._answer, args=(channel, message), daemon=True).start()
+
+    def _answer(self, channel, message):
+        response = self.handle(jsonlib.dumps(message["request"]))
+        try:
+            jsonlib.dumps(response)
+        except (TypeError, ValueError) as e:
+            response = {"erreur": f"réponse pas en JSON : {e}"}
+        try:
+            channel.send({"id": message.get("id"), "response": response})
+        except ConnectionError:
+            return
+        _log(f"réseau → {jsonlib.dumps(message['request'], ensure_ascii=False)}")
+
+
+# ============================================================
+#  CLIENT (n'importe où)
+# ============================================================
+
+_pipes = {}  # (host, port) -> _Pipe : une connexion gardée ouverte par relais
+_pipes_lock = threading.Lock()
+_old_relays = set()  # Relais d'une ancienne version : une seule demande par connexion
+
+
+# "le relais ne répond pas", sauf si l'erreur a déjà un message clair (ex : TLS impossible)
+def _unreachable(host, port, error):
+    if isinstance(error, ConnectionError) and str(error).startswith("capy.network"):
+        return error
+    return ConnectionError(f"capy.network : le relais {host}:{port} ne répond pas")
+
+
+# Connexion client <-> relais gardée ouverte entre les appels (évite TCP + TLS à chaque fois)
+# Chaque demande porte un id : plusieurs appels en parallèle passent par la même connexion
+class _Pipe:
+    def __init__(self, host, port):
+        conn = _connect(host, port, timeout=12)
+        conn.settimeout(None)
+        self.address = (host, port)
+        self.lock = threading.Lock()
+        self.waiting = {}  # id de la demande -> [Event, réponse]
+        self.next_id = 0
+        self.closed = False
+        self.channel = _Channel(conn, self._receive)
+        threading.Thread(target=self._run, daemon=True).start()
+
+    def _run(self):
+        self.channel.run(on_idle=lambda: self.channel.send({"ping": True}))
+        with self.lock:
+            self.closed = True
+            slots = list(self.waiting.values())
+        for slot in slots:  # Demandes en cours -> réponse None (connexion perdue)
+            slot[0].set()
+
+    # Envoyer une demande et attendre la réponse du relais (None si la connexion a coupé avant)
+    def ask(self, message, timeout):
+        done = threading.Event()
+        with self.lock:
+            if self.closed:
+                return None
+            self.next_id += 1
+            ask_id = self.next_id
+            self.waiting[ask_id] = [done, None]
+            try:  # Sous le verrou : les demandes partent dans l'ordre de leurs id
+                self.channel.send({**message, "id": ask_id})
+            except ConnectionError:
+                pass  # _run va libérer la demande
+        answered = done.wait(timeout)
+        with self.lock:
+            slot = self.waiting.pop(ask_id, [done, None])
+        if not answered:
+            self.channel.close()  # Le relais ne répond plus : la prochaine fois on se reconnecte
+            raise _unreachable(*self.address, None)
+        return slot[1]
+
+    # Une réponse du relais arrive
+    def _receive(self, message):
+        with self.lock:
+            if "id" in message:
+                slot = self.waiting.get(message["id"])
+            else:  # Ancien relais : il répond sans id, à la 1re demande seulement, puis ferme
+                _old_relays.add(self.address)
+                slot = self.waiting.get(min(self.waiting, default=None))
+        if slot:
+            slot[1] = message
+            slot[0].set()
+
+
+# La connexion gardée ouverte vers ce relais (on la crée si besoin)
+def _pipe(host, port):
+    with _pipes_lock:
+        pipe = _pipes.get((host, port))
+        if pipe is None or pipe.channel.closing:
+            try:
+                pipe = _pipes[(host, port)] = _Pipe(host, port)
+            except (OSError, ValueError) as e:
+                raise _unreachable(host, port, e) from None
+        return pipe
+
+
+# Fermer les connexions gardées ouvertes (use() a changé de relais, de clé ou d'empreinte)
+def _close_pipes():
+    with _pipes_lock:
+        for pipe in _pipes.values():
+            pipe.channel.close()
+        _pipes.clear()
+        _old_relays.clear()
+
+
+# Une demande sur une connexion neuve, fermée juste après (pour les anciens relais)
+def _call_once(host, port, message):
+    try:
+        with _connect(host, port, timeout=12) as conn:
+            _send(conn, message)
+            line, _ = _recv_line(conn)
+            return jsonlib.loads(line)
+    except (OSError, ValueError) as e:
+        raise _unreachable(host, port, e) from None
+
+
+# Appeler une action d'un serveur par son nom, via le relais (comme capy.call)
+# La connexion chiffrée reste ouverte : seul le 1er appel paie la connexion TLS
+# Ex : capy.network.call("maison", "test") -> {"text": "Hello"}
+def call(name, action, /, **params):
+    host, port = _address(None)
+    message = {"capy": "call", "to": name, "key": _config["key"], "request": {"action": action, **params}}
+    reply = None
+    for _ in range(2):  # Connexion morte (relais relancé) -> on se reconnecte une fois
+        if (host, port) in _old_relays:
+            reply = _call_once(host, port, message)
+        else:
+            reply = _pipe(host, port).ask(message, timeout=15)
+        if reply is not None:
+            break
+    if reply is None:
+        raise _unreachable(host, port, None)
+    if reply.get("capy") != "ok":
+        raise ConnectionError(reply.get("message", "capy.network : erreur du relais"))
+    return reply["response"]
+
+
+# Lancer un relais depuis le terminal : python3 -m capy.network 3879 motdepasse
+if __name__ == "__main__":
+    if len(sys.argv) < 2 or not sys.argv[1].isdigit():
+        print("Usage : python3 -m capy.network PORT [CLÉ]")
+        sys.exit(1)
+    Relay(int(sys.argv[1]), key=sys.argv[2] if len(sys.argv) > 2 else None).run()

capy/wifi.py

@@ -0,0 +1,112 @@
+# capy.wifi : capy entre appareils du même wifi, sans connaître les IP
+# Le serveur s'annonce sous un nom, le client l'appelle par ce nom.
+# Chiffré (TLS) comme capy : l'empreinte de chaque serveur est retenue sous "wifi:<nom>".
+
+import json as jsonlib
+import socket
+import threading
+import time
+
+import capy
+
+DISCOVERY_PORT = 38790  # Port UDP où les serveurs répondent "je suis là"
+_found = {}             # Serveurs déjà trouvés : nom -> (ip, port)
+_secure = {}            # Serveurs trouvés : nom -> chiffré ou pas
+
+
+# Serveur visible sur le wifi sous un nom (port choisi tout seul si on n'en donne pas)
+# Ex : api = capy.wifi.Server("maison") puis api.run()
+class Server(capy.Server):
+    def __init__(self, name, port=0, tls=True):
+        super().__init__(port, tls)
+        self.name = name
+
+    # Lancer le serveur, et répondre aux scans du wifi pour être trouvé
+    def run(self, port=None):
+        threading.Thread(target=self._announce, daemon=True).start()
+        print(f"Visible sur le wifi sous le nom {self.name!r} ({_local_ip()})")
+        super().run(port)
+
+    # Répondre "je suis là" aux scans des clients
+    def _announce(self):
+        with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
+            s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+            s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)  # Plusieurs serveurs sur le même appareil
+            s.bind(("", DISCOVERY_PORT))
+            while True:
+                data, addr = s.recvfrom(1024)
+                if data == b"capy?" and self.listening:
+                    s.sendto(jsonlib.dumps({"name": self.name, "port": self.port, "tls": self.tls}).encode(), addr)
+
+
+# Tous les serveurs capy.wifi du réseau
+# Ex : scan() -> {"maison": ("192.168.1.42", 51234), "salon": ("192.168.1.50", 3879)}
+def scan(timeout=1, _wanted=None):
+    found, me = {}, _local_ip()
+    with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
+        s.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
+        end = time.monotonic() + timeout
+        next_ask = 0
+        while time.monotonic() < end:
+            # On redemande 3 fois : en wifi, un message UDP peut se perdre
+            if time.monotonic() >= next_ask:
+                for target in ("255.255.255.255", "127.0.0.1"):  # Tout le wifi + cet appareil (même sans wifi)
+                    try:
+                        s.sendto(b"capy?", (target, DISCOVERY_PORT))
+                    except OSError:
+                        pass
+                next_ask = time.monotonic() + timeout / 3
+            s.settimeout(max(min(end, next_ask) - time.monotonic(), 0.001))
+            try:
+                data, (ip, _) = s.recvfrom(1024)
+                info = jsonlib.loads(data)
+                name, port = info["name"], int(info["port"])
+            except socket.timeout:
+                continue
+            except (OSError, ValueError, KeyError, TypeError):
+                continue
+            # Serveur sur cet appareil -> 127.0.0.1 (20x plus rapide que passer par l'IP du wifi)
+            found.setdefault(name, ("127.0.0.1" if ip == me else ip, port))
+            _secure.setdefault(name, info.get("tls") is True)
+            if name == _wanted:  # find() : on a ce qu'on cherche, inutile d'attendre
+                break
+    _found.update(found)
+    return found
+
+
+# Trouver un serveur par son nom -> (ip, port)
+# Ex : find("maison") -> ("192.168.1.42", 51234)
+def find(name, timeout=1):
+    if name not in _found:
+        found = scan(timeout, _wanted=name)
+        if name not in found:
+            raise ConnectionError(f"capy.wifi : aucun serveur {name!r} sur le wifi (trouvés : {', '.join(found) or 'aucun'})")
+    return _found[name]
+
+
+# Appeler une action d'un serveur par son nom (comme capy.call, sans IP ni port)
+# tls=False : pour un serveur pas chiffré (Server(..., tls=False))
+# Ex : capy.wifi.call("maison", "test") -> {"text": "Hello"}
+def call(name, action, /, tls=True, **params):
+    for attempt in range(2):
+        host, port = find(name)
+        if _secure.get(name, True) != tls:
+            state = "n'est pas chiffré : mets tls=False" if tls else "est chiffré : enlève tls=False"
+            raise ConnectionError(f"capy.wifi : le serveur {name!r} {state} dans capy.wifi.call()")
+        try:
+            return capy._call(host, port, action, params, tls, label=f"wifi:{name}", who="capy.wifi")
+        except ConnectionError as e:
+            if attempt or "chiffr" in str(e):
+                raise
+            _found.pop(name, None)  # Serveur relancé (autre port, autre IP) -> on le recherche une fois
+            _secure.pop(name, None)
+
+
+# IP de cet appareil sur le wifi (ex : "192.168.1.42")
+def _local_ip():
+    try:
+        with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
+            s.connect(("1.1.1.1", 80))  # Rien n'est envoyé, ça sert juste à savoir quelle IP on utilise
+            return s.getsockname()[0]
+    except OSError:
+        return "127.0.0.1"

capyy-0.3.0.dist-info/METADATA

@@ -0,0 +1,117 @@
+Metadata-Version: 2.4
+Name: capyy
+Version: 0.3.0
+Summary: Tiny encrypted JSON-over-TCP APIs: call a function in another program, on your Wi-Fi or across the internet
+Author: Izac
+License-Expression: MIT
+Project-URL: Homepage, https://libs.zazac.link/capy/
+Project-URL: Documentation, https://libs.zazac.link/capy/
+Keywords: rpc,api,tcp,json,tls,lan,discovery,relay,nat
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Operating System :: OS Independent
+Classifier: Natural Language :: French
+Classifier: Topic :: Internet
+Classifier: Topic :: System :: Networking
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# capyy — tiny encrypted JSON-over-TCP APIs
+
+Call a function in another Python program — on the same machine, on your Wi-Fi, or across the internet —
+with one line of code. Zero dependencies, Python 3.9+, encrypted with TLS by default.
+
+```bash
+pip install capyy
+```
+
+The package is published as **capyy**, but you import it as **`capy`**.
+Error messages are in French (the library was written for French speakers), and the full documentation,
+with examples, is at **[libs.zazac.link/capy](https://libs.zazac.link/capy/)**.
+
+## Quick start
+
+```python
+# server.py
+import capy
+
+api = capy.Server(4000)
+
+@api.action("hello")
+def hello(name="you"):
+    return {"message": f"Hello {name}!"}
+
+api.run()
+```
+
+```python
+# client.py
+import capy
+
+print(capy.call("localhost", 4000, "hello", name="Alice"))   # {'message': 'Hello Alice!'}
+```
+
+- An action returns a `dict`, or JSON written as text with `capy.json('{"text": "Hello"}')`.
+- Errors raised on the server come back as `{"erreur": "..."}` (unknown action, bad parameters, exceptions).
+- `capy.call` raises `ConnectionError` when the server does not answer.
+
+## Reading a response
+
+```python
+reply = {"city": "Paris", "temp": "18.5", "days": [{"name": "monday"}, {"name": "tuesday"}]}
+
+capy.get(reply, "days.1.name")          # "tuesday"  (paths go through dicts and lists)
+capy.get(reply, "wind", default=0)      # 0
+capy.to_float(reply, "temp")            # 18.5
+capy.to_int("42"), capy.to_bool("yes")  # 42, True
+```
+
+`to_str`, `to_int`, `to_float`, `to_bool`, `to_list` and `to_dict` raise a `ValueError` that says exactly
+what could not be converted.
+
+## Encryption (TLS)
+
+Everything is encrypted by default, with nothing to configure.
+
+- Each machine running a server creates its own certificate on first launch (`~/.capy`, using `openssl`)
+  and prints its **fingerprint**.
+- Like SSH, a client **remembers a server's fingerprint** the first time (`~/.capy/known_hosts.json`)
+  and raises `capy.SecurityError` if it ever changes.
+- Use `tls=False` on **both** sides to talk in clear (faster on localhost).
+
+## `capy.wifi` — find each other on the same network
+
+```python
+import capy.wifi
+
+api = capy.wifi.Server("living-room")   # announces itself on the LAN, port chosen automatically
+...
+capy.wifi.call("living-room", "light", on=False)   # from any device on the same Wi-Fi
+capy.wifi.scan()                                    # {'living-room': ('192.168.1.42', 51234)}
+```
+
+## `capy.network` — across the internet, through a relay
+
+A machine behind a home router cannot be reached from the internet, so `capy.network` goes through a
+**relay** running on a machine with a public IP (a VPS). Servers connect to it and register a name;
+clients call that name. Everything is encrypted, and the connection is kept open between calls.
+
+```bash
+python3 -m capy.network 3879 my-secret-key      # on the VPS (open the port in its firewall)
+```
+
+```python
+import capy.network
+
+capy.network.use("my-vps.example:3879", key="my-secret-key")
+capy.network.Server("home").run()        # at home, even behind a router
+capy.network.call("home", "temperature") # from anywhere
+```
+
+## License
+
+MIT

capyy-0.3.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+capy/__init__.py,sha256=_8GyTkQ-1v0sZNuDMxOsIFczgdr6lB1V9V8CnWMZ-Z4,10964
+capy/_tls.py,sha256=LGLxUSUkQ2GkVIgxu0j0KHl_9eC8CsaDG_0Pmpt6W4U,5427
+capy/network.py,sha256=llT4BiZ3s2TWkYly47mn4kDklLh2Z9zkzPUFNOsuaRY,20364
+capy/wifi.py,sha256=5xVv69F02M47j1dsE9CFA5VMq5UXebJ8Y-fWzaahGHc,5006
+capyy-0.3.0.dist-info/licenses/LICENSE,sha256=tGjTKp9sFPwxUZXQBjbeBRrFZtWmGiPz6RXCfVV9NIg,1061
+capyy-0.3.0.dist-info/METADATA,sha256=anKV38ur_jGG9LA-3ivdmOWjWFEqkK_eoCAyVxC4EOk,4004
+capyy-0.3.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+capyy-0.3.0.dist-info/top_level.txt,sha256=ORaAIIZzMv8hrF-iSAV250cVyIpfuaDS8JPYnJw8BU4,5
+capyy-0.3.0.dist-info/RECORD,,

capyy-0.3.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

capyy-0.3.0.dist-info/licenses/LICENSE

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

capyy-0.3.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+capy