⚡️ Speed up function _get_centered_logo_positions by 16%

[codeflash-ai]

📄 16% (0.16x) speedup for _get_centered_logo_positions in pdd/logo_animation.py

⏱️ Runtime : 266 microseconds → 229 microseconds (best of 575 runs)

📝 Explanation and details

The optimization achieves a 15% speedup by making two key changes:

1. Eliminated expensive max() call: The original code used max(len(line) for line in logo_art_lines) which creates a generator and iterates through all lines to find the maximum width. The optimized version computes both logo_width and logo_height in a single loop, avoiding the overhead of the max() function and generator expression.

2. Replaced list append loop with list comprehension: The original code used a manual loop with append() operations to build the target positions list. The optimized version uses a list comprehension [(p.orig_logo_x + offset_x, p.orig_logo_y + offset_y) for p in particles], which is faster for simple mapping operations in Python.

The profiler data shows the original max() call took 5.9% of execution time (132,492ns), while the new loop approach distributes this work more efficiently. The list comprehension also reduces the overhead from multiple append() calls (59.1% of original runtime) to a single list creation operation (79.6% of optimized runtime, but with lower absolute time).

These optimizations are particularly effective for large-scale scenarios - tests with 1000 particles show 16-26% improvements, while smaller cases see 3-11% gains. The optimization works best when there are many particles or logo lines with varying lengths, as it eliminates the quadratic behavior of repeatedly checking line lengths.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from typing import List, Tuple

# imports
import pytest
from pdd.logo_animation import _get_centered_logo_positions


# Define a minimal AnimatedParticle class for testing
class AnimatedParticle:
    def __init__(self, orig_logo_x: int, orig_logo_y: int):
        self.orig_logo_x = orig_logo_x
        self.orig_logo_y = orig_logo_y
from pdd.logo_animation import _get_centered_logo_positions

# unit tests

# Basic Test Cases

def test_single_particle_single_char_logo():
    # One particle, logo is a single character, console is 5x5
    particles = [AnimatedParticle(0, 0)]
    logo_art_lines = ["X"]
    console_width = 5
    console_height = 5
    # Logo width/height = 1, offset_x/y = 2
    expected = [(2, 2)]
    codeflash_output = _get_centered_logo_positions(particles, logo_art_lines, console_width, console_height) # 2.03μs -> 1.96μs (3.57% faster)

def test_multiple_particles_simple_logo():
    # 2 particles, logo is "AB", console is 6x4
    particles = [AnimatedParticle(0, 0), AnimatedParticle(1, 0)]
    logo_art_lines = ["AB"]
    console_width = 6
    console_height = 4
    # Logo width=2, height=1, offset_x=2, offset_y=1
    expected = [(2, 1), (3, 1)]
    codeflash_output = _get_centered_logo_positions(particles, logo_art_lines, console_width, console_height) # 2.09μs -> 1.97μs (6.30% faster)

def test_logo_multiline_centering():
    # 3 particles, logo is 2x2, console is 6x6
    particles = [AnimatedParticle(0, 0), AnimatedParticle(1, 0), AnimatedParticle(0, 1)]
    logo_art_lines = ["AB", "CD"]
    console_width = 6
    console_height = 6
    # Logo width=2, height=2, offset_x=2, offset_y=2
    expected = [(2, 2), (3, 2), (2, 3)]
    codeflash_output = _get_centered_logo_positions(particles, logo_art_lines, console_width, console_height) # 2.32μs -> 2.24μs (3.66% faster)

def test_empty_particles_returns_empty_list():
    # No particles, logo present
    particles = []
    logo_art_lines = ["AB", "CD"]
    console_width = 10
    console_height = 10
    expected = []
    codeflash_output = _get_centered_logo_positions(particles, logo_art_lines, console_width, console_height) # 1.57μs -> 1.64μs (4.14% slower)

# Edge Test Cases

def test_empty_logo_lines_returns_zero_positions():
    # Non-empty particles, logo_art_lines is empty
    particles = [AnimatedParticle(3, 4), AnimatedParticle(1, 2)]
    logo_art_lines = []
    console_width = 10
    console_height = 10
    expected = [(0, 0), (0, 0)]
    codeflash_output = _get_centered_logo_positions(particles, logo_art_lines, console_width, console_height) # 932ns -> 953ns (2.20% slower)

def test_logo_larger_than_console():
    # Logo is larger than console
    particles = [AnimatedParticle(0, 0), AnimatedParticle(1, 0)]
    logo_art_lines = ["ABCDE", "FGHIJ"]
    console_width = 3
    console_height = 1
    # logo_width=5, logo_height=2, offset_x=-1, offset_y=-0.5=>-1
    expected = [(-1, -1), (0, -1)]
    codeflash_output = _get_centered_logo_positions(particles, logo_art_lines, console_width, console_height) # 2.29μs -> 2.06μs (11.2% faster)

def test_logo_exactly_fits_console():
    # Logo fits exactly in the console
    particles = [AnimatedParticle(0, 0), AnimatedParticle(1, 0)]
    logo_art_lines = ["AB", "CD"]
    console_width = 2
    console_height = 2
    # offset_x=0, offset_y=0
    expected = [(0, 0), (1, 0)]
    codeflash_output = _get_centered_logo_positions(particles, logo_art_lines, console_width, console_height) # 2.26μs -> 2.17μs (4.53% faster)

def test_logo_width_zero():
    # Logo line is empty string, width=0
    particles = [AnimatedParticle(0, 0)]
    logo_art_lines = [""]
    console_width = 5
    console_height = 5
    # logo_width=0, logo_height=1, offset_x=2, offset_y=2
    expected = [(2, 2)]
    codeflash_output = _get_centered_logo_positions(particles, logo_art_lines, console_width, console_height) # 1.77μs -> 1.71μs (3.62% faster)

def test_logo_height_zero():
    # Logo lines is [], handled in empty logo test above
    # For completeness, test with empty logo and no particles
    particles = []
    logo_art_lines = []
    console_width = 10
    console_height = 10
    expected = []
    codeflash_output = _get_centered_logo_positions(particles, logo_art_lines, console_width, console_height) # 825ns -> 802ns (2.87% faster)

def test_particle_negative_orig_logo_coords():
    # Particle with negative orig_logo_x/y
    particles = [AnimatedParticle(-2, -3)]
    logo_art_lines = ["X"]
    console_width = 5
    console_height = 5
    # offset_x=2, offset_y=2
    expected = [(-2+2, -3+2)]
    codeflash_output = _get_centered_logo_positions(particles, logo_art_lines, console_width, console_height) # 1.92μs -> 1.76μs (8.78% faster)

def test_logo_art_lines_with_varying_lengths():
    # Logo lines of different lengths
    particles = [AnimatedParticle(0, 0), AnimatedParticle(1, 1)]
    logo_art_lines = ["A", "BCDE", "FG"]
    console_width = 10
    console_height = 10
    # logo_width=4, logo_height=3, offset_x=3, offset_y=3
    expected = [(3, 3), (4, 4)]
    codeflash_output = _get_centered_logo_positions(particles, logo_art_lines, console_width, console_height) # 2.31μs -> 2.09μs (10.6% faster)

# Large Scale Test Cases

def test_large_number_of_particles_and_logo():
    # 1000 particles, logo is 10x10, console is 100x100
    num_particles = 1000
    logo_art_lines = ["X"*10 for _ in range(10)]
    console_width = 100
    console_height = 100
    # offset_x = (100-10)//2 = 45, offset_y = (100-10)//2 = 45
    particles = []
    expected = []
    for i in range(num_particles):
        x = i % 10
        y = i // 10 % 10
        particles.append(AnimatedParticle(x, y))
        expected.append((x+45, y+45))
    codeflash_output = _get_centered_logo_positions(particles, logo_art_lines, console_width, console_height); result = codeflash_output # 63.1μs -> 54.4μs (16.1% faster)

