⚡️ Speed up function merge_cookies by 103% in src/requests/cookies.py

[codeflash-ai]

📄 merge_cookies() in src/requests/cookies.py

📈 Performance improved by 103% (1.03x faster)

⏱️ Runtime went down from 35.0 milliseconds to 17.3 milliseconds (best of 88 runs)

Explanation and details

The original code is clean, but a few optimizations can be introduced to make it more efficient. We can optimize the list comprehension within the cookiejar_from_dict function by converting the existing cookie names to a set for O(1) average-time complexity membership checking. Additionally, we can use update instead of the loop for merging cookies when possible. Here's the optimized version.

Explanation of changes.

1. Set for membership checking: Using a set in names_from_jar ensures that the lookup time complexity is O(1) on average, which is significantly efficient compared to using a list.
2. Directly iterate with items in cookie_dict: Using items() in the dictionary iteration directly provides the key-value pairs, producing cleaner and slightly more efficient code.
3. Small adjustment in the merge_cookies function: Simplified the existing loop that adds cookies from cookies into cookiejar.

These changes make the code both faster and cleaner while maintaining the original logic and functionality.

Correctness verification

The new optimized code was tested for correctness. The results are listed below.

🔘 (none found) − ⚙️ Existing Unit Tests

✅ 46 Passed − 🌀 Generated Regression Tests

(click to show generated tests)

from http.cookiejar import Cookie, CookieJar

import pytest  # used for our unit tests
from requests.cookies import RequestsCookieJar, create_cookie
# function to test
from src.requests.compat import cookielib
from src.requests.cookies import merge_cookies

# unit tests

def test_merge_cookies_basic_dict_into_empty_cookiejar():
    # Merging a dictionary of cookies into an empty CookieJar
    cookiejar = RequestsCookieJar()
    cookies = {'session': 'abc123', 'user': 'john_doe'}
    codeflash_output = merge_cookies(cookiejar, cookies)
    # Outputs were verified to be equal to the original implementation

def test_merge_cookies_basic_dict_into_non_empty_cookiejar():
    # Merging a dictionary of cookies into a non-empty CookieJar
    cookiejar = RequestsCookieJar()
    cookiejar.set_cookie(create_cookie('session', 'xyz789'))
    cookies = {'user': 'john_doe'}
    codeflash_output = merge_cookies(cookiejar, cookies)
    # Outputs were verified to be equal to the original implementation

def test_merge_cookies_basic_cookiejar_into_empty_cookiejar():
    # Merging a CookieJar into another empty CookieJar
    cookiejar = RequestsCookieJar()
    cookies = RequestsCookieJar()
    cookies.set_cookie(create_cookie('session', 'abc123'))
    codeflash_output = merge_cookies(cookiejar, cookies)
    # Outputs were verified to be equal to the original implementation

def test_merge_cookies_basic_cookiejar_into_non_empty_cookiejar():
    # Merging a CookieJar into a non-empty CookieJar
    cookiejar = RequestsCookieJar()
    cookiejar.set_cookie(create_cookie('session', 'xyz789'))
    cookies = RequestsCookieJar()
    cookies.set_cookie(create_cookie('user', 'john_doe'))
    codeflash_output = merge_cookies(cookiejar, cookies)
    # Outputs were verified to be equal to the original implementation

def test_merge_cookies_empty_dict():
    # Empty cookies dictionary
    cookiejar = RequestsCookieJar()
    cookiejar.set_cookie(create_cookie('session', 'xyz789'))
    cookies = {}
    codeflash_output = merge_cookies(cookiejar, cookies)
    # Outputs were verified to be equal to the original implementation

def test_merge_cookies_none_dict():
    # None as cookies dictionary
    cookiejar = RequestsCookieJar()
    cookiejar.set_cookie(create_cookie('session', 'xyz789'))
    cookies = None
    codeflash_output = merge_cookies(cookiejar, cookies)
    # Outputs were verified to be equal to the original implementation

