follow_github.py

import requests
from requests.auth import HTTPBasicAuth
from time import sleep, time
import json
import os
from dotenv import load_dotenv
from random import randint
import sys

load_dotenv()

USERNAME = os.getenv('GITHUB_USERNAME')
TOKEN = os.getenv('GITHUB_TOKEN')

def load_users(filename):
    with open(filename, 'r') as file:
        data = json.load(file)
    return data.get('usuarios', [])

def is_user_followed(username):
    url = f'https://api.github.com/user/following/{username}'
    try:
        response = requests.get(url, auth=HTTPBasicAuth(USERNAME, TOKEN))
        if response.status_code == 204:
            return True
        elif response.status_code == 404:
            return False
        else:
            print(f'Error checking if you follow {username}. Status code: {response.status_code}')
            return False
    except requests.RequestException as e:
        print(f'Error checking {username}: {e}')
        return False

def follow_user(username, failed_users):
    if is_user_followed(username):
        print(f'Already following: {username}. Skipping...')
        return

    url = f'https://api.github.com/user/following/{username}'
    try:
        response = requests.put(url, auth=HTTPBasicAuth(USERNAME, TOKEN))
        if response.status_code == 204:
            print(f'Followed: {username}')
        elif response.status_code == 404:
            print(f'Not found: {username}')
        elif response.status_code == 403:
            rate_limit_reset = int(response.headers.get('X-RateLimit-Reset', 0))
            wait_time = max(0, rate_limit_reset - time())
            print(f'Rate limit exceeded. Waiting {wait_time / 60:.2f} minutes.')
            sleep(wait_time)
            failed_users.append(username)
        elif response.status_code == 429:
            rate_limit_reset = int(response.headers.get('X-RateLimit-Reset', 0))
            wait_time = max(0, rate_limit_reset - time())
            print(f'Error 429: too many requests. Waiting {wait_time / 60:.2f} minutes before retrying.')
            sleep(wait_time)
            failed_users.append(username)
        else:
            print(f'Error following {username}. Status code: {response.status_code}')
            failed_users.append(username)
    except requests.RequestException as e:
        print(f'Error following {username}: {e}')
        failed_users.append(username)

def save_failed_users(failed_users):
    if failed_users:
        output_dir = 'static'
        os.makedirs(output_dir, exist_ok=True)
        output_file = os.path.join(output_dir, 'failed_users.json')
        with open(output_file, 'w', encoding='utf-8') as f:
            json.dump({"usuarios": failed_users}, f, indent=2, ensure_ascii=False)
        print(f'Failed users saved to: {output_file}')

def get_following_users():
    if not USERNAME or not TOKEN:
        print('Error: GitHub credentials are not configured.')
        print('Make sure you have GITHUB_USERNAME and GITHUB_TOKEN in your .env file')
        return []
    
    following_users = []
    url = 'https://api.github.com/user/following'
    page = 1
    per_page = 100
    
    print(f'Connecting to GitHub API as: {USERNAME}')
    
    while True:
        try:
            params = {'page': page, 'per_page': per_page}
            response = requests.get(url, auth=HTTPBasicAuth(USERNAME, TOKEN), params=params)
            
            if response.status_code == 200:
                users = response.json()
                if not users:
                    if page == 1:
                        print('No followed users found.')
                    break
                following_users.extend([user['login'] for user in users])
                print(f'Page {page}: {len(users)} users found (Total: {len(following_users)})')
                page += 1
                
                if len(users) < per_page:
                    break
            elif response.status_code == 401:
                print('Authentication error. Verify that your GitHub token is valid.')
                print('API response:', response.text[:200])
                break
            elif response.status_code == 403 or response.status_code == 429:
                rate_limit_reset = int(response.headers.get('X-RateLimit-Reset', 0))
                wait_time = max(0, rate_limit_reset - time())
                print(f'Rate limit exceeded. Waiting {wait_time / 60:.2f} minutes.')
                sleep(wait_time)
                continue
            else:
                print(f'Error getting followed users. Status code: {response.status_code}')
                print(f'Response: {response.text[:200]}')
                break
        except requests.RequestException as e:
            print(f'Error getting followed users: {e}')
            break
    
    return following_users

def check_rate_limit(response=None):
    if response is None:
        url = 'https://api.github.com/rate_limit'
        try:
            response = requests.get(url, auth=HTTPBasicAuth(USERNAME, TOKEN))
            if response.status_code != 200:
                return True
        except:
            return True
    
    try:
        remaining = int(response.headers.get('X-RateLimit-Remaining', 5000))
        reset_time = int(response.headers.get('X-RateLimit-Reset', 0))
        
        if remaining < 100 and reset_time > 0:
            wait_time = max(0, reset_time - time())
            if wait_time > 0:
                print(f'\n⚠️  Low rate limit ({remaining} remaining). Waiting {wait_time / 60:.1f} minutes...')
                sleep(wait_time)
                return False
    except (ValueError, KeyError):
        pass
    
    return True