def test_large_logo_art_lines_varying_length():
    # 50 particles, logo lines of varying lengths up to 50
    logo_art_lines = [("X"*i) for i in range(1, 51)]
    console_width = 100
    console_height = 100
    logo_width = 50
    logo_height = 50
    offset_x = (100-50)//2 # 25
    offset_y = (100-50)//2 # 25
    particles = []
    expected = []
    for i in range(50):
        particles.append(AnimatedParticle(i, i))
        expected.append((i+offset_x, i+offset_y))
    codeflash_output = _get_centered_logo_positions(particles, logo_art_lines, console_width, console_height); result = codeflash_output # 6.80μs -> 6.56μs (3.66% faster)

def test_large_console_and_logo_art_lines_empty():
    # 500 particles, empty logo_art_lines
    particles = [AnimatedParticle(i, i) for i in range(500)]
    logo_art_lines = []
    console_width = 1000
    console_height = 1000
    expected = [(0, 0)] * 500
    codeflash_output = _get_centered_logo_positions(particles, logo_art_lines, console_width, console_height) # 877ns -> 1.02μs (14.4% slower)

def test_large_console_and_logo_art_lines_one_empty_string():
    # 500 particles, logo_art_lines = [""]
    particles = [AnimatedParticle(i, i) for i in range(500)]
    logo_art_lines = [""]
    console_width = 1000
    console_height = 1000
    # logo_width=0, logo_height=1, offset_x=500, offset_y=499
    expected = [(i+500, i+499) for i in range(500)]
    codeflash_output = _get_centered_logo_positions(particles, logo_art_lines, console_width, console_height) # 39.4μs -> 31.2μs (26.2% 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 List, Tuple

# imports
import pytest  # used for our unit tests
from pdd.logo_animation import _get_centered_logo_positions


# function to test
class AnimatedParticle:
    """Minimal stub for AnimatedParticle for testing."""
    def __init__(self, orig_logo_x: int, orig_logo_y: int):
        self.orig_logo_x = orig_logo_x
        self.orig_logo_y = orig_logo_y
from pdd.logo_animation import _get_centered_logo_positions

# unit tests

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

def test_basic_single_particle_centered_logo():
    # Logo is 3x1, console is 7x5, one particle at (0,0)
    logo_art = ["***"]
    particles = [AnimatedParticle(0, 0)]
    # logo_width=3, logo_height=1; offset_x=(7-3)//2=2, offset_y=(5-1)//2=2
    expected = [(2,2)]
    codeflash_output = _get_centered_logo_positions(particles, logo_art, 7, 5); result = codeflash_output # 1.97μs -> 1.85μs (6.36% faster)

def test_basic_multiple_particles_simple_logo():
    # Logo is 2x2, console is 6x6, particles at (0,0), (1,0), (0,1), (1,1)
    logo_art = ["**", "**"]
    particles = [AnimatedParticle(0,0), AnimatedParticle(1,0), AnimatedParticle(0,1), AnimatedParticle(1,1)]
    # logo_width=2, logo_height=2; offset_x=2, offset_y=2
    expected = [(2,2), (3,2), (2,3), (3,3)]
    codeflash_output = _get_centered_logo_positions(particles, logo_art, 6, 6); result = codeflash_output # 2.36μs -> 2.26μs (4.51% faster)

def test_basic_logo_art_lines_empty_particles():
    # Logo is 3x1, console is 7x5, no particles
    logo_art = ["***"]
    particles = []
    expected = []
    codeflash_output = _get_centered_logo_positions(particles, logo_art, 7, 5); result = codeflash_output # 1.54μs -> 1.48μs (3.78% faster)

def test_basic_logo_art_lines_empty_logo():
    # Logo is empty, 2 particles
    logo_art = []
    particles = [AnimatedParticle(5, 7), AnimatedParticle(2, 3)]
    expected = [(0,0), (0,0)]
    codeflash_output = _get_centered_logo_positions(particles, logo_art, 10, 10); result = codeflash_output # 901ns -> 944ns (4.56% slower)

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

