initial commic

app.py

@@ -1,486 +1,192 @@
 
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-KC ROBOT AI — v3.0 MAX PRO+
-- Flask server (suitable for HuggingFace Spaces / Cloud Run)
-- Backend: Google Gemini (via google.generativeai if available) OR REST fallback (not implemented)
-- TTS: ElevenLabs (preferred, set ELEVEN_API_KEY + voice ids) OR gTTS fallback
-- Endpoints:
-    GET  /                -> simple terminal-style UI
-    POST /api/chat        -> {"message": "..."}  -> returns {"reply": "...", "audio": base64_mp3}
-    POST /notify          -> {"event":"", "msg":""} -> forwarded to telegram
-    GET  /play_latest     -> returns latest saved mp3
-    GET  /poll            -> device poll for queued command (simple)
-    POST /api/sensor      -> sensor updates from ESP32
-- Secrets (env / HF Secrets):
-    GEMINI_API_KEY, GEMINI_MODEL (default gemini-2.5-flash)
-    TELEGRAM_TOKEN, TELEGRAM_CHAT_ID
-    ELEVEN_API_KEY (optional)
-    ELEVEN_VOICE_ID_VN (optional - female Vietnamese)
-    ELEVEN_VOICE_ID_EN (optional - female English)
-"""
-import os
-import io
-import re
-import time
-import json
-import base64
-import logging
-import tempfile
-import threading
-from datetime import datetime
-from functools import wraps
 
-from flask import Flask, request, jsonify, render_template_string, send_file
+# ==========================================================
+#  KC ROBOT AI - APP.PY (V2.0 MAX FINAL)
+#  Cloud AI Robot with Gemini 2.5 Flash + ESP32 + Telegram
+# ==========================================================
 
-# Optional SDK for Gemini
-GENAI_IMPORTED = False
-try:
-    # google.generativeai available in requirements
-    import google.generativeai as genai
-    GENAI_IMPORTED = True
-except Exception:
-    GENAI_IMPORTED = False
-
-# TTS libraries
-from gtts import gTTS
+from flask import Flask, request, jsonify, render_template_string
+from google import genai
 import requests
+import os
+import time
+from gtts import gTTS
+from langdetect import detect
+import tempfile
+import base64
 
-# language detect
-from langdetect import detect as langdetect_detect
-
-# -------------------------
-# Basic logging
-# -------------------------
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger("kcrobot_v3_pro")
-
-# -------------------------
-# CONFIG (ENV / Secrets)
-# -------------------------
-GEMINI_API_KEY = os.getenv("GEMINI_API_KEY", "").strip()
-GEMINI_MODEL = os.getenv("GEMINI_MODEL", "gemini-2.5-flash").strip()
-TELEGRAM_TOKEN = os.getenv("TELEGRAM_TOKEN", "").strip()
-TELEGRAM_CHAT_ID = os.getenv("TELEGRAM_CHAT_ID", "").strip()
-
-# ElevenLabs (optional) - if provided we will use it for nicer voice
-ELEVEN_API_KEY = os.getenv("ELEVEN_API_KEY", "").strip()
-ELEVEN_VOICE_ID_VN = os.getenv("ELEVEN_VOICE_ID_VN", "").strip()  # e.g. 'voice-id-vn-female'
-ELEVEN_VOICE_ID_EN = os.getenv("ELEVEN_VOICE_ID_EN", "").strip()  # e.g. 'voice-id-en-female'
-
-# Data & storage
-BASE = os.getcwd()
-DATA_DIR = os.path.join(BASE, "data")
-os.makedirs(DATA_DIR, exist_ok=True)
-LATEST_MP3_PATH = os.path.join(DATA_DIR, "latest_reply.mp3")
-PENDING_CMD_PATH = os.path.join(DATA_DIR, "pending.json")
-HISTORY_PATH = os.path.join(DATA_DIR, "history.json")
+# ==========================================================
+# CONFIGURATION
+# ==========================================================
 
-# Configure genai if available
-if GENAI_IMPORTED and GEMINI_API_KEY:
-    try:
-        genai.configure(api_key=GEMINI_API_KEY)
-        logger.info("Gemini SDK configured")
-    except Exception:
-        logger.exception("Failed to configure Gemini SDK")
+# Load environment variables from secrets (Cloud Run or Hugging Face)
+GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
+GEMINI_MODEL = os.getenv("GEMINI_MODEL", "gemini-2.5-flash")
+TELEGRAM_TOKEN = os.getenv("TELEGRAM_TOKEN")
+TELEGRAM_CHAT_ID = os.getenv("TELEGRAM_CHAT_ID")
 
-# -------------------------
-# Flask app
-# -------------------------
+# Create Flask app
 app = Flask(__name__)
 
-# -------------------------
-# Helpers: JSON safe
-# -------------------------
-def load_json_safe(path, default):
-    try:
-        if os.path.exists(path):
-            with open(path, "r", encoding="utf-8") as f:
-                return json.load(f)
-    except Exception:
-        logger.exception("load_json_safe failed for %s", path)
-    return default
-
-def save_json_safe(path, data):
-    try:
-        with open(path, "w", encoding="utf-8") as f:
-            json.dump(data, f, ensure_ascii=False, indent=2)
-        return True
-    except Exception:
-        logger.exception("save_json_safe failed for %s", path)
-    return False
-
-# -------------------------
-# Language detection (better handling)
-# -------------------------
-VIET_CHAR_RE = re.compile(r"[àáạảãâầấậẩẫăằắặẳẵđèéẹẻẽêềếệểễìíịỉĩòóọỏõôồốộổỗơờớợởỡùúụủũưừứựửữỳýỵỷỹ]", re.I)
-def detect_lang(text: str) -> str:
-    if not text or not isinstance(text, str):
-        return "en"
-    if VIET_CHAR_RE.search(text):
-        return "vi"
+# ==========================================================
+# SETUP GEMINI CLIENT
+# ==========================================================
+if not GEMINI_API_KEY:
+    print("❌ ERROR: No Gemini API Key found. Please add GEMINI_API_KEY in Secrets.")
+    client = None
+else:
+    client = genai.Client(api_key=GEMINI_API_KEY)
+
+# ==========================================================
+# TELEGRAM UTILITIES
+# ==========================================================
+def send_telegram_message(text):
+    if not TELEGRAM_TOKEN or not TELEGRAM_CHAT_ID:
+        print("⚠️ Telegram not configured.")
+        return
+    url = f"https://api.telegram.org/bot{TELEGRAM_TOKEN}/sendMessage"
+    payload = {"chat_id": TELEGRAM_CHAT_ID, "text": text}
     try:
-        ld = langdetect_detect(text)
-        if ld and ld.startswith("vi"):
-            return "vi"
-        if ld and ld.startswith("en"):
-            return "en"
-        # fallback
-        return "vi" if VIET_CHAR_RE.search(text) else "en"
-    except Exception:
-        return "vi" if VIET_CHAR_RE.search(text) else "en"
-
-# -------------------------
-# Gemini wrapper
-# -------------------------
-def call_gemini(prompt: str, model: str = None, max_output_tokens: int=512, temperature: float=0.2) -> dict:
-    model = model or GEMINI_MODEL
-    if not GEMINI_API_KEY:
-        return {"ok": False, "error": "Gemini API key not configured"}
-    # Try SDK
-    if GENAI_IMPORTED:
-        try:
-            m = genai.GenerativeModel(model)
-            # use generate_content API
-            resp = m.generate_content(prompt)
-            # resp may have text
-            if hasattr(resp, "text") and resp.text:
-                return {"ok": True, "text": resp.text}
-            # try dict-like
-            try:
-                j = resp
-                if isinstance(j, dict) and "candidates" in j:
-                    cand = j.get("candidates", [])
-                    if len(cand):
-                        # try to extract text parts
-                        c0 = cand[0]
-                        content = c0.get("content")
-                        if isinstance(content, list):
-                            parts = []
-                            for p in content:
-                                if isinstance(p, dict) and "text" in p:
-                                    parts.append(p["text"])
-                            if parts:
-                                return {"ok": True, "text": "".join(parts)}
-                return {"ok": True, "text": str(resp)}
-            except Exception:
-                return {"ok": True, "text": str(resp)}
-        except Exception:
-            logger.exception("Gemini SDK call failed")
-    # Fallback: not implementing REST here to avoid accidental misuse (user should set up SDK)
-    return {"ok": False, "error": "Gemini SDK not available or call failed. Set GEMINI_API_KEY and ensure google-generativeai installed."}
-
-# -------------------------
-# Text cleaning for TTS (remove punctuation / emojis)
-# -------------------------
-# We remove characters that TTS often reads aloud (stars, markdown, urls, emoji)
-RE_EMOJI = re.compile(
-    "["
-    "\U0001F600-\U0001F64F"  # emoticons
-    "\U0001F300-\U0001F5FF"  # symbols & pictographs
-    "\U0001F680-\U0001F6FF"  # transport & map symbols
-    "\U0001F1E0-\U0001F1FF"  # flags (iOS)
-    "]+", flags=re.UNICODE)
-
-def clean_for_tts(text: str) -> str:
-    if not text:
-        return ""
-    # convert to str
-    txt = str(text)
-    # remove URLs
-    txt = re.sub(r"http\S+|www\.\S+", " ", txt)
-    # remove code blocks/backticks/markdown-ish characters
-    txt = re.sub(r"[`*_~>#\[\]\{\}\(\)=+\|\\\/\^@%$&]", " ", txt)
-    # remove emojis
-    txt = RE_EMOJI.sub(" ", txt)
-    # collapse multiple spaces
-    txt = re.sub(r"\s+", " ", txt).strip()
-    return txt
-
-# -------------------------
-# TTS backends
-# - prefer ElevenLabs when ELEVEN_API_KEY and voice id provided
-# - fallback to gTTS
-# -------------------------
-def tts_elevenlabs_bytes(text: str, voice_id: str, api_key: str) -> bytes:
-    """
-    ElevenLabs simple REST call to get MP3 bytes.
-    Requires XI-API-Key in header and returns audio/mpeg.
-    """
-    url = f"https://api.elevenlabs.io/v1/text-to-speech/{voice_id}"
-    headers = {"xi-api-key": api_key, "Content-Type": "application/json"}
-    payload = {"text": text, "voice_settings": {"stability": 0.6, "similarity_boost": 0.75}}
-    r = requests.post(url, json=payload, headers=headers, timeout=30)
-    r.raise_for_status()
-    return r.content
+        requests.post(url, json=payload, timeout=5)
+    except Exception as e:
+        print("Telegram Error:", e)
 
-def tts_gtts_bytes(text: str, lang_code: str = "vi") -> bytes:
-    t = gTTS(text=text, lang=lang_code)
-    bio = io.BytesIO()
-    t.write_to_fp(bio)
-    bio.seek(0)
-    return bio.read()
+# ==========================================================
+# GEMINI AI RESPONSE
+# ==========================================================
+def ask_gemini(prompt: str):
+    if not client:
+        return "⚠️ Gemini API key missing. Please configure in Secrets."
 
-def synthesize_save_mp3(answer: str, lang_hint: str="vi") -> (bool, str):
-    """
-    Synthesize answer to MP3, save to LATEST_MP3_PATH, return (ok, path_or_error)
-    Use ElevenLabs if available, else gTTS.
-    """
     try:
-        clean = clean_for_tts(answer)
-        if not clean:
-            clean = "..."
-        mp3_bytes = None
-        # Try ElevenLabs VN/EN if configured
-        if ELEVEN_API_KEY:
-            try:
-                # choose voice id based on lang_hint
-                vid = ELEVEN_VOICE_ID_VN if lang_hint.startswith("vi") and ELEVEN_VOICE_ID_VN else ELEVEN_VOICE_ID_EN if ELEVEN_VOICE_ID_EN else None
-                if vid:
-                    mp3_bytes = tts_elevenlabs_bytes(clean, vid, ELEVEN_API_KEY)
-                    logger.info("TTS: used ElevenLabs voice %s", vid)
-            except Exception:
-                logger.exception("ElevenLabs TTS failed -> fallback to gTTS")
-                mp3_bytes = None
-        if mp3_bytes is None:
-            lang_code = "vi" if lang_hint.startswith("vi") else "en"
-            mp3_bytes = tts_gtts_bytes(clean, lang_code)
-            logger.info("TTS: used gTTS lang=%s", lang_code)
-        with open(LATEST_MP3_PATH, "wb") as f:
-            f.write(mp3_bytes)
-        return True, LATEST_MP3_PATH
+        response = client.models.generate_content(
+            model=GEMINI_MODEL,
+            contents=prompt
+        )
+        if hasattr(response, "text"):
+            return response.text.strip()
+        elif "text" in response:
+            return response["text"].strip()
+        else:
+            return "⚠️ No response text from Gemini."
     except Exception as e:
-        logger.exception("synthesize_save_mp3 failed")
-        return False, str(e)
+        print("Gemini Error:", e)
+        return f"⚠️ Gemini Error: {e}"
 
-# -------------------------
-# Telegram notify helper
-# -------------------------
-def send_telegram(text: str):
-    if not TELEGRAM_TOKEN or not TELEGRAM_CHAT_ID:
-        logger.debug("Telegram not configured")
-        return False
+# ==========================================================
+# LANGUAGE DETECTION & TTS
+# ==========================================================
+def text_to_speech(text):
     try:
-        url = f"https://api.telegram.org/bot{TELEGRAM_TOKEN}/sendMessage"
-        r = requests.post(url, json={"chat_id": TELEGRAM_CHAT_ID, "text": text}, timeout=8)
-        return r.status_code == 200
-    except Exception:
-        logger.exception("send_telegram failed")
-        return False
-
-# -------------------------
-# Pending command helpers (simple queue for ESP32 poll)
-# -------------------------
-def queue_command(cmd: dict):
-    pending = load_json_safe(PENDING_CMD_PATH, [])
-    pending.append({"ts": time.time(), "cmd": cmd})
-    # keep only last 10
-    pending = pending[-10:]
-    save_json_safe(PENDING_CMD_PATH, pending)
-    logger.info("Queued command: %s", cmd)
-
-def pop_pending():
-    pending = load_json_safe(PENDING_CMD_PATH, [])
-    if not pending:
+        lang = detect(text)
+        if lang not in ["vi", "en"]:
+            lang = "en"
+        tts = gTTS(text=text, lang=lang)
+        tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".mp3")
+        tts.save(tmp.name)
+        with open(tmp.name, "rb") as f:
+            audio_b64 = base64.b64encode(f.read()).decode("utf-8")
+        os.unlink(tmp.name)
+        return audio_b64
+    except Exception as e:
+        print("TTS Error:", e)
         return None
-    item = pending.pop(0)
-    save_json_safe(PENDING_CMD_PATH, pending)
-    return item
 
-# -------------------------
-# History save
-# -------------------------
-def append_history(entry: dict):
-    h = load_json_safe(HISTORY_PATH, [])
-    h.append(entry)
-    if len(h) > 1000:
-        h = h[-1000:]
-    save_json_safe(HISTORY_PATH, h)
-
-# -------------------------
-# Simple terminal-style UI (developer mode)
-# -------------------------
-TERMINAL_HTML = """
-<!doctype html>
+# ==========================================================
+# SIMPLE HTML INTERFACE (for testing)
+# ==========================================================
+HTML_PAGE = """
+<!DOCTYPE html>
 <html>
 <head>
-  <meta charset="utf-8">
-  <title>KC ROBOT AI — v3.0 MAX PRO+</title>
-  <style>
-    body{background:#0b1221;color:#cfe7ff;font-family:monospace;padding:14px}
-    #console{background:#061020;padding:12px;border-radius:6px;height:60vh;overflow:auto}
-    .ts{color:#7fbfff}
-    .user{color:#7fff7f}
-    .bot{color:#ffdf7f}
-    .sys{color:#ff8a8a}
-    input{width:60%;padding:8px;margin:6px}
-    button{padding:8px;border-radius:6px}
-  </style>
+<title>KC Robot AI v2.0</title>
+<style>
+body { font-family: Arial; text-align: center; background-color: #101010; color: white; }
+input, button { padding: 10px; font-size: 16px; margin: 5px; }
+#chat { max-width: 700px; margin: auto; text-align: left; background: #202020; padding: 20px; border-radius: 10px; }
+.msg-user { color: #4af; }
+.msg-bot { color: #fa4; margin-left: 20px; }
+audio { margin-top: 10px; }
+</style>
 </head>
 <body>
-  <h2>KC ROBOT AI — v3.0 MAX PRO+</h2>
-  <div id="console"></div>
-  <p>
-    <input id="txt" placeholder="Nhập / Ask..." />
-    <button onclick="send()">Send</button>
-    <button onclick="poll()">Poll pending</button>
-  </p>
+<h1>🤖 KC Robot AI v2.0 MAX FINAL</h1>
+<div id="chat"></div>
+<br>
+<input id="user_input" placeholder="Nói gì đó..." style="width:60%">
+<button onclick="sendMessage()">Gửi</button>
+
 <script>
-async function log(kind, text){
-  const c = document.getElementById("console");
-  const ts = new Date().toLocaleTimeString();
-  const cls = kind === 'user' ? 'user' : (kind === 'bot' ? 'bot' : 'sys');
-  c.innerHTML += `<div><span class="ts">[${ts}]</span> <span class="${cls}">${text}</span></div>`;
-  c.scrollTop = c.scrollHeight;
-}
-async function send(){
-  const v = document.getElementById("txt").value;
-  if(!v) return;
-  await log('user', 'You: ' + v);
-  document.getElementById("txt").value = '';
-  const res = await fetch('/api/chat',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({message:v})});
-  const j = await res.json();
-  await log('bot', 'Robot: ' + j.reply);
-}
-async function poll(){
-  const r = await fetch('/poll');
-  const j = await r.json();
-  await log('sys', 'POLLED: ' + JSON.stringify(j));
+async function sendMessage() {
+  const input = document.getElementById("user_input").value;
+  if (!input) return;
+  const chat = document.getElementById("chat");
+  chat.innerHTML += `<div class='msg-user'><b>Bạn:</b> ${input}</div>`;
+  document.getElementById("user_input").value = "";
+  const res = await fetch("/api/chat", {
+    method: "POST",
+    headers: {"Content-Type": "application/json"},
+    body: JSON.stringify({message: input})
+  });
+  const data = await res.json();
+  chat.innerHTML += `<div class='msg-bot'><b>Robot:</b> ${data.reply}</div>`;
+  if (data.audio) {
+    const audio = document.createElement("audio");
+    audio.src = "data:audio/mp3;base64," + data.audio;
+    audio.controls = true;
+    chat.appendChild(audio);
+  }
+  chat.scrollTop = chat.scrollHeight;
 }
 </script>
 </body>
 </html>
 """
 
