⚡️ Speed up method Urlizer.handle_word by 7%

[codeflash-ai]

📄 7% (0.07x) speedup for Urlizer.handle_word in django/utils/html.py

⏱️ Runtime : 452 microseconds → 422 microseconds (best of 78 runs)

📝 Explanation and details

The optimized code achieves a 7% speedup through several targeted micro-optimizations that reduce attribute lookup overhead and improve loop efficiency:

What optimizations were applied:

1. Pre-computed attribute lookups in trim_punctuation: Moved repeated self.attribute lookups outside the while loop into local variables, reducing costly attribute resolution on each iteration.

2. Eliminated CountsDict dependency: Replaced the custom CountsDict(word=middle) with a simple dictionary that's populated only when needed inside the loop, avoiding upfront computation overhead.

3. Cached middle length calculation: Added middle_len = len(middle) to avoid recalculating the same length multiple times in URL matching conditions.

4. Early variable binding: Combined the special character check into a single word_has_special variable to avoid repeating the same string containment checks.

Why these optimizations work:

• Attribute lookup reduction: Python attribute access (self.attr) is significantly slower than local variable access. Moving these lookups outside the hot loop eliminates repeated dictionary lookups in the object's __dict__.
• Lazy counting: The original code pre-computed all character counts upfront, but the optimized version only counts when the loop actually needs the values, reducing work for words that don't require extensive punctuation trimming.
• Loop efficiency: The while loop in trim_punctuation is called for every word with special characters, so minimizing operations inside it has compounding effects.

Test case performance patterns:
The optimization shows consistent 5-18% improvements across all test cases involving punctuation trimming, URL processing, and email handling. The gains are most pronounced in cases with complex punctuation (like "foo:bar" showing 18.7% improvement) because these trigger the optimized punctuation trimming logic most heavily.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import re

# imports
import pytest
from django.utils.html import Urlizer


# Minimal SafeString and mark_safe for testing
class SafeString(str):
    pass

# Constants and helpers for testing
MAX_URL_LENGTH = 200  # Arbitrary for test, Django uses 2000

# Instantiate the Urlizer for tests
urlizer = Urlizer()

# ------------------------
# Basic Test Cases
# ------------------------





def test_basic_non_url_word():
    # Should return non-URL word unchanged
    codeflash_output = urlizer.handle_word("hello", safe_input=False); result = codeflash_output # 798ns -> 840ns (5.00% slower)

# ------------------------
# Edge Test Cases
# ------------------------

def test_leading_punctuation():
    # Should trim leading punctuation before linkifying
    codeflash_output = urlizer.handle_word("(http://example.com)", safe_input=False); result = codeflash_output # 24.8μs -> 23.1μs (7.62% faster)

def test_trailing_punctuation():
    # Should trim trailing punctuation after linkifying
    codeflash_output = urlizer.handle_word("http://example.com.", safe_input=False); result = codeflash_output # 20.8μs -> 19.4μs (7.39% faster)


def test_url_with_query_and_fragment():
    # Should preserve query and fragment in href
    url = "https://foo.com/path?query=1#frag"
    codeflash_output = urlizer.handle_word(url, safe_input=False); result = codeflash_output # 37.1μs -> 34.9μs (6.40% faster)

def test_email_with_plus_and_dot():
    # Should encode plus and dot in local part
    email = "john.doe+spam@example.com"
    codeflash_output = urlizer.handle_word(email, safe_input=False); result = codeflash_output # 31.8μs -> 30.2μs (5.49% faster)

def test_url_with_max_length_trimming():
    # Should trim displayed URL if over limit
    url = "http://example.com/" + "a" * 50
    codeflash_output = urlizer.handle_word(url, safe_input=False, trim_url_limit=20); result = codeflash_output # 23.9μs -> 22.3μs (7.36% faster)

def test_autoescape_true():
    # Should escape unsafe characters if autoescape is True
    codeflash_output = urlizer.handle_word('<script>http://evil.com</script>', safe_input=False, autoescape=True); result = codeflash_output # 12.6μs -> 11.2μs (12.5% faster)

def test_safe_input_true():
    # Should not escape if safe_input is True
    codeflash_output = urlizer.handle_word("<b>http://foo.com</b>", safe_input=True); result = codeflash_output # 10.8μs -> 9.45μs (14.3% faster)

def test_non_url_with_dot_and_at():
    # Should not linkify if not a valid email or URL
    codeflash_output = urlizer.handle_word("notanemail@notadomain", safe_input=False); result = codeflash_output # 20.5μs -> 19.7μs (3.70% faster)

def test_non_url_with_colon():
    # Should not linkify if not a valid URL
    codeflash_output = urlizer.handle_word("foo:bar", safe_input=False); result = codeflash_output # 9.33μs -> 7.86μs (18.7% faster)

def test_url_with_trailing_semicolon():
    # Should trim trailing semicolon
    codeflash_output = urlizer.handle_word("http://example.com;", safe_input=False); result = codeflash_output # 21.8μs -> 20.7μs (5.33% faster)

def test_url_with_multiple_punctuations():
    # Should trim multiple trailing punctuation
    codeflash_output = urlizer.handle_word("http://example.com...!", safe_input=False); result = codeflash_output # 19.8μs -> 18.4μs (7.62% faster)

