⚡️ Speed up function link_to_hash by 21%

[codeflash-ai]

📄 21% (0.21x) speedup for link_to_hash in bench_runner/table.py

⏱️ Runtime : 899 microseconds → 742 microseconds (best of 472 runs)

📝 Explanation and details

To optimize the given Python code for better runtime performance and memory usage, we can focus on the following areas.

1. Minimize the repeated computation.
2. Avoid unnecessary type conversions.

Explanation of Optimization.

1. Avoid Unnecessary Type Conversion:

   • Instead of repeatedly converting link to a string using str(link), the code now converts link to a string only once inside the first md_link function.

2. Local Variable Usage:

   • Introduced local variables root_path and link_path to prevent calling the .resolve() method multiple times, improving the function's efficiency.

3. Avoiding Condition Check Redundancy:

   • By storing the resolved root_path once, we reduce the computation if root is provided. In the link branch, using not link.startswith("http") avoids redundant type conversions to string.

These changes maintain the same functionality while being more efficient by reducing redundant computations and unnecessary type conversions.

✅ Correctness verification report:

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

⚙️ Existing Unit Tests Details

- codeflash_concolic_dkuyg5kz/tmpojzn4pu_/test_concolic_coverage.py
- test_table.py

🌀 Generated Regression Tests Details

from pathlib import Path
from urllib.parse import quote

# imports
import pytest  # used for our unit tests
from bench_runner.table import link_to_hash
# function to test
from bench_runner.util import PathLike

# unit tests

def test_basic_functionality():
    # Typical GitHub Commit Link
    codeflash_output = link_to_hash("abc123", "user/repo")

def test_empty_hash():
    # Empty Hash
    codeflash_output = link_to_hash("", "user/repo")

def test_empty_fork():
    # Empty Fork
    codeflash_output = link_to_hash("abc123", "")

def test_empty_hash_and_fork():
    # Empty Hash and Fork
    codeflash_output = link_to_hash("", "")

def test_special_characters_in_hash():
    # Special Characters in Hash
    codeflash_output = link_to_hash("a!b@c#1$2%3^", "user/repo")

def test_special_characters_in_fork():
    # Special Characters in Fork
    codeflash_output = link_to_hash("abc123", "user/repo!")

def test_very_long_hash():
    # Very Long Hash
    long_hash = "a" * 1000
    codeflash_output = link_to_hash(long_hash, "user/repo")

def test_very_long_fork_name():
    # Very Long Fork Name
    long_fork = "user/" + "repo" * 1000
    codeflash_output = link_to_hash("abc123", long_fork)

def test_invalid_url_characters_in_fork():
    # Invalid URL Characters in Fork
    codeflash_output = link_to_hash("abc123", "user/repo with spaces")


def test_large_scale():
    # Large Scale Test Case
    hashes = [f"hash{i}" for i in range(1000)]
    forks = [f"user/repo{i}" for i in range(1000)]
    for hash, fork in zip(hashes, forks):
        codeflash_output = link_to_hash(hash, fork)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

from pathlib import Path
from urllib.parse import quote

# imports
import pytest  # used for our unit tests
from bench_runner.table import link_to_hash
# function to test
from bench_runner.util import PathLike

# unit tests

def test_basic_functionality():
    # Valid GitHub Commit Link
    codeflash_output = link_to_hash("abc123", "user/repo")
    codeflash_output = link_to_hash("def456", "another_user/another_repo")

def test_edge_cases_link_to_hash():
    # Empty Strings
    codeflash_output = link_to_hash("", "user/repo")
    codeflash_output = link_to_hash("abc123", "")
    
    # Special Characters in Hash
    codeflash_output = link_to_hash("a!b@c#123", "user/repo")
    
    # Special Characters in Fork
    codeflash_output = link_to_hash("abc123", "user/repo with space")


def test_large_scale():
    # Long Hash and Fork Names
    long_hash = "a" * 1000
    long_fork = "a" * 1000
    codeflash_output = link_to_hash(long_hash, "user/repo")
    codeflash_output = link_to_hash("abc123", long_fork)
    
    # Large Path Structure
    deep_path = "/".join(["folder"] * 1000)

def test_performance_and_scalability():
    # Multiple Calls
    for _ in range(1000):
        codeflash_output = link_to_hash("abc123", "user/repo")
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

from bench_runner.table import link_to_hash

def test_link_to_hash():
    assert link_to_hash('', '') == '[](https://github.com//cpython/commit/)'

📢 Feedback on this optimization?