⚡️ Speed up method JiraDataSource.delete_issue_type_scheme by 8%

[codeflash-ai]

📄 8% (0.08x) speedup for JiraDataSource.delete_issue_type_scheme in backend/python/app/sources/external/jira/jira.py

⏱️ Runtime : 2.80 milliseconds → 2.59 milliseconds (best of 248 runs)

📝 Explanation and details

The optimized code achieves an 8% runtime improvement and 0.4% throughput improvement through several targeted micro-optimizations that reduce unnecessary work and function calls:

Key Optimizations Applied

1. Conditional Dictionary Conversion

• Original: Always calls _as_str_dict() on headers, path_params, and query_params regardless of content
• Optimized: Only converts non-empty dictionaries (hdr_conv = _as_str_dict(_headers) if _headers else {}), skipping conversion for empty dicts
• Impact: Eliminates ~33% of _as_str_dict calls (from 2331 to 800 hits in profiler), saving significant time on the most expensive helper function

2. Fast-Path URL Formatting

• Original: Always attempts template.format_map() and handles exceptions
• Optimized: Adds early check if '{' not in template: to skip formatting when no placeholders exist
• Impact: Reduces unnecessary string operations and exception handling overhead

3. Local Function Reference Caching

• Original: Accesses _serialize_value through module lookup in dict comprehension
• Optimized: Stores reference as ser = _serialize_value before the loop
• Impact: Eliminates repeated attribute lookups during dictionary conversion

4. Client Reference Optimization

• Original: Repeatedly accesses self._client
• Optimized: Stores in local variable client = self._client at method start
• Impact: Reduces attribute access overhead

Performance Analysis

The line profiler shows the optimizations primarily benefit _as_str_dict() (reduced from 2.59ms to 1.93ms total time) and eliminate redundant conversions. The delete_issue_type_scheme method itself drops from 14.5ms to 12.0ms total time.

Test Case Performance

Based on the annotated tests, these optimizations are particularly effective for:

• High-volume concurrent operations (200+ concurrent calls)
• Repeated API calls with similar request patterns
• Scenarios with empty headers/query parameters where conversion can be skipped entirely

The optimizations maintain identical behavior while reducing computational overhead, making them especially valuable in high-throughput API client scenarios.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import asyncio

import pytest
from app.sources.external.jira.jira import JiraDataSource

--- Minimal stubs for dependencies to allow testing ---

class HTTPResponse:
"""Stub for HTTPResponse, mimics a real HTTP response."""
def init(self, status_code=204, content=None):
self.status_code = status_code
self.content = content or {}

class HTTPRequest:
"""Stub for HTTPRequest, holds request data for inspection."""
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

-- Mock HTTP client for async execution --

class MockAsyncHTTPClient:
"""Mock async HTTP client for testing."""
def init(self, base_url, fail_on_execute=False, delay=0, record_requests=False):
self._base_url = base_url
self.fail_on_execute = fail_on_execute
self.delay = delay
self.record_requests = record_requests
self.requests = []

def get_base_url(self):
    return self._base_url

async def execute(self, req):
    if self.delay > 0:
        await asyncio.sleep(self.delay)
    if self.record_requests:
        self.requests.append(req)
    if self.fail_on_execute:
        raise RuntimeError("Simulated client failure")
    # Simulate different response codes based on input for edge tests
    if req.path_params.get('issueTypeSchemeId') == -1:
        return HTTPResponse(status_code=404, content={"error": "Not found"})
    return HTTPResponse(status_code=204, content={"deleted": req.path_params.get('issueTypeSchemeId')})

-- Mock JiraClient wrapper --

class JiraClient:
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_delete_issue_type_scheme_basic_success():
"""Test basic successful deletion with a valid scheme ID."""
client = MockAsyncHTTPClient("https://jira.example.com")
ds = JiraDataSource(JiraClient(client))
resp = await ds.delete_issue_type_scheme(123)

