feat(ci) Run codeflash in on PRs modifying the Python CDK

[girarda]

What

Adds a github action running Codeflash on PRs modifying the Python CDK.

Codeflash will inspect the new code and provide suggestions to improve the performance.

The github action is not required to complete before merging. There is no requirement for updating the code as per Codeflash's suggestions.

For reference:

• Here is an example inlined suggestion
• Here is an example comment describing the improvement, the rationale, and how codeflash tested the change to avoid introducing regressions.

The goal is to try the tool and see if it can provide value by suggesting performance improvement as we go.

This PR is built on top of this PR adding codeflash to the CDK.

I can integrate with airbyte-ci as a follow up step but I want to get this in ASAP so we can try the tool.

Code review guide

The main thing I want to make sure is the GHA has the right security filters.

User Impact

There should be no user impact.

Can this PR be safely reverted and rolled back?

• YES 💚

[vercel]

The latest updates on your projects. Learn more about Vercel for Git ↗︎

1 Skipped Deployment

Name	Status	Preview	Comments	Updated (UTC)
airbyte-docs	⬜️ Ignored (Inspect)	Visit Preview		Aug 22, 2024 9:59pm

[alafanechere]

I would ideally recommend adding poetry run code flash as a poe task and add this poe task here

Suggested change

	poe_tasks = ["check-ci"]
	poe_tasks = ["check-ci", "codeflash"]
	required_env_variables = ["CODEFLASH_API_KEY", "CODEFLASH_PR_NUMBER"]

This would prevent the introduction of a new GHA workflow and make codeflash run on the listed python_versions.

You'd need to set the env vars in the GHA workflow here

[girarda]

@alafanechere am I missing something obvious here? After moving from a custom GHA to airbyte-ci, the workflow is failing because it can't access the CODEFLASH_API_KEY.

[alafanechere]

I think you're missing one last change: the thing that would make airbyte-ci set this env var on the docker container running the poe task.
It has to be defined in [tool.airbyte-ci] in the pyproject.toml file. I'll add a suggestion comment below.

[alafanechere]

I think you're missing one last change: the thing that would make airbyte-ci set this env var on the docker container running the poe task.
It has to be defined in [tool.airbyte-ci] in the pyproject.toml file. I'll add a suggestion comment below.

[codeflash-ai]

Suggested change

	for i in range(len(arr)):
	# This is a diff
	for j in range(len(arr) - 1):
	if arr[j] > arr[j + 1]:
	temp = arr[j]
	arr[j] = arr[j + 1]
	arr[j + 1] = temp
	arr.sort()

[codeflash-ai]

⚡️ Codeflash found optimizations for this PR

📄 sorter() in airbyte-cdk/python/airbyte_cdk/bubble_sort.py

📈 Performance improved by 2,466,795% (24,667.95x faster)

⏱️ Runtime went down from 29.7 seconds to 1.21 millisecond

Explanation and details

Certainly! The current implementation of the sorter function is a simple Bubble Sort algorithm, which has a time complexity of O(n^2). This can be very slow for large arrays. We can make this more efficient by using Python's built-in sorting method, which is implemented as Timsort and has a time complexity of O(n log n).

Here's the optimized code.

This uses Python's built-in sorted() function, which is highly optimized for performance. If you need to sort the list in place, you can use the sort() method of the list.

Both versions will provide a significant performance improvement over the original Bubble Sort implementation.

Correctness verification

The new optimized code was tested for correctness. The results are listed below.

✅ 3 Passed − ⚙️ Existing Unit Tests

(click to show existing tests)

- test_bubble_sort.py

✅ 21 Passed − 🌀 Generated Regression Tests

(click to show generated tests)

# imports
import pytest  # used for our unit tests
from airbyte_cdk.bubble_sort import sorter

# unit tests

# Basic Functionality Tests
def test_simple_unsorted_list():
    codeflash_output = sorter([3, 1, 2])
    # Outputs were verified to be equal to the original implementation

def test_already_sorted_list():
    codeflash_output = sorter([1, 2, 3])
    # Outputs were verified to be equal to the original implementation

def test_reverse_sorted_list():
    codeflash_output = sorter([3, 2, 1])
    # Outputs were verified to be equal to the original implementation

# Edge Cases Tests
def test_empty_list():
    codeflash_output = sorter([])
    # Outputs were verified to be equal to the original implementation

def test_single_element_list():
    codeflash_output = sorter([1])
    # Outputs were verified to be equal to the original implementation

def test_two_elements_already_sorted():
    codeflash_output = sorter([1, 2])
    # Outputs were verified to be equal to the original implementation

def test_two_elements_reverse_sorted():
    codeflash_output = sorter([2, 1])
    # Outputs were verified to be equal to the original implementation

# Lists with Duplicates Tests
def test_all_identical_elements():
    codeflash_output = sorter([2, 2, 2])
    # Outputs were verified to be equal to the original implementation

def test_some_duplicates():
    codeflash_output = sorter([3, 1, 2, 2, 1])
    # Outputs were verified to be equal to the original implementation

# Lists with Negative Numbers Tests
def test_mixed_positive_and_negative_numbers():
    codeflash_output = sorter([3, -1, 2, -2, 1])
    # Outputs were verified to be equal to the original implementation

def test_all_negative_numbers():
    codeflash_output = sorter([-3, -1, -2])
    # Outputs were verified to be equal to the original implementation

# Lists with Floating Point Numbers Tests
def test_mixed_integers_and_floats():
    codeflash_output = sorter([3, 1.5, 2, 2.5, 1])
    # Outputs were verified to be equal to the original implementation

def test_all_floating_point_numbers():
    codeflash_output = sorter([3.1, 1.2, 2.3])
    # Outputs were verified to be equal to the original implementation

# Large Scale Test Cases
def test_large_list_random_integers():
    import random
    random_list = random.sample(range(10000), 1000)
    codeflash_output = sorter(random_list)
    # Outputs were verified to be equal to the original implementation

def test_large_list_sorted_integers():
    sorted_list = list(range(1000))
    codeflash_output = sorter(sorted_list)
    # Outputs were verified to be equal to the original implementation

def test_large_list_reverse_sorted_integers():
    reverse_sorted_list = list(range(999, -1, -1))
    codeflash_output = sorter(reverse_sorted_list)
    # Outputs were verified to be equal to the original implementation

# Performance and Scalability Tests
def test_very_large_list_random_integers():
    import random
    random_list = random.sample(range(100000), 10000)
    codeflash_output = sorter(random_list)
    # Outputs were verified to be equal to the original implementation

def test_very_large_list_sorted_integers():
    sorted_list = list(range(10000))
    codeflash_output = sorter(sorted_list)
    # Outputs were verified to be equal to the original implementation

def test_very_large_list_reverse_sorted_integers():
    reverse_sorted_list = list(range(9999, -1, -1))
    codeflash_output = sorter(reverse_sorted_list)
    # Outputs were verified to be equal to the original implementation

# Lists with Special Values Tests
def test_list_with_none_values():
    with pytest.raises(TypeError):
        sorter([3, 1, None, 2])
    # Outputs were verified to be equal to the original implementation

def test_list_with_mixed_types():
    with pytest.raises(TypeError):
        sorter([3, 'a', 2])
    # Outputs were verified to be equal to the original implementation

# Run the tests
if __name__ == "__main__":
    pytest.main()

🔘 (none found) − ⏪ Replay Tests

wil refactor into using airbyte-ci separately

[girarda]

/approve-and-merge reason="adding a new non-required github action"

[octavia-approvington]

Our work here is done