Eliminar varias cuentas

import time
import requests

API_URL = "https://api.kameleoon.com/accounts/"
ACCESS_TOKEN = "YOUR_ACCESS_TOKEN"

ACCOUNT_IDS = [12345, 54321]

MAX_PER_10_SECONDS = 50
MAX_PER_HOUR = 1000

TEN_SECONDS = 10
ONE_HOUR = 3600


def delete_account(session, account_id):
    headers = {
        "Authorization": f"Bearer {ACCESS_TOKEN}",
    }

    url = f"{API_URL}{account_id}"

    try:
        response = session.delete(url, headers=headers)

        if response.status_code == 429:
            return "rate_limited", None

        if response.status_code in (200, 204):
            return True, response.json() if response.content else {}

        return False, response.text

    except requests.exceptions.RequestException as e:
        return False, str(e)


def process_accounts(account_ids):

    session = requests.Session()

    start_hour = time.monotonic()
    hour_count = 0

    for i in range(0, len(account_ids), MAX_PER_10_SECONDS):

        batch = account_ids[i:i + MAX_PER_10_SECONDS]

        # Enforce hourly limit BEFORE sending requests
        if hour_count + len(batch) > MAX_PER_HOUR:
            elapsed = time.monotonic() - start_hour
            sleep_time = max(0, ONE_HOUR - elapsed)

            print(f"Hourly limit reached. Sleeping {sleep_time:.2f} seconds")
            time.sleep(sleep_time)

            start_hour = time.monotonic()
            hour_count = 0

        batch_start = time.monotonic()

        for account_id in batch:

            while True:
                # Check hourly limit before EACH request
                if hour_count >= MAX_PER_HOUR:
                    elapsed = time.monotonic() - start_hour
                    sleep_time = max(0, ONE_HOUR - elapsed)

                    print(f"Hourly limit reached. Sleeping {sleep_time:.2f} seconds")
                    time.sleep(sleep_time)

                    start_hour = time.monotonic()
                    hour_count = 0

                result, data = delete_account(session, account_id)

                # Count every attempt as a request
                hour_count += 1

                if result == True:
                    print(f"Account {account_id} deleted")
                    break

                elif result == "rate_limited":
                    elapsed = time.monotonic() - start_hour

                    # If close to hourly limit, wait for full reset
                    if hour_count >= MAX_PER_HOUR or elapsed >= ONE_HOUR:
                        sleep_time = max(0, ONE_HOUR - elapsed)
                        print(f"429 likely due to hourly limit. Sleeping {sleep_time:.2f} seconds")
                        time.sleep(sleep_time)

                        start_hour = time.monotonic()
                        hour_count = 0
                    else:
                        print("429 received. Waiting 10 seconds...")
                        time.sleep(TEN_SECONDS)

                    continue

                else:
                    print(f"Failed to delete {account_id}: {data}")
                    break

        # Enforce 10-second window
        elapsed = time.monotonic() - batch_start

        if elapsed < TEN_SECONDS:
            sleep_time = TEN_SECONDS - elapsed
            print(f"Waiting {sleep_time:.2f} seconds before next batch")
            time.sleep(sleep_time)


def main():
    process_accounts(ACCOUNT_IDS)


if __name__ == "__main__":
    main()