-@app.route("/", methods=["GET"])
-def index_ui():
-    return render_template_string(TERMINAL_HTML)
+@app.route("/")
+def home():
+    return render_template_string(HTML_PAGE)
+
+# ==========================================================
+# API ENDPOINTS
+# ==========================================================
 
-# -------------------------
-# API: /api/chat
-# -------------------------
 @app.route("/api/chat", methods=["POST"])
 def api_chat():
-    data = request.get_json(silent=True) or {}
-    msg = data.get("message") or data.get("q") or ""
-    if not msg:
-        return jsonify({"error": "missing message"}), 400
-    logger.info("User -> %s", msg[:200])
-    # notify telegram user query (non-blocking)
-    try:
-        threading.Thread(target=send_telegram, args=(f"👤 User: {msg}",)).start()
-    except Exception:
-        pass
-
-    # send prompt to Gemini
-    res = call_gemini(msg)
-    if not res.get("ok"):
-        text = f"[Gemini error] {res.get('error')}"
-    else:
-        text = res.get("text", "")
-    lang = detect_lang(text)
-    clean_text = clean_for_tts(text)
-    # save history
-    append_history({"ts": time.time(), "user": msg, "reply": text, "lang": lang})
-    # synthesize
-    ok, path_or_err = synthesize_save_mp3(clean_text, lang_hint=lang)
-    if ok:
-        # send telegram with reply and notify
-        try:
-            threading.Thread(target=send_telegram, args=(f"🤖 Robot: {clean_text}",)).start()
-        except Exception:
-            pass
-        # read mp3 bytes and return base64 to client
-        try:
-            with open(path_or_err, "rb") as f:
-                audio_b64 = base64.b64encode(f.read()).decode("utf-8")
-        except Exception:
-            logger.exception("reading mp3 failed")
-            audio_b64 = None
-        return jsonify({"reply": clean_text, "audio": audio_b64})
-    else:
-        logger.warning("TTS failed: %s", path_or_err)
-        return jsonify({"reply": clean_text, "audio": None, "error": path_or_err})
+    data = request.get_json()
+    if not data or "message" not in data:
+        return jsonify({"error": "Missing 'message'"}), 400
 