def test_merge_cookies_empty_cookiejar():
    # Empty CookieJar as cookies
    cookiejar = RequestsCookieJar()
    cookiejar.set_cookie(create_cookie('session', 'xyz789'))
    cookies = RequestsCookieJar()
    codeflash_output = merge_cookies(cookiejar, cookies)
    # Outputs were verified to be equal to the original implementation

def test_merge_cookies_none_cookiejar():
    # None as cookiejar
    cookiejar = None
    cookies = {'session': 'abc123'}
    with pytest.raises(ValueError):
        merge_cookies(cookiejar, cookies)
    # Outputs were verified to be equal to the original implementation


def test_merge_cookies_overwrite_existing():
    # Overwriting existing cookies in CookieJar
    cookiejar = RequestsCookieJar()
    cookiejar.set_cookie(create_cookie('session', 'xyz789'))
    cookies = {'session': 'abc123'}
    codeflash_output = merge_cookies(cookiejar, cookies)
    # Outputs were verified to be equal to the original implementation

def test_merge_cookies_large_dict():
    # Merging a large dictionary of cookies into an empty CookieJar
    cookiejar = RequestsCookieJar()
    cookies = {f'cookie_{i}': f'value_{i}' for i in range(1000)}
    codeflash_output = merge_cookies(cookiejar, cookies)
    for i in range(1000):
        pass
    # Outputs were verified to be equal to the original implementation

def test_merge_cookies_large_cookiejar():
    # Merging a large CookieJar into another empty CookieJar
    cookiejar = RequestsCookieJar()
    cookies = RequestsCookieJar()
    for i in range(1000):
        cookies.set_cookie(create_cookie(f'cookie_{i}', f'value_{i}'))
    codeflash_output = merge_cookies(cookiejar, cookies)
    for i in range(1000):
        pass
    # Outputs were verified to be equal to the original implementation

def test_merge_cookies_sequential_dicts():
    # Merging multiple dictionaries sequentially
    cookiejar = RequestsCookieJar()
    for i in range(10):
        cookies = {f'cookie_{i*100 + j}': f'value_{i*100 + j}' for j in range(100)}
        codeflash_output = merge_cookies(cookiejar, cookies)
    for i in range(1000):
        pass
    # Outputs were verified to be equal to the original implementation

def test_merge_cookies_sequential_cookiejars():
    # Merging multiple CookieJar objects sequentially
    cookiejar = RequestsCookieJar()
    for i in range(10):
        cookies = RequestsCookieJar()
        for j in range(100):
            cookies.set_cookie(create_cookie(f'cookie_{i*100 + j}', f'value_{i*100 + j}'))
        codeflash_output = merge_cookies(cookiejar, cookies)
    for i in range(1000):
        pass
    # Outputs were verified to be equal to the original implementation

def test_merge_cookies_invalid_cookiejar_type():
    # Invalid cookiejar type
    cookiejar = ['session', 'abc123']
    cookies = {'user': 'john_doe'}
    with pytest.raises(ValueError):
        merge_cookies(cookiejar, cookies)
    # Outputs were verified to be equal to the original implementation



from http.cookiejar import Cookie, CookieJar

import pytest  # used for our unit tests
from requests.cookies import RequestsCookieJar, create_cookie
# function to test
from src.requests.compat import cookielib
from src.requests.cookies import merge_cookies

# unit tests

# Helper function to create a CookieJar from a dictionary
def create_cookiejar_from_dict(cookie_dict):
    jar = RequestsCookieJar()
    for name, value in cookie_dict.items():
        jar.set_cookie(create_cookie(name, value))
    return jar

# Basic Functionality
def test_merge_dict_into_empty_cookiejar():
    cookiejar = RequestsCookieJar()
    cookies = {'key1': 'value1', 'key2': 'value2'}
    codeflash_output = merge_cookies(cookiejar, cookies)
    # Outputs were verified to be equal to the original implementation

def test_merge_cookiejar_into_empty_cookiejar():
    cookiejar = RequestsCookieJar()
    cookies = create_cookiejar_from_dict({'key1': 'value1', 'key2': 'value2'})
    codeflash_output = merge_cookies(cookiejar, cookies)
    # Outputs were verified to be equal to the original implementation

