⚡️ Speed up function render_markdown by 7%

[codeflash-ai]

📄 7% (0.07x) speedup for render_markdown in panel/io/mime_render.py

⏱️ Runtime : 290 milliseconds → 271 milliseconds (best of 16 runs)

📝 Explanation and details

The optimization moves the expensive markdown.Markdown() constructor call from inside the function to module initialization time, creating a reusable converter instance. Instead of creating a new Markdown parser on every function call, it reuses the same instance by calling reset() to clear state and convert() to process the text.

Key changes:

• Eliminated per-call constructor overhead: The original code created a new Markdown instance with extensions parsing on every call (98.8% of runtime). The optimized version does this once at import time.
• Reused parser instance: Uses _markdown_converter.reset() and _markdown_converter.convert() pattern, which is the recommended approach for repeated markdown processing.

Why this is faster:

• Reduced object creation: Avoids expensive extension loading, parser initialization, and configuration parsing that happens in markdown.markdown() each time.
• Amortized setup cost: The one-time setup cost is spread across all function calls rather than paid repeatedly.

Performance characteristics:

• Excellent for small/simple content: Shows 100-400% speedups on basic cases (paragraphs, headers, lists) where constructor overhead dominated.
• Moderate gains on complex content: Still 1-7% faster on large documents where actual processing dominates, but constructor overhead is minimized.
• Dramatic improvement on empty/whitespace inputs: Up to 4900% faster since there's almost no processing work, making constructor overhead very apparent.

The optimization maintains identical behavior while eliminating redundant initialization work.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from __future__ import annotations

# imports
import pytest  # used for our unit tests
from panel.io.mime_render import render_markdown

# unit tests

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

def test_basic_paragraph():
    # Test a single paragraph
    html, mime_type = render_markdown("Hello, world!", None, None) # 512μs -> 192μs (167% faster)

def test_basic_bold_and_italic():
    # Test bold and italic formatting
    html, _ = render_markdown("**bold** and *italic*", None, None) # 610μs -> 286μs (113% faster)

def test_basic_link():
    # Test a simple hyperlink
    html, _ = render_markdown("[Google](https://google.com)", None, None) # 564μs -> 251μs (125% faster)

def test_basic_code_inline():
    # Test inline code
    html, _ = render_markdown("Here is `code`.", None, None) # 555μs -> 227μs (144% faster)

def test_basic_unordered_list():
    # Test a simple unordered list
    html, _ = render_markdown("- item 1\n- item 2", None, None) # 623μs -> 301μs (107% faster)

def test_basic_ordered_list():
    # Test a simple ordered list
    html, _ = render_markdown("1. First\n2. Second", None, None) # 633μs -> 299μs (112% faster)

def test_basic_heading():
    # Test a heading
    html, _ = render_markdown("# Heading 1", None, None) # 507μs -> 182μs (178% faster)

def test_basic_blockquote():
    # Test a blockquote
    html, _ = render_markdown("> quoted text", None, None) # 590μs -> 248μs (137% faster)

def test_basic_horizontal_rule():
    # Test a horizontal rule
    html, _ = render_markdown("---", None, None) # 454μs -> 131μs (245% faster)

def test_basic_code_block():
    # Test a fenced code block
    md = "```\ndef foo():\n    pass\n```"
    html, _ = render_markdown(md, None, None) # 4.39ms -> 4.00ms (9.63% faster)

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

def test_empty_string():
    # Test empty string input
    html, _ = render_markdown("", None, None) # 331μs -> 8.28μs (3905% faster)

def test_whitespace_only():
    # Test input with only whitespace
    html, _ = render_markdown("   \n\t   ", None, None) # 306μs -> 6.14μs (4893% faster)

def test_html_escaping():
    # Test that HTML is not escaped (markdown allows raw HTML by default)
    html, _ = render_markdown("<b>raw html</b>", None, None) # 584μs -> 279μs (109% faster)

def test_html_injection():
    # Test that script tags are preserved (markdown does NOT sanitize by default)
    html, _ = render_markdown("<script>alert('xss')</script>", None, None) # 563μs -> 237μs (137% faster)

def test_invalid_markdown():
    # Test input that is not valid markdown (should be rendered as plain text in a paragraph)
    html, _ = render_markdown("not *closed", None, None) # 504μs -> 199μs (153% faster)

def test_only_markdown_symbols():
    # Test input with only markdown symbols
    html, _ = render_markdown("****", None, None) # 439μs -> 134μs (227% faster)

