fix(medicines): bundled list wins when newer; npl_id auto-fill

Author: TSA3000

CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [0.2.10] — 2026-05-10
+
+Two fixes from v0.2.9 testing. Drop-in upgrade from 0.2.9.
+
+- **Bundled medicines list wins when newer.** `MedicineDatabase.async_load` now compares `list_version` between the integration's bundled file and the user's stored copy; the lexicographically newer one wins (the `YYYY.MM.DD-N` format sorts correctly that way). Pre-v0.2.10, anyone who'd ever clicked **Refresh medicine list now** stayed pinned to that cached list across integration upgrades — the v0.2.9 jump from 216 to 7331 bundled entries was invisible until a manual re-refresh. Explicit URL refreshes ahead of the bundle still win.
+- **NPL ID auto-fills from the catalog.** Picking a known medicine in the Add/Edit modal now populates the NPL ID field the same way ATC code and active substance already do. Three spots fixed: `_normalize_entry` preserves `npl_id` on load (was being stripped), `sanitize_for_ws` forwards it to the panel over `pillpilot/get_medicines_db`, and `_applyDrugNameAutoFill` copies it into the draft when empty. User-entered NPL IDs are never overwritten.
+
 ## [0.2.9] — 2026-05-10
 
 Medicine list rebuilt from Läkemedelsverket. Drop-in upgrade from 0.2.8.

RELEASE_NOTES.md

@@ -1,28 +1,15 @@
-# v0.2.9
+# v0.2.10
 
-> Medicine list rebuilt from Läkemedelsverket. Drop-in upgrade from 0.2.8.
+> Two fixes from v0.2.9 testing. Drop-in upgrade from 0.2.9.
 
-## What's new
+## What's fixed
 