@pytest.mark.asyncio
async def test_delete_issue_type_scheme_with_headers():
"""Test deletion with custom headers provided."""
client = MockAsyncHTTPClient("https://jira.example.com", record_requests=True)
ds = JiraDataSource(JiraClient(client))
custom_headers = {"X-Test-Header": "yes"}
resp = await ds.delete_issue_type_scheme(456, headers=custom_headers)

@pytest.mark.asyncio
async def test_delete_issue_type_scheme_returns_httpresponse():
"""Test that the function always returns an HTTPResponse object."""
client = MockAsyncHTTPClient("https://jira.example.com")
ds = JiraDataSource(JiraClient(client))
result = await ds.delete_issue_type_scheme(789)

2. EDGE TEST CASES

@pytest.mark.asyncio
async def test_delete_issue_type_scheme_invalid_id_not_found():
"""Test deletion with an invalid issueTypeSchemeId returns 404."""
client = MockAsyncHTTPClient("https://jira.example.com")
ds = JiraDataSource(JiraClient(client))
resp = await ds.delete_issue_type_scheme(-1)

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

@pytest.mark.asyncio
async def test_delete_issue_type_scheme_client_missing_base_url():
"""Test init with client missing get_base_url raises ValueError."""
class NoBaseUrlClient:
pass
class DummyJiraClient:
def get_client(self):
return NoBaseUrlClient()
with pytest.raises(ValueError, match="get_base_url"):
JiraDataSource(DummyJiraClient())

@pytest.mark.asyncio
async def test_delete_issue_type_scheme_client_execute_raises():
"""Test that an exception in client.execute is propagated."""
client = MockAsyncHTTPClient("https://jira.example.com", fail_on_execute=True)
ds = JiraDataSource(JiraClient(client))
with pytest.raises(RuntimeError, match="Simulated client failure"):
await ds.delete_issue_type_scheme(123)

@pytest.mark.asyncio
async def test_delete_issue_type_scheme_concurrent_calls():
"""Test multiple concurrent deletions with different IDs."""
client = MockAsyncHTTPClient("https://jira.example.com", record_requests=True)
ds = JiraDataSource(JiraClient(client))
ids = [1, 2, 3, 4, 5]
results = await asyncio.gather(*(ds.delete_issue_type_scheme(i) for i in ids))

@pytest.mark.asyncio
async def test_delete_issue_type_scheme_empty_headers_and_query():
"""Test that empty headers and query params are handled gracefully."""
client = MockAsyncHTTPClient("https://jira.example.com", record_requests=True)
ds = JiraDataSource(JiraClient(client))
resp = await ds.delete_issue_type_scheme(999, headers={})

3. LARGE SCALE TEST CASES

@pytest.mark.asyncio
async def test_delete_issue_type_scheme_many_concurrent_calls():
"""Test 50 concurrent deletions to simulate large scale."""
client = MockAsyncHTTPClient("https://jira.example.com", record_requests=True)
ds = JiraDataSource(JiraClient(client))
ids = list(range(100, 150))
results = await asyncio.gather(*(ds.delete_issue_type_scheme(i) for i in ids))

@pytest.mark.asyncio
async def test_delete_issue_type_scheme_concurrent_edge_cases():
"""Test concurrent calls with a mix of valid and invalid IDs."""
client = MockAsyncHTTPClient("https://jira.example.com", record_requests=True)
ds = JiraDataSource(JiraClient(client))
ids = [10, -1, 20, -1, 30]
results = await asyncio.gather(*(ds.delete_issue_type_scheme(i) for i in ids))

4. THROUGHPUT TEST CASES

@pytest.mark.asyncio
async def test_delete_issue_type_scheme_throughput_small_load():
"""Throughput: Test 10 concurrent deletions (small load)."""
client = MockAsyncHTTPClient("https://jira.example.com")
ds = JiraDataSource(JiraClient(client))
ids = list(range(10))
results = await asyncio.gather(*(ds.delete_issue_type_scheme(i) for i in ids))