def test_edge_logo_wider_than_console():
    # Logo is wider than console
    logo_art = ["******"]
    particles = [AnimatedParticle(0, 0), AnimatedParticle(2, 0)]
    # logo_width=6, console_width=4, offset_x=(4-6)//2=-1
    expected = [(-1,2), (1,2)]  # offset_y=(5-1)//2=2
    codeflash_output = _get_centered_logo_positions(particles, logo_art, 4, 5); result = codeflash_output # 2.06μs -> 1.93μs (6.85% faster)

def test_edge_logo_taller_than_console():
    # Logo is taller than console
    logo_art = ["*", "*", "*", "*", "*", "*"]
    particles = [AnimatedParticle(0,0), AnimatedParticle(0,5)]
    # logo_height=6, console_height=4, offset_y=(4-6)//2=-1
    expected = [(2,-1), (2,4)]  # offset_x=(6-1)//2=2
    codeflash_output = _get_centered_logo_positions(particles, logo_art, 7, 4); result = codeflash_output # 2.28μs -> 2.27μs (0.795% faster)

def test_edge_logo_art_lines_with_empty_strings():
    # Logo with empty strings in lines
    logo_art = ["***", "", "*"]
    particles = [AnimatedParticle(0,0), AnimatedParticle(2,2)]
    # logo_width=3, logo_height=3; offset_x=(7-3)//2=2, offset_y=(7-3)//2=2
    expected = [(2,2), (4,4)]
    codeflash_output = _get_centered_logo_positions(particles, logo_art, 7, 7); result = codeflash_output # 2.20μs -> 2.10μs (4.82% faster)

def test_edge_negative_particle_positions():
    # Particles with negative positions
    logo_art = ["**"]
    particles = [AnimatedParticle(-1,-1), AnimatedParticle(-2,-2)]
    # logo_width=2, logo_height=1; offset_x=4, offset_y=2
    expected = [(3,1), (2,0)]
    codeflash_output = _get_centered_logo_positions(particles, logo_art, 6, 3); result = codeflash_output # 1.95μs -> 1.84μs (5.53% faster)

def test_edge_console_size_zero():
    # Console size zero
    logo_art = ["*"]
    particles = [AnimatedParticle(0,0)]
    # logo_width=1, logo_height=1; offset_x=(0-1)//2=-1, offset_y=(0-1)//2=-1
    expected = [(-1,-1)]
    codeflash_output = _get_centered_logo_positions(particles, logo_art, 0, 0); result = codeflash_output # 1.85μs -> 1.75μs (5.48% faster)

def test_edge_logo_art_lines_all_empty():
    # logo_art_lines contains only empty strings
    logo_art = ["", "", ""]
    particles = [AnimatedParticle(1,1)]
    # logo_width=0, logo_height=3; offset_x=(5-0)//2=2, offset_y=(5-3)//2=1
    expected = [(3,2)]
    codeflash_output = _get_centered_logo_positions(particles, logo_art, 5, 5); result = codeflash_output # 1.96μs -> 1.86μs (5.36% faster)

def test_edge_particle_count_greater_than_logo_positions():
    # More particles than logo positions
    logo_art = ["*"]
    particles = [AnimatedParticle(0,0), AnimatedParticle(1,0), AnimatedParticle(2,0)]
    # logo_width=1, logo_height=1; offset_x=2, offset_y=2
    expected = [(2,2), (3,2), (4,2)]
    codeflash_output = _get_centered_logo_positions(particles, logo_art, 5, 5); result = codeflash_output # 2.08μs -> 1.96μs (6.33% faster)

def test_edge_particle_count_less_than_logo_positions():
    # Fewer particles than logo positions
    logo_art = ["**", "**"]
    particles = [AnimatedParticle(0,0)]
    # logo_width=2, logo_height=2; offset_x=2, offset_y=2
    expected = [(2,2)]
    codeflash_output = _get_centered_logo_positions(particles, logo_art, 6, 6); result = codeflash_output # 1.86μs -> 1.80μs (2.99% faster)

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

