⚡️ Speed up function get_cached_gh_event_data by 19% in PR #970 (ranking-changes)

[codeflash-ai]

⚡️ This pull request contains optimizations for PR #970

If you approve this dependent PR, these changes will be merged into the original PR branch ranking-changes.

This PR will be automatically closed if the original PR is merged.

---

📄 19% (0.19x) speedup for get_cached_gh_event_data in codeflash/code_utils/env_utils.py

⏱️ Runtime : 1.44 milliseconds → 1.22 milliseconds (best of 250 runs)

📝 Explanation and details

The optimized code achieves an 18% speedup primarily through binary file I/O optimization. Here are the key changes:

What was optimized:

1. Binary file reading: Changed from text mode "utf-8" to binary mode "rb" with manual UTF-8 decoding
2. Combined read operation: Uses json.loads(f.read().decode("utf-8")) instead of json.load(f)

Why this is faster:

• Binary file reading ("rb") avoids Python's text encoding layer overhead during file I/O
• Reading the entire file into memory with f.read() then parsing is more efficient than json.load()'s incremental parsing through TextIO buffering
• For small-to-medium JSON files (typical for GitHub event data), loading all data at once reduces syscall overhead

Performance characteristics:

• The test results show consistent improvements across different scenarios:
  • Empty environment variables: minimal overhead reduction
  • File operations: ~2-3% improvements in error cases
  • The 18% overall speedup is most beneficial for actual JSON file reading operations

Impact on workloads:
Based on the function references, get_cached_gh_event_data() is called by multiple functions (get_pr_number(), is_repo_a_fork(), is_pr_draft()) that extract specific fields from GitHub event data. Since these functions are likely called during CI/CD workflows where GitHub Actions performance matters, the 18% speedup in JSON parsing directly improves the responsiveness of PR analysis and repository metadata extraction.

Best suited for: Small-to-medium JSON files (typical GitHub event payloads), which matches the expected use case of parsing GitHub Actions event data.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from __future__ import annotations

import json
import os
import tempfile

# imports
import pytest

from codeflash.code_utils.env_utils import get_cached_gh_event_data

# ----------------- BASIC TEST CASES -----------------


def test_returns_empty_dict_if_env_not_set(monkeypatch):
    """Should return {} if GITHUB_EVENT_PATH is not set."""
    monkeypatch.delenv("GITHUB_EVENT_PATH", raising=False)
    codeflash_output = get_cached_gh_event_data()
    result = codeflash_output  # 3.36μs -> 3.36μs (0.000% faster)


def test_returns_empty_dict_if_env_set_to_empty_string(monkeypatch):
    """Should return {} if GITHUB_EVENT_PATH is set to empty string."""
    monkeypatch.setenv("GITHUB_EVENT_PATH", "")
    codeflash_output = get_cached_gh_event_data()
    result = codeflash_output  # 1.50μs -> 1.49μs (0.670% faster)


def test_reads_and_returns_json_data(monkeypatch):
    """Should read and return JSON data from file specified in GITHUB_EVENT_PATH."""
    data = {"foo": "bar", "num": 42}
    with tempfile.NamedTemporaryFile("w+", delete=False, encoding="utf-8") as tf:
        json.dump(data, tf)
        tf.flush()
        monkeypatch.setenv("GITHUB_EVENT_PATH", tf.name)
        tf_name = tf.name
    try:
        codeflash_output = get_cached_gh_event_data()
        result = codeflash_output
    finally:
        os.remove(tf_name)


def test_reads_and_returns_empty_json(monkeypatch):
    """Should return empty dict when file contains {}."""
    with tempfile.NamedTemporaryFile("w+", delete=False, encoding="utf-8") as tf:
        tf.write("{}")
        tf.flush()
        monkeypatch.setenv("GITHUB_EVENT_PATH", tf.name)
        tf_name = tf.name
    try:
        codeflash_output = get_cached_gh_event_data()
        result = codeflash_output
    finally:
        os.remove(tf_name)


