Update responseparser.py

responseparser.py

@@ -1,333 +1,421 @@
+import json
 import lxml.etree as etree
 from datetime import datetime
 from typing import List, Dict, Optional, Union
+import base64
 
 class PatientDataExtractor:
-    """Class to extract all fields from a FHIR Patient resource in a Bundle response (XML format)."""
+    """Class to extract fields from FHIR Patient Bundle (JSON) or C-CDA (XML)."""
     
-    def __init__(self, patient_data: str):
-        """Initialize with patient data in XML string format."""
-        # Parse XML string or use pre-parsed data
-        self.data = etree.fromstring(patient_data) if isinstance(patient_data, str) else patient_data
-        # Define FHIR namespace for XPath queries
-        self.ns = {'fhir': 'http://hl7.org/fhir'}
+    def __init__(self, patient_data: str, format_type: str = None):
+        """Initialize with patient data and optional format type."""
+        self.format = format_type.lower() if format_type else self._detect_format(patient_data)
+        if self.format == "xml":
+            self.data = etree.fromstring(patient_data.encode('utf-8')) if isinstance(patient_data, str) else patient_data
+            self.ns = {'hl7': 'urn:hl7-org:v3'}
+        elif self.format == "json":
+            self.data = json.loads(patient_data) if isinstance(patient_data, str) else patient_data
+        else:
+            raise ValueError("Unsupported format. Use 'xml' or 'json'")
+        
         self.patients = self._extract_patients()
-        self.current_patient_idx = 0  # Default to first patient
+        self.current_patient_idx = 0
+        
+    def _detect_format(self, data: str) -> str:
+        """Detect the format of the input data."""
+        if isinstance(data, str):
+            data = data.strip()
+            if data.startswith('<'):
+                return 'xml'
+            elif data.startswith('{') or data.startswith('['):
+                return 'json'
+        raise ValueError("Cannot determine data format")
         
-    def _extract_patients(self) -> List[etree._Element]:
-        """Extract all patient entries from the Bundle."""
-        # Use XPath to find all Patient elements in the Bundle
-        return self.data.xpath("//fhir:entry/fhir:resource/fhir:Patient", namespaces=self.ns)
+    def _extract_patients(self) -> List:
+        """Extract all patient entries based on format."""
+        if self.format == "xml":
+            return [self.data]  # C-CDA has one patient per document
+        elif self.format == "json":
+            if self.data.get("resourceType") != "Bundle" or "entry" not in self.data:
+                raise ValueError("Invalid FHIR Bundle format")
+            return [entry["resource"] for entry in self.data["entry"] if entry["resource"]["resourceType"] == "Patient"]
 
     def set_patient_by_index(self, index: int) -> bool:
-        """Set the current patient by index. Returns True if successful."""
+        """Set the current patient by index."""
         if 0 <= index < len(self.patients):
             self.current_patient_idx = index
             return True
         return False
 
-    def set_patient_by_id(self, patient_id: str) -> bool:
-        """Set the current patient by FHIR Patient ID. Returns True if successful."""
-        for i, patient in enumerate(self.patients):
-            if patient.attrib.get("id") == patient_id:
-                self.current_patient_idx = i
-                return True
-        return False
-
-    def _get_current_patient(self) -> etree._Element:
+    def _get_current_patient(self):
         """Get the currently selected patient resource."""
         return self.patients[self.current_patient_idx]
 
     # Basic Identification Fields
     def get_id(self) -> str:
-        """Extract FHIR Patient ID."""
-        return self._get_current_patient().attrib.get("id", "")
-
-    def get_resource_type(self) -> str:
-        """Extract resource type (should always be 'Patient')."""
-        return etree.QName(self._get_current_patient().tag).localname
-
-    def get_meta_last_updated(self) -> str:
-        """Extract last updated timestamp from meta."""
         patient = self._get_current_patient()
-        last_updated = patient.xpath("fhir:meta/fhir:lastUpdated/@value", namespaces=self.ns)
-        return last_updated[0] if last_updated else ""
+        if self.format == "xml":
+            id_list = patient.xpath("//hl7:recordTarget/hl7:patientRole/hl7:id/@extension", namespaces=self.ns)
+            return id_list[0] if id_list else ""
+        elif self.format == "json":
+            return patient.get("id", "")
 
-    def get_meta_profile(self) -> List[str]:
-        """Extract profile URIs from meta."""
+    def get_resource_type(self) -> str:
         patient = self._get_current_patient()
-        profiles = patient.xpath("fhir:meta/fhir:profile/@value", namespaces=self.ns)
-        return profiles
+        if self.format == "xml":
+            return "ClinicalDocument"
+        elif self.format == "json":
+            return patient.get("resourceType", "")
 
-    def get_text_div(self) -> str:
-        """Extract generated text narrative (div content)."""
+    def get_meta_last_updated(self) -> str:
         patient = self._get_current_patient()
