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

local_deep_research/__init__.py

@@ -12,10 +12,16 @@ from .config.llm_config import get_llm
 from .config.search_config import get_search
 from .report_generator import get_report_generator
 from .web.app import main
+from .web.database.migrations import ensure_database_initialized
+from .setup_data_dir import setup_data_dir
 
 # Disable logging by default to not interfere with user setup.
 logger.disable("local_deep_research")
 
+# Initialize database.
+setup_data_dir()
+ensure_database_initialized()
+
 
 def get_advanced_search_system(strategy_name: str = "iterdrag"):
     """

local_deep_research/__version__.py

@@ -1 +1 @@
-__version__ = "0.6.1"
+__version__ = "0.6.4"

local_deep_research/setup_data_dir.py

@@ -5,6 +5,7 @@ Creates the data directory for the application database if it doesn't exist.
 """
 
 import os
+from loguru import logger
 
 
 def setup_data_dir():
@@ -19,9 +20,9 @@ def setup_data_dir():
     # Create the data directory if it doesn't exist
     if not os.path.exists(data_dir):
         os.makedirs(data_dir)
-        print(f"Created data directory at: {data_dir}")
+        logger.info(f"Created data directory at: {data_dir}")
     else:
-        print(f"Data directory already exists at: {data_dir}")
+        logger.info(f"Data directory already exists at: {data_dir}")
 
     # Return the path to the data directory
     return data_dir

local_deep_research/utilities/db_utils.py

@@ -16,18 +16,23 @@ DATA_DIR = os.path.abspath(
 DB_PATH = os.path.join(DATA_DIR, "ldr.db")
 
 
-@thread_specific_cache(cache=LRUCache(maxsize=1))
-def get_db_session() -> Session:
+@thread_specific_cache(cache=LRUCache(maxsize=10))
+def get_db_session(_namespace: str = "") -> Session:
     """
+    Args:
+        _namespace: This can be specified to an arbitrary string in order to
+            force the caching mechanism to create separate settings even in
+            the same thread. Usually it does not need to be specified.
+
     Returns:
-        The singleton DB session.
+        The singleton DB session for each thread.
+
     """
     engine = create_engine(f"sqlite:///{DB_PATH}")
     session_class = sessionmaker(bind=engine)
     return session_class()
 
 
-@thread_specific_cache(cache=LRUCache(maxsize=1))
 def get_settings_manager() -> SettingsManager:
     """
     Returns:
@@ -53,12 +58,9 @@ def get_db_setting(
     """
     try:
         # Get settings manager which handles database access
-        value = get_settings_manager().get_setting(key)
-
-        if value is not None:
-            return value
+        return get_settings_manager().get_setting(key, default=default_value)
     except Exception:
         logger.exception(f"Error getting setting {key} from database")
 
-    logger.warning(f"Could not find setting '{key}' in the database.")
+    logger.warning(f"Could not read setting '{key}' from the database.")
     return default_value

local_deep_research/utilities/log_utils.py

@@ -130,7 +130,7 @@ def database_sink(message: loguru.Message) -> None:
     )
 
     # Save the entry to the database.
-    db_session = get_db_session()
+    db_session = get_db_session("log_utils.database_sink")
     try:
         db_session.add(db_log)
         db_session.commit()

local_deep_research/utilities/threading_utils.py

@@ -1,13 +1,17 @@
 import threading
 from functools import wraps
-from typing import Any, Callable, Tuple
-from loguru import logger
+from typing import Any, Callable, Tuple, Hashable
+import uuid
 
+from loguru import logger
 from cachetools import cached, keys
 from flask import current_app, g
 from flask.ctx import AppContext
 
 
+g_thread_local_store = threading.local()
+
+
 def thread_specific_cache(*args: Any, **kwargs: Any) -> Callable:
     """
     A version of `cached()` that is local to a single thread. In other words,
@@ -22,9 +26,18 @@ def thread_specific_cache(*args: Any, **kwargs: Any) -> Callable:
 
     """
 
-    def _key_func(*args_: Any, **kwargs_: Any) -> Tuple[int, ...]:
+    def _key_func(*args_: Any, **kwargs_: Any) -> Tuple[Hashable, ...]:
         base_hash = keys.hashkey(*args_, **kwargs_)
-        return (threading.get_ident(),) + base_hash
+
+        if hasattr(g_thread_local_store, "thread_id"):
+            # We already gave this thread a unique ID. Use that.
+            thread_id = g_thread_local_store.thread_id
+        else:
+            # Give this thread a new unique ID.
+            thread_id = uuid.uuid4().hex
+            g_thread_local_store.thread_id = thread_id
+
+        return (thread_id,) + base_hash
 
     return cached(*args, **kwargs, key=_key_func)
 

local_deep_research/web/api.py

@@ -10,7 +10,7 @@ from functools import wraps
 from flask import Blueprint, jsonify, request
 
 from ..api.research_functions import analyze_documents
-from .services.settings_service import get_setting
+from ..utilities.db_utils import get_db_setting
 
 # Create a blueprint for the API
 api_blueprint = Blueprint("api_v1", __name__, url_prefix="/api/v1")
