⚡️ Speed up method JiraDataSource.submit_bulk_unwatch by 23%

[codeflash-ai]

📄 23% (0.23x) speedup for JiraDataSource.submit_bulk_unwatch in backend/python/app/sources/external/jira/jira.py

⏱️ Runtime : 1.89 milliseconds → 1.54 milliseconds (best of 250 runs)

📝 Explanation and details

The optimization achieves a 22% runtime improvement by eliminating unnecessary allocations and computations that occur on every function call. Here's what drives the performance gains:

Key Optimizations:

1. Skip unnecessary URL formatting: The original code always called _safe_format_url() even when _path was empty. The optimized version checks if not _path and directly concatenates strings, avoiding the expensive format_map() call and exception handling overhead.

2. Optimize header handling: Instead of always creating a new dict with dict(headers or {}) and then calling setdefault(), the optimized version uses conditional logic to only create new dicts when needed, reducing allocations in the common case where no custom headers are provided.

3. Fast-path empty dict handling in _as_str_dict(): The helper function now immediately returns {} for empty dicts and uses a specialized single-item path for dicts with one element, avoiding the overhead of dict comprehensions for small dictionaries.

4. Eliminate redundant dict creation: The optimized version creates _body directly as a dict literal instead of creating an empty dict and then assigning to it.

Performance Impact Analysis:

From the line profiler data, the most significant improvements are:

• URL formatting time reduced from ~1.72ms to near-zero (19% → 1.4% of total time)
• _as_str_dict() calls optimized through fast-path handling for empty and single-item dicts
• Overall function execution time reduced from 9.02ms to 8.23ms

Test Case Performance:

The optimizations are particularly effective for:

• High-throughput scenarios (100+ concurrent calls) where the cumulative effect of micro-optimizations compounds
• Basic usage patterns with standard headers, which represent the most common use case
• Large-scale operations where the function is called repeatedly in tight loops

Since this appears to be an auto-generated API method for Jira bulk operations, these optimizations will benefit any application making frequent Jira API calls, especially in batch processing scenarios.

✅ Correctness verification report:

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

🌀 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 stubs for required classes ----

class HTTPResponse:
    """Stub for HTTPResponse, mimics a real HTTP response."""
    def __init__(self, data):
        self.data = data

    def json(self):
        return self.data

class HTTPRequest:
    """Stub for HTTPRequest, just stores request info."""
    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

# ---- Minimal stub for JiraClient and its client ----

class DummyClient:
    """Dummy client that mimics required methods and async execute."""
    def __init__(self, base_url="http://jira.example.com"):
        self._base_url = base_url
        self.last_request = None

    def get_base_url(self):
        return self._base_url

    async def execute(self, req: HTTPRequest):
        # Save last request for inspection
        self.last_request = req
        # Simulate a successful response
        return HTTPResponse({
            "url": req.url,
            "method": req.method,
            "headers": req.headers,
            "body": req.body,
            "path_params": req.path_params,
            "query_params": req.query_params,
        })

class DummyJiraClient:
    """Dummy JiraClient wrapper."""
    def __init__(self, client):
        self.client = client

    def get_client(self):
        return self.client
from app.sources.external.jira.jira import JiraDataSource

# ---- Unit Tests ----

# 1. Basic Test Cases

@pytest.mark.asyncio
async def test_submit_bulk_unwatch_basic():
    """Test basic async/await behavior and correct response structure."""
    client = DummyJiraClient(DummyClient())
    ds = JiraDataSource(client)
    issues = ["ISSUE-1", "ISSUE-2"]
    resp = await ds.submit_bulk_unwatch(issues)
    data = resp.json()

@pytest.mark.asyncio
async def test_submit_bulk_unwatch_empty_list():
    """Test with an empty issue list."""
    client = DummyJiraClient(DummyClient())
    ds = JiraDataSource(client)
    issues = []
    resp = await ds.submit_bulk_unwatch(issues)
    data = resp.json()

@pytest.mark.asyncio
async def test_submit_bulk_unwatch_custom_headers():
    """Test with custom headers provided."""
    client = DummyJiraClient(DummyClient())
    ds = JiraDataSource(client)
    issues = ["ISSUE-42"]
    custom_headers = {"X-Test-Header": "abc"}
    resp = await ds.submit_bulk_unwatch(issues, headers=custom_headers)
    data = resp.json()

# 2. Edge Test Cases

@pytest.mark.asyncio
async def test_submit_bulk_unwatch_none_client_raises():
    """Test ValueError raised if client is None."""
    class NoneClient:
        def get_client(self):
            return None
    with pytest.raises(ValueError, match="HTTP client is not initialized"):
        JiraDataSource(NoneClient())

@pytest.mark.asyncio
async def test_submit_bulk_unwatch_client_missing_base_url_raises():
    """Test ValueError raised if client lacks get_base_url."""
    class BadClient:
        def get_client(self):
            return object()  # No get_base_url method
    with pytest.raises(ValueError, match="HTTP client does not have get_base_url method"):
        JiraDataSource(BadClient())

