local-deep-research 0.4.4__py3-none-any.whl → 0.5.2__py3-none-any.whl

local_deep_research/web/routes/api_routes.py

@@ -59,9 +59,7 @@ def api_start_research():
                 mode,
                 "in_progress",
                 created_at,
-                json.dumps(
-                    [{"time": created_at, "message": "Research started", "progress": 0}]
-                ),
+                json.dumps([{"time": created_at, "progress": 0}]),
                 json.dumps(research_settings),
             ),
         )
@@ -89,9 +87,11 @@ def api_start_research():
                 "research_id": research_id,
             }
         )
-    except Exception as e:
-        logger.error(f"Error starting research: {str(e)}")
-        return jsonify({"status": "error", "message": str(e)}), 500
+    except Exception:
+        logger.exception("Error starting research")
+        return jsonify(
+            {"status": "error", "message": "Failed to start research"}, 500
+        )
 
 
 @api_bp.route("/status/<int:research_id>", methods=["GET"])
@@ -120,7 +120,9 @@ def api_research_status(research_id):
             try:
                 metadata = json.loads(metadata_str)
             except json.JSONDecodeError:
-                logger.warning(f"Invalid JSON in metadata for research {research_id}")
+                logger.warning(
+                    f"Invalid JSON in metadata for research {research_id}"
+                )
 
         return jsonify(
             {
@@ -144,10 +146,18 @@ def api_terminate_research(research_id):
     try:
         result = cancel_research(research_id)
         return jsonify(
-            {"status": "success", "message": "Research terminated", "result": result}
+            {
+                "status": "success",
+                "message": "Research terminated",
+                "result": result,
+            }
+        )
+    except Exception:
+        logger.exception("Error terminating research")
+        return (
+            jsonify({"status": "error", "message": "Failed to stop research."}),
+            500,
         )
-    except Exception as e:
-        return jsonify({"status": "error", "message": str(e)}), 500
 
 
 @api_bp.route("/resources/<int:research_id>", methods=["GET"])
@@ -158,8 +168,11 @@ def api_get_resources(research_id):
     try:
         resources = get_resources_for_research(research_id)
         return jsonify({"status": "success", "resources": resources})
-    except Exception as e:
-        return jsonify({"status": "error", "message": str(e)}), 500
+    except Exception:
+        logger.exception("Error getting resources for research")
+        return jsonify(
+            {"status": "error", "message": "Failed to get resources"}, 500
+        )
 
 
 @api_bp.route("/resources/<int:research_id>", methods=["POST"])
@@ -182,19 +195,25 @@ def api_add_resource(research_id):
         # Validate required fields
         if not title or not url:
             return (
-                jsonify({"status": "error", "message": "Title and URL are required"}),
+                jsonify(
+                    {"status": "error", "message": "Title and URL are required"}
+                ),
                 400,
             )
 
         # Check if the research exists
         conn = get_db_connection()
         cursor = conn.cursor()
-        cursor.execute("SELECT id FROM research_history WHERE id = ?", (research_id,))
+        cursor.execute(
+            "SELECT id FROM research_history WHERE id = ?", (research_id,)
+        )
         result = cursor.fetchone()
         conn.close()
 
         if not result:
-            return jsonify({"status": "error", "message": "Research not found"}), 404
+            return jsonify(
+                {"status": "error", "message": "Research not found"}
+            ), 404
 
         # Add the resource
         resource_id = add_resource(
@@ -231,10 +250,15 @@ def api_delete_resource(research_id, resource_id):
 
         if success:
             return jsonify(
-                {"status": "success", "message": "Resource deleted successfully"}
+                {
+                    "status": "success",
+                    "message": "Resource deleted successfully",
+                }
             )
         else:
-            return jsonify({"status": "error", "message": "Resource not found"}), 404
+            return jsonify(
+                {"status": "error", "message": "Resource not found"}
+            ), 404
     except Exception as e:
         logger.error(f"Error deleting resource: {str(e)}")
         return jsonify({"status": "error", "message": str(e)}), 500
@@ -252,7 +276,10 @@ def check_ollama_status():
 
         if provider.lower() != "ollama":
             return jsonify(
-                {"running": True, "message": f"Using provider: {provider}, not Ollama"}
+                {
+                    "running": True,
+                    "message": f"Using provider: {provider}, not Ollama",
+                }
             )
 
         # Get Ollama API URL from LLM config
@@ -272,7 +299,9 @@ def check_ollama_status():
             response = requests.get(f"{ollama_base_url}/api/tags", timeout=5)
 
             # Add response details for debugging
-            logger.debug(f"Ollama status check response code: {response.status_code}")
+            logger.debug(
+                f"Ollama status check response code: {response.status_code}"
+            )
 
             if response.status_code == 200:
                 # Try to validate the response content
@@ -420,7 +449,9 @@ def check_ollama_model():
 
                 # Debug log the first bit of the response
                 response_preview = (
-                    str(data)[:500] + "..." if len(str(data)) > 500 else str(data)
+                    str(data)[:500] + "..."
+                    if len(str(data)) > 500
+                    else str(data)
                 )
                 logger.debug(f"Ollama API response data: {response_preview}")
 
@@ -448,7 +479,8 @@ def check_ollama_model():
 
                 # Case-insensitive model name comparison
                 model_exists = any(
-                    m.get("name", "").lower() == model_name.lower() for m in models
+                    m.get("name", "").lower() == model_name.lower()
+                    for m in models
                 )
 
                 if model_exists:
@@ -561,7 +593,9 @@ def api_get_config():
             "search_tool", "auto"
         ),
         "features": {
-            "notifications": current_app.config.get("ENABLE_NOTIFICATIONS", False)
+            "notifications": current_app.config.get(
+                "ENABLE_NOTIFICATIONS", False
+            )
         },
     }
 

local_deep_research/web/routes/benchmark_routes.py

@@ -190,7 +190,10 @@ def get_benchmark_config():
             ],
             "evaluation_models": {
                 "openai_endpoint": [
-                    {"id": "anthropic/claude-3.7-sonnet", "name": "Claude 3.7 Sonnet"}
+                    {
+                        "id": "anthropic/claude-3.7-sonnet",
+                        "name": "Claude 3.7 Sonnet",
+                    }
                 ],
                 "openai": [
                     {"id": "gpt-4o", "name": "GPT-4o"},

local_deep_research/web/routes/globals.py

@@ -0,0 +1,22 @@
+"""
+Stores global state.
+"""
+
+# Active research processes and socket subscriptions
+active_research = {}
+socket_subscriptions = {}
+# Add termination flags dictionary
+termination_flags = {}
+
+
+def get_globals():
+    """
+    Returns:
+        Global state for other modules to access.
+
+    """
+    return {
+        "active_research": active_research,
+        "socket_subscriptions": socket_subscriptions,
+        "termination_flags": termination_flags,
+    }

local_deep_research/web/routes/history_routes.py

@@ -1,10 +1,17 @@
 import json
 import logging
 import traceback
+from pathlib import Path
 
 from flask import Blueprint, jsonify, make_response
 
-from ..models.database import get_db_connection, get_logs_for_research
+from ..models.database import (
+    get_db_connection,
+    get_logs_for_research,
+    get_total_logs_for_research,
+)
+from ..routes.globals import get_globals
+from ..services.research_service import get_research_strategy
 
 # Initialize logger
 logger = logging.getLogger(__name__)
@@ -13,6 +20,20 @@ logger = logging.getLogger(__name__)
 history_bp = Blueprint("history", __name__)
 
 
+def resolve_report_path(report_path: str) -> Path:
+    """
+    Resolve report path to absolute path using pathlib.
+    Handles both absolute and relative paths.
+    """
+    path = Path(report_path)
+    if path.is_absolute():
+        return path
+
+    # If relative path, make it relative to project root
+    project_root = Path(__file__).parent.parent.parent.parent
+    return project_root / path
+
+
 @history_bp.route("/history", methods=["GET"])
 def get_history():
     """Get the research history"""
@@ -24,7 +45,9 @@ def get_history():
         cursor = conn.cursor()
 
         # Get all history records ordered by latest first
-        cursor.execute("SELECT * FROM research_history ORDER BY created_at DESC")
+        cursor.execute(
+            "SELECT * FROM research_history ORDER BY created_at DESC"
+        )
         results = cursor.fetchall()
         conn.close()
 
@@ -135,15 +158,16 @@ def get_research_status(research_id):
         column[0]: row[idx] for idx, column in enumerate(cursor.description)
     }
     cursor = conn.cursor()
-    cursor.execute("SELECT * FROM research_history WHERE id = ?", (research_id,))
+    cursor.execute(
+        "SELECT * FROM research_history WHERE id = ?", (research_id,)
+    )
     result = cursor.fetchone()
     conn.close()
 
     if not result:
-        return jsonify({"status": "error", "message": "Research not found"}), 404
-
-    # Import globals from research routes
-    from .research_routes import get_globals
+        return jsonify(
+            {"status": "error", "message": "Research not found"}
+        ), 404
 
     globals_dict = get_globals()
     active_research = globals_dict["active_research"]
@@ -176,18 +200,22 @@ def get_research_details(research_id):
         column[0]: row[idx] for idx, column in enumerate(cursor.description)
     }
     cursor = conn.cursor()
