⚡️ Speed up function encode_instruments by 18%

[codeflash-ai]

📄 18% (0.18x) speedup for encode_instruments in gs_quant/instrument/core.py

⏱️ Runtime : 1.00 millisecond → 847 microseconds (best of 478 runs)

📝 Explanation and details

The optimization eliminates function call overhead by inlining the encoding logic directly in the list comprehension. Instead of calling encode_instrument(i) for each element, the optimized version uses i.to_dict() if i is not None else None directly within the comprehension.

Key Changes:

• Removed the intermediate function call to encode_instrument() for each item in the list
• Inlined the None check and to_dict() call directly in the list comprehension

Why This Is Faster:
Python function calls have significant overhead - each call involves stack frame creation, parameter passing, and return value handling. By eliminating ~6,000 function calls (as shown in the profiler), the optimization reduces the per-hit time from 457,234ns to 122,899ns - a 73% reduction in per-element processing time.

Performance Characteristics:
The optimization shows the best gains on larger datasets:

• Small lists (1-3 items): 7-25% faster
• Large lists (1000 items): 24-51% faster
• Lists with mixed None values benefit most, showing up to 51% improvement

This is particularly effective for batch processing scenarios where encode_instruments is called with substantial collections of instruments, which appears to be the primary use case based on the test patterns.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from typing import Any, Iterable, Optional

# imports
import pytest
from gs_quant.instrument.core import encode_instruments


# --- Function to test (with dummy Instrument class for testing) ---
class Instrument:
    """Minimal Instrument class for testing encode_instruments."""
    def __init__(self, data):
        self.data = data

    def to_dict(self):
        # For test purposes, just return the data dict
        return self.data
from gs_quant.instrument.core import encode_instruments

# --- Unit Tests ---

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

def test_encode_instruments_single_instrument():
    # Test with a single instrument in a list
    inst = Instrument({'a': 1, 'b': 2})
    codeflash_output = encode_instruments([inst]); result = codeflash_output # 1.20μs -> 956ns (25.4% faster)

def test_encode_instruments_multiple_instruments():
    # Test with multiple instruments
    inst1 = Instrument({'id': 1})
    inst2 = Instrument({'id': 2, 'name': 'Bond'})
    inst3 = Instrument({'id': 3, 'type': 'Option'})
    codeflash_output = encode_instruments([inst1, inst2, inst3]); result = codeflash_output # 1.20μs -> 1.06μs (12.8% faster)

def test_encode_instruments_empty_list():
    # Test with an empty list
    codeflash_output = encode_instruments([]); result = codeflash_output # 624ns -> 609ns (2.46% faster)

def test_encode_instruments_none():
    # Test with None as input
    codeflash_output = encode_instruments(None); result = codeflash_output # 316ns -> 287ns (10.1% faster)

# -----------------------
# Edge Test Cases
# -----------------------

def test_encode_instruments_with_none_in_list():
    # Test with a list containing None
    inst = Instrument({'foo': 'bar'})
    codeflash_output = encode_instruments([inst, None]); result = codeflash_output # 1.16μs -> 953ns (21.4% faster)

def test_encode_instruments_all_none():
    # Test with a list of all None
    codeflash_output = encode_instruments([None, None]); result = codeflash_output # 878ns -> 744ns (18.0% faster)

def test_encode_instruments_mixed_types():
    # Test with a list containing an instrument and an unrelated type
    inst = Instrument({'x': 1})
    # Should raise AttributeError when trying to call .to_dict() on int
    with pytest.raises(AttributeError):
        encode_instruments([inst, 123]) # 2.09μs -> 1.87μs (11.9% faster)


def test_encode_instruments_tuple_input():
    # Test with a tuple as input
    insts = (Instrument({'a': 'A'}), Instrument({'b': 'B'}))
    codeflash_output = encode_instruments(insts); result = codeflash_output # 1.02μs -> 877ns (16.1% faster)

def test_encode_instruments_set_input():
    # Test with a set as input (order not guaranteed)
    insts = {Instrument({'foo': 1}), Instrument({'foo': 2})}
    codeflash_output = encode_instruments(insts); result = codeflash_output # 1.20μs -> 1.11μs (8.09% faster)