@pytest.mark.asyncio
async def test_submit_bulk_unwatch_concurrent_execution():
    """Test concurrent execution of the async function."""
    client = DummyJiraClient(DummyClient())
    ds = JiraDataSource(client)
    issues_list = [["A"], ["B"], ["C"]]
    # Run three concurrent calls
    results = await asyncio.gather(
        *(ds.submit_bulk_unwatch(issues) for issues in issues_list)
    )
    for i, resp in enumerate(results):
        data = resp.json()

@pytest.mark.asyncio
async def test_submit_bulk_unwatch_invalid_issue_ids():
    """Test with unusual/invalid issue IDs."""
    client = DummyJiraClient(DummyClient())
    ds = JiraDataSource(client)
    issues = ["", None, "ISSUE-!@#", "ISSUE-中文"]
    # None will be serialized as 'None' string, empty string as-is
    resp = await ds.submit_bulk_unwatch(issues)
    data = resp.json()

# 3. Large Scale Test Cases

@pytest.mark.asyncio
async def test_submit_bulk_unwatch_large_issue_list():
    """Test with a large list of issue IDs (up to 500)."""
    client = DummyJiraClient(DummyClient())
    ds = JiraDataSource(client)
    issues = [f"ISSUE-{i}" for i in range(500)]
    resp = await ds.submit_bulk_unwatch(issues)
    data = resp.json()

@pytest.mark.asyncio
async def test_submit_bulk_unwatch_many_concurrent_calls():
    """Test many concurrent calls (up to 50)."""
    client = DummyJiraClient(DummyClient())
    ds = JiraDataSource(client)
    issues_list = [[f"ISSUE-{i}"] for i in range(50)]
    results = await asyncio.gather(
        *(ds.submit_bulk_unwatch(issues) for issues in issues_list)
    )
    for i, resp in enumerate(results):
        pass

# 4. Throughput Test Cases

@pytest.mark.asyncio
async def test_submit_bulk_unwatch_throughput_small_load():
    """Throughput test: small load, 5 concurrent calls."""
    client = DummyJiraClient(DummyClient())
    ds = JiraDataSource(client)
    issues_list = [[f"ISSUE-{i}"] for i in range(5)]
    results = await asyncio.gather(
        *(ds.submit_bulk_unwatch(issues) for issues in issues_list)
    )
    for i, resp in enumerate(results):
        pass

@pytest.mark.asyncio
async def test_submit_bulk_unwatch_throughput_medium_load():
    """Throughput test: medium load, 20 concurrent calls."""
    client = DummyJiraClient(DummyClient())
    ds = JiraDataSource(client)
    issues_list = [[f"ISSUE-{i}"] for i in range(20)]
    results = await asyncio.gather(
        *(ds.submit_bulk_unwatch(issues) for issues in issues_list)
    )
    for i, resp in enumerate(results):
        pass

@pytest.mark.asyncio
async def test_submit_bulk_unwatch_throughput_large_load():
    """Throughput test: large load, 100 concurrent calls."""
    client = DummyJiraClient(DummyClient())
    ds = JiraDataSource(client)
    issues_list = [[f"ISSUE-{i}"] for i in range(100)]
    results = await asyncio.gather(
        *(ds.submit_bulk_unwatch(issues) for issues in issues_list)
    )
    for i, resp in enumerate(results):
        pass
# 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
from typing import Any, Dict, Optional

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


# ---- Minimal stubs for dependencies ----
class HTTPResponse:
    """Stub for HTTPResponse object."""
    def __init__(self, data: Any):
        self.data = data

class HTTPRequest:
    """Stub for HTTPRequest object."""
    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 DummyClient:
    """Dummy client to simulate async HTTP execution."""
    def __init__(self, base_url: str):
        self._base_url = base_url
        self.executed_requests = []

    def get_base_url(self):
        return self._base_url

    async def execute(self, request: HTTPRequest):
        # Simulate async HTTP execution and record the request
        self.executed_requests.append(request)
        # Return a dummy HTTPResponse containing the request for verification
        return HTTPResponse({
            "method": request.method,
            "url": request.url,
            "headers": request.headers,
            "body": request.body
        })

class JiraClient:
    """Stub for JiraClient."""
    def __init__(self, client):
        self.client = client

    def get_client(self):
        return self.client
from app.sources.external.jira.jira import JiraDataSource

# ---- Test Suite ----

@pytest.mark.asyncio
async def test_submit_bulk_unwatch_basic_single_issue():
    """Test basic async/await behavior with a single issue."""
    client = DummyClient("https://example.atlassian.net")
    ds = JiraDataSource(JiraClient(client))
    issue_ids = ["ISSUE-1"]
    resp = await ds.submit_bulk_unwatch(issue_ids)

@pytest.mark.asyncio
async def test_submit_bulk_unwatch_basic_multiple_issues():
    """Test basic async/await behavior with multiple issues."""
    client = DummyClient("https://example.atlassian.net")
    ds = JiraDataSource(JiraClient(client))
    issue_ids = ["ISSUE-1", "ISSUE-2", "ISSUE-3"]
    resp = await ds.submit_bulk_unwatch(issue_ids)

