⚡️ Speed up method JiraDataSource.addon_properties_resource_put_addon_property_put by 21%

[codeflash-ai]

📄 21% (0.21x) speedup for JiraDataSource.addon_properties_resource_put_addon_property_put in backend/python/app/sources/external/jira/jira.py

⏱️ Runtime : 2.73 milliseconds → 2.25 milliseconds (best of 22 runs)

📝 Explanation and details

The optimized code achieves a 21% runtime speedup through several targeted micro-optimizations that reduce object allocation and string conversion overhead:

Key Optimizations Applied:

1. Smart Header Processing: Instead of always creating a new dict with dict(headers or {}) and using setdefault(), the code conditionally handles headers - only creating a dict copy when headers exist, otherwise using a static dict. This eliminates unnecessary dict construction in the common case where headers are None.

2. Efficient String Dictionary Conversion: The _as_str_dict() function was optimized with:

   • Early return for empty dicts using a static EMPTY_STR_DICT
   • Type checking with type(k) is str to avoid str(k) conversion when keys are already strings (common case)
   • Manual loop instead of dict comprehension for better control

3. Static Empty Dictionary: Uses EMPTY_STR_DICT constant for _query since it's always empty, avoiding repeated empty dict creation and conversion.

4. Reduced Path Parameter Conversion: Skips _as_str_dict() conversion for path_params since the keys are already strings (addonKey, propertyKey).

5. HTTP Client Header Merging: Uses dict unpacking {**self.headers, **request.headers} instead of .copy() and .update() methods, and optimizes URL formatting to avoid repeated f-string operations.

Performance Impact:
The line profiler shows the most expensive operation was _as_str_dict() calls (64% of total time in original), which dropped significantly in the optimized version. The optimizations are particularly effective for the common case where headers are None/minimal and path parameters are simple strings.

Test Case Performance:
The optimizations show consistent benefits across all test scenarios, with the largest gains in throughput tests (small/medium/large load) where the reduced per-request overhead compounds across multiple operations.

Note: While runtime improved by 21%, throughput decreased by 8.3%, which suggests the optimization may have introduced slight overhead in concurrent execution scenarios, though individual request processing is faster.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import asyncio  # used to run async functions

import pytest  # used for our unit tests
from app.sources.external.jira.jira import JiraDataSource


# Minimal HTTPRequest and HTTPResponse implementations for testing
class HTTPRequest:
    def __init__(
        self, method, url, headers=None, path_params=None, query_params=None, body=None
    ):
        self.method = method
        self.url = url
        self.headers = headers or {}
        self.path_params = path_params or {}
        self.query_params = query_params or {}
        self.body = body


class HTTPResponse:
    def __init__(self, response):
        self.response = response

    def json(self):
        return getattr(self.response, "json_data", {})

    @property
    def status_code(self):
        return getattr(self.response, "status_code", 200)


# Dummy response object to simulate httpx.Response
class DummyResponse:
    def __init__(self, status_code=200, json_data=None):
        self.status_code = status_code
        self.json_data = json_data or {}


# Minimal JiraRESTClientViaUsernamePassword for testing
class JiraRESTClientViaUsernamePassword:
    def __init__(
        self, base_url: str, username: str, password: str, token_type: str = "Basic"
    ) -> None:
        self.base_url = base_url

    def get_base_url(self) -> str:
        return self.base_url

    async def execute(self, request: HTTPRequest, **kwargs):
        # Simulate a successful PUT with echo of body and keys
        return HTTPResponse(
            DummyResponse(
                status_code=200,
                json_data={
                    "url": request.url,
                    "method": request.method,
                    "headers": request.headers,
                    "body": request.body,
                    "path_params": request.path_params,
                    "query_params": request.query_params,
                },
            )
        )


# Minimal JiraClient for testing
class JiraClient:
    def __init__(self, client):
        self.client = client

    def get_client(self):
        return self.client


# ------------------ UNIT TESTS ------------------

# Basic Test Cases


@pytest.mark.asyncio
async def test_addon_properties_resource_put_addon_property_put_basic_success():
    """Basic: Test normal PUT with valid keys and body."""
    client = JiraClient(
        JiraRESTClientViaUsernamePassword("https://jira.example.com", "user", "pass")
    )
    ds = JiraDataSource(client)
    body = {"foo": "bar"}
    headers = {"X-Test": "yes"}
    resp = await ds.addon_properties_resource_put_addon_property_put(
        "addon1", "prop1", body, headers
    )
    data = resp.json()


@pytest.mark.asyncio
async def test_addon_properties_resource_put_addon_property_put_basic_no_headers():
    """Basic: Test PUT with no headers provided."""
    client = JiraClient(
        JiraRESTClientViaUsernamePassword("https://jira.example.com", "user", "pass")
    )
    ds = JiraDataSource(client)
    body = {"foo": "bar"}
    resp = await ds.addon_properties_resource_put_addon_property_put(
        "addonX", "propY", body
    )
    data = resp.json()


@pytest.mark.asyncio
async def test_addon_properties_resource_put_addon_property_put_basic_empty_body():
    """Basic: Test PUT with empty body."""
    client = JiraClient(
        JiraRESTClientViaUsernamePassword("https://jira.example.com", "user", "pass")
    )
    ds = JiraDataSource(client)
    resp = await ds.addon_properties_resource_put_addon_property_put(
        "addon2", "prop2", {}
    )
    data = resp.json()


# Edge Test Cases


@pytest.mark.asyncio
async def test_addon_properties_resource_put_addon_property_put_invalid_base_url_method():
    """Edge: Test error when client does not have get_base_url method."""

    class BadClient:
        def get_client(self):
            class NoBaseUrl:
                pass

            return NoBaseUrl()

    with pytest.raises(ValueError) as excinfo:
        JiraDataSource(BadClient())


@pytest.mark.asyncio
async def test_addon_properties_resource_put_addon_property_put_none_body_and_headers():
    """Edge: Test with None for body and headers."""
    client = JiraClient(
        JiraRESTClientViaUsernamePassword("https://jira.example.com", "user", "pass")
    )
    ds = JiraDataSource(client)
    resp = await ds.addon_properties_resource_put_addon_property_put(
        "addon4", "prop4", None, None
    )
    data = resp.json()


@pytest.mark.asyncio
async def test_addon_properties_resource_put_addon_property_put_special_characters():
    """Edge: Test with special characters in keys."""
    client = JiraClient(
        JiraRESTClientViaUsernamePassword("https://jira.example.com", "user", "pass")
    )
    ds = JiraDataSource(client)
    addonKey = "addon!@#$%^&*()"
    propertyKey = "prop<>?:{}|"
    body = {"data": "value"}
    resp = await ds.addon_properties_resource_put_addon_property_put(
        addonKey, propertyKey, body
    )
    data = resp.json()


@pytest.mark.asyncio
async def test_addon_properties_resource_put_addon_property_put_concurrent():
    """Edge: Test concurrent execution with different keys."""
    client = JiraClient(
        JiraRESTClientViaUsernamePassword("https://jira.example.com", "user", "pass")
    )
    ds = JiraDataSource(client)
    # Prepare several coroutines with different keys/bodies
    coros = [
        ds.addon_properties_resource_put_addon_property_put(
            f"addon{i}", f"prop{i}", {"val": i}
        )
        for i in range(5)
    ]
    results = await asyncio.gather(*coros)
    for i, resp in enumerate(results):
        data = resp.json()


# Large Scale Test Cases


@pytest.mark.asyncio
async def test_addon_properties_resource_put_addon_property_put_large_scale_concurrent():
    """Large Scale: Test with 50 concurrent requests."""
    client = JiraClient(
        JiraRESTClientViaUsernamePassword("https://jira.example.com", "user", "pass")
    )
    ds = JiraDataSource(client)
    N = 50
    coros = [
        ds.addon_properties_resource_put_addon_property_put(
            f"addon{i}", f"prop{i}", {"num": i}
        )
        for i in range(N)
    ]
    results = await asyncio.gather(*coros)
    for i, resp in enumerate(results):
        data = resp.json()


# Throughput Test Cases


@pytest.mark.asyncio
async def test_addon_properties_resource_put_addon_property_put_throughput_small_load():
    """Throughput: Test with small batch of requests."""
    client = JiraClient(
        JiraRESTClientViaUsernamePassword("https://jira.example.com", "user", "pass")
    )
    ds = JiraDataSource(client)
    coros = [
        ds.addon_properties_resource_put_addon_property_put(
            "addonA", f"prop{i}", {"x": i}
        )
        for i in range(5)
    ]
    results = await asyncio.gather(*coros)
    for i, resp in enumerate(results):
        data = resp.json()


@pytest.mark.asyncio
async def test_addon_properties_resource_put_addon_property_put_throughput_medium_load():
    """Throughput: Test with medium batch of requests."""
    client = JiraClient(
        JiraRESTClientViaUsernamePassword("https://jira.example.com", "user", "pass")
    )
    ds = JiraDataSource(client)
    coros = [
        ds.addon_properties_resource_put_addon_property_put(
            "addonB", f"prop{i}", {"y": i}
        )
        for i in range(20)
    ]
    results = await asyncio.gather(*coros)
    for i, resp in enumerate(results):
        data = resp.json()


@pytest.mark.asyncio
async def test_addon_properties_resource_put_addon_property_put_throughput_large_load():
    """Throughput: Test with large batch of requests (100)."""
    client = JiraClient(
        JiraRESTClientViaUsernamePassword("https://jira.example.com", "user", "pass")
    )
    ds = JiraDataSource(client)
    coros = [
        ds.addon_properties_resource_put_addon_property_put(
            "addonC", f"prop{i}", {"z": i}
        )
        for i in range(100)
    ]
    results = await asyncio.gather(*coros)
    for i, resp in enumerate(results):
        data = resp.json()


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

import asyncio  # used to run async functions

import pytest  # used for our unit tests
from app.sources.external.jira.jira import JiraDataSource


# Minimal stubs for HTTPRequest and HTTPResponse for testing purposes
class HTTPRequest:
    def __init__(self, method, url, headers, path_params, query_params, body):
        self.method = method
        self.url = url
        self.headers = headers
        self.path_params = path_params
        self.query_params = query_params
        self.body = body


class HTTPResponse:
    def __init__(self, response):
        self.response = response

    def json(self):
        # For testing, just return the response as-is
        return self.response


# Minimal stub for JiraRESTClientViaUsernamePassword
class JiraRESTClientViaUsernamePassword:
    def __init__(self, base_url, username, password, token_type="Basic"):
        self.base_url = base_url

    def get_base_url(self):
        return self.base_url

    async def execute(self, request, **kwargs):
        # Simulate a successful HTTPResponse
        # Echo back the request data for verification
        return HTTPResponse(
            {
                "method": request.method,
                "url": request.url,
                "headers": request.headers,
                "path_params": request.path_params,
                "query_params": request.query_params,
                "body": request.body,
            }
        )


# Minimal stub for JiraClient
class JiraClient:
    def __init__(self, client):
        self.client = client

    def get_client(self):
        return self.client


# -------------------- TEST CASES --------------------

# Basic Test Cases


@pytest.mark.asyncio
async def test_addon_properties_resource_put_addon_property_put_basic():
    """Test basic async/await behavior and correct response structure."""
    client = JiraClient(
        JiraRESTClientViaUsernamePassword("https://jira.example.com", "user", "pass")
    )
    ds = JiraDataSource(client)
    addonKey = "test-addon"
    propertyKey = "test-property"
    body = {"foo": "bar"}
    headers = {"Custom-Header": "value"}
    resp = await ds.addon_properties_resource_put_addon_property_put(
        addonKey, propertyKey, body, headers
    )
    result = resp.json()


@pytest.mark.asyncio
async def test_addon_properties_resource_put_addon_property_put_default_headers():
    """Test that Content-Type header is set if not provided."""
    client = JiraClient(
        JiraRESTClientViaUsernamePassword("https://jira.example.com", "user", "pass")
    )
    ds = JiraDataSource(client)
    resp = await ds.addon_properties_resource_put_addon_property_put(
        "addon", "property", {"a": 1}
    )
    result = resp.json()


@pytest.mark.asyncio
async def test_addon_properties_resource_put_addon_property_put_none_body_and_headers():
    """Test with None body and None headers."""
    client = JiraClient(
        JiraRESTClientViaUsernamePassword("https://jira.example.com", "user", "pass")
    )
    ds = JiraDataSource(client)
    resp = await ds.addon_properties_resource_put_addon_property_put(
        "addon", "property"
    )
    result = resp.json()


# Edge Test Cases


@pytest.mark.asyncio
async def test_addon_properties_resource_put_addon_property_put_empty_strings():
    """Test with empty strings for addonKey and propertyKey."""
    client = JiraClient(
        JiraRESTClientViaUsernamePassword("https://jira.example.com", "user", "pass")
    )
    ds = JiraDataSource(client)
    resp = await ds.addon_properties_resource_put_addon_property_put("", "", {})
    result = resp.json()


@pytest.mark.asyncio
async def test_addon_properties_resource_put_addon_property_put_special_characters():
    """Test with special characters in keys."""
    client = JiraClient(
        JiraRESTClientViaUsernamePassword("https://jira.example.com", "user", "pass")
    )
    ds = JiraDataSource(client)
    addonKey = "addon!@#"
    propertyKey = "property$%^"
    resp = await ds.addon_properties_resource_put_addon_property_put(
        addonKey, propertyKey, {"x": "y"}
    )
    result = resp.json()


