⚡️ Speed up method DataCol.get_atom_string by 13%

[codeflash-ai]

📄 13% (0.13x) speedup for DataCol.get_atom_string in pandas/io/pytables.py

⏱️ Runtime : 497 microseconds → 441 microseconds (best of 28 runs)

📝 Explanation and details

The optimization caches the tables.StringCol class reference to eliminate repeated attribute lookups in the get_atom_string method.

What was optimized:

• Added a global cache variable _Table_StringCol that stores the tables.StringCol class reference
• Modified _tables() to populate this cache during the initial import
• Updated get_atom_string() to use the cached reference instead of calling _tables().StringCol every time

Why this speeds up the code:
The original code called _tables().StringCol on every invocation of get_atom_string(). This involved:

1. A global variable lookup for _table_mod
2. A function call to _tables()
3. An attribute lookup on the returned module object to access StringCol

The optimization eliminates steps 2-3 for subsequent calls by caching the StringCol class reference directly. Python attribute lookups on module objects are relatively expensive operations, and avoiding them in frequently called methods provides measurable speedup.

Performance impact:

• Line profiler shows the optimized get_atom_string() spends only 2.4% of its time on the actual StringCol instantiation (line with return _Table_StringCol(...)) versus nearly 100% in the original
• The 12% overall speedup is achieved by reducing the per-call overhead from ~804,671ns to ~18,525ns for the StringCol access
• Test results show consistent 10-20% improvements across various input sizes, with particularly good gains (up to 30%) on error cases that fail fast

When this optimization helps most:
This optimization is most beneficial when get_atom_string() is called frequently, as each call now avoids the module attribute lookup overhead. The test results show consistent improvements across all scenarios, suggesting this method is likely used in data processing pipelines where string column creation is repeated many times.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import pytest
from pandas.io.pytables import DataCol

--- Minimal mock for _tables().StringCol, since we cannot import PyTables ---

class MockStringCol:
def init(self, itemsize, shape):
self.itemsize = itemsize
self.shape = shape

def __eq__(self, other):
    return (
        isinstance(other, MockStringCol) and
        self.itemsize == other.itemsize and
        self.shape == other.shape
    )

def __repr__(self):
    return f"MockStringCol(itemsize={self.itemsize}, shape={self.shape})"

from pandas.io.pytables import DataCol

--- Unit tests ---

1. Basic Test Cases

def test_basic_scalar_shape():
# shape is (1,), itemsize is 10
codeflash_output = DataCol.get_atom_string((1,), 10); result = codeflash_output # 19.9μs -> 17.1μs (16.3% faster)

def test_basic_vector_shape():
# shape is (5,), itemsize is 20
codeflash_output = DataCol.get_atom_string((5,), 20); result = codeflash_output # 17.2μs -> 15.1μs (14.2% faster)

def test_basic_list_shape():
# shape is [3], itemsize is 8
codeflash_output = DataCol.get_atom_string([3], 8); result = codeflash_output # 16.1μs -> 14.2μs (13.7% faster)

def test_basic_large_itemsize():
# shape is (2,), itemsize is 100
codeflash_output = DataCol.get_atom_string((2,), 100); result = codeflash_output # 15.8μs -> 13.3μs (18.4% faster)

2. Edge Test Cases

def test_zero_itemsize_raises():
# itemsize is 0, should raise ValueError
with pytest.raises(ValueError):
DataCol.get_atom_string((1,), 0) # 13.5μs -> 11.7μs (15.2% faster)

def test_negative_itemsize_raises():
# itemsize is negative, should raise ValueError
with pytest.raises(ValueError):
DataCol.get_atom_string((1,), -5) # 5.31μs -> 5.06μs (4.96% faster)

def test_zero_shape_raises():
# shape[0] is 0, should raise ValueError
with pytest.raises(ValueError):
DataCol.get_atom_string((0,), 10) # 6.78μs -> 6.34μs (6.96% faster)

def test_negative_shape_raises():
# shape[0] is negative, should raise ValueError
with pytest.raises(ValueError):
DataCol.get_atom_string((-3,), 10) # 6.94μs -> 6.07μs (14.3% faster)

def test_shape_not_tuple_or_list_raises():
# shape is not tuple/list, should raise TypeError
with pytest.raises(TypeError):
DataCol.get_atom_string(5, 10) # 2.03μs -> 1.56μs (30.1% faster)

def test_shape_with_extra_dimensions():
# shape is (10, 2), should use shape[0] only
codeflash_output = DataCol.get_atom_string((10, 2), 5); result = codeflash_output # 24.0μs -> 21.5μs (11.6% faster)

def test_shape_with_float_dimension_raises():
# shape[0] is float, should raise TypeError
with pytest.raises(TypeError):
DataCol.get_atom_string((3.5,), 10) # 9.57μs -> 9.39μs (1.94% faster)

