Update app.py

app.py

@@ -1,18 +1,21 @@
 import os
+import time
 import requests
 from flask import Flask, request, jsonify
 from flask_cors import CORS
 
 app = Flask(__name__)
-CORS(app) # Allow all origins
+CORS(app)
 
-# Get the API Key from HF Secrets
-# Note: HF secrets are loaded as environment variables
+# Load Tokens
 TOKENS_RAW = os.environ.get("AI_SERVICE_TOKEN", "")
 TOKENS = [t.strip() for t in TOKENS_RAW.split(",") if t.strip()]
 
-def call_azure_openai(filename, token):
-    url = "https://models.inference.ai.azure.com/chat/completions"
+# Configuration
+# NOTE: Ensure this is a clean string, NO brackets []
+AZURE_URL = "https://models.inference.ai.azure.com/chat/completions"
+
+def call_azure_openai_with_retry(filename, token, retries=3):
     payload = {
         "model": "gpt-4o-mini",
         "messages": [
@@ -26,18 +29,39 @@ def call_azure_openai(filename, token):
     headers = {
         "Authorization": f"Bearer {token}",
         "Content-Type": "application/json",
-        # We act like a standard python client to Azure
-        "User-Agent": "Mozilla/5.0"
+        "User-Agent": "Mozilla/5.0 (Standard Browser)" 
     }
 
-    response = requests.post(url, headers=headers, json=payload)
-    return response
+    # Retry Loop
+    for attempt in range(retries):
+        try:
+            response = requests.post(AZURE_URL, headers=headers, json=payload, timeout=15)
+            
+            if response.status_code == 200:
+                return response
+            
+            elif response.status_code == 429:
+                # If rate limited, wait and try again (Exponential backoff)
+                wait_time = (attempt + 1) * 2 # Wait 2s, then 4s, then 6s
+                print(f"Rate limited (429). Retrying in {wait_time}s...")
+                time.sleep(wait_time)
+                continue
+                
+            else:
+                # Other errors (401, 500), don't retry, just return
+                return response
+                
+        except Exception as e:
+            print(f"Connection error: {e}")
+            time.sleep(1)
+            
+    return None # Failed after all retries
 
 @app.route('/')
 def health_check():
     return jsonify({
         "status": "active",
-        "platform": "Hugging Face Space (AWS IP)",
+        "platform": "Hugging Face Space (AWS)",
         "tokens_loaded": len(TOKENS)
     })
 
@@ -51,51 +75,42 @@ def analyze():
 
     last_error = ""
 
-    # Try looping through tokens if you have multiple, otherwise just uses the one
-    for i, token in enumerate(TOKENS):
-        try:
-            resp = call_azure_openai(filename, token)
-            
-            if resp.status_code == 200:
+    for token in TOKENS:
+        # Use the retry function
+        resp = call_azure_openai_with_retry(filename, token)
+        
+        if resp and resp.status_code == 200:
+            try:
                 result = resp.json()
                 content = result['choices'][0]['message']['content']
-                
-                # Cleanup Markdown (```json)
-                clean_content = content.replace("```json", "").replace("```", "").strip()
-                try:
-                    return jsonify(jsonify(clean_content).json) # Quick normalize
-                except:
-                    # If it's valid stringified JSON, return it parsed
-                    import json
-                    try:
-                        return jsonify(json.loads(clean_content))
-                    except:
-                        return jsonify({"raw_result": clean_content})
-
-            elif resp.status_code == 429:
-                last_error = "Rate Limited (429)"
-                continue # Try next token
-            else:
-                last_error = f"Error {resp.status_code}: {resp.text}"
+                # Clean Markdown
+                clean = content.replace("```json", "").replace("```", "").strip()
+                import json
+                return jsonify(json.loads(clean))
+            except Exception as e:
+                return jsonify({"raw_result": content, "error": "JSON Parse Error"})
         
-        except Exception as e:
-            last_error = str(e)
+        elif resp:
+            last_error = f"Status {resp.status_code}: {resp.text}"
+        else:
+            last_error = "Connection Timeout/Error"
 
     return jsonify({"error": "All tokens failed", "last_details": last_error}), 500
 
 @app.route('/check-limit')
 def check_limit():
     results = []
-    url = "[https://models.inference.ai.azure.com/chat/completions](https://models.inference.ai.azure.com/chat/completions)"
     
+    # FIX: Uses the clean constant variable defined at the top
     for i, token in enumerate(TOKENS):
         try:
             headers = {"Authorization": f"Bearer {token}", "Content-Type": "application/json"}
-            resp = requests.post(url, headers=headers, json={
+            resp = requests.post(AZURE_URL, headers=headers, json={
                 "model": "gpt-4o-mini",
                 "messages": [{"role":"user", "content":"ping"}],
                 "max_tokens": 1
-            })
+            }, timeout=5)
+            
             results.append({
                 "token_index": i,
                 "status": resp.status_code,