local-deep-research 0.3.12__py3-none-any.whl → 0.4.1__py3-none-any.whl

local_deep_research/utilities/log_utils.py

@@ -0,0 +1,36 @@
+"""
+Utilities for logging.
+"""
+
+import inspect
+import logging
+
+from loguru import logger
+
+
+class InterceptHandler(logging.Handler):
+    """
+    Intercepts logging messages and forwards them to Loguru's logger.
+    """
+
+    def emit(self, record: logging.LogRecord) -> None:
+        # Get corresponding Loguru level if it exists.
+        try:
+            level: str | int = logger.level(record.levelname).name
+        except ValueError:
+            level = record.levelno
+
+        # Find caller from where originated the logged message.
+        frame, depth = inspect.currentframe(), 0
+        while frame:
+            filename = frame.f_code.co_filename
+            is_logging = filename == logging.__file__
+            is_frozen = "importlib" in filename and "_bootstrap" in filename
+            if depth > 0 and not (is_logging or is_frozen):
+                break
+            frame = frame.f_back
+            depth += 1
+
+        logger.opt(depth=depth, exception=record.exc_info).log(
+            level, record.getMessage()
+        )

local_deep_research/utilities/search_utilities.py

@@ -1,8 +1,7 @@
-import logging
 import re
 from typing import Dict, List
 
-logger = logging.getLogger(__name__)
+from loguru import logger
 
 
 def remove_think_tags(text: str) -> str:
@@ -36,9 +35,9 @@ def extract_links_from_search_results(search_results: List[Dict]) -> List[Dict]:
 
             if title and url:
                 links.append({"title": title, "url": url, "index": index})
-        except Exception as e:
+        except Exception:
             # Log the specific error for debugging
-            logger.error(f"Error extracting link from result: {str(e)}")
+            logger.exception("Error extracting link from result")
             continue
     return links
 
@@ -111,8 +110,8 @@ def format_findings(
             try:
                 links = extract_links_from_search_results(search_results)
                 all_links.extend(links)
-            except Exception as link_err:
-                logger.error(f"Error processing search results/links: {link_err}")
+            except Exception:
+                logger.exception("Error processing search results/links")
 
     # Start with the synthesized content (passed as synthesized_content)
     formatted_text += f"{synthesized_content}\n\n"
@@ -215,9 +214,9 @@ def format_findings(
                     if links:
                         formatted_text += "### SOURCES USED IN THIS SECTION:\n"
                         formatted_text += format_links_to_markdown(links) + "\n\n"
-                except Exception as link_err:
-                    logger.error(
-                        f"Error processing search results/links for finding {idx}: {link_err}"
+                except Exception:
+                    logger.exception(
+                        f"Error processing search results/links for finding {idx}"
                     )
             else:
                 logger.debug(f"No search_results found for finding item {idx}.")

local_deep_research/web/app.py

@@ -1,7 +1,8 @@
-import logging
 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 .app_factory import create_app
@@ -11,9 +12,6 @@ from .models.database import (
     LEGACY_RESEARCH_HISTORY_DB,
 )
 
-# Initialize logger
-logger = logging.getLogger(__name__)
-
 # Ensure data directory exists
 setup_data_dir()
 
@@ -24,8 +22,8 @@ if os.path.exists(DB_PATH):
         from .database.schema_upgrade import run_schema_upgrades
 
         run_schema_upgrades()
-    except Exception as e:
-        logger.error(f"Error running schema upgrades: {e}")
+    except Exception:
+        logger.exception("Error running schema upgrades")
         logger.warning("Continuing without schema upgrades")
 
 
@@ -51,6 +49,7 @@ def check_migration_needed():
 app, socketio = create_app()
 
 
+@logger.catch()
 def main():
     """
     Entry point for the web application when run as a command.
@@ -85,9 +84,8 @@ def main():
                     logger.info("Database migration completed successfully.")
                 else:
                     logger.warning("Database migration failed.")
-            except Exception as e:
-                logger.error(f"Error running database migration: {e}")
-                print(f"Error: {e}")
+            except Exception:
+                logger.exception("Error running database migration")
                 print("Please run migration manually.")
 
     # Get web server settings with defaults
@@ -96,7 +94,14 @@ def main():
     debug = get_db_setting("web.debug", True)
 
     logger.info(f"Starting web server on {host}:{port} (debug: {debug})")
-    socketio.run(app, debug=debug, host=host, port=port, allow_unsafe_werkzeug=True)
+    socketio.run(
+        app,
+        debug=debug,
+        host=host,
+        port=port,
+        allow_unsafe_werkzeug=True,
+        use_reloader=False,
+    )
 
 
 if __name__ == "__main__":

local_deep_research/web/app_factory.py

@@ -13,12 +13,11 @@ from flask import (
 )
 from flask_socketio import SocketIO
 from flask_wtf.csrf import CSRFProtect
+from loguru import logger
 
+from ..utilities.log_utils import InterceptHandler
 from .models.database import DB_PATH, init_db
 
-# Initialize logger
-logger = logging.getLogger(__name__)
-
 
 def create_app():
     """
@@ -27,11 +26,9 @@ def create_app():
     Returns:
         tuple: (app, socketio) - The configured Flask app and SocketIO instance
     """
-    # Configure logging
-    logging.basicConfig(level=logging.INFO)
-
     # Set Werkzeug logger to WARNING level to suppress Socket.IO polling logs
     logging.getLogger("werkzeug").setLevel(logging.WARNING)
+    logging.getLogger("werkzeug").addHandler(InterceptHandler())
 
     try:
         # Get directories based on package installation
@@ -42,11 +39,11 @@ def create_app():
 
         # Initialize Flask app with package directories
         app = Flask(__name__, static_folder=STATIC_DIR, template_folder=TEMPLATE_DIR)
-        print(f"Using package static path: {STATIC_DIR}")
-        print(f"Using package template path: {TEMPLATE_DIR}")
-    except Exception as e:
+        logger.debug(f"Using package static path: {STATIC_DIR}")
+        logger.debug(f"Using package template path: {TEMPLATE_DIR}")
+    except Exception:
         # Fallback for development
-        print(f"Package directories not found, using fallback paths: {str(e)}")
+        logger.exception("Package directories not found, using fallback paths")
         app = Flask(
             __name__,
             static_folder=os.path.abspath("static"),
@@ -142,8 +139,8 @@ def apply_middleware(app):
             try:
                 if not request.environ.get("werkzeug.socket"):
                     return
-            except Exception as e:
-                print(f"WebSocket preprocessing error: {e}")
+            except Exception:
+                logger.exception("WebSocket preprocessing error")
                 # Return empty response to prevent further processing
                 return "", 200
 

local_deep_research/web/database/migrations.py

@@ -1,11 +1,8 @@
-import logging
-
+from loguru import logger
 from sqlalchemy import inspect
 
 from ..services.settings_manager import SettingsManager
-from .models import Base, Setting
-
-logger = logging.getLogger(__name__)
+from .models import Base, Journal, Setting
 
 
 def import_default_settings_file(db_session):
@@ -27,12 +24,14 @@ def import_default_settings_file(db_session):
         settings_mgr.load_from_defaults_file(overwrite=False, delete_extra=True)
         logger.info("Successfully imported settings from files")
 
+
         # Update the saved version.
         settings_mgr.update_db_version()
     except Exception as e:
         logger.error("Error importing settings from files: %s", e)
 
 
+
 def run_migrations(engine, db_session=None):
     """
     Run any necessary database migrations
@@ -47,6 +46,10 @@ def run_migrations(engine, db_session=None):
         logger.info("Creating settings table")
         Base.metadata.create_all(engine, tables=[Setting.__table__])
 
+    if not inspector.has_table(Journal.__tablename__):
+        logger.info("Creating journals table.")
+        Base.metadata.create_all(engine, tables=[Journal.__table__])
+
     # Import existing settings from files
     if db_session:
         import_default_settings_file(db_session)

local_deep_research/web/database/models.py

@@ -9,6 +9,7 @@ from sqlalchemy import (
     Float,
     ForeignKey,
     Integer,
+    Sequence,
     String,
     Text,
     UniqueConstraint,
@@ -115,3 +116,22 @@ class Setting(Base):
     )
 
     __table_args__ = (UniqueConstraint("key", name="uix_settings_key"),)
+
+
+class Journal(Base):
+    """
+    Database model for storing information about academic journals.
+    """
+
+    __tablename__ = "journals"
+
+    id = Column(Integer, Sequence("journal_id_seq"), primary_key=True, index=True)
+
+    # Name of the journal
+    name = Column(String(255), nullable=False, unique=True, index=True)
+    # Quality score of the journal
+    quality = Column(Integer, nullable=True)
+    # Model that was used to generate the quality score.
+    quality_model = Column(String(255), nullable=True, index=True)
+    # Time at which the quality was last analyzed.
+    quality_analysis_time = Column(Integer, nullable=False)

local_deep_research/web/database/schema_upgrade.py

@@ -3,14 +3,11 @@ Schema upgrade script for Local Deep Research database.
 Handles schema upgrades for existing ldr.db databases.
 """
 
-import logging
 import os
 import sqlite3
 import sys
 
-# Set up logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
+from loguru import logger
 
 # Add the parent directory to sys.path to allow relative imports
 sys.path.append(
@@ -67,8 +64,8 @@ def remove_research_log_table(conn):
         else:
             logger.info("Table 'research_log' does not exist, no action needed")
             return True
-    except Exception as e:
-        logger.error(f"Error removing research_log table: {e}")
+    except Exception:
+        logger.exception("Error removing research_log table")
         return False
 
 
@@ -98,8 +95,8 @@ def run_schema_upgrades():
 
         logger.info("Schema upgrades completed successfully")
         return True
-    except Exception as e:
-        logger.error(f"Error during schema upgrades: {e}")
+    except Exception:
+        logger.exception("Error during schema upgrades")
         return False
 
 

local_deep_research/web/models/database.py

@@ -1,12 +1,9 @@
 import json
-import logging
 import os
 import sqlite3
-import traceback
 from datetime import datetime
 
-# Initialize logger
-logger = logging.getLogger(__name__)
+from loguru import logger
 
 # Database path
 # Use unified database in data directory
@@ -159,14 +156,14 @@ def calculate_duration(created_at_str, completed_at_str=None):
                         end_time = datetime.fromisoformat(
                             completed_at_str.replace(" ", "T")
                         )
-        except Exception as e:
-            print(f"Error parsing completed_at timestamp: {str(e)}")
+        except Exception:
+            logger.exception("Error parsing completed_at timestamp")
             try:
                 from dateutil import parser
 
                 end_time = parser.parse(completed_at_str)
             except Exception:
-                print(
+                logger.exception(
                     f"Fallback parsing also failed for completed_at: {completed_at_str}"
                 )
                 # Fall back to current time
@@ -192,23 +189,25 @@ def calculate_duration(created_at_str, completed_at_str=None):
                     start_time = datetime.fromisoformat(
                         created_at_str.replace(" ", "T")
                     )
-    except Exception as e:
-        print(f"Error parsing created_at timestamp: {str(e)}")
+    except Exception:
+        logger.exception("Error parsing created_at timestamp")
         # Fallback method if parsing fails
         try:
             from dateutil import parser
 
             start_time = parser.parse(created_at_str)
         except Exception:
-            print(f"Fallback parsing also failed for created_at: {created_at_str}")
+            logger.exception(
+                f"Fallback parsing also failed for created_at:" f" {created_at_str}"
+            )
             return None
 
     # Calculate duration if both timestamps are valid
     if start_time and end_time:
         try:
             return int((end_time - start_time).total_seconds())
-        except Exception as e:
-            print(f"Error calculating duration: {str(e)}")
+        except Exception:
+            logger.exception("Error calculating duration")
 
     return None
 
@@ -238,9 +237,8 @@ def add_log_to_db(research_id, message, log_type="info", progress=None, metadata
         conn.commit()
         conn.close()
         return True
-    except Exception as e:
-        print(f"Error adding log to database: {str(e)}")
-        print(traceback.format_exc())
+    except Exception:
+        logger.exception("Error adding log to database")
         return False
 
 
@@ -288,7 +286,6 @@ def get_logs_for_research(research_id):
             logs.append(formatted_entry)
 
         return logs
-    except Exception as e:
-        print(f"Error retrieving logs from database: {str(e)}")
-        print(traceback.format_exc())
+    except Exception:
+        logger.exception("Error retrieving logs from database")
         return []