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

local_deep_research/web/routes/settings_routes.py

@@ -1,5 +1,4 @@
 import json
-import logging
 import os
 import platform
 import subprocess
@@ -16,6 +15,7 @@ from flask import (
     url_for,
 )
 from flask_wtf.csrf import generate_csrf
+from loguru import logger
 from sqlalchemy.orm import Session
 
 from ...utilities.db_utils import get_db_setting
@@ -29,9 +29,6 @@ from ..services.settings_service import (
 )
 from ..utils.templates import render_template_with_defaults
 
-# Initialize logger
-logger = logging.getLogger(__name__)
-
 # Create a Blueprint for settings
 settings_bp = Blueprint("settings", __name__, url_prefix="/research/settings")
 
@@ -343,7 +340,7 @@ def save_all_settings():
         )
 
     except Exception as e:
-        logger.error(f"Error saving settings: {e}")
+        logger.exception("Error saving settings")
         return (
             jsonify({"status": "error", "message": f"Error saving settings: {str(e)}"}),
             500,
@@ -364,8 +361,8 @@ def reset_to_defaults():
 
         logger.info("Successfully imported settings from default files")
 
-    except Exception as e:
-        logger.error(f"Error importing default settings: {e}")
+    except Exception:
+        logger.exception("Error importing default settings")
 
         # Fallback to predefined settings if file import fails
         logger.info("Falling back to predefined settings")
@@ -414,7 +411,7 @@ def api_get_all_settings():
 
         return jsonify({"status": "success", "settings": settings})
     except Exception as e:
-        logger.error(f"Error getting settings: {e}")
+        logger.exception("Error getting settings")
         return jsonify({"error": str(e)}), 500
 
 
@@ -457,7 +454,7 @@ def api_get_setting(key):
 
         return jsonify({"settings": setting_data})
     except Exception as e:
-        logger.error(f"Error getting setting {key}: {e}")
+        logger.exception(f"Error getting setting {key}")
         return jsonify({"error": str(e)}), 500
 
 
@@ -540,7 +537,7 @@ def api_update_setting(key):
             else:
                 return jsonify({"error": f"Failed to create setting {key}"}), 500
     except Exception as e:
-        logger.error(f"Error updating setting {key}: {e}")
+        logger.exception(f"Error updating setting {key}")
         return jsonify({"error": str(e)}), 500
 
 
@@ -563,7 +560,7 @@ def api_delete_setting(key):
         else:
             return jsonify({"error": f"Failed to delete setting {key}"}), 500
     except Exception as e:
-        logger.error(f"Error deleting setting {key}: {e}")
+        logger.exception(f"Error deleting setting {key}")
         return jsonify({"error": str(e)}), 500
 
 
@@ -581,7 +578,7 @@ def api_import_settings():
         else:
             return jsonify({"error": "Failed to import settings"}), 500
     except Exception as e:
-        logger.error(f"Error importing settings: {e}")
+        logger.exception("Error importing settings")
         return jsonify({"error": str(e)}), 500
 
 
@@ -597,7 +594,7 @@ def api_get_categories():
 
         return jsonify({"categories": category_list})
     except Exception as e:
-        logger.error(f"Error getting categories: {e}")
+        logger.exception("Error getting categories")
         return jsonify({"error": str(e)}), 500
 
 
@@ -609,7 +606,7 @@ def api_get_types():
         types = [t.value for t in SettingType]
         return jsonify({"types": types})
     except Exception as e:
-        logger.error(f"Error getting types: {e}")
+        logger.exception("Error getting types")
         return jsonify({"error": str(e)}), 500
 
 
@@ -633,7 +630,7 @@ def api_get_ui_elements():
 
         return jsonify({"ui_elements": ui_elements})
     except Exception as e:
-        logger.error(f"Error getting UI elements: {e}")
+        logger.exception("Error getting UI elements")
         return jsonify({"error": str(e)}), 500
 
 
@@ -662,11 +659,10 @@ def api_get_available_models():
             import re
 
             import requests
-            from flask import current_app
 
             # Try to query the Ollama API directly
             try:
-                current_app.logger.info("Attempting to connect to Ollama API")
+                logger.info("Attempting to connect to Ollama API")
 
                 raw_base_url = get_db_setting(
                     "llm.ollama.url", "http://localhost:11434"
@@ -679,26 +675,24 @@ def api_get_available_models():
 
                 ollama_response = requests.get(f"{base_url}/api/tags", timeout=5)
 
-                current_app.logger.debug(
+                logger.debug(
                     f"Ollama API response: Status {ollama_response.status_code}"
                 )
 
                 # Try to parse the response even if status code is not 200 to help with debugging
                 response_text = ollama_response.text
-                current_app.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:
                         ollama_data = ollama_response.json()
-                        current_app.logger.debug(
+                        logger.debug(
                             f"Ollama API JSON data: {json.dumps(ollama_data)[:500]}..."
                         )
 
                         if "models" in ollama_data:
                             # Format for newer Ollama API
-                            current_app.logger.info(
+                            logger.info(
                                 f"Found {len(ollama_data.get('models', []))} models in newer Ollama API format"
                             )
                             for model in ollama_data.get("models", []):
@@ -719,12 +713,12 @@ def api_get_available_models():
                                             "provider": "OLLAMA",  # Add provider field for consistency
                                         }
                                     )
-                                    current_app.logger.debug(
+                                    logger.debug(
                                         f"Added Ollama model: {name} -> {display_name}"
                                     )
                         else:
                             # Format for older Ollama API
-                            current_app.logger.info(
+                            logger.info(
                                 f"Found {len(ollama_data)} models in older Ollama API format"
                             )
                             for model in ollama_data:
@@ -743,7 +737,7 @@ def api_get_available_models():
                                             "provider": "OLLAMA",  # Add provider field for consistency
                                         }
                                     )
-                                    current_app.logger.debug(
+                                    logger.debug(
                                         f"Added Ollama model: {name} -> {display_name}"
                                     )
 
@@ -751,12 +745,12 @@ def api_get_available_models():
                         ollama_models.sort(key=lambda x: x["label"])
 
                     except json.JSONDecodeError as json_err:
-                        current_app.logger.error(
+                        logger.error(
                             f"Failed to parse Ollama API response as JSON: {json_err}"
                         )
                         raise Exception(f"Ollama API returned invalid JSON: {json_err}")
                 else:
-                    current_app.logger.warning(
+                    logger.warning(
                         f"Ollama API returned non-200 status code: {ollama_response.status_code}"
                     )
                     raise Exception(
@@ -764,11 +758,9 @@ def api_get_available_models():
                     )
 
             except requests.exceptions.RequestException as e:
-                current_app.logger.warning(f"Could not connect to Ollama API: {str(e)}")
+                logger.warning(f"Could not connect to Ollama API: {str(e)}")
                 # Fallback to default models if Ollama is not running
-                current_app.logger.info(
-                    "Using fallback Ollama models due to connection error"
-                )
+                logger.info("Using fallback Ollama models due to connection error")
                 ollama_models = [
                     {
                         "value": "llama3",
@@ -789,19 +781,17 @@ def api_get_available_models():
 
             # Always set the ollama_models in providers, whether we got real or fallback models
             providers["ollama_models"] = ollama_models
-            current_app.logger.info(f"Final Ollama models count: {len(ollama_models)}")
+            logger.info(f"Final Ollama models count: {len(ollama_models)}")
 
             # Log some model names for debugging
             if ollama_models:
                 model_names = [m["value"] for m in ollama_models[:5]]
-                current_app.logger.info(
-                    f"Sample Ollama models: {', '.join(model_names)}"
-                )
+                logger.info(f"Sample Ollama models: {', '.join(model_names)}")
 
-        except Exception as e:
-            current_app.logger.error(f"Error getting Ollama models: {str(e)}")
+        except Exception:
+            logger.exception("Error getting Ollama models")
             # Use fallback models
-            current_app.logger.info("Using fallback Ollama models due to error")
+            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"},
@@ -812,37 +802,243 @@ def api_get_available_models():
                 },
             ]
 
-        # Add OpenAI models
-        providers["openai_models"] = [
-            {"value": "gpt-4o", "label": "GPT-4o (OpenAI)"},
-            {"value": "gpt-4", "label": "GPT-4 (OpenAI)"},
-            {"value": "gpt-3.5-turbo", "label": "GPT-3.5 Turbo (OpenAI)"},
-        ]
+        # Try to get Custom OpenAI Endpoint models using the OpenAI package
+        openai_endpoint_models = []
+        try:
+            logger.info(
+                "Attempting to connect to Custom OpenAI Endpoint using OpenAI package"
+            )
 
-        # Add Anthropic models
-        providers["anthropic_models"] = [
-            {
-                "value": "claude-3-5-sonnet-latest",
-                "label": "Claude 3.5 Sonnet (Anthropic)",
-            },
-            {"value": "claude-3-opus-20240229", "label": "Claude 3 Opus (Anthropic)"},
-            {
-                "value": "claude-3-sonnet-20240229",
-                "label": "Claude 3 Sonnet (Anthropic)",
-            },
-            {"value": "claude-3-haiku-20240307", "label": "Claude 3 Haiku (Anthropic)"},
-        ]
+            # Get the endpoint URL and API key from settings
+            endpoint_url = get_db_setting("llm.openai_endpoint.url", "")
+            api_key = get_db_setting("llm.openai_endpoint.api_key", "")
+
+            if endpoint_url and api_key:
+                # Import OpenAI package here to avoid dependency issues if not installed
+                import openai
+                from openai import OpenAI
+
+                # Create OpenAI client with custom endpoint
+                client = OpenAI(api_key=api_key, base_url=endpoint_url)
+
+                try:
+                    # Fetch models using the client
+                    logger.debug("Fetching models from OpenAI API")
+                    models_response = client.models.list()
+
+                    # Process models from the response
+                    for model in models_response.data:
+                        model_id = model.id
+                        if model_id:
+                            # Create a clean display name
+                            display_name = model_id.replace("-", " ").strip()
+                            display_name = " ".join(
+                                word.capitalize() for word in display_name.split()
+                            )
+
+                            openai_endpoint_models.append(
+                                {
+                                    "value": model_id,
+                                    "label": f"{display_name} (Custom)",
+                                    "provider": "OPENAI_ENDPOINT",
+                                }
+                            )
+                            logger.debug(
+                                f"Added Custom OpenAI Endpoint model: {model_id} -> {display_name}"
+                            )
+
+                    # Sort models alphabetically
+                    openai_endpoint_models.sort(key=lambda x: x["label"])
+
+                except openai.APIError as api_err:
+                    logger.error(f"OpenAI API error: {str(api_err)}")
+                    raise Exception(f"OpenAI API error: {str(api_err)}")
+
+            else:
+                logger.info("OpenAI Endpoint URL or API key not configured")
+                # Don't raise an exception, just continue with empty models list
+
+        except ImportError:
+            logger.warning(
+                "OpenAI package not installed. Using manual API request fallback."
+            )
+            # Fallback to manual API request if OpenAI package is not installed
+            try:
+                if endpoint_url and api_key:
+                    # Ensure the URL ends with a slash
+                    if not endpoint_url.endswith("/"):
+                        endpoint_url += "/"
+
+                    # Make the request to the endpoint's models API
+                    headers = {"Authorization": f"Bearer {api_key}"}
+                    endpoint_response = requests.get(
+                        f"{endpoint_url}models", headers=headers, timeout=5
+                    )
+
+                    if endpoint_response.status_code == 200:
+                        endpoint_data = endpoint_response.json()
+                        # Process models from the response
+                        if "data" in endpoint_data:
+                            for model in endpoint_data.get("data", []):
+                                model_id = model.get("id", "")
+                                if model_id:
+                                    # Create a clean display name
+                                    display_name = model_id.replace("-", " ").strip()
+                                    display_name = " ".join(
+                                        word.capitalize()
+                                        for word in display_name.split()
+                                    )
+
+                                    openai_endpoint_models.append(
+                                        {
+                                            "value": model_id,
+                                            "label": f"{display_name} (Custom)",
+                                            "provider": "OPENAI_ENDPOINT",
+                                        }
+                                    )
+            except Exception as e:
+                logger.error(f"Fallback API request failed: {str(e)}")
+
+        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")
+
+        # Always set the openai_endpoint_models in providers
+        providers["openai_endpoint_models"] = openai_endpoint_models
+        logger.info(
+            f"Final OpenAI Endpoint models count: {len(openai_endpoint_models)}"
+        )
+
+        # Get OpenAI models using the OpenAI package
+        openai_models = []
+        try:
+            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", "")
+
+            if api_key:
+                # Import OpenAI package here to avoid dependency issues if not installed
+                import openai
+                from openai import OpenAI
+
+                # Create OpenAI client
+                client = OpenAI(api_key=api_key)
+
+                try:
+                    # Fetch models using the client
+                    logger.debug("Fetching models from OpenAI API")
+                    models_response = client.models.list()
+
+                    # Process models from the response
+                    for model in models_response.data:
+                        model_id = model.id
+                        if model_id:
+                            # Create a clean display name
+                            display_name = model_id.replace("-", " ").strip()
+                            display_name = " ".join(
+                                word.capitalize() for word in display_name.split()
+                            )
+
+                            openai_models.append(
+                                {
+                                    "value": model_id,
+                                    "label": f"{display_name} (OpenAI)",
+                                    "provider": "OPENAI",
+                                }
+                            )
+                            logger.debug(
+                                f"Added OpenAI model: {model_id} -> {display_name}"
+                            )
+
+                    # Sort models alphabetically
+                    openai_models.sort(key=lambda x: x["label"])
+
+                except openai.APIError as api_err:
+                    logger.error(f"OpenAI API error: {str(api_err)}")
+                    logger.info("No OpenAI models found due to API error")
+
+            else:
+                logger.info("OpenAI API key not configured, no models available")
+
+        except ImportError:
+            logger.warning("OpenAI package not installed. No models available.")
+        except Exception as e:
+            logger.error(f"Error getting OpenAI models: {str(e)}")
+            logger.info("No OpenAI models available due to error")
+
+        # Always set the openai_models in providers (will be empty array if no models found)
+        providers["openai_models"] = openai_models
+        logger.info(f"Final OpenAI models count: {len(openai_models)}")
+
+        # Try to get Anthropic models using the Anthropic package
+        anthropic_models = []
+        try:
+            logger.info(
+                "Attempting to connect to Anthropic API using Anthropic package"
+            )
+
+            # Get the API key from settings
+            api_key = get_db_setting("llm.anthropic.api_key", "")
+
+            if api_key:
+                # Import Anthropic package here to avoid dependency issues if not installed
+                from anthropic import Anthropic
+
+                # Create Anthropic client
+                client = Anthropic(api_key=api_key)
+
+                try:
+                    # Fetch models using the client
+                    logger.debug("Fetching models from Anthropic API")
+                    models_response = client.models.list()
+
+                    # Process models from the response
+                    for model in models_response.data:
+                        model_id = model.id
+                        if model_id:
+                            # Create a clean display name
+                            display_name = model_id.replace("-", " ").strip()
+                            display_name = " ".join(
+                                word.capitalize() for word in display_name.split()
+                            )
+
+                            anthropic_models.append(
+                                {
+                                    "value": model_id,
+                                    "label": f"{display_name} (Anthropic)",
+                                    "provider": "ANTHROPIC",
+                                }
+                            )
+                            logger.debug(
+                                f"Added Anthropic model: {model_id} -> {display_name}"
+                            )
+
+                    # Sort models alphabetically
+                    anthropic_models.sort(key=lambda x: x["label"])
+
+                except Exception as api_err:
+                    logger.error(f"Anthropic API error: {str(api_err)}")
+            else:
+                logger.info("Anthropic API key not configured")
+
+        except ImportError:
+            logger.warning(
+                "Anthropic package not installed. No models will be available."
+            )
+        except Exception as e:
+            logger.error(f"Error getting Anthropic models: {str(e)}")
+
+        # Set anthropic_models in providers (could be empty if API call failed)
+        providers["anthropic_models"] = anthropic_models
+        logger.info(f"Final Anthropic models count: {len(anthropic_models)}")
 
         # Return all options
         return jsonify({"provider_options": provider_options, "providers": providers})
 
     except Exception as e:
-        import traceback
-
-        error_trace = traceback.format_exc()
-        current_app.logger.error(
-            f"Error getting available models: {str(e)}\n{error_trace}"
-        )
+        logger.exception("Error getting available models")
         return jsonify({"status": "error", "message": str(e)}), 500
 
 
@@ -907,7 +1103,7 @@ def api_get_available_search_engines():
         return jsonify({"engines": engines_dict, "engine_options": engine_options})
 
     except Exception as e:
-        logger.error(f"Error getting available search engines: {e}")
+        logger.exception("Error getting available search engines")
         return jsonify({"error": str(e)}), 500
 
 
@@ -959,6 +1155,7 @@ def open_file_location():
 
         flash(f"Opening folder: {dir_path}", "success")
     except Exception as e:
+        logger.exception("Error opening folder")
         flash(f"Error opening folder: {str(e)}", "error")
 
     # Redirect back to the settings page
@@ -1261,7 +1458,7 @@ def fix_corrupted_settings():
         )
 
     except Exception as e:
-        logger.error(f"Error fixing corrupted settings: {e}")
+        logger.exception("Error fixing corrupted settings")
         db_session.rollback()
         return (
             jsonify(
@@ -1298,5 +1495,5 @@ def check_ollama_status():
                 }
             )
     except requests.exceptions.RequestException as e:
-        logger.info(f"Ollama check failed: {str(e)}")
+        logger.exception("Ollama check failed")
         return jsonify({"running": False, "error": str(e)})