-    cursor.execute("SELECT * FROM research_history WHERE id = ?", (research_id,))
+    cursor.execute(
+        "SELECT * FROM research_history WHERE id = ?", (research_id,)
+    )
     result = cursor.fetchone()
     conn.close()
 
     if not result:
-        return jsonify({"status": "error", "message": "Research not found"}), 404
+        return jsonify(
+            {"status": "error", "message": "Research not found"}
+        ), 404
 
     # Get logs from the dedicated log database
     logs = get_logs_for_research(research_id)
 
-    # Import globals from research routes
-    from .research_routes import get_globals
+    # Get strategy information
+    strategy_name = get_research_strategy(research_id)
 
     globals_dict = get_globals()
     active_research = globals_dict["active_research"]
@@ -215,6 +243,7 @@ def get_research_details(research_id):
             "query": result.get("query"),
             "mode": result.get("mode"),
             "status": result.get("status"),
+            "strategy": strategy_name,
             "progress": active_research.get(research_id, {}).get(
                 "progress", 100 if result.get("status") == "completed" else 0
             ),
@@ -232,7 +261,9 @@ def get_report(research_id):
         column[0]: row[idx] for idx, column in enumerate(cursor.description)
     }
     cursor = conn.cursor()
-    cursor.execute("SELECT * FROM research_history WHERE id = ?", (research_id,))
+    cursor.execute(
+        "SELECT * FROM research_history WHERE id = ?", (research_id,)
+    )
     result = cursor.fetchone()
     conn.close()
 
