local-deep-research 0.1.26__py3-none-any.whl → 0.2.0__py3-none-any.whl

local_deep_research/web/services/settings_service.py

@@ -0,0 +1,187 @@
+import logging
+from pathlib import Path
+from typing import Any, Dict, Optional, Union
+
+from ..database.models import Setting, SettingType
+from .settings_manager import SettingsManager
+
+# Initialize logger
+logger = logging.getLogger(__name__)
+
+
+def get_settings_manager(db_session=None):
+    """
+    Get or create the settings manager instance.
+
+    Args:
+        db_session: Optional database session to use
+
+    Returns:
+        SettingsManager: The settings manager instance
+    """
+    return SettingsManager.get_instance(db_session)
+
+
+def get_setting(key: str, default: Any = None, db_session=None) -> Any:
+    """
+    Get a setting value by key
+
+    Args:
+        key: Setting key
+        default: Default value if setting not found
+        db_session: Optional database session to use
+
+    Returns:
+        Any: The setting value
+    """
+    manager = get_settings_manager(db_session)
+    return manager.get_setting(key, default)
+
+
+def set_setting(key: str, value: Any, commit: bool = True, db_session=None) -> bool:
+    """
+    Set a setting value
+
+    Args:
+        key: Setting key
+        value: Setting value
+        commit: Whether to commit the change
+        db_session: Optional database session
+
+    Returns:
+        bool: True if successful
+    """
+    manager = get_settings_manager(db_session)
+    return manager.set_setting(key, value, commit)
+
+
+def get_all_settings(
+    setting_type: Optional[SettingType] = None, db_session=None
+) -> Dict[str, Any]:
+    """
+    Get all settings, optionally filtered by type
+
+    Args:
+        setting_type: Optional filter by type
+        db_session: Optional database session
+
+    Returns:
+        Dict[str, Any]: Dictionary of settings
+    """
+    manager = get_settings_manager(db_session)
+    return manager.get_all_settings(setting_type)
+
+
+def get_all_settings_as_dict(db_session=None) -> Dict[str, Dict[str, Any]]:
+    """
+    Get all settings as a structured dictionary
+
+    Args:
+        db_session: Optional database session
+
+    Returns:
+        Dict[str, Dict[str, Any]]: Dictionary of settings grouped by type
+    """
+    # Get settings manager
+    manager = get_settings_manager(db_session)
+
+    # Get all settings
+    all_settings = {}
+
+    for setting_type in SettingType:
+        type_key = setting_type.value.lower()
+        type_settings = manager.get_all_settings(setting_type)
+        if type_settings:
+            all_settings[type_key] = type_settings
+
+    return all_settings
+
+
+def create_or_update_setting(
+    setting: Union[Dict[str, Any], Setting], commit: bool = True, db_session=None
+) -> Optional[Setting]:
+    """
+    Create or update a setting
+
+    Args:
+        setting: Setting dictionary or object
+        commit: Whether to commit the change
+        db_session: Optional database session
+
+    Returns:
+        Optional[Setting]: The setting object if successful
+    """
+    manager = get_settings_manager(db_session)
+    return manager.create_or_update_setting(setting, commit)
+
+
+def bulk_update_settings(
+    settings_dict: Dict[str, Any], commit: bool = True, db_session=None
+) -> bool:
+    """
+    Update multiple settings from a dictionary
+
+    Args:
+        settings_dict: Dictionary of setting keys and values
+        commit: Whether to commit the changes
+        db_session: Optional database session
+
+    Returns:
+        bool: True if all updates were successful
+    """
+    manager = get_settings_manager(db_session)
+    success = True
+
+    for key, value in settings_dict.items():
+        if not manager.set_setting(key, value, commit=False):
+            success = False
+
+    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}")
+            manager.db_session.rollback()
+            success = False
+
+    return success
+
+
+def import_settings_from_file(
+    main_settings_file: Union[str, Path],
+    search_engines_file: Union[str, Path],
+    collections_file: Union[str, Path],
+    db_session=None,
+) -> bool:
+    """
+    Import settings from default configuration files
+
+    Args:
+        main_settings_file: Path to the main settings file
+        search_engines_file: Path to the search engines file
+        collections_file: Path to the collections file
+        db_session: Optional database session
+
+    Returns:
+        bool: True if import was successful
+    """
+    manager = get_settings_manager(db_session)
+    return manager.import_default_settings(
+        main_settings_file, search_engines_file, collections_file
+    )
+
+
+def validate_setting(setting: Setting, value: Any) -> tuple[bool, Optional[str]]:
+    """
+    Validate a setting value based on its type and constraints
+
+    Args:
+        setting: The Setting object to validate against
+        value: The value to validate
+
+    Returns:
+        tuple[bool, Optional[str]]: (is_valid, error_message)
+    """
+    from ..routes.settings_routes import validate_setting as routes_validate_setting
+
+    return routes_validate_setting(setting, value)

