search-api-webui 0.1.7__tar.gz → 0.1.9__tar.gz

{search_api_webui-0.1.7 → search_api_webui-0.1.9}/.gitignore

@@ -8,7 +8,6 @@ venv/
 # Frontend / Node
 frontend/node_modules/
 frontend/dist/
-frontend/package-lock.json
 frontend/.DS_Store
 .DS_Store
 
@@ -24,6 +23,7 @@ user_config.json
 .co*/
 .tr*/
 .hi*/
+.ba*/
 
 # Build artifacts
 build/

{search_api_webui-0.1.7 → search_api_webui-0.1.9}/PKG-INFO

@@ -1,49 +1,71 @@
 Metadata-Version: 2.4
 Name: search-api-webui
-Version: 0.1.7
-Summary: A Search API WebUI for Querit, You, and other search providers.
+Version: 0.1.9
+Summary: A Search API WebUI for testing and comparing 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: querit.ai
 License: MIT
 License-File: LICENSE
-Keywords: api,llm,querit,search,tool,webui
+Keywords: api,arena,benchmark,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.4
+Requires-Python: >=3.8
 Requires-Dist: flask-cors>=3.0.0
 Requires-Dist: flask>=1.1.0
 Requires-Dist: jmespath>=0.10.0
 Requires-Dist: pyyaml>=5.3
 Requires-Dist: querit
 Requires-Dist: requests>=2.22.0
+Provides-Extra: build
+Requires-Dist: pyinstaller>=6.0; extra == 'build'
+Provides-Extra: webview
+Requires-Dist: pywebview>=5.0; extra == 'webview'
 Description-Content-Type: text/markdown
 
 # Search API WebUI
 
-A lightweight, local WebUI for testing and visualizing Search APIs (Querit, You, etc.).
+A lightweight, cross-platform WebUI and native Mac App for testing, comparing, and visualizing Search APIs (Querit, You, etc.).
 
-(images)
+![Screenshot](docs/images/screenshot.webp)
 
 ## Features
 
 * **Search**: Support for [Querit.ai](https://www.querit.ai/en/docs/reference/post), [You.com](https://docs.you.com/api-reference/search/v1-search), and generic Search APIs via configuration.
+* **API Arena**: Compare two search providers side-by-side to benchmark latency, payload size, and result relevance.
 * **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 your $HOME folder.
 ## Installation
 
-Use this method if you just want to run the tool without modifying the code.
+### macOS Installation
+
+For macOS users, you can download the DMG installer from the GitHub Releases page:
+
+1. Visit the [Releases page](https://github.com/querit-ai/search-api-webui/releases)
+2. Download the appropriate DMG file for your Mac architecture:
+   - **Apple Silicon (M1/M2/M3)**: `SearchAPIWebUI-<version>-macOS-arm64.dmg`
+   - **Intel Macs**: `SearchAPIWebUI-<version>-macOS-x86_64.dmg`
+3. Open the DMG file and drag `SearchAPIWebUI` to your Applications folder
+4. Launch `SearchAPIWebUI` from Applications
+
+**Note**: Since the application is not code-signed, macOS may block it on first launch. To allow it to run:
+- Go to **System Settings** > **Privacy & Security**
+- Look for the message about `SearchAPIWebUI` being blocked
+- Click **Open Anyway** to allow the application to run
 
 ### Prerequisites
 
 Python 3.7+
+
 ### Install via Pip
 
+Use this method if you just want to run the tool without modifying the code.
+
 ```
 pip install search-api-webui
 ```
@@ -63,36 +85,76 @@ Use this method if you want to contribute to the code or build from source.
 * Python 3.7+
 * Node.js & npm (for building the frontend)
 
-### Setup Steps
+### Quick Start with Makefile
 
 **Clone the repository**
 
-```
+```bash
 git clone https://github.com/querit-ai/search-api-webui.git
 cd search-api-webui
 ```
 
-**Build Frontend**
+**Development Mode** (with hot reload)
+
+```bash
+make dev
+```
+
+This will:
+- Start Flask backend on http://localhost:8889
+- Start Vite frontend dev server on http://localhost:5173
+- Automatically open your browser
+- Enable hot module replacement for instant updates
+
+**Build Python Wheel**
 
+```bash
+make              # or 'make all'
 ```
+
+**Build macOS DMG** (macOS only)
+
+```bash
+make dmg          # Builds for your current architecture
+```
+
+### Manual Setup
+
+If you prefer not to use Makefile:
+
+**Build Frontend**
+
+```bash
 cd frontend
 npm install
 npm run build
-cd …
+cd ..
 ```
 
 **Install search-api-webui (Editable Mode)**
 
-```
+```bash
 pip install -e .
 ```
 
 **Run the Server**
 
-```
+```bash
 python -m search_api_webui.app
 ```
 
+### Available Make Commands
+
+```bash
+make              # Build Python wheel package (default)
+make dev          # Start development servers with hot reload
+make dmg          # Build macOS DMG for current architecture
+make backend      # Start backend server only
+make frontend     # Start frontend dev server only
+make clean        # Clean build artifacts
+make help         # Show all available commands
+```
+
 ## Configuration
 
 ### Add API Keys

search_api_webui-0.1.9/README.md

@@ -0,0 +1,158 @@
+# Search API WebUI
+
+A lightweight, cross-platform WebUI and native Mac App for testing, comparing, and visualizing Search APIs (Querit, You, etc.).
+
+![Screenshot](docs/images/screenshot.webp)
+
+## Features
+
+* **Search**: Support for [Querit.ai](https://www.querit.ai/en/docs/reference/post), [You.com](https://docs.you.com/api-reference/search/v1-search), and generic Search APIs via configuration.
+* **API Arena**: Compare two search providers side-by-side to benchmark latency, payload size, and result relevance.
+* **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 your $HOME folder.
+## Installation
+
+### macOS Installation
+
+For macOS users, you can download the DMG installer from the GitHub Releases page:
+
+1. Visit the [Releases page](https://github.com/querit-ai/search-api-webui/releases)
+2. Download the appropriate DMG file for your Mac architecture:
+   - **Apple Silicon (M1/M2/M3)**: `SearchAPIWebUI-<version>-macOS-arm64.dmg`
+   - **Intel Macs**: `SearchAPIWebUI-<version>-macOS-x86_64.dmg`
+3. Open the DMG file and drag `SearchAPIWebUI` to your Applications folder
+4. Launch `SearchAPIWebUI` from Applications
+
+**Note**: Since the application is not code-signed, macOS may block it on first launch. To allow it to run:
+- Go to **System Settings** > **Privacy & Security**
+- Look for the message about `SearchAPIWebUI` being blocked
+- Click **Open Anyway** to allow the application to run
+
+### Prerequisites
+
+Python 3.7+
+
+### Install via Pip
+
+Use this method if you just want to run the tool without modifying the code.
+
+```
+pip install search-api-webui
+```
+
+### Run the Server
+
+```
+search-api-webui
+```
+
+## Development
+
+Use this method if you want to contribute to the code or build from source.
+
+### Prerequisites
+
+* Python 3.7+
+* Node.js & npm (for building the frontend)
+
+### Quick Start with Makefile
+
+**Clone the repository**
+
+```bash
+git clone https://github.com/querit-ai/search-api-webui.git
+cd search-api-webui
+```
+
+**Development Mode** (with hot reload)
+
+```bash
+make dev
+```
+
+This will:
+- Start Flask backend on http://localhost:8889
+- Start Vite frontend dev server on http://localhost:5173
+- Automatically open your browser
+- Enable hot module replacement for instant updates
+
+**Build Python Wheel**
+
+```bash
+make              # or 'make all'
+```
+
+**Build macOS DMG** (macOS only)
+
+```bash
+make dmg          # Builds for your current architecture
+```
+
+### Manual Setup
+
+If you prefer not to use Makefile:
+
+**Build Frontend**
+
+```bash
+cd frontend
+npm install
+npm run build
+cd ..
+```
+
+**Install search-api-webui (Editable Mode)**
+
+```bash
+pip install -e .
+```
+
+**Run the Server**
+
+```bash
+python -m search_api_webui.app
+```
+
+### Available Make Commands
+
+```bash
+make              # Build Python wheel package (default)
+make dev          # Start development servers with hot reload
+make dmg          # Build macOS DMG for current architecture
+make backend      # Start backend server only
+make frontend     # Start frontend dev server only
+make clean        # Clean build artifacts
+make help         # Show all available commands
+```
+
+## Configuration
+
+### Add API Keys
+
+Open the WebUI settings page (click the gear icon). Enter your API Key for the selected provider (e.g., Querit). Keys are saved locally in $HOME/.search-api-webui/config.json.
+
+### Add New Providers
+
+Edit providers.yaml in the root directory to add custom API endpoints. The system uses JMESPath to map JSON responses to the UI.
+
+```
+my_custom_search:
+url: “https://api.example.com/search”
+method: “GET”
+headers:
+Authorization: “Bearer {api_key}”
+params:
+q: “{query}”
+response_mapping:
+root_path: “data.items”
+fields:
+title: “title”
+url: “link”
+snippet: “snippet”
+```
+
+## License
+
+MIT License. See LICENSE for details.

{search_api_webui-0.1.7 → search_api_webui-0.1.9}/pyproject.toml

@@ -4,15 +4,15 @@ build-backend = "hatchling.build"
 
 [project]
 name = "search-api-webui"
-version = "0.1.7"
-description = "A Search API WebUI for Querit, You, and other search providers."
+version = "0.1.9"
+description = "A Search API WebUI for testing and comparing Querit, You, and other search providers."
 readme = "README.md"
-requires-python = ">=3.4"
+requires-python = ">=3.8"
 license = { text = "MIT" }
 authors = [
     { name = "querit.ai" }
 ]
-keywords = ["search", "api", "webui", "querit", "llm", "tool"]
+keywords = ["search", "api", "webui", "querit", "llm", "tool", "arena", "benchmark"]
 classifiers = [
     "Development Status :: 3 - Alpha",
     "License :: OSI Approved :: MIT License",
@@ -29,6 +29,10 @@ dependencies = [
     "querit"
 ]
 
+[project.optional-dependencies]
+webview = ["pywebview>=5.0"]
+build = ["pyinstaller>=6.0"]
+
 [project.urls]
 Homepage = "https://github.com/querit-ai/search-api-webui"
 Repository = "https://github.com/querit-ai/search-api-webui.git"

{search_api_webui-0.1.7 → search_api_webui-0.1.9}/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-0.1.9/search_api_webui/app.py

@@ -0,0 +1,311 @@
+# Copyright (c) 2026 QUERIT PRIVATE LIMITED
+#
+# 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.
+
+import json
+import logging
+import socket
+import sys
+import threading
+import time
+import webbrowser
+from pathlib import Path
+
+from flask import Flask, jsonify, request, send_from_directory
+from flask_cors import CORS
+
+from search_api_webui.providers import load_providers
+
+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
+
+
+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)
+
+# 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'
+
+if not USER_CONFIG_DIR.exists():
+    USER_CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+
+if PROVIDERS_YAML.exists():
+    provider_map = load_providers(str(PROVIDERS_YAML))
+else:
+    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, encoding='utf-8') as f:
+            return json.load(f)
+    except Exception as 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:
+        logger.error(f'Error saving config: {e}')
+
+
+@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'),
+                },
+            },
+        )
+    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
+
+    api_key = data.get('api_key')
+
+    api_url = data.get('api_url', '').strip()
+    limit = data.get('limit', '10')
+    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]}
+
+    # Initialize provider config if not exists
+    if provider_name not in all_config:
+        all_config[provider_name] = {}
+
+    # 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'})
+
+
+@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 (STATIC_FOLDER / path).exists():
+        return send_from_directory(str(STATIC_FOLDER), path)
+    else:
+        return send_from_directory(str(STATIC_FOLDER), 'index.html')
+
+
+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
+
+
+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()
+
+    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()