⚡️ Speed up function is_valid_cidr by 23%

[codeflash-ai]

📄 23% (0.23x) speedup for is_valid_cidr in src/requests/utils.py

⏱️ Runtime : 1.66 milliseconds → 1.34 milliseconds (best of 193 runs)

📝 Explanation and details

The optimization replaces inefficient string operations with a single, more efficient parsing approach:

Key Changes:

• Replaced .count("/") + multiple .split("/") calls with .partition('/'): The original code calls string_network.split("/") twice - once to extract the mask and once to extract the IP address. The optimized version uses partition('/') which splits the string into exactly three parts (before slash, slash, after slash) in a single operation.

Why This is Faster:

• Eliminates redundant string parsing: .partition() scans the string once and returns all needed components, while the original approach scans multiple times with .count() and .split().
• Reduces object allocations: .split("/") creates a new list each time it's called, whereas .partition() creates a single tuple with fixed size.
• More direct validation: Checking sep != '/' directly validates the slash presence instead of counting occurrences.

Performance Characteristics:
The optimization shows consistent 20-30% speedups across most test cases, particularly excelling with:

• Valid CIDR inputs (24-30% faster): Where both IP validation and mask parsing occur
• Invalid mask scenarios (20-28% faster): Still benefits from efficient initial parsing
• Large-scale operations (25-32% faster): The reduced per-call overhead compounds significantly

The optimization maintains identical behavior and error handling while reducing string processing overhead, making it especially beneficial for applications that validate many CIDR strings.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	✅ 60 Passed
🌀 Generated Regression Tests	✅ 3727 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	🔘 None Found
📊 Tests Coverage	100.0%

⚙️ Existing Unit Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
test_utils.py::TestIsValidCIDR.test_invalid	8.25μs	7.18μs	15.0%✅
test_utils.py::TestIsValidCIDR.test_valid	2.19μs	1.68μs	30.1%✅

🌀 Generated Regression Tests and Runtime

import socket

# imports
import pytest  # used for our unit tests
from requests.utils import is_valid_cidr

# unit tests

# ----------------------------
# 1. Basic Test Cases
# ----------------------------

def test_valid_cidr_typical():
    # Typical valid CIDR
    codeflash_output = is_valid_cidr("192.168.1.0/24") # 1.87μs -> 1.51μs (24.0% faster)

def test_valid_cidr_min_mask():
    # Valid CIDR with minimum mask
    codeflash_output = is_valid_cidr("10.0.0.0/1") # 1.88μs -> 1.48μs (27.5% faster)

def test_valid_cidr_max_mask():
    # Valid CIDR with maximum mask
    codeflash_output = is_valid_cidr("172.16.0.0/32") # 1.79μs -> 1.44μs (25.0% faster)

def test_invalid_cidr_no_slash():
    # No slash present
    codeflash_output = is_valid_cidr("192.168.1.0") # 476ns -> 585ns (18.6% slower)

def test_invalid_cidr_two_slashes():
    # Two slashes present
    codeflash_output = is_valid_cidr("192.168.1.0/24/8") # 508ns -> 2.42μs (79.0% slower)

def test_invalid_cidr_non_numeric_mask():
    # Mask is not a number
    codeflash_output = is_valid_cidr("192.168.1.0/abc") # 2.66μs -> 2.06μs (29.2% faster)

def test_invalid_cidr_mask_zero():
    # Mask is 0 (invalid, must be >=1)
    codeflash_output = is_valid_cidr("10.0.0.0/0") # 1.09μs -> 923ns (18.3% faster)

def test_invalid_cidr_mask_too_large():
    # Mask is 33 (invalid, must be <=32)
    codeflash_output = is_valid_cidr("10.0.0.0/33") # 1.16μs -> 898ns (28.8% faster)

def test_invalid_cidr_bad_ip():
    # IP address is invalid
    codeflash_output = is_valid_cidr("999.999.999.999/24") # 2.59μs -> 2.32μs (11.6% faster)

# ----------------------------
# 2. Edge Test Cases
# ----------------------------

def test_invalid_cidr_empty_string():
    # Empty string input
    codeflash_output = is_valid_cidr("") # 505ns -> 605ns (16.5% slower)

