⚡️ Speed up method GDAL2Tiles.generate_leaflet by 110%

[codeflash-ai]

📄 110% (1.10x) speedup for GDAL2Tiles.generate_leaflet in opendm/tiles/gdal2tiles.py

⏱️ Runtime : 662 microseconds → 316 microseconds (best of 13 runs)

📝 Explanation and details

The optimized code achieves a 109% speedup through several key improvements:

1. Efficient zoom parsing: Replaced the minmax.extend(['']) + slice pattern with direct conditional logic to parse min/max zoom values. This eliminates unnecessary list operations when splitting the zoom string.

2. Variable caching for repeated access: Added local variables (title, copyright, swne) to cache frequently accessed object attributes, reducing attribute lookup overhead in the dictionary construction phase.

3. F-string conversion: Replaced the expensive % args string formatting with f-string interpolation. F-strings are significantly faster for large template strings as they avoid the overhead of dictionary key lookups during formatting.

4. Reduced string operations: By caching title and copyright in local variables, the .replace() calls are made on cached values rather than repeatedly accessing self.options.title and self.options.copyright.

The test results show consistent 40-130% speedups across different scenarios, with the largest gains in cases with many repeated calls (like test_large_scale_many_generate_leaflet_calls showing 130% improvement). The optimizations are particularly effective for template-heavy operations where string formatting dominates the runtime, making this ideal for HTML generation workflows that call generate_leaflet() frequently.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import pytest
from opendm.tiles.gdal2tiles import GDAL2Tiles


# function to test
class Options:
    """Simple options class to mimic the options attribute in GDAL2Tiles."""
    def __init__(self, title, url, copyright, resampling='near', zoom=None, kml=False):
        self.title = title
        self.url = url
        self.copyright = copyright
        self.resampling = resampling
        self.zoom = zoom
        self.kml = kml
from opendm.tiles.gdal2tiles import GDAL2Tiles

# unit tests

# 1. Basic Test Cases

def test_basic_html_title_and_copyright():
    """Test that the title and copyright appear in the output HTML."""
    options = Options(title='Test Map', url='http://example.com', copyright='Copyright 2024')
    gdal = GDAL2Tiles('input.tif', 'output', options)
    gdal.swne = (10.0, 20.0, 30.0, 40.0)
    gdal.tminz = 2
    gdal.tmaxz = 5
    codeflash_output = gdal.generate_leaflet(); html = codeflash_output # 10.3μs -> 6.86μs (50.0% faster)

def test_basic_zoom_and_tileformat():
    """Test that the zoom and tile format are correctly substituted."""
    options = Options(title='Zoom Test', url='http://url', copyright='C')
    gdal = GDAL2Tiles('input.tif', 'output', options)
    gdal.swne = (1.0, 2.0, 3.0, 4.0)
    gdal.tminz = 1
    gdal.tmaxz = 4
    gdal.tileext = 'jpg'
    codeflash_output = gdal.generate_leaflet(); html = codeflash_output # 8.77μs -> 5.99μs (46.4% faster)

def test_basic_center_calculation():
    """Test that the center is calculated correctly from swne."""
    options = Options(title='Center Test', url='', copyright='')
    gdal = GDAL2Tiles('input.tif', 'output', options)
    gdal.swne = (10.0, 20.0, 30.0, 40.0)
    codeflash_output = gdal.generate_leaflet(); html = codeflash_output # 8.40μs -> 5.66μs (48.5% faster)



def test_edge_negative_coordinates():
    """Test with negative coordinates (south/west/north/east)."""
    options = Options(title='Neg Coord', url='', copyright='')
    gdal = GDAL2Tiles('input.tif', 'output', options)
    gdal.swne = (-45.0, -120.0, -30.0, -100.0)
    codeflash_output = gdal.generate_leaflet(); html = codeflash_output # 11.0μs -> 7.90μs (39.5% faster)




def test_edge_extreme_coordinates():
    """Test with coordinates at the extremes of latitude/longitude."""
    options = Options(title='Extreme Coord', url='', copyright='')
    gdal = GDAL2Tiles('input.tif', 'output', options)
    gdal.swne = (-90.0, -180.0, 90.0, 180.0)
    codeflash_output = gdal.generate_leaflet(); html = codeflash_output # 10.6μs -> 7.46μs (42.0% faster)




