fletchtime 0.2.4__tar.gz → 0.2.6__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fletchtime
-Version: 0.2.4
+Version: 0.2.6
 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.6}/config/flint.toml

@@ -20,10 +20,10 @@ standard_orange_warning_time = 20.0
 standard_distances = ["25 yards", "20 pieds", "30 yards", "15 yards", "20 yards", "10 yards"]
 
 # Blason 1 spot (volées impaires)
-standard_target_image_1spot = "assets/targets/flint_35cm_1spot.jpg"
+standard_target_image_1spot = "assets/targets/flint_35cm_1spot.svg"
 
 # Blason 4 spots (volées paires)
-standard_target_image_4spot = "assets/targets/flint_20cm_4spot.jpg"
+standard_target_image_4spot = "assets/targets/flint_20cm_4spot.svg"
 
 # Nombre de flèches du walk-up
 walkup_arrows = 4
@@ -41,7 +41,7 @@ walkup_orange_warning_time = 10.0
 walkup_distances = ["30 yards", "25 yards", "20 yards", "15 yards"]
 
 # Blason du walk-up
-walkup_target_image = "assets/targets/flint_35cm_1spot.jpg"
+walkup_target_image = "assets/targets/flint_35cm_1spot.svg"
 
 # Ordre des relais par défaut
 turn_mode = "ab_then_cd"

{fletchtime-0.2.4 → fletchtime-0.2.6}/config/indoor.toml

@@ -20,10 +20,10 @@ orange_warning_time = 30.0
 distance_label = "20 yards"
 
 # Image du blason recourbe/trad (chemin relatif à web/)
-target_image_recurve = "assets/targets/indoor_recurve.jpg"
+target_image_recurve = "assets/targets/indoor_recurve.svg"
 
 # Image du blason poulies (chemin relatif à web/)
-target_image_compound = "assets/targets/indoor_compound.jpg"
+target_image_compound = "assets/targets/indoor_compound.svg"
 
 # Ordre des relais par défaut : ab_then_cd, cd_then_ab, ab_only, cd_only
 turn_mode = "ab_then_cd"

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

@@ -70,8 +70,8 @@ granularité de l'ordonnanceur est plus grossière que sous Linux). Voir
     "arrow_in_end": 0,
     "total_arrows_in_end": 0,
     "distance_label": "20 yards",
-    "target_image": "assets/targets/indoor_recurve.jpg",
-    "target_image_2": "assets/targets/indoor_compound.jpg",
+    "target_image": "assets/targets/indoor_recurve.svg",
+    "target_image_2": "assets/targets/indoor_compound.svg",
     "finished": false
   },
   "message": null,
@@ -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.6}/docs/roadmap.md

@@ -77,6 +77,88 @@ dépendent d'extensions compilées (Rust/C) peu fiables sur Pydroid 3, voir
 
 ## Backlog — à discuter / non encore programmé dans une étape précise
 
+- ~~**Couleur orange trop marron**~~ -- fait : `#78350f` remplacé par
+  `#b45309` -- plus saturé et plus lumineux, se lit comme un vrai orange
+  plutôt qu'un brun terne, tout en restant cohérent avec la noirceur du
+  rouge/vert déjà en place. Vérifié avec un vrai rendu (Chromium), pas
+  seulement en théorie.
+- ~~**Cibles par défaut en SVG**~~ -- fait : les 4 cibles par défaut
+  (`indoor_recurve`, `indoor_compound`, `flint_35cm_1spot`,
+  `flint_20cm_4spot`) régénérées en SVG plutôt que converties depuis les
+  JPG existants -- proportions et couleurs officielles World Archery (10
+  zones de largeur égale, blanc/noir/bleu/rouge/or), reconstruites
+  proprement plutôt que vectorisées avec perte. Reste net à n'importe
+  quelle taille d'écran, contrairement à un JPG qui peut devenir flou sur
+  un grand affichage. `.svg` ajouté aussi à la détection des bannières
+  (`display.html`), pour la cohérence. Testé avec un vrai rendu de
+  `display.html` : les deux images se chargent et s'affichent
+  correctement.
+
+- ~~**Choix de la lane/muet à l'ouverture d'un écran**~~ -- fait : la page
+  d'accueil permet maintenant de cocher "muet" à côté du champ de lane
+  déjà existant (ex. plusieurs écrans pilotés par le même PC, qui
+  partagent le même haut-parleur -- voir la FAQ du manuel). Même chose
+  dans la fenêtre graphique : le raccourci "Affichage", auparavant figé
+  sur `lane=1`, permet maintenant de choisir la lane et de cocher "muet"
+  avant l'ouverture. Testé avec un vrai navigateur (page d'accueil) et
+  vérifié via la documentation officielle de `customtkinter` (case à
+  cocher, fenêtre).
+
+- ~~**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. **Confirmé résolu en conditions
+  réelles sur Windows** (plus de blocage constaté après ce correctif).
+- ~~**Bouton Quitter hors de la fenêtre**~~ -- fait : la taille de départ
+  de la fenêtre datait d'avant l'ajout de plusieurs sections (ports,
+  statut technique...), devenue trop petite pour tout montrer. Calcule
+  désormais la taille réellement nécessaire à partir du contenu construit
+  (`update_idletasks` + `winfo_reqheight`/`reqwidth`), plutôt qu'un
+  nombre fixe qui redeviendrait insuffisant à la prochaine section
+  ajoutée. **Réserve honnête** : ce motif est standard en Tkinter, mais
+  une source a signalé un comportement parfois différent avec
+  `customtkinter` selon si on l'applique à la fenêtre ou à un cadre
+  interne -- non vérifiable ici (pas d'affichage disponible), à confirmer
+  visuellement.
+- ~~**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. **Confirmé résolu en conditions
+  réelles** (le bon niveau de journal s'affiche bien dans la fenêtre).
+- ~~**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.6}/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.6}/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.6'
+__version_tuple__ = version_tuple = (0, 2, 6)
 