def test_invalid_cidr_slash_only():
    # Just a slash
    codeflash_output = is_valid_cidr("/") # 2.44μs -> 2.19μs (11.2% faster)

def test_invalid_cidr_ip_missing():
    # Missing IP, only mask
    codeflash_output = is_valid_cidr("/24") # 2.31μs -> 2.06μs (12.2% faster)

def test_invalid_cidr_mask_missing():
    # Missing mask, only IP and slash
    codeflash_output = is_valid_cidr("192.168.1.0/") # 2.45μs -> 2.26μs (8.47% faster)

def test_invalid_cidr_leading_trailing_spaces():
    # Spaces around input
    codeflash_output = is_valid_cidr(" 192.168.1.0/24 ") # 2.37μs -> 2.03μs (16.6% faster)

def test_invalid_cidr_mask_negative():
    # Negative mask
    codeflash_output = is_valid_cidr("192.168.1.0/-1") # 1.17μs -> 930ns (25.5% faster)

def test_invalid_cidr_ip_with_leading_zeros():
    # IP with leading zeros is technically valid for inet_aton, but not all systems treat it as such
    codeflash_output = is_valid_cidr("010.000.000.001/8") # 2.06μs -> 1.67μs (23.4% faster)

def test_invalid_cidr_non_ascii_characters():
    # Non-ASCII characters in input
    codeflash_output = is_valid_cidr("192.168.1.0/２４") # 3.04μs -> 2.51μs (21.1% faster)

def test_invalid_cidr_ipv6_not_supported():
    # IPv6 address
    codeflash_output = is_valid_cidr("2001:db8::/32") # 2.33μs -> 1.99μs (17.4% faster)

def test_invalid_cidr_mask_float():
    # Mask is a float
    codeflash_output = is_valid_cidr("192.168.1.0/24.0") # 2.65μs -> 2.26μs (17.4% faster)

def test_invalid_cidr_ip_extra_octets():
    # Too many octets in IP
    codeflash_output = is_valid_cidr("192.168.1.1.1/24") # 2.30μs -> 2.01μs (14.3% faster)

def test_invalid_cidr_ip_too_few_octets():
    # Too few octets in IP
    codeflash_output = is_valid_cidr("192.168/24") # 1.72μs -> 1.36μs (26.3% faster)

def test_invalid_cidr_ip_letters():
    # Letters in IP
    codeflash_output = is_valid_cidr("abc.def.ghi.jkl/24") # 2.12μs -> 1.82μs (16.5% faster)

def test_invalid_cidr_ip_empty_octet():
    # Empty octet in IP
    codeflash_output = is_valid_cidr("192..1.1/24") # 2.11μs -> 1.74μs (21.0% faster)

def test_invalid_cidr_mask_leading_zero():
    # Mask with leading zero (should parse as int)
    codeflash_output = is_valid_cidr("192.168.1.0/08") # 1.91μs -> 1.43μs (33.6% faster)

def test_invalid_cidr_ip_zero():
    # 0.0.0.0/1 is valid
    codeflash_output = is_valid_cidr("0.0.0.0/1") # 1.78μs -> 1.42μs (25.7% faster)

def test_invalid_cidr_ip_broadcast():
    # 255.255.255.255/32 is valid
    codeflash_output = is_valid_cidr("255.255.255.255/32") # 1.81μs -> 1.42μs (27.0% faster)

def test_invalid_cidr_ip_trailing_dot():
    # IP with trailing dot is invalid for inet_aton
    codeflash_output = is_valid_cidr("192.168.1.0./24") # 2.18μs -> 1.93μs (13.2% faster)

def test_invalid_cidr_mask_with_plus_sign():
    # Mask with plus sign
    codeflash_output = is_valid_cidr("192.168.1.0/+24") # 1.84μs -> 1.44μs (27.9% faster)

# ----------------------------
# 3. Large Scale Test Cases
# ----------------------------

def test_large_scale_valid_cidrs():
    # Test a large list of valid CIDRs to check performance and correctness
    base_ip = "10.0.0."
    for i in range(1, 1000):  # 10.0.0.1/8 to 10.0.0.999/8
        cidr = f"{base_ip}{i}/8"
        codeflash_output = is_valid_cidr(cidr) # 550μs -> 436μs (26.0% faster)

