Upload app.py with huggingface_hub

app.py

@@ -11,7 +11,6 @@ import logging
 import os
 from dotenv import load_dotenv
 import random
-from openai import OpenAI
 
 # Load environment variables
 load_dotenv()
@@ -38,111 +37,121 @@ GLOBAL_REGIONS = [
 # HuggingFace Token for all providers
 HF_TOKEN = os.getenv('HF_TOKEN', '')
 
-# Initialize OpenAI-compatible clients for DeepSeek models using HuggingFace router
-openai_clients = []
+# Initialize HTTP clients for DeepSeek models using HuggingFace router
+http_clients = []
 if HF_TOKEN:
-    try:
-        # Primary DeepSeek-V3.2-Exp client
-        primary_client = OpenAI(
-            api_key=HF_TOKEN,
-            base_url="https://router.huggingface.co/v1"
-        )
-        openai_clients.append({
+    # HuggingFace router endpoint
+    router_url = "https://router.huggingface.co/v1/chat/completions"
+    headers = {
+        "Authorization": f"Bearer {HF_TOKEN}",
+        "Content-Type": "application/json"
+    }
+    
+    # Create client configurations for different models
+    http_clients = [
+        {
             "name": "deepseek-v3.2-exp",
-            "client": primary_client,
+            "url": router_url,
+            "headers": headers,
             "model": "deepseek-ai/DeepSeek-V3.2-Exp"
-        })
-        
-        # Secondary DeepSeek-V3-Base client
-        secondary_client = OpenAI(
-            api_key=HF_TOKEN,
-            base_url="https://router.huggingface.co/v1"
-        )
-        openai_clients.append({
+        },
+        {
             "name": "deepseek-v3-base",
-            "client": secondary_client,
+            "url": router_url,
+            "headers": headers,
             "model": "deepseek-ai/DeepSeek-V3-Base"
-        })
-        
-        # Fallback client (same as primary)
-        fallback_client = OpenAI(
-            api_key=HF_TOKEN,
-            base_url="https://router.huggingface.co/v1"
-        )
-        openai_clients.append({
+        },
+        {
             "name": "deepseek-fallback",
-            "client": fallback_client,
+            "url": router_url,
+            "headers": headers,
             "model": "deepseek-ai/DeepSeek-V3.2-Exp"
-        })
-        
-    except Exception as e:
-        logger.error(f"Failed to initialize OpenAI clients: {e}")
+        }
+    ]
 
-# Legacy API_PROVIDERS for compatibility (now using OpenAI client)
+# Legacy API_PROVIDERS for compatibility (now using HTTP requests)
 API_PROVIDERS = [
     {
         "name": "deepseek-v3.2-exp",
-        "provider": "hf_router_openai",
+        "provider": "hf_router_http",
         "model": "deepseek-ai/DeepSeek-V3.2-Exp"
     },
     {
         "name": "deepseek-v3-base", 
-        "provider": "hf_router_openai",
+        "provider": "hf_router_http",
         "model": "deepseek-ai/DeepSeek-V3-Base"
     },
     {
         "name": "deepseek-fallback",
-        "provider": "hf_router_openai",
+        "provider": "hf_router_http",
         "model": "deepseek-ai/DeepSeek-V3.2-Exp"
     }
 ]
 
 def get_next_provider():
-    """Get the next available OpenAI client for failover"""
+    """Get the next available HTTP client for failover"""
     global current_provider_index
-    if not openai_clients:
+    if not http_clients:
         return None
-    client_info = openai_clients[current_provider_index]
-    current_provider_index = (current_provider_index + 1) % len(openai_clients)
+    client_info = http_clients[current_provider_index]
+    current_provider_index = (current_provider_index + 1) % len(http_clients)
     return client_info
 
 def call_deepseek_api(messages: List[Dict], client_info: Dict, max_retries: int = 3) -> Optional[str]:
-    """Call DeepSeek API via HuggingFace Router using OpenAI client"""
+    """Call DeepSeek API via HuggingFace Router using HTTP requests"""
     if not client_info:
         return None
         
     try:
-        client = client_info["client"]
-        model = client_info["model"]
+        # Prepare OpenAI-compatible payload
+        payload = {
+            "model": client_info["model"],
+            "messages": messages,
+            "max_tokens": 1024,
+            "temperature": 0.7,
+            "top_p": 0.9,
+            "stream": False
+        }
         
-        # Use OpenAI client with HuggingFace router
-        response = client.chat.completions.create(
-            model=model,
-            messages=messages,
-            max_tokens=1024,
-            temperature=0.7,
-            top_p=0.9,
-            stream=False
+        # Make HTTP request to HuggingFace router
+        response = requests.post(
+            client_info["url"],
+            headers=client_info["headers"],
+            json=payload,
+            timeout=60
         )
         
-        # Extract content from response
-        if response.choices and len(response.choices) > 0:
-            content = response.choices[0].message.content
-            logger.info(f"✅ Success with OpenAI client: {client_info['name']} ({client_info['model']})")
-            return content.strip()
-        else:
-            logger.warning(f"⚠️ Unexpected response format from {client_info['name']}: {response}")
-            return None
+        if response.status_code == 200:
+            result = response.json()
             
-    except Exception as e:
-        error_msg = str(e).lower()
-        if "rate limit" in error_msg or "429" in error_msg:
+            # Extract content from OpenAI-compatible response
+            if "choices" in result and len(result["choices"]) > 0:
+                content = result["choices"][0]["message"]["content"]
+                logger.info(f"✅ Success with HTTP client: {client_info['name']} ({client_info['model']})")
+                return content.strip()
+            else:
+                logger.warning(f"⚠️ Unexpected response format from {client_info['name']}: {result}")
+                return None
+                
+        elif response.status_code == 429:
             logger.warning(f"💸 Rate limit reached for {client_info['name']}, switching to next provider...")
-        elif "503" in error_msg or "service unavailable" in error_msg:
+            return None
+        elif response.status_code == 503:
             logger.warning(f"⏳ Model loading for {client_info['name']}, waiting...")
-            time.sleep(10)  # Wait for model to load
+            time.sleep(10)
+            return None
         else:
-            logger.warning(f"⚠️ API error from {client_info['name']}: {str(e)}")
+            logger.warning(f"⚠️ API error from {client_info['name']}: {response.status_code} - {response.text}")
+            return None
+            
+    except requests.exceptions.Timeout:
+        logger.warning(f"⏰ Timeout with {client_info['name']}")
+        return None
+    except requests.exceptions.RequestException as e:
+        logger.warning(f"🔌 Connection error with {client_info['name']}: {str(e)}")
+        return None
+    except Exception as e:
+        logger.warning(f"⚠️ Unexpected error with {client_info['name']}: {str(e)}")
         return None
         if "rate limit" in error_msg or "429" in error_msg:
             logger.warning(f"💸 Rate limit reached for {client_info['name']}, switching to next provider...")
@@ -154,28 +163,28 @@ def call_deepseek_api(messages: List[Dict], client_info: Dict, max_retries: int
         return None
 
 def call_deepseek_with_failover(messages: List[Dict]) -> str:
-    """Call DeepSeek-V3.2-Exp with automatic OpenAI client failover"""
-    if not openai_clients:
-        return "OpenAI clients not initialized. Please check HF_TOKEN configuration."
+    """Call DeepSeek-V3.2-Exp with automatic HTTP client failover"""
+    if not http_clients:
+        return "HTTP clients not initialized. Please check HF_TOKEN configuration."
     
     clients_tried = []
     
     # Try all clients until one succeeds
-    for attempt in range(len(openai_clients)):
+    for attempt in range(len(http_clients)):
         client_info = get_next_provider()
         if not client_info:
             continue
             
         clients_tried.append(client_info['name'])
         
-        logger.info(f"🔄 Trying OpenAI client: {client_info['name']} (attempt {attempt + 1}/{len(openai_clients)})")
+        logger.info(f"🔄 Trying HTTP client: {client_info['name']} (attempt {attempt + 1}/{len(http_clients)})")
         
         result = call_deepseek_api(messages, client_info)
         if result:
             return result
     
     # If all clients failed
-    logger.error(f"❌ All OpenAI clients failed: {', '.join(clients_tried)}")
+    logger.error(f"❌ All HTTP clients failed: {', '.join(clients_tried)}")
     return f"I apologize, but all API providers ({', '.join(clients_tried)}) are currently unavailable. Please try again in a moment."
 
 def format_response(text):
@@ -308,7 +317,7 @@ Provide comprehensive analysis with specific numerical values for all calculated
         "year": year,
         "analysis_timestamp": datetime.now().isoformat(),
         "model": MODEL_NAME,
-        "providers": [c["name"] for c in openai_clients]
+        "providers": [c["name"] for c in http_clients]
     }
     
     # Extract metrics from model response
@@ -364,8 +373,8 @@ def status():
         'model': MODEL_NAME,
         'version': AEGIS_VERSION,
         'regions': len(GLOBAL_REGIONS),
-        'providers': [c["name"] for c in openai_clients],
-        'current_provider': openai_clients[current_provider_index]["name"] if openai_clients else "none",
+        'providers': [c["name"] for c in http_clients],
+        'current_provider': http_clients[current_provider_index]["name"] if http_clients else "none",
         'api_ready': True
     })
 