local_deep_research/web/services/socket_service.py

@@ -0,0 +1,210 @@
+import logging
+
+# Initialize logger
+logger = logging.getLogger(__name__)
+
+# Make this a module variable to be set by the Flask app on initialization
+socketio = None
+# Socket subscription tracking
+socket_subscriptions = {}
+
+
+def set_socketio(socket_instance):
+    """Set the Socket.IO instance for the service."""
+    global socketio
+    socketio = socket_instance
+    logger.info("Socket.IO instance attached to socket service")
+
+
+def emit_socket_event(event, data, room=None):
+    """
+    Emit a socket event to clients.
+
+    Args:
+        event: The event name to emit
+        data: The data to send with the event
+        room: Optional room ID to send to specific client
+
+    Returns:
+        bool: True if emission was successful, False otherwise
+    """
+    global socketio
+
+    if not socketio:
+        logger.error("Socket.IO not initialized when attempting to emit event")
+        return False
+
+    try:
+        # If room is specified, only emit to that room
+        if room:
+            socketio.emit(event, data, room=room)
+        else:
+            # Otherwise broadcast to all
+            socketio.emit(event, data)
+        return True
+    except Exception as e:
+        logger.error(f"Error emitting socket event {event}: {str(e)}")
+        return False
+
+
+def emit_to_subscribers(event_base, research_id, data):
+    """
+    Emit an event to all subscribers of a specific research.
+
+    Args:
+        event_base: Base event name (will be formatted with research_id)
+        research_id: ID of the research
+        data: The data to send with the event
+
+    Returns:
+        bool: True if emission was successful, False otherwise
+    """
+    global socketio
+
+    if not socketio:
+        logger.error("Socket.IO not initialized when attempting to emit to subscribers")
+        return False
+
+    try:
+        # Emit to the general channel for the research
+        full_event = f"{event_base}_{research_id}"
+        socketio.emit(full_event, data)
+
+        # Emit to specific subscribers
+        if research_id in socket_subscriptions and socket_subscriptions[research_id]:
+            for sid in socket_subscriptions[research_id]:
+                try:
+                    socketio.emit(full_event, data, room=sid)
+                except Exception as sub_err:
+                    logger.error(f"Error emitting to subscriber {sid}: {str(sub_err)}")
+
+        return True
+    except Exception as e:
+        logger.error(
+            f"Error emitting to subscribers for research {research_id}: {str(e)}"
+        )
+        return False
+
+
+# Socket event handlers moved from app.py
+def handle_connect(request):
+    """Handle client connection"""
+    logger.info(f"Client connected: {request.sid}")
+
+
+def handle_disconnect(request):
+    """Handle client disconnection"""
+    try:
+        logger.info(f"Client disconnected: {request.sid}")
+        # Clean up subscriptions for this client
+        global socket_subscriptions
+        for research_id, subscribers in list(socket_subscriptions.items()):
+            if request.sid in subscribers:
+                subscribers.remove(request.sid)
+            if not subscribers:
+                socket_subscriptions.pop(research_id, None)
+                logger.info(f"Removed empty subscription for research {research_id}")
+    except Exception as e:
+        logger.error(f"Error handling disconnect: {e}")
+
+
+def handle_subscribe(data, request, active_research=None):
+    """Handle client subscription to research updates"""
+    from datetime import datetime
+
+    from ..models.database import get_db_connection
+
+    research_id = data.get("research_id")
+    if research_id:
+        # First check if this research is still active
+        conn = get_db_connection()
+        cursor = conn.cursor()
+        cursor.execute(
+            "SELECT status FROM research_history WHERE id = ?", (research_id,)
+        )
+        result = cursor.fetchone()
+        conn.close()
+
+        # Only allow subscription to valid research
+        if result:
+            status = result[0]
+
+            # Initialize subscription set if needed
+            global socket_subscriptions
+            if research_id not in socket_subscriptions:
+                socket_subscriptions[research_id] = set()
+
+            # Add this client to the subscribers
+            socket_subscriptions[research_id].add(request.sid)
+            logger.info(f"Client {request.sid} subscribed to research {research_id}")
+
+            # Send current status immediately if available
+            if active_research and research_id in active_research:
+                progress = active_research[research_id]["progress"]
+                latest_log = (
+                    active_research[research_id]["log"][-1]
+                    if active_research[research_id]["log"]
+                    else None
+                )
+
+                if latest_log:
+                    emit_socket_event(
+                        f"research_progress_{research_id}",
+                        {
+                            "progress": progress,
+                            "message": latest_log.get("message", "Processing..."),
+                            "status": "in_progress",
+                            "log_entry": latest_log,
+                        },
+                        room=request.sid,
+                    )
+            elif status in ["completed", "failed", "suspended"]:
+                # Send final status for completed research
+                emit_socket_event(
+                    f"research_progress_{research_id}",
+                    {
+                        "progress": 100 if status == "completed" else 0,
+                        "message": (
+                            "Research completed successfully"
+                            if status == "completed"
+                            else (
+                                "Research failed"
+                                if status == "failed"
+                                else "Research was suspended"
+                            )
+                        ),
+                        "status": status,
+                        "log_entry": {
+                            "time": datetime.utcnow().isoformat(),
+                            "message": f"Research is {status}",
+                            "progress": 100 if status == "completed" else 0,
+                            "metadata": {
+                                "phase": (
+                                    "complete" if status == "completed" else "error"
+                                )
+                            },
+                        },
+                    },
+                    room=request.sid,
+                )
+        else:
+            # Research not found
+            emit_socket_event(
+                "error",
+                {"message": f"Research ID {research_id} not found"},
+                room=request.sid,
+            )
+
+
+def handle_socket_error(e):
+    """Handle Socket.IO errors"""
+    logger.error(f"Socket.IO error: {str(e)}")
+    # Don't propagate exceptions to avoid crashing the server
+    return False
+
+
+def handle_default_error(e):
+    """Handle unhandled Socket.IO errors"""
+    logger.error(f"Unhandled Socket.IO error: {str(e)}")
+    # Don't propagate exceptions to avoid crashing the server
+    return False

