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

local_deep_research/web/services/research_service.py

@@ -1,9 +1,10 @@
+import hashlib
 import json
-import logging
-import os
 import threading
-import traceback
 from datetime import datetime
+from pathlib import Path
+
+from loguru import logger
 
 from ...config.llm_config import get_llm
 from ...config.search_config import get_search
@@ -13,11 +14,8 @@ from ...utilities.search_utilities import extract_links_from_search_results
 from ..models.database import add_log_to_db, calculate_duration, get_db_connection
 from .socket_service import emit_to_subscribers
 
-# Initialize logger
-logger = logging.getLogger(__name__)
-
 # Output directory for research results
-OUTPUT_DIR = "research_outputs"
+OUTPUT_DIR = Path("research_outputs")
 
 
 def start_research_process(
@@ -70,6 +68,25 @@ def start_research_process(
     return thread
 
 
+def _generate_report_path(query: str) -> Path:
+    """
+    Generates a path for a new report file based on the query.
+
+    Args:
+        query: The query used for the report.
+
+    Returns:
+        The path that it generated.
+
+    """
+    # Generate a unique filename that does not contain
+    # non-alphanumeric characters.
+    query_hash = hashlib.md5(query.encode("utf-8")).hexdigest()[:10]
+    return OUTPUT_DIR / (
+        f"research_report_{query_hash}_{int(datetime.now().timestamp())}.md"
+    )
+
+
 def run_research_process(
     research_id, query, mode, active_research, termination_flags, **kwargs
 ):
@@ -121,8 +138,8 @@ def run_research_process(
         )
 
         # Set up the AI Context Manager
-        output_dir = os.path.join(OUTPUT_DIR, f"research_{research_id}")
-        os.makedirs(output_dir, exist_ok=True)
+        output_dir = OUTPUT_DIR / f"research_{research_id}"
+        output_dir.mkdir(parents=True, exist_ok=True)
 
         # Set up progress callback
         def progress_callback(message, progress_percent, metadata):
@@ -239,8 +256,8 @@ def run_research_process(
                         event_data["log_entry"] = log_entry
 
                     emit_to_subscribers("research_progress", research_id, event_data)
-                except Exception as e:
-                    logger.error(f"Socket emit error (non-critical): {str(e)}")
+                except Exception:
+                    logger.exception("Socket emit error (non-critical)")
 
         # Function to check termination during long-running operations
         def check_termination():
@@ -275,14 +292,12 @@ def run_research_process(
                     model_provider,
                     model,
                 )
-            except Exception as e:
-                logger.error(
-                    "Error setting LLM provider=%s, model=%s: %s",
+            except Exception:
+                logger.exception(
+                    "Error setting LLM provider=%s, model=%s",
                     model_provider,
                     model,
-                    str(e),
                 )
-                logger.error(traceback.format_exc())
 
         # Set the progress callback in the system
         system = AdvancedSearchSystem(llm=use_llm)
@@ -302,10 +317,8 @@ def run_research_process(
                 )
 
                 logger.info("Successfully set search engine to: %s", search_engine)
-            except Exception as e:
-                logger.error(
-                    "Error setting search engine to %s: %s", search_engine, str(e)
-                )
+            except Exception:
+                logger.exception("Error setting search engine to %s", search_engine)
 
         # Run the search
         progress_callback("Starting research process", 5, {"phase": "init"})
@@ -358,10 +371,8 @@ def run_research_process(
                 if isinstance(
                     raw_formatted_findings, str
                 ) and raw_formatted_findings.startswith("Error:"):
-                    import traceback
-
-                    logger.warning(
-                        f"Detected error in formatted findings: {raw_formatted_findings[:100]}... stack trace: {traceback.format_exc()}"
+                    logger.exception(
+                        f"Detected error in formatted findings: {raw_formatted_findings[:100]}..."
                     )
 
                     # Determine error type for better user feedback
@@ -502,9 +513,9 @@ def run_research_process(
                                     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"
                                 )
 
                     logger.info(
@@ -520,18 +531,8 @@ def run_research_process(
                     )
 
                     # Save as markdown file
-                    if not os.path.exists(OUTPUT_DIR):
-                        os.makedirs(OUTPUT_DIR)
-
-                    safe_query = "".join(
-                        x for x in query if x.isalnum() or x in [" ", "-", "_"]
-                    )[:50]
-                    safe_query = safe_query.replace(" ", "_").lower()
-                    report_path = os.path.join(
-                        OUTPUT_DIR,
-                        f"quick_summary_{safe_query}_"
-                        f"{int(datetime.now().timestamp())}.md",
-                    )
+                    OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+                    report_path = _generate_report_path(query)
 
                     # Send progress update for writing to file
                     progress_callback(
@@ -541,7 +542,7 @@ def run_research_process(
                     )
 
                     logger.info("Writing report to: %s", report_path)
-                    with open(report_path, "w", encoding="utf-8") as f:
+                    with report_path.open("w", encoding="utf-8") as f:
                         f.write("# Quick Research Summary\n\n")
                         f.write(f"Query: {query}\n\n")
                         f.write(clean_markdown)
@@ -579,7 +580,7 @@ def run_research_process(
                             "completed",
                             completed_at,
                             duration_seconds,
-                            report_path,
+                            str(report_path),
                             json.dumps(metadata),
                             research_id,
                         ),
@@ -594,7 +595,7 @@ def run_research_process(
                     progress_callback(
                         "Research completed successfully",
                         100,
-                        {"phase": "complete", "report_path": report_path},
+                        {"phase": "complete", "report_path": str(report_path)},
                     )
 
                     # Clean up resources
@@ -607,10 +608,7 @@ def run_research_process(
                     logger.info("Resources cleaned up for research_id: %s", research_id)
 
                 except Exception as inner_e:
-                    logger.error(
-                        "Error during quick summary generation: %s", str(inner_e)
-                    )
-                    logger.error(traceback.format_exc())
+                    logger.exception("Error during quick summary generation")
                     raise Exception(f"Error generating quick summary: {str(inner_e)}")
             else:
                 raise Exception(
@@ -634,19 +632,10 @@ def run_research_process(
             )
 
             # Save as markdown file
-            if not os.path.exists(OUTPUT_DIR):
-                os.makedirs(OUTPUT_DIR)
-
-            safe_query = "".join(
-                x for x in query if x.isalnum() or x in [" ", "-", "_"]
-            )[:50]
-            safe_query = safe_query.replace(" ", "_").lower()
-            report_path = os.path.join(
-                OUTPUT_DIR,
-                f"detailed_report_{safe_query}_{int(datetime.now().timestamp())}.md",
-            )
+            OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+            report_path = _generate_report_path(query)
 
-            with open(report_path, "w", encoding="utf-8") as f:
+            with report_path.open("w", encoding="utf-8") as f:
                 f.write(final_report["content"])
 
             # Update database
@@ -674,7 +663,7 @@ def run_research_process(
                     "completed",
                     completed_at,
                     duration_seconds,
-                    report_path,
+                    str(report_path),
                     json.dumps(metadata),
                     research_id,
                 ),
@@ -685,7 +674,7 @@ def run_research_process(
             progress_callback(
                 "Research completed successfully",
                 100,
-                {"phase": "complete", "report_path": report_path},
+                {"phase": "complete", "report_path": str(report_path)},
             )
 
             # Clean up resources
@@ -694,10 +683,7 @@ def run_research_process(
     except Exception as e:
         # Handle error
         error_message = f"Research failed: {str(e)}"
-        logger.error(error_message)
-        import traceback
-
-        logger.error("Exception occurred:" + str(traceback.print_exc()))
+        logger.exception(error_message)
 
         try:
             # Check for common Ollama error patterns in the exception and provide more user-friendly errors
@@ -783,12 +769,11 @@ def run_research_process(
                     research_id,
                     {"status": status, "error": message},
                 )
-            except Exception as socket_error:
-                logger.error(f"Failed to emit error via socket: {str(socket_error)}")
+            except Exception:
+                logger.exception("Failed to emit error via socket")
 
-        except Exception as inner_e:
-            logger.error(f"Error in error handler: {str(inner_e)}")
-            logger.error(traceback.format_exc())
+        except Exception:
+            logger.exception("Error in error handler")
 
         # Clean up resources
         cleanup_research_resources(research_id, active_research, termination_flags)
@@ -817,8 +802,8 @@ def cleanup_research_resources(research_id, active_research, termination_flags):
         if result and result[0]:
             current_status = result[0]
         conn.close()
-    except Exception as e:
-        logger.error("Error retrieving research status during cleanup: %s", e)
+    except Exception:
+        logger.exception("Error retrieving research status during cleanup")
 
     # Remove from active research
     if research_id in active_research:
@@ -860,8 +845,8 @@ def cleanup_research_resources(research_id, active_research, termination_flags):
 
             emit_to_subscribers("research_progress", research_id, final_message)
 
-    except Exception as e:
-        logger.error("Error sending final cleanup message: %s", e)
+    except Exception:
+        logger.error("Error sending final cleanup message")
 
 
 def handle_termination(research_id, active_research, termination_flags):

local_deep_research/web/services/settings_manager.py

@@ -1,9 +1,9 @@
 import importlib.resources as pkg_resources
 import json
-import logging
 import os
 from typing import Any, Dict, Optional, Union
 
+from loguru import logger
 from sqlalchemy import func
 from sqlalchemy.exc import SQLAlchemyError
 from sqlalchemy.orm import Session
@@ -19,9 +19,6 @@ from ..models.settings import (
     SearchSetting,
 )
 
-# Setup logging
-logger = logging.getLogger(__name__)
-
 
 def check_env_setting(key: str) -> str | None:
     """

local_deep_research/web/services/settings_service.py

@@ -1,12 +1,10 @@
-import logging
 from typing import Any, Dict, Optional, Union
 
+from loguru import logger
+
 from ..database.models import Setting
 from .settings_manager import SettingsManager
 
-# Initialize logger
-logger = logging.getLogger(__name__)
-
 
 def get_settings_manager(db_session=None):
     """
@@ -110,8 +108,8 @@ def bulk_update_settings(
     if commit and success and manager.db_session:
         try:
             manager.db_session.commit()
-        except Exception as e:
-            logger.error(f"Error committing bulk settings update: {e}")
+        except Exception:
+            logger.exception("Error committing bulk settings update")
             manager.db_session.rollback()
             success = False
 

local_deep_research/web/static/css/styles.css

@@ -1383,6 +1383,18 @@ textarea:focus, input[type="text"]:focus {
     border-color: rgba(255, 193, 7, 0.2);
 }
 
+/* Styling for search engine selection log entries */
+.console-log-entry[data-log-type="info"][data-engine-selected="true"] {
+    background-color: rgba(64, 191, 255, 0.05);
+    border-left: 2px solid var(--accent-tertiary);
+    padding-left: calc(0.5rem - 2px);
+    font-weight: 500;
+}
+
+.console-log-entry[data-log-type="info"][data-engine-selected="true"] .log-message {
+    color: var(--accent-tertiary);
+}
+
 /* Update existing error message styling if needed */
 .error-message {
     display: none;