⚡️ Speed up method SessionRedirectMixin.rebuild_proxies by 7%

[codeflash-ai]

📄 7% (0.07x) speedup for SessionRedirectMixin.rebuild_proxies in src/requests/sessions.py

⏱️ Runtime : 116 milliseconds → 108 milliseconds (best of 50 runs)

📝 Explanation and details

To optimize the given Python program, I will make a few modifications without changing the functionality or the API of the code. Here are a few inefficiencies that can be improved.

1. SessionRedirectMixin.rebuild_proxies: Instead of calling get_auth_from_url for every request, we can move the proxy authentication extraction logic directly into rebuild_proxies. This avoids an extra function call.

2. resolve_proxies: Avoid copying the entire dictionary if unnecessary.

3. Replace repeated .get() calls with direct value retrieval where possible.

4. Move redundant checks outside of loops or conditional blocks.

Here's the optimized code.

In these changes, I.

• Removed the redundant get_auth_from_url call by extracting and directly using it within rebuild_proxies.
• Avoided copying the whole proxies dictionary unnecessarily unless environment proxies are used.
• Used .get() once followed by direct value retrieval to minimize redundant operations.

These changes streamline the existing execution, improving the speed of the functions involved.

✅ Correctness verification report:

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

🌀 Generated Regression Tests Details

import warnings
from base64 import b64encode
from unittest.mock import MagicMock

# imports
import pytest  # used for our unit tests
# function to test
from src.requests._internal_utils import to_native_string
from src.requests.compat import basestring, str, unquote, urlparse
from src.requests.sessions import SessionRedirectMixin
from src.requests.utils import get_environ_proxies, should_bypass_proxies


# unit tests
class TestSessionRedirectMixin:
    @pytest.fixture
    def session_redirect_mixin(self):
        class TestClass(SessionRedirectMixin):
            trust_env = True
        return TestClass()

    

import os
import warnings
from base64 import b64encode
from unittest.mock import Mock, patch

# imports
import pytest  # used for our unit tests
# function to test
from src.requests._internal_utils import to_native_string
from src.requests.compat import basestring, str, unquote, urlparse
from src.requests.sessions import SessionRedirectMixin
from src.requests.utils import get_environ_proxies, should_bypass_proxies


# Mock PreparedRequest class for testing
class MockPreparedRequest:
    def __init__(self, url, headers=None):
        self.url = url
        self.headers = headers if headers is not None else {}

# unit tests

# Basic Functionality Tests

def test_empty_proxies_provided():
    session = SessionRedirectMixin()
    session.trust_env = True
    prepared_request = MockPreparedRequest(url="http://example.com")
    proxies = {}
    codeflash_output = session.rebuild_proxies(prepared_request, proxies)

def test_simple_http_proxy():
    session = SessionRedirectMixin()
    session.trust_env = True
    prepared_request = MockPreparedRequest(url="http://example.com")
    proxies = {"http": "http://proxy.com"}
    codeflash_output = session.rebuild_proxies(prepared_request, proxies)

def test_simple_https_proxy():
    session = SessionRedirectMixin()
    session.trust_env = True
    prepared_request = MockPreparedRequest(url="https://example.com")
    proxies = {"https": "https://proxy.com"}
    codeflash_output = session.rebuild_proxies(prepared_request, proxies)

# Environment Variables Tests
@patch.dict(os.environ, {"http_proxy": "http://env-proxy.com", "https_proxy": "https://env-proxy.com"})
def test_trust_env_variables():
    session = SessionRedirectMixin()
    session.trust_env = True
    prepared_request = MockPreparedRequest(url="http://example.com")
    proxies = {}
    codeflash_output = session.rebuild_proxies(prepared_request, proxies)

@patch.dict(os.environ, {"no_proxy": "example.com"})
def test_no_proxy_env_variable():
    session = SessionRedirectMixin()
    session.trust_env = True
    prepared_request = MockPreparedRequest(url="http://example.com")
    proxies = {}
    codeflash_output = session.rebuild_proxies(prepared_request, proxies)

def test_ignore_env_variables():
    session = SessionRedirectMixin()
    session.trust_env = False
    prepared_request = MockPreparedRequest(url="http://example.com")
    proxies = {}
    codeflash_output = session.rebuild_proxies(prepared_request, proxies)

# Authentication Handling Tests
def test_valid_credentials_in_proxy_url():
    session = SessionRedirectMixin()
    session.trust_env = True
    prepared_request = MockPreparedRequest(url="http://example.com")
    proxies = {"http": "http://user:[email protected]"}
    codeflash_output = session.rebuild_proxies(prepared_request, proxies)

def test_invalid_credentials_in_proxy_url():
    session = SessionRedirectMixin()
    session.trust_env = True
    prepared_request = MockPreparedRequest(url="http://example.com")
    proxies = {"http": "http://user@:proxy.com"}
    codeflash_output = session.rebuild_proxies(prepared_request, proxies)

def test_no_credentials_in_proxy_url():
    session = SessionRedirectMixin()
    session.trust_env = True
    prepared_request = MockPreparedRequest(url="http://example.com")
    proxies = {"http": "http://proxy.com"}
    codeflash_output = session.rebuild_proxies(prepared_request, proxies)

# URL Schemes Tests
def test_http_scheme():
    session = SessionRedirectMixin()
    session.trust_env = True
    prepared_request = MockPreparedRequest(url="http://example.com")
    proxies = {"http": "http://proxy.com"}
    codeflash_output = session.rebuild_proxies(prepared_request, proxies)



def test_malformed_url():
    session = SessionRedirectMixin()
    session.trust_env = True
    prepared_request = MockPreparedRequest(url="http://")
    proxies = {"http": "http://proxy.com"}
    codeflash_output = session.rebuild_proxies(prepared_request, proxies)

def test_no_proxy_for_scheme():
    session = SessionRedirectMixin()
    session.trust_env = True
    prepared_request = MockPreparedRequest(url="http://example.com")
    proxies = {"https": "https://proxy.com"}
    codeflash_output = session.rebuild_proxies(prepared_request, proxies)

def test_proxy_with_special_characters():
    session = SessionRedirectMixin()
    session.trust_env = True
    prepared_request = MockPreparedRequest(url="http://example.com")
    proxies = {"http": "http://user:[email protected]"}
    codeflash_output = session.rebuild_proxies(prepared_request, proxies)

# Proxy Authorization Header Tests
def test_existing_proxy_authorization_header():
    session = SessionRedirectMixin()
    session.trust_env = True
    prepared_request = MockPreparedRequest(url="http://example.com", headers={"Proxy-Authorization": "Basic old_auth"})
    proxies = {"http": "http://user:[email protected]"}
    codeflash_output = session.rebuild_proxies(prepared_request, proxies)

def test_no_proxy_authorization_header():
    session = SessionRedirectMixin()
    session.trust_env = True
    prepared_request = MockPreparedRequest(url="http://example.com")
    proxies = {"http": "http://user:[email protected]"}
    codeflash_output = session.rebuild_proxies(prepared_request, proxies)

# Large Scale Test Cases

def test_high_volume_of_requests():
    session = SessionRedirectMixin()
    session.trust_env = True
    for i in range(1000):
        prepared_request = MockPreparedRequest(url=f"http://example{i}.com")
        proxies = {"http": "http://proxy.com"}
        codeflash_output = session.rebuild_proxies(prepared_request, proxies)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

📢 Feedback on this optimization?