Markdown-Subset-zu-HTML-Konverter

import re import html def markdown_to_html(markdown_text: str) -> str: """Konvertiert eine Teilmenge von Markdown in HTML. Unterstützte Funktionen: - Überschriften (# .. ######) - Ungeordnete Listen mit 2-Leerzeichen-Einrückung - Eingefasste Codeblöcke (```) - Absätze - Inline: ***fett+kursiv***, **fett**, *kursiv* """ def escape(text: str) -> str: # HTML-sensible Zeichen escapen. return html.escape(text, quote=False) def process_inline(text: str) -> str: """Verarbeitet Inline-Markdown. Funktioniert auch mit bereits escapedem Text, da die Marker *, ** und *** keine escapeden Zeichen enthalten. """ escaped = escape(text) # Reihenfolge der Priorität: ***, dann **, dann *. # Nicht-gierige Übereinstimmung verwenden und lose Nicht-Leerzeichen-Grenzen erfordern. # ***text*** escaped = re.sub( r'\*\*\*(.+?)\*\*\*', r'<strong><em>\1</em></strong>', escaped, ) # **text** escaped = re.sub( r'\*\*(.+?)\*\*', r'<strong>\1</strong>', escaped, ) # *text* escaped = re.sub( r'\*(.+?)\*', r'<em>\1</em>', escaped, ) return escaped lines = markdown_text.split('\n') output = [] # Zustandsvariablen in_code_block = False code_buffer = [] paragraph_buffer = [] # Listen-Stack: Liste der aktuell offenen Einrückungsebenen (0, 1, 2, ...) list_stack = [] def flush_paragraph(): if paragraph_buffer: content = ' '.join(paragraph_buffer) output.append(f'<p>{process_inline(content)}</p>') paragraph_buffer.clear() def close_lists_to(level): """Schließt Listen, bis nur noch `level` Listen offen sind (level = Anzahl der offenen <ul>).""" while len(list_stack) > level: output.append('</li>') output.append('</ul>') list_stack.pop() if list_stack: # Nach dem Schließen einer verschachtelten Liste bleibt das übergeordnete <li> offen; # es wird geschlossen, wenn der nächste Geschwister beginnt oder wenn es vollständig geschlossen wird. pass def close_all_lists(): while list_stack: output.append('</li>') output.append('</ul>') list_stack.pop() i = 0 while i < len(lines): line = lines[i] # Codeblock-Verarbeitung if in_code_block: if line.strip().startswith('```'): # Codeblock beenden code_content = '\n'.join(code_buffer) output.append(f'<pre><code>{escape(code_content)}</code></pre>') code_buffer = [] in_code_block = False else: code_buffer.append(line) i += 1 continue # Prüfung auf Codeblock-Start stripped = line.strip() if stripped.startswith('```'): flush_paragraph() close_all_lists() in_code_block = True i += 1 continue # Leerzeile if stripped == '': flush_paragraph() close_all_lists() i += 1 continue # Überschrift? header_match = re.match(r'^(#{1,6}) +(.*)$', line) if header_match: flush_paragraph() close_all_lists() level = len(header_match.group(1)) content = header_match.group(2).rstrip() output.append(f'<h{level}>{process_inline(content)}</h{level}>') i += 1 continue # Listenpunkt? # Führende Leerzeichen abgleichen (müssen gerade sein für Verschachtelung) gefolgt von "- " list_match = re.match(r'^( *)- +(.*)$', line) if list_match: flush_paragraph() indent_spaces = len(list_match.group(1)) # Nur als gültige Einrückungsebene behandeln, wenn die Einrückung ein Vielfaches von 2 ist indent_level = indent_spaces // 2 content = list_match.group(2) # Listen-Stack anpassen if not list_stack: # Frisch beginnen: Die erste Liste muss auf Ebene 0 sein indent_level = 0 output.append('<ul>') list_stack.append(0) output.append(f'<li>{process_inline(content)}') else: current_depth = len(list_stack) - 1 # oberster Index if indent_level > current_depth: # Eine neue verschachtelte Liste öffnen (nur eine Ebene tiefer pro Schritt) indent_level = current_depth + 1 output.append('<ul>') list_stack.append(indent_level) output.append(f'<li>{process_inline(content)}') elif indent_level == current_depth: # Geschwister auf derselben Ebene: vorheriges <li> schließen output.append('</li>') output.append(f'<li>{process_inline(content)}') else: # Einrücken reduzieren: tiefere Listen schließen while len(list_stack) - 1 > indent_level: output.append('</li>') output.append('</ul>') list_stack.pop() # Auch das übergeordnete <li> schließen, das diese verschachtelte Liste enthielt output.append('</li>') # Jetzt auf derselben Ebene: Geschwister hinzufügen output.append(f'<li>{process_inline(content)}') i += 1 continue # Andernfalls ist es eine Absatzzeile if list_stack: close_all_lists() paragraph_buffer.append(line.strip()) i += 1 # Ende der Eingabe: alles leeren if in_code_block: # Nicht geschlossener Codeblock: alles ausgeben, was wir haben code_content = '\n'.join(code_buffer) output.append(f'<pre><code>{escape(code_content)}</code></pre>') flush_paragraph() close_all_lists() return '\n'.join(output) if __name__ == '__main__': sample = '''# Überschrift 1 Dies ist ein Absatz mit **fettem** und *kursivem* Text. Dies ist derselbe Absatz. - Listenpunkt eins - Listenpunkt zwei mit ***fett und kursiv*** - Verschachtelter Listenpunkt - Zurück zur ersten Ebene ```python def hallo(): print("Hallo, Welt!") ``` ''' print(markdown_to_html(sample))

