Upload 3 files

App_Function_Libraries/DB/Character_Chat_DB.py

@@ -0,0 +1,684 @@
+# character_chat_db.py
+# Database functions for managing character cards and chat histories.
+# #
+# Imports
+import configparser
+import sqlite3
+import json
+import os
+import sys
+from typing import List, Dict, Optional, Tuple, Any, Union
+
+from App_Function_Libraries.Utils.Utils import get_database_dir, get_project_relative_path, get_database_path
+from Tests.Chat_APIs.Chat_APIs_Integration_test import logging
+
+#
+#######################################################################################################################
+#
+#
+
+def ensure_database_directory():
+    os.makedirs(get_database_dir(), exist_ok=True)
+
+ensure_database_directory()
+
+
+# Construct the path to the config file
+config_path = get_project_relative_path('Config_Files/config.txt')
+
+# Read the config file
+config = configparser.ConfigParser()
+config.read(config_path)
+
+# Get the chat db path from the config, or use the default if not specified
+chat_DB_PATH = config.get('Database', 'chatDB_path', fallback=get_database_path('chatDB.db'))
+print(f"Chat Database path: {chat_DB_PATH}")
+
+########################################################################################################
+#
+# Functions
+
+# FIXME - Setup properly and test/add documentation for its existence...
+def initialize_database():
+    """Initialize the SQLite database with required tables and FTS5 virtual tables."""
+    conn = None
+    try:
+        conn = sqlite3.connect(chat_DB_PATH)
+        cursor = conn.cursor()
+
+        # Enable foreign key constraints
+        cursor.execute("PRAGMA foreign_keys = ON;")
+
+        # Create CharacterCards table with V2 fields
+        cursor.execute("""
+        CREATE TABLE IF NOT EXISTS CharacterCards (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            name TEXT UNIQUE NOT NULL,
+            description TEXT,
+            personality TEXT,
+            scenario TEXT,
+            image BLOB,
+            post_history_instructions TEXT,
+            first_mes TEXT,
+            mes_example TEXT,
+            creator_notes TEXT,
+            system_prompt TEXT,
+            alternate_greetings TEXT,
+            tags TEXT,
+            creator TEXT,
+            character_version TEXT,
+            extensions TEXT,
+            created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+        );
+        """)
+
+        # Create CharacterChats table
+        cursor.execute("""
+        CREATE TABLE IF NOT EXISTS CharacterChats (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            character_id INTEGER NOT NULL,
+            conversation_name TEXT,
+            chat_history TEXT,
+            is_snapshot BOOLEAN DEFAULT FALSE,
+            created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+            FOREIGN KEY (character_id) REFERENCES CharacterCards(id) ON DELETE CASCADE
+        );
+        """)
+
+        # Create FTS5 virtual table for CharacterChats
+        cursor.execute("""
+        CREATE VIRTUAL TABLE IF NOT EXISTS CharacterChats_fts USING fts5(
+            conversation_name,
+            chat_history,
+            content='CharacterChats',
+            content_rowid='id'
+        );
+        """)
+
+        # Create triggers to keep FTS5 table in sync with CharacterChats
+        cursor.executescript("""
+        CREATE TRIGGER IF NOT EXISTS CharacterChats_ai AFTER INSERT ON CharacterChats BEGIN
+            INSERT INTO CharacterChats_fts(rowid, conversation_name, chat_history)
+            VALUES (new.id, new.conversation_name, new.chat_history);
+        END;
+
+        CREATE TRIGGER IF NOT EXISTS CharacterChats_ad AFTER DELETE ON CharacterChats BEGIN
+            DELETE FROM CharacterChats_fts WHERE rowid = old.id;
+        END;
+
+        CREATE TRIGGER IF NOT EXISTS CharacterChats_au AFTER UPDATE ON CharacterChats BEGIN
+            UPDATE CharacterChats_fts SET conversation_name = new.conversation_name, chat_history = new.chat_history
+            WHERE rowid = new.id;
+        END;
+        """)
+
+        # Create ChatKeywords table
+        cursor.execute("""
+        CREATE TABLE IF NOT EXISTS ChatKeywords (
+            chat_id INTEGER NOT NULL,
+            keyword TEXT NOT NULL,
+            FOREIGN KEY (chat_id) REFERENCES CharacterChats(id) ON DELETE CASCADE
+        );
+        """)
+
+        # Create indexes for faster searches
+        cursor.execute("""
+        CREATE INDEX IF NOT EXISTS idx_chatkeywords_keyword ON ChatKeywords(keyword);
+        """)
+        cursor.execute("""
+        CREATE INDEX IF NOT EXISTS idx_chatkeywords_chat_id ON ChatKeywords(chat_id);
+        """)
+
+        conn.commit()
+        logging.info("Database initialized successfully.")
+    except sqlite3.Error as e:
+        logging.error(f"SQLite error occurred during database initialization: {e}")
+        if conn:
+            conn.rollback()
+        raise
+    except Exception as e:
+        logging.error(f"Unexpected error occurred during database initialization: {e}")
+        if conn:
+            conn.rollback()
+        raise
+    finally:
+        if conn:
+            conn.close()
+
+# Call initialize_database() at the start of your application
+def setup_chat_database():
+    try:
+        initialize_database()
+    except Exception as e:
+        logging.critical(f"Failed to initialize database: {e}")
+        sys.exit(1)
+
+setup_chat_database()
+
+########################################################################################################
+#
+# Character Card handling
+
+def parse_character_card(card_data: Dict[str, Any]) -> Dict[str, Any]:
+    """Parse and validate a character card according to V2 specification."""
+    v2_data = {
+        'name': card_data.get('name', ''),
+        'description': card_data.get('description', ''),
+        'personality': card_data.get('personality', ''),
+        'scenario': card_data.get('scenario', ''),
+        'first_mes': card_data.get('first_mes', ''),
+        'mes_example': card_data.get('mes_example', ''),
+        'creator_notes': card_data.get('creator_notes', ''),
+        'system_prompt': card_data.get('system_prompt', ''),
+        'post_history_instructions': card_data.get('post_history_instructions', ''),
+        'alternate_greetings': json.dumps(card_data.get('alternate_greetings', [])),
+        'tags': json.dumps(card_data.get('tags', [])),
+        'creator': card_data.get('creator', ''),
+        'character_version': card_data.get('character_version', ''),
+        'extensions': json.dumps(card_data.get('extensions', {}))
+    }
+
+    # Handle 'image' separately as it might be binary data
+    if 'image' in card_data:
+        v2_data['image'] = card_data['image']
+
+    return v2_data
+
+
+def add_character_card(card_data: Dict[str, Any]) -> Optional[int]:
+    """Add or update a character card in the database."""
+    conn = sqlite3.connect(chat_DB_PATH)
+    cursor = conn.cursor()
+    try:
+        parsed_card = parse_character_card(card_data)
+
+        # Check if character already exists
+        cursor.execute("SELECT id FROM CharacterCards WHERE name = ?", (parsed_card['name'],))
+        row = cursor.fetchone()
+
+        if row:
+            # Update existing character
+            character_id = row[0]
+            update_query = """
+                UPDATE CharacterCards
+                SET description = ?, personality = ?, scenario = ?, image = ?, 
+                    post_history_instructions = ?, first_mes = ?, mes_example = ?,
+                    creator_notes = ?, system_prompt = ?, alternate_greetings = ?,
+                    tags = ?, creator = ?, character_version = ?, extensions = ?
+                WHERE id = ?
+            """
+            cursor.execute(update_query, (
+                parsed_card['description'], parsed_card['personality'], parsed_card['scenario'],
+                parsed_card['image'], parsed_card['post_history_instructions'], parsed_card['first_mes'],
+                parsed_card['mes_example'], parsed_card['creator_notes'], parsed_card['system_prompt'],
+                parsed_card['alternate_greetings'], parsed_card['tags'], parsed_card['creator'],
+                parsed_card['character_version'], parsed_card['extensions'], character_id
+            ))
+        else:
+            # Insert new character
+            insert_query = """
+                INSERT INTO CharacterCards (name, description, personality, scenario, image, 
+                post_history_instructions, first_mes, mes_example, creator_notes, system_prompt, 
+                alternate_greetings, tags, creator, character_version, extensions)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """
+            cursor.execute(insert_query, (
+                parsed_card['name'], parsed_card['description'], parsed_card['personality'],
+                parsed_card['scenario'], parsed_card['image'], parsed_card['post_history_instructions'],
+                parsed_card['first_mes'], parsed_card['mes_example'], parsed_card['creator_notes'],
+                parsed_card['system_prompt'], parsed_card['alternate_greetings'], parsed_card['tags'],
+                parsed_card['creator'], parsed_card['character_version'], parsed_card['extensions']
+            ))
+            character_id = cursor.lastrowid
+
+        conn.commit()
+        return character_id
+    except sqlite3.IntegrityError as e:
+        logging.error(f"Error adding character card: {e}")
+        return None
+    except Exception as e:
+        logging.error(f"Unexpected error adding character card: {e}")
+        return None
+    finally:
+        conn.close()
+
+# def add_character_card(card_data: Dict) -> Optional[int]:
+#     """Add or update a character card in the database.
+#
+#     Returns the ID of the inserted character or None if failed.
+#     """
+#     conn = sqlite3.connect(chat_DB_PATH)
+#     cursor = conn.cursor()
+#     try:
+#         # Ensure all required fields are present
+#         required_fields = ['name', 'description', 'personality', 'scenario', 'image', 'post_history_instructions', 'first_message']
+#         for field in required_fields:
+#             if field not in card_data:
+#                 card_data[field] = ''  # Assign empty string if field is missing
+#
+#         # Check if character already exists
+#         cursor.execute("SELECT id FROM CharacterCards WHERE name = ?", (card_data['name'],))
+#         row = cursor.fetchone()
+#
+#         if row:
+#             # Update existing character
+#             character_id = row[0]
+#             cursor.execute("""
+#                 UPDATE CharacterCards
+#                 SET description = ?, personality = ?, scenario = ?, image = ?, post_history_instructions = ?, first_message = ?
+#                 WHERE id = ?
+#             """, (
+#                 card_data['description'],
+#                 card_data['personality'],
+#                 card_data['scenario'],
+#                 card_data['image'],
+#                 card_data['post_history_instructions'],
+#                 card_data['first_message'],
+#                 character_id
+#             ))
+#         else:
+#             # Insert new character
+#             cursor.execute("""
+#                 INSERT INTO CharacterCards (name, description, personality, scenario, image, post_history_instructions, first_message)
+#                 VALUES (?, ?, ?, ?, ?, ?, ?)
+#             """, (
+#                 card_data['name'],
+#                 card_data['description'],
+#                 card_data['personality'],
+#                 card_data['scenario'],
+#                 card_data['image'],
+#                 card_data['post_history_instructions'],
+#                 card_data['first_message']
+#             ))
+#             character_id = cursor.lastrowid
+#
+#         conn.commit()
+#         return cursor.lastrowid
+#     except sqlite3.IntegrityError as e:
+#         logging.error(f"Error adding character card: {e}")
+#         return None
+#     except Exception as e:
+#         logging.error(f"Unexpected error adding character card: {e}")
+#         return None
+#     finally:
+#         conn.close()
+
+
+def get_character_cards() -> List[Dict]:
+    """Retrieve all character cards from the database."""
+    logging.debug(f"Fetching characters from DB: {chat_DB_PATH}")
+    conn = sqlite3.connect(chat_DB_PATH)
+    cursor = conn.cursor()
+    cursor.execute("SELECT * FROM CharacterCards")
+    rows = cursor.fetchall()
+    columns = [description[0] for description in cursor.description]
+    conn.close()
+    characters = [dict(zip(columns, row)) for row in rows]
+    #logging.debug(f"Characters fetched from DB: {characters}")
+    return characters
+
+
+def get_character_card_by_id(character_id: Union[int, Dict[str, Any]]) -> Optional[Dict[str, Any]]:
+    """
+    Retrieve a single character card by its ID.
+
+    Args:
+        character_id: Can be either an integer ID or a dictionary containing character data.
+
+    Returns:
+        A dictionary containing the character card data, or None if not found.
+    """
+    conn = sqlite3.connect(chat_DB_PATH)
+    cursor = conn.cursor()
+    try:
+        if isinstance(character_id, dict):
+            # If a dictionary is passed, assume it's already a character card
+            return character_id
+        elif isinstance(character_id, int):
+            # If an integer is passed, fetch the character from the database
+            cursor.execute("SELECT * FROM CharacterCards WHERE id = ?", (character_id,))
+            row = cursor.fetchone()
+            if row:
+                columns = [description[0] for description in cursor.description]
+                return dict(zip(columns, row))
+        else:
+            logging.warning(f"Invalid type for character_id: {type(character_id)}")
+        return None
+    except Exception as e:
+        logging.error(f"Error in get_character_card_by_id: {e}")
+        return None
+    finally:
+        conn.close()
+
+
+def update_character_card(character_id: int, card_data: Dict) -> bool:
+    """Update an existing character card."""
+    conn = sqlite3.connect(chat_DB_PATH)
+    cursor = conn.cursor()
+    try:
+        cursor.execute("""
+            UPDATE CharacterCards
+            SET name = ?, description = ?, personality = ?, scenario = ?, image = ?, post_history_instructions = ?, first_message = ?
+            WHERE id = ?
+        """, (
+            card_data.get('name'),
+            card_data.get('description'),
+            card_data.get('personality'),
+            card_data.get('scenario'),
+            card_data.get('image'),
+            card_data.get('post_history_instructions', ''),
+            card_data.get('first_message', "Hello! I'm ready to chat."),
+            character_id
+        ))
+        conn.commit()
+        return cursor.rowcount > 0
+    except sqlite3.IntegrityError as e:
+        logging.error(f"Error updating character card: {e}")
+        return False
+    finally:
+        conn.close()
+
+
+def delete_character_card(character_id: int) -> bool:
+    """Delete a character card and its associated chats."""
+    conn = sqlite3.connect(chat_DB_PATH)
+    cursor = conn.cursor()
+    try:
+        # Delete associated chats first due to foreign key constraint
+        cursor.execute("DELETE FROM CharacterChats WHERE character_id = ?", (character_id,))
+        cursor.execute("DELETE FROM CharacterCards WHERE id = ?", (character_id,))
+        conn.commit()
+        return cursor.rowcount > 0
+    except sqlite3.Error as e:
+        logging.error(f"Error deleting character card: {e}")
+        return False
+    finally:
+        conn.close()
+
+
+def add_character_chat(character_id: int, conversation_name: str, chat_history: List[Tuple[str, str]], keywords: Optional[List[str]] = None, is_snapshot: bool = False) -> Optional[int]:
+    """
+    Add a new chat history for a character, optionally associating keywords.
+
+    Args:
+        character_id (int): The ID of the character.
+        conversation_name (str): Name of the conversation.
+        chat_history (List[Tuple[str, str]]): List of (user, bot) message tuples.
+        keywords (Optional[List[str]]): List of keywords to associate with this chat.
+        is_snapshot (bool, optional): Whether this chat is a snapshot.
+
+    Returns:
+        Optional[int]: The ID of the inserted chat or None if failed.
+    """
+    conn = sqlite3.connect(chat_DB_PATH)
+    cursor = conn.cursor()
+    try:
+        chat_history_json = json.dumps(chat_history)
+        cursor.execute("""
+            INSERT INTO CharacterChats (character_id, conversation_name, chat_history, is_snapshot)
+            VALUES (?, ?, ?, ?)
+        """, (
+            character_id,
+            conversation_name,
+            chat_history_json,
+            is_snapshot
+        ))
+        chat_id = cursor.lastrowid
+
+        if keywords:
+            # Insert keywords into ChatKeywords table
+            keyword_records = [(chat_id, keyword.strip().lower()) for keyword in keywords]
+            cursor.executemany("""
+                INSERT INTO ChatKeywords (chat_id, keyword)
+                VALUES (?, ?)
+            """, keyword_records)
+
+        conn.commit()
+        return chat_id
+    except sqlite3.Error as e:
+        logging.error(f"Error adding character chat: {e}")
+        return None
+    finally:
+        conn.close()
+
+
+def get_character_chats(character_id: Optional[int] = None) -> List[Dict]:
+    """Retrieve all chats, or chats for a specific character if character_id is provided."""
+    conn = sqlite3.connect(chat_DB_PATH)
+    cursor = conn.cursor()
+    if character_id is not None:
+        cursor.execute("SELECT * FROM CharacterChats WHERE character_id = ?", (character_id,))
+    else:
+        cursor.execute("SELECT * FROM CharacterChats")
+    rows = cursor.fetchall()
+    columns = [description[0] for description in cursor.description]
+    conn.close()
+    return [dict(zip(columns, row)) for row in rows]
+
+
+def get_character_chat_by_id(chat_id: int) -> Optional[Dict]:
+    """Retrieve a single chat by its ID."""
+    conn = sqlite3.connect(chat_DB_PATH)
+    cursor = conn.cursor()
+    cursor.execute("SELECT * FROM CharacterChats WHERE id = ?", (chat_id,))
+    row = cursor.fetchone()
+    conn.close()
+    if row:
+        columns = [description[0] for description in cursor.description]
+        chat = dict(zip(columns, row))
+        chat['chat_history'] = json.loads(chat['chat_history'])
+        return chat
+    return None
+
+
+def search_character_chats(query: str) -> Tuple[List[Dict], str]:
+    """
+    Search for character chats using FTS5.
+
+    Args:
+        query (str): The search query.
+
+    Returns:
+        Tuple[List[Dict], str]: A list of matching chats and a status message.
+    """
+    if not query.strip():
+        return [], "Please enter a search query."
+
+    conn = sqlite3.connect(chat_DB_PATH)
+    cursor = conn.cursor()
+    try:
+        # Use parameterized queries to prevent SQL injection
+        cursor.execute("""
+            SELECT CharacterChats.id, CharacterChats.conversation_name, CharacterChats.chat_history
+            FROM CharacterChats_fts
+            JOIN CharacterChats ON CharacterChats_fts.rowid = CharacterChats.id
+            WHERE CharacterChats_fts MATCH ?
+            ORDER BY rank
+        """, (query,))
+        rows = cursor.fetchall()
+        columns = [description[0] for description in cursor.description]
+        results = [dict(zip(columns, row)) for row in rows]
+        status_message = f"Found {len(results)} chat(s) matching '{query}'."
+        return results, status_message
+    except Exception as e:
+        logging.error(f"Error searching chats with FTS5: {e}")
+        return [], f"Error occurred during search: {e}"
+    finally:
+        conn.close()
+
+def update_character_chat(chat_id: int, chat_history: List[Tuple[str, str]]) -> bool:
+    """Update an existing chat history."""
+    conn = sqlite3.connect(chat_DB_PATH)
+    cursor = conn.cursor()
+    try:
+        chat_history_json = json.dumps(chat_history)
+        cursor.execute("""
+            UPDATE CharacterChats
+            SET chat_history = ?
+            WHERE id = ?
+        """, (
+            chat_history_json,
+            chat_id
+        ))
+        conn.commit()
+        return cursor.rowcount > 0
+    except sqlite3.Error as e:
+        logging.error(f"Error updating character chat: {e}")
+        return False
+    finally:
+        conn.close()
+
+
+def delete_character_chat(chat_id: int) -> bool:
+    """Delete a specific chat."""
+    conn = sqlite3.connect(chat_DB_PATH)
+    cursor = conn.cursor()
+    try:
+        cursor.execute("DELETE FROM CharacterChats WHERE id = ?", (chat_id,))
+        conn.commit()
+        return cursor.rowcount > 0
+    except sqlite3.Error as e:
+        logging.error(f"Error deleting character chat: {e}")
+        return False
+    finally:
+        conn.close()
+
+def fetch_keywords_for_chats(keywords: List[str]) -> List[int]:
+    """
+    Fetch chat IDs associated with any of the specified keywords.
+
+    Args:
+        keywords (List[str]): List of keywords to search for.
+
+    Returns:
+        List[int]: List of chat IDs associated with the keywords.
+    """
+    if not keywords:
+        return []
+
+    conn = sqlite3.connect(chat_DB_PATH)
+    cursor = conn.cursor()
+    try:
+        # Construct the WHERE clause to search for each keyword
+        keyword_clauses = " OR ".join(["keyword = ?"] * len(keywords))
+        sql_query = f"SELECT DISTINCT chat_id FROM ChatKeywords WHERE {keyword_clauses}"
+        cursor.execute(sql_query, keywords)
+        rows = cursor.fetchall()
+        chat_ids = [row[0] for row in rows]
+        return chat_ids
+    except Exception as e:
+        logging.error(f"Error in fetch_keywords_for_chats: {e}")
+        return []
+    finally:
+        conn.close()
+
+def save_chat_history_to_character_db(character_id: int, conversation_name: str, chat_history: List[Tuple[str, str]]) -> Optional[int]:
+    """Save chat history to the CharacterChats table.
+
+    Returns the ID of the inserted chat or None if failed.
+    """
+    return add_character_chat(character_id, conversation_name, chat_history)
+
+def migrate_chat_to_media_db():
+    pass
+
+
+def search_db(query: str, fields: List[str], where_clause: str = "", page: int = 1, results_per_page: int = 5) -> List[Dict[str, Any]]:
+    """
+    Perform a full-text search on specified fields with optional filtering and pagination.
+
+    Args:
+        query (str): The search query.
+        fields (List[str]): List of fields to search in.
+        where_clause (str, optional): Additional SQL WHERE clause to filter results.
+        page (int, optional): Page number for pagination.
+        results_per_page (int, optional): Number of results per page.
+
+    Returns:
+        List[Dict[str, Any]]: List of matching chat records with content and metadata.
+    """
+    if not query.strip():
+        return []
+
+    conn = sqlite3.connect(chat_DB_PATH)
+    cursor = conn.cursor()
+    try:
+        # Construct the MATCH query for FTS5
+        match_query = " AND ".join(fields) + f" MATCH ?"
+        # Adjust the query with the fields
+        fts_query = f"""
+            SELECT CharacterChats.id, CharacterChats.conversation_name, CharacterChats.chat_history
+            FROM CharacterChats_fts
+            JOIN CharacterChats ON CharacterChats_fts.rowid = CharacterChats.id
+            WHERE {match_query}
+        """
+        if where_clause:
+            fts_query += f" AND ({where_clause})"
+        fts_query += " ORDER BY rank LIMIT ? OFFSET ?"
+        offset = (page - 1) * results_per_page
+        cursor.execute(fts_query, (query, results_per_page, offset))
+        rows = cursor.fetchall()
+        columns = [description[0] for description in cursor.description]
+        results = [dict(zip(columns, row)) for row in rows]
+        return results
+    except Exception as e:
+        logging.error(f"Error in search_db: {e}")
+        return []
+    finally:
+        conn.close()
+
+
+def perform_full_text_search_chat(query: str, relevant_chat_ids: List[int], page: int = 1, results_per_page: int = 5) -> \
+List[Dict[str, Any]]:
+    """
+    Perform a full-text search within the specified chat IDs using FTS5.
+
+    Args:
+        query (str): The user's query.
+        relevant_chat_ids (List[int]): List of chat IDs to search within.
+        page (int): Pagination page number.
+        results_per_page (int): Number of results per page.
+
+    Returns:
+        List[Dict[str, Any]]: List of search results with content and metadata.
+    """
+    try:
+        # Construct a WHERE clause to limit the search to relevant chat IDs
+        where_clause = " OR ".join([f"media_id = {chat_id}" for chat_id in relevant_chat_ids])
+        if not where_clause:
+            where_clause = "1"  # No restriction if no chat IDs
+
+        # Perform full-text search using FTS5
+        fts_results = search_db(query, ["content"], where_clause, page=page, results_per_page=results_per_page)
+
+        filtered_fts_results = [
+            {
+                "content": result['content'],
+                "metadata": {"media_id": result['id']}
+            }
+            for result in fts_results
+            if result['id'] in relevant_chat_ids
+        ]
+        return filtered_fts_results
+    except Exception as e:
+        logging.error(f"Error in perform_full_text_search_chat: {str(e)}")
+        return []
+
+
+def fetch_all_chats() -> List[Dict[str, Any]]:
+    """
+    Fetch all chat messages from the database.
+
+    Returns:
+        List[Dict[str, Any]]: List of chat messages with relevant metadata.
+    """
+    try:
+        chats = get_character_chats()  # Modify this function to retrieve all chats
+        return chats
+    except Exception as e:
+        logging.error(f"Error fetching all chats: {str(e)}")
+        return []
+
+#
+# End of Character_Chat_DB.py
+#######################################################################################################################