def test_encode_instruments_custom_iterable():
    # Test with a custom iterable class
    class MyIterable:
        def __init__(self, items):
            self.items = items
        def __iter__(self):
            return iter(self.items)
    insts = MyIterable([Instrument({'z': 9}), Instrument({'z': 10})])
    codeflash_output = encode_instruments(insts); result = codeflash_output # 1.65μs -> 1.45μs (13.7% faster)

def test_encode_instruments_instrument_with_empty_dict():
    # Test instrument whose to_dict returns empty dict
    inst = Instrument({})
    codeflash_output = encode_instruments([inst]); result = codeflash_output # 955ns -> 837ns (14.1% faster)

def test_encode_instruments_instrument_with_nested_dict():
    # Test instrument whose to_dict returns nested dict
    inst = Instrument({'a': {'b': 2}})
    codeflash_output = encode_instruments([inst]); result = codeflash_output # 899ns -> 801ns (12.2% faster)

# -----------------------
# Large Scale Test Cases
# -----------------------

def test_encode_instruments_large_list():
    # Test with a large list of instruments (1000 elements)
    N = 1000
    insts = [Instrument({'idx': i}) for i in range(N)]
    codeflash_output = encode_instruments(insts); result = codeflash_output # 72.2μs -> 48.9μs (47.6% faster)
    for i in range(N):
        pass

def test_encode_instruments_large_list_with_some_none():
    # Test with a large list containing some None values
    N = 1000
    insts = [Instrument({'idx': i}) if i % 10 != 0 else None for i in range(N)]
    codeflash_output = encode_instruments(insts); result = codeflash_output # 70.7μs -> 46.9μs (51.0% faster)
    for i in range(N):
        if i % 10 == 0:
            pass
        else:
            pass


def test_encode_instruments_determinism():
    # Test that repeated calls with the same input give the same output
    insts = [Instrument({'id': 42}), Instrument({'id': 43})]
    codeflash_output = encode_instruments(insts); result1 = codeflash_output # 1.21μs -> 981ns (22.9% faster)
    codeflash_output = encode_instruments(insts); result2 = codeflash_output # 478ns -> 408ns (17.2% faster)

def test_encode_instruments_returns_list():
    # Test that the result is always a list (when not None)
    insts = [Instrument({'x': 1}), None]
    codeflash_output = encode_instruments(insts); result = codeflash_output # 1.01μs -> 883ns (14.7% faster)

# -----------------------
# Invalid Input Handling
# -----------------------

def test_encode_instruments_invalid_input_type():
    # Test with an integer as input (should raise TypeError)
    with pytest.raises(TypeError):
        encode_instruments(123) # 1.12μs -> 1.12μs (0.626% faster)

def test_encode_instruments_string_input():
    # Test with a string as input (should raise AttributeError on .to_dict())
    with pytest.raises(AttributeError):
        encode_instruments("not an instrument") # 1.90μs -> 1.65μs (15.1% faster)

def test_encode_instruments_dict_input():
    # Test with a dict as input (should raise AttributeError)
    with pytest.raises(AttributeError):
        encode_instruments({'a': 1}) # 1.69μs -> 1.52μs (11.4% faster)

# -----------------------
# Miscellaneous
# -----------------------

def test_encode_instruments_instrument_with_non_dict_to_dict():
    # Test instrument whose to_dict returns a non-dict value
    class WeirdInstrument:
        def to_dict(self):
            return 12345
    inst = WeirdInstrument()
    codeflash_output = encode_instruments([inst]); result = codeflash_output # 1.17μs -> 1.02μs (14.6% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from typing import Iterable, Optional

# imports
import pytest
from gs_quant.instrument.core import encode_instruments

# --- Function to test (copied from prompt, with Instrument mock for testing) ---

# Minimal Instrument mock for testing purposes
class Instrument:
    def __init__(self, name, value=None):
        self.name = name
        self.value = value

    def to_dict(self):
        # Handles both with and without value
        d = {'name': self.name}
        if self.value is not None:
            d['value'] = self.value
        return d
from gs_quant.instrument.core import encode_instruments

# --- Unit tests ---

