fletchtime 0.2.4__tar.gz → 0.2.5__tar.gz

{fletchtime-0.2.4/src/fletchtime.egg-info → fletchtime-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fletchtime
-Version: 0.2.4
+Version: 0.2.5
 Summary: Chronométrage de compétitions d'archerie FFTL (Indoor, Flint) -- serveur + interfaces web incluses
 License: GPL-3.0-or-later
 Requires-Python: >=3.11

{fletchtime-0.2.4 → fletchtime-0.2.5}/docs/architecture.md

@@ -343,6 +343,60 @@ confirmer le rendu et l'ergonomie tactile -- voir aussi le piège
 PyInstaller/`customtkinter` documenté dans {doc}`dev-guide/index`.
 ```
 
+## Résilience de la boucle de décompte
+
+`MatchServer.tick_loop()` capture désormais toute exception imprévue en
+son sein (journalisée avec la trace complète) plutôt que de laisser
+mourir la boucle silencieusement -- filet de sécurité ajouté suite à un
+symptôme signalé en pratique : le chrono se figeait indéfiniment, sans
+aucune erreur visible, le reste du serveur (connexions, réponse aux
+commandes) continuant de fonctionner normalement à côté.
+
+```{important}
+**Cause la plus probable identifiée** : sous Windows, remplacer un
+fichier (`Path.replace`) peut échouer avec une "violation de partage"
+si un autre processus a le fichier cible ouvert au même instant
+(antivirus, surveillance de fichiers d'un IDE, Git Bash...) -- une
+différence fondamentale avec la sémantique POSIX (Linux/macOS), où ceci
+n'arrive jamais. Observé une fois en pratique, précisément sur
+`config/match_state.json` -- écrit à chaque tick depuis la persistance
+après plantage (voir plus bas). Sans gestion d'erreur, cette exception
+tuait silencieusement `tick_loop` pour de bon : exactement le symptôme
+rapporté (gel permanent, aucune déconnexion, se produisant aussi bien
+en fenêtre graphique qu'en mode terminal -- sans lien réel avec le
+focus d'une fenêtre, malgré la corrélation observée au départ).
+
+Deux correctifs complémentaires : ce filet dans `tick_loop` (n'importe
+quelle exception, pas seulement celle-ci), et
+`config_store.save_match_snapshot` qui retente quelques fois avant
+d'abandonner proprement (jamais d'exception qui remonterait perturber
+la diffusion de l'état aux écrans pour ce tick). Testé concrètement :
+un échec transitoire (une fois puis réussite) est absorbé et le
+contenu final reste correct ; un échec permanent (toutes les tentatives
+échouent) est abandonné proprement, sans jamais lever d'exception.
+```
+
+## Statut technique exposé via HTTP (`/api/status`)
+
+Les mêmes données déjà affichées dans `control.html` (écrans connectés,
+mode actif, phase en cours, pack de sons, mot de passe configuré ou non)
+sont aussi exposées via un simple GET HTTP, lues directement depuis
+l'instance `MatchServer` partagée avec le serveur WebSocket (voir
+`ServerRuntime`, qui construit maintenant ce `MatchServer` une seule fois
+et le fait circuler vers les deux serveurs plutôt que de le laisser
+`run_ws_server` en créer un nouveau à chaque démarrage).
+
+Utilisé par la fenêtre graphique pour afficher ce même statut sans
+dupliquer la logique de rendu HTML -- interrogé par sondage périodique
+(toutes les 2s) depuis un thread séparé plutôt qu'en temps réel via une
+vraie connexion WebSocket, volontairement : pas besoin de la précision
+temps réel d'une vraie connexion juste pour un affichage de statut, et
+ça évite de dupliquer toute la logique de reconnexion/état déjà présente
+côté web. La requête HTTP elle-même tourne toujours dans un thread à
+part, jamais directement depuis le thread principal de la fenêtre (une
+requête bloquante, même locale, gèlerait sinon l'interface le temps de
+sa réponse).
+
 ## Journal applicatif persistant
 
 En plus du journal affiché dans la fenêtre graphique (en mémoire,
@@ -370,6 +424,21 @@ volatile de la fenêtre.
   dernières secondes de chaque volée -- noierait le journal sans valeur
   diagnostique ajoutée).
 
+```{important}
+`configure_logging` prend un `console_level` séparé du niveau du fichier
+(toujours INFO par défaut, lui) -- la fenêtre graphique doit l'appeler
+avec `console_level=logging.INFO` explicitement, **pas** le défaut
+(`WARNING`, pensé pour un terminal silencieux par défaut, voir
+`fletchtime.__main__`, `-v`/`--verbose`). Un oubli de ce paramètre a
+laissé le widget de journal de la fenêtre silencieux en usage normal
+pendant un temps -- tous les journaux applicatifs ci-dessus sont à
+INFO, donc filtrés par le `WARNING` par défaut, exactement l'inverse de
+ce que ce widget est censé montrer. Confirmé par comparaison directe
+avant/après correctif : file d'attente vide avant, message présent
+après, avec un appel par ailleurs identique.
+```
+
+
 ```{important}
 Le mot de passe (action `authenticate`) n'est **jamais** journalisé -- le
 code ne journalise jamais `data` tel quel, seulement le nom de l'action
@@ -565,3 +634,15 @@ La miniature d'aperçu de `control.html` est un vrai `display.html` chargé
 dans une `<iframe>` (mise à l'échelle en CSS) plutôt qu'une logique de rendu
 dupliquée -- elle s'enregistre avec la lane spéciale `"apercu"`, exclue du
 comptage des écrans connectés.
+
+```{note}
+**Cette même lane `"apercu"` ne joue jamais de son** (voir `display.html`,
+`soundEnabled`) : sans ça, ouvrir la page de contrôle et un vrai écran
+d'affichage sur le même PC faisait entendre chaque son deux fois --
+l'aperçu est une simple vue visuelle pour le responsable du
+chronométrage, pas un écran destiné aux archers. Un paramètre d'URL
+`?mute=1` permet en plus de couper le son sur n'importe quel autre onglet
+ouvert en trop sur la même machine (ex. pour surveiller une autre lane
+sans dupliquer le son de l'écran qui joue réellement pour les archers).
+```
+

{fletchtime-0.2.4 → fletchtime-0.2.5}/docs/roadmap.md

@@ -77,6 +77,48 @@ dépendent d'extensions compilées (Rust/C) peu fiables sur Pydroid 3, voir
 
 ## Backlog — à discuter / non encore programmé dans une étape précise
 
+- ~~**Icône de l'exécutable**~~ -- fait : `web/logo.ico` (multi-résolution,
+  16 à 256px, généré depuis `web/logo.svg`), utilisé par `fletchtime.spec`
+  pour l'exécutable Windows. Sans effet sous Linux, qui n'a pas ce
+  concept de métadonnées d'icône pour un simple binaire (vérifié). Le
+  favicon des pages web était en fait déjà en place, rien à faire là.
+- ~~**Son dupliqué sur plusieurs onglets**~~ -- fait : l'aperçu de
+  `control.html` (une vraie instance de `display.html` en iframe) ne
+  joue plus jamais de son -- c'est une simple vue visuelle, pas un écran
+  destiné aux archers. `?mute=1` permet en plus de couper le son sur
+  n'importe quel autre onglet ouvert en trop sur le même PC.
+- ~~**Chrono figé (sous Windows, pas lié au focus en réalité)**~~ --
+  cause la plus probable identifiée : sous Windows, remplacer un fichier
+  peut échouer avec une "violation de partage" si un autre processus l'a
+  ouvert au même instant (antivirus, surveillance de fichiers d'un
+  IDE...) -- observé une fois en pratique, précisément sur
+  `config/match_state.json`, écrit à chaque tick depuis la persistance
+  après plantage. Sans gestion d'erreur, ça tuait silencieusement
+  `tick_loop` pour de bon -- exactement le symptôme rapporté (gel
+  permanent, pas de déconnexion, se produisant aussi bien en GUI qu'en
+  headless, sans lien réel avec le focus). Deux correctifs : `tick_loop`
+  capture désormais toute exception imprévue en son sein (journalisée
+  avec sa trace complète, ne meurt plus silencieusement) et
+  `save_match_snapshot` retente quelques fois avant d'abandonner
+  proprement (jamais d'exception qui remonterait perturber la diffusion
+  de l'état aux écrans). Testé concrètement : échec transitoire récupéré,
+  échec permanent absorbé sans lever.
+- ~~**Journal absent du widget de la fenêtre**~~ -- vrai bug trouvé en
+  creusant le point précédent : `configure_logging` était appelé sans
+  préciser `console_level`, retombant sur le défaut `WARNING` (pensé
+  pour un terminal silencieux) -- qui filtrait justement tout ce que ce
+  widget est censé montrer (commandes, connexions, transitions, toutes
+  en `INFO`). Corrigé avec `console_level=INFO` explicite pour la
+  fenêtre. Confirmé par comparaison directe avant/après : file vide
+  avant, message présent après.
+- ~~**Données techniques dans la fenêtre**~~ -- fait : nouvel endpoint
+  `/api/status` (les mêmes données déjà affichées dans `control.html`),
+  affiché dans la fenêtre via sondage périodique. `ServerRuntime`
+  construit maintenant le `MatchServer` une seule fois et le partage
+  entre les deux serveurs, plutôt que d'en laisser `run_ws_server` créer
+  un nouveau à chaque démarrage.
+
+
 - ~~**Remerciements**~~ -- structure prête, à compléter : `REMERCIEMENTS.md`
   (modèle à remplir avec les noms), lié depuis le README et intégré à la
   doc Sphinx ({doc}`remerciements` -- même contenu, pas dupliqué, via une

{fletchtime-0.2.4 → fletchtime-0.2.5}/fletchtime.spec

@@ -71,6 +71,13 @@ exe = EXE(
     # assets/ du bootstrap), d'où un serveur qui tourne mais ne sert rien
     # d'utile. "." restaure explicitement l'ancien comportement.
     contents_directory=".",
+    # Icône de l'exécutable (barre des tâches, explorateur de fichiers,
+    # raccourci) -- fichier .ico multi-résolution (16 à 256px), généré à
+    # partir de web/logo.svg. PyInstaller ignore ce paramètre sous Linux
+    # (les .ico n'y ont pas de sens -- l'icône affichée dépend du
+    # gestionnaire de fichiers/bureau, hors du contrôle de l'exécutable
+    # lui-même), donc rien à prévoir de spécial pour cette plateforme.
+    icon=str(project_root / "src" / "fletchtime" / "web" / "logo.ico"),
 )
 
 coll = COLLECT(

{fletchtime-0.2.4 → fletchtime-0.2.5}/src/fletchtime/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.2.4'
-__version_tuple__ = version_tuple = (0, 2, 4)
+__version__ = version = '0.2.5'
+__version_tuple__ = version_tuple = (0, 2, 5)
 
-__commit_id__ = commit_id = 'g5efc3a10b'
+__commit_id__ = commit_id = 'ga6e6ad564'

{fletchtime-0.2.4 → fletchtime-0.2.5}/src/fletchtime/gui.py

@@ -24,8 +24,13 @@ Pydroid reste nécessaire pour confirmer le rendu et l'ergonomie tactile.
 
 from __future__ import annotations
 
+import json
+import logging
 import queue
 import sys
+import threading
+import urllib.error
+import urllib.request
 import webbrowser
 
 import customtkinter as ctk
@@ -64,6 +69,17 @@ _TRANSLATIONS = {
         "networkErrorRange": "Les ports doivent être entre 1 et 65535",
         "networkErrorSame": "Les deux ports doivent être différents",
         "networkApplied": "Appliqué",
+        "techStatusUnavailable": "Statut technique : indisponible (serveur en cours de démarrage ?)",
+        "techStatusClients": "Clients connectés :",
+        "techStatusLanes": "Écrans :",
+        "techStatusNoLanes": "aucun",
+        "techStatusMode": "Mode :",
+        "techStatusNoMode": "aucun",
+        "techStatusPhase": "Phase :",
+        "techStatusSound": "Sons :",
+        "techStatusAuth": "Mot de passe :",
+        "yes": "oui",
+        "no": "non",
     },
     "en": {
         "title": "FletchTime -- Server",
@@ -87,6 +103,17 @@ _TRANSLATIONS = {
         "networkErrorRange": "Ports must be between 1 and 65535",
         "networkErrorSame": "Both ports must be different",
         "networkApplied": "Applied",
+        "techStatusUnavailable": "Technical status: unavailable (server starting?)",
+        "techStatusClients": "Connected clients:",
+        "techStatusLanes": "Screens:",
+        "techStatusNoLanes": "none",
+        "techStatusMode": "Mode:",
+        "techStatusNoMode": "none",
+        "techStatusPhase": "Phase:",
+        "techStatusSound": "Sounds:",
+        "techStatusAuth": "Password:",
+        "yes": "yes",
+        "no": "no",
     },
 }
 
@@ -209,6 +236,7 @@ class FletchTimeApp(ctk.CTk):
 
         self.language = "fr"
         self.log_queue: queue.Queue[str] = queue.Queue()
+        self.status_queue: queue.Queue = queue.Queue()
 
         self.data_root = _data_root()
         self.app_web_dir = _app_web_dir()
@@ -226,10 +254,17 @@ class FletchTimeApp(ctk.CTk):
         # Appelé APRÈS la redirection ci-dessus, volontairement : le
         # StreamHandler créé par configure_logging() se lie au sys.stderr
         # courant au moment de sa création -- fait après le remplacement,
-        # les journaux applicatifs (commandes reçues, pertes de connexion...)
-        # apparaissent donc aussi dans le widget de journal de la fenêtre,
-        # pas seulement dans le fichier persistant.
-        self.log_file = configure_logging(self.data_root / "logs")
+        # les journaux applicatifs (commandes reçues, pertes de connexion,
+        # transitions...) apparaissent donc aussi dans le widget de
+        # journal de la fenêtre, pas seulement dans le fichier persistant.
+        #
+        # console_level=INFO explicite, pas le défaut (WARNING, pensé
+        # pour un terminal silencieux par défaut -- voir
+        # fletchtime.__main__, -v/--verbose) : sans ce paramètre, le
+        # widget de journal de la fenêtre restait silencieux en usage
+        # normal, puisque tous les journaux applicatifs sont à INFO --
+        # exactement l'inverse de ce que ce widget est censé montrer.
+        self.log_file = configure_logging(self.data_root / "logs", console_level=logging.INFO)
 
         self.title(self._t("title"))
         self.geometry("820x600")
@@ -238,6 +273,8 @@ class FletchTimeApp(ctk.CTk):
 
         self._build_ui()
         self._poll_log_queue()
+        self._poll_technical_status()
+        self._drain_status_queue()
         self._start_server()
 
     # -- traductions ---------------------------------------------------
@@ -388,6 +425,20 @@ class FletchTimeApp(ctk.CTk):
         self.network_status_label = ctk.CTkLabel(network_frame, text="", text_color="gray60")
         self.network_status_label.pack(side="left", padx=(4, 12), pady=8, fill="x", expand=True)
 
+        # -- statut technique ---------------------------------------------
+        # Les mêmes données techniques que celles déjà affichées dans la
+        # page de contrôle (écrans connectés, mode actif...), lues via
+        # /api/status -- voir _poll_technical_status ci-dessous, et
+        # fletchtime.server.http_static._DualRootHandler._build_status_body
+        # côté serveur.
+        tech_frame = ctk.CTkFrame(self)
+        tech_frame.pack(fill="x", padx=16, pady=(0, 8))
+
+        self.tech_status_label = ctk.CTkLabel(
+            tech_frame, text=self._t("techStatusUnavailable"), anchor="w", justify="left"
+        )
+        self.tech_status_label.pack(fill="x", padx=12, pady=8)
+
         # -- journal ----------------------------------------------------
         self.log_label = ctk.CTkLabel(self, text=self._t("log_title"), anchor="w")
         self.log_label.pack(fill="x", padx=20, pady=(8, 0))
@@ -557,6 +608,61 @@ class FletchTimeApp(ctk.CTk):
 
     # -- journal (file thread-safe -> widget) ------------------------------
 
+    # -- statut technique (thread séparé pour la requête HTTP -> file) -----
+
+    def _poll_technical_status(self) -> None:
+        # Une requête HTTP, même locale, peut mettre du temps à répondre
+        # (serveur qui démarre, port qui change...) -- jamais faite
+        # directement depuis le thread principal (gèlerait la fenêtre le
+        # temps de la requête). Un thread par sondage, plutôt qu'un seul
+        # thread persistant : plus simple, et chaque requête se termine en
+        # quelques millisecondes en pratique (même machine).
+        threading.Thread(target=self._fetch_technical_status, daemon=True).start()
+        self.after(2000, self._poll_technical_status)
+
+    def _fetch_technical_status(self) -> None:
+        # Tourne dans un thread séparé -- ne touche JAMAIS un widget
+        # Tkinter directement ici (pas thread-safe) ; pousse seulement le
+        # résultat dans une file, lue depuis le thread principal via
+        # _drain_status_queue, exactement comme le journal (self.log_queue).
+        try:
+            url = f"http://127.0.0.1:{self.http_port}/api/status"
+            with urllib.request.urlopen(url, timeout=2) as res:
+                data = json.loads(res.read())
+        except (urllib.error.URLError, OSError, ValueError):
+            # Serveur pas encore démarré, port en cours de changement,
+            # réponse invalide... -- affiche juste "indisponible", jamais
+            # une exception qui remonterait jusqu'au thread principal.
+            data = None
+        self.status_queue.put(data)
+
+    def _drain_status_queue(self) -> None:
+        try:
+            while True:
+                data = self.status_queue.get_nowait()
+                self._render_technical_status(data)
+        except queue.Empty:
+            pass
+        self.after(200, self._drain_status_queue)
+
+    def _render_technical_status(self, data: dict | None) -> None:
+        if not data or not data.get("available"):
+            self.tech_status_label.configure(text=self._t("techStatusUnavailable"))
+            return
+        lanes = ", ".join(data["connected_lanes"]) or self._t("techStatusNoLanes")
+        mode = data["active_mode"] or self._t("techStatusNoMode")
+        phase = data["match_phase"] or "--"
+        text = (
+            f"{self._t('techStatusClients')} {data['connected_clients']}  |  "
+            f"{self._t('techStatusLanes')} {lanes}  |  "
+            f"{self._t('techStatusMode')} {mode}  |  "
+            f"{self._t('techStatusPhase')} {phase}  |  "
+            f"{self._t('techStatusSound')} {data['sound_pack']}  |  "
+            f"{self._t('techStatusAuth')} "
+            f"{self._t('yes') if data['password_configured'] else self._t('no')}"
+        )
+        self.tech_status_label.configure(text=text)
+
     def _poll_log_queue(self) -> None:
         try:
             while True:

{fletchtime-0.2.4 → fletchtime-0.2.5}/src/fletchtime/runtime.py

@@ -18,6 +18,7 @@ import threading
 from http.server import ThreadingHTTPServer
 
 from fletchtime.server.http_static import start_http_server
+from fletchtime.server.match_server import MatchServer
 from fletchtime.server.ws_server import run_ws_server
 
 
@@ -33,6 +34,13 @@ class ServerRuntime:
         self.http_port = http_port
         self.ws_port = ws_port
 
+        # Créé une seule fois ici (pas dans run_ws_server, qui en
+        # construirait un nouveau à chaque start()) -- partagé avec le
+        # serveur HTTP (voir start_http_server, paramètre match_server)
+        # pour exposer l'état du match en lecture via /api/status, sans
+        # dupliquer d'état entre les deux serveurs.
+        self.match_server = MatchServer()
+
         self._httpd: ThreadingHTTPServer | None = None
         self._http_thread: threading.Thread | None = None
         self._ws_thread: threading.Thread | None = None
@@ -52,7 +60,7 @@ class ServerRuntime:
             return
 
         self._httpd = start_http_server(
-            self.app_web_dir, self.http_port, self.assets_dir, self.ws_port
+            self.app_web_dir, self.http_port, self.assets_dir, self.ws_port, self.match_server
         )
         self._http_thread = threading.Thread(target=self._httpd.serve_forever, daemon=True)
         self._http_thread.start()
@@ -72,7 +80,9 @@ class ServerRuntime:
         self._ws_stop_event = asyncio.Event()
         self._ws_ready.set()
         try:
-            loop.run_until_complete(run_ws_server(self.ws_port, self._ws_stop_event))
+            loop.run_until_complete(
+                run_ws_server(self.ws_port, self._ws_stop_event, self.match_server)
+            )
         finally:
             loop.close()
 

{fletchtime-0.2.4 → fletchtime-0.2.5}/src/fletchtime/server/config_store.py

@@ -13,7 +13,9 @@ maison, largement suffisant pour les types simples qu'on manipule ici
 from __future__ import annotations
 
 import json
+import logging
 import sys
+import time
 import tomllib
 from dataclasses import fields
 from pathlib import Path
@@ -21,6 +23,8 @@ from typing import Any
 
 from fletchtime.engine import FlintConfig, IndoorConfig
 
+logger = logging.getLogger("fletchtime.server")
+
 # FletchTime opère sur le répertoire courant, comme la plupart des outils en
 # ligne de commande (jekyll, hugo...) : `config/` vit à côté d'où la
 # commande est lancée -- que ce soit un clone du dépôt (le dev lance
@@ -256,12 +260,45 @@ def _write_toml(path: Path, values: dict[str, Any], comments: dict[str, str]) ->
 def save_match_snapshot(data: dict[str, Any]) -> None:
     """Écriture atomique (fichier temporaire puis renommage) : ne laisse
     jamais un fichier à moitié écrit si le processus s'arrête précisément
-    pendant l'écriture -- ``Path.replace`` est atomique aussi bien sous
-    Linux/macOS que Windows depuis Python 3.3+."""
+    pendant l'écriture -- ``Path.replace`` est garanti atomique aussi bien
+    sous Linux/macOS que Windows depuis Python 3.3+.
+
+    Ceci dit, "atomique" ne veut pas dire "ne peut jamais échouer" : sous
+    Windows, remplacer un fichier peut lever une erreur de "violation de
+    partage" si un autre processus l'a ouvert au même instant (antivirus,
+    surveillance de fichiers d'un IDE, Git Bash...) -- constaté en
+    pratique (voir docs/architecture.md, section sur la résilience de la
+    boucle de décompte, appelante de cette fonction à chaque tick).
+    Ce verrou est transitoire par nature, d'où quelques tentatives avant
+    d'abandonner. Échoue silencieusement (juste un avertissement dans le
+    journal) plutôt que de lever : un instantané manqué n'est jamais
+    grave (le prochain tick, ~200ms plus tard, retente), alors qu'une
+    exception qui remonterait perturberait aussi la diffusion de l'état
+    aux écrans pour ce même tick, pour une raison qui n'a rien à voir
+    avec eux."""
     MATCH_STATE_JSON.parent.mkdir(parents=True, exist_ok=True)
     tmp_path = MATCH_STATE_JSON.with_suffix(".json.tmp")
-    tmp_path.write_text(json.dumps(data), encoding="utf-8")
-    tmp_path.replace(MATCH_STATE_JSON)
+    try:
+        tmp_path.write_text(json.dumps(data), encoding="utf-8")
+    except OSError:
+        logger.warning("Échec d'écriture de l'instantané de match (fichier temporaire)")
+        return
+
+    last_error: OSError | None = None
+    for attempt in range(3):
+        try:
+            tmp_path.replace(MATCH_STATE_JSON)
+            return
+        except OSError as exc:
+            last_error = exc
+            if attempt < 2:
+                time.sleep(0.05)
+    logger.warning(
+        "Échec de sauvegarde de l'instantané de match après plusieurs tentatives "
+        "(fichier probablement verrouillé par un autre processus, ex. antivirus, "
+        "IDE) : %s",
+        last_error,
+    )
 
 
 def load_match_snapshot() -> dict[str, Any] | None:

{fletchtime-0.2.4 → fletchtime-0.2.5}/src/fletchtime/server/http_static.py

@@ -33,9 +33,12 @@ class _DualRootHandler(SimpleHTTPRequestHandler):
     behaviour as before this existed).
     """
 
-    def __init__(self, *args, directory: str, assets_dir: str, ws_port: int, **kwargs) -> None:
+    def __init__(
+        self, *args, directory: str, assets_dir: str, ws_port: int, match_server=None, **kwargs
+    ) -> None:
         self._assets_dir = assets_dir
         self._ws_port = ws_port
+        self._match_server = match_server
         super().__init__(*args, directory=directory, **kwargs)
 
     def do_GET(self) -> None:
@@ -49,15 +52,59 @@ class _DualRootHandler(SimpleHTTPRequestHandler):
             # page elle-même, qui est garanti correct sans configuration
             # supplémentaire côté client.
             body = json.dumps({"version": __version__, "ws_port": self._ws_port}).encode("utf-8")
-            self.send_response(200)
-            self.send_header("Content-Type", "application/json")
-            self.send_header("Content-Length", str(len(body)))
-            self.send_header("Cache-Control", "no-store")
-            self.end_headers()
-            self.wfile.write(body)
+            self._send_json(body)
+            return
+        if self.path == "/api/status":
+            self._send_json(self._build_status_body())
             return
         super().do_GET()
 
+    def _send_json(self, body: bytes) -> None:
+        self.send_response(200)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(body)))
+        self.send_header("Cache-Control", "no-store")
+        self.end_headers()
+        self.wfile.write(body)
+
+    def _build_status_body(self) -> bytes:
+        """Les mêmes données techniques que celles déjà affichées dans la
+        page de contrôle (écrans connectés, mode actif...), exposées ici
+        pour que la fenêtre graphique puisse les afficher aussi sans
+        dupliquer la logique de rendu HTML -- voir fletchtime.gui,
+        interrogé par sondage périodique plutôt qu'en temps réel (pas
+        besoin d'une vraie connexion WebSocket juste pour un affichage de
+        statut, voir sa docstring pour le détail de ce choix).
+
+        Lu directement depuis l'instance MatchServer partagée avec le
+        serveur WebSocket (voir fletchtime.runtime.ServerRuntime), depuis
+        un thread différent de celui qui la modifie -- en lecture seule,
+        sans le verrou asyncio de MatchServer (qui ne serait de toute
+        façon pas utilisable depuis ce thread synchrone). Le GIL rend
+        chaque lecture individuelle atomique ; au pire, une valeur d'un
+        sondage sur deux légèrement obsolète pour un simple affichage de
+        statut, jamais une valeur corrompue."""
+        if self._match_server is None:
+            return json.dumps({"available": False}).encode("utf-8")
+
+        server = self._match_server
+        engine = server.engine
+        state = engine.current_state if engine is not None else None
+        connected_lanes = sorted(
+            {lane for lane in server._display_lanes.values() if lane != "apercu"}
+        )
+        payload = {
+            "available": True,
+            "connected_clients": len(server.clients),
+            "connected_lanes": connected_lanes,
+            "active_mode": server._current_mode_kind,
+            "match_phase": state.phase.value if state is not None else None,
+            "match_finished": state.finished if state is not None else None,
+            "sound_pack": server._sound_pack,
+            "password_configured": bool(server._password),
+        }
+        return json.dumps(payload).encode("utf-8")
+
     def translate_path(self, path: str) -> str:
         if path == "/assets" or path.startswith("/assets/"):
             rel = path[len("/assets") :].lstrip("/")
@@ -74,7 +121,11 @@ class _DualRootHandler(SimpleHTTPRequestHandler):
 
 
 def start_http_server(
-    directory: str, port: int, assets_dir: str | None = None, ws_port: int | None = None
+    directory: str,
+    port: int,
+    assets_dir: str | None = None,
+    ws_port: int | None = None,
+    match_server=None,
 ) -> ThreadingHTTPServer:
     """``assets_dir`` defaults to ``<directory>/assets`` when not given,
     matching the historical single-root behaviour (dev checkout, or a
@@ -85,6 +136,12 @@ def start_http_server(
     fallback, callers should normally pass the real configured value
     (see ``fletchtime.runtime.ServerRuntime``).
 
+    ``match_server``, if given, is exposed read-only via ``/api/status``
+    (see ``_DualRootHandler._build_status_body``) -- ``None`` by default,
+    in which case that endpoint reports ``{"available": false}`` rather
+    than erroring, since not every caller needs/has one to share (e.g.
+    a bare ``start_http_server()`` call in isolation, as some tests do).
+
     Returns the bound (but not yet serving) server instance -- the caller
     is expected to run ``.serve_forever()`` on it (typically in a
     background thread) and can call ``.shutdown()`` from any other thread
@@ -97,5 +154,6 @@ def start_http_server(
         directory=directory,
         assets_dir=resolved_assets_dir,
         ws_port=resolved_ws_port,
+        match_server=match_server,
     )
     return ThreadingHTTPServer(("0.0.0.0", port), handler)

{fletchtime-0.2.4 → fletchtime-0.2.5}/src/fletchtime/server/match_server.py

@@ -420,50 +420,73 @@ class MatchServer:
         # ici puisqu'on mesure un intervalle, pas une heure absolue.
         last_tick = time.monotonic()
         while True:
-            await asyncio.sleep(TICK_INTERVAL)
-            now = time.monotonic()
-            elapsed = now - last_tick
-            last_tick = now
-            events = []
-            async with self._lock:
-                if self.engine is not None:
-                    self.engine.tick(elapsed)
-                    events = self.engine.pop_pending_events()
-                    if events:
-                        state = self.engine.current_state
-                        for event in events:
-                            # countdown_tick exclu volontairement : se
-                            # déclenche une fois par seconde dans les
-                            # dernières secondes de CHAQUE volée --
-                            # noierait le journal sans valeur diagnostique
-                            # ajoutée (le passage à l'orange, lui, est déjà
-                            # journalisé séparément via warning_orange).
-                            if event == "countdown_tick":
-                                continue
-                            logger.info(
-                                "Transition : %s (unité %d, volée %d%s, phase=%s)",
-                                event,
-                                state.unit_number,
-                                state.end_number,
-                                f", {state.current_turn}" if state.current_turn else "",
-                                state.phase.value,
-                            )
-                    # À chaque tick (~5x/seconde), pas seulement
-                    # périodiquement : un instantané périodique trop
-                    # espacé (auparavant toutes les 5s) peut être visible
-                    # par les écrans -- en cas de redémarrage du serveur,
-                    # la reprise se fait alors sur un temps plus ANCIEN
-                    # que ce que l'écran affichait déjà (extrapolé
-                    # localement pendant la coupure, voir display.html et
-                    # docs/architecture.md), provoquant un retour en
-                    # arrière visible du chrono affiché. Écrire un petit
-                    # JSON à chaque tick reste bon marché (fichier local,
-                    # quelques dizaines d'octets) -- réduit la fenêtre de
-                    # péremption à ~200ms, imperceptible.
-                    self._save_snapshot()
-            await self.broadcast_state()
-            if events:
-                await self._broadcast({"type": "events", "events": events})
+            try:
+                await asyncio.sleep(TICK_INTERVAL)
+                now = time.monotonic()
+                elapsed = now - last_tick
+                last_tick = now
+                events = []
+                async with self._lock:
+                    if self.engine is not None:
+                        self.engine.tick(elapsed)
+                        events = self.engine.pop_pending_events()
+                        if events:
+                            state = self.engine.current_state
+                            for event in events:
+                                # countdown_tick exclu volontairement : se
+                                # déclenche une fois par seconde dans les
+                                # dernières secondes de CHAQUE volée --
+                                # noierait le journal sans valeur diagnostique
+                                # ajoutée (le passage à l'orange, lui, est déjà
+                                # journalisé séparément via warning_orange).
+                                if event == "countdown_tick":
+                                    continue
+                                logger.info(
+                                    "Transition : %s (unité %d, volée %d%s, phase=%s)",
+                                    event,
+                                    state.unit_number,
+                                    state.end_number,
+                                    f", {state.current_turn}" if state.current_turn else "",
+                                    state.phase.value,
+                                )
+                        # À chaque tick (~5x/seconde), pas seulement
+                        # périodiquement : un instantané périodique trop
+                        # espacé (auparavant toutes les 5s) peut être visible
+                        # par les écrans -- en cas de redémarrage du serveur,
+                        # la reprise se fait alors sur un temps plus ANCIEN
+                        # que ce que l'écran affichait déjà (extrapolé
+                        # localement pendant la coupure, voir display.html et
+                        # docs/architecture.md), provoquant un retour en
+                        # arrière visible du chrono affiché. Écrire un petit
+                        # JSON à chaque tick reste bon marché (fichier local,
+                        # quelques dizaines d'octets) -- réduit la fenêtre de
+                        # péremption à ~200ms, imperceptible.
+                        self._save_snapshot()
+                await self.broadcast_state()
+                if events:
+                    await self._broadcast({"type": "events", "events": events})
+            except asyncio.CancelledError:
+                # Laisse la vraie annulation (arrêt propre du serveur, voir
+                # ServerRuntime.stop) se propager normalement -- ne doit
+                # surtout pas être avalée par le except Exception ci-dessous
+                # (CancelledError hérite de BaseException depuis Python
+                # 3.8, donc `except Exception` ne l'attraperait de toute
+                # façon pas, mais autant être explicite).
+                raise
+            except Exception:
+                # Ne doit JAMAIS arrêter la boucle silencieusement : sans
+                # ce filet, une exception imprévue ici tuait la boucle de
+                # décompte pour de bon, sans aucune erreur visible nulle
+                # part -- le reste du serveur (connexions, réponse aux
+                # commandes) continuait de fonctionner normalement à côté,
+                # donc rien ne semblait "en panne" du point de vue d'un
+                # client connecté, sinon un chrono figé indéfiniment.
+                # Cause précise jamais identifiée avec certitude (voir
+                # docs/architecture.md) -- ce filet capture la trace
+                # complète pour la prochaine occurrence, et continue au
+                # tick suivant plutôt que de laisser tout le décompte
+                # mourir en silence.
+                logger.exception("Erreur inattendue dans la boucle de décompte")
 
     # -- broadcasting ---------------------------------------------------------
 

{fletchtime-0.2.4 → fletchtime-0.2.5}/src/fletchtime/web/display.html

@@ -91,6 +91,15 @@
 <script>
   const params = new URLSearchParams(location.search);
   const lane = params.get("lane") || "?";
+  // L'aperçu (dans la page de contrôle) ne doit jamais être une source de
+  // son -- c'est un simple coup d'œil visuel pour le responsable du
+  // chronométrage, pas un écran destiné aux archers. Sans ça, ouvrir la
+  // page de contrôle ET un vrai écran d'affichage sur le même PC fait
+  // entendre chaque son deux fois. `mute=1` permet en plus de couper le
+  // son sur n'importe quel autre onglet ouvert en trop sur la même
+  // machine (ex. pour jeter un œil à une autre lane sans dupliquer le
+  // son de l'écran qui joue réellement pour les archers).
+  const soundEnabled = lane !== "apercu" && params.get("mute") !== "1";
   let currentLanguage = localStorage.getItem("fletchtime_lang") || "fr";
   document.getElementById("lane").textContent = t(currentLanguage, "lane") + " " + lane;
 
@@ -301,6 +310,7 @@
   }
 
   function playEventSound(eventName) {
+    if (!soundEnabled) return;
     if (eventName in resolvedSoundExtension) {
       playResolvedSound(eventName, resolvedSoundExtension[eventName]);
     } else {

{fletchtime-0.2.4 → fletchtime-0.2.5/src/fletchtime.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fletchtime
-Version: 0.2.4
+Version: 0.2.5
 Summary: Chronométrage de compétitions d'archerie FFTL (Indoor, Flint) -- serveur + interfaces web incluses
 License: GPL-3.0-or-later
 Requires-Python: >=3.11

{fletchtime-0.2.4 → fletchtime-0.2.5}/src/fletchtime.egg-info/SOURCES.txt

@@ -61,6 +61,7 @@ src/fletchtime/web/control.html
 src/fletchtime/web/display.html
 src/fletchtime/web/i18n.js
 src/fletchtime/web/index.html
+src/fletchtime/web/logo.ico
 src/fletchtime/web/logo.svg
 src/fletchtime/web/manual.html
 src/fletchtime/web/theme.js

{fletchtime-0.2.4 → fletchtime-0.2.5}/src/fletchtime.egg-info/scm_file_list.json

@@ -22,6 +22,7 @@
     "src/fletchtime/web/manual.html",
     "src/fletchtime/web/config.html",
     "src/fletchtime/web/i18n.js",
+    "src/fletchtime/web/logo.ico",
     "src/fletchtime/web/logo.svg",
     "src/fletchtime/web/__init__.py",
     "src/fletchtime/web/screenshots/config.png",

{fletchtime-0.2.4 → fletchtime-0.2.5}/src/fletchtime.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.2.4",
+  "tag": "0.2.5",
   "distance": 0,
-  "node": "g5efc3a10b889b080631cf37c9c761d09919b643a",
+  "node": "ga6e6ad5647b6d656d79af17dd66fa88787867232",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-07-20"

{fletchtime-0.2.4 → fletchtime-0.2.5}/tests/test_config_store.py

@@ -1,6 +1,7 @@
 import tempfile
 import unittest
 from pathlib import Path
+from unittest.mock import patch
 
 from fletchtime.server import config_store
 
@@ -14,16 +15,19 @@ class TestConfigStore(unittest.TestCase):
         self._original_flint = config_store.FLINT_TOML
         self._original_app = config_store.APP_TOML
         self._original_auth = config_store.AUTH_TOML
+        self._original_match_state = config_store.MATCH_STATE_JSON
         config_store.INDOOR_TOML = Path(self._tmpdir.name) / "indoor.toml"
         config_store.FLINT_TOML = Path(self._tmpdir.name) / "flint.toml"
         config_store.APP_TOML = Path(self._tmpdir.name) / "app.toml"
         config_store.AUTH_TOML = Path(self._tmpdir.name) / "auth.toml"
+        config_store.MATCH_STATE_JSON = Path(self._tmpdir.name) / "match_state.json"
 
     def tearDown(self) -> None:
         config_store.INDOOR_TOML = self._original_indoor
         config_store.FLINT_TOML = self._original_flint
         config_store.APP_TOML = self._original_app
         config_store.AUTH_TOML = self._original_auth
+        config_store.MATCH_STATE_JSON = self._original_match_state
         self._tmpdir.cleanup()
 
     def test_missing_file_falls_back_to_dataclass_defaults(self) -> None:
@@ -114,6 +118,44 @@ class TestConfigStore(unittest.TestCase):
         app = config_store.load_app_config()
         self.assertNotIn("bogus_field", app)
 
+    def test_save_match_snapshot_round_trips(self) -> None:
+        config_store.save_match_snapshot({"index": 1, "time_left": 100.0})
+        self.assertEqual(config_store.load_match_snapshot(), {"index": 1, "time_left": 100.0})
+
+    def test_save_match_snapshot_survives_a_transient_windows_sharing_violation(self) -> None:
+        """Sous Windows, remplacer le fichier peut échouer avec une
+        "violation de partage" si un autre processus l'a ouvert au même
+        instant (antivirus, surveillance de fichiers d'un IDE...) --
+        constaté en pratique. Ce verrou est transitoire, donc quelques
+        tentatives suffisent généralement."""
+        original_replace = Path.replace
+        call_count = {"n": 0}
+
+        def flaky_replace(self, target):
+            call_count["n"] += 1
+            if call_count["n"] == 1:
+                raise OSError(32, "verrou transitoire simulé")
+            return original_replace(self, target)
+
+        with patch.object(Path, "replace", flaky_replace):
+            config_store.save_match_snapshot({"index": 2, "time_left": 50.0})
+
+        self.assertEqual(call_count["n"], 2)
+        self.assertEqual(config_store.load_match_snapshot(), {"index": 2, "time_left": 50.0})
+
+    def test_save_match_snapshot_never_raises_even_if_permanently_locked(self) -> None:
+        """Ne doit JAMAIS remonter d'exception : appelé à chaque tick
+        (voir MatchServer.tick_loop), une exception ici perturberait
+        aussi la diffusion de l'état aux écrans pour ce tick, pour une
+        raison qui n'a rien à voir avec eux. Un instantané manqué n'est
+        jamais grave -- le tick suivant, ~200ms plus tard, retente."""
+
+        def always_fails(self, target):
+            raise OSError(32, "verrou permanent simulé")
+
+        with patch.object(Path, "replace", always_fails):
+            config_store.save_match_snapshot({"index": 3, "time_left": 25.0})  # ne doit pas lever
+
 
 if __name__ == "__main__":
     unittest.main()

{fletchtime-0.2.4 → fletchtime-0.2.5}/tests/test_match_server.py

@@ -1241,6 +1241,42 @@ class TestMatchServerLogging(unittest.IsolatedAsyncioTestCase):
         joined = "\n".join(ctx.output)
         self.assertNotIn("countdown_tick", joined)
 
+    async def test_tick_loop_survives_an_unexpected_exception(self) -> None:
+        """Filet de sécurité contre un bug signalé en pratique : le
+        chrono se figeait indéfiniment sans aucune erreur visible, le
+        reste du serveur (connexions, commandes) continuant de
+        fonctionner normalement à côté -- symptôme cohérent avec une
+        exception imprévue tuant silencieusement la boucle. Ce test
+        vérifie qu'une exception injectée dans tick() n'arrête plus la
+        boucle : elle continue au tick suivant, et l'exception est
+        journalisée avec sa trace complète plutôt que d'être avalée."""
+        await self.server.handle_command(json.dumps({"action": "start_indoor"}), self.control)
+
+        original_tick = self.server.engine.tick
+        call_count = {"n": 0}
+
+        def broken_tick(dt):
+            call_count["n"] += 1
+            if call_count["n"] == 2:
+                raise RuntimeError("exception simulée")
+            return original_tick(dt)
+
+        self.server.engine.tick = broken_tick
+
+        with self.assertLogs("fletchtime.server", level="ERROR") as ctx:
+            task = asyncio.ensure_future(self.server.tick_loop())
+            await asyncio.sleep(1.0)
+            task.cancel()
+            try:
+                await task
+            except asyncio.CancelledError:
+                pass
+
+        self.assertGreater(call_count["n"], 2)  # la boucle a continué après l'échec
+        joined = "\n".join(ctx.output)
+        self.assertIn("Erreur inattendue dans la boucle de décompte", joined)
+        self.assertIn("RuntimeError", joined)  # la trace complète est bien journalisée
+
 
 if __name__ == "__main__":
     unittest.main()