@pytest.mark.asyncio
async def test_addon_properties_resource_put_addon_property_put_concurrent_execution():
    """Test concurrent execution with different keys."""
    client = JiraClient(
        JiraRESTClientViaUsernamePassword("https://jira.example.com", "user", "pass")
    )
    ds = JiraDataSource(client)
    tasks = [
        ds.addon_properties_resource_put_addon_property_put(
            f"addon{i}", f"property{i}", {"val": i}
        )
        for i in range(5)
    ]
    results = await asyncio.gather(*tasks)
    for i, resp in enumerate(results):
        result = resp.json()


@pytest.mark.asyncio
async def test_addon_properties_resource_put_addon_property_put_missing_http_client():
    """Test ValueError raised if HTTP client is not initialized."""

    class DummyClient:
        def get_client(self):
            return None

    with pytest.raises(ValueError, match="HTTP client is not initialized"):
        JiraDataSource(DummyClient())


@pytest.mark.asyncio
async def test_addon_properties_resource_put_addon_property_put_missing_get_base_url():
    """Test ValueError raised if client does not have get_base_url."""

    class BadClient:
        def get_client(self):
            return object()  # Does not have get_base_url

    with pytest.raises(
        ValueError, match="HTTP client does not have get_base_url method"
    ):
        JiraDataSource(BadClient())


# Large Scale Test Cases


@pytest.mark.asyncio
async def test_addon_properties_resource_put_addon_property_put_large_scale_concurrency():
    """Test with many concurrent requests (up to 50)."""
    client = JiraClient(
        JiraRESTClientViaUsernamePassword("https://jira.example.com", "user", "pass")
    )
    ds = JiraDataSource(client)
    n = 50
    tasks = [
        ds.addon_properties_resource_put_addon_property_put(
            f"addon{i}", f"property{i}", {"num": i}
        )
        for i in range(n)
    ]
    results = await asyncio.gather(*tasks)
    for i, resp in enumerate(results):
        result = resp.json()


# Throughput Test Cases


@pytest.mark.asyncio
async def test_addon_properties_resource_put_addon_property_put_throughput_small_load():
    """Throughput test: small load of 10 requests."""
    client = JiraClient(
        JiraRESTClientViaUsernamePassword("https://jira.example.com", "user", "pass")
    )
    ds = JiraDataSource(client)
    tasks = [
        ds.addon_properties_resource_put_addon_property_put(
            f"addon{i}", f"property{i}", {"small": i}
        )
        for i in range(10)
    ]
    results = await asyncio.gather(*tasks)
    for i, resp in enumerate(results):
        result = resp.json()


@pytest.mark.asyncio
async def test_addon_properties_resource_put_addon_property_put_throughput_medium_load():
    """Throughput test: medium load of 50 requests."""
    client = JiraClient(
        JiraRESTClientViaUsernamePassword("https://jira.example.com", "user", "pass")
    )
    ds = JiraDataSource(client)
    tasks = [
        ds.addon_properties_resource_put_addon_property_put(
            f"addon{i}", f"property{i}", {"medium": i}
        )
        for i in range(50)
    ]
    results = await asyncio.gather(*tasks)
    for i, resp in enumerate(results):
        result = resp.json()


@pytest.mark.asyncio
async def test_addon_properties_resource_put_addon_property_put_throughput_large_load():
    """Throughput test: large load of 100 requests."""
    client = JiraClient(
        JiraRESTClientViaUsernamePassword("https://jira.example.com", "user", "pass")
    )
    ds = JiraDataSource(client)
    tasks = [
        ds.addon_properties_resource_put_addon_property_put(
            f"addon{i}", f"property{i}", {"large": i}
        )
        for i in range(100)
    ]
    results = await asyncio.gather(*tasks)
    for i, resp in enumerate(results):
        result = resp.json()


# Edge case: headers with non-string values
@pytest.mark.asyncio
async def test_addon_properties_resource_put_addon_property_put_headers_non_string_values():
    """Test headers dict with non-string values gets stringified."""
    client = JiraClient(
        JiraRESTClientViaUsernamePassword("https://jira.example.com", "user", "pass")
    )
    ds = JiraDataSource(client)
    headers = {"X-Int": 123, "X-Bool": True}
    resp = await ds.addon_properties_resource_put_addon_property_put(
        "addon", "property", {}, headers
    )
    result = resp.json()


# Edge case: body as bytes
@pytest.mark.asyncio
async def test_addon_properties_resource_put_addon_property_put_body_bytes():
    """Test body as bytes is passed through."""
    client = JiraClient(
        JiraRESTClientViaUsernamePassword("https://jira.example.com", "user", "pass")
    )
    ds = JiraDataSource(client)
    body = b"binarydata"
    resp = await ds.addon_properties_resource_put_addon_property_put(
        "addon", "property", body
    )
    result = resp.json()


# 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-JiraDataSource.addon_properties_resource_put_addon_property_put-miqp0ccw and push.