-# -------------------------
-# /play_latest -> stream saved mp3
-# -------------------------
-@app.route("/play_latest", methods=["GET"])
-def play_latest():
-    if not os.path.exists(LATEST_MP3_PATH):
-        return jsonify({"error": "no audio"}), 404
-    return send_file(LATEST_MP3_PATH, mimetype="audio/mpeg")
+    user_message = data["message"]
+    print(f"🧠 User said: {user_message}")
+    send_telegram_message(f"User: {user_message}")
 
-# -------------------------
-# /notify -> from esp32 sensors or other services
-# -------------------------
-@app.route("/notify", methods=["POST"])
-def notify():
-    data = request.get_json(silent=True) or {}
-    event = data.get("event", "event")
-    msg = data.get("msg", "")
-    logger.info("NOTIFY %s: %s", event, msg)
-    # Push into telegram
-    try:
-        threading.Thread(target=send_telegram, args=(f"[Robot Notify] {event}: {msg}",)).start()
-    except Exception:
-        pass
-    # optionally queue commands (if provided)
-    cmd = data.get("cmd")
-    if cmd:
-        queue_command(cmd)
-    return jsonify({"status": "ok"})
+    ai_reply = ask_gemini(user_message)
+    send_telegram_message(f"Robot: {ai_reply}")
 
