Update api_usage.py

api_usage.py

@@ -16,13 +16,13 @@ GPT_TYPES = ["gpt-3.5-turbo", "gpt-4", "gpt-4-32k", "gpt-4-32k-0314", "gpt-4o",
 
 TOKEN_LIMIT_PER_TIER_TURBO = {
     "free": 40000,
-    "tier-1": 60000,
+    "tier-1": 200000,
     "tier-1(old?)": 90000,
-    "tier-2": 80000,
-    "tier-3": 160000,
-    "tier-4": 1000000,
-    "tier-5-old": 2000000,
-    "tier-5": 15000000
+    "tier-2/tier-5-old": 2000000,
+    "tier-3": 4000000,
+    "tier-4": 10000000,
+    "tier-5-old": 15000000,
+    "tier-5": 50000000
 }
 TOKEN_LIMIT_PER_TIER_GPT4 = {
     "tier-1": 10000,
@@ -61,12 +61,18 @@ def get_subscription(key, session, org_list):
     list_models_avai = set()
     
     for org_in in org_list:
-        headers = get_headers(key, org_in['id'])
+        if len(org_list) < 2: # mismatch_organization
+            headers = get_headers(key)
+            available_models = get_models(session, key)
+        else:
+            headers = get_headers(key, org_in['id'])
+            available_models = get_models(session, key, org_in['id'])
         if org_in['id']:
             if org_in['is_default']:
                 default_org = org_in['name']            
             org_description.append(f"{org_in['description']} (Created: {datetime.utcfromtimestamp(org_in['created'])} UTC" + (", personal)" if org_in['personal'] else ")"))
-        available_models = get_models(session, key, org_in['id'])
+        if 'No perm' in available_models:
+            available_models.extend(GPT_TYPES)
         has_gpt4_32k = True if GPT_TYPES[2] in available_models else False
         has_gpt4_32k_0314 = True if GPT_TYPES[3] in available_models else False
         has_gpt4 = True if GPT_TYPES[1] in available_models else False
@@ -76,18 +82,47 @@ def get_subscription(key, session, org_list):
                 org.append(f"{org_in['id']} ({org_in['name']}, {org_in['title']}, {org_in['role']})")
             if has_gpt4_32k:
                 list_models_avai.update(GPT_TYPES)
-                status_formated = format_status([GPT_TYPES[2], GPT_TYPES[4], GPT_TYPES[5], GPT_TYPES[1], GPT_TYPES[0]], session, headers)
+                if 'No perm' in available_models:
+                    status_formated = format_status(GPT_TYPES, session, headers)
+                else:
+                    status_formated = format_status([GPT_TYPES[2], GPT_TYPES[4], GPT_TYPES[5], GPT_TYPES[1], GPT_TYPES[0]], session, headers)
                 rpm.append(status_formated[0])
                 tpm.append(status_formated[1])
                 quota.append(status_formated[2])
-                list_models.append(f"gpt-4-32k, gpt-4o, gpt-4-turbo, gpt-4, gpt-3.5-turbo ({len(available_models)} total)")
+                if 'No perm' in available_models:
+                    lst_string = ""
+                    length = len(status_formated[3])
+                    count = 1
+                    for k, v in status_formated[3].items():
+                        if v:
+                            if count < length:
+                                lst_string += f'{k}, '
+                                continue
+                            else:
+                                lst_string += f' {k} '
+                        if v == False:
+                            list_models_avai.remove(k)
+                            if k == GPT_TYPES[2]:
+                                has_gpt4_32k = False
+                            elif k == GPT_TYPES[1]:
+                                has_gpt4 = False
+                            elif k == GPT_TYPES[0]:
+                                has_35 = False
+                            elif k == GPT_TYPES[4]:
+                                has_4o = False
+                        count += 1
+                    lst_string += '(No get model permission)'
+                    #list_models.append(f"gpt-4-32k, gpt-4o, gpt-4-turbo, gpt-4, gpt-3.5-turbo (No get model permission)")
+                    list_models.append(lst_string)
+                else:
+                    list_models.append(f"gpt-4-32k, gpt-4o, gpt-4-turbo, gpt-4, gpt-3.5-turbo ({len(available_models)} total)")
             else:
                 list_models_avai.update([GPT_TYPES[3], GPT_TYPES[1], GPT_TYPES[0]])
                 status_formated = format_status([GPT_TYPES[3], GPT_TYPES[4], GPT_TYPES[5], GPT_TYPES[1], GPT_TYPES[0]], session, headers)
                 rpm.append(status_formated[0])
                 tpm.append(status_formated[1])
                 quota.append(status_formated[2])
-                list_models.append(f"gpt-4-32k-0314, gpt-4o, gpt-4-turbo, gpt-4, gpt-3.5-turbo ({len(available_models)} total)")
+                list_models.append(f"gpt-4-32k-0314, gpt-4o, gpt-4-turbo, gpt-4, gpt-3.5-turbo ({len(available_models)} total)")                
             
         elif has_gpt4:
             if org_in['id']:
@@ -123,6 +158,7 @@ def send_oai_completions(oai_stuff):
     session = oai_stuff[0]
     headers = oai_stuff[1]
     model = oai_stuff[2]
+    model_status = False
     try:
         req_body = {"model": model, "max_tokens": 1}
         rpm_string = ""
@@ -134,6 +170,8 @@ def send_oai_completions(oai_stuff):
             e = result.get("error", {}).get("code", "")
             if e == None or e == 'missing_required_parameter':
                 rpm_num = int(r.headers.get("x-ratelimit-limit-requests", 0))
+                if rpm_num > 0:
+                    model_status = True
                 tpm_num = int(r.headers.get('x-ratelimit-limit-tokens', 0))
                 tpm_left = int(r.headers.get('x-ratelimit-remaining-tokens', 0))
                 _rpm = '{:,}'.format(rpm_num).replace(',', ' ')
@@ -160,20 +198,22 @@ def send_oai_completions(oai_stuff):
                 rpm_string = f"0 ({model})"
                 tpm_string = f"0 ({model})"
                 quota_string = e
-        return rpm_string, tpm_string, quota_string
+        return rpm_string, tpm_string, quota_string, model, model_status
     except Exception as e:
         #print(e)
-        return "", "", ""
+        return "", "", "", model, model_status
         
 def format_status(list_models_avai, session, headers):
     rpm = []
     tpm = []
+    model_status = {}
     quota = ""
     args = [(session, headers, model) for model in list_models_avai]
     with concurrent.futures.ThreadPoolExecutor() as executer:
         for result in executer.map(send_oai_completions, args):
             rpm.append(result[0])
             tpm.append(result[1])
+            model_status[result[3]] = result[4]
             if result[2]:
                 if quota == 'yes | custom-tier':
                     continue
@@ -184,7 +224,7 @@ def format_status(list_models_avai, session, headers):
     for i in range(len(rpm)):                
         rpm_str += rpm[i] + (" | " if i < len(rpm)-1 else "")
         tpm_str += tpm[i] + (" | " if i < len(rpm)-1 else "")
-    return rpm_str, tpm_str, quota
+    return rpm_str, tpm_str, quota, model_status
 
 def check_key_tier(rpm, tpm, dict, headers):
     dictItemsCount = len(dict)
@@ -216,6 +256,8 @@ def get_models(session, key, org: str = None):
     try:
         rq = session.get(f"{BASE_URL}/models", headers=headers, timeout=10)
         avai_models = rq.json()
+        if rq.status_code == 403:
+            return ['No perm']
         list_models = [model["id"] for model in avai_models["data"]] #[model["id"] for model in avai_models["data"] if model["id"] in GPT_TYPES]
     except:
         list_models = []
@@ -265,7 +307,6 @@ async def check_ant_rate_limit(key):
             tasks = [fetch_ant(async_session, json_data) for _ in range(max_requests)]
             results = await asyncio.gather(*tasks)
             count = 0
-            #print(results)
             for result in results:
                 if result:
                     count+=1
@@ -273,7 +314,6 @@ async def check_ant_rate_limit(key):
                 return f'{max_requests} or above'
             return count
     except Exception as e:
-        #print(e)
         return 0 
 
 def check_ant_tier(rpm):
@@ -337,7 +377,6 @@ def check_key_gemini_availability(key):
         else:
             return False, None
     except Exception as e:
-        #print(e)
         return 'Error while making request.', None
 
 def check_key_azure_availability(endpoint, api_key):
@@ -356,7 +395,6 @@ def check_key_azure_availability(endpoint, api_key):
         models = [m["id"] for m in rq["data"] if len(m["capabilities"]["scale_types"])>0]
         return True, models
     except Exception as e:
-        #print(e)
         return False, None     
 
 def get_azure_deploy(endpoint, api_key):
@@ -516,7 +554,6 @@ async def check_key_aws_availability(key):
     iam = session.client('iam')
             
     username = check_username(session)
-    #print(username)
     if not username[0]:
         return False, username[1]
     
@@ -578,7 +615,6 @@ def is_model_working(form_info, model_info):
             return model_info['agreementAvailability']['errorMessage']
         return "No"
     except:
-        #print(form_status)
         return "No"
         
 async def get_model_status(session, key, secret, region, model_name, form_info):
@@ -621,7 +657,7 @@ async def check_bedrock_claude_status(session, key, secret):
         if region and model_name:
             if msg == "Maybe":
                 invoke_info = await send_signed_request_bedrock(session, payload, f"anthropic.{model_name}", key, secret, region)
-                if 'messages.0' in invoke_info.get('message'):
+                if 'messages.0' in invoke_info.get('message') or 'many requests' in invoke_info.get('message'):
                     models[model_name].append(f'{region}: may be Unavailable if disabled')
             else:
                 models[model_name].append(region)