Trying again

server.py

@@ -56,26 +56,49 @@ def extract_patient_name(raw_name):
         return ""
     # Remove everything after (and including) 'DOB'
     name_only = raw_name.split('DOB').strip()
-    # Clean up leftover colon or numbers
-    # Remove trailing colon/spaces/numbers if present
+    # Clean up leftover colon or numbers; remove trailing colon/spaces/numbers if present
     name_only = re.sub(r'[:\d\-\s]+$', '', name_only).strip()
     return name_only
 
+def normalize_str(v):
+    """
+    Safely convert any value (NaN/None/list/number/string) into a clean string.
+    Prevents attribute errors when later trimming or matching. 
+    """
+    try:
+        import math
+        # None or NaN -> empty
+        if v is None:
+            return ""
+        if isinstance(v, float) and math.isnan(v):
+            return ""
+        # Join list-like values into a single string
+        if isinstance(v, list):
+            try:
+                return " ".join("" if x is None else str(x).strip() for x in v).strip()
+            except Exception:
+                return str(v).strip()
+        # Default string conversion + strip
+        return str(v).strip()
+    except Exception:
+        # As a last resort, stringify
+        return f"{v}".strip()
+
 def create_prn_lookup(df_app):
+    """
+    Build a lookup from pure patient name (extracted from 'Patient Name') to PRN.
+    Both keys and values are normalized to robustly handle mixed cell types.
+    """
     prn_dict = {}
     for _, row in df_app.iterrows():
-        pure_name = extract_patient_name(row['Patient Name'])
-        if pure_name:
-            prn_dict[pure_name] = row['PRN']
+        # Normalize inputs
+        pn_raw = normalize_str(row.get('Patient Name', ''))
+        prn_raw = normalize_str(row.get('PRN', ''))
+        pure_name = extract_patient_name(pn_raw)
+        if pure_name and prn_raw:
+            prn_dict[pure_name] = prn_raw
     return prn_dict
 
-def get_email_list():
-    try:
-        with open('config/emails.conf', 'r') as f:
-            return [line.strip() for line in f if line.strip()]
-    except FileNotFoundError:
-        return []
-
 class GmailApiService:
     def __init__(self):
         self.sender_email = os.getenv('EMAIL_SENDER')
@@ -283,9 +306,8 @@ def status_page():
 @app.route('/process_and_initialize', methods=['POST'])
 def handle_file_processing_and_init():
     """
-    HTTP alternative for uploading files. Keeps backward compatibility.
-    Emits both 'data_processed' and 'data_processed_and_ready' for client compatibility.
-    Uses the provided file-handling logic.
+    HTTP alternative for uploading files (kept for compatibility).
+    Emits both 'data_processed' and 'data_processed_and_ready' for client alignment.
     """
     session_id = 'user_session'
     try:
@@ -295,43 +317,46 @@ def handle_file_processing_and_init():
             return jsonify({"error": "Both files are required."}), 400
 
         # Read files
-        app_data_file = request.files['app_data']
-        quantum_data_file = request.files['quantum_data']
-
         df_app = (
-            pd.read_excel(app_data_file)
-            if app_data_file.filename.lower().endswith('.xlsx')
-            else pd.read_csv(app_data_file)
+            pd.read_excel(request.files['app_data'])
+            if request.files['app_data'].filename.lower().endswith('.xlsx')
+            else pd.read_csv(request.files['app_data'])
         )
         df_quantum = (
-            pd.read_excel(quantum_data_file)
-            if quantum_data_file.filename.lower().endswith('.xlsx')
-            else pd.read_csv(quantum_data_file)
+            pd.read_excel(request.files['quantum_data'])
+            if request.files['quantum_data'].filename.lower().endswith('.xlsx')
+            else pd.read_csv(request.files['quantum_data'])
         )
 
         # Validations
         if 'Patient Name' not in df_app.columns or 'PRN' not in df_app.columns:
-            return jsonify({"error": "App Data file must contain 'Patient Name' and 'PRN' columns."}), 400
+            raise ValueError("App Data file must contain 'Patient Name' and 'PRN' columns.")
         if 'Name' not in df_quantum.columns:
-            return jsonify({"error": "Quantum Data file must contain a 'Name' column."}), 400
+            raise ValueError("Quantum Data file must contain a 'Name' column.")
 
