⚡️ Speed up function api_error_handler by 36%

[codeflash-ai]

📄 36% (0.36x) speedup for api_error_handler in mem0/client/utils.py

⏱️ Runtime : 402 microseconds → 297 microseconds (best of 25 runs)

📝 Explanation and details

The optimized version achieves a 35% speedup by moving the functools.wraps import to module level instead of importing it inside the decorator function each time.

Key Optimization:

• Module-level import: The from functools import wraps statement was moved from inside the api_error_handler function to the top-level imports. This eliminates the repeated import cost every time the decorator is instantiated.

Why this matters:
In Python, imports have overhead even when the module is already cached. The original code performed this import operation every time api_error_handler was called to decorate a function. With the optimization, the import happens only once when the module is loaded.

Performance Impact:

• The line profiler shows the decorator creation is now faster, with the main time spent in the wrapper function definition rather than the import operation
• This optimization is particularly beneficial when decorating multiple functions or when the decorator is used frequently during application startup

Minor Change:
The optimized version also caches str(e) as orig_err variable in the exception handling block, avoiding multiple string conversions of the same exception object.

Real-world benefit:
Since this is an error handling decorator likely used across multiple API client functions, the import cost savings accumulate significantly during application initialization when many decorated functions are defined. The 35% speedup in decorator creation directly translates to faster module loading and application startup times.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import json
# --- Function to test (api_error_handler) --- #
import logging

import httpx
# imports
import pytest
from mem0.client.utils import api_error_handler

# --- Dummy exception classes and helpers to mimic mem0.exceptions --- #

class NetworkError(Exception):
    def __init__(self, message, error_code, suggestion, debug_info):
        super().__init__(message)
        self.message = message
        self.error_code = error_code
        self.suggestion = suggestion
        self.debug_info = debug_info

class APIError(Exception):
    def __init__(self, message, status_code, details, debug_info):
        super().__init__(message)
        self.message = message
        self.status_code = status_code
        self.details = details
        self.debug_info = debug_info

def create_exception_from_response(status_code, response_text, details, debug_info):
    # Simulate a mapping for status codes
    if status_code == 404:
        return APIError(f"Not Found: {response_text}", status_code, details, debug_info)
    elif status_code == 400:
        return APIError(f"Bad Request: {response_text}", status_code, details, debug_info)
    elif status_code == 401:
        return APIError(f"Unauthorized: {response_text}", status_code, details, debug_info)
    elif status_code == 429:
        return APIError(f"Rate Limited: {response_text}", status_code, details, debug_info)
    elif status_code == 500:
        return APIError(f"Internal Server Error: {response_text}", status_code, details, debug_info)
    else:
        return APIError(f"HTTP Error {status_code}: {response_text}", status_code, details, debug_info)

logger = logging.getLogger(__name__)
from mem0.client.utils import api_error_handler


# --- Helper classes for simulating httpx exceptions --- #
class DummyRequest:
    def __init__(self, method="GET", url="https://api.example.com/resource"):
        self.method = method
        self.url = url

class DummyResponse:
    def __init__(self, status_code, text="", headers=None):
        self.status_code = status_code
        self.text = text
        self.headers = headers or {}

# --- Unit Tests --- #

# 1. Basic Test Cases

def test_successful_call_returns_value():
    """Test that a normal function call returns its value unchanged."""
    @api_error_handler
    def foo(x):
        return x + 1








def test_many_successful_calls():
    """Test that many successful calls do not trigger error handling."""
    @api_error_handler
    def foo(x):
        return x * 2
    for i in range(1000):  # Large number of calls
        pass





#------------------------------------------------
import json
# function to test
import logging

import httpx
# imports
import pytest
from mem0.client.utils import api_error_handler


# Dummy exception classes and helpers to match the implementation above
class NetworkError(Exception):
    def __init__(self, message, error_code=None, suggestion=None, debug_info=None):
        super().__init__(message)
        self.message = message
        self.error_code = error_code
        self.suggestion = suggestion
        self.debug_info = debug_info or {}

class APIError(Exception):
    def __init__(self, message, status_code=None, details=None, debug_info=None):
        super().__init__(message)
        self.message = message
        self.status_code = status_code
        self.details = details or {}
        self.debug_info = debug_info or {}

class RateLimitError(APIError):
    pass

class NotFoundError(APIError):
    pass

class UnauthorizedError(APIError):
    pass

class BadRequestError(APIError):
    pass

class InternalServerError(APIError):
    pass

def create_exception_from_response(status_code, response_text, details, debug_info):
    # Mimics the real function, mapping status codes to exception types
    if status_code == 429:
        return RateLimitError(response_text, status_code, details, debug_info)
    elif status_code == 404:
        return NotFoundError(response_text, status_code, details, debug_info)
    elif status_code == 401:
        return UnauthorizedError(response_text, status_code, details, debug_info)
    elif status_code == 400:
        return BadRequestError(response_text, status_code, details, debug_info)
    elif status_code >= 500:
        return InternalServerError(response_text, status_code, details, debug_info)
    else:
        return APIError(response_text, status_code, details, debug_info)
from mem0.client.utils import api_error_handler

# ========== UNIT TESTS ==========

# Helper to make a fake httpx.Response and httpx.Request
def fake_response(
    status_code=400,
    text="Bad Request",
    headers=None,
    url="https://api.example.com/test",
    method="GET",
    content_type=None,
):
    headers = headers or {}
    if content_type:
        headers["content-type"] = content_type
    request = httpx.Request(method, url)
    response = httpx.Response(
        status_code=status_code,
        request=request,
        content=text.encode("utf-8"),
        headers=headers,
    )
    return response, request

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

def test_successful_call_returns_value():
    # Should return value if no exception is raised
    @api_error_handler
    def good_func():
        return 42























def test_large_scale_successful_calls():
    # Should not interfere with many successful calls
    @api_error_handler
    def good_func(x):
        return x * 2
    for i in range(1000):
        pass
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

⏪ Replay Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
test_pytest_testsconfigstest_prompts_py_testsvector_storestest_weaviate_py_testsllmstest_deepseek_py_test__replay_test_0.py::test_mem0_client_utils_api_error_handler	201μs	148μs	35.6%✅
test_pytest_testsvector_storestest_opensearch_py_testsvector_storestest_upstash_vector_py_testsllmstest_l__replay_test_0.py::test_mem0_client_utils_api_error_handler	201μs	148μs	35.8%✅

To edit these changes git checkout codeflash/optimize-api_error_handler-mhlij5oh and push.