Grok Engineering, fingers crossed

utils/meldrx.py

@@ -59,18 +59,14 @@ class MeldRxAPI:
             headers["Authorization"] = f"Bearer {self.access_token}"
         return headers
 
-    def get_patients(self) -> Optional[Dict[str, Any]]:
-        url = f"{self.fhir_base_url}/Patient"
-        if not self.access_token and not self.authenticate():
-            print("Cannot proceed without authentication.")
-            return None
-        try:
-            response = self.session.get(url, headers=self._get_headers())
-            response.raise_for_status()
-            return response.json() if response.text else {}
-        except requests.RequestException as e:
-            print(f"Failed to retrieve patients: {e}")
-            return None
+    def get_patients(self):
+        # This should return the FHIR Bundle as per your sample output
+        headers = {"Authorization": f"Bearer {self.access_token}"}
+        response = requests.get(
+            f"https://app.meldrx.com/api/fhir/{self.workspace_id}/Patient",
+            headers=headers
+        )
+        return response.json() if response.status_code == 200 else None
 
     def get_authorization_url(self, scope: str = "patient/*.read openid profile", state: str = "random_state") -> str:
         code_verifier = self._generate_code_verifier()

utils/oneclick.py

@@ -91,63 +91,56 @@ def generate_discharge_paper_one_click(
 
         logger.info(f"Found {len(extractor.patients)} patients in the data")
         
-        matching_patients = []
-        all_patient_ids = []
-        all_patient_names = []
-        
+        matching_patient = None
+        patient_id_input = str(patient_id).strip().lower()
+        first_name_input = str(first_name).strip().lower()
+        last_name_input = str(last_name).strip().lower()
+
+        # Strict matching by patient_id first
         for i in range(len(extractor.patients)):
             extractor.set_patient_by_index(i)
             patient_data = extractor.get_patient_dict()
-            
             patient_id_from_data = str(patient_data.get('id', '')).strip().lower()
-            first_name_from_data = str(patient_data.get('first_name', '')).strip().lower()
-            last_name_from_data = str(patient_data.get('last_name', '')).strip().lower()
-            
-            all_patient_ids.append(patient_id_from_data)
-            all_patient_names.append(f"{first_name_from_data} {last_name_from_data}".strip())
-            
-            patient_id_input = str(patient_id).strip().lower()
-            first_name_input = str(first_name).strip().lower()
-            last_name_input = str(last_name).strip().lower()
             
-            logger.debug(f"Patient {i}: ID={patient_id_from_data}, Name={first_name_from_data} {last_name_from_data}")
-            logger.debug(f"Comparing - Input: ID={patient_id_input}, First={first_name_input}, Last={last_name_input}")
-            
-            # Match logic: ID takes precedence, then first/last name
-            matches = False
             if patient_id_input and patient_id_from_data == patient_id_input:
-                matches = True
-            elif not patient_id_input and first_name_input and last_name_input:
-                if first_name_input == first_name_from_data and last_name_input == last_name_from_data:
-                    matches = True
-            elif not patient_id_input and not first_name_input and not last_name_input:
-                continue  # Skip if no criteria provided
-            
-            if matches:
-                matching_patients.append(patient_data)
-                logger.info(f"Found matching patient: ID={patient_id_from_data}, "
-                           f"Name={first_name_from_data} {last_name_from_data}")
-
-        if not matching_patients:
+                matching_patient = patient_data
+                logger.info(f"Exact match found for patient ID: {patient_id_from_data}")
+                break
+
+        # Fallback to name-based matching if no ID match and names are provided
+        if not matching_patient and (first_name_input or last_name_input):
+            for i in range(len(extractor.patients)):
+                extractor.set_patient_by_index(i)
+                patient_data = extractor.get_patient_dict()
+                first_name_from_data = str(patient_data.get('first_name', '')).strip().lower()
+                last_name_from_data = str(patient_data.get('last_name', '')).strip().lower()
+                
+                if (first_name_input == first_name_from_data and 
+                    last_name_input == last_name_from_data):
+                    matching_patient = patient_data
+                    logger.info(f"Match found by name: {first_name_from_data} {last_name_from_data}")
+                    break
+
+        if not matching_patient:
             search_criteria = f"ID: {patient_id or 'N/A'}, First: {first_name or 'N/A'}, Last: {last_name or 'N/A'}"
+            all_patient_ids = [str(p.get('id', '')) for p in extractor.get_all_patients()]
+            all_patient_names = [f"{p.get('first_name', '')} {p.get('last_name', '')}".strip() 
+                               for p in extractor.get_all_patients()]
             logger.warning(f"No patients matched criteria: {search_criteria}")
-            logger.info(f"Available patient IDs: {all_patient_ids}")
-            logger.info(f"Available patient names: {all_patient_names}")
             return None, (f"No patients found matching criteria: {search_criteria}\n"
                          f"Available IDs: {', '.join(all_patient_ids)}\n"
                          f"Available Names: {', '.join(all_patient_names)}"), None, None, None
+
+        logger.info(f"Selected patient data: {matching_patient}")
         
-        patient_data = matching_patients[0]  # Take the first match
-        logger.info(f"Selected patient data: {patient_data}")
-        
-        basic_summary = format_discharge_summary(patient_data)
-        ai_summary, verified_summary = generate_ai_discharge_summary(patient_data, client)
+        basic_summary = format_discharge_summary(matching_patient)
+        ai_summary, verified_summary = generate_ai_discharge_summary(matching_patient, client)
         
         if not ai_summary or not verified_summary:
             return None, "Failed to generate or verify AI summary", basic_summary, None, None
             
         pdf_gen = PDFGenerator()
-        filename = f"discharge_{patient_data.get('id', 'unknown')}_{patient_data.get('last_name', 'patient')}.pdf"
+        filename = f"discharge_{matching_patient.get('id', 'unknown')}_{matching_patient.get('last_name', 'patient')}.pdf"
         pdf_path = pdf_gen.generate_pdf_from_text(ai_summary, filename)
         
         if pdf_path:

utils/responseparser.py

@@ -256,13 +256,24 @@ class PatientDataExtractor:
     def get_patient_dict(self) -> Dict[str, str]:
         """Return a dictionary of patient data mapped to discharge form fields."""
         data = self.get_all_patient_data()
+        
+        # Get the latest encounter for admission/discharge dates
         latest_encounter = data["encounters"][-1] if data["encounters"] else {}
+        admission_date = latest_encounter.get("start", "")
+        discharge_date = latest_encounter.get("end", "")
+        
+        # Get the latest condition for diagnosis
         latest_condition = data["conditions"][-1] if data["conditions"] else {}
-        medications_str = "; ".join([m["description"] for m in data["medications"] if m["description"]])
+        diagnosis = latest_condition.get("description", "")
+        
+        # Format medications as a string
+        medications_str = "; ".join([m["description"] for m in data["medications"] if m["description"]]) or "None specified"
+        
         return {
             "id": data["id"],
             "first_name": data["first_name"],
             "last_name": data["last_name"],
+            "name_prefix": data["name_prefix"],
             "dob": data["dob"],
             "age": data["age"],
             "sex": data["gender"],
@@ -271,17 +282,25 @@ class PatientDataExtractor:
             "state": data["state"],
             "zip_code": data["zip_code"],
             "phone": data["phone"],
-            "doctor_first_name": "",  # Could be extracted from Practitioner resource if available
+            "admission_date": admission_date,
+            "discharge_date": discharge_date,
+            "diagnosis": diagnosis,
+            "medications": medications_str,
+            "doctor_first_name": "",  # Could be extracted from Practitioner resource if linked
             "doctor_last_name": "",
-            "hospital_name": "",
+            "hospital_name": "",  # Could be extracted from Organization resource if linked
             "doctor_address": "",
             "doctor_city": "",
             "doctor_state": "",
             "doctor_zip": "",
-            "admission_date": latest_encounter.get("start", ""),
-            "discharge_date": latest_encounter.get("end", ""),
-            "diagnosis": latest_condition.get("description", ""),
-            "medications": medications_str if medications_str else "None specified",
+            "middle_initial": "",
+            "referral_source": "",
+            "admission_method": "",
+            "discharge_reason": "",
+            "date_of_death": "",
+            "procedures": "",
+            "preparer_name": "",
+            "preparer_job_title": ""
         }
 
     def get_all_patient_data(self) -> Dict[str, Union[str, List, Dict]]: