wip

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1 @@
+__pycache__

Dockerfile

@@ -0,0 +1,38 @@
+FROM python:3.13
+
+# Install basic tools: wget, curl, unzip
+RUN apt-get update && \
+    apt-get install -y wget curl unzip && \
+    rm -rf /var/lib/apt/lists/*
+
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+
+RUN mkdir -p /home/user/.cache/pip
+
+RUN chown user:user /home/user/.cache/pip
+RUN --mount=type=cache,target=/home/user/.cache/pip pip install --upgrade -r requirements.txt
+
+COPY --chown=user . /app
+
+
+ENV APP_PORT=7860
+ENV APP_HOST="0.0.0.0"
+ENV ENVIRONMENT="production"
+ENV TOKENIZERS_PARALLELISM=false
+
+ENV DEFAULT_MODEL="text-embedding-3-large"
+ENV WARMUP_ENABLED=true
+ENV CUDA_CACHE_CLEAR_ENABLED=true
+ENV EMBEDDING_BATCH_SIZE=8
+ENV EMBEDDINGS_CACHE_ENABLED=true
+ENV EMBEDDINGS_CACHE_MAXSIZE=2048
+ENV REPORT_CACHED_TOKENS=false
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]
+# CMD ["python", "app.py"]

README.md

@@ -0,0 +1,10 @@
+---
+title: Wip Test
+emoji: 🐨
+colorFrom: pink
+colorTo: gray
+sdk: docker
+pinned: false
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,255 @@
+
+from fastapi import FastAPI, Request, Response, WebSocket, WebSocketDisconnect
+from fastapi.responses import HTMLResponse
+from fastapi.concurrency import run_in_threadpool
+from gradio_client import Client
+import gradio as gr
+import uvicorn
+import httpx
+import websockets
+import asyncio
+from urllib.parse import urljoin, urlparse, unquote
+import logging
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = FastAPI()
+
+class HttpClient:
+    def __init__(self):
+        # Configure the HTTP client with appropriate timeouts
+        self.client = httpx.AsyncClient(
+            timeout=httpx.Timeout(30.0),
+            follow_redirects=False
+        )
+    
+    async def forward_request(self, request: Request, target_url: str):
+        """
+        Forward an incoming request to a target URL
+        """
+        try:
+            # Extract method, headers, and body from the incoming request
+            method = request.method
+            headers = dict(request.headers)
+            
+            # Remove headers that shouldn't be forwarded
+            headers.pop("host", None)
+            headers.pop("connection", None)
+            
+            # Get the request body
+            body = await request.body()
+            
+            logger.info(f"Forwarding {method} request to {target_url}")
+            
+            # Forward the request to the target URL
+            response = await self.client.request(
+                method=method,
+                url=target_url,
+                headers=headers,
+                content=body
+            )
+            
+            # Handle the response from the target server
+            response_headers = dict(response.headers)
+            # Remove headers that shouldn't be forwarded from the response
+            response_headers.pop("connection", None)
+            response_headers.pop("transfer-encoding", None)
+            
+            return Response(
+                content=response.content,
+                status_code=response.status_code,
+                headers=response_headers
+            )
+            
+        except httpx.TimeoutException:
+            logger.error(f"Timeout error while forwarding request to {target_url}")
+            return Response(
+                content="Request timeout error",
+                status_code=504
+            )
+        except httpx.NetworkError as e:
+            logger.error(f"Network error while forwarding request: {str(e)}")
+            return Response(
+                content=f"Network error: {str(e)}",
+                status_code=502
+            )
+        except Exception as e:
+            logger.error(f"Error forwarding request: {str(e)}")
+            return Response(
+                content=f"Request error: {str(e)}",
+                status_code=500
+            )
+    
+    async def close(self):
+        await self.client.aclose()
+
+# Initialize the HTTP client
+http_client = HttpClient()
+
+@app.get("/", response_class=HTMLResponse)
+async def read_root():
+    with open("index.html") as f:
+        return f.read()
+
+@app.post("/gp/{repo_id:path}/{api_name:path}")
+async def gradio_client(repo_id: str, api_name: str, request: Request):
+    client = Client(repo_id)
+    data = await request.json()
+    result = await run_in_threadpool(client.predict, *data["args"], api_name=f"/{api_name}")
+    return result
+
+@app.api_route("/wp/{path:path}", methods=["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"])
+async def web_client(request: Request, path: str):
+    """
+    Main web client endpoint that forwards all requests to the target URL
+    specified in the path or the 'X-Target-Url' header
+    """
+    # Prioritize URL in path if it starts with http:// or https://
+    if path.lower().startswith("http://") or path.lower().startswith("https://"):
+        target_url = path
+    else:
+        # Get the target URL from the header
+        target_url = request.headers.get("X-Target-Url")
+        
+        # If we have a target URL from header and a path, combine them
+        if target_url and path:
+            # Validate the target URL from header
+            try:
+                parsed_url = urlparse(target_url)
+                if not parsed_url.scheme or not parsed_url.netloc:
+                    return Response(
+                        content="Invalid X-Target-Url header",
+                        status_code=400
+                    )
+            except Exception:
+                return Response(
+                    content="Invalid X-Target-Url header",
+                    status_code=400
+                )
+            # Join the target URL with the path properly
+            target_url = urljoin(target_url.rstrip('/') + '/', path.lstrip('/'))
+
+    if not target_url:
+        return Response(
+            content="Missing X-Target-Url header or URL in path",
+            status_code=400
+        )
+
+    # Validate the target URL
+    try:
+        parsed_url = urlparse(target_url)
+        if not parsed_url.scheme or not parsed_url.netloc:
+            return Response(
+                content="Invalid X-Target-Url header or URL in path",
+                status_code=400
+            )
+    except Exception:
+        return Response(
+            content="Invalid X-Target-Url header or URL in path",
+            status_code=400
+        )
+
+    # Forward the request
+    return await http_client.forward_request(request, target_url)
+
+@app.websocket("/wp/{path:path}")
+async def websocket_client(websocket: WebSocket, path: str):
+    """
+    WebSocket endpoint that forwards WebSocket connections to the target URL
+    specified in the 'X-Target-Url' header or in the path
+    """
+    # Get the target URL from the header or path
+    target_url = websocket.headers.get("X-Target-Url")
+    
+    # If no header, use path as target URL if it's a valid WebSocket URL
+    if not target_url:
+        # Handle URL-encoded paths
+        decoded_path = path
+        if path and '%' in path:
+            # URL decode the path
+            decoded_path = unquote(path)
+        
+        if decoded_path and (decoded_path.lower().startswith("ws://") or decoded_path.lower().startswith("wss://")):
+            target_url = decoded_path
+        else:
+            await websocket.close(code=1008, reason="Missing X-Target-Url header or invalid URL in path")
+            return
+    
+    # Validate the target URL
+    try:
+        parsed_url = urlparse(target_url)
+        if not parsed_url.scheme or not parsed_url.netloc:
+            await websocket.close(code=1008, reason="Invalid target URL")
+            return
+    except Exception:
+        await websocket.close(code=1008, reason="Invalid target URL")
+        return
+    
+    # Accept the WebSocket connection
+    await websocket.accept()
+    
+    # Convert HTTP/HTTPS URL to WebSocket URL
+    if target_url.lower().startswith("https://"):
+        ws_target_url = "wss://" + target_url[8:]
+    elif target_url.lower().startswith("http://"):
+        ws_target_url = "ws://" + target_url[7:]
+    else:
+        ws_target_url = target_url
+    
+    # Add path if provided (but only if it's not already a complete URL)
+    if path and not (path.lower().startswith("ws://") or path.lower().startswith("wss://")):
+        # Join the target URL with the path properly
+        ws_target_url = urljoin(ws_target_url.rstrip('/') + '/', path.lstrip('/'))
+    
+    try:
+        # Connect to the target WebSocket server
+        async with websockets.connect(ws_target_url) as target_ws:
+            # Forward messages between client and target server
+            async def forward_client_to_target():
+                try:
+                    while True:
+                        data = await websocket.receive_text()
+                        await target_ws.send(data)
+                except WebSocketDisconnect:
+                    pass
+            
+            async def forward_target_to_client():
+                try:
+                    while True:
+                        data = await target_ws.recv()
+                        await websocket.send_text(data)
+                except websockets.ConnectionClosed:
+                    pass
+            
+            # Run both forwarding tasks concurrently
+            await asyncio.gather(
+                forward_client_to_target(),
+                forward_target_to_client(),
+                return_exceptions=True
+            )
+    except websockets.InvalidURI:
+        await websocket.close(code=1008, reason="Invalid WebSocket URL")
+    except websockets.InvalidHandshake:
+        await websocket.close(code=1008, reason="WebSocket handshake failed")
+    except Exception as e:
+        logger.error(f"Error in WebSocket connection: {str(e)}")
+        await websocket.close(code=1011, reason="Internal server error")
+    finally:
+        try:
+            await websocket.close()
+        except:
+            pass
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    return {"status": "ok"}
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    await http_client.close()
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=7860)

index.html

@@ -0,0 +1,101 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Gradio Playgrounf</title>
+    <script src="https://cdn.tailwindcss.com"></script>
+    <script src="https://cdn.jsdelivr.net/npm/json-schema-faker@0.5.9/dist/json-schema-faker.min.js"></script>
+</head>
+<body class="bg-gray-100">
+    <div class="container mx-auto px-4 py-8">
+        <h1 class="text-3xl font-bold mb-4">Gradio Playground</h1>
+        <div class="bg-white p-6 rounded-lg shadow-lg">
+            <div class="mb-4">
+                <label class="block text-gray-700 font-bold mb-2" for="repo_id">
+                    Repo ID
+                </label>
+                <div class="flex">
+                    <input class="shadow appearance-none border rounded w-full py-2 px-3 text-gray-700 leading-tight focus:outline-none focus:shadow-outline" id="repo_id" type="text" value="Agents-MCP-Hackathon/calculator-mcp-marcodsn">
+                    <button class="bg-blue-500 hover:bg-blue-700 text-white font-bold py-2 px-4 rounded ml-2" id="search">
+                        Search
+                    </button>
+                </div>
+            </div>
+            <div class="mb-4">
+                <label class="block text-gray-700 font-bold mb-2" for="api_name">
+                    API Name
+                </label>
+                <input class="shadow appearance-none border rounded w-full py-2 px-3 text-gray-700 leading-tight focus:outline-none focus:shadow-outline" id="api_name" type="text" value="predict">
+            </div>
+            <div class="mb-4">
+                <label class="block text-gray-700 font-bold mb-2" for="args">
+                    Arguments (JSON)
+                </label>
+                <textarea class="shadow appearance-none border rounded w-full py-2 px-3 text-gray-700 leading-tight focus:outline-none focus:shadow-outline" id="args" rows="3">["1 + 2"]</textarea>
+            </div>
+            <button class="bg-blue-500 hover:bg-blue-700 text-white font-bold py-2 px-4 rounded focus:outline-none focus:shadow-outline disabled:opacity-50 disabled:cursor-not-allowed" id="submit">
+                Submit
+            </button>
+            <div class="mt-4">
+                <h2 class="text-xl font-bold mb-2">Result</h2>
+                <pre class="bg-gray-200 p-4 rounded" id="result"></pre>
+                <div class="hidden" id="loading">Loading...</div>
+            </div>
+        </div>
+    </div>
+    <script type="module">
+        import { client } from "https://cdn.jsdelivr.net/npm/@gradio/client/dist/index.min.js";
+
+        const searchButton = document.getElementById("search");
+        const submitButton = document.getElementById("submit");
+        const repoIdInput = document.getElementById("repo_id");
+        const apiNameInput = document.getElementById("api_name");
+        const argsInput = document.getElementById("args");
+        const resultDiv = document.getElementById("result");
+        const loadingDiv = document.getElementById("loading");
+
+        searchButton.addEventListener("click", async () => {
+            const repoId = repoIdInput.value;
+            const app = await client(repoId);
+            const apiInfo = await app.view_api();
+            
+            if (apiInfo.named_endpoints.length > 0) {
+                const firstApiName = apiInfo.named_endpoints[0].name;
+                apiNameInput.value = firstApiName;
+
+                const exampleArgs = apiInfo.named_endpoints[0].parameters.map(p => JSONSchemaFaker.generate(p.component_schema));
+                argsInput.value = JSON.stringify(exampleArgs);
+            } else if (apiInfo.unnamed_endpoints.length > 0) {
+                apiNameInput.value = apiInfo.unnamed_endpoints[0].name;
+
+                const exampleArgs = apiInfo.unnamed_endpoints[0].parameters.map(p => JSONSchemaFaker.generate(p.component_schema));
+                argsInput.value = JSON.stringify(exampleArgs);
+            }
+        });
+
+        submitButton.addEventListener("click", async () => {
+            const repoId = repoIdInput.value;
+            const apiName = apiNameInput.value;
+            const args = JSON.parse(argsInput.value);
+
+            submitButton.disabled = true;
+            loadingDiv.classList.remove("hidden");
+            resultDiv.classList.add("hidden");
+
+            const response = await fetch(`/gp/${repoId}/${apiName}`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json"
+                },
+                body: JSON.stringify({ args })
+            });
+
+            const result = await response.json();
+            resultDiv.textContent = JSON.stringify(result, null, 2);
+
+            submitButton.disabled = false;
+            loadingDiv.classList.add("hidden");
+            resultDiv.classList.remove("hidden");
+        });
+    </script>
+</body>
+</html>

models_config.py

@@ -0,0 +1,60 @@
+# models_config.py
+
+CANONICAL_MODELS = {
+    "all-MiniLM-L6-v2": {
+        "name": "sentence-transformers/all-MiniLM-L6-v2",
+        "dimension": 384,
+        "requires_remote_code": False,
+        "max_tokens": 512,
+    },
+    "gte-multilingual-base": {
+        "name": "Alibaba-NLP/gte-multilingual-base",
+        "dimension": 768,
+        "requires_remote_code": True,
+        "max_tokens": 8192,
+    },
+    "nomic-embed-text-v1.5": {
+        "name": "nomic-ai/nomic-embed-text-v1.5",
+        "dimension": 768,
+        "requires_remote_code": True,
+        "max_tokens": 8192,
+        "instruction_prefix_required": True,
+        "default_instruction_prefix": "search_document:",
+        "known_instruction_prefixes": [
+            "search_document:",
+            "search_query:",
+            "clustering:",
+            "classification:",
+        ],
+    },
+    "all-mpnet-base-v2": {
+        "name": "sentence-transformers/all-mpnet-base-v2",
+        "dimension": 768,
+        "requires_remote_code": False,
+        "max_tokens": 384,
+    },
+}
+
+# Mapping of aliases to their canonical model names
+MODEL_ALIASES = {
+    "all-minilm": "all-MiniLM-L6-v2",
+    "text-embedding-3-small": "all-MiniLM-L6-v2",
+    "text-embedding-3-large": "gte-multilingual-base",
+    "nomic-embed-text": "nomic-embed-text-v1.5",
+}
+
+# This global MODELS dictionary will be used for listing available models and validation.
+# It combines canonical names and aliases for easy lookup.
+MODELS = {**CANONICAL_MODELS, **{alias: CANONICAL_MODELS[canonical] for alias, canonical in MODEL_ALIASES.items()}}
+
+def get_model_config(requested_model_name: str) -> dict:
+    """
+    Resolves a requested model name (which might be an alias) to its canonical
+    configuration. Raises ValueError if the model is not found.
+    """
+    canonical_name = MODEL_ALIASES.get(requested_model_name, requested_model_name)
+    
+    if canonical_name not in CANONICAL_MODELS:
+        raise ValueError(f"Model '{requested_model_name}' (canonical: '{canonical_name}') is not a recognized model.")
+    
+    return CANONICAL_MODELS[canonical_name]

requirements.txt

@@ -0,0 +1,6 @@
+fastapi>=0.116.1
+uvicorn>=0.35.0
+gradio>=5.43.1
+gradio-client>=1.12.1
+httpx>=0.28.1
+websockets>=15.0

static/index.html

@@ -0,0 +1,142 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Embedding Demo</title>
+    <!-- Include Tailwind CSS via CDN -->
+    <script src="https://cdn.tailwindcss.com"></script>
+    <!-- Include Heroicons for the copy icon -->
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0/css/all.min.css">
+</head>
+<body class="bg-gray-100 flex items-center justify-center min-h-screen">
+    <div class="bg-white p-8 rounded-lg shadow-md w-full max-w-md">
+        <h1 class="text-2xl font-bold mb-6 text-center">Embedding Demo</h1>
+        <div class="mb-4">
+            <label for="inputText" class="block text-gray-700 text-sm font-bold mb-2">Enter Text:</label>
+            <textarea id="inputText" class="shadow appearance-none border rounded w-full py-2 px-3 text-gray-700 leading-tight focus:outline-none focus:shadow-outline" rows="4" placeholder="Enter text to embed..."></textarea>
+        </div>
+        <div class="mb-6">
+            <label for="modelSelect" class="block text-gray-700 text-sm font-bold mb-2">Select Model:</label>
+            <select id="modelSelect" class="shadow appearance-none border rounded w-full py-2 px-3 text-gray-700 leading-tight focus:outline-none focus:shadow-outline">
+                <!-- Options will be populated by JavaScript -->
+            </select>
+        </div>
+        <div class="flex items-center justify-between">
+            <button id="embedButton" class="bg-blue-500 hover:bg-blue-700 text-white font-bold py-2 px-4 rounded focus:outline-none focus:shadow-outline disabled:opacity-50 disabled:cursor-not-allowed">
+                Get Embedding
+            </button>
+        </div>
+        <div class="mt-6">
+            <label class="block text-gray-700 text-sm font-bold mb-2">Embedding Result:</label>
+            <div class="flex items-center bg-gray-200 rounded">
+                <div id="result" class="p-4 text-gray-800 text-sm overflow-auto max-h-60 flex-grow">
+                    <p>Embedding result will appear here...</p>
+                </div>
+                <button id="copyButton" class="p-4 self-start text-gray-600 hover:text-gray-800 focus:outline-none">
+                    <i class="fas fa-copy"></i>
+                </button>
+            </div>
+        </div>
+    </div>
+
+    <script>
+        document.addEventListener('DOMContentLoaded', async () => {
+            const modelSelect = document.getElementById('modelSelect');
+
+            try {
+                const response = await fetch('/v1/models');
+                if (!response.ok) {
+                    throw new Error(`HTTP error! status: ${response.status}`);
+                }
+                const data = await response.json();
+
+                // Clear existing options
+                modelSelect.innerHTML = '';
+
+                // Populate dropdown with models
+                data.data.forEach(model => {
+                    const option = document.createElement('option');
+                    option.value = model.id;
+                    option.textContent = model.id;
+                    modelSelect.appendChild(option);
+                });
+
+            } catch (error) {
+                console.error('Error fetching models:', error);
+                // Optionally, add an error message to the dropdown or a separate element
+                const option = document.createElement('option');
+                option.value = '';
+                option.textContent = 'Error loading models';
+                modelSelect.appendChild(option);
+            }
+        });
+
+
+        document.getElementById('embedButton').addEventListener('click', async () => {
+            const inputText = document.getElementById('inputText').value;
+            const model = document.getElementById('modelSelect').value;
+            const resultDiv = document.getElementById('result');
+            const copyButton = document.getElementById('copyButton');
+            const embedButton = document.getElementById('embedButton'); // Get button reference
+
+            if (!inputText) {
+                resultDiv.textContent = 'Please enter some text.';
+                return;
+            }
+
+            resultDiv.textContent = 'Fetching embedding...';
+            copyButton.style.display = 'none'; // Hide copy button while fetching
+            embedButton.disabled = true; // Disable button
+
+            try {
+                const response = await fetch('/v1/embeddings', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({
+                        input: inputText,
+                        model: model,
+                        encoding_format: 'float' // Assuming 'float' is the only supported format
+                    }),
+                });
+
+                if (!response.ok) {
+                    const error = await response.json();
+                    throw new Error(`HTTP error! status: ${response.status}, detail: ${error.detail}`);
+                }
+
+                const data = await response.json();
+                resultDiv.textContent = JSON.stringify(data, null, 2); // Display pretty-printed JSON
+                copyButton.style.display = 'block'; // Show copy button after result is displayed
+
+            } catch (error) {
+                resultDiv.textContent = `Error: ${error.message}`;
+                console.error('Error fetching embedding:', error);
+                copyButton.style.display = 'none'; // Hide copy button on error
+            } finally {
+                embedButton.disabled = false; // Re-enable button
+            }
+        });
+
+        document.getElementById('copyButton').addEventListener('click', async () => {
+            const resultDiv = document.getElementById('result');
+            const textToCopy = resultDiv.textContent;
+
+            try {
+                await navigator.clipboard.writeText(textToCopy);
+                // Optional: Provide visual feedback to the user
+                alert('Copied to clipboard!');
+            } catch (err) {
+                console.error('Failed to copy text: ', err);
+                // Optional: Provide visual feedback to the user
+                alert('Failed to copy text.');
+            }
+        });
+
+        // Initially hide the copy button
+        document.getElementById('copyButton').style.display = 'none';
+    </script>
+</body>
+</html>