Update app.py

app.py

@@ -1,6 +1,6 @@
 import gradio as gr
 import requests, re
-from api_usage import get_subscription, check_key_availability, check_key_ant_availability, check_ant_rate_limit, check_key_gemini_availability, check_key_azure_availability, get_azure_status, get_azure_deploy, check_key_mistral_availability, check_mistral_quota, check_key_replicate_availability, check_key_aws_availability, check_key_or_availability, check_key_or_limits, check_gcp_anthropic, check_groq_status, check_nai_status, check_elevenlabs_status
+from api_usage import get_subscription, check_key_availability, get_orgs_me, check_key_ant_availability, check_ant_rate_limit, check_key_gemini_availability, check_key_azure_availability, get_azure_status, get_azure_deploy, check_key_mistral_availability, check_mistral_quota, check_key_replicate_availability, check_key_aws_availability, check_key_or_availability, check_key_or_limits, check_gcp_anthropic, check_groq_status, check_nai_status, check_elevenlabs_status, check_xai_status, check_stability_status, check_deepseek_status
 
 async def sort_key(key, rate_limit, claude_model):
     _key = key.strip()
@@ -10,7 +10,13 @@ async def sort_key(key, rate_limit, claude_model):
         
     if re.match(re.compile("sk-ant-api03-[a-zA-Z0-9\-_]{93}AA"), _key) or (_key.startswith("sk-ant-") and len(_key) == 93) or (len(_key) == 89 and re.match(re.compile("sk-[a-zA-Z0-9]{86}"), _key)):
         return await get_key_ant_info(_key, rate_limit, claude_model)
-        
+    
+    if re.match(re.compile(r"sk-[a-zA-Z0-9]{48}"), _key) and len(_key) == 51 and 'T3BlbkFJ' not in _key:
+        return get_key_stability_info(_key)
+    
+    if re.match(re.compile(r"sk-[a-f0-9]{32}"), _key):
+        return get_key_deepseek_info(_key)
+    
     if _key.startswith("sk-"):    
         return get_key_oai_info(_key)
         
@@ -23,6 +29,9 @@ async def sort_key(key, rate_limit, claude_model):
     if (_key.startswith("r8_") and len(_key) == 40) or (_key.islower() and len(_key) == 40):
         return get_key_replicate_info(_key)
         
+    if _key.startswith("xai-"):  
+        return get_key_xai_info(_key)
+        
     if len(_key.split(':')) == 2 and _key.split(':')[1].islower() and len(_key.split(':')[1]) == 32 and "openai.azure.com" not in _key.split(':')[1]:
         endpoint = f"{_key.split(':')[0]}.openai.azure.com"
         api_key = _key.split(':')[1]
@@ -56,36 +65,48 @@ async def sort_key(key, rate_limit, claude_model):
 def get_key_oai_info(key):
     # Return a dictionary containing key information
     session = requests.Session()
-    key_avai = check_key_availability(session, key)
-    info_dict = {#"account_name": "",
-                 "key_type": "OpenAI",
-                 "key_availability": True if key_avai[0] else False,
-                 "gpt4_availability": "",
-                 "gpt4_32k_availability": "",
-                 "default_org": "",                 
-                 "org_description": "",
-                 "organization": "",
-                 "models": "",
-                 "requests_per_minute": "",
-                 "tokens_per_minute": "",
-                 #"tokens_per_minute_left": "",
-                 "quota": ""}
-    if key_avai[0]:
-        if key_avai[0] == 200:            
-            info = get_subscription(key, session, key_avai[1])
-            info_dict["default_org"] = info["default_org"]        
-            info_dict["org_description"] = info["org_description"]
-            info_dict["organization"] = info["organization"]   
-        else:
-            empty_org = { 'id': '' }
-            info = get_subscription(key, session, [empty_org])
-            info_dict["organization"] = key_avai[1]
-        info_dict["gpt4_availability"] = info["has_gpt4"]
-        info_dict["gpt4_32k_availability"] = info["has_gpt4_32k"]
-        info_dict["models"] = info["models"]
-        info_dict["requests_per_minute"] = info["rpm"]
-        info_dict["tokens_per_minute"] = info["tpm"]
-        info_dict["quota"] = info["quota"]
+
+    status, org_data = check_key_availability(session, key)
+
+    info_dict = {
+        "key_type": "OpenAI",
+        "key_availability": True if status else False,
+        "gpt4_availability": "",
+        "gpt4_32k_availability": "",
+        "default_org": "",
+        "org_description": "",
+        "organization": "",
+        "models": "",
+        "requests_per_minute": "",
+        "tokens_per_minute": "",
+        "quota": "",
+        "all_models": ""
+    }
+
+    if not status:
+        return info_dict
+
+    if status == 403:
+        status_me, orgs_me = get_orgs_me(session, key)
+        if status_me == 200:
+            org_data = orgs_me
+        
+    subscription_info = get_subscription(key, session, org_data)
+
+    # Update the info_dict with subscription details
+    info_dict.update({
+        "gpt4_availability": subscription_info["has_gpt4"],
+        "gpt4_32k_availability": subscription_info["has_gpt4_32k"],
+        "default_org": subscription_info["default_org"],
+        "org_description": subscription_info["org_description"],
+        "organization": subscription_info["organization"],
+        "models": subscription_info["models"],
+        "requests_per_minute": subscription_info["rpm"],
+        "tokens_per_minute": subscription_info["tpm"],
+        "quota": subscription_info["quota"],
+        "all_models": subscription_info["all_models"]
+    })
+
     return info_dict
 
 async def get_key_ant_info(key, rate_limit, claude_model):