App_Function_Libraries/DB/DB_Manager.py

@@ -70,6 +70,14 @@ from App_Function_Libraries.DB.SQLite_DB import (
     fetch_paginated_data as sqlite_fetch_paginated_data, get_latest_transcription as sqlite_get_latest_transcription, \
     mark_media_as_processed as sqlite_mark_media_as_processed,
 )
+from App_Function_Libraries.DB.Character_Chat_DB import (
+    add_character_card as sqlite_add_character_card, get_character_cards as sqlite_get_character_cards, \
+    get_character_card_by_id as sqlite_get_character_card_by_id, update_character_card as sqlite_update_character_card, \
+    delete_character_card as sqlite_delete_character_card, add_character_chat as sqlite_add_character_chat, \
+    get_character_chats as sqlite_get_character_chats, get_character_chat_by_id as sqlite_get_character_chat_by_id, \
+    update_character_chat as sqlite_update_character_chat, delete_character_chat as sqlite_delete_character_chat, \
+    migrate_chat_to_media_db as sqlite_migrate_chat_to_media_db,
+)
 #
 # Local Imports
 from App_Function_Libraries.Utils.Utils import load_comprehensive_config, get_database_path, get_project_relative_path
@@ -510,9 +518,9 @@ def delete_prompt(*args, **kwargs):
         # Implement Elasticsearch version
         raise NotImplementedError("Elasticsearch version of add_media_with_keywords not yet implemented")
 