-        div = patient.xpath("fhir:text/fhir:div", namespaces=self.ns)
-        if div:
-            return etree.tostring(div[0], encoding="unicode")
-        return ""
+        if self.format == "xml":
+            time_list = patient.xpath("//hl7:effectiveTime/@value", namespaces=self.ns)
+            return time_list[0] if time_list else ""
+        elif self.format == "json":
+            return patient.get("meta", {}).get("lastUpdated", "")
 
     # Name Fields
     def get_first_name(self) -> str:
-        """Extract patient's first name."""
         patient = self._get_current_patient()
-        official_names = patient.xpath("fhir:name[fhir:use/@value='official']", namespaces=self.ns)
-        if official_names:
-            given = official_names[0].xpath("fhir:given/@value", namespaces=self.ns)
-            if given:
-                return given[0]
+        if self.format == "xml":
+            given = patient.xpath("//hl7:recordTarget/hl7:patientRole/hl7:patient/hl7:name/hl7:given/text()", namespaces=self.ns)
+            return given[0] if given else ""
+        elif self.format == "json":
+            for name in patient.get("name", []):
+                if name.get("use") == "official" and "given" in name:
+                    return name["given"][0]
         return ""
 
     def get_last_name(self) -> str:
-        """Extract patient's last name."""
-        patient = self._get_current_patient()
-        official_names = patient.xpath("fhir:name[fhir:use/@value='official']", namespaces=self.ns)
-        if official_names:
-            family = official_names[0].xpath("fhir:family/@value", namespaces=self.ns)
-            if family:
-                return family[0]
-        return ""
-
-    def get_middle_initial(self) -> str:
-        """Extract patient's middle initial (second given name initial if present)."""
         patient = self._get_current_patient()
-        official_names = patient.xpath("fhir:name[fhir:use/@value='official']", namespaces=self.ns)
-        if official_names:
-            given = official_names[0].xpath("fhir:given/@value", namespaces=self.ns)
-            if len(given) > 1:
-                return given[1][0]
+        if self.format == "xml":
+            family = patient.xpath("//hl7:recordTarget/hl7:patientRole/hl7:patient/hl7:name/hl7:family/text()", namespaces=self.ns)
+            return family[0] if family else ""
+        elif self.format == "json":
+            for name in patient.get("name", []):
+                if name.get("use") == "official" and "family" in name:
+                    return name["family"]
         return ""
 
     def get_name_prefix(self) -> str:
-        """Extract patient's name prefix (e.g., Mr., Mrs.)."""
-        patient = self._get_current_patient()
-        official_names = patient.xpath("fhir:name[fhir:use/@value='official']", namespaces=self.ns)
-        if official_names:
-            prefix = official_names[0].xpath("fhir:prefix/@value", namespaces=self.ns)
-            if prefix:
-                return prefix[0]
-        return ""
-
-    def get_maiden_name(self) -> str:
-        """Extract patient's maiden name if available."""
         patient = self._get_current_patient()
-        maiden_names = patient.xpath("fhir:name[fhir:use/@value='maiden']", namespaces=self.ns)
-        if maiden_names:
-            family = maiden_names[0].xpath("fhir:family/@value", namespaces=self.ns)
-            if family:
-                return family[0]
+        if self.format == "xml":
+            prefix = patient.xpath("//hl7:recordTarget/hl7:patientRole/hl7:patient/hl7:name/hl7:prefix/text()", namespaces=self.ns)
+            return prefix[0] if prefix else ""
+        elif self.format == "json":
+            for name in patient.get("name", []):
+                if name.get("use") == "official" and "prefix" in name:
+                    return name["prefix"][0]
         return ""
 
     # Demographic Fields
     def get_dob(self) -> str:
-        """Extract patient's date of birth."""
         patient = self._get_current_patient()
-        dob = patient.xpath("fhir:birthDate/@value", namespaces=self.ns)
-        return dob[0] if dob else ""
+        if self.format == "xml":
+            dob = patient.xpath("//hl7:recordTarget/hl7:patientRole/hl7:patient/hl7:birthTime/@value", namespaces=self.ns)
+            return dob[0] if dob else ""
+        elif self.format == "json":
+            return patient.get("birthDate", "")
 
     def get_age(self) -> str:
-        """Calculate patient's age based on birth date."""
         dob = self.get_dob()
         if not dob:
             return ""
-        birth_date = datetime.strptime(dob, "%Y-%m-%d")
-        today = datetime.now()
-        age = today.year - birth_date.year - ((today.month, today.day) < (birth_date.month, birth_date.day))
-        return str(age)
+        try:
+            birth_date = datetime.strptime(dob[:8], "%Y%m%d")
+            today = datetime.now()
+            age = today.year - birth_date.year - ((today.month, today.day) < (birth_date.month, birth_date.day))
+            return str(age)
+        except ValueError:
+            return ""
 
     def get_gender(self) -> str:
