Update app.py

app.py

@@ -3,6 +3,9 @@ import requests
 import random
 import string
 import time
+import os
+import json
+from datetime import datetime, timedelta
 
 app = Flask(__name__)
 
@@ -176,6 +179,127 @@ def delete_workspace(workspace_id):
         return False
 
 
+# -------------------------------------------------------------------
+# Function to upload audio file and get URL
+# -------------------------------------------------------------------
+def upload_audio_file(file_path, bot_id, workspace_id):
+    """Upload an audio file and return its URL"""
+    global GLOBAL_WORKSPACE_ID, GLOBAL_BOT_ID
+
+    # API endpoint
+    url = "https://api.botpress.cloud/v1/files"
+
+    # Get file name from path
+    file_name = os.path.basename(file_path)
+
+    # Get file size
+    file_size = os.path.getsize(file_path)
+
+    # Get file content type
+    content_type = "audio/mpeg"
+
+    # Calculate expiration date (3 days from now) with proper timezone format
+    now = datetime.now()
+    expires_at = (now + timedelta(days=3)).strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "+02:00"
+
+    # Prepare headers
+    headers = {
+        "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36",
+        "x-bot-id": bot_id,
+        "x-workspace-id": workspace_id,
+        "Content-Type": "application/json",
+        "cookie": AUTH_COOKIE
+    }
+
+    # Prepare payload
+    payload = {
+        "key": file_name,
+        "tags": {
+            "purpose": "emulator",
+            "system": "true"
+        },
+        "size": file_size,
+        "accessPolicies": ["public_content"],
+        "contentType": content_type,
+        "expiresAt": expires_at,
+        "publicContentImmediatelyAccessible": True
+    }
+
+    # Make the PUT request to get the upload URL
+    response = requests.put(url, headers=headers, data=json.dumps(payload))
+
+    if response.status_code == 200:
+        response_data = response.json()
+
+        # Extract the URL and upload URL
+        file_url = response_data.get("file", {}).get("url", "")
+        upload_url = response_data.get("file", {}).get("uploadUrl", "")
+
+        # Now upload the actual file to the upload URL
+        if upload_url:
+            # Read the binary content of the audio file
+            with open(file_path, 'rb') as audio_file:
+                file_content = audio_file.read()
+
+            # Set headers for the upload request with all the headers you provided
+            upload_headers = {
+                "accept": "application/json, text/plain, */*",
+                "accept-encoding": "gzip, deflate, br, zstd",
+                "accept-language": "en-US,en;q=0.9,ar;q=0.8",
+                "connection": "keep-alive",
+                "content-length": str(file_size),
+                "content-type": "audio/mpeg",
+                "host": "s3.us-east-1.amazonaws.com",
+                "origin": "https://studio.botpress.cloud",
+                "referer": "https://studio.botpress.cloud/",
+                "sec-ch-ua": '"Chromium";v="136", "Google Chrome";v="136", "Not.A/Brand";v="99"',
+                "sec-ch-ua-mobile": "?0",
+                "sec-ch-ua-platform": '"Windows"',
+                "sec-fetch-dest": "empty",
+                "sec-fetch-mode": "cors",
+                "sec-fetch-site": "cross-site",
+                "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36",
+                "x-amz-tagging": "public=true"
+            }
+
+            # Make the PUT request to upload the file
+            upload_response = requests.put(upload_url, headers=upload_headers, data=file_content)
+
+            if upload_response.status_code == 200:
+                return file_url, bot_id, workspace_id
+            else:
+                return f"Error uploading file: {upload_response.status_code} - {upload_response.text}", bot_id, workspace_id
+        else:
+            return "No upload URL provided in response", bot_id, workspace_id
+    elif response.status_code == 403:
+        # If we get a 403 error, we need to delete and recreate the bot and workspace
+        print("Received 403 error during file upload. Recreating bot and workspace...")
+
+        # Delete bot first, then workspace
+        if bot_id and workspace_id:
+            delete_bot(bot_id, workspace_id)
+            delete_workspace(workspace_id)
+
+        # Create new workspace and bot
+        new_workspace_id = create_workspace()
+        if not new_workspace_id:
+            return "Failed to create a new workspace after 403 error", bot_id, workspace_id
+
+        new_bot_id = create_bot(new_workspace_id)
+        if not new_bot_id:
+            return "Failed to create a new bot after 403 error", new_workspace_id, workspace_id
+
+        # Update global variables
+        GLOBAL_WORKSPACE_ID = new_workspace_id
+        GLOBAL_BOT_ID = new_bot_id
+
+        # Try again with the new IDs
+        result, _, _ = upload_audio_file(file_path, new_bot_id, new_workspace_id)
+        return result, new_bot_id, new_workspace_id
+    else:
+        return f"Error: {response.status_code} - {response.text}", bot_id, workspace_id
+
+
 # -------------------------------------------------------------------
 # Main function that calls the Botpress API endpoint for audio transcription
 # -------------------------------------------------------------------