local_deep_research/web/static/css/custom_dropdown.css

@@ -0,0 +1,277 @@
+/**
+ * Custom Dropdown Component
+ * Styling for reusable dropdown component
+ */
+
+.custom-dropdown {
+    position: relative;
+    width: 100%;
+    z-index: 5; /* Base z-index for the dropdown container */
+}
+
+.custom-dropdown-input {
+    width: 100%;
+    padding: 10px;
+    border-radius: 6px;
+    border: 1px solid var(--border-color, #343452);
+    background-color: var(--bg-secondary, #1e1e2d);
+    color: var(--text-primary, #f5f5f5);
+    font-size: 0.9rem;
+    cursor: pointer;
+    position: relative;
+    z-index: 6; /* Higher than container for stacking context */
+}
+
+.custom-dropdown-input:focus {
+    outline: none;
+    border-color: var(--accent-primary, #6e4ff6);
+    box-shadow: 0 0 0 3px rgba(110, 79, 246, 0.15);
+}
+
+.custom-dropdown-list {
+    position: absolute;
+    width: 100%;
+    max-height: 250px;
+    overflow-y: auto;
+    z-index: 9999; /* High z-index for default state */
+    background-color: var(--bg-tertiary, #2a2a3a);
+    border: 1px solid var(--border-color, #343452);
+    border-radius: 6px;
+    margin-top: 5px;
+    box-shadow: 0 5px 15px rgba(0, 0, 0, 0.4);
+    display: none;
+}
+
+/* Styles for when the dropdown is active */
+.custom-dropdown-list.dropdown-active {
+    z-index: 99999 !important; /* Extremely high z-index */
+    margin-top: 0 !important; /* Reset margin as top/left are calculated */
+    max-height: 40vh !important; /* Cap at 40% of viewport height */
+    overflow-y: auto !important;
+    box-shadow: 0 6px 20px rgba(0, 0, 0, 0.5) !important; /* Stronger shadow */
+    visibility: visible !important;
+    opacity: 1 !important;
+    clip: auto !important;
+    clip-path: none !important;
+    transform: none !important;
+    pointer-events: auto !important;
+
+    /* Ensure contrast with background */
+    background-color: var(--bg-tertiary, #2a2a3a) !important;
+    color: var(--text-primary, #f5f5f5) !important;
+    border: 2px solid var(--accent-primary, #6e4ff6) !important; /* More visible border */
+
+    /* Width, top, left are set by JS */
+}
+
+/* Explicitly override any ancestor overflow properties - more targeted to avoid side effects */
+body * {
+    overflow: visible !important;
+}
+
+/* Immediately revert the blanket override for essential elements */
+html, body {
+    overflow: auto !important;
+}
+.custom-dropdown-list,
+.custom-dropdown-list.dropdown-fixed {
+    overflow-y: auto !important;
+}
+
+/* Add a special class to the body when a dropdown is active */
+body.dropdown-active {
+    /* Apply a higher z-index to ensure body doesn't create a stacking context that traps our dropdown */
+    z-index: auto !important;
+    position: relative !important;
+}
+
+.custom-dropdown-item {
+    padding: 10px 15px;
+    cursor: pointer;
+    color: var(--text-primary, #f5f5f5);
+    transition: background-color 0.2s;
+}
+
+.custom-dropdown-item:hover,
+.custom-dropdown-item.active {
+    background-color: rgba(110, 79, 246, 0.1);
+}
+
+.custom-dropdown-item .highlight {
+    background-color: rgba(110, 79, 246, 0.3);
+    border-radius: 2px;
+    padding: 0 2px;
+}
+
+.custom-dropdown-no-results {
+    padding: 10px 15px;
+    color: var(--text-secondary, #c0c0cc);
+    font-style: italic;
+}
+
+.custom-dropdown-footer {
+    padding: 10px 15px;
+    border-top: 1px solid var(--border-color, #343452);
+    color: var(--accent-tertiary, #40bfff);
+    font-size: 0.85rem;
+    background-color: rgba(64, 191, 255, 0.08);
+}
+
+/* Custom dropdown with refresh button */
+.custom-dropdown-with-refresh {
+    display: flex;
+    align-items: center; /* Center items vertically */
+    gap: 8px;
+    width: 100%;
+}
+
+.custom-dropdown-with-refresh .custom-dropdown {
+    flex: 1;
+}
+
+.custom-dropdown-refresh-btn {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    width: 38px;
+    height: 38px;
+    background-color: var(--bg-tertiary, #2a2a3a);
+    border: 1px solid var(--border-color, #343452);
+    border-radius: 6px;
+    color: var(--text-secondary, #c0c0cc);
+    cursor: pointer;
+    transition: all 0.2s;
+    flex-shrink: 0; /* Prevent button from shrinking */
+}
+
+.custom-dropdown-refresh-btn:hover {
+    background-color: var(--bg-secondary, #1e1e2d);
+    color: var(--accent-primary, #6e4ff6);
+    border-color: var(--accent-primary, #6e4ff6);
+}
+
+.custom-dropdown-refresh-btn.loading {
+    pointer-events: none;
+}
+
+/* Remove the inner dropdown loader - we'll use JS to only show it in the button */
+.dropdown-loading-indicator {
+    display: none;
+}
+
+/* Only show loader inside button when needed */
+.custom-dropdown-refresh-btn.loading i {
+    display: none;
+}
+
+.custom-dropdown-refresh-btn.loading:before {
+    content: "";
+    width: 16px;
+    height: 16px;
+    border: 2px solid rgba(255, 255, 255, 0.1);
+    border-radius: 50%;
+    border-top-color: var(--accent-primary, #6e4ff6);
+    animation: spin 0.8s linear infinite;
+    display: block;
+}
+
+@keyframes spin {
+    0% { transform: rotate(0deg); }
+    100% { transform: rotate(360deg); }
+}
+
+/* Advanced Options Panel Styles */
+.advanced-options-toggle {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    margin-bottom: 1.5rem;
+    padding: 0.8rem 1rem;
+    background-color: var(--bg-tertiary, rgba(40, 45, 60, 0.7));
+    border-radius: 6px;
+    cursor: pointer;
+    transition: background-color 0.2s;
+    border: 1px solid var(--border-color, rgba(255, 255, 255, 0.1));
+}
+
+.advanced-options-toggle:hover {
+    background-color: rgba(50, 55, 70, 0.8);
+}
+
+.advanced-options-toggle.open {
+    margin-bottom: 0.5rem;
+}
+
+.toggle-text {
+    font-weight: 600;
+    color: var(--text-primary, #e1e2e4);
+}
+
+.advanced-options-panel {
+    position: relative;
+    z-index: 1; /* Lower than dropdowns */
+    transition: max-height 0.3s ease-in-out, opacity 0.3s ease-in-out, margin 0.3s ease-in-out;
+    max-height: 0;
+    overflow: hidden; /* Keep hidden when collapsed */
+    opacity: 0;
+    margin-top: 0;
+    margin-bottom: 0;
+    display: block !important; /* Always display but use max-height/opacity for animation */
+}
+
+.advanced-options-panel.expanded {
+    max-height: 1000px; /* Large enough to fit all content */
+    opacity: 1;
+    margin-bottom: 1.5rem;
+    margin-top: 0.5rem;
+    overflow: visible; /* Allow dropdowns to overflow when expanded */
+}
+
+/* Make dropdowns in advanced panel appear more quickly when expanded */
+.advanced-options-panel.expanded .form-group {
+    animation: fadeIn 0.3s ease forwards;
+}
+
+/* Stagger animation for form groups */
+.advanced-options-panel.expanded .form-row:nth-child(1) .form-group {
+    animation-delay: 0.05s;
+}
+
+.advanced-options-panel.expanded .form-row:nth-child(2) .form-group {
+    animation-delay: 0.1s;
+}
+
+.advanced-options-panel.expanded .form-row:nth-child(3) .form-group {
+    animation-delay: 0.15s;
+}
+
+@keyframes fadeIn {
+    from { opacity: 0; /* transform: translateY(-5px); REMOVED */ }
+    to { opacity: 1; /* transform: translateY(0); REMOVED */ }
+}
+
+.advanced-options-toggle i {
+    transition: transform 0.3s ease;
+}
+
+.advanced-options-toggle.open i {
+    transform: rotate(180deg);
+}
+
+/* Loading state for dropdowns */
+.custom-dropdown.loading input,
+.form-group.loading input {
+    background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='24' height='24' viewBox='0 0 24 24'%3E%3Cpath fill='%236e4ff6' d='M12 2a10 10 0 1 0 10 10A10 10 0 0 0 12 2zm0 18a8 8 0 1 1 8-8 8 8 0 0 1-8 8z' opacity='0.3'/%3E%3Cpath fill='%236e4ff6' d='M20 12h2A10 10 0 0 0 12 2v2a8 8 0 0 1 8 8z'%3E%3CanimateTransform attributeName='transform' dur='1s' from='0 12 12' repeatCount='indefinite' to='360 12 12' type='rotate'/%3E%3C/path%3E%3C/svg%3E");
+    background-position: right 10px center;
+    background-repeat: no-repeat;
+    background-size: 16px 16px;
+}
+
+/* Add special handling for dropdowns in the advanced panel */
+/* .advanced-options-panel .custom-dropdown {
+    z-index: 100;
+} */
+
+.advanced-options-panel .custom-dropdown-list {
+    z-index: 10000; /* Even higher z-index for dropdowns in the advanced panel */
+}