def test_large_scale_many_particles_small_logo():
    # 1000 particles, logo is 1x1, console is 100x100
    logo_art = ["*"]
    particles = [AnimatedParticle(i, 0) for i in range(1000)]
    # logo_width=1, logo_height=1; offset_x=49, offset_y=49
    expected = [(i+49,49) for i in range(1000)]
    codeflash_output = _get_centered_logo_positions(particles, logo_art, 100, 100); result = codeflash_output # 72.5μs -> 60.2μs (20.5% faster)

def test_large_scale_large_logo_and_particles():
    # 500 particles, logo is 30x20, console is 100x100
    logo_art = ["*"*30 for _ in range(20)]
    particles = [AnimatedParticle(i%30, i//30) for i in range(500)]
    # logo_width=30, logo_height=20; offset_x=35, offset_y=40
    expected = [(p.orig_logo_x+35, p.orig_logo_y+40) for p in particles]
    codeflash_output = _get_centered_logo_positions(particles, logo_art, 100, 100); result = codeflash_output # 30.9μs -> 25.9μs (19.5% faster)

def test_large_scale_logo_art_lines_max_width():
    # logo_art_lines with max width at last line
    logo_art = ["*", "**", "***", "****", "*****", "******", "*******"]
    particles = [AnimatedParticle(i, 0) for i in range(7)]
    # logo_width=7, logo_height=7; offset_x=(50-7)//2=21, offset_y=(50-7)//2=21
    expected = [(i+21,21) for i in range(7)]
    codeflash_output = _get_centered_logo_positions(particles, logo_art, 50, 50); result = codeflash_output # 2.64μs -> 2.59μs (1.97% faster)

def test_large_scale_logo_art_lines_irregular_widths():
    # logo_art_lines with irregular widths
    logo_art = ["*", "***", "**", "*****", "*", "****"]
    particles = [AnimatedParticle(i, 0) for i in range(6)]
    # logo_width=5, logo_height=6; offset_x=(20-5)//2=7, offset_y=(20-6)//2=7
    expected = [(i+7,7) for i in range(6)]
    codeflash_output = _get_centered_logo_positions(particles, logo_art, 20, 20); result = codeflash_output # 2.57μs -> 2.46μs (4.55% faster)

def test_large_scale_empty_logo_art_lines_and_particles():
    # Empty logo_art_lines and empty particles
    logo_art = []
    particles = []
    expected = []
    codeflash_output = _get_centered_logo_positions(particles, logo_art, 100, 100); result = codeflash_output # 918ns -> 959ns (4.28% slower)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from pdd.logo_animation import AnimatedParticle
from pdd.logo_animation import _get_centered_logo_positions
from rich.style import Style

def test__get_centered_logo_positions():
    _get_centered_logo_positions([AnimatedParticle('', 0, 0, start_x=0.0, start_y=0.0, current_x=0.0, current_y=0.0, target_x=0.0, target_y=0.0, style=Style(color=None, bgcolor=None, bold=True, dim=None, italic=None, underline=False, blink=False, blink2=None, reverse=False, conceal=None, strike=None, underline2=True, frame=True, encircle=None, overline=None, link='\x00', meta=None), visible=False)], ['\x00'], 0, 0)

def test__get_centered_logo_positions_2():
    _get_centered_logo_positions([], [], 0, 0)

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_tswszncf/tmpy8igrv1_/test_concolic_coverage.py::test__get_centered_logo_positions	1.99μs	1.82μs	9.19%✅
codeflash_concolic_tswszncf/tmpy8igrv1_/test_concolic_coverage.py::test__get_centered_logo_positions_2	844ns	859ns	-1.75%⚠️

To edit these changes git checkout codeflash/optimize-_get_centered_logo_positions-mgllsv3j and push.