-def search_media_database(query: str) -> List[Tuple[int, str, str]]:
+def search_media_database(*args, **kwargs):
     if db_type == 'sqlite':
-        return sqlite_search_media_database(query)
+        return sqlite_search_media_database(*args, **kwargs)
     elif db_type == 'elasticsearch':
         # Implement Elasticsearch version when available
         raise NotImplementedError("Elasticsearch version of search_media_database not yet implemented")
@@ -770,6 +778,93 @@ def get_conversation_name(*args, **kwargs):
 # End of Chat-related Functions
 ############################################################################################################
 
+
+############################################################################################################
+#
+# Character Chat-related Functions
+
+def add_character_card(*args, **kwargs):
+    if db_type == 'sqlite':
+        return sqlite_add_character_card(*args, **kwargs)
+    elif db_type == 'elasticsearch':
+        # Implement Elasticsearch version
+        raise NotImplementedError("Elasticsearch version of add_character_card not yet implemented")
+
+def get_character_cards():
+    if db_type == 'sqlite':
+        return sqlite_get_character_cards()
+    elif db_type == 'elasticsearch':
+        # Implement Elasticsearch version
+        raise NotImplementedError("Elasticsearch version of get_character_cards not yet implemented")
+
+def get_character_card_by_id(*args, **kwargs):
+    if db_type == 'sqlite':
+        return sqlite_get_character_card_by_id(*args, **kwargs)
+    elif db_type == 'elasticsearch':
+        # Implement Elasticsearch version
+        raise NotImplementedError("Elasticsearch version of get_character_card_by_id not yet implemented")
+
+def update_character_card(*args, **kwargs):
+    if db_type == 'sqlite':
+        return sqlite_update_character_card(*args, **kwargs)
+    elif db_type == 'elasticsearch':
+        # Implement Elasticsearch version
+        raise NotImplementedError("Elasticsearch version of update_character_card not yet implemented")
+
+def delete_character_card(*args, **kwargs):
+    if db_type == 'sqlite':
+        return sqlite_delete_character_card(*args, **kwargs)
+    elif db_type == 'elasticsearch':
+        # Implement Elasticsearch version
+        raise NotImplementedError("Elasticsearch version of delete_character_card not yet implemented")
+
+def add_character_chat(*args, **kwargs):
+    if db_type == 'sqlite':
+        return sqlite_add_character_chat(*args, **kwargs)
+    elif db_type == 'elasticsearch':
+        # Implement Elasticsearch version
+        raise NotImplementedError("Elasticsearch version of add_character_chat not yet implemented")
+
+def get_character_chats(*args, **kwargs):
+    if db_type == 'sqlite':
+        return sqlite_get_character_chats(*args, **kwargs)
+    elif db_type == 'elasticsearch':
+        # Implement Elasticsearch version
+        raise NotImplementedError("Elasticsearch version of get_character_chats not yet implemented")
+
+def get_character_chat_by_id(*args, **kwargs):
+    if db_type == 'sqlite':
+        return sqlite_get_character_chat_by_id(*args, **kwargs)
+    elif db_type == 'elasticsearch':
+        # Implement Elasticsearch version
+        raise NotImplementedError("Elasticsearch version of get_character_chat_by_id not yet implemented")
+
+def update_character_chat(*args, **kwargs):
+    if db_type == 'sqlite':
+        return sqlite_update_character_chat(*args, **kwargs)
+    elif db_type == 'elasticsearch':
+        # Implement Elasticsearch version
+        raise NotImplementedError("Elasticsearch version of update_character_chat not yet implemented")
+
+def delete_character_chat(*args, **kwargs):
+    if db_type == 'sqlite':
+        return sqlite_delete_character_chat(*args, **kwargs)
+    elif db_type == 'elasticsearch':
+        # Implement Elasticsearch version
+        raise NotImplementedError("Elasticsearch version of delete_character_chat not yet implemented")
+
+def migrate_chat_to_media_db(*args, **kwargs):
+    if db_type == 'sqlite':
+        return sqlite_migrate_chat_to_media_db(*args, **kwargs)
+    elif db_type == 'elasticsearch':
+        # Implement Elasticsearch version
+        raise NotImplementedError("Elasticsearch version of migrate_chat_to_media_db not yet implemented")
+
+#
+# End of Character Chat-related Functions
+############################################################################################################
+
+
 ############################################################################################################
 #
 # Trash-related Functions

