search-api-webui 0.1.7__py3-none-any.whl → 0.1.9__py3-none-any.whl

search_api_webui/__init__.py

@@ -17,4 +17,3 @@
 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 # DEALINGS IN THE SOFTWARE.
-

search_api_webui/app.py

@@ -19,25 +19,64 @@
 # DEALINGS IN THE SOFTWARE.
 
 import json
-import os
+import logging
+import socket
+import sys
+import threading
+import time
 import webbrowser
 from pathlib import Path
-from flask import Flask, request, jsonify, send_from_directory
+
+from flask import Flask, jsonify, request, send_from_directory
 from flask_cors import CORS
+
 from search_api_webui.providers import load_providers
 
-CURRENT_DIR = Path(__file__).resolve().parent
+try:
+    import webview
+    WEBVIEW_AVAILABLE = True
+except ImportError:
+    WEBVIEW_AVAILABLE = False
+
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+)
+logger = logging.getLogger(__name__)
+
+
+def get_resource_path(relative_path):
+    '''Get absolute path to resource, works for dev and for PyInstaller.'''
+    try:
+        # PyInstaller creates a temp folder and stores path in _MEIPASS
+        base_path = Path(sys._MEIPASS)
+    except Exception:
+        base_path = Path(__file__).resolve().parent
+
+    return base_path / relative_path
 
-STATIC_FOLDER = CURRENT_DIR / 'static'
-if not STATIC_FOLDER.exists():
-    DEV_FRONTEND_DIST = CURRENT_DIR.parent / 'frontend' / 'dist'
-    if DEV_FRONTEND_DIST.exists():
-        STATIC_FOLDER = DEV_FRONTEND_DIST
 
-app = Flask(__name__, static_folder='static')
+CURRENT_DIR = Path(__file__).resolve().parent
+
+# Handle static folder for both dev and packaged app
+if hasattr(sys, '_MEIPASS'):
+    # Running in PyInstaller bundle
+    STATIC_FOLDER = Path(sys._MEIPASS) / 'static'
+else:
+    # Running in development
+    STATIC_FOLDER = CURRENT_DIR / 'static'
+    if not STATIC_FOLDER.exists():
+        DEV_FRONTEND_DIST = CURRENT_DIR.parent / 'frontend' / 'dist'
+        if DEV_FRONTEND_DIST.exists():
+            STATIC_FOLDER = DEV_FRONTEND_DIST
+
+app = Flask(__name__, static_folder=str(STATIC_FOLDER))
 CORS(app)
 
-PROVIDERS_YAML = CURRENT_DIR / 'providers.yaml'
+# Use get_resource_path for providers.yaml
+PROVIDERS_YAML = get_resource_path('providers.yaml')
 USER_CONFIG_DIR = Path.home() / '.search-api-webui'
 USER_CONFIG_JSON = USER_CONFIG_DIR / 'config.json'
 
@@ -47,25 +86,28 @@ if not USER_CONFIG_DIR.exists():
 if PROVIDERS_YAML.exists():
     provider_map = load_providers(str(PROVIDERS_YAML))
 else:
-    print(f"Error: Configuration file not found at {PROVIDERS_YAML}")
+    logger.error(f'Configuration file not found at {PROVIDERS_YAML}')
     provider_map = {}
 
+
 def get_stored_config():
     if not USER_CONFIG_JSON.exists():
         return {}
     try:
-        with open(USER_CONFIG_JSON, 'r', encoding='utf-8') as f:
+        with open(USER_CONFIG_JSON, encoding='utf-8') as f:
             return json.load(f)
     except Exception as e:
-        print(f"Error reading config: {e}")
+        logger.error(f'Error reading config: {e}')
         return {}
 
+
 def save_stored_config(config_dict):
     try:
         with open(USER_CONFIG_JSON, 'w', encoding='utf-8') as f:
             json.dump(config_dict, f, indent=2)
     except Exception as e:
-        print(f"Error saving config: {e}")
+        logger.error(f'Error saving config: {e}')
+
 
 @app.route('/api/providers', methods=['GET'])
 def get_providers_list():
@@ -76,60 +118,77 @@ def get_providers_list():
         config_details = provider_instance.config
 
         user_conf = stored_config.get(name, {})
