fletchtime 0.2.0__tar.gz → 0.2.1__tar.gz

{fletchtime-0.2.0/src/fletchtime.egg-info → fletchtime-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fletchtime
-Version: 0.2.0
+Version: 0.2.1
 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.0 → fletchtime-0.2.1}/docs/architecture.md

@@ -343,6 +343,41 @@ confirmer le rendu et l'ergonomie tactile -- voir aussi le piège
 PyInstaller/`customtkinter` documenté dans {doc}`dev-guide/index`.
 ```
 
+## Journal applicatif persistant
+
+En plus du journal affiché dans la fenêtre graphique (en mémoire,
+perdu à la fermeture -- voir `fletchtime.gui._QueueWriter`),
+`fletchtime.logging_setup.configure_logging` écrit un fichier de journal
+persistant (`<données du club>/logs/fletchtime.log`, avec rotation --
+1 Mo par fichier, 5 fichiers conservés) : utile pour comprendre après
+coup ce qui s'est passé pendant un concours, sans dépendre de la mémoire
+volatile de la fenêtre.
+
+`MatchServer` y journalise :
+- chaque commande reçue (`next`, `stop`, `start_indoor`...), avec la lane
+  d'origine si connue ;
+- chaque connexion/déconnexion, avec le nombre de clients restants ;
+- les pertes de connexion réseau détectées (WiFi, mise en veille...),
+  distinguées d'une fermeture normale ;
+- les messages malformés reçus (JSON invalide) ;
+- les transitions d'état significatives (`prep_start`, `shoot_start`,
+  `warning_orange`, `end_of_volee`, `pause_start`/`pause_end`,
+  `emergency_start`/`emergency_end`, `end_of_match`), avec le contexte
+  (unité, volée, tour, phase) -- qu'elles soient déclenchées naturellement
+  par le décompte ou manuellement (`next`, `goto`...), puisque les deux
+  passent par le même mécanisme de collecte d'événements. `countdown_tick`
+  est volontairement exclu (se déclenche une fois par seconde dans les
+  dernières secondes de chaque volée -- noierait le journal sans valeur
+  diagnostique ajoutée).
+
+```{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
+et la lane, précisément pour éviter qu'un secret ne traîne en clair dans
+un fichier qui persiste sur disque. Vérifié par un test dédié
+(`test_password_never_appears_in_logs`).
+```
+
 ## Récupération après un plantage ou redémarrage du serveur
 
 Avant ce mécanisme, un plantage ou un redémarrage du serveur en plein
@@ -398,15 +433,29 @@ comparable à travers un redémarrage du processus.
 `wallclock_deadline` vaut `None` pendant une pause/urgence (le décompte
 est gelé, aucune échéance à calculer) : `time_left` reste alors la
 valeur figée telle quelle, sans recalcul.
+```
+
+```{important}
+**Si l'échéance est déjà dépassée à la restauration** (le temps
+réellement écoulé pendant l'indisponibilité dépasse ce qui restait sur
+l'étape en cours), le match est marqué **terminé** plutôt que de figer
+`time_left` à 0. Sans ça, le tick normal suivant (`MatchEngine.tick()`,
+voir plus haut) aurait déclenché son rattrapage automatique -- pensé
+pour un simple ralentissement passager du serveur, pas une coupure de
+plusieurs minutes -- et avancé à l'étape suivante avec une durée
+fraîche : le chrono semblait alors "redémarrer" du point de vue des
+archers, alors qu'en réalité bien plus de temps s'était écoulé que ce
+que l'étape en cours pouvait raisonnablement absorber. Une coupure trop
+longue pour être absorbée dans l'étape en cours demande donc une
+intervention explicite du responsable du chronométrage (`restart`/
+`goto`) plutôt qu'une reprise automatique qui devinerait une position
+dans une coupure d'une durée arbitraire.
+```
 
 La sauvegarde à chaque tick (plutôt que périodiquement, ex. toutes les
 5s) garde malgré tout sa valeur avec ce mécanisme : elle limite la
-fenêtre pendant laquelle un **changement d'étape complet** (fin de
-volée, passage à l'orange...) pourrait ne pas être capturé avant un
-plantage -- l'échéance recalculée donne un temps exact pour l'étape
-*enregistrée*, mais ne devine jamais qu'une étape différente aurait dû
-être active entre-temps.
-```
+fenêtre pendant laquelle un changement d'étape aurait pu se produire
+juste avant un plantage sans jamais être capturé dans l'instantané.
 
 ## Fonctionnement dégradé en cas de coupure réseau
 

{fletchtime-0.2.0 → fletchtime-0.2.1}/docs/roadmap.md

@@ -73,27 +73,41 @@ dépendent d'extensions compilées (Rust/C) peu fiables sur Pydroid 3, voir
 
 ## Backlog — à discuter / non encore programmé dans une étape précise
 
+- ~~**Journal applicatif persistant**~~ -- fait : `MatchServer` journalise
+  désormais chaque commande reçue, (dé)connexion, perte de connexion
+  réseau et message malformé dans un fichier avec rotation
+  (`logs/fletchtime.log`), en plus du journal déjà affiché dans la
+  fenêtre (en mémoire, perdu à la fermeture). Voir {doc}`architecture`,
+  section dédiée -- vérifié que le mot de passe ne s'y retrouve jamais.
 - **Fenêtre graphique -- améliorations restant à faire** :
   - Paramétrage du serveur (ports, etc.) et de l'adresse IP exposée sur le
     réseau local, directement depuis la fenêtre plutôt que fichiers de
     config seuls.
-  - Affichage des adresses exposées (accueil/contrôle/affichage) dans la
-    fenêtre elle-même, pas seulement via les boutons de raccourci
-    actuels.
+  - ~~Affichage des adresses exposées~~ -- fait : champ dédié (adresse
+    d'accueil) dans la fenêtre elle-même, en plus des boutons de
+    raccourci -- utile pour retaper l'adresse à la main sur un appareil
+    sans bouton de raccourci. Non vérifié visuellement si le texte reste
+    bien sélectionnable/copiable une fois le champ désactivé (`CTkEntry`
+    n'a pas de vrai état "readonly" contrairement à `ttk.Entry`).
   - Choix du thème clair/sombre dans la fenêtre -- actuellement forcé en
     sombre (`ctk.set_appearance_mode("dark")`), cohérent avec
     `display.html` mais pas ajustable par l'utilisateur comme le sont les
     autres pages web.
-  - Couleur du bouton Quitter à revoir (actuellement neutre/transparent).
-- ~~**Récupération après plantage/redémarrage du serveur**~~ -- fait :
-  `MatchServer` persiste un instantané JSON de l'état du match
-  (`config/match_state.json`, jamais versionné) à chaque commande qui
-  change l'état et périodiquement pendant le décompte, et tente une
+  - ~~Couleur du bouton Quitter à revoir~~ -- fait : couleur pleine
+    (`#3a4354`) au lieu de transparent+contour, visible sans être
+    alarmante (distincte du rouge d'Arrêter et du doré de Démarrer).
+- ~~**Récupération après plantage/redémarrage du serveur**~~ -- fait et
+  **confirmé en conditions réelles avec la v0.2.0** (synchronisation du
+  temps testée, plus de retour en arrière du chrono ; reconnexion
+  vérifiée) : `MatchServer` persiste un instantané JSON de l'état du
+  match (`config/match_state.json`, jamais versionné) à chaque commande
+  qui change l'état et périodiquement pendant le décompte, et tente une
   restauration silencieuse à la construction -- avant ça, un plantage en
   plein match perdait toute la progression (série, volée, temps écoulé).
   Voir {doc}`architecture`, section dédiée, pour le détail complet
-  (écriture atomique, repli silencieux sur un démarrage normal si la
-  reprise échoue).
+  (échéance en horloge murale pour un temps exact quelle que soit la
+  durée de l'indisponibilité, écriture atomique, repli silencieux sur un
+  démarrage normal si la reprise échoue).
 - ~~**Revamping du logo**~~ -- fait : nouveau logo cadran/flèche noir-or-blanc,
   wordmark "FletchTime" bicolore Fletch/Time, cohérent avec le thème clair/sombre.
 - ~~**Sécurisation cyber**~~ -- en partie fait : mot de passe optionnel
@@ -118,20 +132,16 @@ dépendent d'extensions compilées (Rust/C) peu fiables sur Pydroid 3, voir
   confirmée) -- voir le détail de l'investigation dans
   {doc}`dev-guide/index`. Pas de besoin utilisateur macOS avéré à ce jour ;
   à reconsidérer si ça change.
-- **Web app côté client (PWA)** : transformer `control.html`/`display.html`
-  (voire `index.html`) en Progressive Web App -- `manifest.json` + service
-  worker + icônes. Permettrait d'"installer" l'app sur l'écran d'accueil
-  d'une tablette/téléphone (lancement direct, sans retaper l'URL ni passer
-  par le navigateur), et de mettre en cache les fichiers statiques (HTML/CSS/
-  JS/logo) pour un chargement instantané même en cas de WiFi capricieux --
-  le WebSocket, lui, resterait bien sûr en temps réel, seul l'habillage
-  statique serait mis en cache. Chantier indépendant du reste, à ne traiter
-  qu'une fois l'interface stabilisée.
-- **Documentation Sphinx versionnée** : `docs.yml` publie aujourd'hui une
-  seule version de la doc sur GitHub Pages, écrasée à chaque nouveau tag
-  (voir plus bas pourquoi ce n'est plus à chaque push depuis peu) -- pas
-  de moyen de consulter la doc telle qu'elle était pour une release
-  précédente (ex. v0.1.2) si le code a changé depuis. À terme : une doc
-  par tag de version (ex. `/v0.1.2/`, `/v0.1.3/`) en plus d'une version
-  `/latest/`, avec un sélecteur de version dans le thème Furo (voir
-  `sphinx-multiversion` ou équivalent).
+- ~~**Web app côté client (PWA)**~~ -- abandonné délibérément : pas jugé
+  utile pour l'usage réel du club. (Aurait transformé
+  `control.html`/`display.html` en Progressive Web App -- installation
+  sur écran d'accueil, mise en cache des fichiers statiques.)
+- ~~**Documentation Sphinx versionnée**~~ -- abandonné délibérément : les
+  archives `.tar.gz` jointes à chaque Release GitHub suffisent pour
+  consulter la doc d'une version précédente, pas besoin d'un système de
+  versionnage complet côté GitHub Pages.
+- ~~**Termux / lancer FletchTime sur Android sans Pydroid**~~ -- abandonné
+  délibérément pour l'instant : usage réel actuel = téléphone en simple
+  client (accès réseau local), PC pour héberger le serveur. Pas de besoin
+  d'exécuter le serveur lui-même sur Android dans ces conditions. À
+  reconsidérer si l'usage change.

{fletchtime-0.2.0 → fletchtime-0.2.1}/src/fletchtime/__main__.py

@@ -28,6 +28,7 @@ from importlib import resources
 from pathlib import Path
 
 from fletchtime import __version__
+from fletchtime.logging_setup import configure_logging
 from fletchtime.runtime import ServerRuntime
 
 HTTP_PORT = 8000
@@ -152,6 +153,9 @@ def _run_headless() -> None:
     ensure_directories(data_root, app_web_dir)
     assets_dir = data_root / "web" / "assets"
 
+    log_file = configure_logging(data_root / "logs")
+    print(f"Journal détaillé / Detailed log: {log_file}")
+
     _print_banner(local_ip(), data_root)
 
     runtime = ServerRuntime(str(app_web_dir), str(assets_dir), HTTP_PORT, WS_PORT)

{fletchtime-0.2.0 → fletchtime-0.2.1}/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.0'
-__version_tuple__ = version_tuple = (0, 2, 0)
+__version__ = version = '0.2.1'
+__version_tuple__ = version_tuple = (0, 2, 1)
 
-__commit_id__ = commit_id = 'g76ecfc7d6'
+__commit_id__ = commit_id = 'g4c8543661'

{fletchtime-0.2.0 → fletchtime-0.2.1}/src/fletchtime/engine/engine.py

@@ -71,7 +71,28 @@ class MatchEngine:
             # ce cas, le temps reste gelé tel quel.
             deadline = restore.get("wallclock_deadline")
             if deadline is not None:
-                self._time_left = max(0.0, deadline - time.time())
+                remaining = deadline - time.time()
+                if remaining <= 0:
+                    # Le temps réellement écoulé pendant l'indisponibilité
+                    # dépasse ce qui restait sur cette étape -- ne PAS se
+                    # contenter de figer time_left à 0 : le tick normal
+                    # suivant aurait alors déclenché le rattrapage
+                    # automatique de tick() (comportement volontaire et
+                    # préexistant, pensé pour un simple ralentissement
+                    # passager, pas une coupure de plusieurs secondes/
+                    # minutes) et avancé à l'étape suivante avec une durée
+                    # fraîche -- exactement ce qui ressemblait à "le
+                    # chrono repart" du point de vue des archers. Une
+                    # coupure trop longue pour être absorbée dans l'étape
+                    # en cours marque le match terminé : au responsable du
+                    # chronométrage de décider explicitement de la suite
+                    # (restart/goto), plutôt qu'une reprise automatique
+                    # qui devine une position dans une coupure qui a pu
+                    # durer n'importe combien de temps.
+                    self._finished = True
+                    self._time_left = 0.0
+                else:
+                    self._time_left = remaining
             # Pas d'appel à _emit_current_step_event() ici, volontairement :
             # une reprise après crash doit être silencieuse (pas de
             # prep_start/shoot_start rejoué comme si l'étape venait de

{fletchtime-0.2.0 → fletchtime-0.2.1}/src/fletchtime/gui.py

@@ -39,6 +39,7 @@ from fletchtime.__main__ import (
     ensure_directories,
     local_ip,
 )
+from fletchtime.logging_setup import configure_logging
 from fletchtime.runtime import ServerRuntime
 
 _TRANSLATIONS = {
@@ -54,6 +55,7 @@ _TRANSLATIONS = {
         "status_running": "Serveur en cours -- {ip}",
         "log_title": "Journal",
         "club_data": "Données du club :",
+        "addressCaption": "Adresse :",
     },
     "en": {
         "title": "FletchTime -- Server",
@@ -67,6 +69,7 @@ _TRANSLATIONS = {
         "status_running": "Server running -- {ip}",
         "log_title": "Log",
         "club_data": "Club data:",
+        "addressCaption": "Address:",
     },
 }
 
@@ -193,6 +196,14 @@ class FletchTimeApp(ctk.CTk):
         sys.stdout = _QueueWriter(sys.stdout, self.log_queue)
         sys.stderr = _QueueWriter(sys.stderr, self.log_queue)
 
+        # 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")
+
         self.title(self._t("title"))
         self.geometry("820x600")
         self.minsize(640, 480)
@@ -281,6 +292,29 @@ class FletchTimeApp(ctk.CTk):
         )
         self.display_button.pack(side="left", padx=(0, 12), pady=10, expand=True, fill="x")
 
+        # -- 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
+        # l'adresse (utile pour la retaper à la main sur un appareil sans
+        # bouton de raccourci, ex. un téléphone d'archer) -- non vérifié
+        # visuellement si "disabled" préserve la sélection de texte sur
+        # toutes les plateformes ; à confirmer en conditions réelles.
+        address_frame = ctk.CTkFrame(self)
+        address_frame.pack(fill="x", padx=16, pady=(0, 8))
+
+        self.address_caption = ctk.CTkLabel(
+            address_frame,
+            text=self._t("addressCaption"),
+            font=ctk.CTkFont(size=11),
+            text_color="gray60",
+        )
+        self.address_caption.pack(side="left", padx=(12, 8), pady=8)
+
+        self.address_entry = ctk.CTkEntry(
+            address_frame, font=ctk.CTkFont(family="monospace", size=12)
+        )
+        self.address_entry.pack(side="left", padx=(0, 12), pady=8, expand=True, fill="x")
+
         # -- 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))
@@ -303,8 +337,8 @@ class FletchTimeApp(ctk.CTk):
             self,
             text=self._t("quit"),
             command=self._on_quit,
-            fg_color="transparent",
-            border_width=1,
+            fg_color="#3a4354",
+            hover_color="#4a5568",
         )
         self.quit_button.pack(padx=16, pady=(0, 12))
 
