capyy 0.3.2__tar.gz → 0.5.0__tar.gz

{capyy-0.3.2/capyy.egg-info → capyy-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: capyy
-Version: 0.3.2
+Version: 0.5.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
@@ -73,6 +73,30 @@ 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.
 
+## Project file: capy.config.json
+
+Describe the whole project once, then never repeat ports or hosts:
+
+```bash
+python3 -m capy new my-game     # folder + capy.config.json + server.py + client.py
+cd my-game
+cy run             # starts the server, runs the client, stops the server
+```
+
+```json
+{"name": "my-game", "version": "1.0", "mode": "local", "url": "127.0.0.1:2388", "tls": true,
+ "files": {"server": "server.py", "client": "client.py"}}
+```
+
+```python
+app = capy.project()            # finds capy.config.json next to the script, or in a parent folder
+server = app.server()           # server side
+app.call("hello", nom="Izac")   # client side
+```
+
+`mode` can be `local`, `wifi` or `network` (with `relay`, `key`, `fingerprint`). Strings starting with `$` are read
+from environment variables, e.g. `"key": "$CAPY_KEY"`. Inside a project, the `cy` command runs its `scripts` like `npm run` (`cy test`, `cy start`) and its files (`cy server`); create a project with `python3 -m capy new`.
+
 ## Encryption (TLS)
 
 Everything is encrypted by default, with nothing to configure.
@@ -114,6 +138,27 @@ capy.network.Server("home").run()        # at home, even behind a router
 capy.network.call("home", "temperature") # from anywhere
 ```
 
+## `capy.domo` — home automation
+
+One way to drive lights and plugs from Philips Hue, WiZ, Shelly, Yeelight and Home Assistant (and everything
+Home Assistant supports), on your local network, with zero dependencies:
+
+```python
+import capy.domo
+
+home = capy.domo.Home()        # devices, groups and scenes live in capy.domo.json
+home.scan()                    # find devices on the network
+home["salon"].color("orange")  # a device, a group, or "tout" (everything)
+home.scene("film")
+capy.domo.serve(home)          # control it remotely through capy / capy.wifi / capy.network
+```
+
+```bash
+python3 -m capy.domo scan
+python3 -m capy.domo pair hue
+python3 -m capy.domo salon on 30% orange
+```
+
 ## License
 
 MIT

{capyy-0.3.2 → capyy-0.5.0}/README.md

@@ -51,6 +51,30 @@ 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.
 
+## Project file: capy.config.json
+
+Describe the whole project once, then never repeat ports or hosts:
+
+```bash
+python3 -m capy new my-game     # folder + capy.config.json + server.py + client.py
+cd my-game
+cy run             # starts the server, runs the client, stops the server
+```
+
+```json
+{"name": "my-game", "version": "1.0", "mode": "local", "url": "127.0.0.1:2388", "tls": true,
+ "files": {"server": "server.py", "client": "client.py"}}
+```
+
+```python
+app = capy.project()            # finds capy.config.json next to the script, or in a parent folder
+server = app.server()           # server side
+app.call("hello", nom="Izac")   # client side
+```
+
+`mode` can be `local`, `wifi` or `network` (with `relay`, `key`, `fingerprint`). Strings starting with `$` are read
+from environment variables, e.g. `"key": "$CAPY_KEY"`. Inside a project, the `cy` command runs its `scripts` like `npm run` (`cy test`, `cy start`) and its files (`cy server`); create a project with `python3 -m capy new`.
+
 ## Encryption (TLS)
 
 Everything is encrypted by default, with nothing to configure.
@@ -92,6 +116,27 @@ capy.network.Server("home").run()        # at home, even behind a router
 capy.network.call("home", "temperature") # from anywhere
 ```
 
+## `capy.domo` — home automation
+
+One way to drive lights and plugs from Philips Hue, WiZ, Shelly, Yeelight and Home Assistant (and everything
+Home Assistant supports), on your local network, with zero dependencies:
+
+```python
+import capy.domo
+
+home = capy.domo.Home()        # devices, groups and scenes live in capy.domo.json
+home.scan()                    # find devices on the network
+home["salon"].color("orange")  # a device, a group, or "tout" (everything)
+home.scene("film")
+capy.domo.serve(home)          # control it remotely through capy / capy.wifi / capy.network
+```
+
+```bash
+python3 -m capy.domo scan
+python3 -m capy.domo pair hue
+python3 -m capy.domo salon on 30% orange
+```
+
 ## License
 
 MIT

{capyy-0.3.2 → capyy-0.5.0}/capy/__init__.py

@@ -6,6 +6,7 @@ import threading
 from typing import Any
 
 from . import _tls
+from ._project import Project, project  # noqa: F401  (capy.project() : lire capy.config.json)
 from ._tls import SecurityError  # noqa: F401  (capy.SecurityError)
 
 
@@ -51,7 +52,7 @@ class Server:
                 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())
