search-api-webui 0.1.0__py3-none-any.whl

backend/app.py

@@ -0,0 +1,146 @@
+import json
+import os
+from flask import Flask, request, jsonify, send_from_directory
+from flask_cors import CORS
+from backend.providers import load_providers
+
+app = Flask(__name__, static_folder='static')
+CORS(app)
+
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+PROVIDERS_YAML = os.path.join(BASE_DIR, 'providers.yaml')
+USER_CONFIG_JSON = os.path.join(BASE_DIR, 'user_config.json')
+
+provider_map = load_providers(PROVIDERS_YAML)
+
+def get_stored_config():
+    if not os.path.exists(USER_CONFIG_JSON):
+        return {}
+    try:
+        with open(USER_CONFIG_JSON, 'r') as f:
+            return json.load(f)
+    except:
+        return {}
+
+def save_stored_config(config_dict):
+    with open(USER_CONFIG_JSON, 'w') as f:
+        json.dump(config_dict, f, indent=2)
+
+@app.route('/api/providers', methods=['GET'])
+def get_providers_list():
+    stored_config = get_stored_config()
+    providers_info = []
+
+    for name, provider_instance in provider_map.items():
+        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')
+            }
+        })
+    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
+
+    api_key = data.get('api_key')
+
+    api_url = data.get('api_url', '').strip()
+    limit = data.get('limit', '10')
+    language = data.get('language', 'en-US')
+
+    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] = {}
+
+        all_config[provider_name]['api_key'] = api_key
+        all_config[provider_name]['api_url'] = api_url
+        all_config[provider_name]['limit'] = limit
+        all_config[provider_name]['language'] = language
+
+    save_stored_config(all_config)
+    return jsonify({"status": "success"})
+
+@app.route('/api/search', methods=['POST'])
+def search_api():
+    data = request.json
+    query = data.get('query')
+    provider_name = data.get('provider', 'querit')
+
+    api_key = data.get('api_key')
+
+    stored_config = get_stored_config()
+    provider_config = stored_config.get(provider_name, {})
+
+    if isinstance(provider_config, str):
+        provider_config = {'api_key': provider_config}
+
+    if not api_key:
+        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
+
+    provider = provider_map.get(provider_name)
+    if not provider:
+        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')
+    }
+
+    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 os.path.exists(os.path.join(app.static_folder, path)):
+        return send_from_directory(app.static_folder, path)
+    else:
+        return send_from_directory(app.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="0.0.0.0", help="Host to run the server on")
+    args = parser.parse_args()
+    
+    app.run(host=args.host, port=args.port)
+
+if __name__ == "__main__":
+    main()
+

backend/providers/__init__.py

@@ -0,0 +1,34 @@
+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}")
+        return {}
+        
+    with open(file_path, 'r', encoding='utf-8') as f:
+        configs = yaml.safe_load(f)
+
+    providers = {}
+    for name, conf in configs.items():
+        conf['name'] = name
+        provider_type = conf.get('type', 'generic')
+
+        # Instantiate specific provider based on type or name
+        if name == 'querit' or provider_type == 'querit_sdk':
+            providers[name] = QueritSdkProvider(conf)
+        else:
+            providers[name] = GenericProvider(conf)
+
+    return providers

backend/providers/base.py