-        """Extract patient's gender."""
-        patient = self._get_current_patient()
-        gender = patient.xpath("fhir:gender/@value", namespaces=self.ns)
-        return gender[0].capitalize() if gender else ""
-
-    def get_birth_sex(self) -> str:
-        """Extract patient's birth sex from extensions."""
         patient = self._get_current_patient()
-        birth_sex = patient.xpath("fhir:extension[@url='http://hl7.org/fhir/us/core/StructureDefinition/us-core-birthsex']/fhir:valueCode/@value", namespaces=self.ns)
-        return birth_sex[0] if birth_sex else ""
-
-    def get_multiple_birth(self) -> Union[bool, None]:
-        """Extract multiple birth status."""
-        patient = self._get_current_patient()
-        multiple_birth = patient.xpath("fhir:multipleBirthBoolean/@value", namespaces=self.ns)
-        return multiple_birth[0] == "true" if multiple_birth else None
+        if self.format == "xml":
+            gender = patient.xpath("//hl7:recordTarget/hl7:patientRole/hl7:patient/hl7:administrativeGenderCode/@code", namespaces=self.ns)
+            return "Male" if gender and gender[0] == "M" else "Female" if gender and gender[0] == "F" else ""
+        elif self.format == "json":
+            return patient.get("gender", "").capitalize()
 
     # Address Fields
     def get_address_line(self) -> str:
-        """Extract patient's street address."""
         patient = self._get_current_patient()
-        line = patient.xpath("fhir:address/fhir:line/@value", namespaces=self.ns)
-        return line[0] if line else ""
+        if self.format == "xml":
+            line = patient.xpath("//hl7:recordTarget/hl7:patientRole/hl7:addr/hl7:streetAddressLine/text()", namespaces=self.ns)
+            return line[0] if line else ""
+        elif self.format == "json":
+            addresses = patient.get("address", [])
+            return addresses[0]["line"][0] if addresses and "line" in addresses[0] else ""
 
     def get_city(self) -> str:
-        """Extract patient's city."""
         patient = self._get_current_patient()
-        city = patient.xpath("fhir:address/fhir:city/@value", namespaces=self.ns)
-        return city[0] if city else ""
+        if self.format == "xml":
+            city = patient.xpath("//hl7:recordTarget/hl7:patientRole/hl7:addr/hl7:city/text()", namespaces=self.ns)
+            return city[0] if city else ""
+        elif self.format == "json":
+            addresses = patient.get("address", [])
+            return addresses[0]["city"] if addresses and "city" in addresses[0] else ""
 
     def get_state(self) -> str:
-        """Extract patient's state."""
         patient = self._get_current_patient()
-        state = patient.xpath("fhir:address/fhir:state/@value", namespaces=self.ns)
-        return state[0] if state else ""
+        if self.format == "xml":
+            state = patient.xpath("//hl7:recordTarget/hl7:patientRole/hl7:addr/hl7:state/text()", namespaces=self.ns)
+            return state[0] if state else ""
+        elif self.format == "json":
+            addresses = patient.get("address", [])
+            return addresses[0]["state"] if addresses and "state" in addresses[0] else ""
 
     def get_zip_code(self) -> str:
-        """Extract patient's postal code."""
-        patient = self._get_current_patient()
-        postal_code = patient.xpath("fhir:address/fhir:postalCode/@value", namespaces=self.ns)
-        return postal_code[0] if postal_code else ""
-
-    def get_country(self) -> str:
-        """Extract patient's country."""
         patient = self._get_current_patient()
-        country = patient.xpath("fhir:address/fhir:country/@value", namespaces=self.ns)
-        return country[0] if country else ""
-
-    def get_geolocation(self) -> Dict[str, float]:
-        """Extract geolocation (latitude and longitude) from address extension."""
-        patient = self._get_current_patient()
-        lat = patient.xpath("fhir:address/fhir:extension[@url='http://hl7.org/fhir/StructureDefinition/geolocation']/fhir:extension[@url='latitude']/fhir:valueDecimal/@value", namespaces=self.ns)
-        lon = patient.xpath("fhir:address/fhir:extension[@url='http://hl7.org/fhir/StructureDefinition/geolocation']/fhir:extension[@url='longitude']/fhir:valueDecimal/@value", namespaces=self.ns)
-        return {
-            "latitude": float(lat[0]) if lat else None,
-            "longitude": float(lon[0]) if lon else None
-        }
+        if self.format == "xml":
+            zip = patient.xpath("//hl7:recordTarget/hl7:patientRole/hl7:addr/hl7:postalCode/text()", namespaces=self.ns)
+            return zip[0] if zip else ""
+        elif self.format == "json":
+            addresses = patient.get("address", [])
+            return addresses[0]["postalCode"] if addresses and "postalCode" in addresses[0] else ""
 
     # Contact Fields
     def get_phone(self) -> str:
-        """Extract patient's phone number."""
-        patient = self._get_current_patient()
-        phone = patient.xpath("fhir:telecom[fhir:system/@value='phone' and fhir:use/@value='home']/fhir:value/@value", namespaces=self.ns)
-        return phone[0] if phone else ""
-
-    # Identifiers
-    def get_identifiers(self) -> Dict[str, str]:
-        """Extract all identifiers (e.g., SSN, MRN, Driver's License)."""
         patient = self._get_current_patient()
-        id_dict = {}
-        identifiers = patient.xpath("fhir:identifier", namespaces=self.ns)
-        for id_entry in identifiers:
-            id_type = id_entry.xpath("fhir:type/fhir:text/@value", namespaces=self.ns)
-            id_value = id_entry.xpath("fhir:value/@value", namespaces=self.ns)
-            if id_type and id_value:
-                id_dict[id_type[0]] = id_value[0]
-        return id_dict
+        if self.format == "xml":
+            telecom = patient.xpath("//hl7:recordTarget/hl7:patientRole/hl7:telecom/@value", namespaces=self.ns)
+            return telecom[0].replace("tel:", "") if telecom and "tel:" in telecom[0] else ""
+        elif self.format == "json":
+            for telecom in patient.get("telecom", []):
+                if telecom.get("system") == "phone" and telecom.get("use") == "home":
+                    return telecom.get("value", "")
+        return ""
 
-    # Extensions
+    # Extensions and Additional Fields
     def get_race(self) -> str:
-        """Extract patient's race from extensions."""
         patient = self._get_current_patient()
-        race = patient.xpath("fhir:extension[@url='http://hl7.org/fhir/us/core/StructureDefinition/us-core-race']/fhir:extension[@url='text']/fhir:valueString/@value", namespaces=self.ns)
-        return race[0] if race else ""
+        if self.format == "xml":
+            race = patient.xpath("//hl7:recordTarget/hl7:patientRole/hl7:patient/hl7:raceCode/@displayName", namespaces=self.ns)
+            return race[0] if race else ""
+        elif self.format == "json":
+            for ext in patient.get("extension", []):
+                if ext.get("url") == "http://hl7.org/fhir/us/core/StructureDefinition/us-core-race":
+                    for sub_ext in ext.get("extension", []):
+                        if sub_ext.get("url") == "text":
+                            return sub_ext.get("valueString", "")
+        return ""
 
     def get_ethnicity(self) -> str:
-        """Extract patient's ethnicity from extensions."""
         patient = self._get_current_patient()
-        ethnicity = patient.xpath("fhir:extension[@url='http://hl7.org/fhir/us/core/StructureDefinition/us-core-ethnicity']/fhir:extension[@url='text']/fhir:valueString/@value", namespaces=self.ns)
-        return ethnicity[0] if ethnicity else ""
-
-    def get_mothers_maiden_name(self) -> str:
-        """Extract patient's mother's maiden name from extensions."""
-        patient = self._get_current_patient()
-        mothers_maiden = patient.xpath("fhir:extension[@url='http://hl7.org/fhir/StructureDefinition/patient-mothersMaidenName']/fhir:valueString/@value", namespaces=self.ns)
-        return mothers_maiden[0] if mothers_maiden else ""
-
-    def get_birth_place(self) -> Dict[str, str]:
-        """Extract patient's birth place from extensions."""
-        patient = self._get_current_patient()
-        birth_place = patient.xpath("fhir:extension[@url='http://hl7.org/fhir/StructureDefinition/patient-birthPlace']/fhir:valueAddress", namespaces=self.ns)
-        if birth_place:
-            city = birth_place[0].xpath("fhir:city/@value", namespaces=self.ns)
-            state = birth_place[0].xpath("fhir:state/@value", namespaces=self.ns)
-            country = birth_place[0].xpath("fhir:country/@value", namespaces=self.ns)
-            return {
-                "city": city[0] if city else "",
-                "state": state[0] if state else "",
-                "country": country[0] if country else ""
-            }
-        return {"city": "", "state": "", "country": ""}
-
-    def get_disability_adjusted_life_years(self) -> Optional[float]:
-        """Extract disability-adjusted life years from extensions."""
-        patient = self._get_current_patient()
-        daly = patient.xpath("fhir:extension[@url='http://synthetichealth.github.io/synthea/disability-adjusted-life-years']/fhir:valueDecimal/@value", namespaces=self.ns)
-        return float(daly[0]) if daly else None
-
-    def get_quality_adjusted_life_years(self) -> Optional[float]:
-        """Extract quality-adjusted life years from extensions."""
-        patient = self._get_current_patient()
-        qaly = patient.xpath("fhir:extension[@url='http://synthetichealth.github.io/synthea/quality-adjusted-life-years']/fhir:valueDecimal/@value", namespaces=self.ns)
-        return float(qaly[0]) if qaly else None
-
-    # Marital Status
-    def get_marital_status(self) -> str:
-        """Extract patient's marital status."""
-        patient = self._get_current_patient()
-        status = patient.xpath("fhir:maritalStatus/fhir:text/@value", namespaces=self.ns)
-        if status:
-            return status[0]
-        coding = patient.xpath("fhir:maritalStatus/fhir:coding/fhir:display/@value", namespaces=self.ns)
-        return coding[0] if coding else ""
+        if self.format == "xml":
+            ethnicity = patient.xpath("//hl7:recordTarget/hl7:patientRole/hl7:patient/hl7:ethnicGroupCode/@displayName", namespaces=self.ns)
+            return ethnicity[0] if ethnicity else ""
+        elif self.format == "json":
+            for ext in patient.get("extension", []):
+                if ext.get("url") == "http://hl7.org/fhir/us/core/StructureDefinition/us-core-ethnicity":
+                    for sub_ext in ext.get("extension", []):
+                        if sub_ext.get("url") == "text":
+                            return sub_ext.get("valueString", "")
+        return ""
 
