Update app.py

app.py

@@ -1,334 +1,233 @@
-from flask import Flask, request, jsonify, session, redirect, url_for, render_template
-from simple_salesforce import Salesforce, SalesforceAuthenticationFailed, SalesforceError
+
+import gradio as gr
+from transformers import AutoModelForSeq2SeqLM, AutoTokenizer
 import os
+from fastapi import FastAPI
+from pydantic import BaseModel
+from simple_salesforce import Salesforce
 from dotenv import load_dotenv
-import logging
-import requests
-import json
-from datetime import datetime
-from urllib.parse import quote
 
 # Load environment variables
 load_dotenv()
 
-# Configure logging
-logging.basicConfig(
-    level=logging.DEBUG,
-    format='%(asctime)s - %(levelname)s - %(message)s',
-    handlers=[logging.FileHandler('app.log'), logging.StreamHandler()]
-)
-logger = logging.getLogger(__name__)
-
-app = Flask(__name__)
-app.secret_key = os.getenv('FLASK_SECRET_KEY', 'tTPLQduw8wDpxdKOMJ3d9dM3o')
-
-# Salesforce credentials from .env
-SALESFORCE_USERNAME = os.getenv('SALESFORCE_USERNAME')
-SALESFORCE_PASSWORD = os.getenv('SALESFORCE_PASSWORD')
-SALESFORCE_SECURITY_TOKEN = os.getenv('SALESFORCE_SECURITY_TOKEN')
-SALESFORCE_DOMAIN = os.getenv('SALESFORCE_DOMAIN', 'login')
-HUGGING_FACE_API_TOKEN = os.getenv('HUGGING_FACE_API_TOKEN')
-HUGGING_FACE_API_URL = os.getenv('HUGGING_FACE_API_URL', 'https://api-inference.huggingface.co/models/facebook/bart-large')
-
+# Salesforce connection
 def get_salesforce_connection():
-    """Establish a Salesforce connection with detailed error handling."""
     try:
+        # Load credentials from environment variables
+        username = os.getenv("SF_USERNAME")
+        password = os.getenv("SF_PASSWORD")
+        security_token = os.getenv("SF_SECURITY_TOKEN")
+        domain = os.getenv("SF_DOMAIN", "login")  # Default to production (login.salesforce.com)
+
+        # Validate credentials
+        if not all([username, password, security_token, domain]):
+            missing = []
+            if not username:
+                missing.append("SF_USERNAME")
+            if not password:
+                missing.append("SF_PASSWORD")
+            if not security_token:
+                missing.append("SF_SECURITY_TOKEN")
+            if not domain:
+                missing.append("SF_DOMAIN")
+            raise ValueError(f"Missing environment variables: {', '.join(missing)}. Set them in .env or Space environment variables.")
+
+        # Ensure all are strings
+        if not all(isinstance(x, str) for x in [username, password, security_token, domain]):
+            raise ValueError("All Salesforce credentials (SF_USERNAME, SF_PASSWORD, SF_SECURITY_TOKEN, SF_DOMAIN) must be strings.")
+
         sf = Salesforce(
-            username=SALESFORCE_USERNAME,
-            password=SALESFORCE_PASSWORD,
-            security_token=SALESFORCE_SECURITY_TOKEN,
-            domain=SALESFORCE_DOMAIN,
-            version='60.0'
+            username=username,
+            password=password,
+            security_token=security_token,
+            domain=domain
         )
-        logger.info("Successfully connected to Salesforce")
-        sf.query("SELECT Id FROM Supervisor_AI_Coaching__c LIMIT 1")
-        logger.debug("Salesforce connection test query successful")
-        return sf
-    except SalesforceAuthenticationFailed as e:
-        logger.error(f"Salesforce authentication failed: {str(e)}")
-        raise Exception(f"Salesforce authentication failed: {str(e)}")
-    except SalesforceError as e:
-        logger.error(f"Salesforce error during connection: {str(e)}")
-        raise Exception(f"Salesforce error: {str(e)}")
-    except Exception as e:
-        logger.error(f"Unexpected error connecting to Salesforce: {str(e)}")
-        raise Exception(f"Unable to connect to Salesforce: {str(e)}")
-
-@app.route('/')
-def index():
-    if 'supervisor_id' not in session:
-        logger.info("User not logged in, redirecting to login page")
-        return redirect(url_for('login_page'))
-    return redirect(url_for('dashboard'))
-
-@app.route('/login', methods=['GET'])
-def login_page():
-    return render_template('login.html')
-
-@app.route('/signup', methods=['GET'])
-def signup_page():
-    return render_template('signup.html')
-
-@app.route('/login', methods=['POST'])
-def login():
-    data = request.get_json()
-    supervisor_id = data.get('supervisor_id')
-
-    if not supervisor_id:
-        logger.warning("Login failed: Supervisor ID is required")
-        return jsonify({"status": "error", "message": "Supervisor ID is required"}), 400
-
-    try:
-        sf = get_salesforce_connection()
-        logger.debug(f"Querying Salesforce for Supervisor_AI_Coaching_Name__c: {supervisor_id}")
-        supervisor_id_escaped = quote(supervisor_id, safe='')
-        query = f"SELECT Id, Supervisor_AI_Coaching_Name__c, Project_ID__c FROM Supervisor_AI_Coaching__c WHERE Supervisor_AI_Coaching_Name__c = '{supervisor_id_escaped}' LIMIT 1"
-        result = sf.query(query)
-        logger.debug(f"Salesforce query result: {result}")
-
-        if not result['records']:
-            logger.warning(f"Invalid Supervisor ID: {supervisor_id}")
-            return jsonify({"status": "error", "message": "Invalid Supervisor ID"}), 401
-
-        session['supervisor_id'] = supervisor_id
-        logger.info(f"Login successful for {supervisor_id}")
-        return jsonify({"status": "success", "message": "Login successful", "redirect": "/dashboard"})
 
+        # Test connection by fetching user info
+        sf.User.get(sf.user_id)
+        return sf
     except Exception as e:
-        logger.error(f"Login error: {str(e)}")
-        return jsonify({"status": "error", "message": str(e)}), 500
-
-@app.route('/signup', methods=['POST'])
-def signup():
-    data = request.get_json()
-    supervisor_id = data.get('supervisor_id')
-
-    if not supervisor_id:
-        logger.warning("Signup failed: Supervisor ID is required")
-        return jsonify({"status": "error", "message": "Supervisor ID is required"}), 400
-
+        raise Exception(f"Failed to connect to Salesforce: {str(e)}")
+
+# Load Hugging Face token
+HF_TOKEN = os.getenv("HF_TOKEN")
+
+# Model configuration
+MODEL_PATH = "facebook/bart-large"  # Public model
+# MODEL_PATH = "your_actual_username/fine_tuned_bart_construction"  # Uncomment after uploading
+
+try:
+    model = AutoModelForSeq2SeqLM.from_pretrained(MODEL_PATH, use_auth_token=HF_TOKEN if HF_TOKEN else None)
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_PATH, use_auth_token=HF_TOKEN if HF_TOKEN else None)
+except Exception as e:
+    raise Exception(f"Failed to load model: {str(e)}")
+
+# Define input model for FastAPI
+class ChecklistInput(BaseModel):
+    role: str = "Supervisor"
+    project_id: str = "Unknown"
+    project_name: str = "Unknown Project"
+    milestones: str = "No milestones provided"
+    record_id: str = None
+    supervisor_id: str = None
+    project_id_sf: str = None
+    reflection_log: str = None
+    download_link: str = None
+
+# Initialize FastAPI
+app = FastAPI()
+
+@app.post("/generate")
+async def generate_checklist(data: ChecklistInput):
     try:
-        sf = get_salesforce_connection()
-        logger.debug(f"Checking if Supervisor_AI_Coaching_Name__c {supervisor_id} already exists")
-        supervisor_id_escaped = quote(supervisor_id, safe='')
-        query = f"SELECT Id FROM Supervisor_AI_Coaching__c WHERE Supervisor_AI_Coaching_Name__c = '{supervisor_id_escaped}' LIMIT 1"
-        result = sf.query(query)
-        if result['records']:
-            logger.warning(f"Signup failed: Supervisor ID {supervisor_id} already exists")
-            return jsonify({"status": "error", "message": "Supervisor ID already exists"}), 400
+        inputs = f"Role: {data.role} Project: {data.project_id} ({data.project_name}) Milestones: {data.milestones}"
+        input_ids = tokenizer(inputs, return_tensors="pt", max_length=128, truncation=True).input_ids
+        outputs = model.generate(input_ids, max_length=128, num_beams=4, early_stopping=True)
+        checklist = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        tips = "1. Prioritize safety checks\n2. Review milestones\n3. Log progress"
+        kpi_flag = "delay" in data.milestones.lower() or "behind" in data.milestones.lower()
+
+        if data.record_id:
+            sf = get_salesforce_connection()
+            existing_record = sf.Supervisor_AI_Coaching__c.get(data.record_id, default={
+                'Name': '',
+                'Supervisor_ID__c': None,
+                'Project_ID__c': None,
+                'Reflection_Log__c': '',
+                'Download_Link__c': '',
+                'Engagement_Score__c': 0,
+                'KPI_Flag__c': False,
+                'Daily_Checklist__c': '',
+                'Suggested_Tips__c': ''
+            })
+            update_data = {
+                'Daily_Checklist__c': checklist,
+                'Suggested_Tips__c': tips,
+                'Engagement_Score__c': existing_record.get('Engagement_Score__c', 0) + 10,
+                'KPI_Flag__c': kpi_flag,
+                'Supervisor_ID__c': data.supervisor_id if data.supervisor_id else existing_record.get('Supervisor_ID__c'),
+                'Project_ID__c': data.project_id_sf if data.project_id_sf else existing_record.get('Project_ID__c'),
+                'Reflection_Log__c': data.reflection_log if data.reflection_log else existing_record.get('Reflection_Log__c', ''),
+                'Download_Link__c': data.download_link if data.download_link else existing_record.get('Download_Link__c', '')
+            }
+            sf.Supervisor_AI_Coaching__c.update(data.record_id, update_data)
 
-        logger.debug(f"Creating new Supervisor_AI_Coaching__c record for {supervisor_id}")
-        new_record = {
-            'Supervisor_AI_Coaching_Name__c': supervisor_id
+        return {
+            "checklist": checklist,
+            "tips": tips,
+            "kpi_flag": kpi_flag
         }
-        response = sf.Supervisor_AI_Coaching__c.create(new_record)
-        logger.debug(f"Salesforce create response: {response}")
-
-        if not response.get('success'):
-            logger.error(f"Failed to create Supervisor record: {response.get('errors')}")
-            return jsonify({"status": "error", "message": f"Failed to create record in Salesforce: {response.get('errors')}"}), 500
-
-        session['supervisor_id'] = supervisor_id
-        logger.info(f"Signup successful for {supervisor_id}")
-        return jsonify({"status": "success", "message": "Signup successful, you are now logged in", "redirect": "/dashboard"})
     except Exception as e:
-        logger.error(f"Signup error: {str(e)}")
-        return jsonify({"status": "error", "message": str(e)}), 500
-
-@app.route('/dashboard', methods=['GET'])
-def dashboard():
-    return render_template('dashboard.html')
-
-@app.route('/home')
-def home():
-    return render_template('home.html')
-
-def generate_coaching_output(data):
-    """Generate daily checklist and tips using Hugging Face LLM."""
-    logger.info("Generating coaching output for supervisor %s", data['supervisor_id'])
-    milestones_json = json.dumps(data['milestones'], indent=2)
-    prompt = f"""
-You are an AI Coach for construction site supervisors. Based on the following data, generate a daily checklist, three focus tips, and a motivational quote. Ensure outputs are concise, actionable, and tailored to the supervisor's role, project status, and reflection log.
-Supervisor ID: {data['supervisor_id']}
-Project Milestones: {milestones_json}
-Reflection Log: {data['reflection_log']}
-Weather: {data['weather']}
-Format the response as JSON:
-{{
-    "checklist": ["item1", "item2", ...],
-    "tips": ["tip1", "tip2", "tip3"],
-    "quote": "motivational quote"
-}}
-"""
-    headers = {
-        "Authorization": f"Bearer {HUGGING_FACE_API_TOKEN}",
-        "Content-Type": "application/json"
-    }
-    payload = {
-        "inputs": prompt,
-        "parameters": {
-            "max_length": 200,
-            "temperature": 0.7,
-            "top_p": 0.9
-        }
-    }
+        return {"error": str(e)}
 
+# Login and display records
+def login_and_display(project_id_sf):
     try:
-        response = requests.post(HUGGING_FACE_API_URL, headers=headers, json=payload, timeout=5)
-        response.raise_for_status()
-        result = response.json()
-        generated_text = result[0]["generated_text"] if isinstance(result, list) else result["generated_text"]
-
-        start_idx = generated_text.find('{')
-        end_idx = generated_text.rfind('}') + 1
-        if start_idx == -1 or end_idx == 0:
-            logger.error("No valid JSON found in LLM output")
-            raise ValueError("No valid JSON found in LLM output")
-        
-        json_str = generated_text[start_idx:end_idx]
-        output = json.loads(json_str)
-        logger.info("Successfully generated coaching output")
-        return output
-
-    except requests.exceptions.HTTPError as e:
-        logger.error("Hugging Face API HTTP error: %s", e)
-        return None
-    except (json.JSONDecodeError, ValueError) as e:
-        logger.error("Error parsing LLM output: %s", e)
-        return None
+        sf = get_salesforce_connection()
+        query = f"SELECT Id, Name, Supervisor_ID__c, Project_ID__c, Daily_Checklist__c, Suggested_Tips__c, Reflection_Log__c, Engagement_Score__c, KPI_Flag__c, Download_Link__c FROM Supervisor_AI_Coaching__c WHERE Project_ID__c = '{project_id_sf}'"
+        records = sf.query(query)["records"]
+        if not records:
+            return "No records found for Project ID.", "", False
+
+        output = "Supervisor_AI_Coaching__c Records:\n"
+        for record in records:
+            output += (
+                f"Record ID: {record['Id']}\n"
+                f"Name: {record['Name']}\n"
+                f"Supervisor ID: {record['Supervisor_ID__c']}\n"
+                f"Project ID: {record['Project_ID__c']}\n"
+                f"Daily Checklist: {record['Daily_Checklist__c'] or 'N/A'}\n"
+                f"Suggested Tips: {record['Suggested_Tips__c'] or 'N/A'}\n"
+                f"Reflection Log: {record['Reflection_Log__c'] or 'N/A'}\n"
+                f"Engagement Score: {record['Engagement_Score__c'] or 0}%\n"
+                f"KPI Flag: {record['KPI_Flag__c']}\n"
+                f"Download Link: {record['Download_Link__c'] or 'N/A'}\n"
+                f"{'-'*50}\n"
+            )
+        return output, "", False
     except Exception as e:
-        logger.error("Unexpected error in Hugging Face API call: %s", e)
-        return None
-
-def save_to_salesforce(output, supervisor_id, project_id):
-    """Save coaching output to Salesforce Supervisor_AI_Coaching__c object."""
-    if not output:
-        logger.error("No coaching output to save")
-        return False
+        return f"Error querying Salesforce: {str(e)}", "", False
 
+# Generate checklist from record
+def gradio_generate_checklist(record_id, role="Supervisor", project_id="Unknown", project_name="Unknown Project", milestones="No milestones provided", supervisor_id="", project_id_sf="", reflection_log="", download_link=""):
     try:
         sf = get_salesforce_connection()
-        logger.info("Connected to Salesforce")
-
-        coaching_record = {
-            "Supervisor_AI_Coaching_Name__c": supervisor_id,
-            "Project_ID__c": project_id,
-            "Daily_Checklist__c": "\n".join(output["checklist"]),
-            "Suggested_Tips__c": "\n".join(output["tips"]),
-            "Quote__c": output["quote"],
-            "Generated_Date__c": datetime.now().strftime("%Y-%m-%d")
+        existing_record = sf.Supervisor_AI_Coaching__c.get(record_id, default={
+            'Name': '',
+            'Supervisor_ID__c': None,
+            'Project_ID__c': None,
+            'Reflection_Log__c': '',
+            'Download_Link__c': '',
+            'Engagement_Score__c': 0,
+            'KPI_Flag__c': False,
+            'Daily_Checklist__c': '',
+            'Suggested_Tips__c': ''
+        })
+        inputs = f"Role: {role} Project: {project_id} ({project_name}) Milestones: {milestones}"
+        input_ids = tokenizer(inputs, return_tensors="pt", max_length=128, truncation=True).input_ids
+        outputs = model.generate(input_ids, max_length=128, num_beams=4, early_stopping=True)
+        checklist = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        tips = "1. Prioritize safety checks\n2. Review milestones\n3. Log progress"
+        kpi_flag = "delay" in milestones.lower() or "behind" in milestones.lower()
+
+        update_data = {
+            'Daily_Checklist__c': checklist,
+            'Suggested_Tips__c': tips,
+            'Engagement_Score__c': existing_record.get('Engagement_Score__c', 0) + 10,
+            'KPI_Flag__c': kpi_flag,
+            'Supervisor_ID__c': supervisor_id if supervisor_id else existing_record.get('Supervisor_ID__c'),
+            'Project_ID__c': project_id_sf if project_id_sf else existing_record.get('Project_ID__c'),
+            'Reflection_Log__c': reflection_log if reflection_log else existing_record.get('Reflection_Log__c', ''),
+            'Download_Link__c': download_link if download_link else existing_record.get('Download_Link__c', '')
         }
+        sf.Supervisor_AI_Coaching__c.update(record_id, update_data)
+        status = f"Updated Salesforce record {record_id}"
 
-        external_id = f"{supervisor_id}_{datetime.now().strftime('%Y-%m-%d')}"
-        sf.Supervisor_AI_Coaching__c.upsert(f"Supervisor_AI_Coaching_Name__c/{external_id}", coaching_record)
-        logger.info("Successfully saved coaching record to Salesforce for supervisor %s", supervisor_id)
-        return True
-
+        return checklist, tips, kpi_flag, status
     except Exception as e:
-        logger.error("Salesforce error: %s", e)
-        return False
-
-@app.route('/generate', methods=['POST'])
-def generate_endpoint():
-    """Endpoint to generate coaching output based on supervisor data."""
-    try:
-        data = request.get_json()
-        required_keys = ['supervisor_id', 'project_id', 'milestones', 'reflection_log', 'weather']
-        if not data or not all(key in data for key in required_keys):
-            return jsonify({"status": "error", "message": "Invalid or missing supervisor data"}), 400
-
-        coaching_output = generate_coaching_output(data)
-        if coaching_output:
-            success = save_to_salesforce(coaching_output, data["supervisor_id"], data["project_id"])
-            if success:
-                return jsonify({"status": "success", "output": coaching_output}), 200
-            else:
-                return jsonify({"status": "error", "message": "Failed to save to Salesforce"}), 500
-        else:
-            return jsonify({"status": "error", "message": "Failed to generate coaching output"}), 500
-    except Exception as e:
-        logger.error("Error in generate endpoint: %s", e)
-        return jsonify({"status": "error", "message": str(e)}), 500
-
-@app.route('/submit_reflection', methods=['POST'])
-def submit_reflection():
-    """Endpoint to submit a reflection and update Salesforce."""
-    try:
-        data = request.get_json()
-        reflection = data.get('reflection')
-        supervisor_id = session.get('supervisor_id')
-
-        if not reflection or not supervisor_id:
-            return jsonify({"status": "error", "message": "Reflection and supervisor ID are required"}), 400
-
-        sf = get_salesforce_connection()
-        query = f"SELECT Id FROM Supervisor_AI_Coaching__c WHERE Supervisor_AI_Coaching_Name__c = '{quote(supervisor_id, safe='')}' LIMIT 1"
-        result = sf.query(query)
-
-        if not result['records']:
-            return jsonify({"status": "error", "message": "Supervisor not found"}), 404
-
-        record_id = result['records'][0]['Id']
-        sf.Supervisor_AI_Coaching__c.update(record_id, {"Reflection_Log__c": reflection})
-        logger.info(f"Reflection saved for supervisor {supervisor_id}")
-        return jsonify({"status": "success", "message": "Reflection submitted successfully"})
+        return f"Error: {str(e)}", "", False, ""
+
+# Define Gradio interface
+with gr.Blocks() as iface:
+    gr.Markdown("# AI Coach for Site Supervisors")
+    gr.Markdown("Enter a Project ID to view Supervisor_AI_Coaching__c records and generate checklists.")
+
+    with gr.Tab("Login"):
+        project_id_input = gr.Textbox(label="Project ID (Salesforce Project__c ID)", placeholder="Enter Project ID")
+        login_button = gr.Button("Submit")
+        records_output = gr.Textbox(label="Records", lines=10)
+        login_button.click(
+            fn=login_and_display,
+            inputs=project_id_input,
+            outputs=[records_output, gr.Textbox(visible=False), gr.Checkbox(visible=False)]
+        )
 
-    except Exception as e:
-        logger.error(f"Error submitting reflection: {str(e)}")
-        return jsonify({"status": "error", "message": str(e)}), 500
+    with gr.Tab("Generate Checklist"):
+        record_id = gr.Textbox(label="Record ID", placeholder="Enter Record ID from above")
+        role = gr.Textbox(label="Role", value="Supervisor")
+        project_id = gr.Textbox(label="Project ID", value="P001")
+        project_name = gr.Textbox(label="Project Name", value="Building A")
+        milestones = gr.Textbox(label="Milestones", value="Complete foundation by 5/15")
+        supervisor_id = gr.Textbox(label="Supervisor ID (Salesforce User ID, optional)", value="")
+        project_id_sf = gr.Textbox(label="Project ID (Salesforce Project__c ID, optional)", value="")
+        reflection_log = gr.Textbox(label="Reflection Log (optional)", value="")
+        download_link = gr.Textbox(label="Download Link (optional)", value="")
+        generate_button = gr.Button("Generate and Update")
+        checklist_output = gr.Textbox(label="Checklist")
+        tips_output = gr.Textbox(label="Tips")
+        kpi_flag_output = gr.Checkbox(label="KPI Flag")
+        status_output = gr.Textbox(label="Salesforce Status")
+        generate_button.click(
+            fn=gradio_generate_checklist,
+            inputs=[record_id, role, project_id, project_name, milestones, supervisor_id, project_id_sf, reflection_log, download_link],
+            outputs=[checklist_output, tips_output, kpi_flag_output, status_output]
+        )
 
-@app.route('/get_supervisor_data', methods=['GET'])
-def get_supervisor_data():
-    supervisor_id = session.get('supervisor_id')
-    if not supervisor_id:
-        logger.warning("No supervisor ID in session")
-        return jsonify({"status": "error", "message": "User not logged in"}), 401
+# Mount FastAPI
+iface.app = app
 
+if __name__ == "__main__":
     try:
-        sf = get_salesforce_connection()
-        supervisor_id_escaped = quote(supervisor_id, safe='')
-        query = f"""
-            SELECT Supervisor_AI_Coaching_Name__c, Project_ID__c, Daily_Checklist__c, Suggested_Tips__c, 
-                   Reflection_Log__c, Engagement_Score__c, KPI_Flag__c, Quote__c
-            FROM Supervisor_AI_Coaching__c
-            WHERE Supervisor_AI_Coaching_Name__c = '{supervisor_id_escaped}'
-            LIMIT 1
-        """
-        result = sf.query(query)
-
-        if result['records']:
-            record = result['records'][0]
-            data = {
-                "supervisor_id": record['Supervisor_AI_Coaching_Name__c'],
-                "project_id": record['Project_ID__c'],
-                "daily_checklist": record['Daily_Checklist__c'],
-                "suggested_tips": record['Suggested_Tips__c'],
-                "reflection_log": record['Reflection_Log__c'],
-                "engagement_score": record['Engagement_Score__c'] or 0,
-                "kpi_flag": record['KPI_Flag__c'] or False,
-                "quote": record['Quote__c'],
-                "last_login": str(datetime.now())
-            }
-            logger.info(f"Fetched data for supervisor {supervisor_id}")
-            return jsonify({"status": "success", "data": data})
-        else:
-            logger.warning(f"No data found for supervisor {supervisor_id}")
-            return jsonify({"status": "error", "message": "No data found for this supervisor"}), 404
+        iface.launch(server_name="0.0.0.0", server_port=7860, share=False)
     except Exception as e:
-        logger.error(f"Error fetching supervisor data: {str(e)}")
-        return jsonify({"status": "error", "message": str(e)}), 500
-
-@app.route('/logout', methods=['POST'])
-def logout():
-    supervisor_id = session.get('supervisor_id', 'Unknown')
-    session.pop('supervisor_id', None)
-    logger.info(f"User {supervisor_id} logged out")
-    return jsonify({"status": "success", "message": "Logged out successfully"})
-
-@app.route('/health', methods=['GET'])
-def health_check():
-    return jsonify({"status": "healthy", "message": "Application is running"}), 200
-
-if __name__ == '__main__':
-    port = int(os.getenv('PORT', 5000))
-    app.run(host='0.0.0.0', port=port, debug=True)
+        print(f"Failed to launch Gradio: {str(e)}")