# 1. Basic Test Cases

def test_encode_instruments_single_instrument():
    # Test a list with a single Instrument
    instr = Instrument("Guitar", 100)
    codeflash_output = encode_instruments([instr]); result = codeflash_output # 1.35μs -> 1.25μs (7.57% faster)

def test_encode_instruments_multiple_instruments():
    # Test a list with multiple Instruments
    instr1 = Instrument("Guitar", 100)
    instr2 = Instrument("Piano", 200)
    instr3 = Instrument("Drum", 50)
    codeflash_output = encode_instruments([instr1, instr2, instr3]); result = codeflash_output # 1.61μs -> 1.47μs (9.31% faster)

def test_encode_instruments_empty_list():
    # Test with an empty list
    codeflash_output = encode_instruments([]); result = codeflash_output # 596ns -> 616ns (3.25% slower)

def test_encode_instruments_instrument_without_value():
    # Test Instrument with only name (no value)
    instr = Instrument("Flute")
    codeflash_output = encode_instruments([instr]); result = codeflash_output # 1.08μs -> 1.04μs (4.14% faster)

# 2. Edge Test Cases

def test_encode_instruments_none_input():
    # Test when input is None
    codeflash_output = encode_instruments(None); result = codeflash_output # 297ns -> 296ns (0.338% faster)

def test_encode_instruments_list_of_none():
    # Test when input is a list of None
    codeflash_output = encode_instruments([None, None]); result = codeflash_output # 941ns -> 753ns (25.0% faster)

def test_encode_instruments_mixed_instruments_and_none():
    # Test when input contains both Instruments and None
    instr1 = Instrument("Violin", 300)
    instr2 = None
    instr3 = Instrument("Cello", 400)
    codeflash_output = encode_instruments([instr1, instr2, instr3]); result = codeflash_output # 1.45μs -> 1.38μs (5.45% faster)

def test_encode_instruments_iterable_tuple():
    # Test when input is a tuple instead of a list
    instr1 = Instrument("Saxophone", 250)
    instr2 = Instrument("Clarinet", 180)
    codeflash_output = encode_instruments((instr1, instr2)); result = codeflash_output # 1.26μs -> 1.22μs (3.36% faster)


def test_encode_instruments_instrument_with_special_chars():
    # Test Instrument with special characters in name
    instr = Instrument("🎸-Guitar", 999)
    codeflash_output = encode_instruments([instr]); result = codeflash_output # 1.08μs -> 1.03μs (3.96% faster)

def test_encode_instruments_instrument_with_empty_name():
    # Test Instrument with empty string as name
    instr = Instrument("", 0)
    codeflash_output = encode_instruments([instr]); result = codeflash_output # 1.07μs -> 1.04μs (3.47% faster)

def test_encode_instruments_instrument_with_none_value():
    # Test Instrument with explicit None value
    instr = Instrument("Oboe", None)
    codeflash_output = encode_instruments([instr]); result = codeflash_output # 1.07μs -> 988ns (8.10% faster)

def test_encode_instruments_non_instrument_object():
    # Test input containing an object that is not an Instrument or None
    class NotInstrument:
        pass
    not_instr = NotInstrument()
    with pytest.raises(AttributeError):
        encode_instruments([not_instr]) # 1.86μs -> 1.69μs (10.5% faster)

# 3. Large Scale Test Cases

def test_encode_instruments_large_list():
    # Test with a large list of Instruments (size 1000)
    instrs = [Instrument(f"Inst{i}", i) for i in range(1000)]
    codeflash_output = encode_instruments(instrs); result = codeflash_output # 153μs -> 123μs (24.4% faster)
    for i in range(1000):
        pass

def test_encode_instruments_large_list_with_nones():
    # Test with a large list containing both Instruments and None
    instrs = [Instrument(f"Inst{i}", i) if i % 2 == 0 else None for i in range(1000)]
    codeflash_output = encode_instruments(instrs); result = codeflash_output # 89.3μs -> 63.9μs (39.7% faster)
    for i in range(1000):
        if i % 2 == 0:
            pass
        else:
            pass

To edit these changes git checkout codeflash/optimize-encode_instruments-mhb7ckdz and push.