-__commit_id__ = commit_id = 'g5efc3a10b'
+__commit_id__ = commit_id = 'g4502981d1'

{fletchtime-0.2.4 → fletchtime-0.2.6}/src/fletchtime/engine/modes/flint.py

@@ -47,8 +47,8 @@ class FlintConfig:
     )
     # Les volées impaires (1, 3, 5) tirent sur le blason 35cm à 1 spot ; les
     # volées paires (2, 4, 6) sur le blason 20cm à 4 spots.
-    standard_target_image_1spot: str = "assets/targets/flint_35cm_1spot.jpg"
-    standard_target_image_4spot: str = "assets/targets/flint_20cm_4spot.jpg"
+    standard_target_image_1spot: str = "assets/targets/flint_35cm_1spot.svg"
+    standard_target_image_4spot: str = "assets/targets/flint_20cm_4spot.svg"
 
     walkup_arrows: int = 4
     walkup_time_per_arrow: float = 45.0
@@ -63,7 +63,7 @@ class FlintConfig:
         ]
     )
     # La volée 7 (walk-up) suit le même schéma que les volées impaires : 1 spot.
-    walkup_target_image: str = "assets/targets/flint_35cm_1spot.jpg"
+    walkup_target_image: str = "assets/targets/flint_35cm_1spot.svg"
 
     # Comment les archers se relaient sur le parcours : "ab_then_cd",
     # "cd_then_ab" (les deux relais, un après l'autre -- chacun tirant

{fletchtime-0.2.4 → fletchtime-0.2.6}/src/fletchtime/engine/modes/indoor.py

@@ -43,8 +43,8 @@ class IndoorConfig:
     distance_label: str = "20 yards"
     # Deux blasons affichés côte à côte : recourbe/trad à gauche, poulies à
     # droite -- les deux catégories tirent souvent ensemble en Indoor.
-    target_image_recurve: str = "assets/targets/indoor_recurve.jpg"
-    target_image_compound: str = "assets/targets/indoor_compound.jpg"
+    target_image_recurve: str = "assets/targets/indoor_recurve.svg"
+    target_image_compound: str = "assets/targets/indoor_compound.svg"
 
     # Comment les archers se relaient sur un même blason pendant une volée :
     # "ab_then_cd", "cd_then_ab" (les deux relais, dans un ordre ou

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

@@ -24,8 +24,14 @@ 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.parse
+import urllib.request
 import webbrowser
 
 import customtkinter as ctk
