markdown_convert 1.2.51__tar.gz → 1.2.53__tar.gz

{markdown_convert-1.2.51 → markdown_convert-1.2.53}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: markdown_convert
-Version: 1.2.51
+Version: 1.2.53
 Summary: Convert Markdown files to PDF from your command line.
 Project-URL: homepage, https://github.com/Julynx/markdown_convert
 Author-email: Julio Cabria <juliocabria@tutanota.com>
@@ -17,6 +17,8 @@ Requires-Dist: latex2mathml>=3.78.1
 Requires-Dist: markdown2<3,>=2.4.13
 Requires-Dist: playwright>=1.57.0
 Requires-Dist: pygments<3,>=2.17.2
+Requires-Dist: ruamel-yaml>=0.19.1
+Requires-Dist: vl-convert-python>=1.9.0.post1
 Description-Content-Type: text/markdown
 
 # markdown-convert

{markdown_convert-1.2.51 → markdown_convert-1.2.53}/markdown_convert/default.css

@@ -453,14 +453,6 @@ math {
   border-radius: 0.3rem;
 }
 
-.admonition header {
-  display: flex;
-  align-items: center;
-  gap: 0.25rem;
-  margin-bottom: 0.25rem;
-  font-weight: bold;
-}
-
 .admonition strong {
   text-transform: capitalize;
 }
