Update

Main2.py

@@ -1,7 +1,6 @@
 import os
 from flask import Flask
 from flask_sqlalchemy import SQLAlchemy
-from flask_migrate import Migrate
 from dotenv import load_dotenv
 import gradio as gr
 import requests
@@ -11,28 +10,23 @@ import uuid
 import logging
 import speech_recognition as sr
 from moviepy import VideoFileClip
-from sqlalchemy import inspect, text
 
 # Configure logging
 logging.basicConfig(level=logging.INFO,
                     format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
-# Load environment variables from .env file
+# Load environment variables
 load_dotenv()
 
 # Initialize Flask app and SQLAlchemy
 app = Flask(__name__)
-database_url = os.getenv('DATABASE_URL')
-if not database_url:
-    raise ValueError("DATABASE_URL is not set in the .env file or environment.")
-app.config['SQLALCHEMY_DATABASE_URI'] = database_url
+app.config['SQLALCHEMY_DATABASE_URI'] = os.getenv('DATABASE_URL', 'sqlite:///conversations.db')
 app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
 db = SQLAlchemy(app)
-migrate = Migrate(app, db)
 
-# Set Gemini API key from environment variable
-gemini_api_key = os.getenv('GEMINI_API_KEY')
+# Set Gemini API key
+gemini_api_key = "AIzaSyBZNNb9t18a0RVBPtch0knP3nlSNWWu4BA"  # Replace with your actual API key
 gemini_api_url = "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent"
 
 # Database models
@@ -44,6 +38,7 @@ class Character(db.Model):
 
 class Conversation(db.Model):
     __tablename__ = 'conversation'
+    
     id = db.Column(db.Integer, primary_key=True)
     character_id = db.Column(db.Integer, db.ForeignKey('character.id'), nullable=False)
     user_input = db.Column(db.Text, nullable=True)
@@ -57,46 +52,38 @@ def app_context():
     with app.app_context():
         yield
 
-# def reset_and_initialize_database():
-#     """Drop existing tables, recreate them, and verify the schema."""
-#     with app_context():
-#         try:
-            # db.session.execute(text("DROP TABLE IF EXISTS conversation CASCADE;"))
-            # db.session.execute(text("DROP TABLE IF EXISTS character CASCADE;"))
-            # db.session.commit()
-            # logger.info("Dropped existing tables 'conversation' and 'character'.")
-
-            # db.create_all()
-            # logger.info("Database tables recreated successfully.")
-
-        #     inspector = inspect(db.engine)
-        #     columns = inspector.get_columns('character')
-        #     column_names = [col['name'] for col in columns]
-        #     logger.info(f"Columns in 'character' table: {column_names}")
-        #     if 'prompt_template' not in column_names:
-        #         raise RuntimeError("Failed to create 'prompt_template' column in 'character' table.")
-        # except Exception as e:
-        #     db.session.rollback()
-        #     logger.error(f"Error resetting database: {e}")
-        #     raise
-
 def add_predefined_characters():
     with app_context():
         characters = [
-            {"name": "Chuck the Clown", "description": "A funny clown who tells jokes and entertains.", "prompt_template": "You are Chuck the Clown, always ready with a joke and entertainment. Be upbeat, silly, and include jokes in your responses."},
-            {"name": "Sarcastic Pirate", "description": "A pirate with a sharp tongue and a love for treasure.", "prompt_template": "You are a Sarcastic Pirate, ready to share your tales of adventure. Use pirate slang, be witty, sarcastic, and mention your love for treasure and the sea."},
-            {"name": "Professor Sage", "description": "A wise professor knowledgeable about many subjects.", "prompt_template": "You are Professor Sage, sharing wisdom and knowledge. Be scholarly, thoughtful, and provide educational information in your responses."}
+            {
+                "name": "Chuck the Clown",
+                "description": "A funny clown who tells jokes and entertains.",
+                "prompt_template": "You are Chuck the Clown, always ready with a joke and entertainment. Be upbeat, silly, and include jokes in your responses."
+            },
+            {
+                "name": "Sarcastic Pirate",
+                "description": "A pirate with a sharp tongue and a love for treasure.",
+                "prompt_template": "You are a Sarcastic Pirate, ready to share your tales of adventure. Use pirate slang, be witty, sarcastic, and mention your love for treasure and the sea."
+            },
+            {
+                "name": "Professor Sage",
+                "description": "A wise professor knowledgeable about many subjects.",
+                "prompt_template": "You are Professor Sage, sharing wisdom and knowledge. Be scholarly, thoughtful, and provide educational information in your responses."
+            }
         ]
 
         for char_data in characters:
             if not Character.query.filter_by(name=char_data["name"]).first():
-                new_character = Character(name=char_data["name"], description=char_data["description"], prompt_template=char_data["prompt_template"])
+                new_character = Character(
+                    name=char_data["name"],
+                    description=char_data["description"],
+                    prompt_template=char_data["prompt_template"]
+                )
                 db.session.add(new_character)
                 logger.info(f"Adding predefined character: {char_data['name']}")
         
         try:
             db.session.commit()
-            logger.info("Predefined characters added successfully.")
         except Exception as e:
             db.session.rollback()
             logger.error(f"Error adding predefined characters: {e}")
@@ -106,11 +93,17 @@ def add_character(name, description, prompt_template):
         try:
             if Character.query.filter_by(name=name).first():
                 return f"Character '{name}' already exists!"
-            new_character = Character(name=name, description=description, prompt_template=prompt_template)
+
+            new_character = Character(
+                name=name,
+                description=description,
+                prompt_template=prompt_template
+            )
             db.session.add(new_character)
             db.session.commit()
             logger.info(f"Successfully added character: {name}")
             return f"Character '{name}' added successfully!\nDescription: {description}"
+        
         except Exception as e:
             db.session.rollback()
             logger.error(f"Error adding character: {e}")
@@ -128,28 +121,49 @@ def get_existing_characters():
 def chat_with_character(character_name, user_input, user_id, chat_id=None):
     with app_context():
         try:
-            if not gemini_api_key:
-                raise ValueError("GEMINI_API_KEY is not set in the environment.")
-            
             character = Character.query.filter_by(name=character_name).first()
+            
             if not character:
                 return "Character not found.", None
+            
             if not chat_id:
                 chat_id = str(uuid.uuid4())
+            
+            # Retrieve previous conversations for context
             previous_conversations = Conversation.query.filter_by(user_id=user_id).order_by(Conversation.timestamp).all()
             context_prompt = " ".join([f"User: {conv.user_input}\nBot: {conv.bot_response}" for conv in previous_conversations])
             prompt_template = character.prompt_template
             full_prompt = f"{prompt_template}\n{context_prompt}\nUser: {user_input}\nBot:"
 
-            payload = {"contents": [{"parts": [{"text": full_prompt}]}]}
-            headers = {'Content-Type': 'application/json'}
-            response = requests.post(gemini_api_url, headers=headers, json=payload, params={'key': gemini_api_key})
+            payload = {
+                "contents": [{
+                    "parts": [{"text": full_prompt}]
+                }]
+            }
+
+            headers = {
+                'Content-Type': 'application/json'
+            }
+
+            response = requests.post(
+                gemini_api_url,
+                headers=headers,
+                json=payload,
+                params={'key': gemini_api_key}
+            )
 
             if response.status_code == 200:
                 response_data = response.json()
-                if 'candidates' in response_data and response_data['candidates']:
+                if 'candidates' in response_data and len(response_data['candidates']) > 0:
                     bot_response = response_data['candidates'][0]['content']['parts'][0]['text']
-                    conversation = Conversation(character_id=character.id, user_input=user_input, bot_response=bot_response, chat_id=chat_id, user_id=user_id)
+                    
+                    conversation = Conversation(
+                        character_id=character.id,
+                        user_input=user_input,
+                        bot_response=bot_response,
+                        chat_id=chat_id,
+                        user_id=user_id
+                    )
                     db.session.add(conversation)
                     db.session.commit()
                     logger.info(f"Saved conversation with chat_id: {chat_id}")
@@ -159,11 +173,13 @@ def chat_with_character(character_name, user_input, user_id, chat_id=None):
             else:
                 logger.error(f"Error from Gemini API: {response.json()}")
                 return f"An error occurred while generating content: {response.status_code} - {response.text}", chat_id
+
         except Exception as e:
             logger.error(f"Unexpected error in chat_with_character: {e}")
             return f"An unexpected error occurred: {str(e)}", chat_id
 
 def speech_to_text(audio_file):
+    """Convert audio file to text using SpeechRecognition."""
     recognizer = sr.Recognizer()
     with sr.AudioFile(audio_file) as source:
         audio_data = recognizer.record(source)
@@ -177,48 +193,50 @@ def speech_to_text(audio_file):
             return None
 
 def extract_audio_from_video(video_file):
-    audio_file_path = "temp_audio.wav"
+    """Extract audio from video and return the audio file path."""
+    audio_file_path = "temp_audio.wav"  # Temporary file name
     try:
         with VideoFileClip(video_file) as video:
             video.audio.write_audiofile(audio_file_path)
     except Exception as e:
         logger.error(f"Error extracting audio from video: {e}")
-        return None
+        return None  # Return None if there's an error
     return audio_file_path
 
 def get_chat_history(user_id):
+    """Retrieve chat history for a specific user ID."""
     with app_context():
-        try:
-            conversations = Conversation.query.filter_by(user_id=user_id).order_by(Conversation.timestamp).all()
-            return conversations
-        except Exception as e:
-            logger.error(f"Error retrieving chat history: {e}")
-            return []
+        conversations = Conversation.query.filter_by(user_id=user_id).order_by(Conversation.timestamp).all()
+        return conversations if conversations else []  # Return empty list if no conversations
 
 def create_interface():
-    with app_context():
-        add_predefined_characters()
+    with app.app_context():
+        add_predefined_characters()  # Add predefined characters if needed
     
     with gr.Blocks(title="Character Chat System", theme=gr.themes.Default()) as iface:
-        current_chat_id = gr.State(value=None)
-        user_id = gr.State(value=None)
-        chat_messages = gr.State(value=[])
+        current_chat_id = gr.State(value=None)  # State to track the current chat ID
+        user_id = gr.State(value=None)  # State to track user ID
+        chat_messages = gr.State(value=[])  # State to store chat messages
         
-        gr.Markdown("# 🎭 Character Chat System 🎭", elem_id="title")
+        gr.Markdown(
+            "# 🎭 Character Chat System 🎭",
+            elem_id="title"
+        )
         
         with gr.Tab("Sign In"):
-            user_id_input = gr.Textbox(label="User ID (Numeric)", placeholder="Enter your numeric User ID (e.g., 123)", elem_id="user_id_input", interactive=True, lines=2)
+            user_id_input = gr.Textbox(label="User ID", placeholder="Enter your User ID", elem_id="user_id_input", interactive=True, lines=2)
             sign_in_btn = gr.Button("Sign In", variant="primary")
             sign_in_response = gr.Textbox(label="Sign In Response", interactive=False)
 
             def sign_in(user_id_input):
-                try:
-                    user_id_int = int(user_id_input)  # Convert to integer
-                    return f"Welcome, User {user_id_int}!", user_id_int
-                except ValueError:
-                    return "Please enter a valid numeric User ID (e.g., 123)!", None
+                user_id.value = user_id_input
+                return f"Welcome, {user_id_input}!", user_id_input
             
-            sign_in_btn.click(fn=sign_in, inputs=[user_id_input], outputs=[sign_in_response, user_id])
+            sign_in_btn.click(
+                fn=sign_in,
+                inputs=[user_id_input],
+                outputs=[sign_in_response]
+            )
 
         with gr.Tab("Admin: Add Character"):
             with gr.Row():
@@ -228,59 +246,101 @@ def create_interface():
                     prompt_input = gr.Textbox(label="Prompt Template", placeholder="Enter character prompt template", elem_id="prompt_input", lines=3)
                     add_character_btn = gr.Button("Add Character", elem_id="add_character_btn", variant="primary")
                     add_character_response = gr.Textbox(label="Response", interactive=False, elem_id="response_output")
-                    add_character_btn.click(fn=add_character, inputs=[name_input, description_input, prompt_input], outputs=[add_character_response])
+
+                    add_character_btn.click(
+                        fn=add_character,
+                        inputs=[name_input, description_input, prompt_input],
+                        outputs=[add_character_response]
+                    )
+                    
                 with gr.Column():
                     gr.Markdown("## 🌟 Existing Characters 🌟", elem_id="existing_chars_title")
                     existing_characters = get_existing_characters()
-                    character_list = gr.Dataframe(value=existing_characters, headers=["Name", "Description"], interactive=False, elem_id="character_list")
+                    
+                    character_list = gr.Dataframe(
+                        value=existing_characters,
+                        headers=["Name", "Description"],
+                        interactive=False,
+                        elem_id="character_list"
+                    )
+                    
                     refresh_characters_btn = gr.Button("Refresh Character List")
-                    refresh_characters_btn.click(fn=lambda: gr.update(value=get_existing_characters()), outputs=[character_list])
+                    
+                    def refresh_characters():
+                        return gr.update(value=get_existing_characters())
+                    
+                    refresh_characters_btn.click(
+                        fn=refresh_characters,
+                        outputs=[character_list]
+                    )
         
         with gr.Tab("Chat with Character"):
             with gr.Row():
-                character_dropdown = gr.Dropdown(label="Choose Character", choices=[char[0] for char in get_existing_characters()], elem_id="character_dropdown")
-                chat_id_display = gr.Textbox(label="Current Chat ID", interactive=False, elem_id="chat_id_display")
-                user_input = gr.Textbox(label="Your Message", placeholder="Type your message or use audio/video input", elem_id="user_input", lines=2)
-                audio_input = gr.Audio(label="Audio Input", type="filepath", elem_id="audio_input")
-                video_input = gr.Video(label="Video Input", elem_id="video_input")
+                character_dropdown = gr.Dropdown(
+                    label="Choose Character", 
+                    choices=[char[0] for char in get_existing_characters()],
+                    elem_id="character_dropdown"
+                )
+                
+                chat_id_display = gr.Textbox(
+                    label="Current Chat ID", 
+                    interactive=False,
+                    elem_id="chat_id_display"
+                )
+                
+                user_input = gr.Textbox(
+                    label="Your Message",
+                    placeholder="Type your message or use audio input",
+                    elem_id="user_input",
+                    lines=2  # Reduced height for better fitting
+                )
+
+                audio_input = gr.Audio(
+                    label="Audio Input",
+                    type="filepath",  # Type to receive audio file
+                    elem_id="audio_input"
+                )
+
+                video_input = gr.Video(
+                    label="Video Input",  # No type argument needed
+                    elem_id="video_input"
+                )
+                
                 chat_btn = gr.Button("Send", variant="primary")
-                chat_response = gr.Chatbot(label="Chat Responses", elem_id="chat_response", height=300, type="messages")  # Updated to 'messages' type
-
-                def handle_chat(character_name, user_input, audio_file, video_file, user_id, chat_messages, current_chat_id):
-                    if not user_id:
-                        return chat_messages, current_chat_id, "Please sign in with a numeric User ID first!"
-                    if not character_name:
-                        return chat_messages, current_chat_id, "Please select a character!"
-                    final_input = user_input or ""
-                    
+                chat_response = gr.Chatbot(
+                    label="Chat Responses", 
+                    elem_id="chat_response",
+                    height=300  # Set fixed height for the chat display
+                )
+                
+                def handle_chat(character_name, user_input, audio_file, video_file, user_id, chat_messages):
                     if audio_file:
-                        audio_text = speech_to_text(audio_file)
-                        if audio_text:
-                            final_input += f" {audio_text}"
-                        else:
-                            chat_messages.append({"role": "assistant", "content": "Could not understand audio."})
-                            return chat_messages, current_chat_id, None
+                        user_input = speech_to_text(audio_file)
+                        if user_input is None:
+                            return chat_messages, None
                     
                     if video_file:
                         audio_file_path = extract_audio_from_video(video_file)
-                        if audio_file_path:
-                            video_text = speech_to_text(audio_file_path)
-                            if video_text:
-                                final_input += f" {video_text}"
-                            chat_messages.append({"role": "user", "content": "Video uploaded"})
-                        else:
-                            chat_messages.append({"role": "assistant", "content": "Failed to extract audio from video."})
-                            return chat_messages, current_chat_id, None
+                        if audio_file_path is None:  # Check if audio extraction failed
+                            chat_messages.append(("Bot", "Failed to extract audio from video. Please try a different file."))
+                            return chat_messages, None
 
-                    if not final_input.strip():
-                        return chat_messages, current_chat_id, "Please provide a message, audio, or video!"
+                        extracted_text = speech_to_text(audio_file_path)
+                        if extracted_text:
+                            user_input += f" {extracted_text}"  # Append transcribed text
 
-                    response, new_chat_id = chat_with_character(character_name, final_input, user_id, current_chat_id)
-                    chat_messages.append({"role": "user", "content": final_input})
-                    chat_messages.append({"role": "assistant", "content": response})
-                    return chat_messages, new_chat_id, new_chat_id
+                        chat_messages.append(("User", "Video uploaded"))  # Indicate video upload
+
+                    response, new_chat_id = chat_with_character(character_name, user_input, user_id)
+                    chat_messages.append(("User", user_input))  # Add user message
+                    chat_messages.append(("Bot", response))  # Add bot response
+                    return chat_messages, new_chat_id
                 
-                chat_btn.click(fn=handle_chat, inputs=[character_dropdown, user_input, audio_input, video_input, user_id, chat_messages, current_chat_id], outputs=[chat_response, current_chat_id, chat_id_display])
+                chat_btn.click(
+                    fn=handle_chat,
+                    inputs=[character_dropdown, user_input, audio_input, video_input, user_id, chat_messages],
+                    outputs=[chat_response, current_chat_id]
+                )
         
         with gr.Tab("Chat History"):
             with gr.Row():
@@ -289,41 +349,48 @@ def create_interface():
                 chat_history_display = gr.Dataframe(label="Chat History", interactive=False)
 
                 def load_chat_history(user_id):
-                    if not user_id:
-                        return [("Error", "Please sign in with a numeric User ID to view chat history.")]
                     history = get_chat_history(user_id)
                     return [(conv.id, f"User: {conv.user_input}\nBot: {conv.bot_response} at {conv.timestamp}") for conv in history]
 
-                view_history_btn.click(fn=load_chat_history, inputs=[user_id], outputs=[chat_history_display])
+                view_history_btn.click(
+                    fn=load_chat_history,
+                    inputs=[user_id],
+                    outputs=[chat_history_display]
+                )
 
         with gr.Tab("API Status"):
             with gr.Row():
                 gr.Markdown("## 🔌 API Connection Status 🔌")
                 check_api_btn = gr.Button("Check API Status", variant="primary")
                 api_status_display = gr.Textbox(label="API Status", interactive=False)
-                check_api_btn.click(fn=lambda: "✅ API connection successful!" if requests.post(gemini_api_url, headers={'Content-Type': 'application/json'}, json={"contents": [{"parts": [{"text": "Hello"}]}]}, params={'key': gemini_api_key}).status_code == 200 else "❌ API connection failed!", outputs=[api_status_display])
+
+                def check_api_status():
+                    try:
+                        response = requests.post(
+                            gemini_api_url,
+                            headers={'Content-Type': 'application/json'},
+                            json={"contents": [{"parts": [{"text": "Hello"}]}]},
+                            params={'key': gemini_api_key}
+                        )
+                        if response.status_code == 200:
+                            return "✅ API connection successful! Gemini API is operational."
+                        else:
+                            return f"❌ API connection failed: {response.status_code} - {response.text}"
+                    except Exception as e:
+                        return f"❌ API error: {str(e)}"
+
+                check_api_btn.click(
+                    fn=check_api_status,
+                    outputs=[api_status_display]
+                )
     
     return iface
 
 if __name__ == "__main__":
-    if not os.getenv('DATABASE_URL'):
-        logger.error("DATABASE_URL is not set in the .env file or environment.")
-        raise ValueError("DATABASE_URL is required.")
-    if not os.getenv('GEMINI_API_KEY'):
-        logger.error("GEMINI_API_KEY is not set in the .env file or environment.")
-        raise ValueError("GEMINI_API_KEY is required.")
-
-    # with app_context():
-    #     try:
-    #         # reset_and_initialize_database()
-    #         # add_predefined_characters()
-    #     except Exception as e:
-    #         logger.error(f"Error initializing database: {e}")
-    #         logger.info("If the error persists, manually drop the tables using psql:")
-    #         logger.info("psql \"postgresql://avnadmin:AVNS_WIH89YjY1kOIOBH-cFF@pg-197dad92-elyxir4lyf-aa02.d.aivencloud.com:20563/defaultdb?sslmode=require\"")
-    #         logger.info("Then run: DROP TABLE character; DROP TABLE conversation;")
-    #         raise
-
+    with app.app_context():
+        db.create_all()  # Ensure tables are created
+        add_predefined_characters()  # Add predefined characters if needed
+    
     chat_interface = create_interface()
     logger.info("Starting Gradio interface...")
     chat_interface.launch(share=True)