@@ -332,6 +366,21 @@ class FletchTimeApp(ctk.CTk):
         else:
             self.status_dot.configure(text_color="gray50")
             self.status_label.configure(text=self._t("status_stopped"))
+        self._refresh_address()
+
+    def _refresh_address(self) -> None:
+        """L'adresse ne dépend pas de si le serveur tourne réellement --
+        affichée dans tous les cas (utile même à l'arrêt, pour préparer
+        la config réseau à l'avance sur un autre appareil)."""
+        address = f"http://{local_ip()}:{HTTP_PORT}/"
+        # CTkEntry ne supporte que "normal"/"disabled" (contrairement à
+        # ttk.Entry, qui a un vrai état "readonly") -- il faut donc la
+        # débloquer temporairement pour la mettre à jour, puis la
+        # reverrouiller aussitôt après.
+        self.address_entry.configure(state="normal")
+        self.address_entry.delete(0, "end")
+        self.address_entry.insert(0, address)
+        self.address_entry.configure(state="disabled")
 
     def _on_language_change(self, value: str) -> None:
         self.language = value.lower()
@@ -341,6 +390,7 @@ 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.address_caption.configure(text=self._t("addressCaption"))
         self.log_label.configure(text=self._t("log_title"))
         self.quit_button.configure(text=self._t("quit"))
         self.footer_label.configure(text=f"{self._t('club_data')} {self.data_root}")