def test_reads_and_returns_json_with_array(monkeypatch):
    """Should return JSON data with arrays."""
    data = {"arr": [1, 2, 3], "nested": {"a": [4, 5]}}
    with tempfile.NamedTemporaryFile("w+", delete=False, encoding="utf-8") as tf:
        json.dump(data, tf)
        tf.flush()
        monkeypatch.setenv("GITHUB_EVENT_PATH", tf.name)
        tf_name = tf.name
    try:
        codeflash_output = get_cached_gh_event_data()
        result = codeflash_output
    finally:
        os.remove(tf_name)


# ----------------- EDGE TEST CASES -----------------


def test_file_does_not_exist(monkeypatch):
    """Should raise FileNotFoundError if file does not exist."""
    monkeypatch.setenv("GITHUB_EVENT_PATH", "/tmp/nonexistent_file_gh_event.json")
    with pytest.raises(FileNotFoundError):
        get_cached_gh_event_data()  # 13.3μs -> 13.6μs (2.06% slower)


def test_file_is_not_json(monkeypatch):
    """Should raise json.JSONDecodeError if file is not valid JSON."""
    with tempfile.NamedTemporaryFile("w+", delete=False, encoding="utf-8") as tf:
        tf.write("not a json file")
        tf.flush()
        monkeypatch.setenv("GITHUB_EVENT_PATH", tf.name)
        tf_name = tf.name
    try:
        with pytest.raises(json.JSONDecodeError):
            get_cached_gh_event_data()
    finally:
        os.remove(tf_name)


def test_file_is_empty(monkeypatch):
    """Should raise json.JSONDecodeError if file is empty."""
    with tempfile.NamedTemporaryFile("w+", delete=False, encoding="utf-8") as tf:
        # leave file empty
        tf.flush()
        monkeypatch.setenv("GITHUB_EVENT_PATH", tf.name)
        tf_name = tf.name
    try:
        with pytest.raises(json.JSONDecodeError):
            get_cached_gh_event_data()
    finally:
        os.remove(tf_name)


def test_file_contains_json_null(monkeypatch):
    """Should return None if file contains 'null' (JSON null)."""
    with tempfile.NamedTemporaryFile("w+", delete=False, encoding="utf-8") as tf:
        tf.write("null")
        tf.flush()
        monkeypatch.setenv("GITHUB_EVENT_PATH", tf.name)
        tf_name = tf.name
    try:
        codeflash_output = get_cached_gh_event_data()
        result = codeflash_output
    finally:
        os.remove(tf_name)


def test_file_contains_json_array(monkeypatch):
    """Should return list if file contains a JSON array."""
    arr = [1, 2, 3]
    with tempfile.NamedTemporaryFile("w+", delete=False, encoding="utf-8") as tf:
        json.dump(arr, tf)
        tf.flush()
        monkeypatch.setenv("GITHUB_EVENT_PATH", tf.name)
        tf_name = tf.name
    try:
        codeflash_output = get_cached_gh_event_data()
        result = codeflash_output
    finally:
        os.remove(tf_name)


def test_file_permission_denied(monkeypatch):
    """Should raise PermissionError if file cannot be read."""
    with tempfile.NamedTemporaryFile("w+", delete=False, encoding="utf-8") as tf:
        tf.write("{}")
        tf.flush()
        tf_name = tf.name
    # Remove read permissions
    os.chmod(tf_name, 0o000)
    monkeypatch.setenv("GITHUB_EVENT_PATH", tf_name)
    try:
        with pytest.raises(PermissionError):
            get_cached_gh_event_data()
    finally:
        # Restore permissions so we can delete the file
        os.chmod(tf_name, 0o600)
        os.remove(tf_name)


def test_cache_behavior(monkeypatch):
    """Should cache the result and not re-read the file if called again."""
    data1 = {"a": 1}
    data2 = {"b": 2}
    with tempfile.NamedTemporaryFile("w+", delete=False, encoding="utf-8") as tf:
        json.dump(data1, tf)
        tf.flush()
        monkeypatch.setenv("GITHUB_EVENT_PATH", tf.name)
        tf_name = tf.name
    try:
        # First call reads file
        codeflash_output = get_cached_gh_event_data()
        result1 = codeflash_output
        # Overwrite file with different data
        with open(tf_name, "w", encoding="utf-8") as f:
            json.dump(data2, f)
        # Second call should return cached data, not new file contents
        codeflash_output = get_cached_gh_event_data()
        result2 = codeflash_output
    finally:
        os.remove(tf_name)