def does_user_follow_me(username, check_rate=True):
    url = f'https://api.github.com/users/{username}/following/{USERNAME}'
    try:
        response = requests.get(url, auth=HTTPBasicAuth(USERNAME, TOKEN))
        
        if check_rate:
            check_rate_limit(response)
        
        if response.status_code == 204:
            return True
        elif response.status_code == 404:
            return False
        else:
            return False
    except requests.RequestException:
        return False

def unfollow_user(username, failed_users):
    if not is_user_followed(username):
        return
    
    url = f'https://api.github.com/user/following/{username}'
    try:
        response = requests.delete(url, auth=HTTPBasicAuth(USERNAME, TOKEN))
        
        check_rate_limit(response)
        
        if response.status_code == 204:
            pass
        elif response.status_code == 404:
            pass
        elif response.status_code == 403:
            rate_limit_reset = int(response.headers.get('X-RateLimit-Reset', 0))
            wait_time = max(0, rate_limit_reset - time())
            print(f'\n⚠️  Rate limit exceeded. Waiting {wait_time / 60:.2f} minutes.')
            sleep(wait_time)
            failed_users.append(username)
        elif response.status_code == 429:
            rate_limit_reset = int(response.headers.get('X-RateLimit-Reset', 0))
            wait_time = max(0, rate_limit_reset - time())
            print(f'\n⚠️  Error 429: too many requests. Waiting {wait_time / 60:.2f} minutes.')
            sleep(wait_time)
            failed_users.append(username)
        else:
            failed_users.append(username)
    except requests.RequestException:
        failed_users.append(username)

def unfollow_non_followers():
    if not USERNAME or not TOKEN:
        print('Error: GitHub credentials are not configured.')
        print('Make sure you have GITHUB_USERNAME and GITHUB_TOKEN in your .env file')
        return
    
    print('Getting list of users you are following...')
    following_users = get_following_users()
    
    if not following_users:
        print('\nNo users you are following were found.')
        print('This may be due to:')
        print('  1. You are really not following any users')
        print('  2. Authentication error (verify your token)')
        print('  3. The token does not have the necessary permissions')
        return
    
    print(f'Found {len(following_users)} users you are following.')
    print("Checking which ones don't follow you back...")
    print('(Reduced pauses, automatically checking rate limits)\n')
    
    non_followers = []
    failed_users = []
    last_print_time = time()
    print_interval = 5
    
    for i, username in enumerate(following_users, 1):
        current_time = time()
        if current_time - last_print_time >= print_interval or i == 1 or i == len(following_users):
            print(f'[{i}/{len(following_users)}] Checking... ({len(non_followers)} don\'t follow you so far)')
            last_print_time = current_time
        
        if not does_user_follow_me(username):
            non_followers.append(username)
        
        sleep(randint(300, 700) / 1000)
        
        if i % 50 == 0:
            print(f'  → Processed {i} users. Safety pause...')
            sleep(randint(1, 2))
    
    if not non_followers:
        print('\nExcellent! All users you follow also follow you back.')
        return
    
    print(f'\nFound {len(non_followers)} users who don\'t follow you back.')
    respuesta = input('Do you want to unfollow these users? (y/n): ').lower().strip()
    
    if respuesta != 'y':
        print('Operation cancelled.')
        return
    
    print(f'\nUnfollowing {len(non_followers)} users...')
    last_print_time = time()
    
    for i, username in enumerate(non_followers, 1):
        current_time = time()
        if current_time - last_print_time >= print_interval or i == 1 or i == len(non_followers):
            print(f'[{i}/{len(non_followers)}] Processing...')
            last_print_time = current_time
        
        unfollow_user(username, failed_users)
        sleep(randint(500, 1000) / 1000)
        
        if i % 30 == 0:
            print(f'  → Processed {i} users. Safety pause...')
            sleep(randint(1, 2))
    
    if failed_users:
        save_failed_users(failed_users)
        print(f'\n{len(failed_users)} users could not be processed. Check the failed users file.')
    else:
        print(f'\n✓ Process completed. Unfollowed {len(non_followers)} users.')

def main():
    if len(sys.argv) > 1 and sys.argv[1] == '--unfollow':
        unfollow_non_followers()
        return
    
    users_to_follow = load_users('static/usuarios.json')
    failed_users = []
    
    if not users_to_follow:
        print('No users found to follow.')
        return
    
    for user in users_to_follow:
        follow_user(user, failed_users)
        sleep(randint(1, 5))
    
    save_failed_users(failed_users)

if __name__ == "__main__":
    print("=" * 60)
    print("GitHub Mass Following Script")
    print("=" * 60)
    print("\nAvailable modes:")
    print("  1. Follow users (default mode): python follow_github.py")
    print("  2. Unfollow those who don't follow you: python follow_github.py --unfollow")
    print("=" * 60)
    
    if len(sys.argv) > 1 and sys.argv[1] == '--unfollow':
        print("\nMode: Unfollow users who don't follow you\n")
    else:
        print("\nMode: Follow users from the list\n")
    
    main()