fletchtime-0.2.1/src/fletchtime/logging_setup.py

@@ -0,0 +1,56 @@
+"""Configuration du journal applicatif : fichier persistant avec rotation,
+en plus de la sortie standard (déjà captée par la fenêtre graphique et
+visible dans un terminal, mais perdue à la fermeture de l'appli -- voir
+fletchtime.gui._QueueWriter). Utile pour comprendre après coup ce qui
+s'est passé pendant un concours (quelles commandes reçues, pertes de
+connexion, erreurs...) sans dépendre de cette mémoire volatile.
+"""
+
+from __future__ import annotations
+
+import logging
+import logging.handlers
+from pathlib import Path
+
+LOG_FORMAT = "%(asctime)s %(levelname)-8s %(name)s: %(message)s"
+DATE_FORMAT = "%Y-%m-%d %H:%M:%S"
+
+# 1 Mo par fichier, 5 fichiers conservés (dont le courant) -- quelques
+# concours de suite avant qu'un fichier ne soit écrasé, sans grossir
+# indéfiniment sur un usage au long cours.
+MAX_BYTES = 1_000_000
+BACKUP_COUNT = 5
+
+
+def configure_logging(log_dir: Path) -> Path:
+    """Idempotent -- rappelable sans dupliquer les handlers si déjà
+    configuré (utile si un test ou un rechargement appelle ceci plusieurs
+    fois dans le même processus). Retourne le chemin du fichier de
+    journal, pour affichage à l'utilisateur si besoin."""
+    log_dir.mkdir(parents=True, exist_ok=True)
+    log_file = log_dir / "fletchtime.log"
+
+    logger = logging.getLogger("fletchtime")
+    logger.setLevel(logging.INFO)
+
+    already_has_file_handler = any(
+        isinstance(h, logging.handlers.RotatingFileHandler) for h in logger.handlers
+    )
+    if not already_has_file_handler:
+        formatter = logging.Formatter(LOG_FORMAT, datefmt=DATE_FORMAT)
+
+        file_handler = logging.handlers.RotatingFileHandler(
+            log_file, maxBytes=MAX_BYTES, backupCount=BACKUP_COUNT, encoding="utf-8"
+        )
+        file_handler.setFormatter(formatter)
+        logger.addHandler(file_handler)
+
+        # La sortie standard (stdout) est déjà affichée dans un terminal ou
+        # captée par la fenêtre graphique (voir fletchtime.gui) -- ce
+        # handler-ci fait en sorte que les logs applicatifs y apparaissent
+        # aussi, avec les mêmes horodatages/niveaux que dans le fichier.
+        stream_handler = logging.StreamHandler()
+        stream_handler.setFormatter(formatter)
+        logger.addHandler(stream_handler)
+
+    return log_file

