⚡️ Speed up method AgentlessScanningApi.delete_azure_scan_options by 44%

[codeflash-ai]

📄 44% (0.44x) speedup for AgentlessScanningApi.delete_azure_scan_options in src/datadog_api_client/v2/api/agentless_scanning_api.py

⏱️ Runtime : 3.61 milliseconds → 2.50 milliseconds (best of 105 runs)

📝 Explanation and details

The optimization eliminates unnecessary dictionary creation and unpacking in the delete_azure_scan_options method.

Key Change: The original code creates an empty dictionary (kwargs: Dict[str, Any] = {}), assigns the parameter to it (kwargs["subscription_id"] = subscription_id), then unpacks it when calling the endpoint (**kwargs). The optimized version passes the parameter directly as a keyword argument (subscription_id=subscription_id).

Why This is Faster:

• Eliminates dict allocation: No need to create an intermediate dictionary object
• Removes dict assignment overhead: Skips the __setitem__ operation on the dictionary
• Avoids unpacking overhead: Direct keyword passing is more efficient than **kwargs unpacking

Performance Impact: The line profiler shows the optimization removes two expensive operations (7.2% and 8% of total time) that were pure overhead. The test results demonstrate consistent speedups across all scenarios:

• Simple cases: 13-30% faster
• Large scale operations: 39-46% faster on bulk operations (1000 items)
• Edge cases with validation errors: 9-23% faster

This optimization is particularly effective for high-frequency API calls where the method is invoked thousands of times, as shown by the substantial improvements in the large-scale test cases.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import pytest  # used for our unit tests
from src.datadog_api_client.v2.api.agentless_scanning_api import \
    AgentlessScanningApi

# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

#------------------------------------------------
import pytest  # used for our unit tests
from src.datadog_api_client.v2.api.agentless_scanning_api import \
    AgentlessScanningApi

# function to test is imported above (AgentlessScanningApi.delete_azure_scan_options)

# We'll use a simple in-memory store to simulate Azure scan options for testing purposes.
# We'll monkeypatch the Endpoint's call_with_http_info to simulate the backend.

class FakeAzureScanOptionsStore:
    def __init__(self):
        # Maps subscription_id to scan options (dummy values)
        self.options = {}

    def add(self, subscription_id, value=None):
        self.options[subscription_id] = value

    def delete(self, subscription_id):
        if subscription_id in self.options:
            del self.options[subscription_id]
            return True
        return False

    def exists(self, subscription_id):
        return subscription_id in self.options

    def clear(self):
        self.options.clear()

# Helper to monkeypatch the endpoint for delete_azure_scan_options
def make_delete_patch(store: FakeAzureScanOptionsStore):
    def patch_call_with_http_info(self, **kwargs):
        subscription_id = kwargs.get("subscription_id")
        if subscription_id is None:
            raise ValueError("Missing required parameter 'subscription_id'")
        if not isinstance(subscription_id, str):
            raise TypeError("subscription_id must be a string")
        if subscription_id == "":
            raise ValueError("subscription_id cannot be empty")
        if len(subscription_id) > 256:
            raise ValueError("subscription_id too long")
        if not store.delete(subscription_id):
            raise KeyError(f"Subscription ID '{subscription_id}' does not exist")
        # Simulate returning None for successful deletion
        return None
    return patch_call_with_http_info

@pytest.fixture
def azure_store():
    # Fixture to provide a fresh store for each test
    store = FakeAzureScanOptionsStore()
    yield store
    store.clear()

@pytest.fixture
def agentless_api(azure_store, monkeypatch):
    # Patch the endpoint to use our fake store for deletion
    api = AgentlessScanningApi()
    monkeypatch.setattr(
        api._delete_azure_scan_options_endpoint,
        "call_with_http_info",
        make_delete_patch(azure_store).__get__(api._delete_azure_scan_options_endpoint)
    )
    return api

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

def test_delete_existing_scan_option_basic(agentless_api, azure_store):
    # Test deleting a scan option that exists
    subscription_id = "sub-basic-001"
    azure_store.add(subscription_id)
    # Should not raise and should return None
    codeflash_output = agentless_api.delete_azure_scan_options(subscription_id); result = codeflash_output # 3.13μs -> 2.41μs (29.9% faster)

def test_delete_existing_scan_option_with_value(agentless_api, azure_store):
    # Test deleting a scan option with a value stored
    subscription_id = "sub-basic-002"
    azure_store.add(subscription_id, value={"foo": "bar"})
    codeflash_output = agentless_api.delete_azure_scan_options(subscription_id); result = codeflash_output # 2.93μs -> 2.58μs (13.8% faster)

def test_delete_multiple_scan_options(agentless_api, azure_store):
    # Test deleting multiple scan options one by one
    ids = ["sub-basic-003", "sub-basic-004", "sub-basic-005"]
    for sid in ids:
        azure_store.add(sid)
    for sid in ids:
        codeflash_output = agentless_api.delete_azure_scan_options(sid); result = codeflash_output # 5.18μs -> 4.41μs (17.7% faster)

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

def test_delete_nonexistent_scan_option(agentless_api, azure_store):
    # Try to delete a subscription_id that does not exist
    subscription_id = "sub-edge-nonexistent"
    with pytest.raises(KeyError) as excinfo:
        agentless_api.delete_azure_scan_options(subscription_id) # 4.11μs -> 3.52μs (16.7% faster)

