Update interface.py

interface.py

@@ -8,7 +8,7 @@ import numpy as np
 import soundfile as sf
 from pathlib import Path
 from itertools import permutations
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Tuple
 
 from reasoning_pipeline import aggregate_reasoning_summaries
 
@@ -24,6 +24,17 @@ def get_model():
     return _model
 
 
+def round_value(value):
+    if value is None:
+        return None
+    if isinstance(value, bool):
+        return value
+    try:
+        return round(float(value), 2)
+    except (ValueError, TypeError):
+        return value
+
+
 def apply_wiener_filter(est_sources, mixture, iterations=1):
     """
     A simplified Wiener filter refinement. 
@@ -197,6 +208,7 @@ def save_audio_file(path, waveform, sample_rate):
 RESULTS_DIR = Path("pipeline_results")
 REASONING_SUMMARY_PATH = RESULTS_DIR / "reasoning_summary.json"
 PATIENT_REGISTRY_PATH = RESULTS_DIR / "patient_registry.json"
+PATIENT_REGISTRY_BATCHES_PATH = RESULTS_DIR / "patient_registry_batches.json"
 HISTORY_RECORDS_PATH = RESULTS_DIR / "history_records.json"
 DB_PATH = RESULTS_DIR / "speformer.db"
 AUDIO_STORAGE_DIR = RESULTS_DIR / "audio"
@@ -218,7 +230,7 @@ def initialize_database():
         """
         CREATE TABLE IF NOT EXISTS patient_registry (
             id INTEGER PRIMARY KEY,
-            patient_id TEXT UNIQUE,
+            patient_id TEXT,
             name TEXT,
             reference_audio TEXT,
             local_reference_audio TEXT,
@@ -253,6 +265,33 @@ def initialize_database():
         )
         """
     )
+
+    legacy_sql = conn.execute(
+        "SELECT sql FROM sqlite_master WHERE type='table' AND name='patient_registry'"
+    ).fetchone()
+    if legacy_sql and legacy_sql[0] and "patient_id TEXT UNIQUE" in legacy_sql[0]:
+        conn.execute("ALTER TABLE patient_registry RENAME TO patient_registry_old")
+        conn.execute(
+            """
+            CREATE TABLE patient_registry (
+                id INTEGER PRIMARY KEY,
+                patient_id TEXT,
+                name TEXT,
+                reference_audio TEXT,
+                local_reference_audio TEXT,
+                created_at TEXT
+            )
+            """
+        )
+        conn.execute(
+            """
+            INSERT INTO patient_registry (id, patient_id, name, reference_audio, local_reference_audio, created_at)
+            SELECT id, patient_id, name, reference_audio, local_reference_audio, created_at
+            FROM patient_registry_old
+            """
+        )
+        conn.execute("DROP TABLE patient_registry_old")
+
     conn.commit()
     conn.close()
 
@@ -296,12 +335,48 @@ def _copy_audio_to_storage(src_path: Optional[str], subdir: str, prefix: str) ->
     return str(dest)
 
 
-def save_patient_registry(patient_entries: List[Dict[str, str]], registry_path: Optional[Path] = None) -> Path:
+def save_patient_registry(patient_entries: List[Dict[str, str]], registry_path: Optional[Path] = None) -> Tuple[Optional[Path], Optional[str]]:
     path = Path(registry_path) if registry_path is not None else PATIENT_REGISTRY_PATH
     path.parent.mkdir(parents=True, exist_ok=True)
+    # Normalize names for duplicate-batch detection
+    normalized_names = [(entry.get("name") or "").strip() for entry in patient_entries]
+    normalized_names = [n for n in normalized_names if n]
+
+    if not normalized_names:
+        return None, "Error: Please enter at least one patient name before registering."
+
+    if len(normalized_names) != len(set(name.lower() for name in normalized_names)):
+        return None, "Error: Duplicate patient names were entered in this registration. Please use unique names."
 
     initialize_database()
     conn = _get_db_connection()
+    try:
+        cursor = conn.execute("SELECT name FROM patient_registry")
+        existing_names = {row["name"].strip().lower() for row in cursor.fetchall() if row["name"]}
+    except Exception:
+        existing_names = set()
+
+    conflicts = [name for name in normalized_names if name.lower() in existing_names]
+    if conflicts:
+        conn.close()
+        conflict_list = ", ".join(sorted(set(conflicts)))
+        return None, f"Error: Patient name(s) already registered: {conflict_list}. Registration aborted."
+
+    # Load existing registration batches and check for duplicates (set equality)
+    try:
+        batches = []
+        if PATIENT_REGISTRY_BATCHES_PATH.exists():
+            with open(PATIENT_REGISTRY_BATCHES_PATH, "r", encoding="utf-8") as bf:
+                batches = json.load(bf) or []
+        # Build set of non-empty names for comparison
+        new_set = set(normalized_names)
+        for b in batches:
+            if set([x for x in (b.get("names") or []) if x]) == new_set:
+                conn.close()
+                return None, "Error: This exact set of patient names has already been registered."
+    except Exception:
+        batches = []
+
     local_entries = []
     for entry in patient_entries:
         patient_id = entry.get("patient_id") or entry.get("id") or ""
@@ -309,7 +384,7 @@ def save_patient_registry(patient_entries: List[Dict[str, str]], registry_path:
         ref_audio = entry.get("reference_audio")
         local_ref_audio = _copy_audio_to_storage(ref_audio, "patient_reference", patient_id) if ref_audio else None
         conn.execute(
-            "INSERT OR REPLACE INTO patient_registry (patient_id, name, reference_audio, local_reference_audio, created_at) VALUES (?, ?, ?, ?, ?)",
+            "INSERT INTO patient_registry (patient_id, name, reference_audio, local_reference_audio, created_at) VALUES (?, ?, ?, ?, ?)",
             (
                 patient_id,
                 name,
@@ -328,7 +403,16 @@ def save_patient_registry(patient_entries: List[Dict[str, str]], registry_path:
 
     with open(path, "w", encoding="utf-8") as f:
         json.dump(local_entries, f, indent=2)
-    return path
+
+    # Record the saved batch for future duplicate checks
+    try:
+        batch_record = {"timestamp": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()), "names": [e.get("name") for e in local_entries]}
+        batches.append(batch_record)
+        with open(PATIENT_REGISTRY_BATCHES_PATH, "w", encoding="utf-8") as bf:
+            json.dump(batches, bf, indent=2)
+    except Exception:
+        pass
+    return path, None
 
 
 def load_patient_registry(registry_path: Optional[Path] = None) -> List[Dict[str, str]]:
@@ -612,10 +696,9 @@ def monitoring_table_rows(results_path: Optional[Path] = None):
     for item in records:
         rows.append([
             item.get("audio_id"),
-            item.get("overall_state"),
-            item.get("mean_wheeze_prob"),
-            item.get("mean_crackle_prob"),
-            item.get("breathing_rate_mean"),
+            round_value(item.get("mean_wheeze_prob")),
+            round_value(item.get("mean_crackle_prob")),
+            round_value(item.get("breathing_rate_mean")),
             item.get("comment"),
         ])
     return rows