-# -------------------------
-# /poll -> device polling for commands
-# -------------------------
-@app.route("/poll", methods=["GET"])
-def poll():
-    # return one pending command if any
-    item = pop_pending()
-    if item:
-        return jsonify(item)
-    return jsonify({})
+    audio_b64 = text_to_speech(ai_reply)
+    return jsonify({"reply": ai_reply, "audio": audio_b64})
 
-# -------------------------
-# /api/sensor -> sensor updates from ESP32
-# -------------------------
+# ESP32 sensor endpoint
 @app.route("/api/sensor", methods=["POST"])
-def api_sensor():
-    data = request.get_json(silent=True) or {}
+def sensor_data():
+    data = request.get_json()
     if not data:
-        return jsonify({"error": "no data"}), 400
-    logger.info("Sensor update: %s", data)
-    # notify telegram
-    try:
-        threading.Thread(target=send_telegram, args=(f"[Sensor] {json.dumps(data, ensure_ascii=False)}",)).start()
-    except Exception:
-        pass
-    # If sensor wants the robot to speak something, enqueue/synthesize
-    if data.get("speak"):
-        text = str(data.get("speak"))
-        # synthesize and keep latest
-        synthesize_save_mp3(text, lang_hint=detect_lang(text))
+        return jsonify({"error": "No data"}), 400
+    msg = f"👁️ ESP32 Sensor update: {data}"
+    send_telegram_message(msg)
     return jsonify({"status": "received"})
 
-# -------------------------
-# Admin/helper endpoints (optional)
-# -------------------------
-@app.route("/history", methods=["GET"])
-def get_history():
-    h = load_json_safe(HISTORY_PATH, [])
-    return jsonify(h[-200:])
+# Health check
+@app.route("/ping")
+def ping():
+    return jsonify({"status": "ok", "model": GEMINI_MODEL})
 
-# -------------------------
-# Start server
-# -------------------------
+# ==========================================================
+# MAIN ENTRY POINT
+# ==========================================================
 if __name__ == "__main__":
-    logger.info("Starting KC ROBOT AI v3.0 MAX PRO+ (port %s)", os.getenv("PORT", "8080"))
-    # ensure default files exist
-    if not os.path.exists(PENDING_CMD_PATH):
-        save_json_safe(PENDING_CMD_PATH, [])
-    if not os.path.exists(HISTORY_PATH):
-        save_json_safe(HISTORY_PATH, [])
-    # run
-    app.run(host="0.0.0.0", port=int(os.getenv("PORT", "8080")))
+    port = int(os.getenv("PORT", 8080))
+    print(f"🚀 KC Robot AI v2.0 running on port {port}")
+    app.run(host="0.0.0.0", port=port)
+