def test_delete_with_empty_string(agentless_api, azure_store):
    # subscription_id is empty string
    with pytest.raises(ValueError) as excinfo:
        agentless_api.delete_azure_scan_options("") # 3.47μs -> 2.88μs (20.4% faster)

def test_delete_with_none(agentless_api, azure_store):
    # subscription_id is None
    with pytest.raises(ValueError) as excinfo:
        agentless_api.delete_azure_scan_options(None) # 3.32μs -> 2.70μs (22.9% faster)

def test_delete_with_non_string_type(agentless_api, azure_store):
    # subscription_id is not a string
    for bad_type in [123, 45.6, [], {}, object()]:
        with pytest.raises(TypeError) as excinfo:
            agentless_api.delete_azure_scan_options(bad_type)

def test_delete_with_long_subscription_id(agentless_api, azure_store):
    # subscription_id is longer than allowed (simulate limit at 256 chars)
    long_id = "a" * 257
    with pytest.raises(ValueError) as excinfo:
        agentless_api.delete_azure_scan_options(long_id) # 3.55μs -> 3.24μs (9.63% faster)

def test_delete_with_special_characters(agentless_api, azure_store):
    # subscription_id has special characters, should work if present in store
    special_id = "sub-edge-!@#$%^&*()_+-=[]{};':,.<>/?"
    azure_store.add(special_id)
    codeflash_output = agentless_api.delete_azure_scan_options(special_id); result = codeflash_output # 2.98μs -> 2.50μs (19.2% faster)

def test_delete_with_unicode_characters(agentless_api, azure_store):
    # subscription_id has unicode characters
    unicode_id = "sub-edge-测试-Δ-🚀"
    azure_store.add(unicode_id)
    codeflash_output = agentless_api.delete_azure_scan_options(unicode_id); result = codeflash_output # 3.06μs -> 2.56μs (19.2% faster)

def test_delete_with_whitespace(agentless_api, azure_store):
    # subscription_id has leading/trailing whitespace
    ws_id = "  sub-edge-whitespace  "
    azure_store.add(ws_id)
    codeflash_output = agentless_api.delete_azure_scan_options(ws_id); result = codeflash_output # 3.20μs -> 2.52μs (27.4% faster)

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

def test_delete_many_scan_options(agentless_api, azure_store):
    # Add and delete a large number of scan options
    ids = [f"sub-large-{i:03d}" for i in range(1000)]
    for sid in ids:
        azure_store.add(sid)
    # Delete all
    for sid in ids:
        codeflash_output = agentless_api.delete_azure_scan_options(sid); result = codeflash_output # 858μs -> 600μs (42.8% faster)

def test_delete_some_from_large_set(agentless_api, azure_store):
    # Add 1000 scan options, delete every 10th, check others remain
    ids = [f"sub-large-{i:03d}" for i in range(1000)]
    for sid in ids:
        azure_store.add(sid)
    to_delete = ids[::10]
    for sid in to_delete:
        codeflash_output = agentless_api.delete_azure_scan_options(sid); result = codeflash_output # 89.2μs -> 64.0μs (39.4% faster)
    # Check that the others still exist
    for sid in ids:
        if sid in to_delete:
            pass
        else:
            pass

def test_delete_large_id_set_with_unicode(agentless_api, azure_store):
    # Add scan options with unicode ids, delete them all
    ids = [f"sub-large-测试-{i:03d}-🚀" for i in range(1000)]
    for sid in ids:
        azure_store.add(sid)
    for sid in ids:
        codeflash_output = agentless_api.delete_azure_scan_options(sid); result = codeflash_output # 873μs -> 597μs (46.0% faster)

def test_delete_large_id_set_with_special_chars(agentless_api, azure_store):
    # Add scan options with special character ids, delete them all
    ids = [f"sub-large-!@#{i:03d}$%^" for i in range(1000)]
    for sid in ids:
        azure_store.add(sid)
    for sid in ids:
        codeflash_output = agentless_api.delete_azure_scan_options(sid); result = codeflash_output # 872μs -> 597μs (45.9% faster)

def test_delete_large_set_and_then_nonexistent(agentless_api, azure_store):
    # Add and delete a large set, then try deleting a non-existent one
    ids = [f"sub-large-{i:03d}" for i in range(1000)]
    for sid in ids:
        azure_store.add(sid)
    for sid in ids:
        agentless_api.delete_azure_scan_options(sid) # 866μs -> 601μs (44.2% faster)
    # Now try to delete one that was never present
    with pytest.raises(KeyError) as excinfo:
        agentless_api.delete_azure_scan_options("sub-large-not-present") # 3.20μs -> 2.86μs (12.1% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from src.datadog_api_client.v2.api.agentless_scanning_api import AgentlessScanningApi
import pytest

def test_AgentlessScanningApi_delete_azure_scan_options():
    with pytest.raises(AttributeError, match="'SymbolicInt'\\ object\\ has\\ no\\ attribute\\ 'configuration'"):
        AgentlessScanningApi.delete_azure_scan_options(AgentlessScanningApi(api_client=0), '')

🔎 Concolic Coverage Tests and Runtime

To edit these changes git checkout codeflash/optimize-AgentlessScanningApi.delete_azure_scan_options-mgam5n81 and push.