fix: location handling — persist user overrides and enforce location list policy

Locations (and name/type overrides) assigned from the context menu were
never persisted: the DiscoveryManager stores were not saved in the UI
preferences nor reloaded at startup, so everything was lost on restart.

- Persist and restore location_overrides, name_overrides and
  type_overrides in the UI preferences; wire the manager's
  location-prefs dirty callback through a thread-safe Qt signal so
  auto-stored locations are saved too.
- Drop the FR/EN equivalence table in normalize_location_options:
  no translation handling, labels are shown as-is with case-insensitive
  dedup only (first occurrence wins, user entries are never replaced).
- New DiscoveryManager.set_location_policy(list, auto_add): a discovered
  (mDNS/SSDP) location is applied only when present in the configured
  list (reusing the list's exact spelling, no case duplicates) or when
  "Add location" is enabled (then added to the list as-is); otherwise
  the device stays in "no location". Explicit user overrides always win.
- Context menu now always offers the device's current location alongside
  the configured options (location_options_with_current).
- Main window falls back to the locale default location presets when no
  list is configured; the auto-add flag from the Preferences dialog is
  now actually propagated.

Bump version

Author: luc-github

VERSION

@@ -1 +1 @@
-2.0.4
+2.0.5

app/discovery/manager.py

@@ -289,6 +289,10 @@ def __init__(
         self._demo_mode = demo_mode
         self._location_prefs_need_reapply = False
         self._location_prefs_dirty_callback: Callable[[], None] | None = None
+        # Discovered-location policy: casefolded label -> configured spelling.
+        # Permissive until the UI pushes the configured list via set_location_policy.
+        self._allowed_locations: dict[str, str] = {}
+        self._auto_add_discovered_locations = True
 
         for protocol in self._protocols:
             protocol.set_callback(self._on_protocol_event)
@@ -1726,6 +1730,18 @@ def set_location_overrides(self, overrides: dict[str, str]) -> None:
     def get_location_overrides(self) -> dict[str, str]:
         return dict(self._location_overrides)
 
+    def set_location_policy(self, allowed_locations: list[str], auto_add_discovered: bool) -> None:
+        """Discovered locations are applied only when listed here or when auto-add is on;
+        otherwise the device stays without location. User overrides are unaffected."""
+        mapping: dict[str, str] = {}
+        for raw in allowed_locations or []:
+            if isinstance(raw, str) and raw.strip():
+                mapping.setdefault(raw.strip().casefold(), raw.strip())
+        self._allowed_locations = mapping
+        self._auto_add_discovered_locations = bool(auto_add_discovered)
+        # Re-evaluate every cached device against the new policy.
+        self.set_location_overrides(self.get_location_overrides())
+
     def set_field_mapping_rules(self, rules: dict[str, dict[str, list[str]]]) -> None:
         normalized: dict[str, dict[str, list[str]]] = {}
         for key, value in rules.items():
@@ -2642,14 +2658,25 @@ def _apply_location_override(self, device: Device) -> None:
                 self._clip_loc_log(chosen),
             )
         elif d_norm and is_plausible_room_location(d_norm):
-            self._store_location_preference_for_device(device, d_norm)
-            chosen = d_norm
-            dev_log.debug(
-                "Location: auto from discovery (persisted) ip=%s port=%s value=%r",
-                device.ip,
-                device.port,
-                self._clip_loc_log(chosen),
-            )
+            canonical = self._allowed_locations.get(d_norm.casefold())
+            if canonical is not None:
+                d_norm = canonical
+            if canonical is not None or self._auto_add_discovered_locations:
+                self._store_location_preference_for_device(device, d_norm)
+                chosen = d_norm
+                dev_log.debug(
+                    "Location: auto from discovery (persisted) ip=%s port=%s value=%r",
+                    device.ip,
+                    device.port,
+                    self._clip_loc_log(chosen),
+                )
+            else:
+                dev_log.debug(
+                    "Location: discovered %r ignored (not in configured list, auto-add off) ip=%s port=%s",
+                    self._clip_loc_log(d_norm),
+                    device.ip,
+                    device.port,
+                )
         else:
             dev_log.debug(
                 "Location: empty ip=%s port=%s (no RoomName/xml_fields or TXT keys matched)",

app/ui/main_window.py

@@ -81,7 +81,7 @@
 from utils.discovery_cache import purge_device_from_discovery_cache
 from utils.discovery_config import normalize_information_precedence_list
 from utils.double_click_open import resolve_all_connect_targets, resolve_connect_target
-from utils.location_label import normalize_location_options
+from utils.location_label import location_options_with_current, normalize_location_options
 from utils.icon_view_prefs import (
     DEVICE_ICON_REFERENCE_PX,
     ICON_SIZE_PRESET_PIXELS,
@@ -296,6 +296,7 @@ class NetNeighborMainWindow(QMainWindow):
     """Table (list) and icon-mode list; view options stored in ``ui_prefs.json``."""
 
     _notification_received = Signal(str, str, str)  # datetime_str, device_name, status
+    _location_prefs_dirty = Signal()  # emitted from discovery threads → persist on main thread
 
     _FILTER_ROLE = Qt.ItemDataRole.UserRole
     _BUNDLE_KEY_ROLE = Qt.ItemDataRole.UserRole + 1
@@ -375,6 +376,9 @@ def __init__(
             self._location_options = normalize_location_options(
                 [str(v).strip() for v in raw_locs if isinstance(v, str) and str(v).strip()]
             )
+        if not self._location_options:
+            from ui.preset_editors import _default_location_presets
+            self._location_options = _default_location_presets()
         self._type_options: list[tuple[str, str]] = []
         raw_types = prefs.get("type_options")
         if isinstance(raw_types, list):
@@ -406,6 +410,19 @@ def __init__(
             raw_hidden = prefs.get("hidden_overrides")
             if isinstance(raw_hidden, dict):
                 discovery_manager.set_hidden_overrides(raw_hidden)
+            raw_type_o = prefs.get("type_overrides")
+            if isinstance(raw_type_o, dict):
+                discovery_manager.set_type_overrides(raw_type_o)
+            raw_name_o = prefs.get("name_overrides")
+            if isinstance(raw_name_o, dict):
+                discovery_manager.set_name_overrides(raw_name_o)
+            raw_loc_o = prefs.get("location_overrides")
+            if isinstance(raw_loc_o, dict):
+                discovery_manager.set_location_overrides(raw_loc_o)
+            discovery_manager.set_location_policy(
+                self._location_options,
+                bool(prefs.get("auto_add_discovered_locations", False)),
+            )
 
         raw_hidden_meta = prefs.get("hidden_device_meta")
         self._hidden_device_meta: dict[str, dict[str, object]] = {}
@@ -416,10 +433,14 @@ def __init__(
 
         self._notification_log: list[tuple[str, str, str]] = []
         self._notification_received.connect(self._append_notification)
+        self._location_prefs_dirty.connect(self._schedule_persist_ui_prefs)
         if discovery_manager is not None:
             discovery_manager.register_presence_transition_hook(
                 self._on_presence_transition
             )
+            discovery_manager.set_location_prefs_dirty_callback(
+                self._location_prefs_dirty.emit
+            )
 
         self._last_devices: list[Device] = []
         self._bundles: list[DeviceBundle] = []
@@ -1038,6 +1059,9 @@ def _persist_ui_prefs(self) -> None:
             prefs["field_mapping_rules"] = self._discovery_manager.get_field_mapping_rules()
             prefs["monitored_overrides"] = self._discovery_manager.get_monitored_overrides()
             prefs["hidden_overrides"] = self._discovery_manager.get_hidden_overrides()
+            prefs["type_overrides"] = self._discovery_manager.get_type_overrides()
+            prefs["name_overrides"] = self._discovery_manager.get_name_overrides()
+            prefs["location_overrides"] = self._discovery_manager.get_location_overrides()
             self._prune_hidden_device_meta()
             prefs["hidden_device_meta"] = dict(self._hidden_device_meta)
         save_ui_preferences(prefs)
@@ -1110,8 +1134,10 @@ def _open_preferences(self) -> None:
         )
         dlg.exec()
 
-    def _apply_location_presets(self, options: list[str], _auto_add: bool) -> None:
+    def _apply_location_presets(self, options: list[str], auto_add: bool) -> None:
         self._location_options = options
+        if self._discovery_manager is not None:
+            self._discovery_manager.set_location_policy(options, auto_add)
 
     def _apply_type_presets(self, options: list[tuple[str, str]]) -> None:
         self._type_options = options
@@ -1470,6 +1496,8 @@ def _maybe_auto_add_discovered_locations(self) -> None:
         self._location_options = merged
         prefs["location_options"] = merged
         save_ui_preferences(prefs)
+        if self._discovery_manager is not None:
+            self._discovery_manager.set_location_policy(merged, True)
 
     def _filtered_bundles(self) -> list[DeviceBundle]:
         bundles = apply_bundle_category_filter(
@@ -1646,10 +1674,7 @@ def _show_device_context_menu(self, global_pos: QPoint, bundle: DeviceBundle) ->
             bundle_custom_command(bundle) or (self._custom_command_template or "").strip()
         )
         current_loc = bundle_location_label(bundle, no_location_label="")
-        if current_loc and current_loc not in self._location_options:
-            loc_opts = normalize_location_options(self._location_options + [current_loc])
-        else:
-            loc_opts = self._location_options
+        loc_opts = location_options_with_current(self._location_options, current_loc)
         show_device_context_menu(
             self,
             global_pos,

app/utils/location_label.py

@@ -21,32 +21,35 @@ def is_plausible_room_location(value: str | None) -> bool:
     return True
 
 
-_LOCATION_CANONICAL_EQUIV = {
-    "office": "bureau",
-    "room": "chambre",
-    "living room": "salon",
-    "kitchen": "cuisine",
-    "workshop": "atelier",
-    "bathroom": "salle de bain",
-    "master bedroom": "chambre principale",
-}
-
-
 def normalize_location_options(options: list[str]) -> list[str]:
-    """Drop empty/invalid entries and collapse obvious FR/EN duplicates.
+    """Drop empty/invalid entries and case-insensitive duplicates.
 
-    Keeps insertion order while preferring the latest value for equivalent labels.
+    Keeps insertion order while preferring the earliest value, so
+    user-configured options are never replaced by later (discovered) ones.
+    Translations are deliberately NOT handled: "office" and "bureau" are two
+    distinct locations and both stay in the list.
     """
     normalized: list[str] = []
-    by_key: dict[str, int] = {}
+    seen: set[str] = set()
     for raw in options:
         value = str(raw).strip() if isinstance(raw, str) else ""
         if not value or not is_plausible_room_location(value):
             continue
-        key = _LOCATION_CANONICAL_EQUIV.get(value.casefold(), value.casefold())
-        if key in by_key:
-            normalized[by_key[key]] = value
-        else:
-            by_key[key] = len(normalized)
-            normalized.append(value)
+        key = value.casefold()
+        if key in seen:
+            continue
+        seen.add(key)
+        normalized.append(value)
     return normalized
+
+
+def location_options_with_current(options: list[str], current: str | None) -> list[str]:
+    """Return *options* plus the device's current location label."""
+    result = list(options)
+    value = current.strip() if isinstance(current, str) else ""
+    if not value or not is_plausible_room_location(value):
+        return result
+    if any(value.casefold() == opt.casefold() for opt in result):
+        return result
+    result.append(value)
+    return result