-        # Filter and build lookup using provided logic
-        df_app_filtered = df_app.dropna(subset=['PRN'])
-        df_app_filtered = df_app_filtered[df_app_filtered['PRN'].astype(str).str.strip() != '']
-        prn_lookup_dict = create_prn_lookup(df_app_filtered)
+        # Filter out empty PRN rows using normalization (robust against lists/mixed types)
+        df_app['__PN'] = df_app['Patient Name'].apply(normalize_str)
+        df_app['__PRN'] = df_app['PRN'].apply(normalize_str)
+        df_app_filtered = df_app[df_app['__PRN'] != ""].copy()
 
-        # Map PRN for each Quantum name (case-sensitive, as provided)
-        df_quantum = df_quantum.copy()
-        df_quantum['PRN'] = [prn_lookup_dict.get(name, "") for name in df_quantum['Name']]
+        # Create lookup: pure name (from Patient Name) -> PRN, using provided logic pattern
+        prn_lookup_dict = create_prn_lookup(df_app_filtered.rename(columns={'__PN': 'Patient Name', '__PRN': 'PRN'}))
 
-        master_df = df_quantum.copy()
+        # Lookup PRN for each Quantum name (match as-is but normalized to avoid list issues)
+        df_quantum['__Name'] = df_quantum['Name'].apply(normalize_str)
+        prn_list = [prn_lookup_dict.get(n, "") for n in df_quantum['__Name']]
+
+        master_df = pd.DataFrame({
+            'Name': df_quantum['Name'],
+            'PRN': prn_list
+        })
         master_df['Status'] = ''
 
         data['patient_data_for_report'] = master_df
         data['patient_data'] = master_df.to_dict('records')
         session_data[session_id] = data
 
-        # Notify clients
+        # Notify clients (both names for safety with current frontend)
         socketio.emit('data_processed')
         socketio.emit('data_processed_and_ready')
 
@@ -364,7 +389,7 @@ def handle_init(data):
 def handle_process_and_initialize(payload):
     """
     NEW: Socket.IO path for the same workflow the UI currently uses.
-    Decodes base64 files, builds master DF using the provided logic, stores session, and emits 'data_processed_and_ready'.
+    Decodes base64 files, builds master DF via provided logic, stores session, and emits 'data_processed_and_ready'.
     """
     try:
         session_id = 'user_session'
@@ -374,7 +399,6 @@ def handle_process_and_initialize(payload):
             raw = base64.b64decode(file_obj['content'])
             if name.lower().endswith('.xlsx'):
                 return pd.read_excel(io.BytesIO(raw))
-            # CSV path
             text = raw.decode('utf-8', errors='replace')
             return pd.read_csv(io.StringIO(text))
 
@@ -389,16 +413,22 @@ def handle_process_and_initialize(payload):
             emit('error', {'message': "Quantum Data file must contain a 'Name' column."}, room=request.sid)
             return
 
-        # Filter and build lookup using provided logic
-        df_app_filtered = df_app.dropna(subset=['PRN'])
-        df_app_filtered = df_app_filtered[df_app_filtered['PRN'].astype(str).str.strip() != '']
-        prn_lookup_dict = create_prn_lookup(df_app_filtered)
+        # Filter out empty PRN rows using normalization (robust against lists/mixed types)
+        df_app['__PN'] = df_app['Patient Name'].apply(normalize_str)
+        df_app['__PRN'] = df_app['PRN'].apply(normalize_str)
+        df_app_filtered = df_app[df_app['__PRN'] != ""].copy()
+
+        # Create lookup: pure name (from Patient Name) -> PRN, using provided logic pattern
+        prn_lookup_dict = create_prn_lookup(df_app_filtered.rename(columns={'__PN': 'Patient Name', '__PRN': 'PRN'}))
 
-        # Map PRN for each Quantum name (case-sensitive, as provided)
-        df_quantum = df_quantum.copy()
-        df_quantum['PRN'] = [prn_lookup_dict.get(name, "") for name in df_quantum['Name']]
+        # Lookup PRN for each Quantum name (match as-is but normalized to avoid list issues)
+        df_quantum['__Name'] = df_quantum['Name'].apply(normalize_str)
+        prn_list = [prn_lookup_dict.get(n, "") for n in df_quantum['__Name']]
 
-        master_df = df_quantum.copy()
+        master_df = pd.DataFrame({
+            'Name': df_quantum['Name'],
+            'PRN': prn_list
+        })
         master_df['Status'] = ''
 
         # Persist session data (includes meta from payload)