ip_gen.py

import argparse
import ipaddress
import json
import os
import random

CONFIG_FILE = "subnets.json"
DEFAULT_COUNT = 1000
DEFAULT_OUTPUT_FILE = "ips.txt"


def positive_int(value):
    parsed = int(value)
    if parsed <= 0:
        raise argparse.ArgumentTypeError("must be greater than 0")
    return parsed


def get_subnet_weight(value):
    if isinstance(value, dict):
        return max(0.01, float(value.get("weight", 0.1)))
    return max(0.01, float(value))


def generate_weighted_ips(count=DEFAULT_COUNT, output_file=DEFAULT_OUTPUT_FILE, config_file=CONFIG_FILE):
    """
    Generates `count` Cloudflare IPs weighted by performance recorded in `config_file`.
    Writes them to `output_file` (if output_file is not None) and returns the list of IPs.
    """
    if not os.path.exists(config_file):
        raise FileNotFoundError(f"Subnets file '{config_file}' not found.")

    with open(config_file, "r") as f:
        subnet_data = json.load(f)

    subnets = list(subnet_data.keys())
    if not subnets:
        raise ValueError("No subnets found in configuration file.")

    weights = [get_subnet_weight(value) for value in subnet_data.values()]

    # Select subnets based on weights
    chosen_subnets = random.choices(subnets, weights=weights, k=count)

    generated_ips = []
    for cidr in chosen_subnets:
        net = ipaddress.ip_network(cidr)
        # Avoid network and broadcast address if possible
        if net.num_addresses > 2:
            idx = random.randint(1, net.num_addresses - 2)
        else:
            idx = random.randint(0, net.num_addresses - 1)
        random_ip = str(net[idx])
        generated_ips.append(random_ip)

    if output_file:
        os.makedirs(os.path.dirname(output_file) if os.path.dirname(output_file) else ".", exist_ok=True)
        with open(output_file, "w") as f:
            for ip in generated_ips:
                f.write(ip + "\n")
        print(f"Generated {len(generated_ips)} IPs weighted by subnet performance into {output_file}.")

    return generated_ips


def parse_args():
    parser = argparse.ArgumentParser(description="Generate weighted Cloudflare IP candidates.")
    parser.add_argument(
        "-n", "--count",
        type=positive_int,
        default=DEFAULT_COUNT,
        help=f"Number of IPs to generate (default: {DEFAULT_COUNT})."
    )
    parser.add_argument(
        "-o", "--output",
        default=DEFAULT_OUTPUT_FILE,
        help=f"Destination file for generated IPs (default: {DEFAULT_OUTPUT_FILE})."
    )
    parser.add_argument(
        "-s", "--config",
        default=CONFIG_FILE,
        help=f"Path to subnets JSON file (default: {CONFIG_FILE})."
    )
    return parser.parse_args()


def main():
    args = parse_args()
    generate_weighted_ips(args.count, args.output, args.config)


if __name__ == "__main__":
    main()