def test_large_shape_and_itemsize():
# shape is (999,), itemsize is 512
codeflash_output = DataCol.get_atom_string((999,), 512); result = codeflash_output # 23.6μs -> 21.0μs (12.6% faster)

def test_maximum_allowed_shape():
# shape is at upper bound (1000,), itemsize is 1
codeflash_output = DataCol.get_atom_string((1000,), 1); result = codeflash_output # 17.1μs -> 15.1μs (13.6% faster)

def test_maximum_allowed_itemsize():
# itemsize is at upper bound (1000), shape is (1,)
codeflash_output = DataCol.get_atom_string((1,), 1000); result = codeflash_output # 16.3μs -> 14.6μs (12.2% faster)

def test_multiple_large_calls():
# Call multiple times with varying large values
for i in range(900, 1000, 10):
codeflash_output = DataCol.get_atom_string((i,), i); res = codeflash_output # 55.3μs -> 48.8μs (13.5% faster)

def test_large_shape_list():
# shape provided as large list
shape = [999]
codeflash_output = DataCol.get_atom_string(shape, 256); result = codeflash_output # 14.8μs -> 13.3μs (11.4% faster)

codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

#------------------------------------------------
import pytest
from pandas.io.pytables import DataCol

Minimal mock for _tables().StringCol since we cannot import pytables or pandas

class MockStringCol:
def init(self, itemsize, shape):
self.itemsize = itemsize
self.shape = shape

def __eq__(self, other):
    return (
        isinstance(other, MockStringCol)
        and self.itemsize == other.itemsize
        and self.shape == other.shape
    )

def __repr__(self):
    return f"MockStringCol(itemsize={self.itemsize}, shape={self.shape})"

from pandas.io.pytables import DataCol

------------------- UNIT TESTS -------------------

Basic Test Cases

def test_basic_single_element_shape():
# Test with shape of length 1 and positive itemsize
codeflash_output = DataCol.get_atom_string((10,), 8); atom = codeflash_output # 14.9μs -> 13.6μs (9.75% faster)

def test_basic_list_shape():
# Test with shape as a list
codeflash_output = DataCol.get_atom_string([5], 4); atom = codeflash_output # 16.0μs -> 13.2μs (21.7% faster)

def test_basic_different_itemsize():
# Test with different itemsize
codeflash_output = DataCol.get_atom_string((3,), 16); atom = codeflash_output # 15.1μs -> 13.6μs (11.5% faster)

def test_basic_large_shape_small_itemsize():
# Test with large shape and small itemsize
codeflash_output = DataCol.get_atom_string((999,), 1); atom = codeflash_output # 15.3μs -> 14.1μs (8.58% faster)

Edge Test Cases

def test_edge_shape_negative():
# shape[0] < 0 should raise ValueError
with pytest.raises(ValueError):
DataCol.get_atom_string((-1,), 5) # 9.03μs -> 7.89μs (14.4% faster)

def test_edge_itemsize_zero():
# itemsize == 0 should raise ValueError
with pytest.raises(ValueError):
DataCol.get_atom_string((10,), 0) # 17.4μs -> 15.6μs (11.6% faster)

def test_edge_itemsize_negative():
# itemsize < 0 should raise ValueError
with pytest.raises(ValueError):
DataCol.get_atom_string((10,), -4) # 5.23μs -> 5.07μs (3.28% faster)

def test_edge_shape_not_tuple_or_list():
# shape is not a tuple or list
with pytest.raises(TypeError):
DataCol.get_atom_string(10, 5) # 1.73μs -> 1.38μs (25.2% faster)

def test_edge_shape0_not_int():
# shape[0] is not int
with pytest.raises(TypeError):
DataCol.get_atom_string((3.5,), 5) # 11.3μs -> 10.8μs (4.64% faster)

def test_edge_shape_tuple_with_extra_elements():
# shape with extra elements (only shape[0] is used)
codeflash_output = DataCol.get_atom_string((7, 2, 3), 9); atom = codeflash_output # 23.6μs -> 21.2μs (11.6% faster)

Large Scale Test Cases

def test_large_scale_max_shape():
# Test with the largest allowed shape (999)
codeflash_output = DataCol.get_atom_string((999,), 32); atom = codeflash_output # 17.4μs -> 15.4μs (13.6% faster)

def test_large_scale_max_itemsize():
# Test with large itemsize
codeflash_output = DataCol.get_atom_string((100,), 999); atom = codeflash_output # 16.4μs -> 14.6μs (13.0% faster)

def test_large_scale_many_calls():
# Test multiple calls with varying inputs
for i in range(1, 1001, 100):
codeflash_output = DataCol.get_atom_string((i,), i); atom = codeflash_output # 55.3μs -> 48.0μs (15.2% faster)

def test_large_scale_shape_and_itemsize():
# Test with shape and itemsize both at max allowed
codeflash_output = DataCol.get_atom_string((999,), 999); atom = codeflash_output # 14.3μs -> 12.9μs (10.8% faster)

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-DataCol.get_atom_string-mhvzlayz and push.