local-deep-research 0.6.0__py3-none-any.whl → 0.6.4__py3-none-any.whl

local_deep_research/migrate_db.py

@@ -1,149 +0,0 @@
-#!/usr/bin/env python
-"""
-Database migration script for Local Deep Research.
-Migrates data from legacy databases (deep_research.db and research_history.db) to the new unified database (ldr.db).
-"""
-
-import argparse
-import logging
-import os
-import sys
-
-try:
-    from local_deep_research.web.database.migrate_to_ldr_db import (
-        migrate_to_ldr_db,
-    )
-    from local_deep_research.web.models.database import (
-        DB_PATH,
-        LEGACY_DEEP_RESEARCH_DB,
-        LEGACY_RESEARCH_HISTORY_DB,
-    )
-except ImportError:
-    # If that fails, try with the relative path.
-    from .web.database.migrate_to_ldr_db import migrate_to_ldr_db
-    from .web.models.database import (
-        DB_PATH,
-        LEGACY_DEEP_RESEARCH_DB,
-        LEGACY_RESEARCH_HISTORY_DB,
-    )
-
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-    handlers=[logging.StreamHandler()],
-)
-logger = logging.getLogger("migrate_db")
-
-# Add proper paths for import
-current_dir = os.path.dirname(os.path.abspath(__file__))
-sys.path.insert(0, os.path.dirname(os.path.dirname(current_dir)))
-
-
-def main():
-    """Main migration function that parses arguments and runs the migration"""
-    parser = argparse.ArgumentParser(
-        description="Local Deep Research Database Migration"
-    )
-    parser.add_argument(
-        "--backup",
-        action="store_true",
-        help="Create backup of existing databases before migration",
-    )
-    parser.add_argument(
-        "--force",
-        action="store_true",
-        help="Force migration even if target database exists",
-    )
-    parser.add_argument(
-        "--dry-run",
-        action="store_true",
-        help="Only check what would be migrated, don't perform actual migration",
-    )
-    parser.add_argument(
-        "--verbose", action="store_true", help="Enable verbose logging"
-    )
-
-    args = parser.parse_args()
-
-    if args.verbose:
-        logging.getLogger().setLevel(logging.DEBUG)
-
-    print("=" * 80)
-    print("LOCAL DEEP RESEARCH DATABASE MIGRATION")
-    print("=" * 80)
-
-    try:
-        # First try the normal import
-        print(f"Target database will be created at: {DB_PATH}")
-
-        # Check if migration is needed
-        if os.path.exists(DB_PATH) and not args.force:
-            print(f"Target database already exists at: {DB_PATH}")
-            if (
-                input(
-                    "Do you want to continue anyway? This may overwrite data. (y/n): "
-                ).lower()
-                != "y"
-            ):
-                print("Migration aborted.")
-                return 1
-
-        # Check if source databases exist
-        deep_research_exists = os.path.exists(LEGACY_DEEP_RESEARCH_DB)
-        research_history_exists = os.path.exists(LEGACY_RESEARCH_HISTORY_DB)
-
-        if not deep_research_exists and not research_history_exists:
-            print("No legacy databases found. Nothing to migrate.")
-            return 0
-
-        print("Found legacy databases:")
-        if deep_research_exists:
-            print(f"  - {LEGACY_DEEP_RESEARCH_DB}")
-        if research_history_exists:
-            print(f"  - {LEGACY_RESEARCH_HISTORY_DB}")
-
-        # Create backups if requested
-        if args.backup:
-            if deep_research_exists:
-                backup_path = f"{LEGACY_DEEP_RESEARCH_DB}.bak"
-                import shutil
-
-                shutil.copy2(LEGACY_DEEP_RESEARCH_DB, backup_path)
-                print(f"Created backup: {backup_path}")
-
-            if research_history_exists:
-                backup_path = f"{LEGACY_RESEARCH_HISTORY_DB}.bak"
-                import shutil
-
-                shutil.copy2(LEGACY_RESEARCH_HISTORY_DB, backup_path)
-                print(f"Created backup: {backup_path}")
-
-        # Run migration or dry run
-        if args.dry_run:
-            print("\nDRY RUN - No changes will be made.")
-            print(f"Would migrate data to: {DB_PATH}")
-            return 0
-        else:
-            print(f"\nStarting migration to: {DB_PATH}")
-
-            success = migrate_to_ldr_db()
-
-            if success:
-                print("\nMigration completed successfully.")
-                print(
-                    "You can now start the application with the new unified database."
-                )
-                return 0
-            else:
-                print("\nMigration failed. Check the logs for details.")
-                return 1
-
-    except Exception as e:
-        logger.error(f"Migration error: {e}", exc_info=True)
-        print(f"Error during migration: {e}")
-        return 1
-
-
-if __name__ == "__main__":
-    sys.exit(main())

local_deep_research/web/database/migrate_to_ldr_db.py