# Overlapping Cookies
def test_merge_dict_with_overlapping_keys():
    cookiejar = create_cookiejar_from_dict({'key1': 'value1'})
    cookies = {'key1': 'new_value1', 'key2': 'value2'}
    codeflash_output = merge_cookies(cookiejar, cookies)
    # Outputs were verified to be equal to the original implementation

def test_merge_cookiejar_with_overlapping_cookies():
    cookiejar = create_cookiejar_from_dict({'key1': 'value1'})
    cookies = create_cookiejar_from_dict({'key1': 'new_value1', 'key2': 'value2'})
    codeflash_output = merge_cookies(cookiejar, cookies)
    # Outputs were verified to be equal to the original implementation

# Non-Overlapping Cookies
def test_merge_dict_with_non_overlapping_keys():
    cookiejar = create_cookiejar_from_dict({'key1': 'value1'})
    cookies = {'key2': 'value2', 'key3': 'value3'}
    codeflash_output = merge_cookies(cookiejar, cookies)
    # Outputs were verified to be equal to the original implementation

def test_merge_cookiejar_with_non_overlapping_cookies():
    cookiejar = create_cookiejar_from_dict({'key1': 'value1'})
    cookies = create_cookiejar_from_dict({'key2': 'value2', 'key3': 'value3'})
    codeflash_output = merge_cookies(cookiejar, cookies)
    # Outputs were verified to be equal to the original implementation

# Edge Cases
def test_merge_empty_dict():
    cookiejar = create_cookiejar_from_dict({'key1': 'value1'})
    cookies = {}
    codeflash_output = merge_cookies(cookiejar, cookies)
    # Outputs were verified to be equal to the original implementation

def test_merge_empty_cookiejar():
    cookiejar = create_cookiejar_from_dict({'key1': 'value1'})
    cookies = RequestsCookieJar()
    codeflash_output = merge_cookies(cookiejar, cookies)
    # Outputs were verified to be equal to the original implementation

def test_merge_none_as_cookies():
    cookiejar = create_cookiejar_from_dict({'key1': 'value1'})
    cookies = None
    codeflash_output = merge_cookies(cookiejar, cookies)
    # Outputs were verified to be equal to the original implementation

# Invalid Inputs
def test_invalid_cookiejar_type():
    with pytest.raises(ValueError):
        merge_cookies([], {'key1': 'value1'})
    # Outputs were verified to be equal to the original implementation


def test_large_dict():
    cookiejar = RequestsCookieJar()
    cookies = {f'key{i}': f'value{i}' for i in range(1000)}
    codeflash_output = merge_cookies(cookiejar, cookies)
    for i in range(1000):
        pass
    # Outputs were verified to be equal to the original implementation

def test_large_cookiejar():
    cookiejar = RequestsCookieJar()
    cookies = create_cookiejar_from_dict({f'key{i}': f'value{i}' for i in range(1000)})
    codeflash_output = merge_cookies(cookiejar, cookies)
    for i in range(1000):
        pass
    # Outputs were verified to be equal to the original implementation

# Performance and Scalability
def test_merge_large_cookiejar_into_another_large_cookiejar():
    cookiejar = create_cookiejar_from_dict({f'key{i}': f'value{i}' for i in range(500)})
    cookies = create_cookiejar_from_dict({f'key{i+500}': f'value{i+500}' for i in range(500)})
    codeflash_output = merge_cookies(cookiejar, cookies)
    for i in range(500):
        pass
    # Outputs were verified to be equal to the original implementation

def test_merge_large_dict_into_large_cookiejar():
    cookiejar = create_cookiejar_from_dict({f'key{i}': f'value{i}' for i in range(500)})
    cookies = {f'key{i+500}': f'value{i+500}' for i in range(500)}
    codeflash_output = merge_cookies(cookiejar, cookies)
    for i in range(500):
        pass
    # Outputs were verified to be equal to the original implementation

🔘 (none found) − ⏪ Replay Tests