@pytest.mark.asyncio
async def test_delete_issue_type_scheme_throughput_medium_load():
"""Throughput: Test 100 concurrent deletions (medium load)."""
client = MockAsyncHTTPClient("https://jira.example.com")
ds = JiraDataSource(JiraClient(client))
ids = list(range(100, 200))
results = await asyncio.gather(*(ds.delete_issue_type_scheme(i) for i in ids))

@pytest.mark.asyncio
async def test_delete_issue_type_scheme_throughput_mixed_load():
"""Throughput: Test a mix of valid and invalid IDs in concurrent calls."""
client = MockAsyncHTTPClient("https://jira.example.com")
ds = JiraDataSource(JiraClient(client))
ids = [1, 2, -1, 4, -1, 6, 7, 8, -1, 10]
results = await asyncio.gather(*(ds.delete_issue_type_scheme(i) for i in ids))
for i, r in zip(ids, results):
if i == -1:
pass
else:
pass

@pytest.mark.asyncio
async def test_delete_issue_type_scheme_throughput_high_volume():
"""Throughput: Test 200 concurrent deletions (upper bound for fast test)."""
client = MockAsyncHTTPClient("https://jira.example.com")
ds = JiraDataSource(JiraClient(client))
ids = list(range(1000, 1200))
results = await asyncio.gather(*(ds.delete_issue_type_scheme(i) for i in ids))

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 dependencies ----

class HTTPResponse:
"""A minimal HTTPResponse stub for testing."""
def init(self, status_code=204, content=None, headers=None):
self.status_code = status_code
self.content = content
self.headers = headers or {}

class HTTPRequest:
"""A minimal HTTPRequest stub for testing."""
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 JiraClient and HTTPClient stubs ----

class DummyHTTPClient:
"""A dummy async HTTP client that simulates execute()."""
def init(self, base_url="https://dummy-jira.com", raise_on_execute=None):
self._base_url = base_url
self._raise_on_execute = raise_on_execute
self.last_request = None
self.execute_call_count = 0

def get_base_url(self):
    return self._base_url

async def execute(self, request):
    self.execute_call_count += 1
    self.last_request = request
    if self._raise_on_execute:
        raise self._raise_on_execute
    # Simulate different responses based on path param
    if "fail" in str(request.url):
        return HTTPResponse(status_code=404, content="Not Found")
    return HTTPResponse(status_code=204, content="Deleted")

class JiraClient:
"""A dummy JiraClient that wraps a DummyHTTPClient."""
def init(self, client):
self.client = client

def get_client(self):
    return self.client

from app.sources.external.jira.jira import JiraDataSource

---- TESTS ----

1. Basic Test Cases

@pytest.mark.asyncio
async def test_delete_issue_type_scheme_basic_success():
"""Test basic successful deletion with a valid issueTypeSchemeId."""
client = DummyHTTPClient()
ds = JiraDataSource(JiraClient(client))
resp = await ds.delete_issue_type_scheme(123)

@pytest.mark.asyncio
async def test_delete_issue_type_scheme_with_headers():
"""Test deletion with custom headers provided."""
client = DummyHTTPClient()
ds = JiraDataSource(JiraClient(client))
headers = {"X-Test-Header": "foo"}
resp = await ds.delete_issue_type_scheme(456, headers=headers)

@pytest.mark.asyncio
async def test_delete_issue_type_scheme_strict_type_casting():
"""Test that int and str headers are stringified properly."""
client = DummyHTTPClient()
ds = JiraDataSource(JiraClient(client))
headers = {"X-Int": 42, "X-Bool": True}
resp = await ds.delete_issue_type_scheme(789, headers=headers)
h = client.last_request.headers

2. Edge Test Cases

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

@pytest.mark.asyncio
async def test_delete_issue_type_scheme_client_missing_base_url():
"""Test that ValueError is raised if client has no get_base_url method."""
class BadClient:
pass
class BadJiraClient:
def get_client(self):
return BadClient()
with pytest.raises(ValueError, match="HTTP client does not have get_base_url method"):
JiraDataSource(BadJiraClient())