@@ -184,6 +308,8 @@ def transcribe_audio(file_url, prompt, bot_id, workspace_id):
     Sends the audio file URL to the Botpress API endpoint for transcription,
     returns the transcription text and (possibly updated) bot/workspace IDs.
     """
+    global GLOBAL_WORKSPACE_ID, GLOBAL_BOT_ID
+
     # Prepare the headers
     headers = {
         "User-Agent": "Mozilla/5.0",
@@ -207,9 +333,6 @@ def transcribe_audio(file_url, prompt, bot_id, workspace_id):
     max_retries = 3
     timeout = 120  # Increased timeout for long audio files
 
-    # Flag to track if we need to create new IDs due to quota exceeded
-    quota_exceeded = False
-
     # Attempt to send the request
     for attempt in range(max_retries):
         try:
@@ -232,23 +355,10 @@ def transcribe_audio(file_url, prompt, bot_id, workspace_id):
                 print(f"Successfully received transcription from Botpress API")
                 return transcription_text, bot_id, workspace_id
 
-            # Check for quota exceeded error specifically
+            # If we get a 403 error, delete and recreate workspace/bot
             elif response.status_code == 403:
-                error_data = response.json()
-                error_message = error_data.get('message', '')
-
-                # Check if this is the specific quota exceeded error
-                if "has reached its usage limit for ai spend" in error_message:
-                    print(f"Quota exceeded error detected: {error_message}")
-                    quota_exceeded = True
-                    break
-                else:
-                    print(f"Received 403 error but not quota exceeded: {error_message}")
-                    if attempt < max_retries - 1:
-                        time.sleep(2)
-                        continue
-                    else:
-                        return f"Unable to transcribe the audio (Error 403).", bot_id, workspace_id
+                print(f"Received 403 error. Deleting and recreating workspace/bot...")
+                break  # Break out of the retry loop to handle 403 specially
 
             # Handle network errors or timeouts (just retry)
             elif response.status_code in [404, 408, 502, 503, 504]:
@@ -281,73 +391,70 @@ def transcribe_audio(file_url, prompt, bot_id, workspace_id):
             else:
                 return f"Unable to transcribe the audio: {str(e)}", bot_id, workspace_id
 
-    # If quota exceeded, we need to create new resources
-    if quota_exceeded:
-        print("Quota exceeded. Creating new workspace and bot...")
-
-        # First delete the bot, then the workspace (in that order)
-        if bot_id and workspace_id:
-            print(f"Deleting bot {bot_id} first...")
-            delete_success = delete_bot(bot_id, workspace_id)
-            if delete_success:
-                print(f"Successfully deleted bot {bot_id}")
-            else:
-                print(f"Failed to delete bot {bot_id}")
-
-            print(f"Now deleting workspace {workspace_id}...")
-            ws_delete_success = delete_workspace(workspace_id)
-            if ws_delete_success:
-                print(f"Successfully deleted workspace {workspace_id}")
-            else:
-                print(f"Failed to delete workspace {workspace_id}")
-
-        # Create new workspace
-        new_workspace_id = create_workspace()
-        if not new_workspace_id:
-            return "Failed to create a new workspace after quota exceeded. Please try again later.", bot_id, workspace_id
-
-        # Create new bot in the new workspace
-        new_bot_id = create_bot(new_workspace_id)
-        if not new_bot_id:
-            return "Failed to create a new bot after quota exceeded. Please try again later.", new_workspace_id, workspace_id
-
-        # Update headers with new bot ID and workspace ID
-        headers["x-bot-id"] = new_bot_id
-        headers["x-workspace-id"] = new_workspace_id
+    # If we got a 403 error, delete and recreate resources
+    # First delete the bot, then the workspace (in that order)
+    if bot_id and workspace_id:
+        print(f"Deleting bot {bot_id} first...")
+        delete_success = delete_bot(bot_id, workspace_id)
+        if delete_success:
+            print(f"Successfully deleted bot {bot_id}")
+        else:
+            print(f"Failed to delete bot {bot_id}")
 
-        # Try one more time with the new IDs
-        try:
-            print(f"Retrying with new bot_id={new_bot_id}, workspace_id={new_workspace_id}")
-            retry_response = requests.post(botpress_url, json=payload, headers=headers, timeout=timeout)
+        print(f"Now deleting workspace {workspace_id}...")
+        ws_delete_success = delete_workspace(workspace_id)
+        if ws_delete_success:
+            print(f"Successfully deleted workspace {workspace_id}")
+        else:
+            print(f"Failed to delete workspace {workspace_id}")
 
-            if retry_response.status_code == 200:
-                data = retry_response.json()
+    # Create new workspace
+    new_workspace_id = create_workspace()
+    if not new_workspace_id:
+        return "Failed to create a new workspace. Please try again later.", bot_id, workspace_id
 
-                # Extract all text segments from the response
-                transcription_text = ""
-                segments = data.get('output', {}).get('segments', [])
-                for segment in segments:
-                    segment_text = segment.get('text', '')
-                    if segment_text:
-                        transcription_text += segment_text + " "
+    # Create new bot in the new workspace
+    new_bot_id = create_bot(new_workspace_id)
+    if not new_bot_id:
+        return "Failed to create a new bot. Please try again later.", new_workspace_id, workspace_id
 
-                transcription_text = transcription_text.strip()
-                print(f"Successfully received transcription with new IDs")
-                return transcription_text, new_bot_id, new_workspace_id
-            else:
-                print(f"Failed with new IDs: {retry_response.status_code}, {retry_response.text}")
-                return f"Unable to transcribe the audio with new credentials.", new_bot_id, new_workspace_id
+    # Update global variables
+    GLOBAL_WORKSPACE_ID = new_workspace_id
+    GLOBAL_BOT_ID = new_bot_id
 
-        except Exception as e:
-            print(f"Error with new IDs: {str(e)}")
-            return f"Unable to transcribe the audio with new credentials: {str(e)}", new_bot_id, new_workspace_id
+    # Update headers with new bot ID and workspace ID
+    headers["x-bot-id"] = new_bot_id
+    headers["x-workspace-id"] = new_workspace_id
 
-    # Should not reach here due to the handling in the loop
-    return "Unable to transcribe the audio.", bot_id, workspace_id
+    # Try one more time with the new IDs
+    try:
+        print(f"Retrying with new bot_id={new_bot_id}, workspace_id={new_workspace_id}")
+        retry_response = requests.post(botpress_url, json=payload, headers=headers, timeout=timeout)
+
+        if retry_response.status_code == 200:
+            data = retry_response.json()
+
+            # Extract all text segments from the response
+            transcription_text = ""
+            segments = data.get('output', {}).get('segments', [])
+            for segment in segments:
+                segment_text = segment.get('text', '')
+                if segment_text:
+                    transcription_text += segment_text + " "
+
+            transcription_text = transcription_text.strip()
+            print(f"Successfully received transcription with new IDs")
+            return transcription_text, new_bot_id, new_workspace_id
+        else:
+            print(f"Failed with new IDs: {retry_response.status_code}, {retry_response.text}")
+            return f"Unable to transcribe the audio with new credentials.", new_bot_id, new_workspace_id
 
+    except Exception as e:
+        print(f"Error with new IDs: {str(e)}")
+        return f"Unable to transcribe the audio with new credentials: {str(e)}", new_bot_id, new_workspace_id
 
 # -------------------------------------------------------------------
-# Flask Endpoint
+# Flask Endpoints
 # -------------------------------------------------------------------
 @app.route("/transcribe", methods=["POST"])
 def transcribe_endpoint():
@@ -401,6 +508,59 @@ def transcribe_endpoint():
     return jsonify({"transcription": transcription})
 
 
+@app.route("/upload", methods=["POST"])
+def upload_endpoint():
+    """
+    Endpoint to upload an audio file and get its URL
+    Expects form data with a file field named 'audio'
+    Returns JSON with the file URL
+    """
+    global GLOBAL_WORKSPACE_ID, GLOBAL_BOT_ID
+
+    # Check if file was uploaded
+    if 'audio' not in request.files:
+        return jsonify({"error": "No audio file provided"}), 400
+
+    audio_file = request.files['audio']
+
+    # Check if filename is empty
+    if audio_file.filename == '':
+        return jsonify({"error": "No audio file selected"}), 400
+
+    # 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({"error": "I'm currently unavailable. Please try again later."}), 500
+
+    # Save the file temporarily
+    temp_path = f"/tmp/{audio_file.filename}"
+    audio_file.save(temp_path)
+
+    # Upload the file
+    file_url, updated_bot_id, updated_workspace_id = upload_audio_file(temp_path, GLOBAL_BOT_ID, GLOBAL_WORKSPACE_ID)
+
+    # Remove the temporary file
+    os.remove(temp_path)
+
+    # 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
+
+    # Check if we got an error string back
+    if isinstance(file_url, str) and (file_url.startswith("Error") or file_url.startswith("Failed") or file_url.startswith("No upload")):
+        return jsonify({"error": file_url}), 500
+
+    return jsonify({"file_url": file_url})
+
+
 # -------------------------------------------------------------------
 # Run the Flask app
 # -------------------------------------------------------------------