-`medicines_se.json` is now generated from [Läkemedelsverket's open-data register](https://www.dataportal.se/datasets/140_5467) (Sök läkemedelsfakta, dataset 140_5467) instead of being hand-curated. 216 entries → 7331. Covers every human medicine currently `Godkänd` or `Registrerad`. Veterinary and deregistered products are filtered at build time. Snapshot 2026-05-10.
+**Bundled medicines list wins when newer.** Pre-v0.2.10 the stored copy in `.storage/pillpilot.medicines_se` always won over the integration's bundled file. So if you'd ever clicked **Refresh medicine list now** in an earlier release, you stayed stuck on that cached list across HACS upgrades — the v0.2.9 jump from 216 to 7331 entries was invisible until you manually refreshed again. `MedicineDatabase.async_load` now compares `list_version` on the two and picks the newer one. Explicit URL refreshes ahead of the bundle still take precedence.
 
-Each entry now carries `npl_id`, and `aliases` includes former product names from the `Tidigare läkemedelsnamn` column — searching an old brand name finds the current entry.
-
-## Build tool
-
-`tools/build_medicines_se.py` regenerates the JSON from a fresh `Lakemedelsprodukter.xlsx` export. Maintainer tool — not shipped in the integration zip.
-
-```
-pip install openpyxl
-python tools/build_medicines_se.py \
-    --input ~/Downloads/Lakemedelsprodukter.xlsx \
-    --output custom_components/pillpilot/medicines_se.json
-```
-
-Curated aliases on existing entries are preserved across rebuilds.
+**NPL ID auto-fills from the catalog.** When you pick a known medicine in the panel's Add/Edit modal, the NPL ID field now populates from the Läkemedelsverket export, the same way ATC code and active substance already do. Three spots that all had to be in sync: `_normalize_entry` preserves the field on load, `sanitize_for_ws` forwards it to the panel, and `_applyDrugNameAutoFill` writes it into the draft. Anything you typed yourself isn't overwritten.
 
 ## Upgrading
 
-Replace the `pillpilot` directory in `custom_components/` with the contents of this zip and restart Home Assistant. HACS users: update normally. Existing medicines are unaffected.
+Replace the `pillpilot` directory in `custom_components/` with the contents of this zip and restart Home Assistant. HACS users: update normally.
 
-ATC codes come straight from Läkemedelsverket. Still verify against FASS or Sök VARA before relying on them clinically.
+Anyone on the v0.2.9 bundled list (`2026.05.10-1`) and a stored copy from before will be flipped to the bundled list on first load after this upgrade. Existing medicines configured before the upgrade are unaffected.

custom_components/pillpilot/frontend/panel.js

@@ -1565,8 +1565,8 @@ class PillPilotPanel extends HTMLElement {
   }
 
   // Apply auto-fill to the Add/Edit draft based on a typed-or-picked
-  // value in the drug-name field. Fills empty atc_code + notes from
-  // the matched catalog entry; never overwrites user-entered values.
+  // value in the drug-name field. Fills empty atc_code + npl_id + notes
+  // from the matched catalog entry; never overwrites user-entered values.
   // Returns true if anything in the draft changed (caller decides
   // whether to re-render).
   _applyDrugNameAutoFill(typedValue) {
@@ -1588,6 +1588,11 @@ class PillPilotPanel extends HTMLElement {
       draft.drug.atc_code = hit.atc_code;
       changed = true;
     }
+    const userNpl = (draft.drug.npl_id || "").trim();
+    if (!userNpl && hit.npl_id) {
+      draft.drug.npl_id = hit.npl_id;
+      changed = true;
+    }
     const userNotes = (draft.drug.notes || "").trim();
     if (!userNotes && hit.active_substance) {
       draft.drug.notes = `Aktiv substans: ${hit.active_substance}`;

custom_components/pillpilot/manifest.json

@@ -1,7 +1,7 @@
 {
   "domain": "pillpilot",
   "name": "PillPilot",
-  "version": "0.2.9",
+  "version": "0.2.10",
   "documentation": "https://github.com/TSA3000/ha-pillpilot",
   "issue_tracker": "https://github.com/TSA3000/ha-pillpilot/issues",
   "codeowners": ["@TSA3000"],

custom_components/pillpilot/medicines.py

@@ -84,6 +84,7 @@ def _normalize_entry(raw: dict[str, Any]) -> dict[str, Any] | None:
         "aliases": [str(a).strip() for a in aliases_raw if str(a).strip()],
         "active_substance": str(raw.get("active_substance") or "").strip(),
         "atc_code": str(raw.get("atc_code") or "").strip(),
+        "npl_id": str(raw.get("npl_id") or "").strip(),
         "common_forms": [str(f).strip() for f in forms_raw if str(f).strip()],
     }
 
@@ -144,35 +145,65 @@ def is_loaded(self) -> bool:
         return self._loaded
 
     async def async_load(self) -> None:
-        """Load on integration startup. Stored copy wins over bundled."""
+        """Load on integration startup. Bundled wins if it's newer.
+
+        v0.2.10: compares ``list_version`` between the integration's
+        bundled file and any stored copy. The lexicographically newer
+        one wins — the ``YYYY.MM.DD-N`` format sorts correctly that
+        way. Pre-v0.2.10 the stored copy always won, so users who'd
+        ever clicked **Refresh** stayed pinned to that cached list
+        across integration upgrades and never saw new bundled
+        medicines (e.g. the v0.2.9 jump from 216 → 7331 entries was
+        invisible to anyone with a stored copy). Explicit URL
+        refreshes still win when the URL is ahead of the bundle.
+        """
         stored = await self._store.async_load()
+        stored_version = ""
         if stored and isinstance(stored, dict) and stored.get("medicines"):
-            self._data = _normalize_list(stored)
-            self._loaded = True
-            _LOGGER.debug(
-                "Loaded medicines list from storage (version=%s, count=%d)",
-                self._data["list_version"], len(self._data["medicines"]),
-            )
-            return
-        # Fall back to bundled file
+            stored_version = str(stored.get("list_version") or "")
+
+        bundled_data: dict[str, Any] | None = None
         try:
             bundled_text = await self._hass.async_add_executor_job(
                 BUNDLED_PATH.read_text, "utf-8"
             )
-            self._data = _normalize_list(json.loads(bundled_text))
-            self._loaded = True
-            _LOGGER.debug(
-                "Loaded bundled medicines list (version=%s, count=%d)",
-                self._data["list_version"], len(self._data["medicines"]),
-            )
+            bundled_data = json.loads(bundled_text)
         except (OSError, json.JSONDecodeError) as err:
-            _LOGGER.error(
+            _LOGGER.warning(
                 "Could not load bundled medicines list at %s: %s",
                 BUNDLED_PATH, err,
             )
-            # Empty doc — autocomplete dropdown will simply have no options
-            self._data = _empty_doc()
+        bundled_version = str((bundled_data or {}).get("list_version") or "")
+
+        if bundled_data and (
+            not stored_version or bundled_version > stored_version
+        ):
+            self._data = _normalize_list(bundled_data)
             self._loaded = True
+            _LOGGER.debug(
+                "Loaded bundled medicines list (version=%s, count=%d, "
+                "stored=%s)",
+                self._data["list_version"], len(self._data["medicines"]),
+                stored_version or "none",
+            )
+            return
+
+        if stored and isinstance(stored, dict) and stored.get("medicines"):
+            self._data = _normalize_list(stored)
+            self._loaded = True
+            _LOGGER.debug(
+                "Loaded medicines list from storage (version=%s, count=%d, "
+                "bundled=%s)",
+                self._data["list_version"], len(self._data["medicines"]),
+                bundled_version or "none",
+            )
+            return
+
+        _LOGGER.error(
+            "Could not load any medicines list (stored=missing, bundled=missing)"
+        )
+        self._data = _empty_doc()
+        self._loaded = True
 
     async def async_refresh_from_url(self, url: str) -> tuple[bool, str]:
         """Fetch a fresh medicines list from `url` and persist it.
@@ -323,11 +354,11 @@ def sanitize_for_ws(
 ) -> list[dict[str, Any]]:
     """Project the medicines list down to the fields the panel needs.
 
-    The panel's autocomplete/auto-fill needs only ``name``, ``aliases``,
-    ``active_substance`` and ``atc_code``. The bundled list also carries
-    ``common_forms``, vendor metadata, and pre-list comments — all
-    irrelevant on the wire and worth not shipping over the websocket
-    on every panel load.
+    The panel's autocomplete/auto-fill needs ``name``, ``aliases``,
+    ``active_substance``, ``atc_code`` and (since v0.2.10) ``npl_id``.
+    The bundled list also carries ``common_forms``, vendor metadata,
+    and pre-list comments — all irrelevant on the wire and worth not
+    shipping over the websocket on every panel load.
 
     Nameless entries are dropped; missing optional fields are emitted
     as empty strings so the panel can rely on the shape.
@@ -347,5 +378,6 @@ def sanitize_for_ws(
             "aliases": aliases,
             "active_substance": (med.get("active_substance") or "").strip(),
             "atc_code": (med.get("atc_code") or "").strip(),
+            "npl_id": (med.get("npl_id") or "").strip(),
         })
     return out