@@ -0,0 +1,25 @@
+from abc import ABC, abstractmethod
+
+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:
+            query (str): The search keywords.
+            api_key (str): The API Key required for authentication.
+            **kwargs: Arbitrary keyword arguments (e.g., 'limit', 'language', 'api_url').
+
+        Returns:
+            dict: A standardized dictionary containing:
+                - 'results': List of dicts with 'title', 'url', 'snippet'.
+                - 'metrics': Dict with 'latency_ms' and 'size_bytes'.
+                - 'error': (Optional) Error message string if occurred.
+        """
+        pass

backend/providers/generic.py

@@ -0,0 +1,125 @@
+import time
+import requests
+import jmespath
+from .base import BaseProvider
+
+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
+
+    def _fill_template(self, template_obj, **kwargs):
+        """
+        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()}
+            try:
+                return template_obj.format(**safe_kwargs)
+            except KeyError:
+                # Return original string if a placeholder key is missing in kwargs
+                return template_obj
+        elif isinstance(template_obj, dict):
+            return {k: self._fill_template(v, **kwargs) for k, v in template_obj.items()}
+        return template_obj
+
+    def search(self, query, api_key, **kwargs):
+        # 1. Extract parameters with defaults
+        limit = kwargs.get('limit', '10')
+        language = kwargs.get('language', 'en-US')
+        custom_url = kwargs.get('api_url', '').strip()
+
+        # 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
+        }
+
+        # 4. construct request components
+        headers = self._fill_template(self.config.get('headers', {}), **context)
+        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}')
+        
+        start_time = time.time()
+
+        try:
+            req_args = {'headers': headers, 'timeout': 30}
+            if params:
+                req_args['params'] = params
+            if json_body:
+                req_args['json'] = json_body
+
+            if method.upper() == 'GET':
+                response = requests.get(url, **req_args)
+            else:
+                response = requests.post(url, **req_args)
+
+            response.raise_for_status()
+        except Exception as e:
+            print(f"Request Error: {e}")
+            return {
+                "error": str(e),
+                "results": [],
+                "metrics": {"latency_ms": 0, "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}")
+            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 []
+
+        normalized_results = []
+        field_map = mapping.get('fields', {})
+
+        for item in root_list:
+            entry = {}
+            # 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 ""
+            normalized_results.append(entry)
+
+        return {
+            "results": normalized_results,
+            "metrics": {
+                "latency_ms": round((end_time - start_time) * 1000, 2),
+                "size_bytes": len(response.content)
+            }
+        }

backend/providers/querit.py

@@ -0,0 +1,80 @@
+import time
+import json
+from querit import QueritClient
+from querit.models.request import SearchRequest
+from querit.errors import QueritError
+from .base import BaseProvider
+
+class QueritSdkProvider(BaseProvider):
+    """
+    Specialized provider implementation using the official Querit Python SDK.
+    """
+
+    def __init__(self, config):
+        self.config = config
+
+    def search(self, query, api_key, **kwargs):
+        """
+        Executes a search using the Querit SDK.
+        Handles the 'Bearer' prefix logic internally within the SDK.
+        """
+        try:
+            # Initialize client with the raw API key
+            client = QueritClient(
+                api_key=api_key.strip(),
+                timeout=30
+            )
+
+            limit = int(kwargs.get('limit', 10))
+
+            request_model = SearchRequest(
+                query=query,
+                count=limit,
+            )
+
+            print(f'[Querit SDK] Searching: {query} (Limit: {limit})')
+
+            start_time = time.time()
+            
+            # Execute search via SDK
+            response = client.search(request_model)
+            
+            end_time = time.time()
+
+            # Normalize results to standard format
+            normalized_results = []
+            if response.results:
+                for item in response.results:
+                    # Use getattr to safely access SDK object attributes
+                    normalized_results.append({
+                        "title": getattr(item, 'title', ''),
+                        "url": getattr(item, 'url', ''),
+                        # Fallback to description if snippet is missing
+                        "snippet": getattr(item, 'snippet', '') or getattr(item, 'description', '')
+                    })
+
+            # Calculate estimated size for metrics (approximate JSON size)
+            estimated_size = len(json.dumps([r for r in normalized_results]))
+
+            return {
+                "results": normalized_results,
+                "metrics": {
+                    "latency_ms": round((end_time - start_time) * 1000, 2),
+                    "size_bytes": estimated_size
+                }
+            }
+
+        except QueritError as e:
+            print(f"Querit SDK Error: {e}")
+            return {
+                "error": f"Querit SDK Error: {str(e)}",
+                "results": [],
+                "metrics": {"latency_ms": 0, "size_bytes": 0}
+            }
+        except Exception as e:
+            print(f"Unexpected Error: {e}")
+            return {
+                "error": f"Error: {str(e)}",
+                "results": [],
+                "metrics": {"latency_ms": 0, "size_bytes": 0}
+            }

backend/providers.yaml

@@ -0,0 +1,19 @@
+querit:
+  type: "querit_sdk"
+  description: "Official Querit Search via Python SDK"
+  default_limit: 10
+
+ydc_search:
+  url: "https://ydc-index.io/v1/search"
+  method: "GET"
+  headers:
+    X-API-Key: "{api_key}"
+  params:
+    query: "{query}"
+  payload: {}
+  response_mapping:
+    root_path: "results.web" 
+    fields:
+      title: "title"
+      url: "url"
+      snippet: "snippets[0] || description"