def test_cache_cleared_between_env_paths(monkeypatch):
    """Should not cache across different env paths."""
    data1 = {"x": 1}
    data2 = {"y": 2}
    with (
        tempfile.NamedTemporaryFile("w+", delete=False, encoding="utf-8") as tf1,
        tempfile.NamedTemporaryFile("w+", delete=False, encoding="utf-8") as tf2,
    ):
        json.dump(data1, tf1)
        tf1.flush()
        json.dump(data2, tf2)
        tf2.flush()
        tf1_name = tf1.name
        tf2_name = tf2.name
    try:
        # First path
        monkeypatch.setenv("GITHUB_EVENT_PATH", tf1_name)
        get_cached_gh_event_data.cache_clear()
        codeflash_output = get_cached_gh_event_data()
        result1 = codeflash_output
        # Second path
        monkeypatch.setenv("GITHUB_EVENT_PATH", tf2_name)
        get_cached_gh_event_data.cache_clear()
        codeflash_output = get_cached_gh_event_data()
        result2 = codeflash_output
    finally:
        os.remove(tf1_name)
        os.remove(tf2_name)


# ----------------- LARGE SCALE TEST CASES -----------------


def test_large_json_file(monkeypatch):
    """Should handle a large JSON file with many keys."""
    large_data = {f"key_{i}": i for i in range(1000)}
    with tempfile.NamedTemporaryFile("w+", delete=False, encoding="utf-8") as tf:
        json.dump(large_data, tf)
        tf.flush()
        monkeypatch.setenv("GITHUB_EVENT_PATH", tf.name)
        tf_name = tf.name
    try:
        codeflash_output = get_cached_gh_event_data()
        result = codeflash_output
    finally:
        os.remove(tf_name)


def test_large_nested_json(monkeypatch):
    """Should handle deeply nested JSON structures."""
    nested = {"level0": {"level1": {"level2": {"level3": {"level4": list(range(100))}}}}}
    with tempfile.NamedTemporaryFile("w+", delete=False, encoding="utf-8") as tf:
        json.dump(nested, tf)
        tf.flush()
        monkeypatch.setenv("GITHUB_EVENT_PATH", tf.name)
        tf_name = tf.name
    try:
        codeflash_output = get_cached_gh_event_data()
        result = codeflash_output
    finally:
        os.remove(tf_name)


def test_many_small_json_files(monkeypatch):
    """Should handle repeated calls with many different small JSON files."""
    for i in range(10):
        data = {"index": i}
        with tempfile.NamedTemporaryFile("w+", delete=False, encoding="utf-8") as tf:
            json.dump(data, tf)
            tf.flush()
            monkeypatch.setenv("GITHUB_EVENT_PATH", tf.name)
            tf_name = tf.name
        try:
            get_cached_gh_event_data.cache_clear()
            codeflash_output = get_cached_gh_event_data()
            result = codeflash_output
        finally:
            os.remove(tf_name)


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

import json
import os
import tempfile

# function to test
# imports
import pytest

from codeflash.code_utils.env_utils import get_cached_gh_event_data

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


# Helper function to clear the lru_cache between tests
def clear_cache():
    get_cached_gh_event_data.cache_clear()


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


def test_no_env_var_returns_empty_dict(monkeypatch):
    """If GITHUB_EVENT_PATH is not set, should return empty dict."""
    clear_cache()
    monkeypatch.delenv("GITHUB_EVENT_PATH", raising=False)
    codeflash_output = get_cached_gh_event_data()
    result = codeflash_output  # 3.33μs -> 3.42μs (2.63% slower)


def test_env_var_points_to_valid_json(monkeypatch):
    """If GITHUB_EVENT_PATH points to a valid JSON file, should return parsed dict."""
    clear_cache()
    data = {"foo": "bar", "num": 123}
    with tempfile.NamedTemporaryFile(mode="w+", delete=False, encoding="utf-8") as tf:
        json.dump(data, tf)
        tf.flush()
        monkeypatch.setenv("GITHUB_EVENT_PATH", tf.name)
        tf_name = tf.name
    try:
        codeflash_output = get_cached_gh_event_data()
        result = codeflash_output
    finally:
        os.remove(tf_name)