def test_large_scale_invalid_cidrs_masks():
    # Test a large list of invalid CIDRs with out-of-range masks
    base_ip = "10.0.0."
    for i in range(1, 1000):
        cidr = f"{base_ip}{i}/0"  # mask 0 is invalid
        codeflash_output = is_valid_cidr(cidr) # 300μs -> 243μs (23.3% faster)
        cidr = f"{base_ip}{i}/33"  # mask 33 is invalid
        codeflash_output = is_valid_cidr(cidr)

def test_large_scale_invalid_cidrs_ips():
    # Test a large list of invalid CIDRs with bad IPs
    for i in range(256, 256 + 100):  # invalid first octet
        cidr = f"{i}.0.0.1/24"
        codeflash_output = is_valid_cidr(cidr) # 60.8μs -> 48.5μs (25.3% faster)


def test_large_scale_invalid_last_octet():
    for i in range(256, 512):
        cidr = f"10.0.0.{i}/24"
        codeflash_output = is_valid_cidr(cidr) # 157μs -> 125μs (25.6% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import socket

# imports
import pytest  # used for our unit tests
from requests.utils import is_valid_cidr

# unit tests

# --- Basic Test Cases ---

def test_valid_cidr_typical():
    # Typical valid CIDR
    codeflash_output = is_valid_cidr("192.168.1.0/24") # 2.63μs -> 2.11μs (24.7% faster)
    codeflash_output = is_valid_cidr("10.0.0.0/8") # 1.05μs -> 815ns (29.4% faster)
    codeflash_output = is_valid_cidr("172.16.0.0/16") # 762ns -> 518ns (47.1% faster)

def test_invalid_cidr_missing_slash():
    # Missing slash
    codeflash_output = not is_valid_cidr("192.168.1.0") # 519ns -> 577ns (10.1% slower)
    codeflash_output = not is_valid_cidr("10.0.0.0 8") # 276ns -> 241ns (14.5% faster)

def test_invalid_cidr_non_integer_mask():
    # Non-integer mask
    codeflash_output = not is_valid_cidr("192.168.1.0/abc") # 2.64μs -> 2.41μs (9.68% faster)
    codeflash_output = not is_valid_cidr("10.0.0.0/8.5") # 1.11μs -> 960ns (15.6% faster)

def test_invalid_cidr_mask_out_of_range():
    # Mask out of valid range
    codeflash_output = not is_valid_cidr("192.168.1.0/0") # 1.11μs -> 864ns (28.0% faster)
    codeflash_output = not is_valid_cidr("10.0.0.0/33") # 722ns -> 579ns (24.7% faster)

def test_invalid_cidr_bad_ip():
    # Invalid IP addresses
    codeflash_output = not is_valid_cidr("999.999.999.999/24") # 2.39μs -> 2.07μs (15.3% faster)
    codeflash_output = not is_valid_cidr("256.0.0.1/8") # 1.02μs -> 824ns (24.2% faster)
    codeflash_output = not is_valid_cidr("abc.def.ghi.jkl/16") # 732ns -> 579ns (26.4% faster)
    codeflash_output = not is_valid_cidr("192.168.1/24") # 759ns -> 605ns (25.5% faster)

# --- Edge Test Cases ---

def test_valid_cidr_edge_masks():
    # Edge valid masks
    codeflash_output = is_valid_cidr("1.2.3.4/1") # 1.67μs -> 1.35μs (23.1% faster)
    codeflash_output = is_valid_cidr("255.255.255.255/32") # 998ns -> 789ns (26.5% faster)

def test_invalid_cidr_multiple_slashes():
    # Multiple slashes
    codeflash_output = not is_valid_cidr("192.168.1.0/24/extra") # 547ns -> 2.29μs (76.2% slower)
    codeflash_output = not is_valid_cidr("1.2.3.4/32/1") # 310ns -> 1.02μs (69.5% slower)