@@ -240,7 +271,10 @@ def get_report(research_id):
         return jsonify({"status": "error", "message": "Report not found"}), 404
 
     try:
-        with open(result["report_path"], "r", encoding="utf-8") as f:
+        # Resolve report path using helper function
+        report_path = resolve_report_path(result["report_path"])
+
+        with open(report_path, "r", encoding="utf-8") as f:
             content = f.read()
 
         # Create an enhanced metadata dictionary with database fields
@@ -280,7 +314,9 @@ def get_markdown(research_id):
         column[0]: row[idx] for idx, column in enumerate(cursor.description)
     }
     cursor = conn.cursor()
-    cursor.execute("SELECT * FROM research_history WHERE id = ?", (research_id,))
+    cursor.execute(
+        "SELECT * FROM research_history WHERE id = ?", (research_id,)
+    )
     result = cursor.fetchone()
     conn.close()
 
@@ -288,7 +324,10 @@ def get_markdown(research_id):
         return jsonify({"status": "error", "message": "Report not found"}), 404
 
     try:
-        with open(result["report_path"], "r", encoding="utf-8") as f:
+        # Resolve report path using helper function
+        report_path = resolve_report_path(result["report_path"])
+
+        with open(report_path, "r", encoding="utf-8") as f:
             content = f.read()
         return jsonify({"status": "success", "content": content})
     except Exception as e:
@@ -304,12 +343,16 @@ def get_research_logs(research_id):
         column[0]: row[idx] for idx, column in enumerate(cursor.description)
     }
     cursor = conn.cursor()
-    cursor.execute("SELECT id FROM research_history WHERE id = ?", (research_id,))
+    cursor.execute(
+        "SELECT id FROM research_history WHERE id = ?", (research_id,)
+    )
     result = cursor.fetchone()
     conn.close()
 
     if not result:
-        return jsonify({"status": "error", "message": "Research not found"}), 404
+        return jsonify(
+            {"status": "error", "message": "Research not found"}
+        ), 404
 
     # Retrieve logs from the database
     logs = get_logs_for_research(research_id)
@@ -317,38 +360,20 @@ def get_research_logs(research_id):
     # Format logs correctly if needed
     formatted_logs = []
     for log in logs:
+        log_entry = log.copy()
         # Ensure each log has time, message, and type fields
-        log_entry = {
-            "time": log.get("time", ""),
-            "message": log.get("message", "No message"),
-            "type": log.get("type", "info"),
-        }
+        log_entry["time"] = log.get("time", "")
+        log_entry["message"] = log.get("message", "No message")
+        log_entry["type"] = log.get("type", "info")
         formatted_logs.append(log_entry)
 
-    # Import globals from research routes
-    from .research_routes import get_globals
-
-    globals_dict = get_globals()
-    active_research = globals_dict["active_research"]
-
-    # Add any current logs from memory if this is an active research
-    if research_id in active_research and active_research[research_id].get("log"):
-        # Use the logs from memory temporarily until they're saved to the database
-        memory_logs = active_research[research_id]["log"]
-
-        # Format memory logs too
-        for log in memory_logs:
-            log_entry = {
-                "time": log.get("time", ""),
-                "message": log.get("message", "No message"),
-                "type": log.get("type", "info"),
-            }
+    return jsonify({"status": "success", "logs": formatted_logs})
 
-            # Check if this log is already in our formatted logs by timestamp
-            if not any(flog["time"] == log_entry["time"] for flog in formatted_logs):
-                formatted_logs.append(log_entry)
 
-        # Sort logs by timestamp
-        formatted_logs.sort(key=lambda x: x["time"])
+@history_bp.route("/log_count/<int:research_id>")
+def get_log_count(research_id):
+    """Get the total number of logs for a specific research ID"""
+    # Get the total number of logs for this research ID
+    total_logs = get_total_logs_for_research(research_id)
 
-    return jsonify({"status": "success", "logs": formatted_logs})
+    return jsonify({"status": "success", "total_logs": total_logs})