Attempt to fix, fingers crossed

callbackmanager.py

@@ -183,8 +183,8 @@ def process_fhir_bundle(fhir_bundle):
             patients.append(resource)
     return patients
 
-def create_patient_stripe(patient):
-    """Create a UI stripe for an individual patient with enhanced functionality"""
+def create_patient_stripe_data(patient):
+    """Extract data from patient to create a stripe (without components or event handlers)"""
     # Safely extract name components
     official_name = next(
         (n for n in patient.get("name", []) if n.get("use") == "official"),
@@ -204,75 +204,32 @@ def create_patient_stripe(patient):
     state = address.get("state", "")
     postal_code = address.get("postalCode", "")
 
-    with gr.Row(variant="panel") as stripe:
-        with gr.Column(scale=3):
-            gr.Markdown(f"""
-            **{given_names} {family_name}**  
-            *{gender} | Born: {birth_date}*  
-            {city}, {state} {postal_code}
-            """)
-            patient_id_box = gr.Textbox(patient_id, label="Patient ID", visible=False)
-        
-        with gr.Column(scale=1):
-            status = gr.Dropdown(
-                choices=["Pending", "Reviewed", "Approved", "Rejected"],
-                value="Pending",
-                label="Review Status"
-            )
-        
-        with gr.Column(scale=1):
-            generate_btn = gr.Button("Generate Report", visible=False)
-            probability = gr.Label("Risk Probability", visible=False)
-            documents_btn = gr.Button("View Documents", visible=True)
-            
-        doc_output = gr.JSON(label="Patient Documents", visible=False)
-
-    # Dynamic visibility and document handling
-    def update_components(selected_status):
-        visible = selected_status in ["Reviewed", "Approved"]
-        return (
-            {"visible": visible},  # For generate_btn
-            {"visible": visible, "value": {"Low": 0.3, "Medium": 0.6, "High": 0.9}.get(selected_status, 0.5)}  # For probability
-        )
-
-    def show_documents(patient_id):
-        docs = CALLBACK_MANAGER.get_patient_documents(patient_id)
-        return {"value": docs, "visible": True}  # For doc_output
-
-    status.change(
-        update_components,
-        inputs=status,
-        outputs=[generate_btn, probability]
-    )
-    
-    documents_btn.click(
-        fn=show_documents,
-        inputs=patient_id_box,
-        outputs=doc_output
-    )
-
-    return stripe
+    # Return structured data that can be used to display the patient info
+    return {
+        "name": f"{given_names} {family_name}",
+        "gender": gender,
+        "birth_date": birth_date,
+        "patient_id": patient_id,
+        "city": city,
+        "state": state,
+        "postal_code": postal_code
+    }
 
 def update_patient_display(patient_data_json):
     """
-    Update the patient display with parsed FHIR data
-    
-    Args:
-        patient_data_json: JSON string of FHIR patient data
-        
-    Returns:
-        Tuple of updates for the UI components
+    Update the patient display with parsed FHIR data.
+    Returns processed data without trying to update UI components directly.
     """
     try:
         # Handle the case where patient_data_json is an error message
         if isinstance(patient_data_json, str) and (patient_data_json.startswith("Not authenticated") or patient_data_json.startswith("Failed")):
             logger.warning(f"Error in patient data: {patient_data_json}")
-            return (
-                {"visible": False},  # For pagination_row
-                [],  # For patient_stripes
-                {"value": f"Error: {patient_data_json}"},  # For metadata_md
-                None  # For patient_data_state
-            )
+            return {
+                "has_pagination": False,
+                "patients": [],
+                "metadata": f"Error: {patient_data_json}",
+                "raw_data": None
+            }
         
         # Parse JSON if it's a string
         if isinstance(patient_data_json, str):
@@ -280,72 +237,147 @@ def update_patient_display(patient_data_json):
                 fhir_bundle = json.loads(patient_data_json)
             except json.JSONDecodeError as e:
                 logger.error(f"JSON decode error: {str(e)} - Data: {patient_data_json[:100]}...")
-                return (
-                    {"visible": False},
-                    [],
-                    {"value": f"Invalid JSON data: {str(e)}"},
-                    None
-                )
+                return {
+                    "has_pagination": False,
+                    "patients": [],
+                    "metadata": f"Invalid JSON data: {str(e)}",
+                    "raw_data": None
+                }
         else:
             fhir_bundle = patient_data_json
         
         # Safety check
         if not isinstance(fhir_bundle, dict):
             logger.error(f"Unexpected data type: {type(fhir_bundle)}")
-            return (
-                {"visible": False},
-                [],
-                {"value": f"Expected dictionary but got {type(fhir_bundle)}"},
-                None
-            )
+            return {
+                "has_pagination": False,
+                "patients": [],
+                "metadata": f"Expected dictionary but got {type(fhir_bundle)}",
+                "raw_data": None
+            }
             
         patients = process_fhir_bundle(fhir_bundle)
         
         if not patients:
             logger.warning("No patients found in data")
-            return (
-                {"visible": False},
-                [],
-                {"value": "No patients found in the data"},
-                None
-            )
+            return {
+                "has_pagination": False,
+                "patients": [],
+                "metadata": "No patients found in the data",
+                "raw_data": None
+            }
         
-        # Update pagination controls
+        # Check pagination
         has_prev = any(link.get("relation") == "previous" for link in fhir_bundle.get("link", []))
         has_next = any(link.get("relation") == "next" for link in fhir_bundle.get("link", []))
         
-        # Create stripes - handle list vs single patient
-        stripes = []
+        # Create patient data for display
+        patient_data_list = []
         for patient in patients:
             try:
-                stripe = create_patient_stripe(patient)
-                stripes.append(stripe)
+                patient_data = create_patient_stripe_data(patient)
+                patient_data_list.append(patient_data)
             except Exception as e:
-                logger.error(f"Error creating patient stripe: {str(e)}")
+                logger.error(f"Error processing patient data: {str(e)}")
                 # Continue with other patients if one fails
         
-        logger.info(f"Created {len(stripes)} patient stripes successfully")
+        logger.info(f"Processed {len(patient_data_list)} patients successfully")
         
-        return (
-            {"visible": has_prev or has_next},
-            stripes,
-            {"value": f"""
-            **Bundle Metadata**  
-            Type: {fhir_bundle.get('type', 'Unknown')}  
-            Total Patients: {fhir_bundle.get('total', len(patients))}  
-            Last Updated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
-            """},
-            {"patients": patients, "bundle": fhir_bundle}
-        )
+        # Generate metadata string
+        metadata_text = f"""
+        **Bundle Metadata**  
+        Type: {fhir_bundle.get('type', 'Unknown')}  
+        Total Patients: {fhir_bundle.get('total', len(patients))}  
+        Last Updated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+        """
+        
+        return {
+            "has_pagination": has_prev or has_next,
+            "patients": patient_data_list,
+            "metadata": metadata_text,
+            "raw_data": {"patients": patients, "bundle": fhir_bundle}
+        }
     except Exception as e:
         error_msg = f"Error loading patient data: {str(e)}\n{traceback.format_exc()}"
         logger.error(error_msg)
-        return (
-            {"visible": False},
-            [],
-            {"value": error_msg},
+        return {
+            "has_pagination": False,
+            "patients": [],
+            "metadata": error_msg,
+            "raw_data": None
+        }
+
+def fetch_and_display_patients():
+    try:
+        logger.info("Fetching patient data...")
+        # Get data from API
+        data = CALLBACK_MANAGER.get_patient_data()
+        logger.info(f"Received patient data: {data[:100]}..." if isinstance(data, str) else "Received non-string data")
+        
+        # Handle case when the data is just an error message
+        if data.startswith("Not authenticated") or data.startswith("Failed"):
+            logger.warning(f"Authentication issue: {data}")
+            processed_data = {
+                "has_pagination": False,
+                "patients": [],
+                "metadata": f"Error: {data}",
+                "raw_data": None
+            }
+        else:
+            # Process the results
+            try:
+                processed_data = update_patient_display(data)
+                logger.info("Successfully processed patient display data")
+            except Exception as e:
+                logger.error(f"Error in update_patient_display: {str(e)}\n{traceback.format_exc()}")
+                processed_data = {
+                    "has_pagination": False, 
+                    "patients": [],
+                    "metadata": f"Error processing patient data: {str(e)}",
+                    "raw_data": None
+                }
+        
+        # Return the raw JSON and processed data
+        return [
+            data,  # For the raw JSON output
+            processed_data["has_pagination"],  # Update pagination visibility
+            format_patient_html(processed_data["patients"]),  # HTML for patients
+            processed_data["metadata"],  # Metadata text
+            processed_data["raw_data"]  # State data
+        ]
+            
+    except Exception as e:
+        error_msg = f"Unexpected error fetching patient data: {str(e)}\n{traceback.format_exc()}"
+        logger.error(error_msg)
+        return [
+            f"Error: {str(e)}",
+            False,
+            "",
+            error_msg,
             None
-        )
+        ]
+
+def format_patient_html(patients):
+    """Format patient list as HTML for display in markdown component"""
+    if not patients:
+        return "No patients found."
+        
+    html = ""
+    for i, patient in enumerate(patients):
+        html += f"""
+        <div style="padding: 10px; margin: 10px 0; border: 1px solid #ccc; border-radius: 5px; background-color: #f9f9f9;">
+          <h3>{patient['name']}</h3>
+          <p>{patient['gender']} | Born: {patient['birth_date']}</p>
+          <p>{patient['city']}, {patient['state']} {patient['postal_code']}</p>
+          <p>ID: {patient['patient_id']}</p>
+          <hr/>
+          <div style="display: flex; justify-content: space-between;">
+            <span>Status: Pending Review</span>
+            <button onclick="alert('Documents for patient {patient['patient_id']}')">View Documents</button>
+          </div>
+        </div>
+        """
+    return html
 
 def generate_pdf_from_form(
     first_name, last_name, middle_initial, dob, age, sex, address, city, state, zip_code,
@@ -497,12 +529,12 @@ with gr.Blocks() as demo:
         patient_data_state = gr.State()
 
         # Pagination controls 
-        with gr.Row(visible=False) as pagination_row:
-            prev_btn = gr.Button("Previous Page")
-            next_btn = gr.Button("Next Page")
+        with gr.Row() as pagination_row:
+            prev_btn = gr.Button("Previous Page", visible=False)
+            next_btn = gr.Button("Next Page", visible=False)
         
-        # Patient stripes container
-        patient_stripes = gr.Column()
+        # Replace patient stripes with a single markdown component
+        patient_display = gr.HTML("No patient data loaded.")
         
         # Metadata display
         metadata_md = gr.Markdown()