Update app.py

app.py

@@ -5,14 +5,16 @@ from api import api_router
 import gradio as gr
 import requests
 import logging
+import time
 
+# Configure logging
 logging.basicConfig(level=logging.DEBUG)
 logger = logging.getLogger(__name__)
 logger.debug("Initializing application")
 
 app = FastAPI()
 
-# CORS
+# CORS Configuration
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
@@ -23,6 +25,68 @@ app.add_middleware(
 
 app.include_router(api_router)
 
+# Constants
+BACKEND_URL = "https://rocketfarmstudios-cps-api.hf.space"
+ADMIN_EMAIL = "yakdhanali97@gmail.com"
+ADMIN_PASSWORD = "123456"
+MAX_TOKEN_RETRIES = 3
+TOKEN_RETRY_DELAY = 2  # seconds
+
+# Global token storage with refresh capability
+class TokenManager:
+    def __init__(self):
+        self.token = None
+        self.last_obtained = 0
+        self.token_expiry = 3600  # 1 hour default expiry
+
+    def get_token(self, force_refresh=False):
+        current_time = time.time()
+        
+        if not force_refresh and self.token and (current_time - self.last_obtained) < self.token_expiry:
+            return self.token
+            
+        for attempt in range(MAX_TOKEN_RETRIES):
+            try:
+                login_payload = {
+                    "username": ADMIN_EMAIL,
+                    "password": ADMIN_PASSWORD,
+                    "device_token": "admin-device-token"
+                }
+                
+                logger.debug(f"Attempting to obtain admin token (attempt {attempt + 1})")
+                res = requests.post(
+                    f"{BACKEND_URL}/auth/login",
+                    json=login_payload,
+                    timeout=10
+                )
+                
+                if res.status_code == 200:
+                    token_data = res.json()
+                    self.token = token_data.get("access_token")
+                    if not self.token:
+                        raise Exception("No access_token in response")
+                    
+                    self.last_obtained = current_time
+                    # Get expiry from token if available, otherwise use default
+                    self.token_expiry = token_data.get("expires_in", 3600)
+                    logger.info("Successfully obtained admin token")
+                    return self.token
+                
+                logger.error(f"Token request failed: {res.status_code} - {res.text}")
+                if res.status_code == 401:
+                    raise Exception("Invalid admin credentials")
+                    
+            except requests.exceptions.RequestException as e:
+                logger.error(f"Network error during token fetch: {str(e)}")
+                if attempt < MAX_TOKEN_RETRIES - 1:
+                    time.sleep(TOKEN_RETRY_DELAY)
+                continue
+                
+        raise Exception("Failed to obtain admin token after multiple attempts")
+
+token_manager = TokenManager()
+
+# Root endpoint
 @app.get("/")
 def root():
     logger.debug("Root endpoint accessed")
@@ -36,13 +100,6 @@ async def redirect_login(request: Request):
 
 # Admin authentication logic
 def authenticate_admin(email: str = None, password: str = None):
-    """
-    Authenticate admin user with predefined email and password.
-    In a production environment, this should use secure password hashing and a database.
-    """
-    ADMIN_EMAIL = "yakdhanali97@gmail.com"
-    ADMIN_PASSWORD = "123456"  # In production, hash this password and compare securely
-
     if email != ADMIN_EMAIL or password != ADMIN_PASSWORD:
         logger.warning(f"Failed admin login attempt with email: {email}")
         raise HTTPException(status_code=401, detail="Unauthorized: Invalid email or password")
@@ -50,59 +107,54 @@ def authenticate_admin(email: str = None, password: str = None):
     logger.info(f"Admin authenticated successfully: {email}")
     return True
 
-# Gradio doctor creation logic
-BACKEND_URL = "https://rocketfarmstudios-cps-api.hf.space"
-
-# Get admin token by logging in to the auth Space
-def get_admin_token():
-    """
-    Authenticate with the auth Space to get a JWT token for admin requests.
-    """
-    login_payload = {
-        "username": "yakdhanali97@gmail.com",
-        "password": "123456",
-        "device_token": "admin-device-token"  # Replace with a valid device token if required
-    }
-    try:
-        res = requests.post(f"{BACKEND_URL}/auth/login", json=login_payload)
-        if res.status_code == 200:
-            token = res.json().get("access_token")
-            logger.info("Successfully obtained admin token")
-            return token
-        else:
-            logger.error(f"Failed to obtain admin token: {res.status_code} - {res.text}")
-            raise Exception("Failed to obtain admin token")
-    except Exception as e:
-        logger.error(f"Error obtaining admin token: {str(e)}")
-        raise
-
-# Store the admin token globally (in production, consider refreshing this token periodically)
-try:
-    ADMIN_TOKEN = get_admin_token()
-except Exception as e:
-    logger.critical("Could not initialize admin token, application startup failed")
-    raise
-
+# Doctor creation with token handling
 def create_doctor(full_name, email, matricule, password, specialty):
-    payload = {
-        "full_name": full_name,
-        "email": email,
-        "license_number": matricule,
-        "password": password,
-        "specialty": specialty,
-    }
-    headers = {
-        "Authorization": f"Bearer {ADMIN_TOKEN}"
-    }
     try:
-        res = requests.post(f"{BACKEND_URL}/auth/admin/doctors", json=payload, headers=headers)
+        token = token_manager.get_token()
+        
+        payload = {
+            "full_name": full_name,
+            "email": email,
+            "license_number": matricule,
+            "password": password,
+            "specialty": specialty,
+        }
+        headers = {
+            "Authorization": f"Bearer {token}",
+            "Content-Type": "application/json"
+        }
+        
+        res = requests.post(
+            f"{BACKEND_URL}/auth/admin/doctors",
+            json=payload,
+            headers=headers,
+            timeout=10
+        )
+        
         if res.status_code == 201:
             return "✅ Doctor created successfully!"
-        return f"❌ {res.json().get('detail', 'Error occurred')}"
-    except Exception as e:
+        elif res.status_code == 401:  # Token might be expired
+            logger.warning("Token expired, attempting refresh...")
+            token = token_manager.get_token(force_refresh=True)
+            headers["Authorization"] = f"Bearer {token}"
+            res = requests.post(
+                f"{BACKEND_URL}/auth/admin/doctors",
+                json=payload,
+                headers=headers,
+                timeout=10
+            )
+            if res.status_code == 201:
+                return "✅ Doctor created successfully!"
+        
+        error_detail = res.json().get('detail', 'Unknown error occurred')
+        return f"❌ Error: {error_detail} (Status: {res.status_code})"
+        
+    except requests.exceptions.RequestException as e:
         return f"❌ Network Error: {str(e)}"
+    except Exception as e:
+        return f"❌ System Error: {str(e)}"
 
-# Define Gradio interface
+# Gradio interface
 admin_ui = gr.Blocks(css="""
     .gradio-container {
         background-color: #1A1B1F;
@@ -121,7 +173,7 @@ admin_ui = gr.Blocks(css="""
 
 with admin_ui:
     gr.Markdown("<div class='title-text'>👨‍⚕️ Doctor Account Creator</div>")
-    gr.Markdown("<div class='description-text'>Admins can register new doctors using this secure panel. Generated at 10:09 PM CET on Sunday, May 25, 2025.</div>")
+    gr.Markdown("<div class='description-text'>Admins can register new doctors using this secure panel</div>")
 
     with gr.Column():
         full_name = gr.Textbox(label="Full Name", placeholder="e.g. Dr. Sarah Hopkins")
@@ -129,8 +181,9 @@ with admin_ui:
         matricule = gr.Textbox(label="Matricule", placeholder="e.g. DOC-1234")
         specialty = gr.Dropdown(
             label="Specialty",
-            choices=["Cardiology", "Neurology", "Pediatrics", "Oncology", "General Practice", "Psychiatry", "Dermatology", "Orthopedics"],
-            value="Cardiology"
+            choices=["Cardiology", "Neurology", "Pediatrics", "Oncology", 
+                    "General Practice", "Psychiatry", "Dermatology", "Orthopedics"],
+            value="General Practice"
         )
         password = gr.Textbox(label="Password", type="password", placeholder="Secure password")
         submit_btn = gr.Button("Create Doctor Account")
@@ -142,22 +195,29 @@ with admin_ui:
             outputs=output
         )
 
-# Mount Gradio interface at startup (unprotected for now, authentication handled by route)
+# Mount Gradio interface
 app = gr.mount_gradio_app(app, admin_ui, path="/admin-auth")
 
-# Authentication route to redirect to /admin-auth with credentials
+# Admin dashboard route
 @app.get("/admin")
 async def admin_dashboard(email: str = None, password: str = None, response: Response = None):
-    logger.debug("Admin dashboard accessed with email and password")
+    logger.debug("Admin dashboard accessed")
     try:
         authenticate_admin(email, password)
-        # Redirect to the mounted Gradio interface
         return RedirectResponse(url="/admin-auth", status_code=307)
     except HTTPException as e:
         response.status_code = 401
-        return HTMLResponse(content="<h1>401 Unauthorized</h1><p>Invalid email or password. Please use: email=yakdhanali97@gmail.com&password=123456</p>")
+        return HTMLResponse(content="""
+            <h1>401 Unauthorized</h1>
+            <p>Invalid email or password.</p>
+            <p>Please use the following credentials:</p>
+            <ul>
+                <li>Email: yakdhanali97@gmail.com</li>
+                <li>Password: 123456</li>
+            </ul>
+        """)
 
 if __name__ == "__main__":
-    logger.debug("Running main block")
+    logger.info("Starting application")
     import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)  # For local testing
+    uvicorn.run(app, host="0.0.0.0", port=7860)