Download app.py from AidSdg/AI4SDG: direct link, hf CLI and curl.
- Browser
- Download file 28.9 kB
-
https://huggingface.co/spaces/AidSdg/AI4SDG/resolve/main/app.py
- Command line
-
hf download hf://spaces/AidSdg/AI4SDG/app.py
-
curl -L -o app.py https://huggingface.co/spaces/AidSdg/AI4SDG/resolve/main/app.py
28.9 kB
| import os | |
| import gradio as gr | |
| import google.generativeai as genai | |
| from openai import OpenAI | |
| import tempfile | |
| from gtts import gTTS | |
| import speech_recognition as sr | |
| from PIL import Image | |
| import docx | |
| from PyPDF2 import PdfReader | |
| from transformers import BlipProcessor, BlipForConditionalGeneration | |
| import torch | |
| from functools import lru_cache | |
| import threading | |
| import random | |
| from fastapi import FastAPI, HTTPException | |
| from fastapi.middleware.cors import CORSMiddleware | |
| from pydantic import BaseModel | |
| from typing import List, Optional | |
| import uvicorn | |
| # ----------------------------- | |
| # OPTIONAL OCR SETUP | |
| # ----------------------------- | |
| try: | |
| import pytesseract | |
| OCR_AVAILABLE = True | |
| except ImportError: | |
| OCR_AVAILABLE = False | |
| print("β οΈ pytesseract not installed. OCR will be skipped.") | |
| # ----------------------------- | |
| # API KEYS SETUP | |
| # ----------------------------- | |
| # NOTE: These environmental variables must be set where the app is run. | |
| # Using dummy values if not set to allow the app to initialize, but API calls will fail without real keys | |
| GENAI_KEY = os.getenv("GEMINI_API_KEY", "dummy_genai_key") | |
| OPENAI_KEY = os.getenv("OPENAI_API_KEY", "dummy_openai_key") | |
| genai.configure(api_key=GENAI_KEY) | |
| openai_client = OpenAI(api_key=OPENAI_KEY) | |
| # ----------------------------- | |
| # CHATCDS SYSTEM PROMPT | |
| # ----------------------------- | |
| SYSTEM_PROMPT = """ | |
| You are ChatCDS, an AI assistant created by the Advanced Initiative for Deploying Sustainable Development Goals (AIDSDG), | |
| powered by AI4SDG (Artificial Intelligence for Scaling Sustainable Development Goals). You help NYSC corps members plan, align, and scale their Community Development Service (CDS) projects | |
| with the United Nations Sustainable Development Goals (SDGs). | |
| You are knowledgeable about SDG targets, community impact design, budgeting, and proposal writing. | |
| Always speak with encouragement and clarity. When relevant, show which SDG(s) align with the idea. | |
| Be professional, concise, and human-sounding. | |
| """ | |
| # ----------------------------- | |
| # WELCOME MESSAGES | |
| # ----------------------------- | |
| WELCOME_MESSAGES = [ | |
| "π Welcome to ChatCDS! Ready to make a real impact in your community? Let's align your CDS project with the SDGs and create lasting change!", | |
| "π Hello, changemaker! ChatCDS is here to help you design, plan, and scale your Community Development Service project. What SDG goal inspires you today?", | |
| "π Great to see you! Let's turn your CDS ideas into actionable projects that transform communities. How can I assist you today?", | |
| "π‘ Welcome back! Your community needs your innovative ideas. Let's work together to align your CDS project with sustainable development goals!", | |
| "π Hello! Ready to be a catalyst for change? ChatCDS is your partner in guiding your CDS journey from concept to implementation. Let's get started!", | |
| "β¨ Welcome, corps member! Every great project starts with a single idea. Share yours, and let's make it SDG-aligned and impactful!", | |
| "π― Hi there! ChatCDS is your partner in creating meaningful community impact. Let's explore how your CDS project can contribute to the SDGs!", | |
| "π± Welcome! Your service year is an opportunity to plant seeds of change. Let's nurture your CDS ideas into sustainable community solutions!", | |
| ] | |
| MOTIVATIONAL_QUOTES = [ | |
| "πͺ Remember: Small actions, when multiplied by millions, can transform the world!", | |
| "π Your CDS project has the power to create ripples of positive change in your community!", | |
| "π Every SDG goal achieved starts with someone like you taking action!", | |
| "π‘ Innovation in community service doesn't require perfectionβit requires passion and commitment!", | |
| "π You're not just servingβyou're building a legacy of sustainable development!", | |
| "β¨ The best time to start making a difference was yesterday. The second best time is now!", | |
| "π― Your unique perspective as a corps member is exactly what your community needs!", | |
| ] | |
| # ----------------------------- | |
| # MEMORY MANAGEMENT & CHAT HISTORY | |
| # ----------------------------- | |
| chat_sessions = {} | |
| current_session_id = None | |
| api_user_sessions = {} | |
| def get_welcome_message(): | |
| welcome = random.choice(WELCOME_MESSAGES) | |
| motivation = random.choice(MOTIVATIONAL_QUOTES) | |
| return f"{welcome}\n\n{motivation}" | |
| def generate_session_id(): | |
| import time | |
| return f"session_{int(time.time())}_{random.randint(1000, 9999)}" | |
| def save_current_session(history: List[dict]): | |
| """Saves the current chat history (in dictionary format) to chat_sessions.""" | |
| global current_session_id, chat_sessions | |
| if current_session_id and len(history) > 1: | |
| from datetime import datetime | |
| first_user_msg = "New Chat" | |
| for msg in history: | |
| # History is list of dicts | |
| content = msg.get("content") | |
| role = msg.get("role") | |
| if role == "user" and content: | |
| clean_content = content.replace('\n', ' ').strip() | |
| first_user_msg = clean_content[:60] + ("..." if len(clean_content) > 60 else "") | |
| break | |
| chat_sessions[current_session_id] = { | |
| "history": history.copy(), | |
| "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"), | |
| "preview": first_user_msg, | |
| "title": first_user_msg | |
| } | |
| def get_chat_history_list(): | |
| if not chat_sessions: | |
| return [] | |
| chat_list = [] | |
| for session_id, session_data in sorted(chat_sessions.items(), key=lambda x: x[1]["timestamp"], reverse=True): | |
| clean_title = session_data['title'].replace('\n', ' ').strip() | |
| display_text = f"π {session_data['timestamp']} | {clean_title}" | |
| chat_list.append(display_text) | |
| return chat_list | |
| def load_chat_session(selected_chat): | |
| """Loads history in the required dictionary format for Gradio.""" | |
| global current_session_id | |
| if not selected_chat or selected_chat == "" or not chat_sessions: | |
| new_history = initialize_chat() | |
| new_choices = get_chat_history_list() | |
| # Returns history (list of dicts), blank input, and updated dropdown | |
| return new_history, "", gr.Dropdown(choices=new_choices, value=None) | |
| for session_id, session_data in chat_sessions.items(): | |
| clean_title = session_data['title'].replace('\n', ' ').strip() | |
| display_text = f"π {session_data['timestamp']} | {clean_title}" | |
| if display_text == selected_chat or display_text.strip() == selected_chat.strip(): | |
| current_session_id = session_id | |
| new_choices = get_chat_history_list() | |
| # History is already in dictionary format (list of dicts) | |
| return session_data["history"], "", gr.Dropdown(choices=new_choices, value=selected_chat) | |
| new_history = initialize_chat() | |
| new_choices = get_chat_history_list() | |
| return new_history, "", gr.Dropdown(choices=new_choices, value=None) | |
| def delete_chat_session(selected_chat): | |
| global chat_sessions | |
| if not selected_chat or not chat_sessions: | |
| new_choices = get_chat_history_list() | |
| return gr.Dropdown(choices=new_choices, value=None), "No chat selected to delete" | |
| for session_id, session_data in list(chat_sessions.items()): | |
| clean_title = session_data['title'].replace('\n', ' ').strip() | |
| display_text = f"π {session_data['timestamp']} | {clean_title}" | |
| if display_text == selected_chat or display_text.strip() == selected_chat.strip(): | |
| del chat_sessions[session_id] | |
| new_choices = get_chat_history_list() | |
| return gr.Dropdown(choices=new_choices, value=None), f"β Chat deleted successfully!" | |
| new_choices = get_chat_history_list() | |
| return gr.Dropdown(choices=new_choices, value=None), "β Chat not found" | |
| def rename_chat_session(selected_chat, new_title): | |
| global chat_sessions | |
| if not selected_chat or not chat_sessions or not new_title.strip(): | |
| new_choices = get_chat_history_list() | |
| return gr.Dropdown(choices=new_choices, value=selected_chat), "Please provide a valid title" | |
| for session_id, session_data in chat_sessions.items(): | |
| clean_title = session_data['title'].replace('\n', ' ').strip() | |
| display_text = f"π {session_data['timestamp']} | {clean_title}" | |
| if display_text == selected_chat or display_text.strip() == selected_chat.strip(): | |
| chat_sessions[session_id]["title"] = new_title.strip() | |
| new_choices = get_chat_history_list() | |
| new_display = f"π {session_data['timestamp']} | {new_title.strip()}" | |
| return gr.Dropdown(choices=new_choices, value=new_display), f"β Chat renamed to: {new_title}" | |
| new_choices = get_chat_history_list() | |
| return gr.Dropdown(choices=new_choices, value=selected_chat), "β Chat not found" | |
| def start_new_chat(history): | |
| global current_session_id | |
| save_current_session(history) # history is list of dicts | |
| current_session_id = generate_session_id() | |
| new_history = initialize_chat() | |
| new_choices = get_chat_history_list() | |
| return new_history, "", None, None, None, gr.Dropdown(choices=new_choices, value=None), "" | |
| def generate_ai_response_gradio(messages: List[dict]): | |
| """Handles the model call for the Gradio interface.""" | |
| prompt = SYSTEM_PROMPT + "\n\nConversation so far:\n" | |
| # Use only the last 6 messages (system instructions + 5 turns) | |
| for m in messages[-6:]: | |
| prompt += f"{m['role'].capitalize()}: {m['content']}\n" | |
| try: | |
| # Gemini call | |
| gemini_model = genai.GenerativeModel("gemini-1.5-flash") | |
| response = gemini_model.generate_content(prompt) | |
| reply = response.text.strip() | |
| except Exception as e: | |
| try: | |
| # OpenAI fallback using structured message format | |
| ai_messages = [{"role": "system", "content": SYSTEM_PROMPT}] | |
| for m in messages[-6:]: | |
| ai_messages.append({"role": m['role'], "content": m['content']}) | |
| completion = openai_client.chat.completions.create( | |
| model="gpt-4o-mini", | |
| messages=ai_messages | |
| ) | |
| reply = completion.choices[0].message.content.strip() | |
| except Exception as e: | |
| reply = f"β οΈ Error generating response: {e}" | |
| return reply | |
| def chat_with_ai_api(user_input: str, user_id: str, history: List[dict] = None): | |
| """Handles the model call for the external FastAPI API.""" | |
| if user_id not in api_user_sessions: | |
| api_user_sessions[user_id] = [] | |
| if history is None: | |
| history = api_user_sessions[user_id] | |
| # 1. Prepare messages for model | |
| messages = [{"role": "system", "content": SYSTEM_PROMPT}] | |
| messages.extend(history[-10:]) | |
| messages.append({"role": "user", "content": user_input}) | |
| prompt = SYSTEM_PROMPT + "\n\nConversation history:\n" | |
| for msg in messages[-10:]: | |
| role = msg.get("role", "user") | |
| content = msg.get("content", "") | |
| prompt += f"{role.capitalize()}: {content}\n" | |
| # 2. Call model | |
| try: | |
| gemini_model = genai.GenerativeModel("gemini-1.5-flash") | |
| response = gemini_model.generate_content(prompt) | |
| reply = response.text.strip() | |
| except Exception: | |
| try: | |
| completion = openai_client.chat.completions.create( | |
| model="gpt-4o-mini", | |
| messages=messages | |
| ) | |
| reply = completion.choices[0].message.content.strip() | |
| except Exception: | |
| reply = f"β οΈ Sorry, I'm having trouble processing your request. Please try again." | |
| # 3. Update internal API session memory | |
| api_user_sessions[user_id].append({"role": "user", "content": user_input}) | |
| api_user_sessions[user_id].append({"role": "assistant", "content": reply}) | |
| if len(api_user_sessions[user_id]) > 50: | |
| api_user_sessions[user_id] = api_user_sessions[user_id][-50:] | |
| return reply | |
| def transcribe_audio(audio_file): | |
| recognizer = sr.Recognizer() | |
| try: | |
| with sr.AudioFile(audio_file) as source: | |
| audio = recognizer.record(source) | |
| return recognizer.recognize_google(audio) | |
| except Exception as e: | |
| print(f"Audio transcription error: {e}") | |
| return "Sorry, I couldn't process the audio input." | |
| def generate_voice_output(text): | |
| if not text: | |
| return None | |
| try: | |
| with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmpfile: | |
| tts = gTTS(text=text, lang="en") | |
| tts.save(tmpfile.name) | |
| return tmpfile.name | |
| except Exception as e: | |
| print(f"TTS generation error: {e}") | |
| return None | |
| def extract_text_from_pdf(file_path): | |
| try: | |
| reader = PdfReader(file_path) | |
| text = "" | |
| for page in reader.pages: | |
| page_text = page.extract_text() | |
| if page_text: | |
| text += page_text + "\n" | |
| return text | |
| except Exception: | |
| return "[Could not read PDF content]" | |
| def extract_text_from_docx(file_path): | |
| try: | |
| doc = docx.Document(file_path) | |
| text = "\n".join([para.text for para in doc.paragraphs]) | |
| return text | |
| except Exception: | |
| return "[Could not read DOCX content]" | |
| def extract_text_from_txt(file_path): | |
| try: | |
| with open(file_path, "r", encoding="utf-8") as f: | |
| return f.read() | |
| except Exception: | |
| return "[Could not read TXT content]" | |
| def summarize_text(text): | |
| if len(text.strip()) == 0: | |
| return "" | |
| # Simple chunking for very long documents | |
| chunk_size = 2000 | |
| chunks = [text[i:i+chunk_size] for i in range(0, len(text), chunk_size)] | |
| summaries = [] | |
| for chunk in chunks: | |
| prompt = f"Please summarize the following content in 3β5 concise sentences for ChatCDS:\n\n{chunk}" | |
| try: | |
| summary_response = openai_client.chat.completions.create( | |
| model="gpt-4o-mini", | |
| messages=[{"role": "system", "content": "You are a helpful summarizer."}, | |
| {"role": "user", "content": prompt}] | |
| ) | |
| summary = summary_response.choices[0].message.content.strip() | |
| summaries.append(summary) | |
| except Exception: | |
| summaries.append("[Could not summarize chunk]") | |
| return " ".join(summaries) | |
| processor = None | |
| blip_model = None | |
| image_caption_cache = {} | |
| def load_blip_models(): | |
| global processor, blip_model | |
| if processor is None: | |
| try: | |
| processor = BlipProcessor.from_pretrained("Salesforce/blip-image-captioning-base") | |
| blip_model = BlipForConditionalGeneration.from_pretrained("Salesforce/blip-image-captioning-base") | |
| except Exception as e: | |
| print(f"Failed to load BLIP models: {e}") | |
| def describe_image_advanced(image_path): | |
| load_blip_models() | |
| if processor is None or blip_model is None: | |
| return "[Image analysis skipped: Model loading failed]" | |
| if image_path in image_caption_cache: | |
| return image_caption_cache[image_path] | |
| try: | |
| img = Image.open(image_path).convert('RGB') | |
| # Generates caption focusing on community-relevant details | |
| inputs = processor(images=img, text="a detailed description of the image relevant to community projects", return_tensors="pt") | |
| out = blip_model.generate(**inputs, max_length=50) | |
| caption = processor.decode(out[0], skip_special_tokens=True) | |
| ocr_text_placeholder = "" | |
| if OCR_AVAILABLE: | |
| import pytesseract | |
| ocr_text = pytesseract.image_to_string(img).strip() | |
| if ocr_text: | |
| ocr_text_placeholder = f" (Contains text: {ocr_text[:100]}...)" | |
| result = f"[Image description: {caption}.{ocr_text_placeholder}]" | |
| image_caption_cache[image_path] = result | |
| return result | |
| except Exception as e: | |
| print(f"Image analysis error: {e}") | |
| return "[Could not analyze image]" | |
| def async_file_image_processing(file_input, image_input, user_input_container): | |
| """Processes files and images and appends context to the user input container.""" | |
| if file_input is not None: | |
| file_path = file_input.name | |
| ext = os.path.splitext(file_path)[1].lower() | |
| file_text = "" | |
| if ext == ".pdf": | |
| file_text = extract_text_from_pdf(file_path) | |
| elif ext == ".docx": | |
| file_text = extract_text_from_docx(file_path) | |
| elif ext == ".txt": | |
| file_text = extract_text_from_txt(file_path) | |
| else: | |
| user_input_container.append(f"\n[Uploaded file: {os.path.basename(file_path)} - Type not supported for summary]") | |
| if file_text: | |
| summaries = summarize_text(file_text) | |
| if summaries: | |
| user_input_container.append(f"\n[File summary: {summaries}]") | |
| if image_input is not None: | |
| img_desc = describe_image_advanced(image_input) | |
| user_input_container.append(f"\n{img_desc}") | |
| def process_input(user_input, audio_input, file_input, image_input, history): | |
| global current_session_id | |
| try: | |
| if current_session_id is None: | |
| current_session_id = generate_session_id() | |
| # 1. Handle Audio Input | |
| if audio_input is not None: | |
| transcribed_text = transcribe_audio(audio_input) | |
| user_input = transcribed_text if user_input.strip() == "" else f"{user_input}\n({transcribed_text})" | |
| # 2. Prepare combined input | |
| user_input_container = [user_input] | |
| # 3. Process files and images | |
| thread = threading.Thread(target=async_file_image_processing, args=(file_input, image_input, user_input_container)) | |
| thread.start() | |
| thread.join() | |
| # The first element is the original text input | |
| main_user_input = user_input_container[0] | |
| # Subsequent elements are context from attachments | |
| context_input = "".join(user_input_container[1:]) | |
| # Combine text and context for the full prompt sent to the model | |
| full_prompt = main_user_input | |
| if context_input: | |
| full_prompt = f"{main_user_input}\n\n[CONTEXT FROM ATTACHMENTS]:{context_input}" | |
| # 4. Generate AI response | |
| # Create temporary message list for the model, including the new user message | |
| new_user_message = {"role": "user", "content": full_prompt} | |
| model_history = history + [new_user_message] | |
| reply = generate_ai_response_gradio(model_history) | |
| # 5. Update Gradio history (Crucial fix: using dictionary format) | |
| # The Gradio component only shows 'main_user_input' to the user, not the hidden context string | |
| history.append({"role": "user", "content": main_user_input}) | |
| history.append({"role": "assistant", "content": reply}) | |
| # 6. Generate voice output | |
| voice_file = generate_voice_output(reply) | |
| # 7. Save session and update dropdown | |
| save_current_session(history) | |
| new_choices = get_chat_history_list() | |
| # 8. Return outputs, clearing inputs after successful submission | |
| # Returning None for file/audio/image components effectively clears them | |
| return history, voice_file, "", None, None, None, gr.Dropdown(choices=new_choices, value=None) | |
| except Exception as e: | |
| print(f"Critical runtime error in process_input: {e}") | |
| # If any part of the function fails, return a safe state with an error message | |
| # And ensure inputs are cleared to allow re-submission | |
| history.append({"role": "assistant", "content": f"β οΈ An error occurred: {e}. Please try again or simplify your request."}) | |
| new_choices = get_chat_history_list() | |
| return history, None, "", None, None, None, gr.Dropdown(choices=new_choices, value=None) | |
| def initialize_chat(): | |
| global current_session_id | |
| current_session_id = generate_session_id() | |
| welcome_msg = get_welcome_message() | |
| # FIXED: Use dictionary format for modern Gradio Chatbot | |
| initial_history = [{"role": "assistant", "content": welcome_msg}] | |
| return initial_history | |
| # --- FastAPI Setup --- | |
| app = FastAPI(title="ChatCDS API", version="1.0.0") | |
| app.add_middleware( | |
| CORSMiddleware, | |
| allow_origins=["*"], | |
| allow_credentials=True, | |
| allow_methods=["*"], | |
| allow_headers=["*"], | |
| ) | |
| class Message(BaseModel): | |
| role: str | |
| content: str | |
| class ChatRequest(BaseModel): | |
| message: str | |
| user_id: str | |
| history: Optional[List[Message]] = [] | |
| class ChatResponse(BaseModel): | |
| response: str | |
| user_id: str | |
| timestamp: str | |
| # Fixed FastAPI route to avoid conflict with Gradio root mount | |
| async def api_root(): | |
| """Provides status and endpoint information for the FastAPI service.""" | |
| return { | |
| "status": "online", | |
| "service": "ChatCDS API", | |
| "version": "1.0.0", | |
| "endpoints": { | |
| "status_check": "/api-status", | |
| "health_check": "/health", | |
| "chat": "/api/chat", | |
| "docs": "/docs" | |
| }, | |
| "note": "Gradio UI is mounted at the root path /" | |
| } | |
| async def health_check(): | |
| return { | |
| "status": "healthy", | |
| "active_sessions": len(api_user_sessions), | |
| "models": "Gemini + OpenAI" | |
| } | |
| async def chat_endpoint(request: ChatRequest): | |
| try: | |
| # Convert Pydantic list of Message models back into a list of dictionaries for the chat_with_ai_api function | |
| history = [msg.dict() for msg in request.history] if request.history else [] | |
| response = chat_with_ai_api( | |
| user_input=request.message, | |
| user_id=request.user_id, | |
| history=history | |
| ) | |
| from datetime import datetime | |
| return ChatResponse( | |
| response=response, | |
| user_id=request.user_id, | |
| timestamp=datetime.now().isoformat() | |
| ) | |
| except Exception as e: | |
| print(f"API Error: {e}") | |
| raise HTTPException(status_code=500, detail=str(e)) | |
| async def clear_session(user_id: str): | |
| if user_id in api_user_sessions: | |
| del api_user_sessions[user_id] | |
| return {"status": "success", "message": f"Session cleared for {user_id}"} | |
| return {"status": "info", "message": "No session found"} | |
| # --- Gradio UI Setup --- | |
| custom_css = """ | |
| #chatbot {height: 460px; overflow-y: auto; background-color: #f7f9fc;} | |
| textarea {resize: none !important;} | |
| .gr-text-input textarea {line-height: 1.5em; font-size: 15px;} | |
| .input-accordion {margin-top: 10px; border: 1px solid #e0e0e0; border-radius: 8px; padding: 10px;} | |
| .chat-history-section {background: linear-gradient(135deg, #1e3c72 0%, #2a5298 100%); padding: 15px; border-radius: 8px; margin-bottom: 15px; border: 1px solid #4a6fa5;} | |
| .chat-history-section label {color: #ffffff !important; font-weight: 500;} | |
| .chat-history-section .markdown {color: #ffffff !important;} | |
| .new-chat-btn {margin-top: 10px;} | |
| .status-message {padding: 8px; border-radius: 4px; margin-top: 8px; text-align: center; font-size: 14px;} | |
| .gradio-container {font-family: 'Inter', sans-serif;} | |
| """ | |
| def create_ui(): | |
| initial_history = initialize_chat() | |
| with gr.Blocks(css=custom_css) as demo: | |
| gr.Markdown(""" | |
| ## π ChatCDS β Artificial Intelligence for Community Development Service | |
| Empowering NYSC corps members to plan, align, and scale their CDS projects with the UN SDGs. | |
| **π API Endpoint:** Status at `/api-status`, Chat at `/api/chat`. | |
| """) | |
| with gr.Accordion("π Chat History", open=False, elem_classes="chat-history-section"): | |
| gr.Markdown("### π¬ Access your previous conversations", elem_classes="markdown") | |
| chat_history_dropdown = gr.Dropdown( | |
| label="π Your Chat Sessions", | |
| choices=[], | |
| interactive=True, | |
| allow_custom_value=False, | |
| value=None | |
| ) | |
| with gr.Row(): | |
| load_chat_btn = gr.Button("π₯ Load Chat", scale=1, variant="primary", size="sm") | |
| new_chat_btn = gr.Button("β New Chat", scale=1, variant="secondary", size="sm") | |
| with gr.Row(): | |
| with gr.Column(scale=2): | |
| rename_input = gr.Textbox( | |
| label="βοΈ Rename Selected Chat", | |
| placeholder="Enter new title...", | |
| lines=1 | |
| ) | |
| rename_btn = gr.Button("πΎ Rename", size="sm", variant="secondary") | |
| with gr.Column(scale=1): | |
| gr.Markdown("### ") | |
| delete_btn = gr.Button("ποΈ Delete Chat", size="sm", variant="stop") | |
| status_message = gr.Textbox( | |
| label="", | |
| interactive=False, | |
| show_label=False, | |
| elem_classes="status-message" | |
| ) | |
| chatbot = gr.Chatbot( | |
| elem_id="chatbot", | |
| label="ChatCDS", | |
| value=initial_history, | |
| show_label=False, | |
| type="messages" | |
| ) | |
| with gr.Row(): | |
| txt_input = gr.Textbox( | |
| label="Type your message (Press Shift + Enter to send)", | |
| placeholder="Ask about your CDS idea, SDG, or project plan...", | |
| lines=3, | |
| scale=9 | |
| ) | |
| submit_btn = gr.Button( | |
| "π Send", | |
| variant="primary", | |
| scale=1, | |
| min_width=80 | |
| ) | |
| # FIX: Explicitly wrapped inputs in gr.Column to fix "littered" layout | |
| with gr.Accordion("β Additional Options (Voice, Files, Images)", open=False, elem_classes="input-accordion"): | |
| with gr.Column(): | |
| voice_input = gr.Audio( | |
| label="π€ Voice Input", | |
| type="filepath", | |
| # Removed redundant elem_id | |
| ) | |
| file_input = gr.File( | |
| label="π Upload Document (PDF, DOCX, TXT)", | |
| file_types=[".pdf", ".docx", ".txt"], | |
| # Removed redundant elem_id | |
| ) | |
| image_input = gr.Image( | |
| label="πΌ Upload Image", | |
| type="filepath", | |
| # Removed redundant elem_id | |
| ) | |
| voice_output = gr.Audio(label="π Voice Output", type="filepath") | |
| # ----------------------------- | |
| # EVENT HANDLERS | |
| # ----------------------------- | |
| demo.load( | |
| lambda: (initialize_chat(), gr.Dropdown(choices=get_chat_history_list(), value=None)), | |
| outputs=[chatbot, chat_history_dropdown] | |
| ) | |
| # Send button click and Enter key submit are identical | |
| submit_args = { | |
| "fn": process_input, | |
| "inputs": [txt_input, voice_input, file_input, image_input, chatbot], | |
| "outputs": [chatbot, voice_output, txt_input, voice_input, file_input, image_input, chat_history_dropdown] | |
| } | |
| submit_btn.click(**submit_args) | |
| txt_input.submit(**submit_args) | |
| load_chat_btn.click( | |
| load_chat_session, | |
| inputs=[chat_history_dropdown], | |
| outputs=[chatbot, txt_input, chat_history_dropdown] | |
| ) | |
| new_chat_btn.click( | |
| start_new_chat, | |
| inputs=[chatbot], | |
| outputs=[chatbot, txt_input, voice_input, file_input, image_input, chat_history_dropdown, status_message] | |
| ) | |
| rename_btn.click( | |
| rename_chat_session, | |
| inputs=[chat_history_dropdown, rename_input], | |
| outputs=[chat_history_dropdown, status_message] | |
| ) | |
| delete_btn.click( | |
| delete_chat_session, | |
| inputs=[chat_history_dropdown], | |
| outputs=[chat_history_dropdown, status_message] | |
| ) | |
| return demo | |
| # ----------------------------- | |
| # APPLICATION ENTRY POINT | |
| # ----------------------------- | |
| # Mount the Gradio interface onto the FastAPI app instance | |
| demo = create_ui() | |
| app = gr.mount_gradio_app(app, demo, path="/") | |
| # This block ensures the combined FastAPI/Gradio application is run | |
| # correctly when the script is executed directly. | |
| if __name__ == "__main__": | |
| print("Starting ChatCDS application...") | |
| uvicorn.run(app, host="0.0.0.0", port=7860) | |