+                conn.sendall((_dumps(self.handle(line)) + "\n").encode())
             except (OSError, ValueError):
                 return
             print(f"{addr[0]} → {_hide(line)}")
@@ -76,6 +77,15 @@ class Server:
 
 
 # Renvoyer du JSON écrit en texte depuis une action
+# Réponse d'une action -> texte JSON (une réponse impossible à mettre en JSON devient une erreur claire)
+# Ex : return {1, 2} (un set) -> {"erreur": "réponse pas en JSON : Object of type set is not JSON serializable"}
+def _dumps(response):
+    try:
+        return jsonlib.dumps(response, ensure_ascii=False)
+    except (TypeError, ValueError) as e:
+        return jsonlib.dumps({"erreur": f"réponse pas en JSON : {e}"}, ensure_ascii=False)
+
+
 # Paramètres jamais affichés dans le journal du serveur (mots de passe, tokens…)
 SECRETS = ("password", "passwd", "pwd", "mdp", "motdepasse", "secret", "token")
 
@@ -284,6 +294,8 @@ def _call(host, port, action, params, tls, label, who="capy"):
         error = e
     except (OSError, ValueError) as e:
         error = e
+    if connected and isinstance(error, socket.timeout):  # Connecté, mais l'action met trop longtemps
+        raise ConnectionError(f"{who} : le serveur {host}:{port} n'a pas répondu à temps (3 s) : l'action est sans doute trop lente") from None
     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

capyy-0.5.0/capy/__main__.py