@@ -398,23 +407,23 @@ def chat():
                 'provider_status': 'HF_TOKEN missing'
             }), 500
             
-        if not openai_clients:
-            logger.error("OpenAI clients not initialized!")
+        if not http_clients:
+            logger.error("HTTP clients not initialized!")
             return jsonify({
-                'error': 'OpenAI clients not initialized. Please check HF_TOKEN configuration.',
-                'provider_status': 'OpenAI clients not initialized'
+                'error': 'HTTP clients not initialized. Please check HF_TOKEN configuration.',
+                'provider_status': 'HTTP clients not initialized'
             }), 500
         
         # Generate response using AEGIS Multi-Domain System with DeepSeek-V3.2-Exp
         logger.info("Generating AEGIS analysis...")
         response = analyze_with_aegis_conductor(message, analysis_type)
         
-        if not response or response.startswith("I apologize, but all API providers") or response.startswith("OpenAI clients not initialized"):
-            logger.error("All OpenAI clients failed or returned empty response")
+        if not response or response.startswith("I apologize, but all API providers") or response.startswith("HTTP clients not initialized"):
+            logger.error("All HTTP clients failed or returned empty response")
             return jsonify({
                 'error': 'All API providers are currently unavailable. Please check your HF_TOKEN and try again.',
                 'response': response,
-                'provider_status': 'All OpenAI clients failed'
+                'provider_status': 'All HTTP clients failed'
             }), 503
         
         logger.info(f"Successfully generated response of length: {len(response)}")