{fletchtime-0.2.0 → fletchtime-0.2.1}/src/fletchtime/server/match_server.py

@@ -11,6 +11,7 @@ from __future__ import annotations
 
 import asyncio
 import json
+import logging
 import time
 from dataclasses import asdict, replace
 
@@ -25,6 +26,8 @@ from . import config_store
 
 TICK_INTERVAL = 0.2  # seconds between engine ticks / broadcasts
 
+logger = logging.getLogger("fletchtime.server")
+
 # Actions qui changent l'état du match ou son affichage -- protégées par mot
 # de passe si un mot de passe est configuré (voir _auth_required). Tout le
 # reste (get_config, register_display, authenticate) reste toujours
@@ -110,12 +113,19 @@ class MatchServer:
 
     async def register(self, websocket) -> None:
         self.clients.add(websocket)
+        logger.info("Connexion établie (total: %d client(s))", len(self.clients))
         await self._send_state_to(websocket)
 
     async def unregister(self, websocket) -> None:
+        lane = self._display_lanes.get(websocket)
         self.clients.discard(websocket)
         self._display_lanes.pop(websocket, None)
         self._authenticated_connections.discard(websocket)
+        logger.info(
+            "Connexion perdue%s (total: %d client(s) restant(s))",
+            f" (lane={lane})" if lane else "",
+            len(self.clients),
+        )
 
     # -- authentication -------------------------------------------------------
 