@@ -1,297 +0,0 @@
-"""
-Migration script to merge deep_research.db and research_history.db into ldr.db
-"""
-
-# Standard library imports
-# import json  # Remove unused imports
-import logging
-import os
-import sqlite3
-import sys
-import traceback
-
-# from pathlib import Path  # Remove unused imports
-
-# Set up logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-# Add the parent directory to sys.path to allow relative imports
-sys.path.append(
-    os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
-)
-
-# Import the database module after adding to sys path
-# pylint: disable=wrong-import-position
-from src.local_deep_research.web.models.database import (  # noqa: E402
-    DB_PATH,
-    LEGACY_DEEP_RESEARCH_DB,
-    LEGACY_RESEARCH_HISTORY_DB,
-)
-
-
-def migrate_to_ldr_db():
-    """
-    Migrates data from deep_research.db and research_history.db to ldr.db
-    """
-    # Ensure data directory exists
-    try:
-        from src.local_deep_research.setup_data_dir import setup_data_dir
-
-        setup_data_dir()
-    except ImportError:
-        # If we can't import directly, check the path manually
-        logger.info("Creating data directory manually")
-        data_dir = os.path.dirname(DB_PATH)
-        os.makedirs(data_dir, exist_ok=True)
-
-    logger.info(f"Using database path: {DB_PATH}")
-
-    # Check if ldr.db already exists
-    if os.path.exists(DB_PATH):
-        logger.info(f"Target database {DB_PATH} already exists")
-
-        # Ask for confirmation
-        if (
-            input(
-                f"Target database {DB_PATH} already exists. Do you want to continue migration? (y/n): "
-            ).lower()
-            != "y"
-        ):
-            logger.info("Migration aborted by user")
-            return False
-
-    # Connect to the target database
-    try:
-        ldr_conn = sqlite3.connect(DB_PATH)
-        ldr_cursor = ldr_conn.cursor()
-        logger.info(f"Connected to target database: {DB_PATH}")
-    except Exception as e:
-        logger.error(f"Failed to connect to target database: {e}")
-        return False
-
-    # Enable foreign keys
-    ldr_cursor.execute("PRAGMA foreign_keys = OFF")
-
-    # Initialize the database schema
-    try:
-        from src.local_deep_research.web.models.database import init_db
-
-        init_db()
-        logger.info("Initialized database schema")
-    except Exception as e:
-        logger.error(f"Failed to initialize database schema: {e}")
-        ldr_conn.close()
-        return False
-
-    # Migrate from research_history.db
-    migrated_research = migrate_research_history_db(
-        ldr_conn, LEGACY_RESEARCH_HISTORY_DB
-    )
-
-    # Migrate from deep_research.db
-    migrated_deep_research = migrate_deep_research_db(
-        ldr_conn, LEGACY_DEEP_RESEARCH_DB
-    )
-
-    # Re-enable foreign keys and commit
-    ldr_cursor.execute("PRAGMA foreign_keys = ON")
-    ldr_conn.commit()
-    ldr_conn.close()
-
-    logger.info(
-        f"Migration completed - Research History: {migrated_research}, Deep Research: {migrated_deep_research}"
-    )
-    return True
-
-
-def migrate_research_history_db(ldr_conn, legacy_path):
-    """
-    Migrates data from research_history.db to ldr.db
-
-    Args:
-        ldr_conn: Connection to the target ldr.db
-        legacy_path: Path to legacy research_history.db
-
-    Returns:
-        bool: True if migration was successful, False otherwise
-    """
-    if not os.path.exists(legacy_path):
-        logger.warning(f"Legacy database not found: {legacy_path}")
-        return False
-
-    try:
-        # Connect to legacy database
-        legacy_conn = sqlite3.connect(legacy_path)
-        legacy_cursor = legacy_conn.cursor()
-        ldr_cursor = ldr_conn.cursor()
-
-        logger.info(f"Connected to legacy database: {legacy_path}")
-
-        # Get tables from legacy database
-        legacy_cursor.execute(
-            "SELECT name FROM sqlite_master WHERE type='table'"
-        )
-        tables = [row[0] for row in legacy_cursor.fetchall()]
-
-        for table in tables:
-            # Skip sqlite internal tables
-            if table.startswith("sqlite_"):
-                continue
-
-            logger.info(f"Migrating table: {table}")
-
-            # Check if table exists in target database
-            ldr_cursor.execute(
-                f"SELECT name FROM sqlite_master WHERE type='table' AND name='{table}'"
-            )
-            if not ldr_cursor.fetchone():
-                # Create the table in the target database
-                legacy_cursor.execute(
-                    f"SELECT sql FROM sqlite_master WHERE type='table' AND name='{table}'"
-                )
-                create_sql = legacy_cursor.fetchone()[0]
-                logger.info(f"Creating table {table} with SQL: {create_sql}")
-                ldr_cursor.execute(create_sql)
-                logger.info(f"Created table {table} in target database")
-
-            # Get column names
-            legacy_cursor.execute(f"PRAGMA table_info({table})")
-            columns = [row[1] for row in legacy_cursor.fetchall()]
-
-            # Get all data from legacy table
-            legacy_cursor.execute(f"SELECT * FROM {table}")
-            rows = legacy_cursor.fetchall()
-
-            logger.info(f"Found {len(rows)} rows in {table}")
-
-            if rows:
-                # Create placeholders for the SQL query
-                placeholders = ", ".join(["?" for _ in columns])
-                columns_str = ", ".join(columns)
-
-                # Insert data into target database
-                for row in rows:
-                    try:
-                        ldr_cursor.execute(
-                            f"INSERT OR IGNORE INTO {table} ({columns_str}) VALUES ({placeholders})",
-                            row,
-                        )
-                    except sqlite3.Error as e:
-                        logger.error(f"Error inserting into {table}: {e}")
-                        logger.error(f"Row data: {row}")
-                        continue
-
-                # Verify data was inserted
-                ldr_cursor.execute(f"SELECT COUNT(*) FROM {table}")
-                count = ldr_cursor.fetchone()[0]
-                logger.info(
-                    f"Migrated {count} rows to {table} (expected {len(rows)})"
-                )
-            else:
-                logger.info(f"No data to migrate from {table}")
-
-        legacy_conn.close()
-        return True
-
-    except Exception as e:
-        logger.error(f"Failed to migrate from {legacy_path}: {e}")
-        logger.error(f"Exception details: {traceback.format_exc()}")
-        return False
-
-
-def migrate_deep_research_db(ldr_conn, legacy_path):
-    """
-    Migrates data from deep_research.db to ldr.db
-
-    Args:
-        ldr_conn: Connection to the target ldr.db
-        legacy_path: Path to legacy deep_research.db
-
-    Returns:
-        bool: True if migration was successful, False otherwise
-    """
-    if not os.path.exists(legacy_path):
-        logger.warning(f"Legacy database not found: {legacy_path}")
-        return False
-
-    try:
-        # Connect to legacy database
-        legacy_conn = sqlite3.connect(legacy_path)
-        legacy_cursor = legacy_conn.cursor()
-        ldr_cursor = ldr_conn.cursor()
-
-        logger.info(f"Connected to legacy database: {legacy_path}")
-
-        # Get tables from legacy database
-        legacy_cursor.execute(
-            "SELECT name FROM sqlite_master WHERE type='table'"
-        )
-        tables = [row[0] for row in legacy_cursor.fetchall()]
-
-        # Migrate each table
-        for table in tables:
-            # Skip sqlite internal tables
-            if table.startswith("sqlite_"):
-                continue
-
-            # Skip the research_log table as it's redundant with research_logs
-            if table == "research_log":
-                logger.info(
-                    "Skipping redundant table 'research_log', using 'research_logs' instead"
-                )
-                continue
-
-            logger.info(f"Migrating table: {table}")
-
-            # Check if table exists in target database
-            ldr_cursor.execute(
-                f"SELECT name FROM sqlite_master WHERE type='table' AND name='{table}'"
-            )
-            if not ldr_cursor.fetchone():
-                # Create the table in the target database
-                legacy_cursor.execute(
-                    f"SELECT sql FROM sqlite_master WHERE type='table' AND name='{table}'"
-                )
-                create_sql = legacy_cursor.fetchone()[0]
-                ldr_cursor.execute(create_sql)
-                logger.info(f"Created table {table} in target database")
-
-            # Get column names
-            legacy_cursor.execute(f"PRAGMA table_info({table})")
-            columns = [row[1] for row in legacy_cursor.fetchall()]
-
-            # Get all data from legacy table
-            legacy_cursor.execute(f"SELECT * FROM {table}")
-            rows = legacy_cursor.fetchall()
-
-            if rows:
-                # Create placeholders for the SQL query
-                placeholders = ", ".join(["?" for _ in columns])
-                columns_str = ", ".join(columns)
-
-                # Insert data into target database
-                for row in rows:
-                    try:
-                        ldr_cursor.execute(
-                            f"INSERT OR IGNORE INTO {table} ({columns_str}) VALUES ({placeholders})",
-                            row,
-                        )
-                    except sqlite3.Error as e:
-                        logger.error(f"Error inserting into {table}: {e}")
-                        continue
-
-                logger.info(f"Migrated {len(rows)} rows from {table}")
-            else:
-                logger.info(f"No data to migrate from {table}")
-
-        legacy_conn.close()
-        return True
-
-    except Exception as e:
-        logger.error(f"Failed to migrate from {legacy_path}: {e}")
-        return False
-
-
-if __name__ == "__main__":
-    migrate_to_ldr_db()