Update app.py

app.py

@@ -1,471 +1,189 @@
-from flask import Flask, request, jsonify
-import requests
-import random
-import string
+from flask import Flask, jsonify
+import threading
 import time
-import json
+import requests
+from datetime import datetime
+import logging
 
-app = Flask(__name__)
+# Setup logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
 
-# Global variables to store workspace and bot IDs
-GLOBAL_WORKSPACE_ID = None
-GLOBAL_BOT_ID = None
-
-
-# Authorization value used in requests (should be updated with a valid Authorization),
-TOKEN = "Bearer bp_pat_vTuxol25N0ymBpYaWqtWpFfGPKt260IfT784"
-# -------------------------------------------------------------------
-# Helper functions for random bot/workspace names
-# -------------------------------------------------------------------
-def generate_random_name(length=5):
-    """Generate a random name for workspace or bot"""
-    return ''.join(random.choices(string.ascii_letters, k=length))
-
-# -------------------------------------------------------------------
-# Functions to create/delete workspaces and bots
-# -------------------------------------------------------------------
-def create_workspace():
-    """Create a new workspace and return its ID"""
-    ws_url = "https://api.botpress.cloud/v1/admin/workspaces"
-    headers = {
-        "User-Agent": "Mozilla/5.0",
-        "Authorization": TOKEN
-    }
-    payload = {"name": generate_random_name()}
+app = Flask(__name__)
 
+# ============ CONFIG ============
+NUM_SERVERS = 55  # serverclass1 to serverclass55
+PING_INTERVAL = 300  # seconds (5 minutes) - like cron-job.org
+REQUEST_TIMEOUT = 30
+
+# Templates for serverclassN URLs
+SERVERCLASS_TEMPLATES = [
+    "https://serverclass{n}-claude-4-6-opus.hf.space/health",
+    "https://serverclass{n}-gpt-5-4.hf.space/health",
+    "https://serverclass{n}-tts.hf.space/health",
+    "https://serverclass{n}-transcript.hf.space/health",
+]
+
+# Extra fixed URLs
+EXTRA_URLS = [
+    "https://dooratre-backup.hf.space/health",
+    "https://dooratre-reload-bot.hf.space/health",
+]
+
+
+def build_urls():
+    urls = []
+    for n in range(1, NUM_SERVERS + 1):
+        for tpl in SERVERCLASS_TEMPLATES:
+            urls.append(tpl.format(n=n))
+    urls.extend(EXTRA_URLS)
+    return urls
+
+
+ALL_URLS = build_urls()
+
+# ============ STATE ============
+state = {
+    "running": False,
+    "thread": None,
+    "lock": threading.Lock(),
+    "stop_event": threading.Event(),
+    "last_cycle_start": None,
+    "last_cycle_end": None,
+    "cycles_completed": 0,
+    "total_pings": 0,
+    "success_count": 0,
+    "fail_count": 0,
+    "last_results": {},
+}
+
+
+def ping_url(url):
     try:
-        response = requests.post(ws_url, headers=headers, json=payload)
-        if response.status_code == 200:
-            response_json = response.json()
-            workspace_id = response_json.get('id')
-            print(f"Successfully created workspace: {workspace_id}")
-            return workspace_id
-        else:
-            print(f"Workspace creation failed with: {response.status_code}, {response.text}")
-            return None
+        r = requests.get(url, timeout=REQUEST_TIMEOUT)
+        ok = r.status_code == 200
+        return ok, r.status_code, None
     except Exception as e:
-        print(f"Error creating workspace: {str(e)}")
-        return None
-
-
-def create_bot(workspace_id):
-    """Create a new bot in the specified workspace and return its ID"""
-    if not workspace_id:
-        print("Cannot create bot: No workspace ID provided")
-        return None
-
-    bot_url = "https://api.botpress.cloud/v1/admin/bots"
-    headers = {
-        "User-Agent": "Mozilla/5.0",
-        "x-workspace-id": workspace_id,
-        "Authorization": TOKEN,
-        "Content-Type": "application/json"
-    }
-    payload = {"name": generate_random_name()}
-
-    try:
-        response = requests.post(bot_url, headers=headers, json=payload)
-        if response.status_code == 200:
-            response_json = response.json()
-            bot_id = response_json.get("bot", {}).get("id")
-            if not bot_id:
-                print("Bot ID not found in the response.")
-                return None
-
-            print(f"Successfully created bot: {bot_id} in workspace: {workspace_id}")
-
-            # Install integration for the new bot
-            integration_success = install_bot_integration(bot_id, workspace_id)
-            if integration_success:
-                print(f"Successfully installed integration for bot {bot_id}")
-                return bot_id
+        return False, None, str(e)
+
+
+def cron_worker(stop_event: threading.Event):
+    logger.info(f"Cron worker started. Total URLs: {len(ALL_URLS)}")
+    while not stop_event.is_set():
+        cycle_start = datetime.utcnow().isoformat()
+        state["last_cycle_start"] = cycle_start
+        logger.info(f"=== Cycle started at {cycle_start} ===")
+
+        for url in ALL_URLS:
+            if stop_event.is_set():
+                logger.info("Stop event received, breaking cycle.")
+                break
+            ok, status, err = ping_url(url)
+            state["total_pings"] += 1
+            if ok:
+                state["success_count"] += 1
+                logger.info(f"[OK {status}] {url}")
             else:
-                print(f"Failed to install integration for bot {bot_id}")
-                return bot_id  # Still return the bot ID even if integration fails
-        else:
-            print(f"Bot creation failed with: {response.status_code}, {response.text}")
-            return None
-    except Exception as e:
-        print(f"Error creating bot: {str(e)}")
-        return None
-
-
-def install_bot_integration(bot_id, workspace_id):
-    """Install required integration for the bot to function properly"""
-    if not bot_id or not workspace_id:
-        print("Cannot install integration: Missing bot ID or workspace ID")
-        return False
-
-    url = f"https://api.botpress.cloud/v1/admin/bots/{bot_id}"
-    headers = {
-        "User-Agent": "Mozilla/5.0",
-        "Authorization": TOKEN,
-        "Content-Type": "application/json",
-        "x-bot-id": bot_id,
-        "x-workspace-id": workspace_id
-    }
-    # Integration payload
-    payload = {
-        "integrations": {
-            "intver_01KKY7XBSZXB1P9GDV5F1KQ4NB": {
-                "enabled": True
+                state["fail_count"] += 1
+                logger.warning(f"[FAIL {status}] {url} | err={err}")
+            state["last_results"][url] = {
+                "ok": ok,
+                "status": status,
+                "error": err,
+                "time": datetime.utcnow().isoformat(),
             }
-        }
-    }
 
-    try:
-        response = requests.put(url, headers=headers, json=payload)
-        if response.status_code == 200:
-            print(f"Successfully installed integration for bot {bot_id}")
-            return True
-        else:
-            print(f"Failed to install integration: {response.status_code}, {response.text}")
-            return False
-    except Exception as e:
-        print(f"Error installing integration: {str(e)}")
-        return False
+        state["cycles_completed"] += 1
+        state["last_cycle_end"] = datetime.utcnow().isoformat()
+        logger.info(f"=== Cycle done. Sleeping {PING_INTERVAL}s ===")
+
+        # Sleep but be responsive to stop_event
+        stop_event.wait(PING_INTERVAL)
+
+    logger.info("Cron worker stopped.")
+
+
+@app.route("/")
+def index():
+    return jsonify({
+        "service": "Cron-like pinger",
+        "running": state["running"],
+        "total_urls": len(ALL_URLS),
+        "endpoints": ["/start", "/end", "/status", "/urls"],
+    })
+
+
+@app.route("/start", methods=["GET", "POST"])
+def start():
+    with state["lock"]:
+        if state["running"]:
+            return jsonify({"status": "already_running"}), 200
+
+        state["stop_event"] = threading.Event()
+        t = threading.Thread(target=cron_worker, args=(state["stop_event"],), daemon=True)
+        state["thread"] = t
+        state["running"] = True
+        t.start()
+        logger.info("Cron started via /start")
+        return jsonify({
+            "status": "started",
+            "total_urls": len(ALL_URLS),
+            "interval_seconds": PING_INTERVAL,
+        })
 
 
-def try_delete_bot(bot_id, workspace_id):
-    """Attempt to delete a bot from the specified workspace but continue if it fails"""
-    if not bot_id or not workspace_id:
-        print("Cannot delete bot: Missing bot ID or workspace ID")
-        return False
+@app.route("/end", methods=["GET", "POST"])
+def end():
+    with state["lock"]:
+        if not state["running"]:
+            return jsonify({"status": "not_running"}), 200
 
-    url = f"https://api.botpress.cloud/v1/admin/bots/{bot_id}"
-    headers = {
-        "User-Agent": "Mozilla/5.0",
-        "x-workspace-id": workspace_id,
-        "Authorization": TOKEN
-    }
+        state["stop_event"].set()
+        state["running"] = False
+        logger.info("Cron stop requested via /end")
+        return jsonify({"status": "stopping"})
 
-    try:
-        response = requests.delete(url, headers=headers)
-        if response.status_code in [200, 204]:
-            print(f"Successfully deleted bot: {bot_id}")
-            return True
-        else:
-            print(f"Failed to delete bot: {response.status_code}, {response.text}")
-            return False
-    except Exception as e:
-        print(f"Error deleting bot: {str(e)}")
-        return False
 
+@app.route("/status")
+def status():
+    return jsonify({
+        "running": state["running"],
+        "total_urls": len(ALL_URLS),
+        "cycles_completed": state["cycles_completed"],
+        "total_pings": state["total_pings"],
+        "success_count": state["success_count"],
+        "fail_count": state["fail_count"],
+        "last_cycle_start": state["last_cycle_start"],
+        "last_cycle_end": state["last_cycle_end"],
+        "interval_seconds": PING_INTERVAL,
+    })
 
-def try_delete_workspace(workspace_id):
-    """Attempt to delete a workspace but continue if it fails"""
-    if not workspace_id:
-        print("Cannot delete workspace: No workspace ID provided")
-        return False
 
-    url = f"https://api.botpress.cloud/v1/admin/workspaces/{workspace_id}"
-    headers = {
-        "User-Agent": "Mozilla/5.0",
-        "Authorization": TOKEN
-    }
+@app.route("/urls")
+def urls():
+    return jsonify({"count": len(ALL_URLS), "urls": ALL_URLS})
 
-    try:
-        response = requests.delete(url, headers=headers)
-        if response.status_code in [200, 204]:
-            print(f"Successfully deleted workspace: {workspace_id}")
-            return True
-        else:
-            print(f"Failed to delete workspace: {response.status_code}, {response.text}")
-            return False
-    except Exception as e:
-        print(f"Error deleting workspace: {str(e)}")
-        return False
-
-
-# -------------------------------------------------------------------
-# Main function that calls the Botpress API endpoint
-# -------------------------------------------------------------------
-def chat_with_assistant(user_input, chat_history, bot_id, workspace_id, temperature=0.9, top_p=0.95, max_tokens=None):
-    """
-    Sends the user input and chat history to the Botpress API endpoint,
-    returns the assistant's response and (possibly updated) bot/workspace IDs.
-    """
-    # Prepare the headers
-    headers = {
-        "User-Agent": "Mozilla/5.0",
-        "x-bot-id": bot_id,
-        "Content-Type": "application/json",
-        "Authorization": TOKEN
-    }
-
-    # Process chat history into the format expected by the API
-    messages = []
-    system_prompt = ""
-
-    for msg in chat_history:
-        if msg["role"] == "system":
-            system_prompt = msg["content"]
-        elif msg["role"] in ["user", "assistant"]:
-            # Pass multipart messages directly without modifying their structure
-            if "type" in msg and msg["type"] == "multipart" and "content" in msg:
-                messages.append(msg)  # Keep the original multipart structure
-            # Handle regular text messages
-            else:
-                messages.append({
-                    "role": msg["role"],
-                    "content": msg["content"]
-                })
-
-    # Add the latest user input if not already in chat history
-    if user_input and isinstance(user_input, str) and (not messages or messages[-1]["role"] != "user" or messages[-1]["content"] != user_input):
-        messages.append({
-            "role": "user",
-            "content": user_input
-        })
 
-    # Prepare the payload for the API
-    payload = {
-        "type": "openai:generateContent",
-        "input": {
-            "model": {
-                "id": "gpt-5.4-2026-03-05"
-            },
-            "systemPrompt": system_prompt,
-            "messages": messages,
-            "temperature": temperature,
-            "debug": False,
-        }
-    }
-
-    # Add maxTokens to the payload if provided
-    if max_tokens is not None:
-        payload["input"]["maxTokens"] = max_tokens
-
-    botpress_url = "https://api.botpress.cloud/v1/chat/actions"
-    max_retries = 3
-    timeout = 120  # Increased timeout for long messages
-
-    # For debugging
-    print("Payload being sent to Botpress:")
-    print(json.dumps(payload, indent=2))
-
-    # Attempt to send the request
-    for attempt in range(max_retries):
-        try:
-            print(f"Attempt {attempt+1}: Sending request to Botpress API with bot_id={bot_id}, workspace_id={workspace_id}")
-            response = requests.post(botpress_url, json=payload, headers=headers, timeout=timeout)
-
-            # If successful (200)
-            if response.status_code == 200:
-                data = response.json()
-                assistant_content = data.get('output', {}).get('choices', [{}])[0].get('content', '')
-                print(f"Successfully received response from Botpress API")
-                return assistant_content, bot_id, workspace_id
-
-            # Check for authentication or permission errors (401, 403)
-            elif response.status_code in [401, 403]:
-                error_message = "Authentication error"
-                try:
-                    error_data = response.json()
-                    error_message = error_data.get('message', 'Authentication error')
-                except:
-                    pass
-
-                print(f"Authentication error detected: {error_message}")
-
-                # We need to create new resources immediately
-                print("Creating new workspace and bot...")
-                new_workspace_id = create_workspace()
-                if not new_workspace_id:
-                    print("Failed to create a new workspace")
-                    if attempt < max_retries - 1:
-                        time.sleep(3)
-                        continue
-                    else:
-                        return "Unable to create new resources. Please try again later.", bot_id, workspace_id
-
-                new_bot_id = create_bot(new_workspace_id)
-                if not new_bot_id:
-                    print("Failed to create a new bot")
-                    if attempt < max_retries - 1:
-                        time.sleep(3)
-                        continue
-                    else:
-                        return "Unable to create new bot. Please try again later.", new_workspace_id, workspace_id
-
-                print(f"Created new workspace: {new_workspace_id} and bot: {new_bot_id}")
-
-                # Try again with new IDs
-                headers["x-bot-id"] = new_bot_id
-                try:
-                    print(f"Retrying with new bot_id={new_bot_id}")
-                    retry_response = requests.post(botpress_url, json=payload, headers=headers, timeout=timeout)
-
-                    if retry_response.status_code == 200:
-                        data = retry_response.json()
-                        assistant_content = data.get('output', {}).get('choices', [{}])[0].get('content', '')
-                        print(f"Successfully received response with new IDs")
-
-                        # Try to clean up old resources in the background, but don't wait for result
-                        if bot_id and workspace_id:
-                            print(f"Attempting to clean up old resources in the background")
-                            try_delete_bot(bot_id, workspace_id)
-                            try_delete_workspace(workspace_id)
-
-                        return assistant_content, new_bot_id, new_workspace_id
-                    else:
-                        print(f"Failed with new IDs: {retry_response.status_code}")
-                        if attempt < max_retries - 1:
-                            time.sleep(2)
-                            continue
-                        else:
-                            return f"Unable to get a response even with new credentials.", new_bot_id, new_workspace_id
-
-                except Exception as e:
-                    print(f"Error with new IDs: {str(e)}")
-                    if attempt < max_retries - 1:
-                        time.sleep(2)
-                        continue
-                    else:
-                        return f"Error with new credentials: {str(e)}", new_bot_id, new_workspace_id
-
-            # Handle network errors or timeouts (just retry)
-            elif response.status_code in [404, 408, 502, 503, 504]:
-                print(f"Received error {response.status_code}. Retrying...")
-                time.sleep(3)  # Wait before retrying
-                continue
-
-            # Any other error status code
-            else:
-                print(f"Received unexpected error: {response.status_code}, {response.text}")
-                if attempt < max_retries - 1:
-                    time.sleep(2)
-                    continue
-                else:
-                    return f"Unable to get a response from the assistant (Error {response.status_code}).", bot_id, workspace_id
-
-        except requests.exceptions.Timeout:
-            print(f"Request timed out. Retrying...")
-            if attempt < max_retries - 1:
-                time.sleep(2)
-                continue
-            else:
-                return "The assistant is taking too long to respond. Please try again with a shorter message.", bot_id, workspace_id
+@app.route("/results")
+def results():
+    return jsonify(state["last_results"])
 
-        except Exception as e:
-            print(f"Error during request: {str(e)}")
-            if attempt < max_retries - 1:
-                time.sleep(2)
-                continue
-            else:
-                return f"Unable to get a response from the assistant: {str(e)}", bot_id, workspace_id
-
-    # Should not reach here due to the handling in the loop
-    return "Unable to get a response from the assistant.", bot_id, workspace_id
-
-
-# -------------------------------------------------------------------
-# Flask Endpoint
-# -------------------------------------------------------------------
-@app.route("/chat", methods=["POST"])
-def chat_endpoint():
-    """
-    Expects JSON with:
-    {
-      "user_input": "string", // Can be null if multipart message is in chat_history
-      "chat_history": [
-         {"role": "system", "content": "..."},
-         {"role": "user",   "content": "..."},
-         // Or for images:
-         {"role": "user", "type": "multipart", "content": [
-            {"type": "image", "url": "https://example.com/image.jpg"},
-            {"type": "text", "text": "What's in this image?"}
-         ]},
-         ...
-      ],
-      "temperature": 0.9,  // Optional, defaults to 0.9
-      "top_p": 0.95,       // Optional, defaults to 0.95
-      "max_tokens": 1000   // Optional, defaults to null (no limit)
-    }
-    Returns JSON with:
-    {
-      "assistant_response": "string"
-    }
-    """
-    global GLOBAL_WORKSPACE_ID, GLOBAL_BOT_ID
-
-    # Parse JSON from request
-    data = request.get_json(force=True)
-    user_input = data.get("user_input", "")
-    chat_history = data.get("chat_history", [])
-
-    # Get temperature, top_p, and max_tokens from request, or use defaults
-    temperature = data.get("temperature", 0.9)
-    top_p = data.get("top_p", 0.95)
-    max_tokens = data.get("max_tokens", None)
-
-    # Validate temperature and top_p values
-    try:
-        temperature = float(temperature)
-        if not 0 <= temperature <= 2:
-            temperature = 0.9
-            print(f"Invalid temperature value. Using default: {temperature}")
-    except (ValueError, TypeError):
-        temperature = 0.9
-        print(f"Invalid temperature format. Using default: {temperature}")
 
-    try:
-        top_p = float(top_p)
-        if not 0 <= top_p <= 1:
-            top_p = 0.95
-            print(f"Invalid top_p value. Using default: {top_p}")
-    except (ValueError, TypeError):
-        top_p = 0.95
-        print(f"Invalid top_p format. Using default: {top_p}")
-
-    # Validate max_tokens if provided
-    if max_tokens is not None:
-        try:
-            max_tokens = int(max_tokens)
-            if max_tokens <= 0:
-                print("Invalid max_tokens value (must be positive). Not using max_tokens.")
-                max_tokens = None
-        except (ValueError, TypeError):
-            print("Invalid max_tokens format. Not using max_tokens.")
-            max_tokens = None
-
-    # If we don't yet have a workspace or bot, create them
-    if not GLOBAL_WORKSPACE_ID or not GLOBAL_BOT_ID:
-        print("No existing IDs found. Creating new workspace and bot...")
-        GLOBAL_WORKSPACE_ID = create_workspace()
-        if GLOBAL_WORKSPACE_ID:
-            GLOBAL_BOT_ID = create_bot(GLOBAL_WORKSPACE_ID)
-
-        # If creation failed
-        if not GLOBAL_WORKSPACE_ID or not GLOBAL_BOT_ID:
-            return jsonify({"assistant_response": "I'm currently unavailable. Please try again later."}), 500
-
-    # Call our function that interacts with Botpress API
-    print(f"Sending chat request with existing bot_id={GLOBAL_BOT_ID}, workspace_id={GLOBAL_WORKSPACE_ID}")
-    print(f"Using temperature={temperature}, top_p={top_p}, max_tokens={max_tokens}")
-
-    assistant_response, updated_bot_id, updated_workspace_id = chat_with_assistant(
-        user_input,
-        chat_history,
-        GLOBAL_BOT_ID,
-        GLOBAL_WORKSPACE_ID,
-        temperature,
-        top_p,
-        max_tokens
-    )
-
-    # Update global IDs if they changed
-    if updated_bot_id != GLOBAL_BOT_ID or updated_workspace_id != GLOBAL_WORKSPACE_ID:
-        print(f"Updating global IDs: bot_id={updated_bot_id}, workspace_id={updated_workspace_id}")
-        GLOBAL_BOT_ID = updated_bot_id
-        GLOBAL_WORKSPACE_ID = updated_workspace_id
-
-    return jsonify({"assistant_response": assistant_response})
-
-
-# -------------------------------------------------------------------
-# Run the Flask app
-# -------------------------------------------------------------------
+@app.route("/health")
+def health():
+    return jsonify({"status": "ok"})
+
 
 if __name__ == "__main__":
-    app.run(host="0.0.0.0", port=7860, debug=True)
+    # Auto-start cron on boot (optional - comment out if you only want manual /start)
+    # Uncomment below if you want it to auto-run:
+    # state["stop_event"] = threading.Event()
+    # t = threading.Thread(target=cron_worker, args=(state["stop_event"],), daemon=True)
+    # state["thread"] = t
+    # state["running"] = True
+    # t.start()
+
+    app.run(host="0.0.0.0", port=7860, debug=False, threaded=True)