⚡️ Speed up function get_sample_data by 18%

[codeflash-ai]

📄 18% (0.18x) speedup for get_sample_data in lib/matplotlib/cbook.py

⏱️ Runtime : 193 microseconds → 163 microseconds (best of 5 runs)

📝 Explanation and details

The optimization achieves a 17% speedup through two key improvements:

1. Function Attribute Caching in _get_data_path
The most significant optimization caches the result of matplotlib.get_data_path() as a function attribute (_get_data_path._base_path). The line profiler shows this reduces time from 1.89ms to 1.39ms (27% improvement) by eliminating repeated expensive path lookups. Since _get_data_path is called 50 times in the test, this caching provides substantial savings when accessing multiple sample data files.

2. Early Return and Tuple Optimization in get_sample_data
Moving the asfileobj=False check to the top enables faster early returns for path-only requests. Additionally, replacing list literals ['.npy', '.npz'] with tuples ('.npy', '.npz') for suffix checks provides minor performance gains since tuple membership tests are slightly faster than lists in Python.

Impact on Workloads
Based on the function references, get_sample_data is called in matplotlib test suites and visualization demos where sample datasets are loaded. The caching optimization is particularly beneficial when:

• Loading multiple sample files in sequence (common in test suites)
• Creating multiple plots that reference the same sample data directory
• Running automated tests or scripts that repeatedly access matplotlib's sample data

The annotated tests show consistent 15-27% speedups across different file types, with the optimization being most effective for workflows that make repeated calls to get_sample_data or when asfileobj=False (path-only access) is used.

✅ Correctness verification report:

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

⚙️ Existing Unit Tests and Runtime

🌀 Generated Regression Tests and Runtime

import gzip
from pathlib import Path

import numpy as np

# imports
import pytest
from matplotlib.cbook import get_sample_data

# --- Function Under Test (copied from user prompt, with minimal stubs/mocks for file system) ---


# Minimal stub for matplotlib.get_data_path
class DummyMatplotlib:
    @staticmethod
    def get_data_path():
        # Use a temporary directory for testing
        return str(Path(__file__).parent / "mpl-data")


matplotlib = DummyMatplotlib()

# --- Test Setup Helpers ---


@pytest.fixture(scope="module", autouse=True)
def setup_sample_data_dir(tmp_path_factory):
    """
    Create a temporary 'mpl-data/sample_data' directory with test files.
    """
    base = tmp_path_factory.mktemp("mpl-data")
    sample_data_dir = base / "sample_data"
    sample_data_dir.mkdir(parents=True, exist_ok=True)

    # Create a plain text file
    (sample_data_dir / "test.txt").write_text("hello world\nsecond line")

    # Create a CSV file
    (sample_data_dir / "test.csv").write_text("a,b,c\n1,2,3\n4,5,6")

    # Create a gzipped file
    with gzip.open(sample_data_dir / "test.gz", "wb") as f:
        f.write(b"compressed data\nsecond line")

    # Create a .npy file
    np.save(sample_data_dir / "arr.npy", np.array([1, 2, 3]))

    # Create a .npz file
    np.savez(sample_data_dir / "multi.npz", x=np.arange(5), y=np.arange(5, 10))

    # Create a binary file
    (sample_data_dir / "bin.dat").write_bytes(b"\x00\x01\x02\x03\x04")

    # Create an empty file
    (sample_data_dir / "empty.txt").write_text("")

    # Create a large file (for large scale test)
    large_data = b"0123456789" * 100  # 1000 bytes
    (sample_data_dir / "large.bin").write_bytes(large_data)

    # Patch DummyMatplotlib.get_data_path to return our temp base
    DummyMatplotlib.get_data_path = staticmethod(lambda: str(base))

    yield  # tests run


# --- Unit Tests ---

# 1. Basic Test Cases


def test_txt_file_asfileobj_false(setup_sample_data_dir):
    # Should return file path as string
    codeflash_output = get_sample_data("test.txt", asfileobj=False)
    path = codeflash_output  # 20.0μs -> 15.8μs (26.7% faster)


def test_bin_file_asfileobj_false(setup_sample_data_dir):
    # Should return file path as string
    codeflash_output = get_sample_data("bin.dat", asfileobj=False)
    path = codeflash_output  # 19.7μs -> 15.7μs (25.2% faster)


# 2. Edge Test Cases


def test_nonexistent_file_raises(setup_sample_data_dir):
    # Should raise FileNotFoundError for missing file
    with pytest.raises(FileNotFoundError):
        get_sample_data(
            "does_not_exist.txt", asfileobj=True
        )  # 37.3μs -> 35.8μs (4.08% faster)


def test_gz_file_asfileobj_false(setup_sample_data_dir):
    # Should return file path as string, not file object
    codeflash_output = get_sample_data("test.gz", asfileobj=False)
    path = codeflash_output  # 17.6μs -> 15.0μs (17.4% faster)


def test_large_bin_file_asfileobj_false(setup_sample_data_dir):
    # Should return correct path for large file
    codeflash_output = get_sample_data("large.bin", asfileobj=False)
    path = codeflash_output  # 19.0μs -> 15.1μs (25.9% faster)

import gzip
from pathlib import Path

import numpy as np

# imports
import pytest
from matplotlib.cbook import get_sample_data

# --- Minimal stubs for matplotlib internals to make the function testable ---
# These stubs simulate the data path and sample files for unit testing.
# In production, matplotlib.get_data_path() and sample files would be real.

# Simulate a base data directory for sample_data
BASE_DATA_DIR = Path(__file__).parent / "mpl-data"
SAMPLE_DATA_DIR = BASE_DATA_DIR / "sample_data"


# --- Helper functions to create sample files for testing ---
def create_text_file(filename, content):
    path = SAMPLE_DATA_DIR / filename
    with open(path, "w") as f:
        f.write(content)
    return path


def create_binary_file(filename, content_bytes):
    path = SAMPLE_DATA_DIR / filename
    with open(path, "wb") as f:
        f.write(content_bytes)
    return path


def create_gz_file(filename, content):
    path = SAMPLE_DATA_DIR / filename
    with gzip.open(path, "wt") as f:
        f.write(content)
    return path


def create_npy_file(filename, array):
    path = SAMPLE_DATA_DIR / filename
    np.save(path, array)
    return path


def create_npz_file(filename, arrays_dict):
    path = SAMPLE_DATA_DIR / filename
    np.savez(path, **arrays_dict)
    return path


# --- Basic Test Cases ---


def test_get_sample_data_txt_file_path():
    # Should return file path as string if asfileobj is False
    codeflash_output = get_sample_data("test.txt", asfileobj=False)
    path = codeflash_output  # 18.8μs -> 15.5μs (21.5% faster)


# --- Edge Test Cases ---


def test_get_sample_data_invalid_file_raises():
    # Should raise FileNotFoundError for missing file
    with pytest.raises(FileNotFoundError):
        get_sample_data(
            "does_not_exist.txt", asfileobj=True
        )  # 40.8μs -> 35.1μs (16.2% faster)


def test_get_sample_data_path_returns_str():
    # Should always return a string path when asfileobj=False
    codeflash_output = get_sample_data("test.csv", asfileobj=False)
    path = codeflash_output  # 19.6μs -> 15.3μs (27.6% faster)


# --- Large Scale Test Cases ---

To edit these changes git checkout codeflash/optimize-get_sample_data-miscep90 and push.