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

local_deep_research/web/routes/settings_routes.py

@@ -41,7 +41,9 @@ def get_db_session() -> Session:
         return current_app.extensions["sqlalchemy"].session()
 
 
-def validate_setting(setting: Setting, value: Any) -> Tuple[bool, Optional[str]]:
+def validate_setting(
+    setting: Setting, value: Any
+) -> Tuple[bool, Optional[str]]:
     """
     Validate a setting value based on its type and constraints.
 
@@ -101,7 +103,9 @@ def save_all_settings():
         form_data = request.get_json()
         if not form_data:
             return (
-                jsonify({"status": "error", "message": "No settings data provided"}),
+                jsonify(
+                    {"status": "error", "message": "No settings data provided"}
+                ),
                 400,
             )
 
@@ -163,7 +167,8 @@ def save_all_settings():
 
             # Special handling for corrupted or empty values
             if value == "[object Object]" or (
-                isinstance(value, str) and value.strip() in ["{}", "[]", "{", "["]
+                isinstance(value, str)
+                and value.strip() in ["{}", "[]", "{", "["]
             ):
                 if key.startswith("report."):
                     value = {}
@@ -199,18 +204,22 @@ def save_all_settings():
 
             if current_setting:
                 # Validate the setting
-                is_valid, error_message = validate_setting(current_setting, value)
+                is_valid, error_message = validate_setting(
+                    current_setting, value
+                )
 
                 if is_valid:
                     # Save the setting
-                    success = set_setting(key, value, db_session=db_session)
+                    success = set_setting(key, value)
                     if success:
                         updated_settings.append(key)
 
                     # Track settings by type for exporting
                     if current_setting.type not in settings_by_type:
                         settings_by_type[current_setting.type] = []
-                    settings_by_type[current_setting.type].append(current_setting)
+                    settings_by_type[current_setting.type].append(
+                        current_setting
+                    )
                 else:
                     # Add to validation errors
                     validation_errors.append(
@@ -235,7 +244,9 @@ def save_all_settings():
                 # Determine better UI element based on value type
                 if isinstance(value, bool):
                     new_setting["ui_element"] = "checkbox"
-                elif isinstance(value, (int, float)) and not isinstance(value, bool):
+                elif isinstance(value, (int, float)) and not isinstance(
+                    value, bool
+                ):
                     new_setting["ui_element"] = "number"
                 elif isinstance(value, (dict, list)):
                     new_setting["ui_element"] = "textarea"
@@ -339,10 +350,15 @@ def save_all_settings():
             }
         )
 
-    except Exception as e:
+    except Exception:
         logger.exception("Error saving settings")
         return (
-            jsonify({"status": "error", "message": f"Error saving settings: {str(e)}"}),
+            jsonify(
+                {
+                    "status": "error",
+                    "message": "An internal error occurred while saving settings.",
+                }
+            ),
             500,
         )
 
@@ -367,7 +383,9 @@ def reset_to_defaults():
         # Fallback to predefined settings if file import fails
         logger.info("Falling back to predefined settings")
         # Import here to avoid circular imports
-        from ..database.migrations import setup_predefined_settings as setup_settings
+        from ..database.migrations import (
+            setup_predefined_settings as setup_settings,
+        )
 
         setup_settings(db_session)
 
@@ -400,7 +418,9 @@ def api_get_all_settings():
             filtered_settings = {}
             # Need to get all setting details to check category
             db_settings = db_session.query(Setting).all()
-            category_keys = [s.key for s in db_settings if s.category == category]
+            category_keys = [
+                s.key for s in db_settings if s.category == category
+            ]
 
             # Filter settings by keys
             for key, value in settings.items():
@@ -424,12 +444,14 @@ def api_get_setting(key):
         # get_settings_manager(db_session)
 
         # Get setting
-        value = get_setting(key, db_session=db_session)
+        value = get_setting(key)
         if value is None:
             return jsonify({"error": f"Setting not found: {key}"}), 404
 
         # Get additional metadata from database.
-        db_setting = db_session.query(Setting).filter(Setting.key == key).first()
+        db_setting = (
+            db_session.query(Setting).filter(Setting.key == key).first()
+        )
 
         if db_setting:
             # Return full setting details
@@ -477,7 +499,9 @@ def api_update_setting(key):
         # get_settings_manager(db_session)
 
         # Check if setting exists
-        db_setting = db_session.query(Setting).filter(Setting.key == key).first()
+        db_setting = (
+            db_session.query(Setting).filter(Setting.key == key).first()
+        )
 
         if db_setting:
             # Check if setting is editable
@@ -487,9 +511,13 @@ def api_update_setting(key):
             # Update setting
             success = set_setting(key, value)
             if success:
-                return jsonify({"message": f"Setting {key} updated successfully"})
+                return jsonify(
+                    {"message": f"Setting {key} updated successfully"}
+                )
             else:
-                return jsonify({"error": f"Failed to update setting {key}"}), 500
+                return jsonify(
+                    {"error": f"Failed to update setting {key}"}
+                ), 500
         else:
             # Create new setting with default metadata
             setting_dict = {
@@ -535,7 +563,9 @@ def api_update_setting(key):
                     201,
                 )
             else:
-                return jsonify({"error": f"Failed to create setting {key}"}), 500
+                return jsonify(
+                    {"error": f"Failed to create setting {key}"}
+                ), 500
     except Exception as e:
         logger.exception(f"Error updating setting {key}")
         return jsonify({"error": str(e)}), 500
@@ -549,7 +579,9 @@ def api_delete_setting(key):
         settings_manager = get_settings_manager(db_session)
 
         # Check if setting exists
-        db_setting = db_session.query(Setting).filter(Setting.key == key).first()
+        db_setting = (
+            db_session.query(Setting).filter(Setting.key == key).first()
+        )
         if not db_setting:
             return jsonify({"error": f"Setting not found: {key}"}), 404
 
@@ -568,8 +600,7 @@ def api_delete_setting(key):
 def api_import_settings():
     """Import settings from defaults file"""
     try:
-        db_session = get_db_session()
-        settings_manager = get_settings_manager(db_session)
+        settings_manager = get_settings_manager(get_db_session())
 
         success = settings_manager.load_from_defaults_file()
 
@@ -673,7 +704,9 @@ def api_get_available_models():
                     else "http://localhost:11434"
                 )
 
-                ollama_response = requests.get(f"{base_url}/api/tags", timeout=5)
+                ollama_response = requests.get(
+                    f"{base_url}/api/tags", timeout=5
+                )
 
                 logger.debug(
                     f"Ollama API response: Status {ollama_response.status_code}"
@@ -681,7 +714,9 @@ def api_get_available_models():
 
                 # Try to parse the response even if status code is not 200 to help with debugging
                 response_text = ollama_response.text
-                logger.debug(f"Ollama API raw response: {response_text[:500]}...")
+                logger.debug(
+                    f"Ollama API raw response: {response_text[:500]}..."
+                )
 
                 if ollama_response.status_code == 200:
                     try:
@@ -700,7 +735,9 @@ def api_get_available_models():
                                 name = model.get("name", "")
                                 if name:
                                     # Improved display name formatting
-                                    display_name = re.sub(r"[:/]", " ", name).strip()
+                                    display_name = re.sub(
+                                        r"[:/]", " ", name
+                                    ).strip()
                                     display_name = " ".join(
                                         word.capitalize()
                                         for word in display_name.split()
@@ -725,7 +762,9 @@ def api_get_available_models():
                                 name = model.get("name", "")
                                 if name:
                                     # Improved display name formatting
-                                    display_name = re.sub(r"[:/]", " ", name).strip()
+                                    display_name = re.sub(
+                                        r"[:/]", " ", name
+                                    ).strip()
                                     display_name = " ".join(
                                         word.capitalize()
                                         for word in display_name.split()
@@ -748,7 +787,9 @@ def api_get_available_models():
                         logger.error(
                             f"Failed to parse Ollama API response as JSON: {json_err}"
                         )
-                        raise Exception(f"Ollama API returned invalid JSON: {json_err}")
+                        raise Exception(
+                            f"Ollama API returned invalid JSON: {json_err}"
+                        )
                 else:
                     logger.warning(
                         f"Ollama API returned non-200 status code: {ollama_response.status_code}"
@@ -760,7 +801,9 @@ def api_get_available_models():
             except requests.exceptions.RequestException as e:
                 logger.warning(f"Could not connect to Ollama API: {str(e)}")
                 # Fallback to default models if Ollama is not running
-                logger.info("Using fallback Ollama models due to connection error")
+                logger.info(
+                    "Using fallback Ollama models due to connection error"
+                )
                 ollama_models = [
                     {
                         "value": "llama3",
@@ -793,8 +836,16 @@ def api_get_available_models():
             # Use fallback models
             logger.info("Using fallback Ollama models due to error")
             providers["ollama_models"] = [
-                {"value": "llama3", "label": "Llama 3 (Ollama)", "provider": "OLLAMA"},
-                {"value": "mistral", "label": "Mistral (Ollama)", "provider": "OLLAMA"},
+                {
+                    "value": "llama3",
+                    "label": "Llama 3 (Ollama)",
+                    "provider": "OLLAMA",
+                },
+                {
+                    "value": "mistral",
+                    "label": "Mistral (Ollama)",
+                    "provider": "OLLAMA",
+                },
                 {
                     "value": "gemma:latest",
                     "label": "Gemma (Ollama)",
@@ -833,7 +884,8 @@ def api_get_available_models():
                             # Create a clean display name
                             display_name = model_id.replace("-", " ").strip()
                             display_name = " ".join(
-                                word.capitalize() for word in display_name.split()
+                                word.capitalize()
+                                for word in display_name.split()
                             )
 
                             openai_endpoint_models.append(
@@ -883,7 +935,9 @@ def api_get_available_models():
                                 model_id = model.get("id", "")
                                 if model_id:
                                     # Create a clean display name
-                                    display_name = model_id.replace("-", " ").strip()
+                                    display_name = model_id.replace(
+                                        "-", " "
+                                    ).strip()
                                     display_name = " ".join(
                                         word.capitalize()
                                         for word in display_name.split()
@@ -902,7 +956,9 @@ def api_get_available_models():
         except Exception as e:
             logger.error(f"Error getting OpenAI Endpoint models: {str(e)}")
             # Use fallback models (empty in this case)
-            logger.info("Using fallback (empty) OpenAI Endpoint models due to error")
+            logger.info(
+                "Using fallback (empty) OpenAI Endpoint models due to error"
+            )
 
         # Always set the openai_endpoint_models in providers
         providers["openai_endpoint_models"] = openai_endpoint_models
@@ -913,7 +969,9 @@ def api_get_available_models():
         # Get OpenAI models using the OpenAI package
         openai_models = []
         try:
-            logger.info("Attempting to connect to OpenAI API using OpenAI package")
+            logger.info(
+                "Attempting to connect to OpenAI API using OpenAI package"
+            )
 
             # Get the API key from settings
             api_key = get_db_setting("llm.openai.api_key", "")
@@ -938,7 +996,8 @@ def api_get_available_models():
                             # Create a clean display name
                             display_name = model_id.replace("-", " ").strip()
                             display_name = " ".join(
-                                word.capitalize() for word in display_name.split()
+                                word.capitalize()
+                                for word in display_name.split()
                             )
 
                             openai_models.append(
@@ -960,7 +1019,9 @@ def api_get_available_models():
                     logger.info("No OpenAI models found due to API error")
 
             else:
-                logger.info("OpenAI API key not configured, no models available")
+                logger.info(
+                    "OpenAI API key not configured, no models available"
+                )
 
         except ImportError:
             logger.warning("OpenAI package not installed. No models available.")
@@ -1001,7 +1062,8 @@ def api_get_available_models():
                             # Create a clean display name
                             display_name = model_id.replace("-", " ").strip()
                             display_name = " ".join(
-                                word.capitalize() for word in display_name.split()
+                                word.capitalize()
+                                for word in display_name.split()
                             )
 
                             anthropic_models.append(
@@ -1035,7 +1097,9 @@ def api_get_available_models():
         logger.info(f"Final Anthropic models count: {len(anthropic_models)}")
 
         # Return all options
-        return jsonify({"provider_options": provider_options, "providers": providers})
+        return jsonify(
+            {"provider_options": provider_options, "providers": providers}
+        )
 
     except Exception as e:
         logger.exception("Error getting available models")
@@ -1068,7 +1132,10 @@ def api_get_available_search_engines():
 
             description = (
                 db_session.query(Setting)
-                .filter(Setting.key == f"search.engine.web.{engine_name}.description")
+                .filter(
+                    Setting.key
+                    == f"search.engine.web.{engine_name}.description"
+                )
                 .first()
             )
             if description is None:
@@ -1078,7 +1145,9 @@ def api_get_available_search_engines():
 
             strengths = (
                 db_session.query(Setting)
-                .filter(Setting.key == f"search.engine.web.{engine_name}.strengths")
+                .filter(
+                    Setting.key == f"search.engine.web.{engine_name}.strengths"
+                )
                 .first()
             )
             if strengths is None:
@@ -1088,7 +1157,9 @@ def api_get_available_search_engines():
                 strengths = strengths.value
 
             engines_dict[engine_name] = dict(
-                display_name=display_name, strengths=strengths, description=description
+                display_name=display_name,
+                strengths=strengths,
+                description=description,
             )
 
         # Format as options for dropdown
@@ -1100,7 +1171,9 @@ def api_get_available_search_engines():
             for key in engines_dict.keys()
         ]
 
-        return jsonify({"engines": engines_dict, "engine_options": engine_options})
+        return jsonify(
+            {"engines": engines_dict, "engine_options": engine_options}
+        )
 
     except Exception as e:
         logger.exception("Error getting available search engines")
@@ -1141,13 +1214,19 @@ def open_file_location():
         flash("No file path provided", "error")
         return redirect(url_for("settings.settings_page"))
 
-    # Get the directory containing the file
-    dir_path = os.path.dirname(os.path.abspath(file_path))
-
-    # Open the directory in the file explorer
     try:
+        # Validate the file path
+        file_path = os.path.abspath(file_path)
+        if not os.path.exists(file_path):
+            flash("File path does not exist", "error")
+            return redirect(url_for("settings.settings_page"))
+
+        # Get the directory containing the file
+        dir_path = os.path.dirname(file_path)
+
+        # Open the directory in the file explorer
         if platform.system() == "Windows":
-            subprocess.Popen(f'explorer "{dir_path}"')
+            subprocess.Popen(["explorer", dir_path])
         elif platform.system() == "Darwin":  # macOS
             subprocess.Popen(["open", dir_path])
         else:  # Linux
@@ -1215,12 +1294,16 @@ def fix_corrupted_settings():
             "app.knowledge_accumulation_context_limit",
             "app.output_dir",
         ]:
-            setting = db_session.query(Setting).filter(Setting.key == key).first()
+            setting = (
+                db_session.query(Setting).filter(Setting.key == key).first()
+            )
             if setting:
                 # Move to proper category if not already there
                 proper_key = key.replace("app.", "report.")
                 existing_proper = (
-                    db_session.query(Setting).filter(Setting.key == proper_key).first()
+                    db_session.query(Setting)
+                    .filter(Setting.key == proper_key)
+                    .first()
                 )
 
                 if not existing_proper:
@@ -1261,12 +1344,16 @@ def fix_corrupted_settings():
             "app.search_language",
             "app.snippets_only",
         ]:
-            setting = db_session.query(Setting).filter(Setting.key == key).first()
+            setting = (
+                db_session.query(Setting).filter(Setting.key == key).first()
+            )
             if setting:
                 # Move to proper category if not already there
                 proper_key = key.replace("app.", "search.")
                 existing_proper = (
-                    db_session.query(Setting).filter(Setting.key == proper_key).first()
+                    db_session.query(Setting)
+                    .filter(Setting.key == proper_key)
+                    .first()
                 )
 
                 if not existing_proper:
@@ -1306,12 +1393,16 @@ def fix_corrupted_settings():
             "app.lmstudio_url",
             "app.llamacpp_model_path",
         ]:
-            setting = db_session.query(Setting).filter(Setting.key == key).first()
+            setting = (
+                db_session.query(Setting).filter(Setting.key == key).first()
+            )
             if setting:
                 # Move to proper category if not already there
                 proper_key = key.replace("app.", "llm.")
                 existing_proper = (
-                    db_session.query(Setting).filter(Setting.key == proper_key).first()
+                    db_session.query(Setting)
+                    .filter(Setting.key == proper_key)
+                    .first()
                 )
 
                 if not existing_proper:
@@ -1407,7 +1498,10 @@ def fix_corrupted_settings():
                 elif setting.key == "report.detailed_citations":
                     default_value = True
             elif setting.key.startswith("app."):
-                if setting.key == "app.theme" or setting.key == "app.default_theme":
+                if (
+                    setting.key == "app.theme"
+                    or setting.key == "app.default_theme"
+                ):
                     default_value = "dark"
                 elif setting.key == "app.enable_notifications":
                     default_value = True
@@ -1476,16 +1570,23 @@ def check_ollama_status():
     """Check if Ollama is running and available"""
     try:
         # Get Ollama URL from settings
-        raw_base_url = get_db_setting("llm.ollama.url", "http://localhost:11434")
+        raw_base_url = get_db_setting(
+            "llm.ollama.url", "http://localhost:11434"
+        )
         base_url = (
-            normalize_url(raw_base_url) if raw_base_url else "http://localhost:11434"
+            normalize_url(raw_base_url)
+            if raw_base_url
+            else "http://localhost:11434"
         )
 
         response = requests.get(f"{base_url}/api/version", timeout=2.0)
 
         if response.status_code == 200:
             return jsonify(
-                {"running": True, "version": response.json().get("version", "unknown")}
+                {
+                    "running": True,
+                    "version": response.json().get("version", "unknown"),
+                }
             )
         else:
             return jsonify(