@@ -148,9 +158,17 @@ class MatchServer:
         try:
             data = json.loads(raw_message)
         except json.JSONDecodeError:
+            logger.warning("Message reçu invalide (pas du JSON) : %r", raw_message[:200])
             return
         action = data.get("action")
 
+        # Ne jamais journaliser `data` tel quel : l'action "authenticate"
+        # transporte le mot de passe en clair, qui n'a rien à faire dans un
+        # fichier de log. Le nom de l'action et la lane (si connue) suffisent
+        # amplement pour comprendre après coup ce qui s'est passé.
+        lane = self._display_lanes.get(websocket)
+        logger.info("Commande reçue : %s%s", action, f" (lane={lane})" if lane else "")
+
         if action == "authenticate":
             await self._handle_authenticate(data, websocket)
             return
@@ -411,6 +429,25 @@ class MatchServer:
                 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

{fletchtime-0.2.0 → fletchtime-0.2.1}/src/fletchtime/server/ws_server.py

@@ -9,9 +9,12 @@ pages) is served separately by ``fletchtime.server.http_static``.
 from __future__ import annotations
 
 import asyncio
+import logging
 
 from .match_server import MatchServer
 
+logger = logging.getLogger("fletchtime.server")
+
 
 async def run_ws_server(
     port: int,
@@ -38,8 +41,11 @@ async def run_ws_server(
             # Expected when a phone/tablet screen locks or the browser tab
             # is backgrounded: Android suspends network activity, the
             # client stops answering keepalive pings, and the connection
-            # times out. Not an error condition worth a traceback.
-            pass
+            # times out. Not an error condition worth a traceback, mais
+            # utile à journaliser : distingue une perte de connexion réseau
+            # abrupte d'une fermeture normale (onglet fermé proprement),
+            # voir aussi le journal générique de MatchServer.unregister.
+            logger.warning("Perte de connexion réseau détectée (WiFi, veille...)")
         finally:
             await server_state.unregister(websocket)
 

{fletchtime-0.2.0 → fletchtime-0.2.1/src/fletchtime.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fletchtime
-Version: 0.2.0
+Version: 0.2.1
 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.0 → fletchtime-0.2.1}/src/fletchtime.egg-info/SOURCES.txt

@@ -28,6 +28,7 @@ src/fletchtime/__init__.py
 src/fletchtime/__main__.py
 src/fletchtime/_version.py
 src/fletchtime/gui.py
+src/fletchtime/logging_setup.py
 src/fletchtime/runtime.py
 src/fletchtime.egg-info/PKG-INFO
 src/fletchtime.egg-info/SOURCES.txt

{fletchtime-0.2.0 → fletchtime-0.2.1}/src/fletchtime.egg-info/scm_file_list.json

@@ -12,6 +12,7 @@
     "src/fletchtime/gui.py",
     "src/fletchtime/__main__.py",
     "src/fletchtime/runtime.py",
+    "src/fletchtime/logging_setup.py",
     "src/fletchtime/__init__.py",
     "src/fletchtime/web/index.html",
     "src/fletchtime/web/control.html",

{fletchtime-0.2.0 → fletchtime-0.2.1}/src/fletchtime.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.2.0",
+  "tag": "0.2.1",
   "distance": 0,
-  "node": "g76ecfc7d6ca946855ae5248f47e40b8d96ed50f0",
+  "node": "g4c854366173a38e914c10115cdfde6cc1c085eab",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-07-19"

{fletchtime-0.2.0 → fletchtime-0.2.1}/tests/test_engine.py

@@ -675,7 +675,15 @@ class TestMatchEngineSnapshotRestore(unittest.TestCase):
             engine2 = MatchEngine(IndoorMode(self._cfg()), restore=snapshot)
             self.assertEqual(engine2.current_state.time_left, 240.0)  # inchangé
 
-    def test_restore_clamps_to_zero_after_a_very_long_outage(self) -> None:
+    def test_restore_marks_match_finished_after_an_outage_longer_than_time_left(self) -> None:
+        """Une coupure plus longue que ce qui restait sur l'étape en cours
+        marque le match terminé, plutôt que de figer time_left à 0 --
+        sans ça, le tick normal suivant aurait déclenché le rattrapage
+        automatique de tick() (pensé pour un simple ralentissement
+        passager, pas une coupure de plusieurs minutes) et fait
+        redémarrer le chrono sur l'étape suivante avec une durée fraîche,
+        ce qui ressemblait exactement à "le chrono repart" du point de
+        vue des archers."""
         from unittest.mock import patch
 
         with patch("fletchtime.engine.engine.time.time", return_value=2000.0):
@@ -688,7 +696,12 @@ class TestMatchEngineSnapshotRestore(unittest.TestCase):
         # 500 vraies secondes plus tard -- largement au-delà des 220s restantes
         with patch("fletchtime.engine.engine.time.time", return_value=2500.0):
             engine2 = MatchEngine(IndoorMode(self._cfg()), restore=snapshot)
-            self.assertEqual(engine2.current_state.time_left, 0.0)  # jamais négatif
+            self.assertTrue(engine2.current_state.finished)
+            self.assertEqual(engine2.current_state.time_left, 0.0)
+            # Un tick normal supplémentaire ne doit rien faire avancer :
+            # un match terminé reste terminé, pas de redémarrage du chrono.
+            engine2.tick(0.2)
+            self.assertTrue(engine2.current_state.finished)
 
 
 if __name__ == "__main__":

{fletchtime-0.2.0 → fletchtime-0.2.1}/tests/test_match_server.py

@@ -1111,5 +1111,121 @@ class TestMatchServerCrashRecovery(unittest.IsolatedAsyncioTestCase):
         self.assertIsNone(server.engine)
 
 
+class TestMatchServerLogging(unittest.IsolatedAsyncioTestCase):
+    """Couvre le journal applicatif (voir fletchtime.logging_setup) --
+    commandes reçues, (dé)connexions, et surtout l'absence de fuite du
+    mot de passe dans les journaux."""
+
+    async def asyncSetUp(self) -> None:
+        # Efface tout instantané laissé par un test précédent -- voir
+        # setUpModule/tearDownModule plus haut, qui isole déjà le chemin
+        # lui-même, mais pas son contenu entre deux tests de ce fichier.
+        config_store.clear_match_snapshot()
+        # Isole aussi INDOOR_TOML/FLINT_TOML/APP_TOML -- un des tests de
+        # cette classe appelle une vraie sauvegarde de config (mode
+        # indoor, shoot_time=10.0) : sans cette isolation, cet appel
+        # écrivait directement dans le vrai config/indoor.toml du projet
+        # à chaque exécution de la suite de tests (bug réel constaté,
+        # pas hypothétique -- voir l'historique de ce fichier).
+        self._tmpdir = tempfile.TemporaryDirectory()
+        self._original_indoor = config_store.INDOOR_TOML
+        self._original_flint = config_store.FLINT_TOML
+        self._original_app = config_store.APP_TOML
+        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"
+
+        self.server = MatchServer()
+        self.control = FakeWebSocket()
+
+    async def asyncTearDown(self) -> None:
+        config_store.clear_match_snapshot()
+        config_store.INDOOR_TOML = self._original_indoor
+        config_store.FLINT_TOML = self._original_flint
+        config_store.APP_TOML = self._original_app
+        self._tmpdir.cleanup()
+        config_store.clear_match_snapshot()
+
+    async def test_received_command_is_logged(self) -> None:
+        with self.assertLogs("fletchtime.server", level="INFO") as ctx:
+            await self.server.handle_command(json.dumps({"action": "start_indoor"}), self.control)
+        self.assertTrue(any("start_indoor" in line for line in ctx.output))
+
+    async def test_connect_and_disconnect_are_logged(self) -> None:
+        with self.assertLogs("fletchtime.server", level="INFO") as ctx:
+            await self.server.register(self.control)
+            await self.server.unregister(self.control)
+        joined = "\n".join(ctx.output)
+        self.assertIn("établie", joined)
+        self.assertIn("perdue", joined)
+
+    async def test_invalid_json_message_is_logged_as_warning(self) -> None:
+        with self.assertLogs("fletchtime.server", level="WARNING") as ctx:
+            await self.server.handle_command("pas du json {{{", self.control)
+        self.assertTrue(any("invalide" in line for line in ctx.output))
+
+    async def test_password_never_appears_in_logs(self) -> None:
+        """Test de sécurité : l'action authenticate transporte le mot de
+        passe en clair -- il ne doit jamais se retrouver dans un message
+        de journal, où il traînerait en clair dans un fichier persistant."""
+        secret = "SUPER_SECRET_PASSWORD_xyz789"
+        with self.assertLogs("fletchtime.server", level="INFO") as ctx:
+            await self.server.handle_command(
+                json.dumps({"action": "authenticate", "password": secret}), self.control
+            )
+        joined = "\n".join(ctx.output)
+        self.assertNotIn(secret, joined)
+
+    async def test_state_transition_is_logged_with_context(self) -> None:
+        await self.server.handle_command(json.dumps({"action": "start_indoor"}), self.control)
+        self.server.engine.tick(10)  # RED -> GREEN
+        self.server.engine.pop_pending_events()
+
+        with self.assertLogs("fletchtime.server", level="INFO") as ctx:
+            await self.server.handle_command(json.dumps({"action": "next"}), self.control)
+            task = asyncio.ensure_future(self.server.tick_loop())
+            await asyncio.sleep(0.3)
+            task.cancel()
+            try:
+                await task
+            except asyncio.CancelledError:
+                pass
+
+        joined = "\n".join(ctx.output)
+        self.assertIn("Transition", joined)
+        self.assertIn("prep_start", joined)
+
+    async def test_countdown_tick_is_never_logged(self) -> None:
+        """countdown_tick se déclenche une fois par seconde dans les
+        dernières secondes de chaque volée -- noierait le journal sans
+        valeur diagnostique ajoutée (contrairement à warning_orange, qui
+        lui doit apparaître)."""
+        await self.server.handle_command(
+            json.dumps(
+                {
+                    "action": "save_config",
+                    "mode": "indoor",
+                    "values": {"shoot_time": 10.0, "orange_warning_time": 3.0},
+                }
+            )
+        )
+        await self.server.handle_command(json.dumps({"action": "start_indoor"}), self.control)
+        self.server.engine.tick(10)  # RED -> GREEN(10s)
+        self.server.engine.pop_pending_events()
+        self.server.engine.tick(7.5)  # 2.5s restantes -- franchit orange et des ticks
+
+        with self.assertLogs("fletchtime.server", level="INFO") as ctx:
+            task = asyncio.ensure_future(self.server.tick_loop())
+            await asyncio.sleep(0.3)
+            task.cancel()
+            try:
+                await task
+            except asyncio.CancelledError:
+                pass
+
+        joined = "\n".join(ctx.output)
+        self.assertNotIn("countdown_tick", joined)
+
+
 if __name__ == "__main__":
     unittest.main()