add callback manager , model app

callbackmanager.py

@@ -4,6 +4,11 @@ from meldrx import MeldRxAPI
 import json
 import os
 
+import gradio as gr
+from meldrx import MeldRxAPI  
+import json
+import os
+
 class CallbackManager:
     def __init__(self, redirect_uri: str, client_secret: str = None):
         client_id = os.getenv("APPID")

meldrx.py

@@ -22,7 +22,7 @@ class MeldRxAPI:
         self.session = requests.Session()
 
     def _generate_code_verifier(self) -> str:
-        self.code_verifier = secrets.token_urlsafe(32)  # 43 characters, per PKCE spec
+        self.code_verifier = secrets.token_urlsafe(32)  # 43 characters
         return self.code_verifier
 
     def _generate_code_challenge(self, code_verifier: str) -> str:
@@ -43,7 +43,7 @@ class MeldRxAPI:
             token_data = response.json()
             self.access_token = token_data.get("access_token")
             if not self.access_token:
-                raise ValueError("No access token received from the server.")
+                raise ValueError("No access token received.")
             return True
         except requests.RequestException as e:
             print(f"Authentication failed: {e}")
@@ -107,7 +107,7 @@ class MeldRxAPI:
             token_data = response.json()
             self.access_token = token_data.get("access_token")
             if not self.access_token:
-                raise ValueError("No access token received from the server.")
+                raise ValueError("No access token received.")
             return True
         except requests.RequestException as e:
             print(f"Authentication failed: {e}")
@@ -115,96 +115,7 @@ class MeldRxAPI:
         except ValueError as e:
             print(f"Authentication error: {e}")
             return False
-
-    def _get_headers(self) -> Dict[str, str]:
-        """
-        Generate headers with the Bearer token for authenticated requests.
-
-        Returns:
-            Dict[str, str]: Headers dictionary with Authorization token if available.
-        """
-        headers = {"Content-Type": "application/json"}
-        if self.access_token:
-            headers["Authorization"] = f"Bearer {self.access_token}"
-        return headers
-
-    def get_patients(self) -> Optional[Dict[str, Any]]:
-        """
-        Retrieve a list of patients from the specified workspace (FHIR API).
-
-        Returns:
-            Optional[Dict[str, Any]]: Patient data as a dictionary if successful, None otherwise.
-        """
-        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_authorization_url(self, scope: str = "patient/*.read openid profile", state: str = "random_state") -> str:
-            """
-            Generate the SMART on FHIR authorization URL for patient login.
-
-            Args:
-                scope (str): The requested scopes (default: patient/*.read openid profile).
-                state (str): A random state string for security (default: random_state).
-
-            Returns:
-                str: The authorization URL to open in a browser.
-            """
-            params = {
-                "response_type": "code",
-                "client_id": self.client_id,
-                "redirect_uri": self.redirect_uri,
-                "scope": scope,
-                "state": state,
-                "aud": self.fhir_base_url
-            }
-            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.
-
-        Args:
-            auth_code (str): The authorization code from the redirect URI.
-
-        Returns:
-            bool: True if authentication is successful, False otherwise.
-        """
-        payload = {
-            "grant_type": "authorization_code",
-            "code": auth_code,
-            "redirect_uri": self.redirect_uri,
-            "client_id": self.client_id
-        }
-        if self.client_secret:
-            payload["client_secret"] = self.client_secret
-        headers = {"Content-Type": "application/x-www-form-urlencoded"}
-
-        try:
-            response = self.session.post(self.token_url, data=payload, headers=headers)
-            response.raise_for_status()
-            token_data = response.json()
-            self.access_token = token_data.get("access_token")
-            if not self.access_token:
-                raise ValueError("No access token received from the server.")
-            return True
-        except requests.RequestException as e:
-            print(f"Authentication failed: {e}")
-            return False
-        except ValueError as e:
-            print(f"Authentication error: {e}")
-            return False
     def create_virtual_workspace(self, snapshot: str = "patient-prefetch",
                                patient_id: str = "AutoPopulatedIfNotManuallySet",
                                hook: str = "patient-view") -> bool: