Update app.py

app.py

@@ -1,208 +1,4 @@
-from fastapi import FastAPI, Request, HTTPException
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import RedirectResponse
-from api import api_router
-import gradio as gr
-import aiohttp
-import asyncio
-import logging
-import time
-from typing import Optional
-from pydantic import BaseModel
-
-# Configure logging
-logging.basicConfig(
-    level=logging.DEBUG,
-    format="%(asctime)s - %(levelname)s - %(name)s - %(message)s"
-)
-logger = logging.getLogger(__name__)
-logger.debug("Initializing application")
-
-app = FastAPI()
-
-# CORS Configuration (restrict in production)
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-app.include_router(api_router)
-
-# Constants
-BACKEND_URL = "https://rocketfarmstudios-cps-api.hf.space"  # Update if different backend
-ADMIN_EMAIL = "yakdhanali97@gmail.com"
-ADMIN_PASSWORD = "123456"
-MAX_TOKEN_RETRIES = 3
-TOKEN_RETRY_DELAY = 2  # seconds
-TOKEN_EXPIRY = 3600  # 1 hour default expiry
-
-# Pydantic models
-class LoginPayload(BaseModel):
-    email: str
-    password: str
-
-class DoctorPayload(BaseModel):
-    full_name: str
-    email: str
-    license_number: str
-    password: str
-    specialty: str
-
-class TokenManager:
-    def __init__(self):
-        self.token = None
-        self.last_refresh = 0
-        self.expires_in = TOKEN_EXPIRY
-        self.lock = asyncio.Lock()
-
-    async def _make_login_request(self) -> Optional[str]:
-        try:
-            async with aiohttp.ClientSession() as session:
-                payload = LoginPayload(
-                    email=ADMIN_EMAIL,
-                    password=ADMIN_PASSWORD
-                )
-                login_url = f"{BACKEND_URL.rstrip('/')}/auth/login"
-                logger.debug(f"Sending login request to {login_url} with payload: {payload.dict()}")
-                async with session.post(
-                    login_url,
-                    json=payload.dict(),
-                    timeout=15,
-                    headers={"Content-Type": "application/json"}
-                ) as response:
-                    logger.debug(f"Login response status: {response.status}, URL: {response.url}")
-                    if response.status == 200:
-                        data = await response.json()
-                        token = data.get("access_token")
-                        if not token:
-                            logger.error("No access_token in response")
-                            return None
-                        logger.info(f"Received token: {token[:10]}...")
-                        return token
-                    else:
-                        error = await response.text()
-                        logger.error(f"Login failed: {response.status} - {error}, URL: {response.url}")
-                        return None
-        except aiohttp.ClientError as e:
-            logger.error(f"Login request error: {str(e)}, URL: {login_url}")
-            return None
-
-    async def refresh_token(self) -> str:
-        async with self.lock:
-            for attempt in range(MAX_TOKEN_RETRIES):
-                token = await self._make_login_request()
-                if token:
-                    self.token = token
-                    self.last_refresh = time.time()
-                    logger.info("Successfully refreshed admin token")
-                    return token
-                
-                wait_time = min(5, (attempt + 1) * TOKEN_RETRY_DELAY)
-                logger.warning(f"Attempt {attempt + 1} failed, retrying in {wait_time}s...")
-                await asyncio.sleep(wait_time)
-
-            raise HTTPException(status_code=500, detail="Failed to obtain admin token after multiple attempts")
-
-    async def get_token(self) -> str:
-        if not self.token or (time.time() - self.last_refresh) > (self.expires_in - 60):
-            return await self.refresh_token()
-        return self.token
-
-token_manager = TokenManager()
-
-@app.get("/")
-def root():
-    logger.debug("Root endpoint accessed")
-    return {"message": "🚀 FastAPI with MongoDB + JWT is running."}
-
-@app.post("/login")
-async def redirect_login(request: Request):
-    logger.info("Redirecting /login to /auth/login")
-    return RedirectResponse(url="/auth/login", status_code=307)
-
-async def async_create_doctor(full_name: str, email: str, license_number: str, specialty: str, password: str):
-    try:
-        # Validate inputs
-        if not all([full_name, email, license_number, specialty, password]):
-            logger.error("Doctor creation failed: All fields are required")
-            raise HTTPException(status_code=422, detail="All fields are required")
-
-        token = await token_manager.get_token()
-        
-        payload = DoctorPayload(
-            full_name=full_name,
-            email=email,
-            license_number=license_number,
-            password=password,
-            specialty=specialty
-        )
-        headers = {
-            "Authorization": f"Bearer {token}",
-            "Content-Type": "application/json"
-        }
-        
-        doctor_url = f"{BACKEND_URL.rstrip('/')}/auth/admin/doctors"
-        logger.debug(f"Sending doctor creation request to {doctor_url} with payload: {payload.dict()}")
-        async with aiohttp.ClientSession() as session:
-            async with session.post(
-                doctor_url,
-                json=payload.dict(),
-                headers=headers,
-                timeout=15
-            ) as response:
-                logger.debug(f"Doctor creation response status: {response.status}, URL: {response.url}")
-                if response.status == 201:
-                    return "✅ Doctor created successfully!"
-                elif response.status == 401:
-                    logger.warning("Token expired, attempting refresh...")
-                    token = await token_manager.refresh_token()
-                    headers["Authorization"] = f"Bearer {token}"
-                    async with session.post(
-                        doctor_url,
-                        json=payload.dict(),
-                        headers=headers,
-                        timeout=15
-                    ) as retry_response:
-                        logger.debug(f"Retry doctor creation response status: {retry_response.status}, URL: {retry_response.url}")
-                        if retry_response.status == 201:
-                            return "✅ Doctor created successfully!"
-                        error_detail = await retry_response.text()
-                        return f"❌ Error: {error_detail} (Status: {retry_response.status})"
-                
-                error_detail = await response.text()
-                return f"❌ Error: {error_detail} (Status: {response.status})"
-                
-    except HTTPException as e:
-        logger.error(f"Doctor creation failed: {str(e)}")
-        return f"❌ Error: {str(e)}"
-    except Exception as e:
-        logger.error(f"Doctor creation failed: {str(e)}")
-        return f"❌ System Error: {str(e)}"
-
-def sync_create_doctor(full_name: str, email: str, license_number: str, specialty: str, password: str):
-    return asyncio.run(async_create_doctor(full_name, email, license_number, specialty, password))
-
-# New endpoint for public doctor creation
-@app.post("/create-doctor")
-async def create_doctor(payload: DoctorPayload):
-    result = await async_create_doctor(
-        full_name=payload.full_name,
-        email=payload.email,
-        license_number=payload.lice
-System: I notice the code in the artifact appears incomplete, as it cuts off mid-line in the `/create-doctor` endpoint. I'll provide a corrected and complete version of the updated `app.py` to ensure the `/create-doctor` endpoint and all other functionality are fully implemented. I'll also address the 422 error by ensuring the `TokenManager` sends the correct payload to the `/auth/login` endpoint, based on the Postman test results indicating the backend expects `username` and `password` fields.
-
-### Updated Code with Fixes
-The following code:
-- Updates the `LoginPayload` model to use `username` instead of `email`, matching the backend’s expected schema (based on the 422 error).
-- Completes the `/create-doctor` endpoint.
-- Preserves all other functionality (`/admin`, `/test-backend`, Gradio UI, etc.).
-- Includes environment variable support for `BACKEND_URL` to allow easy configuration.
-- Adds detailed logging to debug payload issues.
 
-<xaiArtifact artifact_id="0bf1081b-f3f2-4a40-9616-4a9b212f1422" artifact_version_id="0b44a4c4-6f14-45b8-bbbe-50e0dded5ed0" title="app.py" contentType="text/python">
 from fastapi import FastAPI, Request, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import RedirectResponse