@pytest.mark.asyncio
async def test_submit_bulk_unwatch_empty_list():
    """Edge case: Empty list of issues."""
    client = DummyClient("https://example.atlassian.net")
    ds = JiraDataSource(JiraClient(client))
    issue_ids = []
    resp = await ds.submit_bulk_unwatch(issue_ids)

@pytest.mark.asyncio
async def test_submit_bulk_unwatch_custom_headers():
    """Test custom headers are merged and Content-Type is set."""
    client = DummyClient("https://example.atlassian.net")
    ds = JiraDataSource(JiraClient(client))
    headers = {"Authorization": "Bearer token123"}
    issue_ids = ["ISSUE-1"]
    resp = await ds.submit_bulk_unwatch(issue_ids, headers=headers)

@pytest.mark.asyncio
async def test_submit_bulk_unwatch_missing_client_raises():
    """Edge case: HTTP client is None should raise ValueError."""
    class DummyNoneClient:
        def get_client(self):
            return None
    with pytest.raises(ValueError, match="HTTP client is not initialized"):
        JiraDataSource(DummyNoneClient())

@pytest.mark.asyncio
async def test_submit_bulk_unwatch_missing_get_base_url_raises():
    """Edge case: HTTP client missing get_base_url method should raise ValueError."""
    class NoBaseUrlClient:
        pass
    class DummyClientWrapper:
        def get_client(self):
            return NoBaseUrlClient()
    with pytest.raises(ValueError, match="HTTP client does not have get_base_url method"):
        JiraDataSource(DummyClientWrapper())

@pytest.mark.asyncio
async def test_submit_bulk_unwatch_concurrent_execution():
    """Test concurrent async execution of submit_bulk_unwatch."""
    client = DummyClient("https://example.atlassian.net")
    ds = JiraDataSource(JiraClient(client))
    issue_lists = [["ISSUE-1"], ["ISSUE-2"], ["ISSUE-3"]]
    # Run three concurrent requests
    results = await asyncio.gather(
        *(ds.submit_bulk_unwatch(issue_ids) for issue_ids in issue_lists)
    )
    for i, resp in enumerate(results):
        pass

@pytest.mark.asyncio
async def test_submit_bulk_unwatch_large_list():
    """Large scale: Test with a large list of issue IDs."""
    client = DummyClient("https://example.atlassian.net")
    ds = JiraDataSource(JiraClient(client))
    issue_ids = [f"ISSUE-{i}" for i in range(500)]  # 500 issues
    resp = await ds.submit_bulk_unwatch(issue_ids)

@pytest.mark.asyncio
async def test_submit_bulk_unwatch_concurrent_large_scale():
    """Large scale: Test many concurrent calls with different issue lists."""
    client = DummyClient("https://example.atlassian.net")
    ds = JiraDataSource(JiraClient(client))
    # 20 concurrent requests with different issue lists
    issue_lists = [[f"ISSUE-{i}-{j}" for j in range(10)] for i in range(20)]
    results = await asyncio.gather(
        *(ds.submit_bulk_unwatch(issue_ids) for issue_ids in issue_lists)
    )
    for i, resp in enumerate(results):
        pass

@pytest.mark.asyncio
async def test_submit_bulk_unwatch_throughput_small_load():
    """Throughput: Small load of repeated requests."""
    client = DummyClient("https://example.atlassian.net")
    ds = JiraDataSource(JiraClient(client))
    # 10 requests, each with a single issue
    issue_lists = [[f"ISSUE-{i}"] for i in range(10)]
    results = await asyncio.gather(
        *(ds.submit_bulk_unwatch(issue_ids) for issue_ids in issue_lists)
    )
    # Assert all responses are correct
    for i, resp in enumerate(results):
        pass

@pytest.mark.asyncio
async def test_submit_bulk_unwatch_throughput_medium_load():
    """Throughput: Medium load of repeated requests."""
    client = DummyClient("https://example.atlassian.net")
    ds = JiraDataSource(JiraClient(client))
    # 50 requests, each with 5 issues
    issue_lists = [[f"ISSUE-{i}-{j}" for j in range(5)] for i in range(50)]
    results = await asyncio.gather(
        *(ds.submit_bulk_unwatch(issue_ids) for issue_ids in issue_lists)
    )
    # Assert all responses are correct
    for i, resp in enumerate(results):
        pass

@pytest.mark.asyncio
async def test_submit_bulk_unwatch_throughput_high_volume():
    """Throughput: High volume concurrent requests (100 calls)."""
    client = DummyClient("https://example.atlassian.net")
    ds = JiraDataSource(JiraClient(client))
    # 100 requests, each with 2 issues
    issue_lists = [[f"ISSUE-{i}-A", f"ISSUE-{i}-B"] for i in range(100)]
    results = await asyncio.gather(
        *(ds.submit_bulk_unwatch(issue_ids) for issue_ids in issue_lists)
    )
    # Assert all responses are correct
    for i, resp in enumerate(results):
        pass
# 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.submit_bulk_unwatch-mhos8dph and push.