App_Function_Libraries/DB/SQLite_DB.py

@@ -102,8 +102,8 @@ backup_path = get_project_relative_path(backup_path)
 db_path = sqlite_path
 backup_dir = backup_path
 
-print(f"Database path: {db_path}")
-print(f"Backup directory: {backup_dir}")
+print(f"Media Database path: {db_path}")
+print(f"Media Backup directory: {backup_dir}")
 #create_automated_backup(db_path, backup_dir)
 
 # FIXME - Setup properly and test/add documentation for its existence...
@@ -277,9 +277,9 @@ db = Database()
 
 # Usage example:
 if db.table_exists('DocumentVersions'):
-    logging.info("DocumentVersions table exists")
+    logging.debug("DocumentVersions table exists")
 else:
-    logging.error("DocumentVersions table does not exist")
+    logging.debug("DocumentVersions table does not exist")
 
 
 # Function to create tables with the new media schema
@@ -467,7 +467,7 @@ def check_media_exists(title: str, url: str) -> Optional[int]:
     try:
         with db.get_connection() as conn:
             cursor = conn.cursor()
-            query = 'SELECT id FROM Media WHERE title = ? AND url = ?'
+            query = 'SELECT id FROM Media WHERE title = ? OR url = ?'
             cursor.execute(query, (title, url))
             result = cursor.fetchone()
             logging.debug(f"check_media_exists query: {query}")