@@ -522,4 +514,15 @@ math {
 
 .admonition.caution strong {
   color: var(--color-ad-caution);
+}
+
+/* Vega-Lite charts*/
+div.vega-lite,
+div.vega {
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  width: 100%;
+  margin-top: 1em;
+  margin-bottom: 1em;
 }

{markdown_convert-1.2.51 → markdown_convert-1.2.53}/markdown_convert/modules/convert.py

@@ -9,7 +9,6 @@ import time
 from datetime import datetime
 from pathlib import Path
 
-import markdown2
 from playwright.sync_api import sync_playwright
 
 from .autoinstall import ensure_chromium
@@ -19,6 +18,7 @@ from .constants import (
     MARKDOWN_EXTENSIONS,
     PDF_PARAMS,
 )
+from .overrides import markdown2
 from .resources import get_code_css_path, get_css_path, get_output_path
 from .transform import (
     create_html_document,

markdown_convert-1.2.53/markdown_convert/modules/extras.py

@@ -0,0 +1,248 @@
+"""
+Extras are defined as helper functions called by
+render_extra_features from transform.py
+"""
+
+import json
+import re
+
+import vl_convert as vlc
+from bs4 import BeautifulSoup, Tag
+from ruamel.yaml import YAML
+
+
+class ExtraFeature:
+    """
+    Base class for extra features that can be applied to HTML.
+
+    Attributes:
+        pattern (str): Regex pattern to match the extra feature in the HTML.
+        run_before_stash (bool): Whether to run this extra before stashing code blocks.
+    """
+
+    pattern = r""
+    run_before_stash = False
+
+    def replace(self, match, html):
+        """
+        Replaces the matched pattern with the rendered extra feature.
+
+        Args:
+            match (re.Match): The regex match object.
+            html (str): The full HTML content.
+
+        Returns:
+            str: The replacement string.
+
+        Raises:
+            NotImplementedError: If the subclass does not implement this method.
+        """
+        raise NotImplementedError("Subclasses must implement the replace method.")
+
+
+class CheckboxExtra(ExtraFeature):
+    """
+    Extra feature for rendering checkboxes.
+    """
+
+    pattern = r"(?P<checkbox>\[\s\]|\[x\])"
+
+    def replace(match, html):
+        """
+        Render a tag for a checkbox.
+
+        Args:
+            match: Element identified as a checkbox
+        Returns:
+            str: tag representing the checkbox
+        """
+        status = "checked" if "[x]" in match.group("checkbox") else ""
+        return f'<input type="checkbox" {status}>'
+
+
+class HighlightExtra(ExtraFeature):
+    """
+    Extra feature for rendering highlighted text.
+    """
+
+    pattern = r"==(?P<content>.*?)=="
+
+    def replace(match, html):
+        """
+        Render a tag for a highlight.
+
+        Args:
+            match: Element identified as a highlight
+        Returns:
+            str: tag representing the highlight
+        """
+        content = match.group("content")
+        return f'<span class="highlight">{content}</span>'
+
+
+class CustomSpanExtra(ExtraFeature):
+    """
+    Extra feature for rendering custom spans with specific classes.
+    """
+
+    pattern = r"(?P<cls>[a-zA-Z0-9_-]+)\{\{\s*(?P<content>.*?)\s*\}\}"
+
+    def replace(match, html):
+        """
+        Render a tag for a custom span.
+
+        Args:
+            match: Element identified as a custom span
+        Returns:
+            str: tag representing the custom span
+        """
+        cls = match.group("cls")
+        content = match.group("content")
+        return f'<span class="{cls}">{content}</span>'
+
+
+class TocExtra(ExtraFeature):
+    """
+    Extra feature for rendering a Table of Contents.
+    """
+
+    pattern = r"\[TOC(?:\s+depth=(?P<depth>\d+))?\]"
+
+    def replace(match, html):
+        """
+        Render a tag for a table of contents
+
+        Args:
+            match: Element identified as a table of contents
+        Returns:
+            str: tag representing the table of contents
+        """
+        soup = BeautifulSoup(html, "html.parser")
+        max_level = match.group("depth")
+        max_level = 3 if max_level is None else int(max_level)
+
+        headers = [
+            header
+            for header in soup.find_all(
+                [f"h{index}" for index in range(1, max_level + 1)]
+            )
+            if header.get("id")
+        ]
+        if not headers:
+            return ""
+
+        tag: Tag = soup.new_tag("ul", attrs={"class": "toc"})
+        active_list = {0: tag}
+        last_list_element = {}
+
+        for header in headers:
+            level = int(header.name[1])
+
+            if level not in active_list:
+                parent_lvl = max(key for key in active_list if key < level)
+                if last_list_element.get(parent_lvl):
+                    sub_list = soup.new_tag("ul")
+                    last_list_element[parent_lvl].append(sub_list)
+                    active_list[level] = sub_list
+                else:
+                    active_list[level] = active_list[parent_lvl]
+
+            active_list = {
+                key: value for key, value in active_list.items() if key <= level
+            }
+
+            list_item = soup.new_tag("li")
+            link = soup.new_tag("a", href=f"#{header['id']}")
+            link.string = header.get_text(strip=True)
+            list_item.append(link)
+
+            active_list[level].append(list_item)
+            last_list_element[level] = list_item
+
+        return tag.prettify()
+
+
+class VegaExtra(ExtraFeature):
+    """
+    Extra feature for rendering Vega-Lite diagrams from JSON or YAML.
+    """
+
+    pattern = (
+        r"<pre[^>]*>"
+        r"<code[^>]*class=[\"'][^\"]*language-vega[^\"]*[\"'][^>]*>"
+        r"(?P<content>.*?)"
+        r"</code>"
+        r"</pre>"
+    )
+    run_before_stash = True
+
+    def replace(match, html):
+        """
+        Render a tag for a vega lite diagram from JSON or YAML.
+
+        Args:
+            match (re.Match): Element identified as a vega lite diagram.
+            html (str): The full HTML content.
+
+        Returns:
+            str: SVG tag representing the vega lite diagram.
+        """
+        content = match.group("content")
+        spec = None
+
+        try:
+            spec = json.loads(content)
+        except (json.JSONDecodeError, TypeError):
+            try:
+                yaml = YAML(typ="safe")
+                spec = yaml.load(content)
+            except Exception as exc:
+                print(f"WARNING: Failed to parse Vega-Lite spec: {exc}")
+                return match.group(0)
+
+        if spec is None:
+            return match.group(0)
+
+        try:
+            tag = vlc.vegalite_to_svg(spec)
+            return f"<div class='vega-lite'>{tag}</div>"
+        except Exception as exc:
+            print(f"WARNING: Failed to convert Vega-Lite spec to SVG: {exc}")
+            return match.group(0)
+
+
+def apply_extras(extras: set[ExtraFeature], html, before_stash=False):
+    """
+    Applies extra features to an html string.
+    Args:
+        extras: set[ExtraFeature] Extra features to apply
+        html: complete html text, used by some extras like TOC.
+    Returns:
+        str: The updated html.
+    """
+    for extra in extras:
+        if not extra.run_before_stash == before_stash:
+            continue
+
+        # Loop until the pattern no longer matches
+        while re.search(extra.pattern, html, flags=re.DOTALL):
+            new_html = html
+            try:
+                new_html = re.sub(
+                    extra.pattern,
+                    lambda match: extra.replace(match, html=html),
+                    html,
+                    flags=re.DOTALL,
+                )
+            except Exception as exc:
+                print(
+                    f"WARNING: An exception occurred while trying to apply an extra:\n{exc}"
+                )
+                pass
+
+            # Safety break:
+            if new_html == html:
+                break
+            html = new_html
+
+    return html

markdown_convert-1.2.53/markdown_convert/modules/overrides.py

@@ -0,0 +1,36 @@
+"""
+Overrides for markdown2.
+"""
+
+import markdown2
+
+
+def tags(self, lexer_name: str) -> tuple[str, str]:
+    """
+    Overrides markdown2.FencedCodeBlocks.tags
+
+    Provides support for the fenced code blocks language attribute without
+    the need to have the highlightjs-lang extension enabled.
+    """
+    pre_class = self.md._html_class_str_from_tag("pre")
+    if lexer_name:
+        code_class = f' class="{lexer_name} language-{lexer_name}"'
+    else:
+        code_class = self.md._html_class_str_from_tag("code")
+    return (f"<pre{pre_class}><code{code_class}>", "</code></pre>")
+
+
+def _convert_double_match(self, match):
+    """
+    Overrides markdown2.Latex._convert_double_match
+
+    Fixes bug #674 of latex macros that start with backslash n not being
+    properly rendered.
+    """
+    return self.converter.convert(match.group(1).replace("\n", " "), display="block")
+
+
+# Apply overrides on module import and expose markdown2
+markdown2.FencedCodeBlocks.tags = tags
+markdown2.Latex._convert_double_match = _convert_double_match
+__all__ = ["markdown2"]

markdown_convert-1.2.53/markdown_convert/modules/transform.py

@@ -0,0 +1,135 @@
+"""
+Module for transforming HTML content.
+"""
+
+import re
+
+from bs4 import BeautifulSoup
+
+from .extras import (
+    apply_extras,
+    ExtraFeature,
+    CheckboxExtra,
+    CustomSpanExtra,
+    HighlightExtra,
+    TocExtra,
+    VegaExtra,
+)
+
+
+def create_html_document(html_content, css_content, csp):
+    """
+    Creates a complete HTML document with the given content, CSS, and Content Security Policy.
+    Args:
+        html_content (str): The HTML content to include in the body.
+        css_content (str): The CSS styles to include in the head.
+        csp (str): The Content Security Policy string.
+    Returns:
+        str: A complete HTML document as a string.
+    """
+    return f"""<!DOCTYPE html>
+<html>
+<head>
+<meta charset="UTF-8">
+<meta http-equiv="Content-Security-Policy" content="{csp or ""}">
+<style>
+{css_content or ""}
+</style>
+</head>
+<body>
+{html_content or ""}
+</body>
+</html>"""
+
+
+def create_sections(html_string):
+    """
+    Wraps each h2 and its following content in a <section> tag.
+    The section ends when the next h2 is encountered, or the parent ends.
+
+    Args:
+        html_string (str): The input HTML string.
+    Returns:
+        str: The modified HTML string with sections wrapped.
+    """
+    soup = BeautifulSoup(html_string, "html.parser")
+
+    for header in soup.find_all("h2"):
+        new_section = soup.new_tag("section")
+        header.insert_before(new_section)
+
+        current = header
+        while current is not None and (current == header or current.name != "h2"):
+            next_sibling = current.next_sibling
+            new_section.append(current)
+            current = next_sibling
+
+    return str(soup)
+
+
+def render_mermaid_diagrams(html, *, nonce):
+    """
+    Renders Mermaid diagrams in the HTML content.
+
+    Args:
+        html (str): HTML content.
+        nonce (str): Cryptographic nonce for CSP.
+    Returns:
+        str: HTML content with rendered Mermaid diagrams.
+    """
+    mermaid_script = f"""
+<script type="module" nonce="{nonce}">
+  import mermaid from 'https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.esm.min.mjs';
+  mermaid.initialize({{
+    startOnLoad: true,
+    theme: 'default',
+    themeVariables: {{}},
+    fontFamily: 'arial, verdana, sans-serif'
+  }});
+</script>
+"""
+
+    if '<div class="mermaid">' in html:
+        html = mermaid_script + html
+
+    return html
+
+
+def render_extra_features(
+    html,
+    extras: set[ExtraFeature] = (
+        CheckboxExtra,
+        CustomSpanExtra,
+        HighlightExtra,
+        TocExtra,
+        VegaExtra,
+    ),
+):
+    """
+    Renders extra features by protecting specific tags, applying regex
+    transformations, and restoring the protected content.
+    """
+    placeholders = {}
+
+    def stash(match):
+        key = f"__PROTECTED_BLOCK_{len(placeholders)}__"
+        placeholders[key] = match.group(0)
+        return key
+
+    # 0. Pre protection extras
+    html = apply_extras(extras, html, before_stash=True)
+
+    # 1. Protection: Replace ignored tags with unique hashes
+    ignored_pattern = re.compile(
+        r"<(code|pre|script|style)\b[^>]*>.*?</\1>", re.DOTALL | re.IGNORECASE
+    )
+    html = ignored_pattern.sub(stash, html)
+
+    # 2. Transformations: Define patterns and their replacements
+    html = apply_extras(extras, html, before_stash=False)
+
+    # 3. Restoration: Replace hashes back with original content
+    for key, original_content in placeholders.items():
+        html = html.replace(key, original_content)
+
+    return html

{markdown_convert-1.2.51 → markdown_convert-1.2.53}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "markdown_convert"
-version = "1.2.51"
+version = "1.2.53"
 description = "Convert Markdown files to PDF from your command line."
 authors = [
     { name = "Julio Cabria", email = "juliocabria@tutanota.com" },
@@ -25,6 +25,8 @@ dependencies = [
     "playwright>=1.57.0",
     "beautifulsoup4>=4.14.3",
     "install-playwright>=1.0.0",
+    "vl-convert-python>=1.9.0.post1",
+    "ruamel-yaml>=0.19.1",
 ]
 
 [project.urls]
@@ -48,6 +50,7 @@ include = [
     "markdown_convert/modules/utils.py",
     "markdown_convert/modules/validate.py",
     "markdown_convert/modules/autoinstall.py",
+    "markdown_convert/modules/overrides.py",
 ]
 
 [tool.hatch.build.targets.wheel]
@@ -66,6 +69,7 @@ include = [
     "markdown_convert/modules/utils.py",
     "markdown_convert/modules/validate.py",
     "markdown_convert/modules/autoinstall.py",
+    "markdown_convert/modules/overrides.py",
 ]
 
 [dependency-groups]

markdown_convert-1.2.51/markdown_convert/modules/extras.py

@@ -1,100 +0,0 @@
-"""
-Extras are defined as helper functions called by
-render_extra_features from transform.py
-"""
-
-
-def create_checkbox(soup, match):
-    """
-    Render a tag for a checkbox.
-
-    Args:
-        soup: HTML beautifulsoup
-        match: Element identified as a checkbox
-    Returns:
-        tag: Beautifulsoup tag representing the checkbox
-    """
-    tag = soup.new_tag("input", type="checkbox")
-    if "[x]" in match.group("checkbox"):
-        tag["checked"] = ""
-    return tag
-
-
-def create_highlight(soup, match):
-    """
-    Render a tag for a highlight.
-
-    Args:
-        soup: HTML beautifulsoup
-        match: Element identified as a highlight
-    Returns:
-        tag: Beautifulsoup tag representing the highlight
-    """
-    tag = soup.new_tag("span", attrs={"class": "highlight"})
-    tag.string = match.group("hl_content")
-    return tag
-
-
-def create_custom_span(soup, match):
-    """
-    Render a tag for a custom span.
-
-    Args:
-        soup: HTML beautifulsoup
-        match: Element identified as a custom span
-    Returns:
-        tag: Beautifulsoup tag representing the custom span
-    """
-    tag = soup.new_tag("span", attrs={"class": match.group("cls")})
-    tag.string = match.group("sp_content")
-    return tag
-
-
-def create_toc(soup, match):
-    """
-    Render a tag for a table of contents
-
-    Args:
-        soup: HTML beautifulsoup
-        match: Element identified as a table of contents
-    Returns:
-        tag: Beautifulsoup tag representing the table of contents
-    """
-    max_level = match.group("depth")
-    max_level = 3 if max_level is None else int(max_level)
-
-    headers = [
-        header
-        for header in soup.find_all([f"h{index}" for index in range(1, max_level + 1)])
-        if header.get("id")
-    ]
-    if not headers:
-        return ""
-
-    tag = soup.new_tag("ul", attrs={"class": "toc"})
-    active_list = {0: tag}
-    last_list_element = {}
-
-    for header in headers:
-        level = int(header.name[1])
-
-        if level not in active_list:
-            parent_lvl = max(key for key in active_list if key < level)
-            if last_list_element.get(parent_lvl):
-                sub_list = soup.new_tag("ul")
-                last_list_element[parent_lvl].append(sub_list)
-                active_list[level] = sub_list
-            else:
-                active_list[level] = active_list[parent_lvl]
-
-        active_list = {key: value for key, value in active_list.items() if key <= level}
-
-        list_item = soup.new_tag("li")
-        link = soup.new_tag("a", href=f"#{header['id']}")
-        link.string = header.get_text(strip=True)
-        list_item.append(link)
-
-        active_list[level].append(list_item)
-        last_list_element[level] = list_item
-
-    return tag

markdown_convert-1.2.51/markdown_convert/modules/transform.py

@@ -1,164 +0,0 @@
-"""
-Module for transforming HTML content.
-"""
-
-import re
-
-from bs4 import BeautifulSoup
-
-from .constants import YELLOW
-from .extras import create_checkbox, create_custom_span, create_highlight, create_toc
-from .utils import color
-
-
-def create_html_document(html_content, css_content, csp):
-    """
-    Creates a complete HTML document with the given content, CSS, and Content Security Policy.
-    Args:
-        html_content (str): The HTML content to include in the body.
-        css_content (str): The CSS styles to include in the head.
-        csp (str): The Content Security Policy string.
-    Returns:
-        str: A complete HTML document as a string.
-    """
-    return f"""<!DOCTYPE html>
-<html>
-<head>
-<meta charset="UTF-8">
-<meta http-equiv="Content-Security-Policy" content="{csp or ""}">
-<style>
-{css_content or ""}
-</style>
-</head>
-<body>
-{html_content or ""}
-</body>
-</html>"""
-
-
-def create_sections(html_string):
-    """
-    Wraps each h2 and its following content in a <section> tag.
-    The section ends when the next h2 is encountered, or the parent ends.
-
-    Args:
-        html_string (str): The input HTML string.
-    Returns:
-        str: The modified HTML string with sections wrapped.
-    """
-    soup = BeautifulSoup(html_string, "html.parser")
-
-    for header in soup.find_all("h2"):
-        new_section = soup.new_tag("section")
-        header.insert_before(new_section)
-
-        current = header
-        while current is not None and (current == header or current.name != "h2"):
-            next_sibling = current.next_sibling
-            new_section.append(current)
-            current = next_sibling
-
-    return str(soup)
-
-
-def render_mermaid_diagrams(html, *, nonce):
-    """
-    Renders Mermaid diagrams in the HTML content.
-
-    Args:
-        html (str): HTML content.
-        nonce (str): Cryptographic nonce for CSP.
-    Returns:
-        str: HTML content with rendered Mermaid diagrams.
-    """
-    mermaid_script = f"""
-<script type="module" nonce="{nonce}">
-  import mermaid from 'https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.esm.min.mjs';
-  mermaid.initialize({{
-    startOnLoad: true,
-    theme: 'default',
-    themeVariables: {{}},
-    fontFamily: 'arial, verdana, sans-serif'
-  }});
-</script>
-"""
-
-    if '<div class="mermaid">' in html:
-        html = mermaid_script + html
-
-    return html
-
-
-def render_extra_features(html):
-    """
-    Renders extra features like checkboxes, highlights, and custom spans in the HTML content.
-
-    Args:
-        html (str): HTML content.
-    Returns:
-        str: HTML content with extra features rendered.
-    """
-
-    handlers = {
-        "checkbox": create_checkbox,
-        "highlight": create_highlight,
-        "span": create_custom_span,
-        "toc": create_toc,
-    }
-
-    master_pattern = re.compile(
-        r"(?P<checkbox>\[\s\]|\[x\])|"
-        r"(?P<highlight>==(?P<hl_content>.*?)==)|"
-        r"(?P<span>(?P<cls>[a-zA-Z0-9_-]+)\{\{\s*(?P<sp_content>.*?)\s*\}\})|"
-        r"(?P<toc>\[TOC(?:\s+depth=(?P<depth>\d+))?\])"
-    )
-
-    ignored_tags = {"code", "pre", "script", "style"}
-
-    soup = BeautifulSoup(html, "html.parser")
-    for text_node in soup.find_all(string=True):
-        # Ignore text nodes within certain tags
-        if text_node.parent.name in ignored_tags:
-            continue
-
-        # If no match, skip processing
-        content = text_node.string
-        if not master_pattern.search(content):
-            continue
-
-        new_nodes = []
-        last_end = 0
-        for match in master_pattern.finditer(content):
-            start, end = match.span()
-
-            # Append text before the match
-            if start > last_end:
-                new_nodes.append(content[last_end:start])
-
-            kind = match.lastgroup
-
-            # Call the appropriate handler
-            handler = handlers.get(kind)
-            if handler:
-                try:
-                    tag = handler(soup, match)
-                    new_nodes.append(tag)
-                except Exception as exc:
-                    print(
-                        color(
-                            YELLOW,
-                            f"WARNING: Handler for '{kind}' failed with exception: {exc}",
-                        )
-                    )
-                    new_nodes.append(match.group(0))
-
-            last_end = end
-
-        # Append any remaining text after the last match
-        if new_nodes:
-            if last_end < len(content):
-                new_nodes.append(content[last_end:])
-
-            text_node.replace_with(*new_nodes)
-
-    return str(soup)