⚡️ Speed up method AutoIntParamType.convert by 747%

[codeflash-ai]

📄 747% (7.47x) speedup for AutoIntParamType.convert in src/together/cli/api/utils.py

⏱️ Runtime : 40.7 milliseconds → 4.80 milliseconds (best of 158 runs)

📝 Explanation and details

The optimization caches the translated error format string to avoid repeated expensive gettext operations during ValueError handling.

Key optimization:

• Added lazy caching of the error format string using hasattr check and self._error_format attribute
• The original code called _("{value!r} is not a valid {number_type}.") on every ValueError, which was consuming 89.8% of execution time
• Now the gettext translation only happens once per class instance, then reuses the cached format string

Performance impact:
The line profiler shows the original _().format() call took 122.8ms (89.8% of total time), while the optimized version's format operation takes only 1.0ms (7.1% of total time). The caching check adds minimal overhead (~0.35ms) that only runs once per instance.

Test case benefits:
This optimization particularly excels with error cases that repeatedly fail validation:

• Invalid strings like "foo", "1.23", "MAX" see 400-660% speedup
• Batch processing of invalid inputs benefits significantly
• Valid conversions remain virtually unchanged (slight 1-2% variation)

The optimization maintains identical error messages and behavior while dramatically reducing the cost of handling validation failures through smart caching of the localized format string.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from __future__ import annotations

from gettext import gettext as _
from typing import Literal

import click
# imports
import pytest  # used for our unit tests
from together.cli.api.utils import AutoIntParamType

# unit tests

# Helper: create instance of the class to test
auto_int = AutoIntParamType()

# -----------------------------
# 1. Basic Test Cases
# -----------------------------

def test_convert_with_positive_integer():
    # Should convert a simple positive integer string
    codeflash_output = auto_int.convert("42", None, None) # 535ns -> 548ns (2.37% slower)

def test_convert_with_negative_integer():
    # Should convert a negative integer string
    codeflash_output = auto_int.convert("-17", None, None) # 656ns -> 625ns (4.96% faster)

def test_convert_with_zero():
    # Should convert "0" string to integer 0
    codeflash_output = auto_int.convert("0", None, None) # 637ns -> 627ns (1.59% faster)

def test_convert_with_max_string():
    # Should return "max" literal if input is "max"
    codeflash_output = auto_int.convert("max", None, None) # 357ns -> 367ns (2.72% slower)

def test_convert_with_leading_and_trailing_spaces():
    # Should raise error, as int("  123  ") is valid, but "max" with spaces is not
    with pytest.raises(click.BadParameter):
        auto_int.convert("  max  ", None, None)
    # Should raise error for integer with spaces (int() does not strip)
    with pytest.raises(click.BadParameter):
        auto_int.convert(" 123 ", None, None)

# -----------------------------
# 2. Edge Test Cases
# -----------------------------

def test_convert_with_empty_string():
    # Should raise error for empty string
    with pytest.raises(click.BadParameter):
        auto_int.convert("", None, None) # 56.2μs -> 12.0μs (370% faster)

def test_convert_with_non_numeric_string():
    # Should raise error for non-numeric, non-"max" string
    with pytest.raises(click.BadParameter):
        auto_int.convert("foo", None, None) # 45.4μs -> 9.12μs (398% faster)

def test_convert_with_float_string():
    # Should raise error for float string
    with pytest.raises(click.BadParameter):
        auto_int.convert("1.23", None, None) # 43.6μs -> 8.55μs (410% faster)

def test_convert_with_hexadecimal_string():
    # Should raise error for hex string (int("0x10") fails)
    with pytest.raises(click.BadParameter):
        auto_int.convert("0x10", None, None) # 43.1μs -> 8.31μs (419% faster)

def test_convert_with_large_integer_string():
    # Should convert very large integer string
    large_int = str(2**62)
    codeflash_output = auto_int.convert(large_int, None, None) # 730ns -> 746ns (2.14% slower)

def test_convert_with_plus_sign():
    # Should convert "+123" to 123
    codeflash_output = auto_int.convert("+123", None, None) # 632ns -> 644ns (1.86% slower)