@@ -30,12 +30,14 @@ def api_access_control(f):
     @wraps(f)
     def decorated_function(*args, **kwargs):
         # Check if API is enabled
-        api_enabled = get_setting("app.enable_api", True)  # Default to enabled
+        api_enabled = get_db_setting(
+            "app.enable_api", True
+        )  # Default to enabled
         if not api_enabled:
             return jsonify({"error": "API access is disabled"}), 403
 
         # Implement rate limiting
-        rate_limit = get_setting(
+        rate_limit = get_db_setting(
             "app.api_rate_limit", 60
         )  # Default 60 requests per minute
         if rate_limit:

local_deep_research/web/app.py

@@ -1,49 +1,8 @@
-import os
-import sys
-
 from loguru import logger
 
-from ..setup_data_dir import setup_data_dir
 from ..utilities.db_utils import get_db_setting
 from ..utilities.log_utils import config_logger
 from .app_factory import create_app
-from .models.database import (
-    DB_PATH,
-    LEGACY_DEEP_RESEARCH_DB,
-    LEGACY_RESEARCH_HISTORY_DB,
-)
-
-# Ensure data directory exists
-setup_data_dir()
-
-# Run schema upgrades if database exists
-if os.path.exists(DB_PATH):
-    try:
-        logger.info("Running schema upgrades on existing database")
-        from .database.schema_upgrade import run_schema_upgrades
-
-        run_schema_upgrades()
-    except Exception:
-        logger.exception("Error running schema upgrades")
-        logger.warning("Continuing without schema upgrades")
-
-
-# Check if we need to run database migration
-def check_migration_needed():
-    """Check if database migration is needed, based on presence of legacy files and absence of new DB"""
-    if not os.path.exists(DB_PATH):
-        # The new database doesn't exist, check if legacy databases exist
-        legacy_files_exist = os.path.exists(
-            LEGACY_DEEP_RESEARCH_DB
-        ) or os.path.exists(LEGACY_RESEARCH_HISTORY_DB)
-
-        if legacy_files_exist:
-            logger.info(
-                "Legacy database files found, but ldr.db doesn't exist. Migration needed."
-            )
-            return True
-
-    return False
 
 
 @logger.catch
@@ -58,39 +17,6 @@ def main():
     # Create the Flask app and SocketIO instance
     app, socketio = create_app()
 
-    # Check if migration is needed
-    if check_migration_needed():
-        logger.info(
-            "Database migration required. Run migrate_db.py before starting the application."
-        )
-        print("=" * 80)
-        print("DATABASE MIGRATION REQUIRED")
-        print(
-            "Legacy database files were found, but the new unified database doesn't exist."
-        )
-        print(
-            "Please run 'python -m src.local_deep_research.web.database.migrate_to_ldr_db' to migrate your data."
-        )
-        print(
-            "You can continue without migration, but your previous data won't be available."
-        )
-        print("=" * 80)
-
-        # If --auto-migrate flag is passed, run migration automatically
-        if "--auto-migrate" in sys.argv:
-            logger.info("Auto-migration flag detected, running migration...")
-            try:
-                from .database.migrate_to_ldr_db import migrate_to_ldr_db
-
-                success = migrate_to_ldr_db()
-                if success:
-                    logger.info("Database migration completed successfully.")
-                else:
-                    logger.warning("Database migration failed.")
-            except Exception:
-                logger.exception("Error running database migration")
-                print("Please run migration manually.")
-
     # Get web server settings with defaults
     port = get_db_setting("web.port", 5000)
     host = get_db_setting("web.host", "0.0.0.0")

local_deep_research/web/app_factory.py

@@ -13,7 +13,7 @@ from flask_wtf.csrf import CSRFProtect
 from loguru import logger
 
 from ..utilities.log_utils import InterceptHandler
-from .models.database import DB_PATH, init_db
+from .models.database import DB_PATH
 from .services.socket_service import SocketIOService
 
 
@@ -77,7 +77,6 @@ def create_app():
 
     # Initialize the database
     create_database(app)
-    init_db()
 
     # Register socket service
     socket_service = SocketIOService(app=app)
@@ -261,9 +260,6 @@ def create_database(app):
     from sqlalchemy import create_engine
     from sqlalchemy.orm import scoped_session, sessionmaker
 
-    from .database.migrations import run_migrations
-    from .database.models import Base
-
     # Configure SQLite to use URI mode, which allows for relative file paths
     engine = create_engine(
         app.config["SQLALCHEMY_DATABASE_URI"],
@@ -273,18 +269,12 @@ def create_database(app):
 
     app.engine = engine
 
-    # Create all tables
-    Base.metadata.create_all(engine)
-
     # Configure session factory
     session_factory = sessionmaker(
         bind=engine, autocommit=False, autoflush=False
     )
     app.db_session = scoped_session(session_factory)
 
-    # Run migrations and setup predefined settings
-    run_migrations(engine, app.db_session)
-
     # Add teardown context
     @app.teardown_appcontext
     def remove_session(exception=None):