def markdown_to_html(markdown_text: str) -> str: import re from html import escape lines = markdown_text.splitlines() out = [] paragraph_lines = [] list_stack = [] i = 0 in_code_block = False code_lines = [] def parse_inline(text: str) -> str: parts = [] i = 0 n = len(text) while i < n: if text.startswith('***', i): j = text.find('***', i + 3) if j != -1: inner = parse_inline(text[i + 3:j]) parts.append(f'<strong><em>{inner}</em></strong>') i = j + 3 continue if text.startswith('**', i): j = text.find('**', i + 2) if j != -1: inner = parse_inline(text[i + 2:j]) parts.append(f'<strong>{inner}</strong>') i = j + 2 continue if text.startswith('*', i): j = text.find('*', i + 1) if j != -1: inner = parse_inline(text[i + 1:j]) parts.append(f'<em>{inner}</em>') i = j + 1 continue parts.append(escape(text[i])) i += 1 return ''.join(parts) def flush_paragraph(): nonlocal paragraph_lines if paragraph_lines: text = ' '.join(line.strip() for line in paragraph_lines) out.append(f'<p>{parse_inline(text)}</p>') paragraph_lines = [] def close_lists_to(level: int): while len(list_stack) > level: out.append('</li>') out.append('</ul>') list_stack.pop() def handle_list_item(indent_spaces: int, content: str): level = indent_spaces // 2 if indent_spaces % 2 != 0: return False if level > len(list_stack): if level != len(list_stack) + 1: return False out.append('<ul>') list_stack.append(True) elif level < len(list_stack): close_lists_to(level) out.append('</li>') else: if list_stack: out.append('</li>') else: out.append('<ul>') list_stack.append(True) while len(list_stack) < level + 1: out.append('<ul>') list_stack.append(True) out.append(f'<li>{parse_inline(content)}') return True while i < len(lines): line = lines[i] if in_code_block: if line.startswith('```'): out.append(f'<pre><code>{escape("\n".join(code_lines))}</code></pre>') code_lines = [] in_code_block = False else: code_lines.append(line) i += 1 continue if line.startswith('```'): flush_paragraph() close_lists_to(0) in_code_block = True code_lines = [] i += 1 continue if not line.strip(): flush_paragraph() close_lists_to(0) i += 1 continue header_match = re.match(r'^(#{1,6})\s+(.*)$', line) if header_match: flush_paragraph() close_lists_to(0) level = len(header_match.group(1)) content = parse_inline(header_match.group(2).strip()) out.append(f'<h{level}>{content}</h{level}>') i += 1 continue list_match = re.match(r'^( *)(- )(.+)$', line) if list_match: flush_paragraph() indent = len(list_match.group(1)) content = list_match.group(3) if handle_list_item(indent, content): i += 1 continue if list_stack: close_lists_to(0) paragraph_lines.append(line) i += 1 if in_code_block: out.append(f'<pre><code>{escape("\n".join(code_lines))}</code></pre>') flush_paragraph() close_lists_to(0) return '\n'.join(out)