def test_convert_with_minus_zero():
    # Should convert "-0" to 0 (int("-0") == 0)
    codeflash_output = auto_int.convert("-0", None, None) # 654ns -> 652ns (0.307% faster)

def test_convert_with_case_sensitive_max():
    # Should raise error for "MAX" (case sensitive)
    with pytest.raises(click.BadParameter):
        auto_int.convert("MAX", None, None) # 49.9μs -> 9.81μs (409% faster)
    with pytest.raises(click.BadParameter):
        auto_int.convert("Max", None, None) # 31.2μs -> 4.12μs (658% faster)

def test_convert_with_special_characters():
    # Should raise error for string with special characters
    with pytest.raises(click.BadParameter):
        auto_int.convert("123!", None, None) # 42.1μs -> 7.96μs (429% faster)
    with pytest.raises(click.BadParameter):
        auto_int.convert("!max", None, None) # 29.3μs -> 3.99μs (635% faster)

def test_convert_with_none_input():
    # Should raise error for None input (since value: str)
    with pytest.raises(TypeError):
        auto_int.convert(None, None, None) # 1.50μs -> 1.44μs (4.31% faster)

def test_convert_with_boolean_string():
    # Should raise error for "True" and "False"
    with pytest.raises(click.BadParameter):
        auto_int.convert("True", None, None) # 44.3μs -> 8.41μs (426% faster)
    with pytest.raises(click.BadParameter):
        auto_int.convert("False", None, None) # 29.8μs -> 3.92μs (660% faster)

def test_convert_with_whitespace_only():
    # Should raise error for whitespace-only string
    with pytest.raises(click.BadParameter):
        auto_int.convert("   ", None, None) # 45.6μs -> 8.82μs (417% faster)



def test_convert_with_many_valid_integers():
    # Should convert a range of integer strings correctly
    for i in range(-1000, 1000, 100):
        codeflash_output = auto_int.convert(str(i), None, None) # 4.55μs -> 4.65μs (2.02% slower)

def test_convert_with_many_invalid_strings():
    # Should raise error for many invalid strings
    invalids = ["foo", "bar", "baz", "1.1", "maxx", "1e3", "0b101", "", "  ", "!", "max "]
    for s in invalids:
        with pytest.raises(click.BadParameter):
            auto_int.convert(s, None, None)

def test_convert_with_large_integer_boundaries():
    # Should handle very large and very small integers
    big = str(10**100)
    small = str(-10**100)
    codeflash_output = auto_int.convert(big, None, None) # 1.01μs -> 1.03μs (2.14% slower)
    codeflash_output = auto_int.convert(small, None, None) # 531ns -> 531ns (0.000% faster)

def test_convert_performance_large_batch():
    # Should perform reasonably with a batch of 1000 valid and invalid inputs
    valid_inputs = [str(i) for i in range(500)]
    invalid_inputs = ["foo" + str(i) for i in range(500)]
    # All valid should convert correctly
    for s in valid_inputs:
        codeflash_output = auto_int.convert(s, None, None) # 90.9μs -> 91.3μs (0.365% slower)
    # All invalid should raise
    for s in invalid_inputs:
        with pytest.raises(click.BadParameter):
            auto_int.convert(s, None, None)

def test_convert_with_mixed_case_list():
    # Should handle a mixed list of valid and invalid inputs
    test_cases = [
        ("123", 123),
        ("-999", -999),
        ("max", "max"),
        ("MAX", click.BadParameter),
        ("foo", click.BadParameter),
        ("0", 0),
        ("+0", 0),
        ("-0", 0),
        ("", click.BadParameter),
        ("   ", click.BadParameter),
        ("1.0", click.BadParameter),
    ]
    for value, expected in test_cases:
        if expected is click.BadParameter:
            with pytest.raises(click.BadParameter):
                auto_int.convert(value, None, None)
        else:
            codeflash_output = auto_int.convert(value, None, None)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import click  # required for click.Parameter and click.Context
# imports
import pytest  # used for our unit tests
from together.cli.api.utils import AutoIntParamType


# Fixtures for dummy param and context
@pytest.fixture
def dummy_param():
    # Minimal dummy param for testing; not used in logic
    return None