def test_email_with_subdomain():
    # Should linkify email with subdomain
    email = "user@mail.example.com"
    codeflash_output = urlizer.handle_word(email, safe_input=False); result = codeflash_output # 25.0μs -> 24.0μs (3.81% faster)

def test_url_with_ipv6():
    # Should linkify IPv6 URLs
    url = "http://[2001:db8::1]/foo"
    codeflash_output = urlizer.handle_word(url, safe_input=False); result = codeflash_output # 19.4μs -> 18.3μs (5.92% faster)

def test_url_with_unicode():
    # Should handle unicode characters in URL
    url = "http://exämple.com"
    codeflash_output = urlizer.handle_word(url, safe_input=False); result = codeflash_output # 21.3μs -> 19.7μs (8.41% faster)

def test_email_with_unicode():
    # Should encode unicode in email
    email = "üser@exämple.com"
    codeflash_output = urlizer.handle_word(email, safe_input=False); result = codeflash_output # 16.1μs -> 14.8μs (9.30% faster)

# ------------------------
# Large Scale Test Cases
# ------------------------


def test_long_url():
    # Should handle very long URLs up to MAX_URL_LENGTH
    long_url = "http://" + "a" * (MAX_URL_LENGTH - 7) + ".com"
    codeflash_output = urlizer.handle_word(long_url, safe_input=False); result = codeflash_output # 31.4μs -> 28.8μs (8.87% faster)

def test_long_email():
    # Should handle very long emails
    local = "a" * 400
    domain = "b" * 400 + ".com"
    email = f"{local}@{domain}"
    codeflash_output = urlizer.handle_word(email, safe_input=False); result = codeflash_output # 18.9μs -> 17.9μs (5.43% faster)



#------------------------------------------------
import re

# imports
import pytest
from django.utils.html import Urlizer


# Minimal SafeString and mark_safe implementation for testing
class SafeString(str):
    pass

def EmailValidator(allowlist=None):
    def validate(value):
        # Basic email validation for testing
        if not re.match(r"^[^@]+@[^@]+\.[^@]+$", value):
            raise ValueError("Invalid email")
    return validate

# Constants
MAX_URL_LENGTH = 2000

# handle_word function to test
def handle_word(
    word,
    *,
    safe_input,
    trim_url_limit=None,
    nofollow=False,
    autoescape=False,
):
    # Helper: is_email_simple
    def is_email_simple(value):
        try:
            EmailValidator()(value)
        except Exception:
            return False
        return True

    # Helper: trim_url
    def trim_url(x, limit):
        if limit is None or len(x) <= limit:
            return x
        return "%s…" % x[: max(0, limit - 1)]

    # Helper: trim_punctuation
    trailing_punctuation_chars = ".,:;!"
    wrapping_punctuation = [("(", ")"), ("[", "]")]
    def trim_punctuation(word):
        # Strip all opening wrapping punctuation.
        middle = word
        lead = ""
        trail = ""
        changed = True
        while changed and middle:
            changed = False
            for opening, closing in wrapping_punctuation:
                if middle.startswith(opening):
                    lead += opening
                    middle = middle[1:]
                    changed = True
                if middle.endswith(closing):
                    trail = closing + trail
                    middle = middle[:-1]
                    changed = True
            if middle and middle[-1] in trailing_punctuation_chars:
                trail = middle[-1] + trail
                middle = middle[:-1]
                changed = True
            if middle and middle[0] in trailing_punctuation_chars:
                lead += middle[0]
                middle = middle[1:]
                changed = True
        return lead, middle, trail

    # Main logic
    if "." in word or "@" in word or ":" in word:
        lead, middle, trail = trim_punctuation(word)
        url = None
        nofollow_attr = ' rel="nofollow"' if nofollow else ""
        # Basic http(s) url
        if len(middle) <= MAX_URL_LENGTH and re.match(r"^https?://", middle, re.IGNORECASE):
            url = smart_urlquote(middle)
        # Basic www or domain url
        elif len(middle) <= MAX_URL_LENGTH and (
            re.match(r"^www\.", middle, re.IGNORECASE)
            or re.match(r"^[^@]+?\.(com|edu|gov|int|mil|net|org)($|/.*)$", middle, re.IGNORECASE)
        ):
            url = smart_urlquote(f"http://{middle}")
        # Email
        elif ":" not in middle and is_email_simple(middle):
            local, domain = middle.rsplit("@", 1)
            import urllib.parse
            local = urllib.parse.quote(local, safe="")
            domain = urllib.parse.quote(domain, safe="")
            url = f"mailto:{local}@{domain}"
            nofollow_attr = ""
        # Make link
        if url:
            trimmed = trim_url(middle, trim_url_limit)
            if autoescape and not safe_input:
                lead, trail = escape(lead), escape(trail)
                trimmed = escape(trimmed)
            middle = f'<a href="{escape(url)}"{nofollow_attr}>{trimmed}</a>'
            return mark_safe(f"{lead}{middle}{trail}")
        else:
            if safe_input:
                return mark_safe(word)
            elif autoescape:
                return escape(word)
    elif safe_input:
        return mark_safe(word)
    elif autoescape:
        return escape(word)
    return word

# ============================
# Unit Tests for handle_word
# ============================

# 1. Basic Test Cases

To edit these changes git checkout codeflash/optimize-Urlizer.handle_word-mh6sp5jl and push.