def test_large_scale_high_zoom_levels():
    """Test with high zoom levels and large coordinate values."""
    options = Options(title='HighZoom', url='', copyright='')
    gdal = GDAL2Tiles('input.tif', 'output', options)
    gdal.tminz = 0
    gdal.tmaxz = 999
    gdal.swne = (100.0, 200.0, 300.0, 400.0)
    codeflash_output = gdal.generate_leaflet(); html = codeflash_output # 10.1μs -> 6.86μs (47.9% faster)

def test_large_scale_many_generate_leaflet_calls():
    """Test calling generate_leaflet many times to check for memory leaks or performance issues."""
    options = Options(title='ManyCalls', url='', copyright='')
    gdal = GDAL2Tiles('input.tif', 'output', options)
    gdal.swne = (0.0, 0.0, 100.0, 100.0)
    for i in range(100):  # Reasonable number for unit test
        gdal.tminz = i
        gdal.tmaxz = i + 1
        codeflash_output = gdal.generate_leaflet(); html = codeflash_output # 466μs -> 202μs (130% faster)

def test_large_scale_varied_coordinates():
    """Test with a variety of coordinate values in a loop."""
    options = Options(title='VariedCoords', url='', copyright='')
    gdal = GDAL2Tiles('input.tif', 'output', options)
    for i in range(10):  # Keep under 1000 iterations
        gdal.swne = (i * 10.0, i * 20.0, i * 30.0, i * 40.0)
        codeflash_output = gdal.generate_leaflet(); html = codeflash_output # 51.8μs -> 26.3μs (96.5% faster)
        centerlon = (gdal.swne[2] + gdal.swne[0]) / 2.0
        centerlat = (gdal.swne[1] + gdal.swne[3]) / 2.0


#------------------------------------------------
import pytest  # used for our unit tests
from opendm.tiles.gdal2tiles import GDAL2Tiles


# function to test
class Options:
    """A minimal options class to mimic GDAL2Tiles options for testing."""
    def __init__(self, title="Title", url="", copyright="Copyright", resampling="near", zoom=None, kml=False):
        self.title = title
        self.url = url
        self.copyright = copyright
        self.resampling = resampling
        self.zoom = zoom
        self.kml = kml
from opendm.tiles.gdal2tiles import GDAL2Tiles

# unit tests

# 1. Basic Test Cases












def test_edge_swne_with_negative_coords():
    """Test SWNE with negative coordinates (e.g., southern hemisphere)."""
    options = Options()
    gdal2tiles = GDAL2Tiles("input.tif", "output", options)
    gdal2tiles.swne = (-45, -120, -10, -60)
    codeflash_output = gdal2tiles.generate_leaflet(); html = codeflash_output # 11.0μs -> 7.78μs (42.0% faster)

def test_edge_swne_all_equal():
    """Test SWNE where all coordinates are equal (degenerate bounds)."""
    options = Options()
    gdal2tiles = GDAL2Tiles("input.tif", "output", options)
    gdal2tiles.swne = (10, 10, 10, 10)
    codeflash_output = gdal2tiles.generate_leaflet(); html = codeflash_output # 8.60μs -> 5.61μs (53.4% faster)








def test_large_scale_varied_swne():
    """Test with SWNE covering a large area."""
    options = Options()
    gdal2tiles = GDAL2Tiles("input.tif", "output", options)
    # swne = (min_lat, min_lon, max_lat, max_lon)
    gdal2tiles.swne = (-90, -180, 90, 180)
    codeflash_output = gdal2tiles.generate_leaflet(); html = codeflash_output # 10.00μs -> 6.33μs (57.8% faster)


def test_large_scale_multiple_instances():
    """Test creating multiple GDAL2Tiles instances with different settings."""
    for i in range(10):
        title = f"Map {i}"
        copyright = f"Copyright {i}"
        options = Options(title=title, copyright=copyright)
        gdal2tiles = GDAL2Tiles("input.tif", "output", options)
        gdal2tiles.tminz = i
        gdal2tiles.tmaxz = i + 10
        gdal2tiles.swne = (i, i+1, i+2, i+3)
        codeflash_output = gdal2tiles.generate_leaflet(); html = codeflash_output # 54.8μs -> 26.4μs (108% faster)
        # Check center calculation
        centerlon = (i+2 + i)/2
        centerlat = (i+3 + i+1)/2



#------------------------------------------------
from opendm.tiles.gdal2tiles import GDAL2Tiles

To edit these changes git checkout codeflash/optimize-GDAL2Tiles.generate_leaflet-mh5qqord and push.