@pytest.fixture
def dummy_ctx():
    # Minimal dummy context for testing; not used in logic
    return None

# Basic Test Cases

def test_convert_returns_integer_for_valid_string(dummy_param, dummy_ctx):
    """Test conversion of valid integer string."""
    conv = AutoIntParamType()
    codeflash_output = conv.convert("42", dummy_param, dummy_ctx) # 574ns -> 582ns (1.37% slower)
    codeflash_output = conv.convert("-17", dummy_param, dummy_ctx) # 373ns -> 379ns (1.58% slower)
    codeflash_output = conv.convert("0", dummy_param, dummy_ctx) # 242ns -> 237ns (2.11% faster)

def test_convert_returns_max_for_max_string(dummy_param, dummy_ctx):
    """Test conversion of 'max' string."""
    conv = AutoIntParamType()
    codeflash_output = conv.convert("max", dummy_param, dummy_ctx) # 385ns -> 360ns (6.94% faster)

def test_convert_raises_for_non_integer_string(dummy_param, dummy_ctx):
    """Test conversion of non-integer, non-'max' string."""
    conv = AutoIntParamType()
    with pytest.raises(click.BadParameter):
        conv.convert("hello", dummy_param, dummy_ctx) # 52.2μs -> 57.5μs (9.16% slower)
    with pytest.raises(click.BadParameter):
        conv.convert("42.5", dummy_param, dummy_ctx) # 31.5μs -> 4.40μs (617% faster)
    with pytest.raises(click.BadParameter):
        conv.convert("", dummy_param, dummy_ctx) # 28.1μs -> 3.37μs (733% faster)
    with pytest.raises(click.BadParameter):
        conv.convert(" ", dummy_param, dummy_ctx) # 27.5μs -> 3.16μs (770% faster)

# Edge Test Cases

def test_convert_accepts_large_integer_strings(dummy_param, dummy_ctx):
    """Test conversion of very large integer strings."""
    conv = AutoIntParamType()
    big_int_str = str(2**63)
    codeflash_output = conv.convert(big_int_str, dummy_param, dummy_ctx) # 727ns -> 702ns (3.56% faster)
    neg_big_int_str = str(-2**63)
    codeflash_output = conv.convert(neg_big_int_str, dummy_param, dummy_ctx) # 356ns -> 366ns (2.73% slower)

def test_convert_accepts_leading_and_trailing_spaces(dummy_param, dummy_ctx):
    """Test conversion of integer strings with spaces (should fail)."""
    conv = AutoIntParamType()
    # int(" 42 ") works in Python, so convert should accept it
    codeflash_output = conv.convert(" 42 ", dummy_param, dummy_ctx) # 593ns -> 555ns (6.85% faster)
    codeflash_output = conv.convert("\t-7\n", dummy_param, dummy_ctx) # 333ns -> 327ns (1.83% faster)

def test_convert_case_sensitivity_for_max(dummy_param, dummy_ctx):
    """Test that only 'max' (lowercase) is accepted, not 'MAX' or 'Max'."""
    conv = AutoIntParamType()
    with pytest.raises(click.BadParameter):
        conv.convert("MAX", dummy_param, dummy_ctx) # 47.8μs -> 51.4μs (7.05% slower)
    with pytest.raises(click.BadParameter):
        conv.convert("Max", dummy_param, dummy_ctx) # 29.9μs -> 4.09μs (632% faster)
    with pytest.raises(click.BadParameter):
        conv.convert("mAx", dummy_param, dummy_ctx) # 27.5μs -> 3.10μs (787% faster)


def test_convert_with_float_string(dummy_param, dummy_ctx):
    """Test conversion of float string (should fail)."""
    conv = AutoIntParamType()
    with pytest.raises(click.BadParameter):
        conv.convert("3.14", dummy_param, dummy_ctx) # 55.5μs -> 56.6μs (1.84% slower)
    with pytest.raises(click.BadParameter):
        conv.convert("-0.001", dummy_param, dummy_ctx) # 32.0μs -> 4.95μs (546% faster)