def test_unicode_characters():
    # Test unicode and emoji support
    html, _ = render_markdown("I ❤️ Python 🐍", None, None) # 518μs -> 192μs (169% faster)

def test_multiple_newlines():
    # Test handling of multiple newlines (should create paragraphs)
    html, _ = render_markdown("para1\n\npara2", None, None) # 554μs -> 249μs (122% faster)

def test_nested_lists():
    # Test nested unordered lists
    md = "- item 1\n  - subitem 1\n  - subitem 2\n- item 2"
    html, _ = render_markdown(md, None, None) # 760μs -> 417μs (82.0% faster)

def test_table_extension():
    # Test markdown table (requires "extra" extension)
    md = "| A | B |\n|---|---|\n| 1 | 2 |"
    html, _ = render_markdown(md, None, None) # 886μs -> 532μs (66.6% faster)

def test_smart_quotes():
    # Test that straight quotes are converted to smart quotes
    md = '"Hello," she said.'
    html, _ = render_markdown(md, None, None) # 541μs -> 219μs (146% faster)

def test_codehilite_extension():
    # Test codehilite adds class to code block
    md = "```python\nprint(1)\n```"
    html, _ = render_markdown(md, None, None) # 921μs -> 571μs (61.4% faster)

def test_very_long_line():
    # Test a single very long line (edge of performance)
    long_line = "a" * 1000
    html, _ = render_markdown(long_line, None, None) # 815μs -> 481μs (69.3% faster)

def test_meta_and_mime_are_ignored():
    # meta and mime are not used, but should not affect output
    html1, _ = render_markdown("test", None, None) # 492μs -> 183μs (168% faster)
    html2, _ = render_markdown("test", {"foo": "bar"}, "text/markdown") # 419μs -> 126μs (232% faster)

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

def test_large_document_multiple_features():
    # Test a large markdown document with various features
    md = "# Title\n\n" + \
         "\n".join(f"## Section {i}\n\nParagraph {i} with **bold** and *italic*.\n\n- item 1\n- item 2\n\n" +
                   "```python\nprint('section')\n```\n" for i in range(20))
    html, _ = render_markdown(md, None, None) # 14.1ms -> 13.9ms (1.28% faster)

def test_large_number_of_lists():
    # Test many list items to check scalability
    md = "\n".join(f"- item {i}" for i in range(500))
    html, _ = render_markdown(md, None, None) # 31.7ms -> 31.3ms (1.06% faster)

def test_large_number_of_tables():
    # Test many tables in one document
    table = "| A | B |\n|---|---|\n| 1 | 2 |\n"
    md = "\n".join(table for _ in range(50))
    html, _ = render_markdown(md, None, None) # 19.7ms -> 19.4ms (1.40% faster)

def test_large_code_block():
    # Test a large code block
    code = "\n".join(f"print({i})" for i in range(500))
    md = f"```python\n{code}\n```"
    html, _ = render_markdown(md, None, None) # 11.8ms -> 11.6ms (1.62% faster)

def test_performance_large_paragraphs():
    # Test many large paragraphs
    para = "Lorem ipsum dolor sit amet, " * 20
    md = "\n\n".join(para for _ in range(100))
    html, _ = render_markdown(md, None, None) # 24.5ms -> 24.1ms (1.62% faster)

def test_large_nested_lists():
    # Test deeply nested lists (up to 10 levels)
    md = "- a\n"
    for i in range(1, 10):
        md += "  " * i + f"- level {i}\n"
    html, _ = render_markdown(md, None, None) # 1.44ms -> 1.09ms (31.5% faster)

# ---------------------- #
# Negative/Invalid Input Test Cases
# ---------------------- #



#------------------------------------------------
from __future__ import annotations

# imports
import pytest  # used for our unit tests
from panel.io.mime_render import render_markdown

# unit tests

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

def test_basic_empty_string():
    # Empty string should return empty HTML string
    html, mime_type = render_markdown("", {}, "text/markdown") # 482μs -> 18.0μs (2572% faster)

def test_basic_plain_text():
    # Plain text should be wrapped in <p> tags
    html, mime_type = render_markdown("Hello world", {}, "text/markdown") # 583μs -> 334μs (74.7% faster)

def test_basic_header():
    # Markdown header should be converted to <h1>
    html, mime_type = render_markdown("# Title", {}, "text/markdown") # 500μs -> 208μs (140% faster)

def test_basic_bold_and_italic():
    # Bold and italic markdown should be converted to <strong> and <em>
    html, _ = render_markdown("**bold** *italic*", {}, "text/markdown") # 620μs -> 289μs (114% faster)

