search-api-webui 0.1.6__py3-none-any.whl → 0.1.8__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,55 @@
 # DEALINGS IN THE SOFTWARE.
 
 import json
-import os
+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
+
+
+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 +77,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}")
+    print(f'Error: 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}")
+        print(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}")
+        print(f'Error saving config: {e}')
+
 
 @app.route('/api/providers', methods=['GET'])
 def get_providers_list():
@@ -76,34 +109,37 @@ 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', 'en-US'),
+                },
+            },
+        )
     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
+        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': 'API Key field is missing'}), 400
 
     api_key = data.get('api_key')
 
@@ -118,7 +154,7 @@ def update_config():
 
     if not api_key:
         if provider_name in all_config:
-            all_config[provider_name]['api_key'] = ""
+            all_config[provider_name]['api_key'] = ''
     else:
         if provider_name not in all_config:
             all_config[provider_name] = {}
@@ -129,7 +165,8 @@ def update_config():
         all_config[provider_name]['language'] = language
 
     save_stored_config(all_config)
-    return jsonify({"status": "success"})
+    return jsonify({'status': 'success'})
+
 
 @app.route('/api/search', methods=['POST'])
 def search_api():
@@ -149,46 +186,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)
+def main():
+    import argparse
 
-    app.run(host=args.host, port=args.port)
+    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')
+    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}'
+    print('Starting Search API WebUI...')
+    print(f'  - Config Storage: {USER_CONFIG_JSON}')
+    print(f'  - Serving on: {url}')
+    if args.webview:
+        print('  - Mode: webview')
+
+    if args.webview:
+        if not WEBVIEW_AVAILABLE:
+            print('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):
+                print(f'Server is ready! Opening browser: {url}')
+                webbrowser.open(url)
+            else:
+                print('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):
+                print('Server is ready! Using webview mode...')
+                webview.create_window('Search API WebUI', url, width=1200, height=800)
+                webview.start()
+            else:
+                print('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):
+                print(f'Server is ready! Opening browser: {url}')
+                webbrowser.open(url)
+            else:
+                print('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

@@ -19,25 +19,28 @@
 # DEALINGS IN THE SOFTWARE.
 
 import os
+
 import yaml
+
 from .generic import GenericProvider
 from .querit import QueritSdkProvider
 
+
 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}")
+        print(f'Warning: 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

@@ -20,15 +20,74 @@
 
 from abc import ABC, abstractmethod
 
+
+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 +98,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

search_api_webui/providers/generic.py

@@ -18,41 +18,48 @@
 # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 # DEALINGS IN THE SOFTWARE.
 
+import html
+import logging
 import time
-import requests
+
 import jmespath
-from .base import BaseProvider
+import requests
+
+from .base import BaseProvider, parse_server_latency
+
+logger = logging.getLogger(__name__)
+
 
 class GenericProvider(BaseProvider):
-    """
+    '''
     A generic search provider driven by YAML configuration.
     It constructs HTTP requests dynamically and maps responses using JMESPath.
-    """
+    '''
 
     def __init__(self, config):
-        """
+        '''
         Initialize the provider with a configuration dictionary.
-        
+
         Args:
             config (dict): Configuration containing url, headers, params, and mapping rules.
-        """
+        '''
         self.config = config
         self.session = requests.Session()  # Persistent connection session
-        self._connection_ready = False     # Connection ready status
-        self._last_url = None              # Last used URL tracker
+        self._connection_ready = False  # Connection ready status
+        self._last_url = None  # Last used URL tracker
 
     def _fill_template(self, template_obj, **kwargs):
-        """
-        Recursively replaces placeholders (e.g., {query}) in dictionaries or strings 
+        '''
+        Recursively replaces placeholders (e.g., {query}) in dictionaries or strings
         with values provided in kwargs.
-        
+
         Args:
             template_obj (dict | str): The structure containing placeholders.
             **kwargs: Key-value pairs to inject into the template.
-            
+
         Returns:
             The structure with placeholders replaced by actual values.
-        """
+        '''
         if isinstance(template_obj, str):
             # Treat None values as empty strings to prevent "None" appearing in URLs
             safe_kwargs = {k: (v if v is not None else '') for k, v in kwargs.items()}
@@ -66,7 +73,7 @@ class GenericProvider(BaseProvider):
         return template_obj
 
     def _ensure_connection(self, url, headers):
-        """
+        '''
         Pre-warm HTTPS connection and verify availability.
         Uses lightweight HEAD request to verify connection without fetching response body.
 
@@ -76,7 +83,7 @@ class GenericProvider(BaseProvider):
 
         Returns:
             bool: Whether connection is ready
-        """
+        '''
         # Re-warm if URL changed or connection not ready
         if url != self._last_url or not self._connection_ready:
             try:
@@ -84,13 +91,24 @@ class GenericProvider(BaseProvider):
                 self.session.head(url, headers=headers, timeout=5)
                 self._connection_ready = True
                 self._last_url = url
-                print(f'  [Connection Pool] Connected to: {url}')
+                logger.debug('[Connection Pool] Connected to: %s', url)
             except Exception as e:
                 self._connection_ready = False
-                print(f'  [Connection Pool] Connection warm-up failed: {e}')
+                logger.warning('[Connection Pool] Connection warm-up failed: %s', e)
                 raise
 
     def search(self, query, api_key, **kwargs):
+        '''
+        Perform search using the configured API.
+
+        Args:
+            query: Search query string
+            api_key: API key for authentication
+            **kwargs: Additional parameters (limit, language, api_url)
+
+        Returns:
+            dict: Search results with 'results' and 'metrics' keys
+        '''
         # 1. Extract parameters with defaults
         limit = kwargs.get('limit', '10')
         language = kwargs.get('language', 'en-US')
@@ -99,13 +117,13 @@ class GenericProvider(BaseProvider):
         # 2. Determine configuration
         url = custom_url if custom_url else self.config.get('url')
         method = self.config.get('method', 'GET')
-        
+
         # 3. Prepare context for template injection
         context = {
             'query': query,
             'api_key': api_key,
             'limit': limit,
-            'language': language
+            'language': language,
         }
 
         # 4. construct request components
@@ -113,24 +131,21 @@ class GenericProvider(BaseProvider):
         params = self._fill_template(self.config.get('params', {}), **context)
         json_body = self._fill_template(self.config.get('payload', {}), **context)
 
-        # Logging (Masking sensitive API keys)
-        print(f'[{self.config.get("name", "Unknown")}] Search:')
-        print(f'  URL: {url} | Method: {method}')
-        
+        logger.info('[%s] Search: URL=%s | Method=%s',
+                  self.config.get('name', 'Unknown'), url, method)
+
         # Ensure connection is pre-warmed (use HEAD request to verify availability)
         # Pre-warming is not counted in request latency, only verifies connection
         try:
             self._ensure_connection(url, headers)
         except Exception as e:
-            print(f"Connection Warm-up Error: {e}")
+            logger.error('Connection Warm-up Error: %s', e)
             return {
-                "error": f"Connection failed: {str(e)}",
-                "results": [],
-                "metrics": {"latency_ms": 0, "size_bytes": 0}
+                'error': f'Connection failed: {str(e)}',
+                'results': [],
+                'metrics': {'latency_ms': 0, 'server_latency_ms': None, 'size_bytes': 0},
             }
 
-        start_time = time.time()
-
         try:
             req_args = {'headers': headers, 'timeout': 30}
             if params:
@@ -139,29 +154,31 @@ class GenericProvider(BaseProvider):
                 req_args['json'] = json_body
 
             # Use Session to send request (connection is reused)
+            start_time = time.time()
             if method.upper() == 'GET':
                 response = self.session.get(url, **req_args)
             else:
                 response = self.session.post(url, **req_args)
+            end_time = time.time()
 
             response.raise_for_status()
         except Exception as e:
-            print(f"Request Error: {e}")
+            logger.error('Request Error: %s', e)
             return {
-                "error": str(e),
-                "results": [],
-                "metrics": {"latency_ms": 0, "size_bytes": 0}
+                'error': str(e),
+                'results': [],
+                'metrics': {'latency_ms': 0, 'server_latency_ms': None, 'size_bytes': 0},
             }
 
-        end_time = time.time()
-
         # 5. Parse and Normalize Response
         try:
             raw_data = response.json()
         except Exception as e:
-            print(f"JSON Parse Error: {e}")
+            logger.error('JSON Parse Error: %s', e)
             raw_data = {}
 
+        logger.debug('Full response: %s', raw_data)
+
         mapping = self.config.get('response_mapping', {})
         # Use JMESPath to find the list of results
         root_list = jmespath.search(mapping.get('root_path', '@'), raw_data) or []
@@ -174,13 +191,23 @@ class GenericProvider(BaseProvider):
             # Map specific fields (title, url, etc.) based on config
             for std_key, source_path in field_map.items():
                 val = jmespath.search(source_path, item)
-                entry[std_key] = val if val else ""
+                # Decode HTML entities for site_name
+                if std_key == 'site_name' and val:
+                    val = html.unescape(val)
+                entry[std_key] = val if val else ''
             normalized_results.append(entry)
 
+        # Extract server latency from response if configured
+        server_latency_path = mapping.get('server_latency_path')
+        server_latency_ms = parse_server_latency(
+            jmespath.search(server_latency_path, raw_data),
+        ) if server_latency_path else None
+
         return {
-            "results": normalized_results,
-            "metrics": {
-                "latency_ms": round((end_time - start_time) * 1000, 2),
-                "size_bytes": len(response.content)
-            }
+            'results': normalized_results,
+            'metrics': {
+                'latency_ms': round((end_time - start_time) * 1000, 2),
+                'server_latency_ms': server_latency_ms,
+                'size_bytes': len(response.content),
+            },
         }