-        
+
         if isinstance(user_conf, str):
             user_conf = {'api_key': user_conf}
 
         has_key = bool(user_conf.get('api_key'))
 
-        providers_info.append({
-            "name": name,
-            "has_key": has_key,
-            "details": config_details,
-            "user_settings": {
-                "api_url": user_conf.get('api_url', ''),
-                "limit": user_conf.get('limit', '10'),
-                "language": user_conf.get('language', 'en-US')
-            }
-        })
+        providers_info.append(
+            {
+                'name': name,
+                'has_key': has_key,
+                'details': config_details,
+                'user_settings': {
+                    'api_url': user_conf.get('api_url', ''),
+                    'limit': user_conf.get('limit', '10'),
+                    'language': user_conf.get('language'),
+                },
+            },
+        )
     return jsonify(providers_info)
 
+
 @app.route('/api/config', methods=['POST'])
 def update_config():
     data = request.json
     provider_name = data.get('provider')
 
     if not provider_name:
-        return jsonify({"error": "Provider name is required"}), 400
-
-    if 'api_key' not in data:
-        return jsonify({"error": "API Key field is missing"}), 400
+        return jsonify({'error': 'Provider name is required'}), 400
 
     api_key = data.get('api_key')
 
     api_url = data.get('api_url', '').strip()
     limit = data.get('limit', '10')
-    language = data.get('language', 'en-US')
+    language = data.get('language')
 
     all_config = get_stored_config()
 
     if provider_name in all_config and isinstance(all_config[provider_name], str):
         all_config[provider_name] = {'api_key': all_config[provider_name]}
 
-    if not api_key:
-        if provider_name in all_config:
-            all_config[provider_name]['api_key'] = ""
-    else:
-        if provider_name not in all_config:
-            all_config[provider_name] = {}
+    # Initialize provider config if not exists
+    if provider_name not in all_config:
+        all_config[provider_name] = {}
 
-        all_config[provider_name]['api_key'] = api_key
+    # Update advanced settings, skip empty values
+    if api_url:
         all_config[provider_name]['api_url'] = api_url
+    elif 'api_url' in all_config[provider_name]:
+        del all_config[provider_name]['api_url']
+
+    if limit:
         all_config[provider_name]['limit'] = limit
+    elif 'limit' in all_config[provider_name]:
+        del all_config[provider_name]['limit']
+
+    if language:
         all_config[provider_name]['language'] = language
+    elif 'language' in all_config[provider_name]:
+        del all_config[provider_name]['language']
+
+    # Only update api_key if explicitly provided
+    if api_key is not None:
+        all_config[provider_name]['api_key'] = api_key
+
+    # Clean up empty provider config
+    if not all_config[provider_name]:
+        del all_config[provider_name]
 
     save_stored_config(all_config)
-    return jsonify({"status": "success"})
+    return jsonify({'status': 'success'})
+
 
 @app.route('/api/search', methods=['POST'])
 def search_api():
@@ -149,46 +208,104 @@ def search_api():
         api_key = provider_config.get('api_key')
 
     if not api_key:
-        return jsonify({"error": f"API Key for {provider_name} is missing. Please configure it."}), 401
+        return (
+            jsonify({'error': f'API Key for {provider_name} is missing. Please configure it.'}),
+            401,
+        )
 
     provider = provider_map.get(provider_name)
     if not provider:
-        return jsonify({"error": "Provider not found"}), 404
+        return jsonify({'error': 'Provider not found'}), 404
 
     search_kwargs = {
         'api_url': provider_config.get('api_url'),
         'limit': provider_config.get('limit'),
-        'language': provider_config.get('language')
+        'language': provider_config.get('language'),
     }
 
     result = provider.search(query, api_key, **search_kwargs)
     return jsonify(result)
 
+
 # Host React Frontend
 @app.route('/', defaults={'path': ''})
 @app.route('/<path:path>')
 def serve(path):
-    if path != "" and (STATIC_FOLDER / path).exists():
+    if path != '' and (STATIC_FOLDER / path).exists():
         return send_from_directory(str(STATIC_FOLDER), path)
     else:
         return send_from_directory(str(STATIC_FOLDER), 'index.html')
 