def test_env_var_points_to_empty_json(monkeypatch):
    """If GITHUB_EVENT_PATH points to an empty JSON object, should return {}."""
    clear_cache()
    with tempfile.NamedTemporaryFile(mode="w+", delete=False, encoding="utf-8") as tf:
        tf.write("{}")
        tf.flush()
        monkeypatch.setenv("GITHUB_EVENT_PATH", tf.name)
        tf_name = tf.name
    try:
        codeflash_output = get_cached_gh_event_data()
        result = codeflash_output
    finally:
        os.remove(tf_name)


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


def test_env_var_points_to_nonexistent_file(monkeypatch):
    """If GITHUB_EVENT_PATH points to a non-existent file, should raise FileNotFoundError."""
    clear_cache()
    fake_path = "/tmp/this_file_should_not_exist_gh_event.json"
    monkeypatch.setenv("GITHUB_EVENT_PATH", fake_path)
    with pytest.raises(FileNotFoundError):
        get_cached_gh_event_data()  # 13.2μs -> 13.4μs (1.42% slower)


def test_env_var_points_to_invalid_json(monkeypatch):
    """If GITHUB_EVENT_PATH points to a file with invalid JSON, should raise JSONDecodeError."""
    clear_cache()
    with tempfile.NamedTemporaryFile(mode="w+", delete=False, encoding="utf-8") as tf:
        tf.write("{not: valid json,}")  # invalid JSON
        tf.flush()
        monkeypatch.setenv("GITHUB_EVENT_PATH", tf.name)
        tf_name = tf.name
    try:
        with pytest.raises(json.JSONDecodeError):
            get_cached_gh_event_data()
    finally:
        os.remove(tf_name)


def test_env_var_points_to_non_json_file(monkeypatch):
    """If GITHUB_EVENT_PATH points to a file with non-JSON content, should raise JSONDecodeError."""
    clear_cache()
    with tempfile.NamedTemporaryFile(mode="w+", delete=False, encoding="utf-8") as tf:
        tf.write("Just some text that is not JSON")
        tf.flush()
        monkeypatch.setenv("GITHUB_EVENT_PATH", tf.name)
        tf_name = tf.name
    try:
        with pytest.raises(json.JSONDecodeError):
            get_cached_gh_event_data()
    finally:
        os.remove(tf_name)


def test_env_var_points_to_json_array(monkeypatch):
    """If GITHUB_EVENT_PATH points to a JSON array, should return the array (not a dict)."""
    clear_cache()
    arr = [1, 2, 3]
    with tempfile.NamedTemporaryFile(mode="w+", delete=False, encoding="utf-8") as tf:
        json.dump(arr, tf)
        tf.flush()
        monkeypatch.setenv("GITHUB_EVENT_PATH", tf.name)
        tf_name = tf.name
    try:
        codeflash_output = get_cached_gh_event_data()
        result = codeflash_output
    finally:
        os.remove(tf_name)


def test_env_var_points_to_json_null(monkeypatch):
    """If GITHUB_EVENT_PATH points to a JSON null, should return None."""
    clear_cache()
    with tempfile.NamedTemporaryFile(mode="w+", delete=False, encoding="utf-8") as tf:
        tf.write("null")
        tf.flush()
        monkeypatch.setenv("GITHUB_EVENT_PATH", tf.name)
        tf_name = tf.name
    try:
        codeflash_output = get_cached_gh_event_data()
        result = codeflash_output
    finally:
        os.remove(tf_name)


def test_env_var_points_to_json_true_false(monkeypatch):
    """If GITHUB_EVENT_PATH points to a JSON true/false, should return True/False."""
    clear_cache()
    for val in ("true", "false"):
        with tempfile.NamedTemporaryFile(mode="w+", delete=False, encoding="utf-8") as tf:
            tf.write(val)
            tf.flush()
            monkeypatch.setenv("GITHUB_EVENT_PATH", tf.name)
            tf_name = tf.name
        try:
            codeflash_output = get_cached_gh_event_data()
            result = codeflash_output
            expected = True if val == "true" else False
        finally:
            os.remove(tf_name)
        clear_cache()


