local-deep-research 0.4.0__tar.gz → 0.4.2__tar.gz

{local_deep_research-0.4.0 → local_deep_research-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: local-deep-research
-Version: 0.4.0
+Version: 0.4.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.4.0 → local_deep_research-0.4.2}/pyproject.toml

@@ -65,7 +65,7 @@ dependencies = [
     "plotly>=6.0.1",
     "kaleido==0.1.0",
 ]
-version = "0.4.0"
+version = "0.4.2"
 
 [project.license]
 file = "LICENSE"

{local_deep_research-0.4.0 → local_deep_research-0.4.2}/src/local_deep_research/__init__.py

@@ -9,6 +9,7 @@ from .__version__ import __version__
 from .config.llm_config import get_llm
 from .config.search_config import get_search
 from .report_generator import get_report_generator
+from .web.app import main
 
 
 def get_advanced_search_system(strategy_name: str = "iterdrag"):

local_deep_research-0.4.2/src/local_deep_research/__version__.py

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

{local_deep_research-0.4.0 → local_deep_research-0.4.2}/src/local_deep_research/config/llm_config.py

@@ -79,7 +79,7 @@ def get_llm(model_name=None, temperature=None, provider=None, openai_endpoint_ur
     if get_db_setting("llm.supports_max_tokens", True):
         # Use 80% of context window to leave room for prompts
         max_tokens = min(
-            get_db_setting("llm.max_tokens", 30000), int(context_window_size * 0.8)
+            int(get_db_setting("llm.max_tokens", 30000)), int(context_window_size * 0.8)
         )
         common_params["max_tokens"] = max_tokens
 

{local_deep_research-0.4.0 → local_deep_research-0.4.2}/src/local_deep_research/defaults/default_settings.json

@@ -342,7 +342,7 @@
         "options": null,
         "step": 0.05,
         "type": "LLM",
-        "ui_element": "slider",
+        "ui_element": "range",
         "value": 0.7,
         "visible": true
     },

{local_deep_research-0.4.0 → local_deep_research-0.4.2}/src/local_deep_research/web/app.py

@@ -94,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-0.4.0 → local_deep_research-0.4.2}/src/local_deep_research/web/services/research_service.py

@@ -1,8 +1,8 @@
 import hashlib
 import json
-import os
 import threading
 from datetime import datetime
+from pathlib import Path
 
 from loguru import logger
 
@@ -15,7 +15,7 @@ from ..models.database import add_log_to_db, calculate_duration, get_db_connecti
 from .socket_service import emit_to_subscribers
 
 # Output directory for research results