@@ -424,10 +433,10 @@ def chat():
             'timestamp': time.time(),
             'model': f"AEGIS BIO LAB {AEGIS_VERSION} CONDUCTOR (DeepSeek-V3.2-Exp)",
             'analysis_type': analysis_type,
-            'provider': f"{openai_clients[current_provider_index]['name'] if openai_clients else 'none'} (OpenAI)",
-            'hf_router_openai': True,
+            'provider': f"{http_clients[current_provider_index]['name'] if http_clients else 'none'} (HTTP)",
+            'hf_router_http': True,
             'hf_token_configured': bool(HF_TOKEN and len(HF_TOKEN) > 10),
-            'clients_initialized': len(openai_clients)
+            'clients_initialized': len(http_clients)
         })
         
     except Exception as e:
@@ -496,16 +505,16 @@ def diagnostic():
             <strong>Model:</strong> {MODEL_NAME}
         </div>
         
-        <div class="status {'good' if openai_clients else 'bad'}">
-            <strong>OpenAI Clients:</strong> {len(openai_clients)} initialized
+        <div class="status {'good' if http_clients else 'bad'}">
+            <strong>HTTP Clients:</strong> {len(http_clients)} initialized
         </div>
         
         <div class="status good">
-            <strong>Current Client:</strong> {openai_clients[current_provider_index]["name"] if openai_clients else "none"}
+            <strong>Current Client:</strong> {http_clients[current_provider_index]["name"] if http_clients else "none"}
         </div>
         
         <h2>🔧 Configuration Instructions</h2>
-        <p>Using HuggingFace Router with OpenAI client (only HF_TOKEN required):</p>
+        <p>Using HuggingFace Router with HTTP requests (only HF_TOKEN required):</p>
         <ol>
             <li>Go to your space settings</li>
             <li>Click "Variables and secrets"</li>
@@ -528,10 +537,10 @@ def provider_status():
     """Get status of all InferenceClient providers"""
     provider_statuses = []
     
