add callback manager , model app

callbackmanager.py

@@ -1,3 +1,4 @@
+
 import gradio as gr
 from meldrx import MeldRxAPI  
 import json
@@ -7,10 +8,10 @@ class CallbackManager:
     def __init__(self, redirect_uri: str, client_secret: str = None):
         client_id = os.getenv("APPID")
         if not client_id:
-            raise ValueError("APPID environment variable not set. Please configure it in your Space secrets.")
+            raise ValueError("APPID environment variable not set.")
         workspace_id = os.getenv("WORKSPACE_URL")
         if not workspace_id:
-            raise ValueError("WORKSPACE_URL environment variable not set. Please configure it in your Space secrets.")
+            raise ValueError("WORKSPACE_URL environment variable not set.")
         self.api = MeldRxAPI(client_id, client_secret, workspace_id, redirect_uri)
         self.auth_code = None
         self.access_token = None
@@ -42,45 +43,27 @@ def display_form(
 ):
     form = f"""
     **Patient Discharge Form**
-    
-    **Patient Details:**
     - Name: {first_name} {middle_initial} {last_name}
     - Date of Birth: {dob}, Age: {age}, Sex: {sex}
     - Address: {address}, {city}, {state}, {zip_code}
-    
-    **Primary Healthcare Professional Details:**
-    - Name: {doctor_first_name} {doctor_middle_initial} {doctor_last_name}
+    - Doctor: {doctor_first_name} {doctor_middle_initial} {doctor_last_name}
     - Hospital/Clinic: {hospital_name}
-    - Address: {doctor_address}, {doctor_city}, {doctor_state}, {doctor_zip}
-    
-    **Admission and Discharge Details:**
-    - Date of Admission: {admission_date}
-    - Source of Referral: {referral_source}
-    - Method of Admission: {admission_method}
-    - Date of Discharge: {discharge_date}
-    - Discharge Reason: {discharge_reason}
-    - Date of Death (if applicable): {date_of_death}
-    
-    **Diagnosis & Procedures:**
+    - Doctor Address: {doctor_address}, {doctor_city}, {doctor_state}, {doctor_zip}
+    - Admission Date: {admission_date}, Source: {referral_source}, Method: {admission_method}
+    - Discharge Date: {discharge_date}, Reason: {discharge_reason}
+    - Date of Death: {date_of_death}
     - Diagnosis: {diagnosis}
     - Procedures: {procedures}
-    
-    **Medication Details:**
-    - Medications on Discharge: {medications}
-    
-    **Prepared By:**
-    - Name: {preparer_name}, Job Title: {preparer_job_title}
+    - Medications: {medications}
+    - Prepared By: {preparer_name}, {preparer_job_title}
     """
     return form
 
-# Initialize CallbackManager
 CALLBACK_MANAGER = CallbackManager(
     redirect_uri="https://multitransformer-discharge-guard.hf.space/callback",
-    client_secret=None  # Replace with actual secret if needed
+    client_secret=None
 )
 
-
-
 with gr.Blocks() as demo:
     gr.Markdown("# Patient Discharge Form with MeldRx Integration")
     with gr.Tab("Authenticate with MeldRx"):

meldrx.py

@@ -18,16 +18,14 @@ class MeldRxAPI:
         self.workspace_id = workspace_id
         self.redirect_uri = redirect_uri
         self.access_token = None
-        self.code_verifier = None  # Store the code_verifier for later use
+        self.code_verifier = None
         self.session = requests.Session()
 
     def _generate_code_verifier(self) -> str:
-        """Generate a random code_verifier string (43-128 characters)."""
-        self.code_verifier = secrets.token_urlsafe(32)  # Generates a 43-character safe string
+        self.code_verifier = secrets.token_urlsafe(32)  # 43 characters, per PKCE spec
         return self.code_verifier
 
     def _generate_code_challenge(self, code_verifier: str) -> str:
-        """Generate a code_challenge from the code_verifier using SHA-256."""
         sha256_hash = hashlib.sha256(code_verifier.encode('utf-8')).digest()
         code_challenge = base64.urlsafe_b64encode(sha256_hash).decode('utf-8').rstrip('=')
         return code_challenge
@@ -74,7 +72,6 @@ class MeldRxAPI:
             return None
 
     def get_authorization_url(self, scope: str = "patient/*.read openid profile", state: str = "random_state") -> str:
-        """Generate the SMART on FHIR authorization URL with PKCE."""
         code_verifier = self._generate_code_verifier()
         code_challenge = self._generate_code_challenge(code_verifier)
         params = {
@@ -85,13 +82,12 @@ class MeldRxAPI:
             "state": state,
             "aud": self.fhir_base_url,
             "code_challenge": code_challenge,
-            "code_challenge_method": "S256"  # MeldRx likely expects SHA-256
+            "code_challenge_method": "S256"
         }
         query_string = "&".join(f"{k}={v}" for k, v in params.items())
         return f"{self.authorize_url}?{query_string}"
 
     def authenticate_with_code(self, auth_code: str) -> bool:
-        """Exchange an authorization code for an access token, including the code_verifier."""
         if not self.code_verifier:
             print("Code verifier not set. Generate an authorization URL first.")
             return False
@@ -100,7 +96,7 @@ class MeldRxAPI:
             "code": auth_code,
             "redirect_uri": self.redirect_uri,
             "client_id": self.client_id,
-            "code_verifier": self.code_verifier  # Include the code_verifier
+            "code_verifier": self.code_verifier
         }
         if self.client_secret:
             payload["client_secret"] = self.client_secret