local-deep-research 0.5.0__py3-none-any.whl → 0.5.3__py3-none-any.whl

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,