@@ -0,0 +1,169 @@
+# Les commandes d'un projet capy (tout vient de capy.config.json)
+#
+# cy : seulement DANS un projet capy (un dossier avec capy.config.json, ou en dessous)
+#   cy                          -> montre le projet (nom, mode, adresse, fichiers, scripts…)
+#   cy NOM [args…]              -> lance le script NOM de "scripts" (comme npm run)
+#   cy scripts                  -> liste les scripts
+#   cy server / cy client       -> lance un fichier de "files"
+#   cy run                      -> lance le serveur en fond, puis le client, puis arrête le serveur
+#
+# python3 -m capy : tout ce que fait cy, plus créer un projet
+#   python3 -m capy new NOM [mode]    -> crée un dossier NOM avec capy.config.json, server.py, client.py
+#   python3 -m capy init [nom] [mode] -> crée juste capy.config.json ici
+#   mode : local (par défaut), wifi ou network
+
+import difflib
+import socket
+import subprocess
+import sys
+import threading
+import time
+
+from ._project import COMMANDS, FILE_NAME, MODES, find, init, new, project
+
+USAGE = f"""Dans un projet capy ({FILE_NAME}) :
+  cy                     montre le projet
+  cy NOM [args…]         lance le script NOM de "scripts" (comme npm run)
+  cy scripts             liste les scripts
+  cy server / client     lance un fichier de "files"
+  cy run                 serveur en fond + client, puis arrête le serveur
+Créer un projet :
+  python3 -m capy new NOM [mode]      un dossier complet (config, server.py, client.py)
+  python3 -m capy init [nom] [mode]   juste {FILE_NAME} ici
+  modes : {", ".join(MODES)}"""
+
+
+# Le projet du dossier actuel (ou au-dessus), sinon on explique quoi faire
+def _project():
+    path = find(".")
+    if path is None:
+        sys.exit(f"cy marche dans un projet capy, et il n'y a pas de {FILE_NAME} ici ni au-dessus.\n"
+                 f"  Crée un projet : python3 -m capy new mon-projet\n"
+                 f"  ou juste le fichier : python3 -m capy init")
+    try:
+        return project(path)
+    except ValueError as e:
+        sys.exit(str(e))
+
+
+# Lancer un fichier du projet avec le même Python, depuis le dossier du projet
+def _start(app, name, args=(), **options):
+    try:
+        path = app.file(name)
+    except KeyError as e:
+        sys.exit(e.args[0])
+    if not path.is_file():
+        sys.exit(f"capy : le fichier {name!r} ({path}) n'existe pas")
+    return subprocess.Popen([sys.executable, "-u", str(path), *args], cwd=app.folder, **options)
+
+
+# Attendre que le serveur réponde (10 s max) ; False s'il s'est arrêté avant
+def _wait_ready(app, process):
+    end = time.monotonic() + 10
+    while time.monotonic() < end:
+        if process.poll() is not None:
+            return False
+        try:
+            if app.mode == "local" and app.port:
+                socket.create_connection((app.host, app.port), timeout=0.3).close()
+                return True
+            if app.mode == "wifi":
+                import capy.wifi
+                capy.wifi._found.pop(app.name, None)
+                capy.wifi.find(app.name, timeout=0.3)
+                return True
+            if app.mode == "network" or not app.port:
+                time.sleep(2)  # Pas de moyen simple de vérifier : on laisse 2 s au serveur
+                return process.poll() is None
+        except (OSError, ConnectionError):
+            time.sleep(0.2)
+    return process.poll() is None
+
+
+# Recopier la sortie du serveur, avec "server │" devant chaque ligne
+def _relay_output(process):
+    for line in process.stdout:
+        print(f"\033[2mserver │\033[0m {line}", end="", flush=True)
+
+
+def run(app, args):
+    server = _start(app, "server", stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
+    threading.Thread(target=_relay_output, args=(server,), daemon=True).start()
+    try:
+        if not _wait_ready(app, server):
+            time.sleep(0.2)  # Laisser s'afficher l'erreur du serveur
+            sys.exit(f"capy : le serveur s'est arrêté (ou ne répond pas après 10 s)")
+        client = _start(app, "client", args)
+        code = client.wait()
+    except KeyboardInterrupt:
+        code = 130
+    finally:
+        server.terminate()
+        try:
+            server.wait(timeout=3)
+        except subprocess.TimeoutExpired:
+            server.kill()
+    sys.exit(code)
+
+
+def main(args):
+    command = args[0] if args else None
+    if command in ("-h", "--help", "help"):
+        print(USAGE)
+        return
+    if command in ("init", "new"):
+        rest = args[1:]
+        mode = next((a for a in rest if a in MODES), "local")
+        name = next((a for a in rest if a not in MODES), None)
+        if command == "new" and not name:
+            sys.exit("Usage : python3 -m capy new NOM [mode]")
+        try:
+            path = new(name, mode) / FILE_NAME if command == "new" else init(name=name, mode=mode)
+        except (FileExistsError, ValueError) as e:
+            sys.exit(str(e))
+        print(f"Créé : {path.parent if command == 'new' else path}")
+        print(project(path).describe())
+        if command == "new":
+            print(f"\nPour l'essayer :\n  cd {name}\n  cy run")
+        if mode == "network":
+            print("Pense à : export CAPY_KEY='la clé du relais' (dans ~/.zshrc), et à mettre l'adresse de ton relais")
+        return
+    app = _project()
+    if command is None:
+        print(app.describe())
+    elif command == "run":
+        run(app, args[1:])
+    elif command == "scripts":
+        if not app.scripts:
+            print('Pas de "scripts" dans ' + FILE_NAME + ', ex : "scripts": {"test": "python3 -m unittest"}')
+        for name, line in app.scripts.items():
+            print(f"  {name:<12} {line}")
+    elif command in app.scripts:
+        print(f"\033[2m> {app.scripts[command]}\033[0m", flush=True)  # Comme npm : on montre la commande lancée
+        try:
+            sys.exit(app.run_script(command, args[1:]))
+        except KeyboardInterrupt:
+            sys.exit(130)
+    elif command in app.files:
+        try:
+            sys.exit(_start(app, command, args[1:]).wait())
+        except KeyboardInterrupt:
+            sys.exit(130)
+    else:
+        names = list(app.scripts) + list(app.files) + list(COMMANDS)
+        close = difflib.get_close_matches(command, names, n=1)
+        if close:
+            sys.exit(f"capy : {command!r} inconnu, tu voulais dire {close[0]!r} ?  (cy {close[0]})")
+        sys.exit(f"capy : commande, script ou fichier {command!r} inconnu (possibles : {', '.join(names)})\n\n{USAGE}")
+
+
+# La commande cy : seulement les commandes d'un projet (pas new ni init, qui créent un projet)
+def cli():
+    args = sys.argv[1:]
+    if args[:1] in (["new"], ["init"]):
+        sys.exit(f"cy sert dans un projet existant ; pour en créer un : python3 -m capy {' '.join(args)}")
+    main(args)
+
+
+if __name__ == "__main__":  # python3 -m capy : tout, y compris new et init
+    main(sys.argv[1:])