@@ -603,57 +603,6 @@ def mark_media_as_processed(database, media_id):
 # Keyword-related Functions
 #
 
-# Function to add a keyword
-def add_keyword(keyword: str) -> int:
-    keyword = keyword.strip().lower()
-    with db.get_connection() as conn:
-        cursor = conn.cursor()
-        try:
-            # Insert into Keywords table
-            cursor.execute('INSERT OR IGNORE INTO Keywords (keyword) VALUES (?)', (keyword,))
-
-            # Get the keyword_id (whether it was just inserted or already existed)
-            cursor.execute('SELECT id FROM Keywords WHERE keyword = ?', (keyword,))
-            keyword_id = cursor.fetchone()[0]
-
-            # Check if the keyword exists in keyword_fts
-            cursor.execute('SELECT rowid FROM keyword_fts WHERE rowid = ?', (keyword_id,))
-            if not cursor.fetchone():
-                # If it doesn't exist in keyword_fts, insert it
-                cursor.execute('INSERT OR IGNORE INTO keyword_fts (rowid, keyword) VALUES (?, ?)', (keyword_id, keyword))
-
-            logging.info(f"Keyword '{keyword}' added or updated with ID: {keyword_id}")
-            conn.commit()
-            return keyword_id
-        except sqlite3.IntegrityError as e:
-            logging.error(f"Integrity error adding keyword: {e}")
-            raise DatabaseError(f"Integrity error adding keyword: {e}")
-        except sqlite3.Error as e:
-            logging.error(f"Error adding keyword: {e}")
-            raise DatabaseError(f"Error adding keyword: {e}")
-
-
-
-# Function to delete a keyword
-def delete_keyword(keyword: str) -> str:
-    keyword = keyword.strip().lower()
-    with db.get_connection() as conn:
-        cursor = conn.cursor()
-        try:
-            cursor.execute('SELECT id FROM Keywords WHERE keyword = ?', (keyword,))
-            keyword_id = cursor.fetchone()
-            if keyword_id:
-                cursor.execute('DELETE FROM Keywords WHERE keyword = ?', (keyword,))
-                cursor.execute('DELETE FROM keyword_fts WHERE rowid = ?', (keyword_id[0],))
-                conn.commit()
-                return f"Keyword '{keyword}' deleted successfully."
-            else:
-                return f"Keyword '{keyword}' not found."
-        except sqlite3.Error as e:
-            raise DatabaseError(f"Error deleting keyword: {e}")
-
-
-
 # Function to add media with keywords
 def add_media_with_keywords(url, title, media_type, content, keywords, prompt, summary, transcription_model, author,
                             ingestion_date):