-OUTPUT_DIR = "research_outputs"
+OUTPUT_DIR = Path("research_outputs")
 
 
 def start_research_process(
@@ -68,7 +68,7 @@ def start_research_process(
     return thread
 
 
-def _generate_report_path(query: str) -> str:
+def _generate_report_path(query: str) -> Path:
     """
     Generates a path for a new report file based on the query.
 
@@ -82,9 +82,8 @@ def _generate_report_path(query: str) -> str:
     # Generate a unique filename that does not contain
     # non-alphanumeric characters.
     query_hash = hashlib.md5(query.encode("utf-8")).hexdigest()[:10]
-    return os.path.join(
-        OUTPUT_DIR,
-        f"research_report_{query_hash}_{datetime.now().isoformat()}.md",
+    return OUTPUT_DIR / (
+        f"research_report_{query_hash}_{int(datetime.now().timestamp())}.md"
     )
 
 
@@ -139,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):
@@ -532,9 +531,7 @@ def run_research_process(
                     )
 
                     # Save as markdown file
-                    if not os.path.exists(OUTPUT_DIR):
-                        os.makedirs(OUTPUT_DIR)
-
+                    OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
                     report_path = _generate_report_path(query)
 
                     # Send progress update for writing to file
@@ -545,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)
@@ -583,7 +580,7 @@ def run_research_process(
                             "completed",
                             completed_at,
                             duration_seconds,
-                            report_path,
+                            str(report_path),
                             json.dumps(metadata),
                             research_id,
                         ),
@@ -598,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
@@ -635,12 +632,10 @@ def run_research_process(
             )
 
             # Save as markdown file
-            if not os.path.exists(OUTPUT_DIR):
-                os.makedirs(OUTPUT_DIR)
-
+            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
@@ -668,7 +663,7 @@ def run_research_process(
                     "completed",
                     completed_at,
                     duration_seconds,
-                    report_path,
+                    str(report_path),
                     json.dumps(metadata),
                     research_id,
                 ),
@@ -679,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

{local_deep_research-0.4.0 → local_deep_research-0.4.2}/src/local_deep_research/web/services/settings_manager.py

@@ -1,7 +1,7 @@
 import importlib.resources as pkg_resources
 import json
 import os
-from typing import Any, Dict, Optional, Union
+from typing import Any, Dict, Optional, Type, Union
 
 from loguru import logger
 from sqlalchemy import func
@@ -45,6 +45,15 @@ class SettingsManager:
     Provides methods to get and set settings, with the ability to override settings in memory.
     """
 
+    _UI_ELEMENT_TO_SETTING_TYPE = {
+        "text": str,
+        "password": str,
+        "select": str,
+        "number": float,
+        "range": float,
+        "checkbox": bool,
+    }
+
     def __init__(self, db_session: Session):
         """
         Initialize the settings manager
@@ -59,6 +68,57 @@ class SettingsManager:
         default_settings = pkg_resources.read_text(defaults, "default_settings.json")
         self.default_settings = json.loads(default_settings)
 
+    def __get_typed_setting_value(
+        self, setting: Type[Setting], default: Any = None, check_env: bool = True
+    ) -> str | float | bool | None:
+        """
+        Extracts the value for a particular setting, ensuring that it has the
+        correct type.
+
+        Args:
+            setting: The setting to get the value for.
+            default: Default value to return if the value of the setting is
+                invalid.
+            check_env: If true, it will check the environment variable for
+                this setting before reading from the DB.
+
+        Returns:
+            The value of the setting.
+
+        """
+        setting_type = self._UI_ELEMENT_TO_SETTING_TYPE.get(setting.ui_element, None)
+        if setting_type is None:
+            logger.warning(
+                "Got unknown type {} for setting {}, returning default value.",
+                setting.ui_element,
+                setting.key,
+            )
+            return default
+
+        # Check environment variable first, then database.
+        if check_env:
+            env_value = check_env_setting(setting.key)
+            if env_value is not None:
+                try:
+                    return setting_type(env_value)
+                except ValueError:
+                    logger.warning(
+                        "Setting {} has invalid value {}. Falling back to DB.",
+                        setting.key,
+                        env_value,
+                    )
+
+        # If environment variable does not exist, read from the database.
+        try:
+            return setting_type(setting.value)
+        except ValueError:
+            logger.warning(
+                "Setting {} has invalid value {}. Returning default.",
+                setting.key,
+                setting.value,
+            )
+            return default
+
     def get_setting(self, key: str, default: Any = None, check_env: bool = True) -> Any:
         """
         Get a setting value
@@ -72,11 +132,6 @@ class SettingsManager:
         Returns:
             Setting value or default if not found
         """
-        if check_env:
-            env_value = check_env_setting(key)
-            if env_value is not None:
-                return env_value
-
         # If using database first approach and session available, check database
         if self.db_first and self.db_session:
             try:
@@ -87,22 +142,17 @@ class SettingsManager:
                 )
                 if len(settings) == 1:
                     # This is a bottom-level key.
-                    value = settings[0].value
-                    return value
+                    return self.__get_typed_setting_value(
+                        settings[0], default, check_env
+                    )
                 elif len(settings) > 1:
                     # This is a higher-level key.
                     settings_map = {}
                     for setting in settings:
                         output_key = setting.key.removeprefix(f"{key}.")
-                        value = setting.value
-
-                        if check_env:
-                            # Handle possible replacements from environment variables.
-                            env_value = check_env_setting(setting.key)
-                            if env_value is not None:
-                                value = env_value
-
-                        settings_map[output_key] = value
+                        settings_map[output_key] = self.__get_typed_setting_value(
+                            setting, default, check_env
+                        )
                     return settings_map
             except SQLAlchemyError as e:
                 logger.error(f"Error retrieving setting {key} from database: {e}")
@@ -149,6 +199,7 @@ class SettingsManager:
                         value=value,
                         type=setting_type,
                         name=key.split(".")[-1].replace("_", " ").title(),
+                        ui_element="text",
                         description=f"Setting for {key}",
                     )
                     self.db_session.add(new_setting)

{local_deep_research-0.4.0 → local_deep_research-0.4.2}/src/local_deep_research/web_search_engines/engines/search_engine_searxng.py

@@ -98,7 +98,7 @@ class SearXNGSearchEngine(BaseSearchEngine):
         self.language = language
         try:
             self.safe_search = SafeSearchSetting[safe_search]
-        except ValueError:
+        except KeyError:
             logger.error(
                 "'{}' is not a valid safe search setting. Disabling safe search",
                 safe_search,

{local_deep_research-0.4.0 → local_deep_research-0.4.2}/src/local_deep_research/web_search_engines/search_engine_factory.py

@@ -49,8 +49,6 @@ def create_search_engine(
 
         # If not found, check the database for the API key
         if not api_key:
-            from ..utilities.db_utils import get_db_setting
-
             api_key = get_db_setting(f"search.engine.web.{engine_name}.api_key")
 
         # Still try to get from engine config if not found

local_deep_research-0.4.2/tests/test_settings_manager.py

@@ -0,0 +1,208 @@
+import os
+from typing import Any
+
+import pytest
+from sqlalchemy.exc import SQLAlchemyError
+
+from src.local_deep_research.web.services.settings_manager import (
+    Setting,
+    SettingsManager,
+    SettingType,
+    check_env_setting,
+)
+
+
+def test_check_env_setting_exists(monkeypatch):
+    monkeypatch.setenv("LDR_APP_VERSION", "1.0.0")
+    assert check_env_setting("app.version") == "1.0.0"
+
+
+def test_check_env_setting_not_exists():
+    # Ensure the environment variable is not set
+    if "LDR_APP_VERSION" in os.environ:
+        del os.environ["LDR_APP_VERSION"]
+    assert check_env_setting("app.version") is None
+
+
+@pytest.mark.parametrize(
+    "ui_element, setting_value, expected",
+    [
+        ("text", "hello", "hello"),
+        ("select", "option_a", "option_a"),
+        ("password", "secret", "secret"),
+        ("number", "3.14", 3.14),
+        ("range", "3.14", 3.14),
+        ("checkbox", "true", True),
+    ],
+)
+def test_get_setting_from_db(
+    mocker, ui_element: str, setting_value: str, expected: Any
+):
+    """
+    Tests that we can successfully read settings from the DB.
+
+    Args:
+        mocker: The fixture to use for mocking.
+        ui_element: The value of the `ui_element` parameter, which controls the return type.
+        setting_value: The value to use for the setting in the DB.
+        expected: The expected typed value of the setting.
+    """
+    # Arrange: Set up the mock database session and a sample setting
+    mock_db_session = mocker.MagicMock()
+    mock_setting = Setting(
+        key="test.setting", value=setting_value, ui_element=ui_element
+    )
+    mock_db_session.query.return_value.filter.return_value.all.return_value = [
+        mock_setting
+    ]
+
+    # Act: Call the get_setting method with the test key
+    settings_manager = SettingsManager(db_session=mock_db_session)
+    result = settings_manager.get_setting("test.setting")
+
+    # Assert: Verify that the result matches the expected value
+    assert result == expected, f"Expected {expected}, but got {result}"
+
+
+@pytest.mark.parametrize(
+    "ui_element, env_value, expected",
+    [
+        ("text", "hello", "hello"),
+        ("select", "option_a", "option_a"),
+        ("password", "secret", "secret"),
+        ("number", "3.14", 3.14),
+        ("range", "3.14", 3.14),
+        ("checkbox", "true", True),
+    ],
+)
+def test_get_setting_from_env(
+    mocker, monkeypatch, ui_element: str, env_value: str, expected: Any
+):
+    """
+    Tests that we can successfully override DB settings with environment
+    variables.
+
+    Args:
+        mocker: The fixture to use for mocking.
+        ui_element: The value of the `ui_element` parameter, which controls the return type.
+        env_value: The value to use for the setting in the environment variable.
+        expected: The expected typed value of the setting.
+    """
+    # Arrange: Set up the mock database session and ensure an environment variable is set
+    mock_db_session = mocker.MagicMock()
+    monkeypatch.setenv("LDR_TEST_SETTING", env_value)
+    # Ensure DB query returns an old version to verify environment variable is prioritized
+    mock_setting = Setting(key="test.setting", value="db_value", ui_element=ui_element)
+    mock_db_session.query.return_value.filter.return_value.all.return_value = [
+        mock_setting
+    ]
+
+    # Act: Call the get_setting method with the test key
+    settings_manager = SettingsManager(db_session=mock_db_session)
+    result = settings_manager.get_setting("test.setting")
+
+    # Assert: Verify that the result matches the expected value
+    assert result == expected, f"Expected {expected}, but got {result}"
+
+
+def test_get_setting_default(mocker):
+    mock_db_session = mocker.MagicMock()
+    # Ensure DB query returns nothing
+    mock_db_session.query.return_value.filter.return_value.all.return_value = []
+
+    settings_manager = SettingsManager(db_session=mock_db_session)
+    assert (
+        settings_manager.get_setting("non_existent_setting", default="default_value")
+        == "default_value"
+    )
+
+
+def test_get_setting_invalid_type(mocker):
+    """
+    Tests that when a setting's value cannot be converted to the type
+    specified by the `ui_element`, it will always return the default value.
+
+    Args:
+        mocker: The fixture to use for mocking.
+
+    """
+    # Arrange: Set up a mock DB session and setting with an invalid type
+    mock_db_session = mocker.MagicMock()
+    mock_setting = Setting(
+        key="test.invalid_type", value="not_a_number", ui_element="number"
+    )
+    mock_db_session.query.return_value.filter.return_value.all.return_value = [
+        mock_setting
+    ]
+
+    # Act: Call get_setting with a default value and an invalid type
+    settings_manager = SettingsManager(db_session=mock_db_session)
+    result = settings_manager.get_setting("test.invalid_type", default=10)
+
+    # Assert: Check that the default value is returned and not the invalid string
+    assert result == 10
+
+
+# The mocker fixture is automatically available
+def test_set_setting_update_existing(mocker):
+    mock_db_session = mocker.MagicMock()
+    mock_setting = Setting(key="app.version", value="1.0.0")
+    mock_db_session.query.return_value.filter.return_value.first.return_value = (
+        mock_setting
+    )
+    mocker.patch(
+        "src.local_deep_research.web.services.settings_manager.func.now"
+    )  # Patching the func.now call
+
+    settings_manager = SettingsManager(db_session=mock_db_session)
+    result = settings_manager.set_setting("app.version", "2.0.0")
+
+    assert result is True
+    assert mock_setting.value == "2.0.0"
+    mock_db_session.commit.assert_called_once()
+    mock_db_session.rollback.assert_not_called()
+
+
+def test_set_setting_create_new(mocker):
+    mock_db_session = mocker.MagicMock()
+    mock_db_session.query.return_value.filter.return_value.first.return_value = None
+    mocker.patch(
+        "src.local_deep_research.web.services.settings_manager.func.now"
+    )  # Patching the func.now call
+
+    settings_manager = SettingsManager(db_session=mock_db_session)
+    result = settings_manager.set_setting("new.setting", "new_value")
+
+    assert result is True
+    mock_db_session.add.assert_called_once()
+    new_setting = mock_db_session.add.call_args[0][0]
+    assert isinstance(new_setting, Setting)
+    assert new_setting.key == "new.setting"
+    assert new_setting.value == "new_value"
+    assert new_setting.type == SettingType.APP  # Assuming 'app' type for this key
+    mock_db_session.commit.assert_called_once()
+    mock_db_session.rollback.assert_not_called()
+
+
+def test_set_setting_db_error(mocker):
+    mock_db_session = mocker.MagicMock()
+    # Set the side_effect to an instance of SQLAlchemyError
+    mock_db_session.query.return_value.filter.return_value.first.side_effect = (
+        SQLAlchemyError("Simulated DB Error")
+    )
+
+    # Mock the logger to check if error is logged
+    mock_logger = mocker.patch(
+        "src.local_deep_research.web.services.settings_manager.logger"
+    )
+
+    settings_manager = SettingsManager(db_session=mock_db_session)
+    result = settings_manager.set_setting("app.version", "2.0.0")
+
+    # Assert that the method returned False
+    assert result is False
+
+    mock_db_session.rollback.assert_called_once()
+    mock_db_session.commit.assert_not_called()
+    mock_logger.error.assert_called_once()
+    # mock_logger.error.assert_called_once_with("Error setting value for app.version: Simulated DB Error")

local_deep_research-0.4.0/src/local_deep_research/__version__.py

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

local_deep_research-0.4.0/src/local_deep_research/app.py

@@ -1,8 +0,0 @@
-"""
-Main entry point for the Local Deep Research application.
-"""
-
-from src.local_deep_research.web.app import main
-
-if __name__ == "__main__":
-    main()

local_deep_research-0.4.0/tests/test_settings_manager.py

@@ -1,98 +0,0 @@
-import os
-import pytest
-import sys
-from pathlib import Path
-from sqlalchemy.exc import SQLAlchemyError
-
-# Add the src directory to the path before importing project modules
-sys.path.append(str(Path(__file__).parent.parent))
-
-from src.local_deep_research.web.services.settings_manager import check_env_setting, SettingsManager, Setting, SettingType
-
-def test_check_env_setting_exists(monkeypatch):
-    monkeypatch.setenv("LDR_APP_VERSION", "1.0.0")
-    assert check_env_setting("app.version") == "1.0.0"
-
-def test_check_env_setting_not_exists():
-    # Ensure the environment variable is not set
-    if "LDR_APP_VERSION" in os.environ:
-        del os.environ["LDR_APP_VERSION"]
-    assert check_env_setting("app.version") is None
-
-def test_get_setting_from_db(mocker):
-    mock_db_session = mocker.MagicMock()
-    mock_setting = Setting(key="app.version", value="1.0.0")
-    # Use mocker.patch.object for patching instances
-    mock_db_session.query.return_value.filter.return_value.all.return_value = [mock_setting]
-
-    settings_manager = SettingsManager(db_session=mock_db_session)
-    assert settings_manager.get_setting("app.version") == "1.0.0"
-
-def test_get_setting_from_env(mocker, monkeypatch):
-    mock_db_session = mocker.MagicMock()
-    monkeypatch.setenv("LDR_APP_VERSION", "2.0.0")
-    # Ensure DB query returns nothing to verify environment variable is prioritized
-    mock_db_session.query.return_value.filter.return_value.all.return_value = []
-
-    settings_manager = SettingsManager(db_session=mock_db_session)
-    assert settings_manager.get_setting("app.version") == "2.0.0"
-
-def test_get_setting_default(mocker):
-    mock_db_session = mocker.MagicMock()
-    # Ensure DB query returns nothing
-    mock_db_session.query.return_value.filter.return_value.all.return_value = []
-
-    settings_manager = SettingsManager(db_session=mock_db_session)
-    assert settings_manager.get_setting("non_existent_setting", default="default_value") == "default_value"
-
-# The mocker fixture is automatically available
-def test_set_setting_update_existing(mocker):
-    mock_db_session = mocker.MagicMock()
-    mock_setting = Setting(key="app.version", value="1.0.0")
-    mock_db_session.query.return_value.filter.return_value.first.return_value = mock_setting
-    mocker.patch("src.local_deep_research.web.services.settings_manager.func.now") # Patching the func.now call
-
-    settings_manager = SettingsManager(db_session=mock_db_session)
-    result = settings_manager.set_setting("app.version", "2.0.0")
-
-    assert result is True
-    assert mock_setting.value == "2.0.0"
-    mock_db_session.commit.assert_called_once()
-    mock_db_session.rollback.assert_not_called()
-
-def test_set_setting_create_new(mocker):
-    mock_db_session = mocker.MagicMock()
-    mock_db_session.query.return_value.filter.return_value.first.return_value = None
-    mocker.patch("src.local_deep_research.web.services.settings_manager.func.now") # Patching the func.now call
-
-    settings_manager = SettingsManager(db_session=mock_db_session)
-    result = settings_manager.set_setting("new.setting", "new_value")
-
-    assert result is True
-    mock_db_session.add.assert_called_once()
-    new_setting = mock_db_session.add.call_args[0][0]
-    assert isinstance(new_setting, Setting)
-    assert new_setting.key == "new.setting"
-    assert new_setting.value == "new_value"
-    assert new_setting.type == SettingType.APP # Assuming 'app' type for this key
-    mock_db_session.commit.assert_called_once()
-    mock_db_session.rollback.assert_not_called()
-
-def test_set_setting_db_error(mocker):
-    mock_db_session = mocker.MagicMock()
-    # Set the side_effect to an instance of SQLAlchemyError
-    mock_db_session.query.return_value.filter.return_value.first.side_effect = SQLAlchemyError("Simulated DB Error")
-
-    # Mock the logger to check if error is logged
-    mock_logger = mocker.patch("src.local_deep_research.web.services.settings_manager.logger")
-
-    settings_manager = SettingsManager(db_session=mock_db_session)
-    result = settings_manager.set_setting("app.version", "2.0.0")
-
-    # Assert that the method returned False
-    assert result is False
-
-    mock_db_session.rollback.assert_called_once()
-    mock_db_session.commit.assert_not_called()
-    mock_logger.error.assert_called_once()
-    # mock_logger.error.assert_called_once_with("Error setting value for app.version: Simulated DB Error")