Update app.py

app.py

@@ -1,471 +1,185 @@
-from flask import Flask, request, jsonify
+from flask import Flask, request, jsonify, render_template, url_for
+from urllib.parse import urlencode
 import requests
-import random
-import string
-import time
-import json
+import os
 
 app = Flask(__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()}
-
-    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
-    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
-            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_01K235NKSVEGFZAJ7E0MT2N647": {
-                "enabled": True
-            }
+# External screenshot service config
+SCREENSHOT_API = "https://corvo-ai-xx-sc.hf.space/capture"
+
+# Allowed intervals and mapping to TradingView "interval" code
+INTERVAL_MAP = {
+    # minutes
+    "1m": "1",
+    "3m": "3",
+    "5m": "5",
+    "5min": "5",
+    "15m": "15",
+    "15min": "15",
+    "30m": "30",
+    "30min": "30",
+    # hours
+    "1h": "60",
+    "2h": "120",
+    "4h": "240",
+    # days/weeks/months
+    "1d": "D",
+    "1D": "D",
+    "d": "D",
+    "D": "D",
+    "1w": "W",
+    "1W": "W",
+    "w": "W",
+    "W": "W",
+    "1mth": "M",
+    "1M": "M",
+    "m": "M",
+    "M": "M"
+}
+
+def normalize_interval(raw_interval: str) -> str:
+    if not raw_interval:
+        return "D"
+    key = raw_interval.strip()
+    return INTERVAL_MAP.get(key, key)
+
+def parse_indicators_param(indicators_raw):
+    # Accept indicators as:
+    # - JSON array in body or query (list)
+    # - Comma-separated string "PUB;id1,PUB;id2"
+    # Returns a list of indicator IDs
+    if indicators_raw is None:
+        return []
+    if isinstance(indicators_raw, list):
+        return [str(x).strip() for x in indicators_raw if str(x).strip()]
+    if isinstance(indicators_raw, str):
+        parts = [p.strip() for p in indicators_raw.split(",") if p.strip()]
+        return parts
+    return []
+
+@app.route("/")
+def index():
+    return jsonify({
+        "message": "Chart Screenshot API",
+        "endpoints": {
+            "chart_html": "/chart?symbol=BTCUSDT&exchange=BINANCE&interval=1h&indicators=PUB;abc,PUB;def",
+            "screenshot_api": "/api/screenshot"
         }
-    }
-
-    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
-
-
-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("/chart")
+def chart():
+    # This endpoint renders the TradingView chart using query params:
+    # symbol, exchange, interval, indicators (comma separated), theme (optional)
+    symbol = request.args.get("symbol", "BTCUSDT")
+    exchange = request.args.get("exchange", "BINANCE")
+    interval = normalize_interval(request.args.get("interval", "1D"))
+    indicators = parse_indicators_param(request.args.get("indicators"))
+    theme = request.args.get("theme", "dark")
+
+    return render_template(
+        "chart.html",
+        symbol=symbol,
+        exchange=exchange,
+        interval=interval,
+        indicators=indicators,
+        theme=theme
+    )
 
-    url = f"https://api.botpress.cloud/v1/admin/bots/{bot_id}"
-    headers = {
-        "User-Agent": "Mozilla/5.0",
-        "x-workspace-id": workspace_id,
-        "Authorization": TOKEN
+@app.route("/api/screenshot", methods=["POST"])
+def api_screenshot():
+    """
+    Request JSON:
+    {
+      "symbol": "BTCUSDT",                 // required
+      "exchange": "BINANCE",               // optional, default BINANCE
+      "interval": "1h",                    // optional, default 1D
+      "indicators": ["PUB;id1","PUB;id2"], // optional, or comma-separated string
+      "theme": "dark",                     // optional, default "dark"
+      "width": 1080,                       // optional
+      "height": 1920,                      // optional
+      "fullPage": false                    // optional
     }
 
-    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
-
-
-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
+    Response JSON:
+    {
+      "imageUrl": "https://...png",
+      "htmlUrl": "https://...html",
+      "screenshotMeta": {...}
     }
-
-    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
+    data = request.get_json(silent=True) or {}
+
+    symbol = data.get("symbol", None)
+    if not symbol:
+        return jsonify({"error": "symbol is required"}), 400
+
+    exchange = data.get("exchange", "BINANCE")
+    interval = normalize_interval(data.get("interval", "1D"))
+    indicators = parse_indicators_param(data.get("indicators"))
+    theme = data.get("theme", "dark")
+
+    # Build the chart URL hosted by this same app
+    # indicators are passed as comma-separated values
+    query = {
+        "symbol": symbol,
+        "exchange": exchange,
+        "interval": interval,
+        "theme": theme
     }
+    if indicators:
+        query["indicators"] = ",".join(indicators)
 
-    # 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"]
-                })
+    # Absolute URL to /chart so the screenshot service can access it
+    chart_url = request.url_root.rstrip("/") + url_for("chart") + "?" + urlencode(query)
 
-    # 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
-        })
+    # Build screenshot payload
+    width = data.get("width", 1080)
+    height = data.get("height", 1920)
+    full_page = data.get("fullPage", False)
 
-    # Prepare the payload for the API
     payload = {
-        "type": "openai:generateContent",
-        "input": {
-            "model": {
-                "id": "gpt-4.1-2025-04-14"
-            },
-            "systemPrompt": system_prompt,
-            "messages": messages,
-            "temperature": temperature,
-            "debug": False,
-        }
+        "urls": [chart_url],
+        "width": width,
+        "height": height,
+        "fullPage": bool(full_page)
     }
 
-    # 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
-
-        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}")
+        resp = requests.post(SCREENSHOT_API, json=payload, timeout=60)
+    except requests.RequestException as e:
+        return jsonify({"error": "Failed to reach screenshot service", "details": str(e)}), 502
 
-    # 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 resp.status_code != 200:
+        return jsonify({"error": "Screenshot service error", "status": resp.status_code, "body": resp.text}), 502
 
-    # 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
-    )
+    body = resp.json()
+    errors = body.get("errors") or []
+    if errors:
+        return jsonify({"error": "Screenshot service reported errors", "details": errors}), 502
 
-    # 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
+    results = body.get("results") or []
+    if not results:
+        return jsonify({"error": "No results from screenshot service"}), 502
 
-    return jsonify({"assistant_response": assistant_response})
+    first = results[0]
+    output = first.get("output") or {}
+    image_url = output.get("imageUrl")
+    html_url = output.get("htmlUrl")
 
+    if not image_url:
+        return jsonify({"error": "Screenshot result missing imageUrl", "raw": first}), 502
 
-# -------------------------------------------------------------------
-# Run the Flask app
-# -------------------------------------------------------------------
+    # Return only the URLs (what you asked for), plus meta for debugging
+    return jsonify({
+        "imageUrl": image_url,
+        "htmlUrl": html_url,
+        "screenshotMeta": first.get("meta", {})
+    })
 
 if __name__ == "__main__":
-    app.run(host="0.0.0.0", port=7860, debug=True)
+    # Host and port can be configured via env
+    host = os.getenv("HOST", "0.0.0.0")
+    port = int(os.getenv("PORT", "7860"))
+    app.run(host=host, port=port, debug=True)