@@ -828,6 +777,59 @@ def ingest_article_to_db(url, title, author, content, keywords, summary, ingesti
         return str(e)
 
 
+# Function to add a keyword
+def add_keyword(keyword: str) -> int:
+    if not keyword.strip():
+        raise DatabaseError("Keyword cannot be empty")
+
+    keyword = keyword.strip().lower()
+    with db.get_connection() as conn:
+        cursor = conn.cursor()
+        try:
+            # Insert into Keywords table
+            cursor.execute('INSERT OR IGNORE INTO Keywords (keyword) VALUES (?)', (keyword,))
+
+            # Get the keyword_id (whether it was just inserted or already existed)
+            cursor.execute('SELECT id FROM Keywords WHERE keyword = ?', (keyword,))
+            keyword_id = cursor.fetchone()[0]
+
+            # Check if the keyword exists in keyword_fts
+            cursor.execute('SELECT rowid FROM keyword_fts WHERE rowid = ?', (keyword_id,))
+            if not cursor.fetchone():
+                # If it doesn't exist in keyword_fts, insert it
+                cursor.execute('INSERT OR IGNORE INTO keyword_fts (rowid, keyword) VALUES (?, ?)', (keyword_id, keyword))
+
+            logging.info(f"Keyword '{keyword}' added or updated with ID: {keyword_id}")
+            conn.commit()
+            return keyword_id
+        except sqlite3.IntegrityError as e:
+            logging.error(f"Integrity error adding keyword: {e}")
+            raise DatabaseError(f"Integrity error adding keyword: {e}")
+        except sqlite3.Error as e:
+            logging.error(f"Error adding keyword: {e}")
+            raise DatabaseError(f"Error adding keyword: {e}")
+
+
+
+# Function to delete a keyword
+def delete_keyword(keyword: str) -> str:
+    keyword = keyword.strip().lower()
+    with db.get_connection() as conn:
+        cursor = conn.cursor()
+        try:
+            cursor.execute('SELECT id FROM Keywords WHERE keyword = ?', (keyword,))
+            keyword_id = cursor.fetchone()
+            if keyword_id:
+                cursor.execute('DELETE FROM Keywords WHERE keyword = ?', (keyword,))
+                cursor.execute('DELETE FROM keyword_fts WHERE rowid = ?', (keyword_id[0],))
+                conn.commit()
+                return f"Keyword '{keyword}' deleted successfully."
+            else:
+                return f"Keyword '{keyword}' not found."
+        except sqlite3.Error as e:
+            raise DatabaseError(f"Error deleting keyword: {e}")
+
+
 def fetch_all_keywords() -> List[str]:
     try:
         with db.get_connection() as conn:
@@ -998,14 +1000,15 @@ def add_media_version(conn, media_id: int, prompt: str, summary: str) -> None:
 
 
 # Function to search the database with advanced options, including keyword search and full-text search
-def sqlite_search_db(search_query: str, search_fields: List[str], keywords: str, page: int = 1, results_per_page: int = 10):
+
+def sqlite_search_db(search_query: str, search_fields: List[str], keywords: str, page: int = 1, results_per_page: int = 10, connection=None):
     if page < 1:
         raise ValueError("Page number must be 1 or greater.")
 
     # Prepare keywords by splitting and trimming
     keywords = [keyword.strip().lower() for keyword in keywords.split(',') if keyword.strip()]
 
-    with db.get_connection() as conn:
+    def execute_query(conn):
         cursor = conn.cursor()
         offset = (page - 1) * results_per_page
 
@@ -1042,10 +1045,13 @@ def sqlite_search_db(search_query: str, search_fields: List[str], keywords: str,
         params.extend([results_per_page, offset])
 
         cursor.execute(query, params)
-        results = cursor.fetchall()
-
-        return results
+        return cursor.fetchall()
 
+    if connection:
+        return execute_query(connection)
+    else:
+        with db.get_connection() as conn:
+            return execute_query(conn)
 
 # Gradio function to handle user input and display results with pagination, with better feedback
 def search_and_display(search_query, search_fields, keywords, page):
@@ -1177,8 +1183,9 @@ def is_valid_date(date_string: str) -> bool:
 
 
 
-def add_media_to_database(url, info_dict, segments, summary, keywords, custom_prompt_input, whisper_model, media_type='video', overwrite=False):
-    db = Database()
+def add_media_to_database(url, info_dict, segments, summary, keywords, custom_prompt_input, whisper_model, media_type='video', overwrite=False, db=None):
+    if db is None:
+        db = Database()
     try:
         with db.get_connection() as conn:
             cursor = conn.cursor()
@@ -1365,12 +1372,14 @@ def schedule_chunking(media_id: int, content: str, media_name: str):
 # Functions to manage prompts DB
 
 def create_prompts_db():
+    logging.debug("create_prompts_db: Creating prompts database.")
     with sqlite3.connect(get_database_path('prompts.db')) as conn:
         cursor = conn.cursor()
         cursor.executescript('''
             CREATE TABLE IF NOT EXISTS Prompts (
                 id INTEGER PRIMARY KEY AUTOINCREMENT,
                 name TEXT NOT NULL UNIQUE,
+                author TEXT,
                 details TEXT,
                 system TEXT,
                 user TEXT
@@ -1391,22 +1400,42 @@ def create_prompts_db():
             CREATE INDEX IF NOT EXISTS idx_promptkeywords_keyword_id ON PromptKeywords(keyword_id);
         ''')
 
+# FIXME - dirty hack that should be removed later...
+# Migration function to add the 'author' column to the Prompts table
+def add_author_column_to_prompts():
+    with sqlite3.connect(get_database_path('prompts.db')) as conn:
+        cursor = conn.cursor()
+        # Check if 'author' column already exists
+        cursor.execute("PRAGMA table_info(Prompts)")
+        columns = [col[1] for col in cursor.fetchall()]
+
+        if 'author' not in columns:
+            # Add the 'author' column
+            cursor.execute('ALTER TABLE Prompts ADD COLUMN author TEXT')
+            print("Author column added to Prompts table.")
+        else:
+            print("Author column already exists in Prompts table.")
+
+add_author_column_to_prompts()
 
 def normalize_keyword(keyword):
     return re.sub(r'\s+', ' ', keyword.strip().lower())
 
 
-def add_prompt(name, details, system, user=None, keywords=None):
-    if not name or not system:
-        return "Name and system prompt are required."
+# FIXME - update calls to this function to use the new args
+def add_prompt(name, author, details, system=None, user=None, keywords=None):
+    logging.debug(f"add_prompt: Adding prompt with name: {name}, author: {author}, system: {system}, user: {user}, keywords: {keywords}")
+    if not name:
+        logging.error("add_prompt: A name is required.")
+        return "A name is required."
 
     try:
         with sqlite3.connect(get_database_path('prompts.db')) as conn:
             cursor = conn.cursor()
             cursor.execute('''
-                INSERT INTO Prompts (name, details, system, user)
-                VALUES (?, ?, ?, ?)
-            ''', (name, details, system, user))
+                INSERT INTO Prompts (name, author, details, system, user)
+                VALUES (?, ?, ?, ?, ?)
+            ''', (name, author, details, system, user))
             prompt_id = cursor.lastrowid
 
             if keywords:
@@ -1428,10 +1457,11 @@ def add_prompt(name, details, system, user=None, keywords=None):
 
 
 def fetch_prompt_details(name):
+    logging.debug(f"fetch_prompt_details: Fetching details for prompt: {name}")
     with sqlite3.connect(get_database_path('prompts.db')) as conn:
         cursor = conn.cursor()
         cursor.execute('''
-            SELECT p.name, p.details, p.system, p.user, GROUP_CONCAT(k.keyword, ', ') as keywords
+            SELECT p.name, p.author, p.details, p.system, p.user, GROUP_CONCAT(k.keyword, ', ') as keywords
             FROM Prompts p
             LEFT JOIN PromptKeywords pk ON p.id = pk.prompt_id
             LEFT JOIN Keywords k ON pk.keyword_id = k.id
@@ -1442,6 +1472,7 @@ def fetch_prompt_details(name):
 
 
 def list_prompts(page=1, per_page=10):
+    logging.debug(f"list_prompts: Listing prompts for page {page} with {per_page} prompts per page.")
     offset = (page - 1) * per_page
     with sqlite3.connect(get_database_path('prompts.db')) as conn:
         cursor = conn.cursor()
@@ -1458,6 +1489,7 @@ def list_prompts(page=1, per_page=10):
 # This will not scale. For a large number of prompts, use a more efficient method.
 # FIXME - see above statement.
 def load_preset_prompts():
+    logging.debug("load_preset_prompts: Loading preset prompts.")
     try:
         with sqlite3.connect(get_database_path('prompts.db')) as conn:
             cursor = conn.cursor()
@@ -1469,8 +1501,8 @@ def load_preset_prompts():
         return []
 
 
-def insert_prompt_to_db(title, description, system_prompt, user_prompt, keywords=None):
-    return add_prompt(title, description, system_prompt, user_prompt, keywords)
+def insert_prompt_to_db(title, author, description, system_prompt, user_prompt, keywords=None):
+    return add_prompt(title, author, description, system_prompt, user_prompt, keywords)
 
 
 def get_prompt_db_connection():
@@ -1479,6 +1511,7 @@ def get_prompt_db_connection():
 
 
 def search_prompts(query):
+    logging.debug(f"search_prompts: Searching prompts with query: {query}")
     try:
         with get_prompt_db_connection() as conn:
             cursor = conn.cursor()
@@ -1498,6 +1531,7 @@ def search_prompts(query):
 
 
 def search_prompts_by_keyword(keyword, page=1, per_page=10):
+    logging.debug(f"search_prompts_by_keyword: Searching prompts by keyword: {keyword}")
     normalized_keyword = normalize_keyword(keyword)
     offset = (page - 1) * per_page
     with sqlite3.connect(get_database_path('prompts.db')) as conn:
@@ -1527,6 +1561,7 @@ def search_prompts_by_keyword(keyword, page=1, per_page=10):
 
 
 def update_prompt_keywords(prompt_name, new_keywords):
+    logging.debug(f"update_prompt_keywords: Updating keywords for prompt: {prompt_name}")
     try:
         with sqlite3.connect(get_database_path('prompts.db')) as conn:
             cursor = conn.cursor()
@@ -1557,40 +1592,43 @@ def update_prompt_keywords(prompt_name, new_keywords):
         return f"Database error: {e}"
 
 
-def add_or_update_prompt(title, description, system_prompt, user_prompt, keywords=None):
+def add_or_update_prompt(title, author, description, system_prompt, user_prompt, keywords=None):
+    logging.debug(f"add_or_update_prompt: Adding or updating prompt: {title}")
     if not title:
         return "Error: Title is required."
 
     existing_prompt = fetch_prompt_details(title)
     if existing_prompt:
         # Update existing prompt
-        result = update_prompt_in_db(title, description, system_prompt, user_prompt)
+        result = update_prompt_in_db(title, author, description, system_prompt, user_prompt)
         if "successfully" in result:
             # Update keywords if the prompt update was successful
             keyword_result = update_prompt_keywords(title, keywords or [])
             result += f" {keyword_result}"
     else:
         # Insert new prompt
-        result = insert_prompt_to_db(title, description, system_prompt, user_prompt, keywords)
+        result = insert_prompt_to_db(title, author, description, system_prompt, user_prompt, keywords)
 
     return result
 
 
 def load_prompt_details(selected_prompt):
+    logging.debug(f"load_prompt_details: Loading prompt details for {selected_prompt}")
     if selected_prompt:
         details = fetch_prompt_details(selected_prompt)
         if details:
-            return details[0], details[1], details[2], details[3], details[4]  # Include keywords
-    return "", "", "", "", ""
+            return details[0], details[1], details[2], details[3], details[4], details[5]
+    return "", "", "", "", "", ""
 
 
-def update_prompt_in_db(title, description, system_prompt, user_prompt):
+def update_prompt_in_db(title, author, description, system_prompt, user_prompt):
+    logging.debug(f"update_prompt_in_db: Updating prompt: {title}")
     try:
         with sqlite3.connect(get_database_path('prompts.db')) as conn:
             cursor = conn.cursor()
             cursor.execute(
-                "UPDATE Prompts SET details = ?, system = ?, user = ? WHERE name = ?",
-                (description, system_prompt, user_prompt, title)
+                "UPDATE Prompts SET author = ?, details = ?, system = ?, user = ? WHERE name = ?",
+                (author, description, system_prompt, user_prompt, title)
             )
             if cursor.rowcount == 0:
                 return "No prompt found with the given title."
@@ -1602,6 +1640,7 @@ def update_prompt_in_db(title, description, system_prompt, user_prompt):
 create_prompts_db()
 
 def delete_prompt(prompt_id):
+    logging.debug(f"delete_prompt: Deleting prompt with ID: {prompt_id}")
     try:
         with sqlite3.connect(get_database_path('prompts.db')) as conn:
             cursor = conn.cursor()
@@ -1671,15 +1710,21 @@ def update_media_content(selected_item, item_mapping, content_input, prompt_inpu
         return f"Error updating content: {str(e)}"
 
 
-def search_media_database(query: str) -> List[Tuple[int, str, str]]:
-    try:
-        with db.get_connection() as conn:
+def search_media_database(query: str, connection=None) -> List[Tuple[int, str, str]]:
+    def execute_query(conn):
+        try:
             cursor = conn.cursor()
             cursor.execute("SELECT id, title, url FROM Media WHERE title LIKE ?", (f'%{query}%',))
-            results = cursor.fetchall()
-        return results
-    except sqlite3.Error as e:
-        raise Exception(f"Error searching media database: {e}")
+            return cursor.fetchall()
+        except sqlite3.Error as e:
+            raise Exception(f"Error searching media database: {e}")
+
+    if connection:
+        return execute_query(connection)
+    else:
+        with db.get_connection() as conn:
+            return execute_query(conn)
+
 
 def load_media_content(media_id: int) -> dict:
     try:
@@ -2586,7 +2631,6 @@ def get_paginated_files(page: int = 1, results_per_page: int = 50) -> Tuple[List
 #
 # Functions to manage document versions
 
-
 def create_document_version(media_id: int, content: str) -> int:
     logging.info(f"Attempting to create document version for media_id: {media_id}")
     try:
@@ -2910,22 +2954,23 @@ def update_media_table(db):
     # Add chunking_status column if it doesn't exist
     add_missing_column_if_not_exists(db, 'Media', 'chunking_status', "TEXT DEFAULT 'pending'")
 
-# Vector check FIXME/Delete later
-def alter_media_table(db):
-    alter_query = '''
-    ALTER TABLE Media ADD COLUMN vector_processing INTEGER DEFAULT 0
-    '''
-    try:
-        db.execute_query(alter_query)
-        logging.info("Media table altered successfully to include vector_processing column.")
-    except Exception as e:
-        logging.error(f"Error altering Media table: {str(e)}")
-        # If the column already exists, SQLite will throw an error, which we can safely ignore
-        if "duplicate column name" not in str(e).lower():
-            raise
-
-# Vector check FIXME/Delete later
-alter_media_table(db)
+# DEADCODE
+# # Vector check FIXME/Delete later
+# def alter_media_table(db):
+#     alter_query = '''
+#     ALTER TABLE Media ADD COLUMN vector_processing INTEGER DEFAULT 0
+#     '''
+#     try:
+#         db.execute_query(alter_query)
+#         logging.info("Media table altered successfully to include vector_processing column.")
+#     except Exception as e:
+#         logging.error(f"Error altering Media table: {str(e)}")
+#         # If the column already exists, SQLite will throw an error, which we can safely ignore
+#         if "duplicate column name" not in str(e).lower():
+#             raise
+#
+# # Vector check FIXME/Delete later
+# alter_media_table(db)
 
 #
 # End of Functions to manage media chunks