-    # Communication
     def get_language(self) -> str:
-        """Extract patient's preferred language."""
         patient = self._get_current_patient()
-        language = patient.xpath("fhir:communication/fhir:language/fhir:text/@value", namespaces=self.ns)
-        return language[0] if language else ""
+        if self.format == "xml":
+            lang = patient.xpath("//hl7:recordTarget/hl7:patientRole/hl7:patient/hl7:languageCommunication/hl7:languageCode/@code", namespaces=self.ns)
+            return lang[0] if lang else ""
+        elif self.format == "json":
+            comms = patient.get("communication", [])
+            return comms[0]["language"]["text"] if comms and "language" in comms[0] else ""
+
+    # Medications
+    def get_medications(self) -> List[Dict[str, str]]:
+        if self.format == "xml":
+            section = self.data.xpath("//hl7:section[hl7:code/@code='10160-0']", namespaces=self.ns)
+            if not section:
+                return []
+            meds = section[0].xpath(".//hl7:substanceAdministration", namespaces=self.ns)
+            result = []
+            for med in meds:
+                start_list = med.xpath(".//hl7:effectiveTime/hl7:low/@value", namespaces=self.ns)
+                start = start_list[0] if start_list else ""
+                stop_list = med.xpath(".//hl7:effectiveTime/hl7:high/@value", namespaces=self.ns)
+                stop = stop_list[0] if stop_list else ""  # Safely handle missing <high>
+                desc_list = med.xpath(".//hl7:manufacturedMaterial/hl7:code/@displayName", namespaces=self.ns)
+                desc = desc_list[0] if desc_list else ""
+                code_list = med.xpath(".//hl7:manufacturedMaterial/hl7:code/@code", namespaces=self.ns)
+                code = code_list[0] if code_list else ""
+                result.append({"start": start, "stop": stop, "description": desc, "code": code})
+            return result
+        elif self.format == "json":
+            entries = self.data.get("entry", [])
+            result = []
+            for entry in entries:
+                if entry["resource"]["resourceType"] == "MedicationRequest":
+                    med = entry["resource"]
+                    start = med.get("authoredOn", "")
+                    stop = med.get("dispenseRequest", {}).get("validityPeriod", {}).get("end", "")
+                    desc = med.get("medicationCodeableConcept", {}).get("text", "")
+                    code = med.get("medicationCodeableConcept", {}).get("coding", [{}])[0].get("code", "")
+                    result.append({"start": start, "stop": stop, "description": desc, "code": code})
+            return result
+
+    # Encounters
+    def get_encounters(self) -> List[Dict[str, str]]:
+        if self.format == "xml":
+            service = self.data.xpath("//hl7:documentationOf/hl7:serviceEvent", namespaces=self.ns)
+            if not service:
+                return []
+            start_list = service[0].xpath(".//hl7:effectiveTime/hl7:low/@value", namespaces=self.ns)
+            start = start_list[0] if start_list else ""
+            end_list = service[0].xpath(".//hl7:effectiveTime/hl7:high/@value", namespaces=self.ns)
+            end = end_list[0] if end_list else ""
+            return [{"start": start, "end": end, "description": "Patient Care", "code": ""}]
+        elif self.format == "json":
+            entries = self.data.get("entry", [])
+            result = []
+            for entry in entries:
+                if entry["resource"]["resourceType"] == "Encounter":
+                    enc = entry["resource"]
+                    start = enc.get("period", {}).get("start", "")
+                    end = enc.get("period", {}).get("end", "")
+                    desc = enc.get("type", [{}])[0].get("text", "")
+                    code = enc.get("type", [{}])[0].get("coding", [{}])[0].get("code", "")
+                    result.append({"start": start, "end": end, "description": desc, "code": code})
+            return result
+
+    # Conditions/Diagnoses
+    def get_conditions(self) -> List[Dict[str, str]]:
+        if self.format == "xml":
+            section = self.data.xpath("//hl7:section[hl7:code/@code='11450-4']", namespaces=self.ns)
+            if not section:
+                return []
+            entries = section[0].xpath(".//hl7:entry/hl7:act/hl7:entryRelationship/hl7:observation", namespaces=self.ns) if section else []
+            result = []
+            for entry in entries:
+                onset_list = entry.xpath(".//hl7:effectiveTime/hl7:low/@value", namespaces=self.ns)
+                onset = onset_list[0] if onset_list else ""
+                desc_list = entry.xpath(".//hl7:value/@displayName", namespaces=self.ns)
+                desc = desc_list[0] if desc_list else ""
+                code_list = entry.xpath(".//hl7:value/@code", namespaces=self.ns)
+                code = code_list[0] if code_list else ""
+                result.append({"onset": onset, "description": desc, "code": code})
+            return result
+        elif self.format == "json":
+            entries = self.data.get("entry", [])
+            result = []
+            for entry in entries:
+                if entry["resource"]["resourceType"] == "Condition":
+                    cond = entry["resource"]
+                    onset = cond.get("onsetDateTime", "")
+                    desc = cond.get("code", {}).get("text", "")
+                    code = cond.get("code", {}).get("coding", [{}])[0].get("code", "")
+                    result.append({"onset": onset, "description": desc, "code": code})
+            return result
+
+    # Immunizations
+    def get_immunizations(self) -> List[Dict[str, str]]:
+        if self.format == "xml":
+            section = self.data.xpath("//hl7:section[hl7:code/@code='11369-6']", namespaces=self.ns)
+            if not section:
+                return []
+            immunizations = section[0].xpath(".//hl7:substanceAdministration", namespaces=self.ns)
+            result = []
+            for imm in immunizations:
+                date_list = imm.xpath(".//hl7:effectiveTime/@value", namespaces=self.ns)
+                date = date_list[0] if date_list else ""
+                desc_list = imm.xpath(".//hl7:consumable/hl7:manufacturedProduct/hl7:manufacturedMaterial/hl7:code/@displayName", namespaces=self.ns)
+                desc = desc_list[0] if desc_list else ""
+                code_list = imm.xpath(".//hl7:consumable/hl7:manufacturedProduct/hl7:manufacturedMaterial/hl7:code/@code", namespaces=self.ns)
+                code = code_list[0] if code_list else ""
+                result.append({"date": date, "description": desc, "code": code})
+            return result
+        elif self.format == "json":
+            entries = self.data.get("entry", [])
+            result = []
+            for entry in entries:
+                if entry["resource"]["resourceType"] == "Immunization":
+                    imm = entry["resource"]
+                    date = imm.get("occurrenceDateTime", "")
+                    desc = imm.get("vaccineCode", {}).get("text", "")
+                    code = imm.get("vaccineCode", {}).get("coding", [{}])[0].get("code", "")
+                    result.append({"date": date, "description": desc, "code": code})
+            return result
+
+    # Diagnostic Reports
+    def get_diagnostic_reports(self) -> List[Dict[str, str]]:
+        if self.format == "xml":
+            section = self.data.xpath("//hl7:section[hl7:code/@code='30954-2']", namespaces=self.ns)
+            if not section:
+                return []
+            reports = section[0].xpath(".//hl7:organizer", namespaces=self.ns)
+            result = []
+            for report in reports:
+                start_list = report.xpath(".//hl7:effectiveTime/hl7:low/@value", namespaces=self.ns)
+                start = start_list[0] if start_list else ""
+                desc_list = report.xpath(".//hl7:code/@displayName", namespaces=self.ns)
+                desc = desc_list[0] if desc_list else ""
+                code_list = report.xpath(".//hl7:code/@code", namespaces=self.ns)
+                code = code_list[0] if code_list else ""
+                result.append({"start": start, "description": desc, "code": code})
+            return result
+        elif self.format == "json":
+            entries = self.data.get("entry", [])
+            result = []
+            for entry in entries:
+                if entry["resource"]["resourceType"] == "DiagnosticReport":
+                    report = entry["resource"]
+                    start = report.get("effectiveDateTime", "")
+                    desc = report.get("code", {}).get("text", "")
+                    code = report.get("code", {}).get("coding", [{}])[0].get("code", "")
+                    data = report.get("presentedForm", [{}])[0].get("data", "")
+                    if data:
+                        decoded = base64.b64decode(data).decode('utf-8')
+                        result.append({"start": start, "description": desc, "code": code, "content": decoded})
+                    else:
+                        result.append({"start": start, "description": desc, "code": code})
+            return result
 
     # Comprehensive Extraction