@@ -59,11 +65,24 @@ _TRANSLATIONS = {
         "themeLight": "Clair",
         "themeDark": "Sombre",
         "networkCaption": "Ports (HTTP/WS) :",
+        "displayOptionsCaption": "Lane à ouvrir :",
+        "muteLabel": "Muet",
         "apply": "Appliquer",
         "networkErrorNotANumber": "Les ports doivent être des nombres",
         "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",
@@ -82,11 +101,24 @@ _TRANSLATIONS = {
         "themeLight": "Light",
         "themeDark": "Dark",
         "networkCaption": "Ports (HTTP/WS):",
+        "displayOptionsCaption": "Lane to open:",
+        "muteLabel": "Muted",
         "apply": "Apply",
         "networkErrorNotANumber": "Ports must be numbers",
         "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 +241,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,18 +259,47 @@ 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")
+        self.geometry("820x600")  # taille de départ -- corrigée juste après
         self.minsize(640, 480)
         self.protocol("WM_DELETE_WINDOW", self._on_quit)
 
         self._build_ui()
+
+        # La taille de départ ci-dessus datait d'avant l'ajout de plusieurs
+        # sections (ports, statut technique...) -- trop petite pour tout
+        # montrer, le bouton Quitter se retrouvant hors de la fenêtre
+        # visible (constaté en pratique). Plutôt que de deviner un nouveau
+        # nombre fixe qui redeviendrait insuffisant à la prochaine section
+        # ajoutée, calcule la taille réellement nécessaire à partir du
+        # contenu construit juste au-dessus : update_idletasks() force
+        # Tkinter à calculer la taille demandée par chaque widget avant
+        # qu'on ne la lise, sans quoi winfo_reqheight/reqwidth
+        # renverraient une valeur pas encore à jour.
+        self.update_idletasks()
+        required_width = max(820, self.winfo_reqwidth())
+        required_height = max(600, self.winfo_reqheight())
+        self.geometry(f"{required_width}x{required_height}")
+        # Empêche aussi de redescendre en dessous de cette taille par un
+        # redimensionnement manuel -- le bouton Quitter (et tout le reste)
+        # doit rester accessible sans avoir à agrandir la fenêtre.
+        self.minsize(required_width, required_height)
+
         self._poll_log_queue()
+        self._poll_technical_status()
+        self._drain_status_queue()
         self._start_server()
 
     # -- traductions ---------------------------------------------------
@@ -324,10 +386,36 @@ class FletchTimeApp(ctk.CTk):
         self.display_button = ctk.CTkButton(
             links_frame,
             text=self._t("display"),
-            command=lambda: self._open_link("/display.html?lane=1"),
+            command=self._open_display,
         )
         self.display_button.pack(side="left", padx=(0, 12), pady=10, expand=True, fill="x")
 
+        # -- options d'affichage (lane à ouvrir, muet ou non) --------------
+        # Auparavant un simple raccourci vers lane=1 -- rendu configurable
+        # pour pouvoir ouvrir n'importe quelle lane et couper le son sur cet
+        # onglet précis (voir display.html, soundEnabled) directement
+        # depuis la fenêtre, comme c'est déjà possible depuis la page
+        # d'accueil.
+        display_options_frame = ctk.CTkFrame(self)
+        display_options_frame.pack(fill="x", padx=16, pady=(0, 8))
+
+        self.display_options_caption = ctk.CTkLabel(
+            display_options_frame,
+            text=self._t("displayOptionsCaption"),
+            font=ctk.CTkFont(size=11),
+            text_color="gray60",
+        )
+        self.display_options_caption.pack(side="left", padx=(12, 8), pady=8)
+
+        self.lane_entry = ctk.CTkEntry(display_options_frame, width=90, justify="center")
+        self.lane_entry.insert(0, "1")
+        self.lane_entry.pack(side="left", padx=(0, 12), pady=8)
+
+        self.mute_checkbox = ctk.CTkCheckBox(
+            display_options_frame, text=self._t("muteLabel"), width=20
+        )
+        self.mute_checkbox.pack(side="left", padx=(0, 12), pady=8)
+
         # -- adresse du serveur -----------------------------------------
         # CTkEntry (désactivée après affichage) plutôt qu'un simple
         # libellé : l'intention est de permettre de sélectionner/copier
@@ -388,6 +476,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))
@@ -420,6 +522,13 @@ class FletchTimeApp(ctk.CTk):
     def _open_link(self, path: str) -> None:
         webbrowser.open(f"http://127.0.0.1:{self.http_port}{path}")
 
+    def _open_display(self) -> None:
+        lane = self.lane_entry.get().strip() or "1"
+        path = f"/display.html?lane={urllib.parse.quote(lane)}"
+        if self.mute_checkbox.get():
+            path += "&mute=1"
+        self._open_link(path)
+
     def _start_server(self) -> None:
         if self.runtime.is_running:
             return
@@ -463,6 +572,8 @@ class FletchTimeApp(ctk.CTk):
         self.home_button.configure(text=self._t("home"))
         self.control_button.configure(text=self._t("control"))
         self.display_button.configure(text=self._t("display"))
+        self.display_options_caption.configure(text=self._t("displayOptionsCaption"))
+        self.mute_checkbox.configure(text=self._t("muteLabel"))
         self.address_caption.configure(text=self._t("addressCaption"))
         self.log_label.configure(text=self._t("log_title"))
         self.quit_button.configure(text=self._t("quit"))
@@ -557,6 +668,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.6}/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()