-    for i, client_info in enumerate(openai_clients):
+    for i, client_info in enumerate(http_clients):
         status_info = {
             "name": client_info["name"],
-            "provider_type": "hf_router_openai",
+            "provider_type": "hf_router_http",
             "active": i == current_provider_index,
             "model": client_info.get("model", MODEL_NAME),
             "has_api_key": bool(HF_TOKEN and len(HF_TOKEN) > 10),
@@ -540,40 +549,40 @@ def provider_status():
         provider_statuses.append(status_info)
     
     # Count available providers
-    available_providers = len(openai_clients) if HF_TOKEN and len(HF_TOKEN) > 10 else 0
+    available_providers = len(http_clients) if HF_TOKEN and len(HF_TOKEN) > 10 else 0
     
     return jsonify({
         "providers": provider_statuses,
-        "current_provider": openai_clients[current_provider_index]["name"] if openai_clients else "none",
-        "current_provider_type": "hf_router_openai",
-        "total_providers": len(openai_clients),
+        "current_provider": http_clients[current_provider_index]["name"] if http_clients else "none",
+        "current_provider_type": "hf_router_http",
+        "total_providers": len(http_clients),
         "available_providers": available_providers,
         "model": MODEL_NAME,
         "api_keys_status": {
             "hf_token": bool(HF_TOKEN and len(HF_TOKEN) > 10),
-            "note": "Using HuggingFace Router with OpenAI client - only HF_TOKEN required"
+            "note": "Using HuggingFace Router with HTTP requests - only HF_TOKEN required"
         }
     })
 
 @app.route('/switch_provider', methods=['POST'])
 def switch_provider():
-    """Manually switch to next OpenAI client provider"""
+    """Manually switch to next HTTP client provider"""
     global current_provider_index
     
-    if not openai_clients:
+    if not http_clients:
         return jsonify({
-            "error": "No OpenAI clients available",
+            "error": "No HTTP clients available",
             "message": "Please check HF_TOKEN configuration"
         }), 500
     
-    old_client = openai_clients[current_provider_index]["name"]
-    current_provider_index = (current_provider_index + 1) % len(openai_clients)
-    new_client = openai_clients[current_provider_index]["name"]
+    old_client = http_clients[current_provider_index]["name"]
+    current_provider_index = (current_provider_index + 1) % len(http_clients)
+    new_client = http_clients[current_provider_index]["name"]
     
     return jsonify({
-        "switched_from": f"{old_client} (OpenAI)",
-        "switched_to": f"{new_client} (OpenAI)",
-        "message": f"Switched from {old_client} to {new_client} OpenAI client",
+        "switched_from": f"{old_client} (HTTP)",
+        "switched_to": f"{new_client} (HTTP)",
+        "message": f"Switched from {old_client} to {new_client} HTTP client",
         "model": MODEL_NAME
     })
 
@@ -584,19 +593,19 @@ def initialize_system():
     
     print("🚀 AEGIS BIO LAB 10 CONDUCTOR initializing with DeepSeek-V3.2-Exp via HuggingFace Router...")
     print(f"🤗 Model: {MODEL_NAME}")
-    print(f"🔗 Endpoint: https://router.huggingface.co/v1")
+    print(f"🔗 Endpoint: https://router.huggingface.co/v1/chat/completions")
     
-    if openai_clients:
-        client_list = ', '.join([f"{c['name']} ({c['model']})" for c in openai_clients])
-        print(f"📡 Available OpenAI clients: {client_list}")
-        print(f"🔄 Automatic failover enabled across {len(openai_clients)} OpenAI clients")
+    if http_clients:
+        client_list = ', '.join([f"{c['name']} ({c['model']})" for c in http_clients])
+        print(f"📡 Available HTTP clients: {client_list}")
+        print(f"🔄 Automatic failover enabled across {len(http_clients)} HTTP clients")
     else:
-        print("❌ No OpenAI clients initialized - check HF_TOKEN")
+        print("❌ No HTTP clients initialized - check HF_TOKEN")
     
     print(f"🌍 Global analysis across {len(GLOBAL_REGIONS)} regions")
     print(f"🔑 Using HuggingFace Token: {'✅ Valid' if HF_TOKEN and len(HF_TOKEN) > 10 else '❌ Missing'}")
     
-    loading_status = f"AEGIS BIO LAB {AEGIS_VERSION} CONDUCTOR ready with DeepSeek-V3.2-Exp via HuggingFace Router"
+    loading_status = f"AEGIS BIO LAB {AEGIS_VERSION} CONDUCTOR ready with DeepSeek-V3.2-Exp via HuggingFace Router HTTP"
     print("✅ AEGIS BIO LAB 10 CONDUCTOR ready!")
 
 if __name__ == '__main__':