fletchtime 0.2.1__tar.gz → 0.2.2__tar.gz

{fletchtime-0.2.1 → fletchtime-0.2.2}/.gitignore

@@ -27,6 +27,10 @@ docs/_build/
 # vrai secret et ne doit jamais être versionné.
 config/auth.toml
 
+# Préférences de la fenêtre graphique (thème...) -- propres à la machine/
+# personne qui lance la fenêtre, pas un réglage de club à partager.
+config/gui.toml
+
 # Instantané du match en cours (récupération après crash) -- propre à une
 # session de match en cours, pas un réglage du club à partager/versionner.
 config/match_state.json

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fletchtime
-Version: 0.2.1
+Version: 0.2.2
 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
@@ -21,6 +21,11 @@ Dynamic: license-file
 
 <img src="https://mrfanghodev.github.io/fletchtime/_static/logo.svg" width="80" height="80" alt="FletchTime logo">
 
+[![Python](https://img.shields.io/badge/python-version-from-pep-621-toml?tomlFilePath=https%3A%2F%2Fraw.githubusercontent.com%2FMrFanghoDev%2Ffletchtime%2Fmaster%2Fpyproject.toml)](pyproject.toml)
+[![Licence](https://img.shields.io/github/license/MrFanghoDev/fletchtime)](LICENSE)
+[![Tests](https://github.com/MrFanghoDev/fletchtime/actions/workflows/test.yml/badge.svg?branch=master)](https://github.com/MrFanghoDev/fletchtime/actions/workflows/test.yml)
+[![PyPI](https://img.shields.io/pypi/v/fletchtime)](https://pypi.org/project/fletchtime/)
+
 # FletchTime
 
 Logiciel open source de gestion du temps pour compétitions d'archerie FFTL
@@ -122,6 +127,29 @@ from fletchtime.engine import IndoorMode, IndoorConfig, MatchEngine
 engine = MatchEngine(IndoorMode(IndoorConfig()))
 ```
 
+## Plusieurs salles de compétition sur un même PC
+
+Chaque installation de FletchTime (dossier `pip install`, ou dossier de
+l'exécutable autoporteur) fait tourner **une seule salle** -- son propre
+match, sa propre urgence, sa propre config. Pour plusieurs salles en
+parallèle sur le même PC :
+
+1. **Copie le dossier FletchTime une fois par salle** (ex. `salle-A/`,
+   `salle-B/`) -- ça isole automatiquement `config/` (temps de tir,
+   urgence...), les journaux, et l'instantané de récupération après
+   plantage : chaque copie a sa propre urgence, indépendante des autres.
+2. Dans la fenêtre de chaque copie, section **Ports (HTTP/WS)** : donne
+   des ports différents à chaque salle (ex. salle A garde `8000`/`8765`
+   par défaut, salle B passe à `8001`/`8766`) -- **Appliquer** redémarre
+   le serveur automatiquement si besoin.
+3. Lance chaque copie séparément. Les écrans de chaque salle se
+   connectent à l'adresse (IP + port) affichée dans la fenêtre de leur
+   salle respective.
+
+**Windows** : le pare-feu autorise généralement par chemin d'exécutable --
+avec des copies de dossier séparées, prévoir de valider l'alerte une fois
+par copie au premier lancement.
+
 ## Contribuer
 
 Envie de proposer un correctif, une idée, ou juste signaler un bug ? Voir

{fletchtime-0.2.1 → fletchtime-0.2.2}/README.md

@@ -1,5 +1,10 @@
 <img src="https://mrfanghodev.github.io/fletchtime/_static/logo.svg" width="80" height="80" alt="FletchTime logo">
 
+[![Python](https://img.shields.io/badge/python-version-from-pep-621-toml?tomlFilePath=https%3A%2F%2Fraw.githubusercontent.com%2FMrFanghoDev%2Ffletchtime%2Fmaster%2Fpyproject.toml)](pyproject.toml)
+[![Licence](https://img.shields.io/github/license/MrFanghoDev/fletchtime)](LICENSE)
+[![Tests](https://github.com/MrFanghoDev/fletchtime/actions/workflows/test.yml/badge.svg?branch=master)](https://github.com/MrFanghoDev/fletchtime/actions/workflows/test.yml)
+[![PyPI](https://img.shields.io/pypi/v/fletchtime)](https://pypi.org/project/fletchtime/)
+
 # FletchTime
 
 Logiciel open source de gestion du temps pour compétitions d'archerie FFTL
@@ -101,6 +106,29 @@ from fletchtime.engine import IndoorMode, IndoorConfig, MatchEngine
 engine = MatchEngine(IndoorMode(IndoorConfig()))
 ```
 
+## Plusieurs salles de compétition sur un même PC
+
+Chaque installation de FletchTime (dossier `pip install`, ou dossier de
+l'exécutable autoporteur) fait tourner **une seule salle** -- son propre
+match, sa propre urgence, sa propre config. Pour plusieurs salles en
+parallèle sur le même PC :
+
+1. **Copie le dossier FletchTime une fois par salle** (ex. `salle-A/`,
+   `salle-B/`) -- ça isole automatiquement `config/` (temps de tir,
+   urgence...), les journaux, et l'instantané de récupération après
+   plantage : chaque copie a sa propre urgence, indépendante des autres.
+2. Dans la fenêtre de chaque copie, section **Ports (HTTP/WS)** : donne
+   des ports différents à chaque salle (ex. salle A garde `8000`/`8765`
+   par défaut, salle B passe à `8001`/`8766`) -- **Appliquer** redémarre
+   le serveur automatiquement si besoin.
+3. Lance chaque copie séparément. Les écrans de chaque salle se
+   connectent à l'adresse (IP + port) affichée dans la fenêtre de leur
+   salle respective.
+
+**Windows** : le pare-feu autorise généralement par chemin d'exécutable --
+avec des copies de dossier séparées, prévoir de valider l'alerte une fois
+par copie au premier lancement.
+
 ## Contribuer
 
 Envie de proposer un correctif, une idée, ou juste signaler un bug ? Voir

{fletchtime-0.2.1 → fletchtime-0.2.2}/docs/index.md

@@ -1,3 +1,14 @@
+```{image} _static/logo.svg
+:alt: FletchTime
+:width: 140px
+:align: center
+```
+
+[![Python](https://img.shields.io/badge/python-version-from-pep-621-toml?tomlFilePath=https%3A%2F%2Fraw.githubusercontent.com%2FMrFanghoDev%2Ffletchtime%2Fmaster%2Fpyproject.toml)](https://github.com/MrFanghoDev/fletchtime/blob/master/pyproject.toml)
+[![Licence](https://img.shields.io/github/license/MrFanghoDev/fletchtime)](https://github.com/MrFanghoDev/fletchtime/blob/master/LICENSE)
+[![Tests](https://github.com/MrFanghoDev/fletchtime/actions/workflows/test.yml/badge.svg?branch=master)](https://github.com/MrFanghoDev/fletchtime/actions/workflows/test.yml)
+[![PyPI](https://img.shields.io/pypi/v/fletchtime)](https://pypi.org/project/fletchtime/)
+
 # FletchTime
 
 Logiciel de gestion du temps pour compétitions d'archerie FFTL (Indoor et Flint),

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

@@ -79,20 +79,29 @@ dépendent d'extensions compilées (Rust/C) peu fiables sur Pydroid 3, voir
   (`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.
+- ~~**Fenêtre graphique -- améliorations**~~ -- toutes faites (paramétrage
+  réseau, affichage des adresses, thème, couleur du bouton Quitter) :
+  - ~~Paramétrage du serveur et de l'adresse IP exposée~~ -- fait :
+    ports HTTP/WebSocket modifiables directement dans la fenêtre
+    (`config/gui.toml`), avec redémarrage automatique du serveur si les
+    ports changent pendant qu'il tourne. Objectif principal : plusieurs
+    salles de compétition sur un même PC -- copier le dossier FletchTime
+    une fois par salle (isole aussi `config/`, `logs/`, l'instantané de
+    récupération, donc des urgences bien séparées), donner des ports
+    différents à chaque copie, lancer chacune séparément. Testé
+    concrètement : deux instances simultanées sur le même processus,
+    ports différents, contenu totalement isolé entre les deux.
   - ~~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.
+  - ~~Choix du thème clair/sombre dans la fenêtre~~ -- fait : sélecteur
+    Système/Clair/Sombre dans l'en-tête, préférence persistée dans
+    `config/gui.toml` (jamais versionné, propre à la machine -- voir
+    `.gitignore`). Indépendant de `display.html`, qui reste lui, par
+    choix délibéré, toujours sombre.
   - ~~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).

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

@@ -30,9 +30,15 @@ from pathlib import Path
 from fletchtime import __version__
 from fletchtime.logging_setup import configure_logging
 from fletchtime.runtime import ServerRuntime
+from fletchtime.server import config_store
 
-HTTP_PORT = 8000
-WS_PORT = 8765
+# Anciennement des constantes HTTP_PORT/WS_PORT figées ici -- les ports
+# par défaut vivent maintenant uniquement dans
+# config_store.DEFAULT_GUI_CONFIG, seule source de vérité (voir
+# _run_headless ci-dessous et fletchtime.gui, qui lisent tous deux
+# config_store.load_gui_config() plutôt qu'une constante figée). Permet
+# de faire tourner plusieurs salles de compétition sur un même PC : une
+# copie de dossier par salle, chacune avec son propre config/gui.toml.
 
 # Dossiers pré-remplis avec un contenu par défaut fourni avec FletchTime
 # (copié une seule fois, au tout premier lancement -- jamais écrasé
@@ -113,14 +119,14 @@ def local_ip() -> str:
         s.close()
 
 
-def _print_banner(ip: str, data_root: Path) -> None:
+def _print_banner(ip: str, data_root: Path, http_port: int) -> None:
     print("=" * 60)
     print(f"  FletchTime {__version__} -- serveur de contrôle et d'affichage")
     print(f"  FletchTime {__version__} -- control and display server")
     print("=" * 60)
-    print(f"  Accueil / Home      : http://{ip}:{HTTP_PORT}/")
-    print(f"  Contrôle / Control  : http://{ip}:{HTTP_PORT}/control.html")
-    print(f"  Affichage / Display : http://{ip}:{HTTP_PORT}/display.html?lane=1")
+    print(f"  Accueil / Home      : http://{ip}:{http_port}/")
+    print(f"  Contrôle / Control  : http://{ip}:{http_port}/control.html")
+    print(f"  Affichage / Display : http://{ip}:{http_port}/display.html?lane=1")
     print()
     print("  Depuis CET appareil, remplace l'IP par 127.0.0.1 si besoin.")
     print("  From THIS device, replace the IP with 127.0.0.1 if needed.")
@@ -156,9 +162,19 @@ def _run_headless() -> None:
     log_file = configure_logging(data_root / "logs")
     print(f"Journal détaillé / Detailed log: {log_file}")
 
-    _print_banner(local_ip(), data_root)
+    # Ports lus depuis config/gui.toml (mêmes préférences que la fenêtre
+    # graphique, voir config_store.load_gui_config) -- permet de faire
+    # tourner plusieurs salles de compétition sur le même PC : une copie
+    # de dossier par salle, chacune avec son propre gui.toml donnant des
+    # ports différents. "gui.toml" malgré le nom concerne aussi ce mode
+    # terminal, pour que les deux se comportent de façon cohérente.
+    gui_config = config_store.load_gui_config()
+    http_port = gui_config["http_port"]
+    ws_port = gui_config["ws_port"]
 
-    runtime = ServerRuntime(str(app_web_dir), str(assets_dir), HTTP_PORT, WS_PORT)
+    _print_banner(local_ip(), data_root, http_port)
+
+    runtime = ServerRuntime(str(app_web_dir), str(assets_dir), http_port, ws_port)
     runtime.start()
 
     stop_event = threading.Event()

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

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

@@ -32,8 +32,6 @@ import customtkinter as ctk
 
 from fletchtime import __version__
 from fletchtime.__main__ import (
-    HTTP_PORT,
-    WS_PORT,
     _app_web_dir,
     _data_root,
     ensure_directories,
@@ -41,6 +39,7 @@ from fletchtime.__main__ import (
 )
 from fletchtime.logging_setup import configure_logging
 from fletchtime.runtime import ServerRuntime
+from fletchtime.server import config_store
 
 _TRANSLATIONS = {
     "fr": {
@@ -56,6 +55,15 @@ _TRANSLATIONS = {
         "log_title": "Journal",
         "club_data": "Données du club :",
         "addressCaption": "Adresse :",
+        "themeSystem": "Système",
+        "themeLight": "Clair",
+        "themeDark": "Sombre",
+        "networkCaption": "Ports (HTTP/WS) :",
+        "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é",
     },
     "en": {
         "title": "FletchTime -- Server",
@@ -70,6 +78,15 @@ _TRANSLATIONS = {
         "log_title": "Log",
         "club_data": "Club data:",
         "addressCaption": "Address:",
+        "themeSystem": "System",
+        "themeLight": "Light",
+        "themeDark": "Dark",
+        "networkCaption": "Ports (HTTP/WS):",
+        "apply": "Apply",
+        "networkErrorNotANumber": "Ports must be numbers",
+        "networkErrorRange": "Ports must be between 1 and 65535",
+        "networkErrorSame": "Both ports must be different",
+        "networkApplied": "Applied",
     },
 }
 
@@ -160,10 +177,7 @@ class FletchTimeApp(ctk.CTk):
         # Doit être fait AVANT super().__init__() : customtkinter applique
         # le thème au moment de la construction de chaque widget, fenêtre
         # racine comprise -- appelé après, la fenêtre elle-même garderait
-        # le thème par défaut. Mode sombre forcé (pas "system") : reprend
-        # la même palette que les pages web en thème sombre, cohérent
-        # avec display.html qui reste lui aussi toujours sombre par choix
-        # délibéré (voir docs/architecture.md).
+        # le thème par défaut.
         #
         # Part d'un thème intégré à customtkinter ("dark-blue" -- garanti
         # complet pour la version installée) plutôt qu'un JSON entièrement
@@ -174,7 +188,20 @@ class FletchTimeApp(ctk.CTk):
         # les couleurs sont ensuite surchargées (voir _apply_brand_colors),
         # tout le reste (rayons, épaisseurs de bordure...) reste celui,
         # déjà testé, du thème intégré.
-        ctk.set_appearance_mode("dark")
+        #
+        # Thème choisi par la personne qui lance la fenêtre (voir
+        # config/gui.toml, config_store.load_gui_config) -- "system" par
+        # défaut, qui suit le thème du système d'exploitation (sauf sous
+        # Linux, limitation connue de customtkinter -- retombe sur
+        # "light"). Indépendant de display.html, qui reste lui, par choix
+        # délibéré, toujours sombre (voir docs/architecture.md) : l'écran
+        # vu par les archers et la fenêtre de contrôle du responsable du
+        # chronométrage sont deux préoccupations distinctes.
+        gui_config = config_store.load_gui_config()
+        self.theme = gui_config["theme"]
+        self.http_port = gui_config["http_port"]
+        self.ws_port = gui_config["ws_port"]
+        ctk.set_appearance_mode(self.theme)
         ctk.set_default_color_theme("dark-blue")
         _apply_brand_colors()
 
@@ -188,7 +215,7 @@ class FletchTimeApp(ctk.CTk):
         ensure_directories(self.data_root, self.app_web_dir)
         self.assets_dir = self.data_root / "web" / "assets"
         self.runtime = ServerRuntime(
-            str(self.app_web_dir), str(self.assets_dir), HTTP_PORT, WS_PORT
+            str(self.app_web_dir), str(self.assets_dir), self.http_port, self.ws_port
         )
 
         # Capte le journal d'accès HTTP (http.server écrit sur stderr) et
@@ -236,6 +263,15 @@ class FletchTimeApp(ctk.CTk):
             text_color="gray60",
         ).pack(side="left", padx=(0, 16), pady=12)
 
+        self.theme_menu = ctk.CTkOptionMenu(
+            header,
+            values=[self._t("themeSystem"), self._t("themeLight"), self._t("themeDark")],
+            width=110,
+            command=self._on_theme_change,
+        )
+        self.theme_menu.set(self._theme_label(self.theme))
+        self.theme_menu.pack(side="right", padx=(0, 8), pady=12)
+
         self.lang_menu = ctk.CTkOptionMenu(
             header, values=["FR", "EN"], width=70, command=self._on_language_change
         )
@@ -315,6 +351,43 @@ class FletchTimeApp(ctk.CTk):
         )
         self.address_entry.pack(side="left", padx=(0, 12), pady=8, expand=True, fill="x")
 
+        # -- réseau (ports) -----------------------------------------------
+        # Ports modifiables plutôt que figés : permet de faire tourner
+        # plusieurs salles de compétition sur le même PC -- une copie de
+        # dossier par salle, chacune avec des ports différents (voir
+        # config/gui.toml, config_store). Changer un port ici redémarre le
+        # serveur automatiquement s'il tournait déjà, pour que le
+        # changement prenne effet immédiatement (voir _on_apply_network).
+        network_frame = ctk.CTkFrame(self)
+        network_frame.pack(fill="x", padx=16, pady=(0, 8))
+
+        self.network_caption = ctk.CTkLabel(
+            network_frame,
+            text=self._t("networkCaption"),
+            font=ctk.CTkFont(size=11),
+            text_color="gray60",
+        )
+        self.network_caption.pack(side="left", padx=(12, 8), pady=8)
+
+        self.http_port_entry = ctk.CTkEntry(network_frame, width=70, justify="center")
+        self.http_port_entry.insert(0, str(self.http_port))
+        self.http_port_entry.pack(side="left", padx=(0, 4), pady=8)
+
+        self.network_separator = ctk.CTkLabel(network_frame, text="/", text_color="gray60")
+        self.network_separator.pack(side="left", padx=2, pady=8)
+
+        self.ws_port_entry = ctk.CTkEntry(network_frame, width=70, justify="center")
+        self.ws_port_entry.insert(0, str(self.ws_port))
+        self.ws_port_entry.pack(side="left", padx=(4, 12), pady=8)
+
+        self.network_apply_button = ctk.CTkButton(
+            network_frame, text=self._t("apply"), width=90, command=self._on_apply_network
+        )
+        self.network_apply_button.pack(side="left", padx=(0, 8), pady=8)
+
+        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)
+
         # -- 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))
@@ -345,7 +418,7 @@ class FletchTimeApp(ctk.CTk):
     # -- actions ---------------------------------------------------------
 
     def _open_link(self, path: str) -> None:
-        webbrowser.open(f"http://127.0.0.1:{HTTP_PORT}{path}")
+        webbrowser.open(f"http://127.0.0.1:{self.http_port}{path}")
 
     def _start_server(self) -> None:
         if self.runtime.is_running:
@@ -372,7 +445,7 @@ class FletchTimeApp(ctk.CTk):
         """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}/"
+        address = f"http://{local_ip()}:{self.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
@@ -394,6 +467,88 @@ class FletchTimeApp(ctk.CTk):
         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}")
+        # Les valeurs du menu de thème sont des libellés traduits (pas des
+        # codes internes comme "FR"/"EN") -- il faut donc reconstruire la
+        # liste ET repositionner la sélection sur le thème actuel, pas
+        # juste changer le texte d'un widget existant.
+        self.theme_menu.configure(
+            values=[self._t("themeSystem"), self._t("themeLight"), self._t("themeDark")]
+        )
+        self.theme_menu.set(self._theme_label(self.theme))
+        self.network_caption.configure(text=self._t("networkCaption"))
+        self.network_apply_button.configure(text=self._t("apply"))
+        self._refresh_status()
+
+    def _theme_label(self, theme: str) -> str:
+        return {
+            "system": self._t("themeSystem"),
+            "light": self._t("themeLight"),
+            "dark": self._t("themeDark"),
+        }.get(theme, self._t("themeSystem"))
+
+    def _on_theme_change(self, label: str) -> None:
+        reverse = {
+            self._t("themeSystem"): "system",
+            self._t("themeLight"): "light",
+            self._t("themeDark"): "dark",
+        }
+        theme = reverse.get(label, "system")
+        self.theme = theme
+        ctk.set_appearance_mode(theme)
+        config_store.save_gui_config({"theme": theme})
+
+    def _on_apply_network(self) -> None:
+        """Change les ports HTTP/WebSocket -- reconstruit ServerRuntime
+        avec les nouvelles valeurs (les ports sont figés à la
+        construction, voir fletchtime.runtime.ServerRuntime) et
+        redémarre automatiquement si le serveur tournait déjà, pour que
+        le changement prenne effet tout de suite plutôt que de laisser
+        la fenêtre dans un état incohérent (ports affichés différents de
+        ceux réellement utilisés par le serveur en cours)."""
+        try:
+            http_port = int(self.http_port_entry.get())
+            ws_port = int(self.ws_port_entry.get())
+        except ValueError:
+            self.network_status_label.configure(
+                text=self._t("networkErrorNotANumber"), text_color="#d6534a"
+            )
+            return
+
+        if not (1 <= http_port <= 65535) or not (1 <= ws_port <= 65535):
+            self.network_status_label.configure(
+                text=self._t("networkErrorRange"), text_color="#d6534a"
+            )
+            return
+        if http_port == ws_port:
+            self.network_status_label.configure(
+                text=self._t("networkErrorSame"), text_color="#d6534a"
+            )
+            return
+
+        try:
+            config_store.save_gui_config({"http_port": http_port, "ws_port": ws_port})
+        except ValueError:
+            # Filet de sécurité seulement -- les cas attendus sont déjà
+            # couverts par les vérifications ci-dessus, donc ce chemin ne
+            # devrait normalement jamais s'exécuter.
+            self.network_status_label.configure(
+                text=self._t("networkErrorRange"), text_color="#d6534a"
+            )
+            return
+
+        was_running = self.runtime.is_running
+        if was_running:
+            self.runtime.stop()
+
+        self.http_port = http_port
+        self.ws_port = ws_port
+        self.runtime = ServerRuntime(
+            str(self.app_web_dir), str(self.assets_dir), self.http_port, self.ws_port
+        )
+        if was_running:
+            self.runtime.start()
+
+        self.network_status_label.configure(text=self._t("networkApplied"), text_color="#2fb344")
         self._refresh_status()
 
     def _on_quit(self) -> None:

{fletchtime-0.2.1 → fletchtime-0.2.2}/src/fletchtime/server/config_store.py

@@ -47,6 +47,11 @@ AUTH_TOML = CONFIG_DIR / "auth.toml"
 # (voir .gitignore) : propre à une session de match en cours, pas un
 # réglage du club.
 MATCH_STATE_JSON = CONFIG_DIR / "match_state.json"
+# Préférences de la fenêtre graphique (thème...) -- fichier séparé de
+# app.toml exprès : ce ne sont pas des réglages du match/serveur diffusés
+# aux écrans web, juste des préférences purement locales à qui lance la
+# fenêtre sur cette machine précise.
+GUI_TOML = CONFIG_DIR / "gui.toml"
 
 APP_COMMENTS: dict[str, str] = {
     "sound_pack": "Nom du dossier dans web/assets/sounds/packs/ à utiliser (ex. classic)",
@@ -54,6 +59,13 @@ APP_COMMENTS: dict[str, str] = {
 }
 DEFAULT_APP_CONFIG: dict[str, Any] = {"sound_pack": "classic", "countdown_tick_seconds": 5}
 
+GUI_COMMENTS: dict[str, str] = {
+    "theme": 'Thème de la fenêtre : "system" (suit le thème du système), "light" ou "dark"',
+    "http_port": "Port HTTP (pages web) -- change ceci pour faire tourner plusieurs salles sur le même PC",
+    "ws_port": "Port WebSocket (temps réel) -- doit être différent du port HTTP",
+}
+DEFAULT_GUI_CONFIG: dict[str, Any] = {"theme": "system", "http_port": 8000, "ws_port": 8765}
+
 AUTH_COMMENTS: dict[str, str] = {
     "password": (
         "Mot de passe requis pour piloter le match et modifier la "
@@ -148,6 +160,31 @@ def save_app_config(overrides: dict[str, Any]) -> dict[str, Any]:
     return merged
 
 
+def load_gui_config() -> dict[str, Any]:
+    """Préférences de la fenêtre graphique -- voir GUI_TOML. Comme
+    load_app_config, un plain dict plutôt qu'une dataclass formelle : un
+    seul champ aujourd'hui, peut grandir."""
+    data = _load_toml(GUI_TOML)
+    merged = dict(DEFAULT_GUI_CONFIG)
+    merged.update({k: v for k, v in data.items() if k in DEFAULT_GUI_CONFIG})
+    return merged
+
+
+def save_gui_config(overrides: dict[str, Any]) -> dict[str, Any]:
+    merged = load_gui_config()
+    merged.update({k: v for k, v in overrides.items() if k in DEFAULT_GUI_CONFIG})
+    if merged["theme"] not in ("system", "light", "dark"):
+        raise ValueError(f'theme must be "system", "light" or "dark", got {merged["theme"]!r}')
+    for key in ("http_port", "ws_port"):
+        port = merged[key]
+        if not isinstance(port, int) or not (1 <= port <= 65535):
+            raise ValueError(f"{key} must be an integer between 1 and 65535, got {port!r}")
+    if merged["http_port"] == merged["ws_port"]:
+        raise ValueError("http_port and ws_port must be different")
+    _write_toml(GUI_TOML, merged, GUI_COMMENTS)
+    return merged
+
+
 def load_auth_config() -> dict[str, Any]:
     data = _load_toml(AUTH_TOML)
     merged = dict(DEFAULT_AUTH_CONFIG)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fletchtime
-Version: 0.2.1
+Version: 0.2.2
 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
@@ -21,6 +21,11 @@ Dynamic: license-file
 
 <img src="https://mrfanghodev.github.io/fletchtime/_static/logo.svg" width="80" height="80" alt="FletchTime logo">
 
+[![Python](https://img.shields.io/badge/python-version-from-pep-621-toml?tomlFilePath=https%3A%2F%2Fraw.githubusercontent.com%2FMrFanghoDev%2Ffletchtime%2Fmaster%2Fpyproject.toml)](pyproject.toml)
+[![Licence](https://img.shields.io/github/license/MrFanghoDev/fletchtime)](LICENSE)
+[![Tests](https://github.com/MrFanghoDev/fletchtime/actions/workflows/test.yml/badge.svg?branch=master)](https://github.com/MrFanghoDev/fletchtime/actions/workflows/test.yml)
+[![PyPI](https://img.shields.io/pypi/v/fletchtime)](https://pypi.org/project/fletchtime/)
+
 # FletchTime
 
 Logiciel open source de gestion du temps pour compétitions d'archerie FFTL
@@ -122,6 +127,29 @@ from fletchtime.engine import IndoorMode, IndoorConfig, MatchEngine
 engine = MatchEngine(IndoorMode(IndoorConfig()))
 ```
 
+## Plusieurs salles de compétition sur un même PC
+
+Chaque installation de FletchTime (dossier `pip install`, ou dossier de
+l'exécutable autoporteur) fait tourner **une seule salle** -- son propre
+match, sa propre urgence, sa propre config. Pour plusieurs salles en
+parallèle sur le même PC :
+
+1. **Copie le dossier FletchTime une fois par salle** (ex. `salle-A/`,
+   `salle-B/`) -- ça isole automatiquement `config/` (temps de tir,
+   urgence...), les journaux, et l'instantané de récupération après
+   plantage : chaque copie a sa propre urgence, indépendante des autres.
+2. Dans la fenêtre de chaque copie, section **Ports (HTTP/WS)** : donne
+   des ports différents à chaque salle (ex. salle A garde `8000`/`8765`
+   par défaut, salle B passe à `8001`/`8766`) -- **Appliquer** redémarre
+   le serveur automatiquement si besoin.
+3. Lance chaque copie séparément. Les écrans de chaque salle se
+   connectent à l'adresse (IP + port) affichée dans la fenêtre de leur
+   salle respective.
+
+**Windows** : le pare-feu autorise généralement par chemin d'exécutable --
+avec des copies de dossier séparées, prévoir de valider l'alerte une fois
+par copie au premier lancement.
+
 ## Contribuer
 
 Envie de proposer un correctif, une idée, ou juste signaler un bug ? Voir

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

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