Upgrade

Main2.py

@@ -1,6 +1,7 @@
 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
@@ -10,23 +11,28 @@ 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
+# Load environment variables from .env file
 load_dotenv()
 
 # Initialize Flask app and SQLAlchemy
 app = Flask(__name__)
-app.config['SQLALCHEMY_DATABASE_URI'] = os.getenv('DATABASE_URL', 'sqlite:///conversations.db')
+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_TRACK_MODIFICATIONS'] = False
 db = SQLAlchemy(app)
+migrate = Migrate(app, db)
 
-# Set Gemini API key
-gemini_api_key = "AIzaSyBZNNb9t18a0RVBPtch0knP3nlSNWWu4BA"  # Replace with your actual API key
+# Set Gemini API key from environment variable
+gemini_api_key = os.getenv('GEMINI_API_KEY')
 gemini_api_url = "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent"
 
 # Database models
@@ -38,7 +44,6 @@ 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)
@@ -52,38 +57,46 @@ 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}")
@@ -93,17 +106,11 @@ 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}")
@@ -121,49 +128,28 @@ def get_existing_characters():
 def chat_with_character(character_name, user_input, user_id, chat_id=None):
     with app_context():
         try:
-            character = Character.query.filter_by(name=character_name).first()
+            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 len(response_data['candidates']) > 0:
+                if 'candidates' in response_data and response_data['candidates']:
                     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}")
@@ -173,13 +159,11 @@ 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)
@@ -193,50 +177,48 @@ def speech_to_text(audio_file):
             return None
 
 def extract_audio_from_video(video_file):
-    """Extract audio from video and return the audio file path."""
-    audio_file_path = "temp_audio.wav"  # Temporary file name
+    audio_file_path = "temp_audio.wav"
     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 if there's an error
+        return None
     return audio_file_path
 
 def get_chat_history(user_id):
-    """Retrieve chat history for a specific user ID."""
     with app_context():
-        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
+        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 []
 
 def create_interface():
-    with app.app_context():
-        add_predefined_characters()  # Add predefined characters if needed
+    with app_context():
+        add_predefined_characters()
     
     with gr.Blocks(title="Character Chat System", theme=gr.themes.Default()) as iface:
-        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
+        current_chat_id = gr.State(value=None)
+        user_id = gr.State(value=None)
+        chat_messages = gr.State(value=[])
         
-        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", placeholder="Enter your User ID", elem_id="user_id_input", interactive=True, lines=2)
+            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)
             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):
-                user_id.value = user_id_input
-                return f"Welcome, {user_id_input}!", 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
             
-            sign_in_btn.click(
-                fn=sign_in,
-                inputs=[user_id_input],
-                outputs=[sign_in_response]
-            )
+            sign_in_btn.click(fn=sign_in, inputs=[user_id_input], outputs=[sign_in_response, user_id])
 
         with gr.Tab("Admin: Add Character"):
             with gr.Row():
@@ -246,101 +228,59 @@ 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")
-                    
-                    def refresh_characters():
-                        return gr.update(value=get_existing_characters())
-                    
-                    refresh_characters_btn.click(
-                        fn=refresh_characters,
-                        outputs=[character_list]
-                    )
+                    refresh_characters_btn.click(fn=lambda: gr.update(value=get_existing_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 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"
-                )
-                
+                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")
                 chat_btn = gr.Button("Send", variant="primary")
-                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):
+                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 ""
+                    
                     if audio_file:
-                        user_input = speech_to_text(audio_file)
-                        if user_input is None:
-                            return chat_messages, None
+                        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
                     
                     if video_file:
                         audio_file_path = extract_audio_from_video(video_file)
-                        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
-
-                        extracted_text = speech_to_text(audio_file_path)
-                        if extracted_text:
-                            user_input += f" {extracted_text}"  # Append transcribed text
+                        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
 
-                        chat_messages.append(("User", "Video uploaded"))  # Indicate video upload
+                    if not final_input.strip():
+                        return chat_messages, current_chat_id, "Please provide a message, audio, or video!"
 
-                    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
+                    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_btn.click(
-                    fn=handle_chat,
-                    inputs=[character_dropdown, user_input, audio_input, video_input, user_id, chat_messages],
-                    outputs=[chat_response, current_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])
         
         with gr.Tab("Chat History"):
             with gr.Row():
@@ -349,48 +289,41 @@ 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)
-
-                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]
-                )
+                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])
     
     return iface
 
 if __name__ == "__main__":
-    with app.app_context():
-        db.create_all()  # Ensure tables are created
-        add_predefined_characters()  # Add predefined characters if needed
-    
+    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
+
     chat_interface = create_interface()
     logger.info("Starting Gradio interface...")
     chat_interface.launch(share=True)