@pytest.mark.asyncio
async def test_delete_issue_type_scheme_execute_raises_exception():
"""Test that exceptions from the client's execute method are propagated."""
client = DummyHTTPClient(raise_on_execute=RuntimeError("boom"))
ds = JiraDataSource(JiraClient(client))
with pytest.raises(RuntimeError, match="boom"):
await ds.delete_issue_type_scheme(101)

@pytest.mark.asyncio
async def test_delete_issue_type_scheme_not_found_response():
"""Test that a 404 Not Found response is handled and returned."""
client = DummyHTTPClient()
ds = JiraDataSource(JiraClient(client))
resp = await ds.delete_issue_type_scheme("fail")

@pytest.mark.asyncio
async def test_delete_issue_type_scheme_concurrent_calls():
"""Test concurrent deletion requests with different IDs."""
client = DummyHTTPClient()
ds = JiraDataSource(JiraClient(client))
ids = [100, 200, 300, 400]
results = await asyncio.gather(
*(ds.delete_issue_type_scheme(i) for i in ids)
)

3. Large Scale Test Cases

@pytest.mark.asyncio
async def test_delete_issue_type_scheme_many_concurrent():
"""Test many concurrent delete calls to check scalability."""
client = DummyHTTPClient()
ds = JiraDataSource(JiraClient(client))
ids = list(range(10, 60)) # 50 concurrent calls
results = await asyncio.gather(
*(ds.delete_issue_type_scheme(i) for i in ids)
)

@pytest.mark.asyncio
async def test_delete_issue_type_scheme_edge_case_id_zero():
"""Test deletion with edge-case ID = 0."""
client = DummyHTTPClient()
ds = JiraDataSource(JiraClient(client))
resp = await ds.delete_issue_type_scheme(0)

@pytest.mark.asyncio
async def test_delete_issue_type_scheme_edge_case_negative_id():
"""Test deletion with negative issueTypeSchemeId."""
client = DummyHTTPClient()
ds = JiraDataSource(JiraClient(client))
resp = await ds.delete_issue_type_scheme(-999)

4. Throughput Test Cases

@pytest.mark.asyncio
async def test_delete_issue_type_scheme_throughput_small_load():
"""Throughput: Test 10 concurrent deletions (small load)."""
client = DummyHTTPClient()
ds = JiraDataSource(JiraClient(client))
ids = list(range(1, 11))
results = await asyncio.gather(*(ds.delete_issue_type_scheme(i) for i in ids))

@pytest.mark.asyncio
async def test_delete_issue_type_scheme_throughput_medium_load():
"""Throughput: Test 100 concurrent deletions (medium load)."""
client = DummyHTTPClient()
ds = JiraDataSource(JiraClient(client))
ids = list(range(1000, 1100))
results = await asyncio.gather(*(ds.delete_issue_type_scheme(i) for i in ids))

@pytest.mark.asyncio
async def test_delete_issue_type_scheme_throughput_varied_headers():
"""Throughput: Test 20 concurrent deletions with varied headers."""
client = DummyHTTPClient()
ds = JiraDataSource(JiraClient(client))
ids = list(range(500, 520))
headers_list = [{"X-Req": str(i)} for i in ids]
coros = [ds.delete_issue_type_scheme(i, headers=h) for i, h in zip(ids, headers_list)]
results = await asyncio.gather(*coros)
for i, r in enumerate(results):
pass

@pytest.mark.asyncio
async def test_delete_issue_type_scheme_throughput_high_volume():
"""Throughput: Test 200 concurrent deletions (high volume, under 1000)."""
client = DummyHTTPClient()
ds = JiraDataSource(JiraClient(client))
ids = list(range(2000, 2200))
results = await asyncio.gather(*(ds.delete_issue_type_scheme(i) for i in ids))

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.delete_issue_type_scheme-mhs79pj1 and push.