def test_basic_link():
    # Markdown link should be converted to <a>
    html, _ = render_markdown("[link](http://example.com)", {}, "text/markdown") # 569μs -> 262μs (117% faster)

def test_basic_code_block():
    # Markdown code block should be converted to <pre><code>
    html, _ = render_markdown("```\nprint('hi')\n```", {}, "text/markdown") # 4.42ms -> 4.12ms (7.20% faster)

def test_basic_list():
    # Markdown list should be converted to <ul><li>
    html, _ = render_markdown("- item1\n- item2", {}, "text/markdown") # 652μs -> 328μs (98.6% faster)

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



def test_edge_unsupported_mime():
    # Function always returns 'text/html' regardless of mime
    html, mime_type = render_markdown("# Title", {}, "application/x-markdown") # 537μs -> 214μs (151% faster)

def test_edge_html_escaping():
    # Markdown should escape HTML by default
    html, _ = render_markdown("<script>alert('x')</script>", {}, "text/markdown") # 566μs -> 266μs (113% faster)

def test_edge_special_characters():
    # Special characters should be handled correctly
    html, _ = render_markdown("5 > 3 & 2 < 4", {}, "text/markdown") # 527μs -> 204μs (157% faster)

def test_edge_unicode_characters():
    # Unicode characters should be preserved
    html, _ = render_markdown("Café 😊", {}, "text/markdown") # 506μs -> 186μs (171% faster)

def test_edge_multiple_extensions():
    # Extensions should be applied, e.g., "extra" enables tables
    md = "|A|B|\n|-|-|\n|1|2|"
    html, _ = render_markdown(md, {}, "text/markdown") # 868μs -> 551μs (57.5% faster)

def test_edge_codehilite_extension():
    # codehilite should add class to code block
    md = "```python\nprint('hi')\n```"
    html, _ = render_markdown(md, {}, "text/markdown") # 895μs -> 617μs (45.0% faster)

def test_edge_smarty_extension():
    # Smarty extension should convert quotes to curly quotes
    md = '"Hello"'
    html, _ = render_markdown(md, {}, "text/markdown") # 535μs -> 218μs (145% faster)

def test_edge_meta_argument_unused():
    # meta argument is unused, but should not affect output
    html1, _ = render_markdown("test", {}, "text/markdown") # 485μs -> 176μs (175% faster)
    html2, _ = render_markdown("test", {"foo": "bar"}, "text/markdown") # 413μs -> 124μs (232% faster)

def test_edge_mime_argument_unused():
    # mime argument is unused, but should not affect output
    html1, _ = render_markdown("test", {}, "text/markdown") # 499μs -> 171μs (190% faster)
    html2, _ = render_markdown("test", {}, "application/x-markdown") # 401μs -> 117μs (242% faster)

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

def test_large_long_markdown():
    # Large markdown string (repeated headers and lists)
    md = "# Header\n" + ("- item\n" * 500)
    html, _ = render_markdown(md, {}, "text/markdown") # 30.7ms -> 30.4ms (0.891% faster)

def test_large_table():
    # Large markdown table
    header = "|Col|\n|-|\n"
    rows = "".join("|Row{}|\n".format(i) for i in range(1, 501))
    md = header + rows
    html, _ = render_markdown(md, {}, "text/markdown") # 46.7ms -> 45.8ms (1.85% faster)

def test_large_mixed_content():
    # Large markdown with mixed content
    md = "# Title\n" + ("Paragraph\n\n" * 250) + ("- list\n" * 250)
    html, _ = render_markdown(md, {}, "text/markdown") # 29.6ms -> 29.4ms (0.748% faster)

def test_large_unicode_content():
    # Large markdown with unicode characters
    md = ("😊 Café\n\n" * 300)
    html, _ = render_markdown(md, {}, "text/markdown") # 18.2ms -> 17.7ms (2.44% faster)

def test_large_code_blocks():
    # Many code blocks
    md = "\n".join("```python\nprint({})\n```".format(i) for i in range(1, 101))
    html, _ = render_markdown(md, {}, "text/markdown") # 27.7ms -> 27.5ms (0.967% faster)

# ------------------------------
# Determinism Test
# ------------------------------

def test_determinism():
    # Same input should always yield same output
    md = "# Determinism\n- a\n- b"
    html1, _ = render_markdown(md, {}, "text/markdown") # 768μs -> 403μs (90.7% faster)
    html2, _ = render_markdown(md, {}, "text/markdown") # 610μs -> 304μs (100% faster)
# 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-render_markdown-mhagyix7 and push.