local-deep-research 0.5.0__tar.gz → 0.5.2__tar.gz

{local_deep_research-0.5.0 → local_deep_research-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: local-deep-research
-Version: 0.5.0
+Version: 0.5.2
 Summary: AI-powered research assistant with deep, iterative analysis using LLMs and web searches
 Author-Email: LearningCircuit <185559241+LearningCircuit@users.noreply.github.com>, HashedViking <6432677+HashedViking@users.noreply.github.com>
 License: MIT License

{local_deep_research-0.5.0 → local_deep_research-0.5.2}/pyproject.toml

@@ -67,7 +67,7 @@ dependencies = [
     "kaleido==0.2.1",
     "aiohttp>=3.9.0",
 ]
-version = "0.5.0"
+version = "0.5.2"
 
 [project.license]
 file = "LICENSE"

local_deep_research-0.5.2/src/local_deep_research/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.5.2"

{local_deep_research-0.5.0 → local_deep_research-0.5.2}/src/local_deep_research/web/database/migrations.py

@@ -2,7 +2,14 @@ from loguru import logger
 from sqlalchemy import inspect
 
 from ..services.settings_manager import SettingsManager
-from .models import Base, Journal, Setting, ResearchLog
+from .models import (
+    Base,
+    Journal,
+    Setting,
+    ResearchLog,
+    Research,
+    ResearchHistory,
+)
 
 
 def import_default_settings_file(db_session):
@@ -52,6 +59,14 @@ def run_migrations(engine, db_session=None):
         logger.info("Creating research logs table.")
         Base.metadata.create_all(engine, tables=[ResearchLog.__table__])
 
+    if not inspector.has_table(Research.__tablename__):
+        logger.info("Creating research table.")
+        Base.metadata.create_all(engine, tables=[Research.__table__])
+
+    if not inspector.has_table(ResearchHistory.__tablename__):
+        logger.info("Creating research table.")
+        Base.metadata.create_all(engine, tables=[ResearchHistory.__table__])
+
     # Import existing settings from files
     if db_session:
         import_default_settings_file(db_session)

{local_deep_research-0.5.0 → local_deep_research-0.5.2}/src/local_deep_research/web/database/models.py

@@ -34,6 +34,37 @@ class ResearchStatus(enum.Enum):
     CANCELLED = "cancelled"
 
 
+class ResearchHistory(Base):
+    """Represents the research table."""
+
+    __tablename__ = "research_history"
+
+    # Unique identifier for each record.
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    # The search query.
+    query = Column(Text, nullable=False)
+    # The mode of research (e.g., 'quick_summary', 'detailed_report').
+    mode = Column(Text, nullable=False)
+    # Current status of the research.
+    status = Column(Text, nullable=False)
+    # The timestamp when the research started.
+    created_at = Column(Text, nullable=False)
+    # The timestamp when the research was completed.
+    completed_at = Column(Text)
+    # Duration of the research in seconds.
+    duration_seconds = Column(Integer)
+    # Path to the generated report.
+    report_path = Column(Text)
+    # Additional metadata about the research.
+    research_meta = Column(JSON)
+    # Latest progress log message.
+    progress_log = Column(JSON)
+    # Current progress of the research (as a percentage).
+    progress = Column(Integer)
+    # Title of the research report.
+    title = Column(Text)
+
+
 class Research(Base):
     __tablename__ = "research"
 
@@ -54,14 +85,6 @@ class Research(Base):
     end_time = Column(DateTime, nullable=True)
     error_message = Column(Text, nullable=True)
 
-    # Relationships
-    report = relationship(
-        "ResearchReport",
-        back_populates="research",
-        uselist=False,
-        cascade="all, delete-orphan",
-    )
-
 
 class ResearchLog(Base):
     __tablename__ = "app_logs"
@@ -88,29 +111,6 @@ class ResearchLog(Base):
     )
 
 
-class ResearchReport(Base):
-    __tablename__ = "research_report"
-
-    id = Column(Integer, primary_key=True, index=True)
-    research_id = Column(
-        Integer,
-        ForeignKey("research.id", ondelete="CASCADE"),
-        nullable=False,
-        unique=True,
-    )
-    content = Column(Text, nullable=True)
-    created_at = Column(DateTime, server_default=func.now(), nullable=False)
-    updated_at = Column(
-        DateTime, server_default=func.now(), onupdate=func.now(), nullable=False
-    )
-    report_metadata = Column(
-        JSON, nullable=True
-    )  # Additional metadata about the report
-
-    # Relationships
-    research = relationship("Research", back_populates="report")
-
-
 class SettingType(enum.Enum):
     APP = "app"
     LLM = "llm"

{local_deep_research-0.5.0 → local_deep_research-0.5.2}/src/local_deep_research/web/models/database.py

@@ -43,26 +43,6 @@ def init_db():
     conn = get_db_connection()
     cursor = conn.cursor()
 
-    # Create the table if it doesn't exist
-    cursor.execute(
-        """
-    CREATE TABLE IF NOT EXISTS research_history (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        query TEXT NOT NULL,
-        mode TEXT NOT NULL,
-        status TEXT NOT NULL,
-        created_at TEXT NOT NULL,
-        completed_at TEXT,
-        duration_seconds INTEGER,
-        report_path TEXT,
-        metadata TEXT,
-        progress_log TEXT,
-        progress INTEGER,
-        title TEXT
-    )
-    """
-    )
-
     # Create a dedicated table for research logs
     cursor.execute(
         """
@@ -101,7 +81,7 @@ def init_db():
     columns = [column[1] for column in cursor.fetchall()]
 
     if "duration_seconds" not in columns:
-        print(
+        logger.info(
             "Adding missing 'duration_seconds' column to research_history table"
         )
         cursor.execute(
@@ -110,16 +90,26 @@ def init_db():
 
     # Check if the progress column exists, add it if missing
     if "progress" not in columns:
-        print("Adding missing 'progress' column to research_history table")
+        logger.info(
+            "Adding missing 'progress' column to research_history table"
+        )
         cursor.execute(
             "ALTER TABLE research_history ADD COLUMN progress INTEGER"
         )
 
     # Check if the title column exists, add it if missing
     if "title" not in columns:
-        print("Adding missing 'title' column to research_history table")
+        logger.info("Adding missing 'title' column to research_history table")
         cursor.execute("ALTER TABLE research_history ADD COLUMN title TEXT")
 
+    # Check if the metadata column exists, and rename it to "research_meta"
+    # if it does.
+    if "metadata" in columns:
+        logger.info("Renaming 'metadata' column to 'research_meta'")
+        cursor.execute(
+            "ALTER TABLE research_history RENAME COLUMN metadata TO research_meta"
+        )
+
     # Enable foreign key support
     cursor.execute("PRAGMA foreign_keys = ON")
 

{local_deep_research-0.5.0 → local_deep_research-0.5.2}/src/local_deep_research/web/routes/research_routes.py

@@ -15,13 +15,18 @@ from flask import (
 )
 from loguru import logger
 
-from ..models.database import calculate_duration, get_db_connection
+from ..models.database import (
+    calculate_duration,
+    get_db_connection,
+)
 from ..services.research_service import (
     run_research_process,
     start_research_process,
 )
 from ..utils.templates import render_template_with_defaults
 from .globals import active_research, termination_flags
+from ..database.models import ResearchHistory, ResearchLog
+from ...utilities.db_utils import get_db_session
 
 # Create a Blueprint for the research application
 research_bp = Blueprint("research", __name__, url_prefix="/research")
@@ -220,20 +225,19 @@ def start_research():
         "questions_per_iteration": questions_per_iteration,
     }
 
-    cursor.execute(
-        "INSERT INTO research_history (query, mode, status, created_at, progress_log, metadata) VALUES (?, ?, ?, ?, ?, ?)",
-        (
-            query,
-            mode,
-            "in_progress",
-            created_at,
-            json.dumps([{"time": created_at, "progress": 0}]),
-            json.dumps(research_settings),
-        ),
-    )
-    research_id = cursor.lastrowid
-    conn.commit()
-    conn.close()
+    db_session = get_db_session()
+    with db_session:
+        research = ResearchHistory(
+            query=query,
+            mode=mode,
+            status="in_progress",
+            created_at=created_at,
+            progress_log=[{"time": created_at, "progress": 0}],
+            research_meta=research_settings,
+        )
+        db_session.add(research)
+        db_session.commit()
+        research_id = research.id
 
     # Start the research process with the selected parameters
     research_thread = start_research_process(
@@ -612,59 +616,30 @@ def get_history():
 
 @research_bp.route("/api/research/<int:research_id>")
 def get_research_details(research_id):
-    """Get full details of a research"""
+    """Get full details of a research using ORM"""
     try:
-        conn = get_db_connection()
-        cursor = conn.cursor()
-        cursor.execute(
-            """SELECT id, query, status, progress, mode,
-               created_at, completed_at, report_path, metadata
-               FROM research_history WHERE id = ?""",
-            (research_id,),
+        db_session = get_db_session()
+        research = (
+            db_session.query(ResearchHistory)
+            .filter(ResearchHistory.id == research_id)
+            .first()
         )
-        result = cursor.fetchone()
 
-        if result is None:
-            conn.close()
+        if not research:
             return jsonify({"error": "Research not found"}), 404
 
-        # Unpack the result
-        (
-            research_id,
-            query,
-            status,
-            progress,
-            mode,
-            created_at,
-            completed_at,
-            report_path,
-            metadata_str,
-        ) = result
-
-        # Parse metadata if it exists
-        metadata = {}
-        if metadata_str:
-            try:
-                metadata = json.loads(metadata_str)
-            except json.JSONDecodeError:
-                logger.warning(
-                    f"Invalid JSON in metadata for research {research_id}"
-                )
-
-        conn.close()
-
         return jsonify(
             {
-                "id": research_id,
-                "query": query,
-                "status": status,
-                "progress": progress,
-                "progress_percentage": progress or 0,
-                "mode": mode,
-                "created_at": created_at,
-                "completed_at": completed_at,
-                "report_path": report_path,
-                "metadata": metadata,
+                "id": research.id,
+                "query": research.query,
+                "status": research.status,
+                "progress": research.progress,
+                "progress_percentage": research.progress or 0,
+                "mode": research.mode,
+                "created_at": research.created_at,
+                "completed_at": research.completed_at,
+                "report_path": research.report_path,
+                "metadata": research.research_meta,
             }
         )
     except Exception as e:
@@ -676,50 +651,36 @@ def get_research_details(research_id):
 def get_research_logs(research_id):
     """Get logs for a specific research"""
     try:
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
         # First check if the research exists
-        cursor.execute(
-            "SELECT id FROM research_history WHERE id = ?", (research_id,)
-        )
-        if cursor.fetchone() is None:
-            conn.close()
-            return jsonify({"error": "Research not found"}), 404
-
-        # Get logs from research_logs table
-        cursor.execute(
-            """SELECT id, message, timestamp, log_type, progress, metadata
-               FROM research_logs
-               WHERE research_id = ?
-               ORDER BY timestamp ASC""",
-            (research_id,),
-        )
+        db_session = get_db_session()
+        with db_session:
+            research = (
+                db_session.query(ResearchHistory)
+                .filter_by(id=research_id)
+                .first()
+            )
+            if not research:
+                return jsonify({"error": "Research not found"}), 404
+
+            # Get logs from research_logs table
+            log_results = (
+                db_session.query(ResearchLog)
+                .filter_by(research_id=research_id)
+                .order_by(ResearchLog.timestamp)
+                .all()
+            )
 
         logs = []
-        for row in cursor.fetchall():
-            log_id, message, timestamp, log_type, progress, metadata_str = row
-
-            # Parse metadata if it exists
-            metadata = {}
-            if metadata_str:
-                try:
-                    metadata = json.loads(metadata_str)
-                except json.JSONDecodeError:
-                    pass
-
+        for row in log_results:
             logs.append(
                 {
-                    "id": log_id,
-                    "message": message,
-                    "timestamp": timestamp,
-                    "log_type": log_type,
-                    "progress": progress,
-                    "metadata": metadata,
+                    "id": row.id,
+                    "message": row.message,
+                    "timestamp": row.timestamp,
+                    "log_type": row.level,
                 }
             )
 
-        conn.close()
         return jsonify(logs)
 
     except Exception as e:
@@ -730,27 +691,18 @@ def get_research_logs(research_id):
 @research_bp.route("/api/report/<int:research_id>")
 def get_research_report(research_id):
     """Get the research report content"""
-    from ..database.models import Research
-    from ...utilities.db_utils import get_db_session
-
     session = get_db_session()
     try:
         # Query using ORM
-        research = session.query(Research).filter_by(id=research_id).first()
+        research = (
+            session.query(ResearchHistory).filter_by(id=research_id).first()
+        )
 
         if research is None:
             return jsonify({"error": "Research not found"}), 404
 
         # Parse metadata if it exists
-        metadata = {}
-        if research.metadata:
-            try:
-                metadata = json.loads(research.metadata)
-            except json.JSONDecodeError:
-                logger.warning(
-                    f"Invalid JSON in metadata for research {research_id}"
-                )
-
+        metadata = research.research_meta
         # Check if report file exists
         if not research.report_path or not os.path.exists(research.report_path):
             return jsonify({"error": "Report file not found"}), 404
@@ -771,11 +723,11 @@ def get_research_report(research_id):
                 "content": content,
                 "metadata": {
                     "query": research.query,
-                    "mode": research.mode.value if research.mode else None,
-                    "created_at": research.created_at.isoformat()
+                    "mode": research.mode if research.mode else None,
+                    "created_at": research.created_at
                     if research.created_at
                     else None,
-                    "completed_at": research.completed_at.isoformat()
+                    "completed_at": research.completed_at
                     if research.completed_at
                     else None,
                     "report_path": research.report_path,