If this doesn't work gotta rollback

callbackmanager.py

@@ -163,222 +163,8 @@ def display_form(
     - Medications: {medications}
     - Prepared By: {preparer_name}, {preparer_job_title}
     """
-
-    
     return form
 
-def process_fhir_bundle(fhir_bundle):
-    """Extract and structure patient data from FHIR bundle"""
-    patients = []
-    if not isinstance(fhir_bundle, dict):
-        # Try to parse the data if it's a string
-        try:
-            fhir_bundle = json.loads(fhir_bundle)
-        except:
-            return []
-            
-    for entry in fhir_bundle.get("entry", []):
-        resource = entry.get("resource", {})
-        if resource.get("resourceType") == "Patient":
-            patients.append(resource)
-    return patients
-
-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"),
-        next((n for n in patient.get("name", [])), {})  # Fallback to first name if no official
-    )
-    given_names = " ".join(official_name.get("given", ["Unknown"]))
-    family_name = official_name.get("family", "Unknown")
-    
-    # Extract demographic information
-    gender = patient.get("gender", "unknown").capitalize()
-    birth_date = patient.get("birthDate", "Unknown")
-    patient_id = patient.get("id", "Unknown")
-    
-    # Extract address information
-    address = patient.get("address", [{}])[0] if patient.get("address") else {}
-    city = address.get("city", "Unknown")
-    state = address.get("state", "")
-    postal_code = address.get("postalCode", "")
-
-    # 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.
-    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 {
-                "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):
-            try:
-                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 {
-                    "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 {
-                "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 {
-                "has_pagination": False,
-                "patients": [],
-                "metadata": "No patients found in the data",
-                "raw_data": None
-            }
-        
-        # 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 patient data for display
-        patient_data_list = []
-        for patient in patients:
-            try:
-                patient_data = create_patient_stripe_data(patient)
-                patient_data_list.append(patient_data)
-            except Exception as e:
-                logger.error(f"Error processing patient data: {str(e)}")
-                # Continue with other patients if one fails
-        
-        logger.info(f"Processed {len(patient_data_list)} patients successfully")
-        
-        # 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 {
-            "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,
     doctor_first_name, doctor_last_name, doctor_middle_initial, hospital_name, doctor_address,
@@ -494,13 +280,13 @@ def generate_pdf_from_meldrx(patient_data):
     except Exception as e:
         return None, f"Error generating PDF: {str(e)}"
 
+# Create a simplified interface to avoid complex component interactions
 CALLBACK_MANAGER = CallbackManager(
     redirect_uri="https://multitransformer-discharge-guard.hf.space/callback",
     client_secret=None
 )
 
-
-
+# Create the UI
 with gr.Blocks() as demo:
     gr.Markdown("# Patient Discharge Form with MeldRx Integration")
     
@@ -513,7 +299,7 @@ with gr.Blocks() as demo:
         auth_result = gr.Textbox(label="Authentication Result")
         
         patient_data_button = gr.Button("Fetch Patient Data")
-        patient_data_output = gr.Textbox(label="Patient Data")
+        patient_data_output = gr.Textbox(label="Patient Data", lines=10)
         
         # Add button to generate PDF from MeldRx data
         meldrx_pdf_button = gr.Button("Generate PDF from MeldRx Data")
@@ -521,26 +307,58 @@ with gr.Blocks() as demo:
         meldrx_pdf_download = gr.File(label="Download Generated PDF")
         
         auth_submit.click(fn=CALLBACK_MANAGER.set_auth_code, inputs=auth_code_input, outputs=auth_result)
+    
+    with gr.Tab("Patient Dashboard"):
+        gr.Markdown("## Patient Data")
+        dashboard_output = gr.HTML("<p>Fetch patient data from the Authentication tab first.</p>")
         
-    with gr.Tab("Show Patients Log"):
-        gr.Markdown("## Patient Dashboard")
-
-        # Store patient data in a state variable
-        patient_data_state = gr.State()
-
-        # Pagination controls 
-        with gr.Row() as pagination_row:
-            prev_btn = gr.Button("Previous Page", visible=False)
-            next_btn = gr.Button("Next Page", visible=False)
-        
-        # Replace patient stripes with a single markdown component
-        patient_display = gr.HTML("No patient data loaded.")
-        
-        # Metadata display
-        metadata_md = gr.Markdown()
-        
-        # Refresh button
         refresh_btn = gr.Button("Refresh Data")
+        
+        # Simple function to update dashboard based on fetched data
+        def update_dashboard():
+            try:
+                data = CALLBACK_MANAGER.get_patient_data()
+                if data.startswith("Not authenticated") or data.startswith("Failed") or data.startswith("Error"):
+                    return f"<p>{data}</p>"
+                    
+                try:
+                    # Parse the data
+                    patients_data = json.loads(data)
+                    patients = []
+                    
+                    # Extract patients from bundle
+                    for entry in patients_data.get("entry", []):
+                        resource = entry.get("resource", {})
+                        if resource.get("resourceType") == "Patient":
+                            patients.append(resource)
+                    
+                    # Generate HTML for each patient
+                    html = "<h3>Patients</h3>"
+                    for patient in patients:
+                        # Extract name
+                        name = patient.get("name", [{}])[0]
+                        given = " ".join(name.get("given", ["Unknown"]))
+                        family = name.get("family", "Unknown")
+                        
+                        # Extract other details
+                        gender = patient.get("gender", "unknown").capitalize()
+                        birth_date = patient.get("birthDate", "Unknown")
+                        
+                        # Generate HTML card
+                        html += f"""
+                        <div style="border: 1px solid #ddd; padding: 10px; margin: 10px 0; border-radius: 5px;">
+                            <h4>{given} {family}</h4>
+                            <p><strong>Gender:</strong> {gender}</p>
+                            <p><strong>Birth Date:</strong> {birth_date}</p>
+                            <p><strong>ID:</strong> {patient.get("id", "Unknown")}</p>
+                        </div>
+                        """
+                    
+                    return html
+                except Exception as e:
+                    return f"<p>Error parsing patient data: {str(e)}</p>"
+            except Exception as e:
+                return f"<p>Error fetching patient data: {str(e)}</p>"
     
     with gr.Tab("Discharge Form"):
         gr.Markdown("## Patient Details")
@@ -622,78 +440,33 @@ with gr.Blocks() as demo:
             outputs=pdf_output
         )
     
-    # Define a function to handle fetching and displaying patients with better error handling
-    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}")
-                return [
-                    data,  # For the raw JSON output
-                    {"visible": False},  # For pagination_row
-                    [],  # For patient_stripes
-                    {"value": f"Error: {data}"},  # For metadata_md
-                    None  # For patient_data_state
-                ]
-            
-            # Process the results for UI display
-            try:
-                pagination_update, stripes_update, metadata_update, state_update = update_patient_display(data)
-                logger.info("Successfully processed patient display data")
-                
-                return [
-                    data,  # For the raw JSON output
-                    pagination_update,
-                    stripes_update,
-                    metadata_update,
-                    state_update
-                ]
-            except Exception as e:
-                logger.error(f"Error in update_patient_display: {str(e)}\n{traceback.format_exc()}")
-                # Return at least the raw data, even if display processing fails
-                return [
-                    data,
-                    {"visible": False},
-                    [],
-                    {"value": f"Error processing patient data: {str(e)}"},
-                    None
-                ]
-                
-        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)}",
-                {"visible": False},
-                [],
-                {"value": error_msg},
-                None
-            ]
-
-    # Connect the patient data button to both display the raw JSON and update the patient display
+    # Connect the patient data buttons
     patient_data_button.click(
-        fn=fetch_and_display_patients,
+        fn=CALLBACK_MANAGER.get_patient_data,
         inputs=None,
-        outputs=[patient_data_output, pagination_row, patient_stripes, metadata_md, patient_data_state]
+        outputs=patient_data_output
     )
-        
+    
+    # Connect refresh button to update dashboard
+    refresh_btn.click(
+        fn=update_dashboard,
+        inputs=None,
+        outputs=dashboard_output
+    )
+    
     # Add functionality for PDF generation from MeldRx data
     meldrx_pdf_button.click(
         fn=generate_pdf_from_meldrx,
         inputs=patient_data_output,
         outputs=[meldrx_pdf_download, meldrx_pdf_status]
     )
-        
-    # Connect refresh button in patient log tab
-    refresh_btn.click(
-        fn=fetch_and_display_patients,
+    
+    # Connect patient data updates to dashboard
+    patient_data_button.click(
+        fn=update_dashboard,
         inputs=None,
-        outputs=[patient_data_output, pagination_row, patient_stripes, metadata_md, patient_data_state]
+        outputs=dashboard_output
     )
 
-demo.launch()
+# Launch with sharing enabled for public access
+demo.launch(share=True)