def test_invalid_cidr_empty_string():
    # Empty string
    codeflash_output = not is_valid_cidr("") # 484ns -> 571ns (15.2% slower)
    # Only slash
    codeflash_output = not is_valid_cidr("/") # 2.28μs -> 1.77μs (29.0% faster)
    # Slash with no IP or mask
    codeflash_output = not is_valid_cidr("/24") # 1.56μs -> 1.35μs (15.9% faster)
    codeflash_output = not is_valid_cidr("192.168.1.0/") # 914ns -> 825ns (10.8% faster)

def test_invalid_cidr_leading_trailing_spaces():
    # Leading/trailing spaces
    codeflash_output = not is_valid_cidr(" 192.168.1.0/24") # 1.85μs -> 1.53μs (21.1% faster)
    codeflash_output = not is_valid_cidr("192.168.1.0/24 ") # 1.09μs -> 843ns (29.1% faster)
    codeflash_output = not is_valid_cidr(" 192.168.1.0/24 ") # 707ns -> 548ns (29.0% faster)

def test_invalid_cidr_leading_zeros():
    # Leading zeros in IP
    codeflash_output = is_valid_cidr("192.168.001.000/24") # 1.60μs -> 1.30μs (23.4% faster)

def test_invalid_cidr_negative_mask():
    # Negative mask
    codeflash_output = not is_valid_cidr("192.168.1.0/-1") # 1.06μs -> 864ns (22.8% faster)

def test_invalid_cidr_mask_with_plus_sign():
    # Mask with plus sign
    codeflash_output = is_valid_cidr("192.168.1.0/+24") # 1.76μs -> 1.33μs (32.5% faster)

def test_invalid_cidr_mask_with_leading_zeros():
    # Mask with leading zeros
    codeflash_output = is_valid_cidr("192.168.1.0/08") # 1.70μs -> 1.31μs (29.5% faster)

def test_invalid_cidr_ipv6_address():
    # IPv6 addresses (should fail, only IPv4 supported)
    codeflash_output = not is_valid_cidr("2001:db8::/32") # 2.18μs -> 1.85μs (17.4% faster)
    codeflash_output = not is_valid_cidr("::1/128") # 720ns -> 609ns (18.2% faster)

def test_invalid_cidr_extra_characters():
    # Extra characters after mask
    codeflash_output = not is_valid_cidr("192.168.1.0/24abc") # 2.54μs -> 2.30μs (10.5% faster)
    codeflash_output = not is_valid_cidr("192.168.1.0/24 ") # 1.41μs -> 1.15μs (23.1% faster)

# --- Large Scale Test Cases ---

def test_large_scale_all_masks():
    # Test all valid masks for a single IP
    for mask in range(1, 33):
        cidr = f"10.1.2.3/{mask}"
        codeflash_output = is_valid_cidr(cidr) # 17.0μs -> 13.1μs (30.0% faster)

def test_large_scale_various_ips():
    # Test a large number of valid IPs with a fixed mask
    for i in range(1, 255):
        cidr = f"192.168.0.{i}/24"
        codeflash_output = is_valid_cidr(cidr) # 127μs -> 96.2μs (32.6% faster)

def test_large_scale_invalid_masks():
    # Test a large number of invalid masks
    for mask in [-10, 0, 33, 100, 999]:
        cidr = f"10.0.0.1/{mask}"
        codeflash_output = not is_valid_cidr(cidr) # 3.19μs -> 2.63μs (21.2% faster)

def test_large_scale_invalid_ips():
    # Test a large number of invalid IPs
    for i in range(256, 266):
        cidr = f"10.0.0.{i}/24"
        codeflash_output = not is_valid_cidr(cidr) # 7.85μs -> 6.64μs (18.2% faster)

def test_large_scale_random_garbage():
    # Random garbage strings
    garbage = [
        "hello/world",
        "1234/56/78",
        "10.0.0.1//24",
        "10.0.0.1/24/32",
        "....../24",
        "10.0.0.1/2.4",
        "10.0.0.1/",
        "/24",
        "10.0.0.1/ 24",
        "10.0.0.1/24 ",
        " 10.0.0.1/24",
        "10.0.0.1/24\n",
        "\t10.0.0.1/24"
    ]
    for s in garbage:
        codeflash_output = not is_valid_cidr(s) # 10.8μs -> 10.8μs (0.288% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

To edit these changes git checkout codeflash/optimize-is_valid_cidr-mgpwicoy and push.