def test_convert_with_special_characters(dummy_param, dummy_ctx):
    """Test conversion of string with special characters (should fail)."""
    conv = AutoIntParamType()
    with pytest.raises(click.BadParameter):
        conv.convert("@42", dummy_param, dummy_ctx) # 43.2μs -> 47.0μs (8.11% slower)
    with pytest.raises(click.BadParameter):
        conv.convert("42!", dummy_param, dummy_ctx) # 30.3μs -> 4.41μs (588% faster)
    with pytest.raises(click.BadParameter):
        conv.convert("max!", dummy_param, dummy_ctx) # 27.6μs -> 3.34μs (725% faster)

# Large Scale Test Cases

def test_convert_many_valid_integer_strings(dummy_param, dummy_ctx):
    """Test conversion of many valid integer strings for scalability."""
    conv = AutoIntParamType()
    for i in range(1000):  # up to 1000 elements
        s = str(i)
        codeflash_output = conv.convert(s, dummy_param, dummy_ctx) # 185μs -> 187μs (1.01% slower)
        s_neg = str(-i)
        codeflash_output = conv.convert(s_neg, dummy_param, dummy_ctx)

def test_convert_many_invalid_strings(dummy_param, dummy_ctx):
    """Test conversion of many invalid strings for robustness."""
    conv = AutoIntParamType()
    invalids = [f"notanumber{i}" for i in range(1000)]
    for s in invalids:
        with pytest.raises(click.BadParameter):
            conv.convert(s, dummy_param, dummy_ctx)

def test_convert_many_max_strings(dummy_param, dummy_ctx):
    """Test conversion of many 'max' strings for consistency."""
    conv = AutoIntParamType()
    for _ in range(1000):
        codeflash_output = conv.convert("max", dummy_param, dummy_ctx) # 126μs -> 124μs (1.11% faster)

def test_convert_large_integer_boundaries(dummy_param, dummy_ctx):
    """Test conversion of boundary values near 32-bit and 64-bit integer limits."""
    conv = AutoIntParamType()
    # 32-bit signed int boundaries
    codeflash_output = conv.convert(str(2**31 - 1), dummy_param, dummy_ctx) # 787ns -> 784ns (0.383% faster)
    codeflash_output = conv.convert(str(-2**31), dummy_param, dummy_ctx) # 332ns -> 334ns (0.599% slower)
    # 64-bit signed int boundaries
    codeflash_output = conv.convert(str(2**63 - 1), dummy_param, dummy_ctx) # 312ns -> 317ns (1.58% slower)
    codeflash_output = conv.convert(str(-2**63), dummy_param, dummy_ctx) # 249ns -> 264ns (5.68% slower)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from click.core import Command
from click.core import CommandCollection
from click.core import Context
from together.cli.api.utils import AutoIntParamType
import pytest

def test_AutoIntParamType_convert():
    with pytest.raises(BadParameter, match="'\\\\x00\\\\x00\\\\x00'\\ is\\ not\\ a\\ valid\\ integer_or_max\\."):
        AutoIntParamType.convert(AutoIntParamType(), '\x00\x00\x00', None, None)

def test_AutoIntParamType_convert_2():
    AutoIntParamType.convert(AutoIntParamType(), '000', None, Context(CommandCollection(name=None, sources=None), parent=Context(Command(None, context_settings=None, callback=(x:=[0, 0], lambda *a: x.pop(0) if len(x) > 1 else x[0])[1], params=None, help='', epilog=None, short_help=None, options_metavar=None, add_help_option=True, no_args_is_help=False, hidden=False, deprecated=''), parent=None, info_name=None, obj='', auto_envvar_prefix='-', default_map={}, terminal_width=None, max_content_width=None, resilient_parsing=False, allow_extra_args=None, allow_interspersed_args=True, ignore_unknown_options=None, help_option_names=None, token_normalize_func=lambda *a: , color=True, show_default=False), info_name=None, obj=None, auto_envvar_prefix='ḛ', default_map=None, terminal_width=0, max_content_width=0, resilient_parsing=True, allow_extra_args=False, allow_interspersed_args=False, ignore_unknown_options=True, help_option_names=[], token_normalize_func=lambda *a: , color=True, show_default=None))

To edit these changes git checkout codeflash/optimize-AutoIntParamType.convert-mgzwj1cv and push.