-def main():
-    import argparse
-    parser = argparse.ArgumentParser(description="Search API WebUI")
-    parser.add_argument("--port", type=int, default=8889, help="Port to run the server on")
-    parser.add_argument("--host", type=str, default="127.0.0.1", help="Host to run the server on")
-    args = parser.parse_args()
 
-    url = f"http://{args.host}:{args.port}"
-    print(f"Starting Search API WebUI...")
-    print(f"  - Config Storage: {USER_CONFIG_JSON}")
-    print(f"  - Serving on: {url}")
+def wait_for_server_ready(host, port):
+    start_time = time.time()
+    while time.time() - start_time < 10:
+        try:
+            with socket.create_connection((host, port), timeout=1):
+                return True
+        except (OSError, ConnectionRefusedError):
+            time.sleep(0.1)
+    return False
 
-    # Open browser automatically after a short delay to ensure server is ready
-    webbrowser.open(url)
 
-    app.run(host=args.host, port=args.port)
+def main():
+    import argparse
+
+    parser = argparse.ArgumentParser(description='Search API WebUI')
+    parser.add_argument('--port', type=int, default=8889, help='Port to run the server on')
+    parser.add_argument('--host', type=str, default='localhost', help='Host to run the server on')
+    parser.add_argument('-w', '--webview', action='store_true', help='Use webview to open the application')
+    args = parser.parse_args()
 
-if __name__ == "__main__":
+    url = f'http://{args.host}:{args.port}'
+    logger.info('Starting Search API WebUI...')
+    logger.info(f'  - Config Storage: {USER_CONFIG_JSON}')
+    logger.info(f'  - Serving on: {url}')
+    if args.webview:
+        logger.info('  - Mode: webview')
+
+    if args.webview:
+        if not WEBVIEW_AVAILABLE:
+            logger.warning('webview library not installed. Falling back to webbrowser.')
+            # Start server in background thread and wait for it to be ready
+            server_thread = threading.Thread(
+                target=lambda: app.run(
+                    host=args.host, port=args.port, use_reloader=False,
+                ),
+                daemon=True,
+            )
+            server_thread.start()
+            if wait_for_server_ready(args.host, args.port):
+                logger.info(f'Server is ready! Opening browser: {url}')
+                webbrowser.open(url)
+            else:
+                logger.error('Server took too long to start. Browser not opened.')
+        else:
+            # Start server in background thread and wait for it to be ready, then start webview
+            server_thread = threading.Thread(
+                target=lambda: app.run(
+                    host=args.host, port=args.port, use_reloader=False,
+                ),
+                daemon=True,
+            )
+            server_thread.start()
+            if wait_for_server_ready(args.host, args.port):
+                logger.info('Server is ready! Using webview mode...')
+                webview.create_window('Search API WebUI', url, width=1200, height=800)
+                webview.start()
+            else:
+                logger.error('Server took too long to start. Webview not opened.')
+    else:
+        # Start a background thread to check server status and open the browser automatically
+        def open_browser():
+            if wait_for_server_ready(args.host, args.port):
+                logger.info(f'Server is ready! Opening browser: {url}')
+                webbrowser.open(url)
+            else:
+                logger.error('Server took too long to start. Browser not opened.')
+        threading.Thread(target=open_browser, daemon=True).start()
+        app.run(host=args.host, port=args.port)
+
+
+if __name__ == '__main__':
     main()

search_api_webui/providers/__init__.py

@@ -18,26 +18,32 @@
 # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 # DEALINGS IN THE SOFTWARE.
 
+import logging
 import os
+
 import yaml
+
 from .generic import GenericProvider
 from .querit import QueritSdkProvider
 
+logger = logging.getLogger(__name__)
+
+
 def load_providers(file_path='providers.yaml'):