@@ -98,14 +119,20 @@ async def get_key_ant_info(key, rate_limit, claude_model):
                  "filter_response": "",
                  "requests_per_minute": "",
                  "tokens_per_minute": "",
+                 "tokens_input_per_minute": "",
+                 "tokens_output_per_minute": "",
                  "tier": "",
-                 "concurrent_rate_limit": ""}
+                 "concurrent_rate_limit": "",
+                 "models": ""}
     
     info_dict["status"] = key_avai[1]
     info_dict["filter_response"] = key_avai[2]
     info_dict["requests_per_minute"] = key_avai[3] + ("" if key_avai[3] == "" else f" ({key_avai[4]} left)")
     info_dict["tokens_per_minute"] = key_avai[5] + ("" if key_avai[5] == "" else f" ({key_avai[6]} left)")
+    info_dict["tokens_input_per_minute"] = key_avai[8] + ("" if key_avai[8] == "" else f" ({key_avai[9]} left)")
+    info_dict["tokens_output_per_minute"] = key_avai[10] + ("" if key_avai[10] == "" else f" ({key_avai[11]} left)")
     info_dict["tier"] = key_avai[7]
+    info_dict["models"] = key_avai[12]
         
     if rate_limit:
         rate = await check_ant_rate_limit(key, claude_model)
@@ -272,7 +299,45 @@ def get_key_elevenlabs_info(key):
                  "user_info": key_avai[1],
                  "voices_info": key_avai[2]}
     return info_dict
+
+def get_key_xai_info(key):
+    key_avai = check_xai_status(key)
+    info_dict = {#"account_name": "",
+                 "key_type": "xAI Grok",
+                 "key_availability": key_avai[0],
+                 "key_status": "",
+                 "models": ""}
+    if key_avai[0]:
+        info_dict['key_status'] = key_avai[1]
+        info_dict['models'] = key_avai[2]
+    return info_dict
     
+def get_key_stability_info(key):
+    key_avai = check_stability_status(key)
+    info_dict = {#"account_name": "",
+                 "key_type": "Stability AI",
+                 "key_availability": key_avai[0],
+                 "account_info": "",
+                 "credits": "",
+                 "models": ""}
+    if key_avai[0]:
+        info_dict['account_info'] = key_avai[1]
+        info_dict['credits'] = key_avai[2]
+        info_dict['models'] = key_avai[3]
+    return info_dict
+
+def get_key_deepseek_info(key):
+    key_avai = check_deepseek_status(key)
+    info_dict = {#"account_name": "",
+                 "key_type": "deepseek",
+                 "key_availability": key_avai[0],
+                 "balance": "",
+                 "models": ""}
+    if key_avai[0]:        
+        info_dict['models'] = key_avai[1]
+        info_dict['balance'] = key_avai[2]
+    return info_dict
+
 def not_supported(key):
     info_dict = {#"account_name": "",
                      "key_type": "Not supported",
@@ -284,7 +349,7 @@ def clear_inputs(text):
 
 with gr.Blocks() as demo:
     gr.Markdown('''
-    # OpenAI/Anthropic/Gemini/Azure/Mistral/Replicate/AWS Claude/OpenRouter/Vertex AI(GCP Anthropic)/Groq/NovelAI/ElevenLabs API Key Status Checker
+    # OpenAI/Anthropic/Gemini/Azure/Mistral/Replicate/AWS Claude/OpenRouter/Vertex AI(GCP Anthropic)/Groq/NovelAI/ElevenLabs/xAI/Stability/Deepseek API Key Status Checker
     
     *(Based on shaocongma, CncAnon1, su, Drago, kingbased key checkers)*
     AWS credential's format: AWS_ACCESS_KEY_ID:AWS_SECRET_ACCESS_KEY (root might not be accurate)