search-api-webui 0.1.0__tar.gz

search_api_webui-0.1.0/.gitignore

@@ -0,0 +1,28 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+venv/
+.env
+
+# Frontend / Node
+frontend/node_modules/
+frontend/dist/
+frontend/package-lock.json
+frontend/.DS_Store
+.DS_Store
+
+# Backend
+backend/static/
+
+# User Configuration
+user_config.json
+
+# IDE
+.idea/
+.vscode/
+
+# Build artifacts
+build/
+dist/
+*.egg-info/

search_api_webui-0.1.0/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2026 querit-ai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 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-0.1.0/PKG-INFO

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: search-api-webui
+Version: 0.1.0
+Summary: A Search API WebUI for Querit, You, and other search providers.
+Project-URL: Homepage, https://github.com/querit-ai/search-api-webui
+Project-URL: Repository, https://github.com/querit-ai/search-api-webui.git
+Project-URL: Issues, https://github.com/querit-ai/search-api-webui/issues
+Author: Search API WebUI Team
+License: MIT
+License-File: LICENSE
+Keywords: api,llm,querit,search,tool,webui
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: Flask
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.7
+Requires-Dist: flask-cors
+Requires-Dist: flask>=2.0.0
+Requires-Dist: jmespath
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: querit
+Requires-Dist: requests>=2.25.0
+Description-Content-Type: text/markdown
+
+# Search API WebUI
+
+A lightweight, local WebUI for testing and visualizing Search APIs (Querit, YDC, etc.).
+
+## Features
+
+- 🔍 **Search**: Support for Querit, You.com, and generic Search APIs via configuration.
+- ⚡ **Performance Metrics**: Real-time display of request latency and payload size.
+- 🎨 **Visual Rendering**: Renders standard search results (Title, Snippet, URL) in a clean card layout.
+- 🛠️ **Configurable**: Easy-to-edit `providers.yaml` to add or modify search providers.
+- 🔒 **Secure**: API Keys are stored locally in `user_config.json` and never committed.
+
+## Quick Start
+
+### Prerequisites
+
+- Python 3.7+
+- Node.js & npm (for building the frontend)
+
+### Installation
+
+1. **Clone the repository**
+   ```bash
+   git clone https://github.com/querit-ai/search-api-webui.git
+   cd search-api-webui
+   ```
+2. **Build Frontend**
+   ```bash
+   cd frontend
+   npm install
+   npm run build
+   cd ..
+   ```
+3. **Install Backend**
+   ```bash
+   pip install -e .
+   ```
+
+### Usage
+**Run the server:**
+   ```bash
+   python -m backend.app
+   ```
+Or if you installed via pip:
+   ```bash
+   search-api-webui
+   ```
+
+Open your browser at http://localhost:8889.
+
+## Configuration
+### Add API Keys
+1. Open the WebUI settings page.
+2. Enter your API Key for the selected provider (e.g., Querit).
+3. Keys are saved locally in user_config.json.
+
+### Add New Providers
+Edit providers.yaml to add custom API endpoints. The system uses JMESPath to map JSON responses to the UI.
+```yaml
+my_custom_search:
+      url: "https://api.example.com/search"
+      method: "GET"
+      ...
+```
+## Development
+Backend: Flask (in backend/)
+Frontend: React + Vite (in frontend/)
+## License
+MIT License. See LICENSE for details.

search_api_webui-0.1.0/README.md

@@ -0,0 +1,69 @@
+# Search API WebUI
+
+A lightweight, local WebUI for testing and visualizing Search APIs (Querit, YDC, etc.).
+
+## Features
+
+- 🔍 **Search**: Support for Querit, You.com, and generic Search APIs via configuration.
+- ⚡ **Performance Metrics**: Real-time display of request latency and payload size.
+- 🎨 **Visual Rendering**: Renders standard search results (Title, Snippet, URL) in a clean card layout.
+- 🛠️ **Configurable**: Easy-to-edit `providers.yaml` to add or modify search providers.
+- 🔒 **Secure**: API Keys are stored locally in `user_config.json` and never committed.
+
+## Quick Start
+
+### Prerequisites
+
+- Python 3.7+
+- Node.js & npm (for building the frontend)
+
+### Installation
+
+1. **Clone the repository**
+   ```bash
+   git clone https://github.com/querit-ai/search-api-webui.git
+   cd search-api-webui
+   ```
+2. **Build Frontend**
+   ```bash
+   cd frontend
+   npm install
+   npm run build
+   cd ..
+   ```
+3. **Install Backend**
+   ```bash
+   pip install -e .
+   ```
+
+### Usage
+**Run the server:**
+   ```bash
+   python -m backend.app
+   ```
+Or if you installed via pip:
+   ```bash
+   search-api-webui
+   ```
+
+Open your browser at http://localhost:8889.
+
+## Configuration
+### Add API Keys
+1. Open the WebUI settings page.
+2. Enter your API Key for the selected provider (e.g., Querit).
+3. Keys are saved locally in user_config.json.
+
+### Add New Providers
+Edit providers.yaml to add custom API endpoints. The system uses JMESPath to map JSON responses to the UI.
+```yaml
+my_custom_search:
+      url: "https://api.example.com/search"
+      method: "GET"
+      ...
+```
+## Development
+Backend: Flask (in backend/)
+Frontend: React + Vite (in frontend/)
+## License
+MIT License. See LICENSE for details.

search_api_webui-0.1.0/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()
+

search_api_webui-0.1.0/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

search_api_webui-0.1.0/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

search_api_webui-0.1.0/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)
+            }
+        }

search_api_webui-0.1.0/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}
+            }