-    """
+    '''
     Parses the YAML configuration file and instantiates the appropriate provider classes.
-    
+
     Args:
         file_path (str): Path to the providers configuration file.
-        
+
     Returns:
         dict: A dictionary mapping provider names to their initialized instances.
-    """
+    '''
     if not os.path.exists(file_path):
-        print(f"Warning: Provider config file not found at {file_path}")
+        logger.warning(f'Provider config file not found at {file_path}')
         return {}
-        
-    with open(file_path, 'r', encoding='utf-8') as f:
+
+    with open(file_path, encoding='utf-8') as f:
         configs = yaml.safe_load(f)
 
     providers = {}

search_api_webui/providers/base.py

@@ -19,16 +19,108 @@
 # DEALINGS IN THE SOFTWARE.
 
 from abc import ABC, abstractmethod
+from urllib.parse import urlparse
+
+
+def extract_domain_from_url(url):
+    '''
+    Extract domain name from URL, removing 'www.' prefix.
+
+    Args:
+        url (str): The URL to extract domain from.
+
+    Returns:
+        str | None: The domain name without 'www.' prefix
+                   (e.g., 'example.com' from 'https://www.example.com/path'),
+                   or None if the URL is invalid or has no netloc.
+
+    Examples:
+        >>> extract_domain_from_url('https://www.example.com/path')
+        'example.com'
+        >>> extract_domain_from_url('http://example.com')
+        'example.com'
+        >>> extract_domain_from_url('invalid-url')
+        None
+    '''
+    if not url or not isinstance(url, str):
+        return None
+    try:
+        parsed = urlparse(url)
+        domain = parsed.netloc if parsed.netloc else None
+        if domain and domain.startswith('www.'):
+            domain = domain[4:]
+        return domain
+    except Exception:
+        return None
+
+
+def parse_server_latency(latency_value):
+    '''
+    Parse server latency value from various formats to milliseconds.
+
+    Args:
+        latency_value: The latency value to parse. Can be:
+            - int/float: A numeric value
+            - str: A string with or without unit suffix (e.g., "123ms", "0.123s", "123")
+
+    Returns:
+        float | None: The latency in milliseconds, or None if parsing fails.
+
+    Rules:
+        1. If numeric (int/float):
+           - If it's an integer, assume milliseconds
+           - If it's a decimal (fractional), assume seconds and convert to ms
+        2. If string:
+           - If ends with 'ms' (case insensitive), parse as milliseconds
+           - If ends with 's' (case insensitive), parse as seconds and convert to ms
+           - If no suffix, convert to number and apply rule 1
+    '''
+    if latency_value is None:
+        return None
+
+    try:
+        # Handle string input
+        if isinstance(latency_value, str):
+            value_str = latency_value.strip().lower()
+
+            # Check for explicit unit suffix
+            if value_str.endswith('ms'):
+                return round(float(value_str[:-2]), 2)
+            elif value_str.endswith('s'):
+                return round(float(value_str[:-1]) * 1000, 2)
+            else:
+                # No suffix, convert to number and apply numeric logic
+                num_value = float(value_str)
+                if num_value.is_integer():
+                    # Integer implies milliseconds
+                    return round(num_value, 2)
+                else:
+                    # Decimal implies seconds, convert to ms
+                    return round(num_value * 1000, 2)
+
+        # Handle numeric input
+        elif isinstance(latency_value, (int, float)):
+            if float(latency_value).is_integer():
+                # Integer implies milliseconds
+                return round(float(latency_value), 2)
+            else:
+                # Decimal implies seconds, convert to ms
+                return round(float(latency_value) * 1000, 2)
+
+        return None
+    except (ValueError, AttributeError):
+        return None
+
 
 class BaseProvider(ABC):
-    """
+    '''
     Abstract base class for all search providers.
     Enforces a standard interface for executing search queries.
-    """
+    '''
 
     @abstractmethod
     def search(self, query, api_key, **kwargs):
-        """
+        '''
         Execute a search request against the provider.
 
         Args:
@@ -39,7 +131,8 @@ class BaseProvider(ABC):
         Returns:
             dict: A standardized dictionary containing:
                 - 'results': List of dicts with 'title', 'url', 'snippet'.
-                - 'metrics': Dict with 'latency_ms' and 'size_bytes'.
+                - 'metrics': Dict with 'latency_ms' (client latency), 'server_latency_ms' (server reported latency),
+                  and 'size_bytes'.
                 - 'error': (Optional) Error message string if occurred.
-        """
+        '''
         pass