Refactoring, create a src folders with the python toolchain

This commit is contained in:
stilobique committed 2026-11-08 14:22:51 +01:00
1 parent 2790d92a60
commit 33e4fe0c4e
19 files changed
+246 -122

No files matched your search

+29
View File
@@ -0,0 +1,29 @@
"""Outils de développement du client Jellyfin pour Freebox Player.
freebox-jellyfin preview [--fullscreen] aperçu sur le PC (qmlscene + libfbxqml)
freebox-jellyfin check chargement en HTTP comme sur la box (CI)
freebox-jellyfin package paquet FreeStore dans dist/
freebox-jellyfin deploy [--box IP] … lancement sur un Player en mode développeur
"""
import sys
COMMANDS = ("preview", "check", "package", "deploy")
def main(argv=None):
argv = sys.argv[1:] if argv is None else argv
if not argv or argv[0] not in COMMANDS:
print(__doc__.strip())
print("\nAide d'une commande : freebox-jellyfin <commande> --help")
return 0 if argv and argv[0] in ("-h", "--help") else 2
command, rest = argv[0], argv[1:]
# Imports à la demande : chaque commande ne charge que son module.
if command == "preview":
from .preview import main as run
elif command == "check":
from .check_load import main as run
elif command == "package":
from .package import main as run
else:
from .deploy import main as run
return run(rest)
+5
View File
@@ -0,0 +1,5 @@
import sys
from . import main
sys.exit(main())
+75
View File
@@ -0,0 +1,75 @@
"""Charge l'application comme le Freebox Player (fichiers servis en HTTP) et échoue si Qt
signale une erreur ou un avertissement venant de l'app.
En HTTP, Qt ne peut pas lister les dossiers : c'est là qu'apparaissent les « X is not a type »
(qmldir manquant) ou « Cyclic dependency » (singletons), invisibles en lançant depuis le disque.
"""
import argparse
import functools
import http.server
import os
import subprocess
import sys
import tempfile
import threading
from .project import PROJECT_DIR, libfbxqml, qmlscene
# Messages attendus hors de la box : Settings de libfbxqml (pas d'objet App sur PC).
EXPECTED = ("/libfbxqml/", "qml: Setting", "qml: Getting settings failed")
class _Quiet(http.server.SimpleHTTPRequestHandler):
def log_message(self, *args):
pass
class _Server(http.server.ThreadingHTTPServer):
def handle_error(self, request, client_address):
pass # qmlscene qui s'arrête en plein téléchargement (BrokenPipe) : sans intérêt
def problems(output):
"""Lignes de sortie de qmlscene qui ne sont pas attendues."""
return [line for line in output.splitlines()
if line.strip() and not any(marker in line for marker in EXPECTED)]
def run(duration):
lib, scene = libfbxqml(), qmlscene()
server = _Server(
("127.0.0.1", 0), functools.partial(_Quiet, directory=str(PROJECT_DIR)))
threading.Thread(target=server.serve_forever, daemon=True).start()
url = "http://127.0.0.1:%d/Jellyfin.qml" % server.server_address[1]
print("Chargement de %s pendant %g s…" % (url, duration), flush=True)
try:
with tempfile.TemporaryDirectory() as runtime:
os.chmod(runtime, 0o700)
# Rendu logiciel : la CI (conteneur) n'a pas d'OpenGL.
env = dict(os.environ, XDG_RUNTIME_DIR=runtime,
QT_QPA_PLATFORM="offscreen", QT_QUICK_BACKEND="software")
try:
result = subprocess.run([scene, "-I", str(lib), url], env=env, timeout=duration,
stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
output = result.stdout
except subprocess.TimeoutExpired as expired: # cas normal : l'app reste ouverte
output = expired.stdout or ""
if isinstance(output, bytes):
output = output.decode(errors="replace")
finally:
server.shutdown()
unexpected = problems(output)
if unexpected:
print("Échec : messages inattendus au chargement :", file=sys.stderr)
print("\n".join(unexpected), file=sys.stderr)
return 1
print("OK : chargement sans erreur.")
return 0
def main(argv=None):
parser = argparse.ArgumentParser(prog="freebox-jellyfin check", description=__doc__.splitlines()[0])
parser.add_argument("--duration", type=float, default=6, help="durée du chargement en secondes (défaut : 6)")
args = parser.parse_args(argv)
return run(args.duration)
+214
View File
@@ -0,0 +1,214 @@
"""Lance l'application sur un Freebox Player en mode développeur.
Reproduit le « Run » du plugin QtCreator Freebox (github.com/fbx/freebox-qtcreator-plugin) :
1. trouve le Player sur le réseau local (SSDP, type « fbx:devel ») ou utilise --box ;
2. sert le dossier du projet en HTTP (le Player y télécharge manifest.json et les QML) ;
3. appelle la méthode JSON-RPC « debug_qml_app » sur http://<box>/pub/devel ;
4. affiche stdout/stderr de l'application jusqu'à sa fermeture (ou Ctrl+C).
Usage : freebox-jellyfin deploy [--box 192.168.0.21] [--server media.example.com] [--user nom[:mdp]] [--entry main] [--verbose] [--log deploy.log]
--server : l'app ajoute ce serveur au démarrage (utile car la box n'enregistre rien en mode développement).
--user nom[:mot_de_passe] : compte proposé sur « Qui regarde ? » (le mot de passe transite en clair sur le réseau local).
La sortie est aussi écrite dans deploy.log (racine du projet), écrasé à chaque lancement.
"""
import argparse
import functools
import http.server
import json
import os
import selectors
import socket
import sys
import threading
import time
import urllib.request
from .project import PROJECT_DIR
PROJECT_DIR = str(PROJECT_DIR)
SSDP_ADDR = ("239.255.255.250", 1900)
SSDP_TYPE = "fbx:devel"
def discover(timeout=3.0):
"""Renvoie l'adresse IP du premier Player en mode développeur qui répond."""
request = (
"M-SEARCH * HTTP/1.1\r\n"
"HOST: 239.255.255.250:1900\r\n"
'MAN: "ssdp:discover"\r\n'
"MX: 1\r\n"
"ST: %s\r\n\r\n" % SSDP_TYPE
).encode()
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP)
sock.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, 2)
sock.settimeout(timeout)
try:
sock.sendto(request, SSDP_ADDR)
while True:
data, (addr, _) = sock.recvfrom(4096)
headers = data.decode(errors="replace").lower()
if "st: %s" % SSDP_TYPE in headers or "nt: %s" % SSDP_TYPE in headers:
return addr
except socket.timeout:
return None
finally:
sock.close()
def local_ip_towards(box):
"""Adresse de ce PC vue depuis le Player (interface utilisée pour le joindre)."""
with socket.create_connection((box, 80), timeout=3) as sock:
return sock.getsockname()[0]
DEV_CONFIG_PATH = "/dev-config.json"
class QuietHandler(http.server.SimpleHTTPRequestHandler):
verbose = False
dev_config = None # dict servi sur DEV_CONFIG_PATH (jamais écrit sur disque)
def do_GET(self):
if self.path.split("?")[0] == DEV_CONFIG_PATH and self.dev_config is not None:
body = json.dumps(self.dev_config).encode()
self.send_response(200)
self.send_header("Content-Type", "application/json")
self.send_header("Content-Length", str(len(body)))
self.end_headers()
self.wfile.write(body)
return
super().do_GET()
def log_message(self, fmt, *args):
if self.verbose:
sys.stderr.write("[http] %s\n" % (fmt % args))
def serve_project(bind_ip, verbose, dev_config=None):
QuietHandler.verbose = verbose
QuietHandler.dev_config = dev_config
handler = functools.partial(QuietHandler, directory=PROJECT_DIR)
server = http.server.ThreadingHTTPServer((bind_ip, 0), handler)
threading.Thread(target=server.serve_forever, daemon=True).start()
return server
def json_rpc(box, method, params):
body = json.dumps({"jsonrpc": "2.0", "method": method, "params": params, "id": "0"}).encode()
request = urllib.request.Request(
"http://%s/pub/devel" % box, data=body, headers={"Content-Type": "application/json"}
)
with urllib.request.urlopen(request, timeout=15) as reply:
answer = json.load(reply)
if "error" in answer:
raise RuntimeError(answer["error"].get("message", answer["error"]))
return answer.get("result", {})
def stream_output(box, stdout_port, stderr_port):
"""Affiche la sortie de l'app ; se termine quand le Player ferme stdout (app quittée)."""
selector = selectors.DefaultSelector()
streams = {}
for port, target in ((stdout_port, sys.stdout), (stderr_port, sys.stderr)):
if port:
sock = socket.create_connection((box, port), timeout=5)
sock.settimeout(None)
selector.register(sock, selectors.EVENT_READ)
streams[sock] = target
while streams:
for key, _ in selector.select():
sock = key.fileobj
data = sock.recv(4096)
if not data:
selector.unregister(sock)
sock.close()
if streams.pop(sock) is sys.stdout:
return
continue
streams[sock].write(data.decode(errors="replace"))
streams[sock].flush()
class Tee:
"""Duplique un flux (stdout/stderr) dans le fichier de log."""
def __init__(self, stream, log):
self.stream = stream
self.log = log
def write(self, text):
self.stream.write(text)
self.stream.flush()
self.log.write(text)
self.log.flush()
def flush(self):
self.stream.flush()
self.log.flush()
def main(argv=None):
parser = argparse.ArgumentParser(prog="freebox-jellyfin deploy", description=__doc__.splitlines()[0])
parser.add_argument("--box", help="adresse IP du Player (sinon découverte SSDP)")
parser.add_argument("--entry", default="main", help="entry point du manifest.json (défaut : main)")
parser.add_argument("--verbose", action="store_true", help="affiche les fichiers téléchargés par le Player")
parser.add_argument("--server", action="append", default=[], metavar="ADRESSE",
help="serveur Jellyfin ajouté automatiquement par l'app au démarrage "
"(ex. media.stilobique.com ; option répétable)")
parser.add_argument("--user", action="extend", nargs="+", default=[], metavar="NOM[:MOT_DE_PASSE]",
help="compte(s) affiché(s) sur l'écran « Qui regarde ? » ; avec mot de passe, "
"connexion en un clic (ex. --user alice:mdp bob, ou --user répété)")
parser.add_argument("--log", default=os.path.join(PROJECT_DIR, "deploy.log"),
help="fichier de log, écrasé à chaque lancement (défaut : deploy.log ; vide pour désactiver)")
args = parser.parse_args(argv)
if args.log:
log = open(args.log, "w", encoding="utf-8")
log.write("# freebox-jellyfin deploy %s\n" % time.strftime("%Y-%m-%d %H:%M:%S"))
sys.stdout = Tee(sys.stdout, log)
sys.stderr = Tee(sys.stderr, log)
box = args.box
if not box:
print("Recherche d'un Freebox Player en mode développeur…")
box = discover()
if not box:
sys.exit("Aucun Player trouvé. Vérifiez le mode développeur, ou passez --box <IP>.")
print("Player : %s" % box)
try:
me = local_ip_towards(box)
except OSError as error:
sys.exit("Impossible de joindre %s:80 (%s)." % (box, error))
users = []
for spec in args.user:
name, sep, password = spec.partition(":")
users.append({"name": name, "password": password} if sep else {"name": name})
dev_config = {"servers": args.server, "users": users} if (args.server or users) else None
server = serve_project(me, args.verbose, dev_config)
port = server.server_address[1]
manifest_url = "http://%s:%d/manifest.json" % (me, port)
print("Projet servi sur %s" % manifest_url)
if args.server:
print("Serveurs de test proposés à l'app : %s" % ", ".join(args.server))
if users: # les mots de passe ne sont jamais affichés
print("Utilisateurs de test : %s" % ", ".join(
u["name"] + (" (mot de passe fourni)" if "password" in u else "") for u in users))
try:
result = json_rpc(box, "debug_qml_app", {
"manifest_url": manifest_url,
"entry_point": args.entry,
"wait": False,
})
print("Application lancée. Ctrl+C pour arrêter.\n")
stream_output(box, result.get("stdout_port"), result.get("stderr_port"))
print("\nApplication fermée sur le Player.")
except KeyboardInterrupt:
print("\nArrêt.")
except Exception as error: # erreurs réseau ou JSON-RPC : message lisible
sys.exit("Échec du lancement : %s" % error)
finally:
server.shutdown()
+148
View File
@@ -0,0 +1,148 @@
"""Fabrique le paquet FreeStore (.tar.gz) à téléverser sur la console FreeFactory.
Reproduit « Outils > Freebox SDK > Make FreeStore Package » du plugin QtCreator Freebox
(github.com/fbx/freebox-qtcreator-plugin, src/freestorepackager.cc) :
- fichiers inclus comme dans Jellyfin.fbxproject : QML, JS, images, polices, qmldir et
manifest.json (tools/ et src/ sont exclus : l'outillage PC n'a rien à faire sur la box) ;
- vérifications : manifest.json (identifiant, version identique à Session.clientVersion,
points d'entrée existants), JSON valides,
syntaxe QML/JS (qmllint, s'il est installé) ;
- archive tar (format ustar, avec les entrées de dossiers) compressée en gzip.
Usage : freebox-jellyfin package [--output dist/paquet.tar.gz]
"""
import argparse
import io
import json
import os
import re
import shutil
import subprocess
import sys
import tarfile
import time
from .project import PROJECT_DIR
PROJECT_DIR = str(PROJECT_DIR)
# Types de fichiers repris de Jellyfin.fbxproject (QmlFiles, JavaScriptFiles, ImageFiles, Files).
EXTENSIONS = {".qml", ".js", ".png", ".jpg", ".jpeg", ".gif", ".svg", ".bmp", ".webp",
".ttf", ".otf", ".woff"}
NAMES = {"qmldir", "manifest.json"}
EXCLUDED_DIRS = {"tools", "dist", "src"}
def collect_files():
files = []
for root, dirs, names in os.walk(PROJECT_DIR):
rel_root = os.path.relpath(root, PROJECT_DIR)
# Dossiers cachés (.git, .idea…) et dossiers d'outillage exclus.
dirs[:] = sorted(d for d in dirs if not d.startswith(".")
and not (rel_root == "." and d in EXCLUDED_DIRS))
for name in sorted(names):
if name in NAMES or os.path.splitext(name)[1].lower() in EXTENSIONS:
files.append(os.path.normpath(os.path.join(rel_root, name)))
return files
def check_manifest(files):
"""Mêmes règles que fileformat/manifest.cc du plugin. Renvoie le manifest."""
path = os.path.join(PROJECT_DIR, "manifest.json")
if not os.path.exists(path):
raise ValueError("manifest.json manquant")
manifest = json.load(open(path, encoding="utf-8"))
identifier = manifest.get("identifier")
if not isinstance(identifier, str) or not re.fullmatch(r"\w+(\.\w+)+", identifier):
raise ValueError("manifest.json : « identifier » absent ou invalide (forme attendue : a.b.c)")
entry_points = manifest.get("entryPoints")
if not isinstance(entry_points, dict) or not entry_points:
raise ValueError("manifest.json : « entryPoints » absent ou invalide")
defaults = 0
for key, entry in entry_points.items():
if not isinstance(entry, dict) or not isinstance(entry.get("file"), str):
raise ValueError("manifest.json : entryPoints.%s.file doit être un fichier" % key)
if not re.fullmatch(r"[/\w.+~-]+", entry["file"]):
raise ValueError("manifest.json : caractères invalides dans entryPoints.%s.file" % key)
if entry["file"] not in files:
raise ValueError("manifest.json : entryPoints.%s.file « %s » absent du paquet" % (key, entry["file"]))
if "uiFlavor" in entry and entry["uiFlavor"] not in ("multi", "classic"):
raise ValueError("manifest.json : entryPoints.%s.uiFlavor doit valoir multi ou classic" % key)
if entry.get("default") is True:
defaults += 1
if defaults > 1:
raise ValueError("manifest.json : un seul point d'entrée peut avoir « default »: true")
version = manifest.get("version")
if not isinstance(version, str) or not re.fullmatch(r"\d+\.\d+\.\d+", version):
raise ValueError("manifest.json : « version » absente ou invalide (forme attendue : 1.2.3)")
# La version envoyée à Jellyfin (Session.clientVersion) doit rester la même.
session = open(os.path.join(PROJECT_DIR, "Core", "Session.qml"), encoding="utf-8").read()
client = re.search(r'clientVersion:\s*"([^"]*)"', session)
if not client or client.group(1) != version:
raise ValueError("version du manifest (%s) différente de Session.clientVersion (%s)"
% (version, client.group(1) if client else "introuvable"))
icon = manifest.get("icon")
if icon and icon not in files:
raise ValueError("manifest.json : icône « %s » absente du paquet" % icon)
return manifest
def check_sources(files):
for name in files:
if name.endswith(".json"):
json.load(open(os.path.join(PROJECT_DIR, name), encoding="utf-8"))
qmllint = shutil.which("qmllint")
if not qmllint:
print("Attention : qmllint introuvable, syntaxe QML/JS non vérifiée.")
return
sources = [os.path.join(PROJECT_DIR, f) for f in files if f.endswith((".qml", ".js"))]
result = subprocess.run([qmllint] + sources, capture_output=True, text=True)
if result.returncode != 0:
raise ValueError("erreurs de syntaxe QML/JS :\n" + (result.stdout + result.stderr).strip())
def build_archive(files, output):
def info(name, is_dir, size=0):
entry = tarfile.TarInfo(name + ("/" if is_dir else ""))
entry.type = tarfile.DIRTYPE if is_dir else tarfile.REGTYPE
entry.mode = 0o755 if is_dir else 0o644
entry.size = size
entry.mtime = int(time.time())
entry.uid = entry.gid = 0
entry.uname = entry.gname = ""
return entry
os.makedirs(os.path.dirname(os.path.abspath(output)), exist_ok=True)
seen_dirs = set()
with tarfile.open(output, "w:gz", format=tarfile.USTAR_FORMAT) as archive:
for name in files:
# Entrées de dossiers (comme le plugin), du parent vers l'enfant.
parts = name.split(os.sep)[:-1]
for depth in range(1, len(parts) + 1):
directory = "/".join(parts[:depth])
if directory not in seen_dirs:
seen_dirs.add(directory)
archive.addfile(info(directory, True))
data = open(os.path.join(PROJECT_DIR, name), "rb").read()
archive.addfile(info(name.replace(os.sep, "/"), False, len(data)), io.BytesIO(data))
def main(argv=None):
parser = argparse.ArgumentParser(prog="freebox-jellyfin package", description=__doc__.splitlines()[0])
parser.add_argument("--output", help="archive à créer (défaut : dist/<identifier>-<version>.tar.gz)")
args = parser.parse_args(argv)
files = collect_files()
try:
manifest = check_manifest(files)
check_sources(files)
except (ValueError, json.JSONDecodeError) as error:
sys.exit("Paquet non créé : %s" % error)
output = args.output or os.path.join(
PROJECT_DIR, "dist", "%s-%s.tar.gz" % (manifest["identifier"], manifest["version"]))
build_archive(files, output)
print("Paquet créé : %s — version %s (%d fichiers, %.1f Ko)" % (
os.path.relpath(output, os.getcwd()), manifest["version"], len(files), os.path.getsize(output) / 1024))
print("À téléverser sur la console FreeFactory (http://factory.free.fr).")
+15
View File
@@ -0,0 +1,15 @@
"""Lance l'application sur le PC avec qmlscene (Qt 5) et libfbxqml."""
import argparse
import os
from .project import PROJECT_DIR, libfbxqml, qmlscene
def main(argv=None):
parser = argparse.ArgumentParser(prog="freebox-jellyfin preview", description=__doc__)
parser.add_argument("--fullscreen", action="store_true",
help="lance Jellyfin.qml en plein écran, comme sur la box (sinon fenêtre 1280x720)")
args = parser.parse_args(argv)
lib, scene = libfbxqml(), qmlscene()
qml = PROJECT_DIR / ("Jellyfin.qml" if args.fullscreen else "tools/preview.qml")
os.execv(scene, [scene, "-I", str(lib), str(qml)])
+33
View File
@@ -0,0 +1,33 @@
"""Emplacements partagés par les commandes : racine du projet QML, libfbxqml et qmlscene."""
import os
import shutil
import sys
from pathlib import Path
def _find_root() -> Path:
"""Dossier contenant manifest.json : depuis le dossier courant, sinon depuis ce module."""
for start in (Path.cwd(), Path(__file__).resolve().parent):
for folder in (start, *start.parents):
if (folder / "manifest.json").is_file() and (folder / "Jellyfin.qml").is_file():
return folder
sys.exit("Projet introuvable : lancez la commande depuis le dépôt Jellyfin-Freebox.")
PROJECT_DIR = _find_root()
def libfbxqml() -> Path:
"""libfbxqml (module fbx.application en QML pur) : ../libfbxqml, ou $LIBFBXQML."""
path = Path(os.environ.get("LIBFBXQML", PROJECT_DIR.parent / "libfbxqml"))
if not (path / "fbx").is_dir():
sys.exit("libfbxqml introuvable : git clone https://github.com/fbx/libfbxqml.git %s" % path)
return path
def qmlscene() -> str:
"""qmlscene de Qt 5 : $QMLSCENE, le PATH, ou l'emplacement Debian/Ubuntu."""
path = os.environ.get("QMLSCENE") or shutil.which("qmlscene") or "/usr/lib/qt5/bin/qmlscene"
if not os.path.exists(path) and not shutil.which(path):
sys.exit("qmlscene introuvable : sudo apt install qmlscene")
return path