def test_cache_behavior(monkeypatch):
    """The function should cache its result. Changing the file after the first call should not change the returned value."""
    clear_cache()
    data1 = {"a": 1}
    data2 = {"b": 2}
    with tempfile.NamedTemporaryFile(mode="w+", delete=False, encoding="utf-8") as tf:
        json.dump(data1, tf)
        tf.flush()
        monkeypatch.setenv("GITHUB_EVENT_PATH", tf.name)
        tf_name = tf.name
    try:
        # First call - should read data1
        codeflash_output = get_cached_gh_event_data()
        result1 = codeflash_output
        # Overwrite file with data2
        with open(tf_name, "w", encoding="utf-8") as f:
            json.dump(data2, f)
        # Second call - should still return data1 due to cache
        codeflash_output = get_cached_gh_event_data()
        result2 = codeflash_output
    finally:
        os.remove(tf_name)
        clear_cache()


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


def test_large_json_object(monkeypatch):
    """Should handle large JSON files (dict with 1000 keys)."""
    clear_cache()
    large_dict = {f"key_{i}": i for i in range(1000)}
    with tempfile.NamedTemporaryFile(mode="w+", delete=False, encoding="utf-8") as tf:
        json.dump(large_dict, tf)
        tf.flush()
        monkeypatch.setenv("GITHUB_EVENT_PATH", tf.name)
        tf_name = tf.name
    try:
        codeflash_output = get_cached_gh_event_data()
        result = codeflash_output
    finally:
        os.remove(tf_name)


def test_large_json_array(monkeypatch):
    """Should handle large JSON files (array of 1000 elements)."""
    clear_cache()
    large_arr = list(range(1000))
    with tempfile.NamedTemporaryFile(mode="w+", delete=False, encoding="utf-8") as tf:
        json.dump(large_arr, tf)
        tf.flush()
        monkeypatch.setenv("GITHUB_EVENT_PATH", tf.name)
        tf_name = tf.name
    try:
        codeflash_output = get_cached_gh_event_data()
        result = codeflash_output
    finally:
        os.remove(tf_name)


def test_multiple_calls_same_env(monkeypatch):
    """Multiple calls with the same env var should return the same object (cache hit)."""
    clear_cache()
    data = {"foo": "bar"}
    with tempfile.NamedTemporaryFile(mode="w+", delete=False, encoding="utf-8") as tf:
        json.dump(data, tf)
        tf.flush()
        monkeypatch.setenv("GITHUB_EVENT_PATH", tf.name)
        tf_name = tf.name
    try:
        codeflash_output = get_cached_gh_event_data()
        result1 = codeflash_output
        codeflash_output = get_cached_gh_event_data()
        result2 = codeflash_output
    finally:
        os.remove(tf_name)
        clear_cache()


def test_multiple_calls_different_env(monkeypatch):
    """Changing the env var does NOT change the cached result due to lru_cache(maxsize=1)."""
    clear_cache()
    data1 = {"foo": 1}
    data2 = {"bar": 2}
    with (
        tempfile.NamedTemporaryFile(mode="w+", delete=False, encoding="utf-8") as tf1,
        tempfile.NamedTemporaryFile(mode="w+", delete=False, encoding="utf-8") as tf2,
    ):
        json.dump(data1, tf1)
        tf1.flush()
        json.dump(data2, tf2)
        tf2.flush()
        tf1_name = tf1.name
        tf2_name = tf2.name
    try:
        monkeypatch.setenv("GITHUB_EVENT_PATH", tf1_name)
        codeflash_output = get_cached_gh_event_data()
        result1 = codeflash_output
        monkeypatch.setenv("GITHUB_EVENT_PATH", tf2_name)
        codeflash_output = get_cached_gh_event_data()
        result2 = codeflash_output
    finally:
        os.remove(tf1_name)
        os.remove(tf2_name)
        clear_cache()


# 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-pr970-2025-12-17T22.51.27 and push.