-    def get_all_patient_data(self) -> Dict[str, Union[str, Dict, List, float, bool, None]]:
+    def get_all_patient_data(self) -> Dict[str, Union[str, List, Dict]]:
         """Extract all available data for the current patient."""
         return {
             "id": self.get_id(),
             "resource_type": self.get_resource_type(),
             "meta_last_updated": self.get_meta_last_updated(),
-            "meta_profile": self.get_meta_profile(),
-            "text_div": self.get_text_div(),
             "first_name": self.get_first_name(),
             "last_name": self.get_last_name(),
-            "middle_initial": self.get_middle_initial(),
             "name_prefix": self.get_name_prefix(),
-            "maiden_name": self.get_maiden_name(),
             "dob": self.get_dob(),
             "age": self.get_age(),
             "gender": self.get_gender(),
-            "birth_sex": self.get_birth_sex(),
-            "multiple_birth": self.get_multiple_birth(),
             "address_line": self.get_address_line(),
             "city": self.get_city(),
             "state": self.get_state(),
             "zip_code": self.get_zip_code(),
-            "country": self.get_country(),
-            "geolocation": self.get_geolocation(),
             "phone": self.get_phone(),
-            "identifiers": self.get_identifiers(),
             "race": self.get_race(),
             "ethnicity": self.get_ethnicity(),
-            "mothers_maiden_name": self.get_mothers_maiden_name(),
-            "birth_place": self.get_birth_place(),
-            "disability_adjusted_life_years": self.get_disability_adjusted_life_years(),
-            "quality_adjusted_life_years": self.get_quality_adjusted_life_years(),
-            "marital_status": self.get_marital_status(),
-            "language": self.get_language()
+            "language": self.get_language(),
+            "medications": self.get_medications(),
+            "encounters": self.get_encounters(),
+            "conditions": self.get_conditions(),
+            "immunizations": self.get_immunizations(),
+            "diagnostic_reports": self.get_diagnostic_reports()
         }
 
     def get_patient_dict(self) -> Dict[str, str]:
-        """Return a dictionary of patient data mapped to discharge form fields (for app.py compatibility)."""
-        patient_data = self.get_all_patient_data()
+        """Return a dictionary of patient data mapped to discharge form fields."""
+        data = self.get_all_patient_data()
+        latest_encounter = data["encounters"][-1] if data["encounters"] else {}
+        latest_condition = data["conditions"][-1] if data["conditions"] else {}
+        medications_str = "; ".join([m["description"] for m in data["medications"]])
         return {
-            "first_name": patient_data["first_name"],
-            "last_name": patient_data["last_name"],
-            "middle_initial": patient_data["middle_initial"],
-            "dob": patient_data["dob"],
-            "age": patient_data["age"],
-            "sex": patient_data["gender"],
-            "address": patient_data["address_line"],
-            "city": patient_data["city"],
-            "state": patient_data["state"],
-            "zip_code": patient_data["zip_code"],
+            "first_name": data["first_name"],
+            "last_name": data["last_name"],
+            "middle_initial": "",
+            "dob": data["dob"],
+            "age": data["age"],
+            "sex": data["gender"],
+            "address": data["address_line"],
+            "city": data["city"],
+            "state": data["state"],
+            "zip_code": data["zip_code"],
             "doctor_first_name": "",
             "doctor_last_name": "",
             "doctor_middle_initial": "",
@@ -336,21 +424,21 @@ class PatientDataExtractor:
             "doctor_city": "",
             "doctor_state": "",
             "doctor_zip": "",
-            "admission_date": "",
+            "admission_date": latest_encounter.get("start", ""),
             "referral_source": "",
             "admission_method": "",
-            "discharge_date": "",
+            "discharge_date": latest_encounter.get("end", ""),
             "discharge_reason": "",
             "date_of_death": "",
-            "diagnosis": "",
+            "diagnosis": latest_condition.get("description", ""),
             "procedures": "",
-            "medications": "",
+            "medications": medications_str,
             "preparer_name": "",
             "preparer_job_title": ""
         }
 
     def get_all_patients(self) -> List[Dict[str, str]]:
-        """Return a list of dictionaries for all patients (for app.py)."""
+        """Return a list of dictionaries for all patients."""
         original_idx = self.current_patient_idx
         all_patients = []
         for i in range(len(self.patients)):
@@ -360,113 +448,6 @@ class PatientDataExtractor:
         return all_patients
 
     def get_patient_ids(self) -> List[str]:
-        """Return a list of all patient IDs in the Bundle."""
-        return [patient.attrib.get("id", "") for patient in self.patients]
-
-# # Example usage with integration into app.py
-# def integrate_with_app(patient_data: str):
-#     """Integrate PatientDataExtractor with the Gradio app."""
-#     extractor = PatientDataExtractor(patient_data)
-    
-#     # Function to populate form with selected patient's data
-#     def populate_form(patient_id: str):
-#         if extractor.set_patient_by_id(patient_id):
-#             patient_dict = extractor.get_patient_dict()
-#             return list(patient_dict.values())  # Return values in order expected by display_form
-#         return [""] * 28  # Return empty values if patient not found
-
-#     # Modify the Gradio app to include patient selection
-#     with gr.Blocks() as demo:
-#         gr.Markdown("# Patient Discharge Form with MeldRx Integration")
-#         with gr.Tab("Authenticate with MeldRx"):
-#             gr.Markdown("## SMART on FHIR Authentication")
-#             auth_url_output = gr.Textbox(label="Authorization URL", value=CALLBACK_MANAGER.get_auth_url(), interactive=False)
-#             gr.Markdown("Copy the URL above, open it in a browser, log in, and paste the 'code' from the redirect URL below.")
-#             auth_code_input = gr.Textbox(label="Authorization Code")
-#             auth_submit = gr.Button("Submit Code")
-#             auth_result = gr.Textbox(label="Authentication Result")
-#             patient_data_button = gr.Button("Fetch Patient Data")
-#             patient_data_output = gr.Textbox(label="Patient Data")
-#             auth_submit.click(fn=CALLBACK_MANAGER.set_auth_code, inputs=auth_code_input, outputs=auth_result)
-#             patient_data_button.click(fn=CALLBACK_MANAGER.get_patient_data, inputs=None, outputs=patient_data_output)
-        
-#         with gr.Tab("Discharge Form"):
-#             gr.Markdown("## Select Patient")
-#             patient_dropdown = gr.Dropdown(choices=extractor.get_patient_ids(), label="Select Patient ID")
-#             populate_button = gr.Button("Populate Form with Patient Data")
-            
-#             gr.Markdown("## Patient Details")
-#             with gr.Row():
-#                 first_name = gr.Textbox(label="First Name")
-#                 last_name = gr.Textbox(label="Last Name")
-#                 middle_initial = gr.Textbox(label="Middle Initial")
-#             with gr.Row():
-#                 dob = gr.Textbox(label="Date of Birth")
-#                 age = gr.Textbox(label="Age")
-#                 sex = gr.Textbox(label="Sex")
-#             address = gr.Textbox(label="Address")
-#             with gr.Row():
-#                 city = gr.Textbox(label="City")
-#                 state = gr.Textbox(label="State")
-#                 zip_code = gr.Textbox(label="Zip Code")
-#             gr.Markdown("## Primary Healthcare Professional Details")
-#             with gr.Row():
-#                 doctor_first_name = gr.Textbox(label="Doctor's First Name")
-#                 doctor_last_name = gr.Textbox(label="Doctor's Last Name")
-#                 doctor_middle_initial = gr.Textbox(label="Middle Initial")
-#             hospital_name = gr.Textbox(label="Hospital/Clinic Name")
-#             doctor_address = gr.Textbox(label="Address")
-#             with gr.Row():
-#                 doctor_city = gr.Textbox(label="City")
-#                 doctor_state = gr.Textbox(label="State")
-#                 doctor_zip = gr.Textbox(label="Zip Code")
-#             gr.Markdown("## Admission and Discharge Details")
-#             with gr.Row():
-#                 admission_date = gr.Textbox(label="Date of Admission")
-#                 referral_source = gr.Textbox(label="Source of Referral")
-#             admission_method = gr.Textbox(label="Method of Admission")
-#             with gr.Row():
-#                 discharge_date = gr.Textbox(label="Date of Discharge")
-#                 discharge_reason = gr.Radio(["Treated", "Transferred", "Discharge Against Advice", "Patient Died"], label="Discharge Reason")
-#             date_of_death = gr.Textbox(label="Date of Death (if applicable)")
-#             gr.Markdown("## Diagnosis & Procedures")
-#             diagnosis = gr.Textbox(label="Diagnosis")
-#             procedures = gr.Textbox(label="Operation & Procedures")
-#             gr.Markdown("## Medication Details")
-#             medications = gr.Textbox(label="Medication on Discharge")
-#             gr.Markdown("## Prepared By")
-#             with gr.Row():
-#                 preparer_name = gr.Textbox(label="Name")
-#                 preparer_job_title = gr.Textbox(label="Job Title")
-#             submit = gr.Button("Generate Form")
-#             output = gr.Markdown()
-
-#             # Inputs list for populate_form and display_form
-#             inputs_list = [
-#                 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,
-#                 doctor_city, doctor_state, doctor_zip,
-#                 admission_date, referral_source, admission_method, discharge_date, discharge_reason, date_of_death,
-#                 diagnosis, procedures, medications, preparer_name, preparer_job_title
-#             ]
-
-#             # Populate form with patient data when button is clicked
-#             populate_button.click(
-#                 fn=populate_form,
-#                 inputs=patient_dropdown,
-#                 outputs=inputs_list
-#             )
-
-#             # Generate the form output
-#             submit.click(
-#                 display_form,
-#                 inputs=inputs_list,
-#                 outputs=output
-#             )
-
-#     return demo
+        """Return a list of all patient IDs."""
+        return [self.get_id() for _ in self.patients]
 
-# # Assuming patient_data is the JSON string from your example
-# # patient_data = <your JSON string here>
-# # demo = integrate_with_app(patient_data)
-# # demo.launch()