Proxy Program for searching and checking working proxy servers

Code
import sys

import subprocess

import os

import socket

import urllib.request

import time

from concurrent.futures import ThreadPoolExecutor

import requests

from fake_useragent import UserAgent

import random

from pystyle import Colors, Colorate, Center



# Constants for color output

RESET = "\033[0m"

GREEN_TEXT = "\033[32m"

RED_TEXT = "\033[31m"



# Global UserAgent object for caching

ua = UserAgent()



required_modules = [

    "pystyle",

    "urllib3",

    "fake_useragent",

    "requests"

]



def print_with_delay(text, delay=0.1):

    """Prints text with a delay between characters"""

    for char in text:

        print(char, end='', flush=True)

        time.sleep(delay)

    print()



def install(package):

    """Installs the specified package via pip"""

    subprocess.check_call([sys.executable, "-m", "pip", "install", package])



def check_and_install_modules():

    """Checks and installs required modules"""

    print_with_delay(

        GREEN_TEXT + "Welcome to the Free Proxy installation wizard.\n"

        "Now we will install all dependencies for the program to work properly\n"

        "Installation will not take more than 3 minutes.\n3\n2\n1\n" + RESET)

    

    for module in required_modules:

        try:

            __import__(module)

            print(GREEN_TEXT + f"{module} already installed." + RESET)

        except ImportError:

            print(f"Installation {module}...")

            install(module)

            print_with_delay(GREEN_TEXT + f"Module installed {module}" + RESET)



def user_agents():

    """Generates a random User-Agent"""

    browser_types = ['chrome', 'firefox', 'safari', 'edge']

    random_browser = random.choice(browser_types)

    return getattr(ua, random_browser)



def fetch_proxies():

    """Obtains a list of proxies from various sources"""

    proxies = set()  # Use set to avoid duplicates

    timeout = 300

    urls = [

        "https://api.proxyscrape.com/v3/free-proxy-list/get?request=displayproxies&protocol=http&timeout={timeout}",

        "https://raw.githubusercontent.com/monosans/proxy-list/main/proxies/http.txt"

    ]



    headers = {

        "accept": "text/plain, */*; q=0.01",

        "accept-language": "en-US,en;q=0.8",

        "user-agent": user_agents(),

    }



    for url in urls:

        try:

            response = requests.get(url, headers=headers, timeout=10)

            response.raise_for_status()

            proxies.update(response.text.strip().split('\n'))

        except requests.RequestException as e:

            print(f"{RED_TEXT}Error when receiving a proxy: {e}{RESET}")

    

    return list(proxies)



def is_proxy_working(proxy, timeout=3):

    """Checks if the proxy is functional"""

    try:

        test_url = "http://www.google.com"

        proxies = {"http": f"http://{proxy}"}

        response = requests.get(test_url, proxies=proxies, timeout=timeout)

        return response.status_code == 200

    except:

        return False



def get_country(ip):

    """Determines the country by IP"""

    ip_api_url = "http://ip-api.com/json/"

    try:

        response = requests.get(ip_api_url + ip, timeout=5)

        response.raise_for_status()

        return response.json().get('country', 'Unknown')

    except:

        return "Unknown"



def fetch_and_check_proxies():

    """Basic function of proxy verification"""

    try:

        proxies = fetch_proxies()

        print(f"{GREEN_TEXT}[*] Proxies found: {len(proxies)}{RESET}")



        working_proxies = []

        

        # Processing user input with validation

        while True:

            try:

                limit = int(input("[+] Enter the number of proxies you need: "))

                if limit > 0:

                    break

                print(f"{RED_TEXT}The number must be positive{RESET}")

            except ValueError:

                print(f"{RED_TEXT}Enter an integer{RESET}")



        with ThreadPoolExecutor() as executor:

            futures = []

            for proxy in proxies:

                if len(working_proxies) >= limit:

                    break

                

                futures.append(executor.submit(

                    lambda p: (p, get_country(p.split(':')[0])) if is_proxy_working(p) else (None, None),

                    proxy.strip()

                ))



            for future in futures:

                proxy, country = future.result()

                if proxy:

                    print(f"{GREEN_TEXT}Working proxy: {proxy}, Country: {country}{RESET}")

                    working_proxies.append(proxy)

                    if len(working_proxies) >= limit:

                        break



        # Saving working proxies to a file

        if working_proxies:

            with open("working_proxies.txt", "w") as f:

                f.write("\n".join(working_proxies))

            print(f"{GREEN_TEXT}[*] Working proxies are saved in working_proxies.txt{RESET}")



    except Exception as e:

        print(f"{RED_TEXT}Error: {e}{RESET}")

    finally:

        input(f"{Colors.white}[$] Press Enter to return to the main menu...")



def main():

    """Main function"""

    os.system('cls' if os.name == 'nt' else 'clear')

    check_and_install_modules()

    

    banner = """

    ███████╗██████╗ ███████╗███████╗    ██████╗ ██████╗  ██████╗ ██╗  ██╗██╗   ██╗

    ██╔════╝██╔══██╗██╔════╝██╔════╝    ██╔══██╗██╔══██╗██╔═══██╗╚██╗██╔╝╚██╗ ██╔╝

    █████╗  ██████╔╝█████╗  █████╗      ██████╔╝██████╔╝██║   ██║ ╚███╔╝  ╚████╔╝ 

    ██╔══╝  ██╔══██╗██╔══╝  ██╔══╝      ██╔═══╝ ██╔══██╗██║   ██║ ██╔██╗   ╚██╔╝  

    ██║     ██║  ██║███████╗███████╗    ██║     ██║  ██║╚██████╔╝██╔╝ ██╗   ██║   

    ╚═╝     ╚═╝  ╚═╝╚══════╝╚══════╝    ╚═╝     ╚═╝  ╚═╝ ╚═════╝ ╚═╝  ╚═╝   ╚═╝   

                        [%] Author: DarkG8

    """

    

    os.system('cls' if os.name == 'nt' else 'clear')

    print(Colorate.Horizontal(Colors.purple_to_red, Center.XCenter(banner)))

    

    while True:

        user_response = input(Colors.white + "Want to start looking for proxies? - Yes / No: ").strip().lower()

        if user_response == 'yes':

            fetch_and_check_proxies()

        elif user_response == 'no':

            print("Close the program")

            time.sleep(1)

            sys.exit(0)

        else:

            print(f"{RED_TEXT}The answer Yes or No is accepted{RESET}")



if __name__ == "__main__":

    try:

        main()

    except KeyboardInterrupt:

        print(f"{RED_TEXT}[!] Program terminated by the user{RESET}")

        sys.exit(0)

    except Exception as e:

        print(f"{RED_TEXT}[!] Critical error: {e}{RESET}")

        sys.exit(1)