notionary 0.2.21__py3-none-any.whl → 0.2.22__py3-none-any.whl

notionary/blocks/child_page/child_page_element.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+import re
+from typing import Optional
+
+from notionary.blocks.base_block_element import BaseBlockElement
+from notionary.blocks.syntax_prompt_builder import BlockElementMarkdownInformation
+from notionary.blocks.models import Block, BlockCreateResult, BlockType
+from notionary.page.page_context import get_page_context
+
+
+class ChildPageElement(BaseBlockElement):
+    """
+    Handles conversion between Markdown page references and Notion child page blocks.
+
+    Creates new pages when converting from markdown.
+    """
+
+    PATTERN_BRACKET = re.compile(r"^\[page:\s*(.+)\]$", re.IGNORECASE)
+    PATTERN_EMOJI = re.compile(r"^[📝📄]\s*(.+)$")
+
+    @classmethod
+    def match_notion(cls, block: Block) -> bool:
+        return block.type == BlockType.CHILD_PAGE and getattr(block, "child_page", None)
+
+    @classmethod
+    async def markdown_to_notion(cls, text: str) -> Optional[BlockCreateResult]:
+        """
+        Convert markdown page syntax to an actual Notion page.
+        Returns None since child_page blocks are created implicitly via Pages API (not Blocks API).
+        """
+        context = get_page_context()
+
+        text = text.strip()
+
+        match = cls.PATTERN_BRACKET.match(text)
+        if not match:
+            match = cls.PATTERN_EMOJI.match(text)
+
+        if not match:
+            return None
+
+        title = match.group(1).strip()
+        if not title:
+            return None
+
+        # Reject multiline titles
+        if "\n" in title or "\r" in title:
+            return None
+
+        try:
+            # Create the actual page using context
+            await context.page_client.create_page(
+                title=title,
+                parent_page_id=context.page_id,
+            )
+            # Return None as per BaseBlockElement convention:
+            # child_page blocks cannot be written through the Blocks API directly.
+            # Creating a page under the parent page will automatically insert a child_page block.
+            return None
+
+        except Exception as e:
+            print(f"Failed to create page '{title}': {e}")
+            return None
+
+    @classmethod
+    async def notion_to_markdown(cls, block: Block) -> Optional[str]:
+        if block.type != BlockType.CHILD_PAGE or not getattr(block, "child_page", None):
+            return None
+
+        title = block.child_page.title
+        if not title or not title.strip():
+            return None
+
+        # Use bracket syntax for output
+        return f"[page: {title.strip()}]"
+
+    @classmethod
+    def get_system_prompt_information(cls) -> Optional[BlockElementMarkdownInformation]:
+        """Get system prompt information for child page blocks."""
+        return BlockElementMarkdownInformation(
+            block_type=cls.__name__,
+            description="Creates new sub-pages within a Notion page.",
+            syntax_examples=[
+                "[page: Meeting Notes]",
+                "[page: Ideas]",
+                "📝 Project Overview",
+                "📄 Research Log",
+            ],
+            usage_guidelines=(
+                "Use to create new pages that will appear as child_page blocks in the current page. "
+                "Pages are created via the Pages API with the current page as parent."
+            ),
+        )

notionary/blocks/client.py

@@ -24,7 +24,6 @@ class NotionBlockClient(BaseNotionClient):
                 return None
         return None
 
-    # das hier ist falsch (Columns werden nicht richtig abgebildet)
     async def get_blocks_by_page_id_recursively(
         self, page_id: str, parent_id: Optional[str] = None
     ) -> list[Block]:

notionary/blocks/code/code_element.py

@@ -5,6 +5,7 @@ from typing import Optional
 
 from notionary.blocks.base_block_element import BaseBlockElement
 from notionary.blocks.code.code_models import CodeBlock, CodeLanguage, CreateCodeBlock
+from notionary.blocks.syntax_prompt_builder import BlockElementMarkdownInformation
 from notionary.blocks.models import Block, BlockCreateResult, BlockType
 from notionary.blocks.rich_text.rich_text_models import RichTextObject
 
@@ -22,6 +23,7 @@ class CodeElement(BaseBlockElement):
 
     DEFAULT_LANGUAGE = "plain text"
     CODE_START_PATTERN = re.compile(r"^```(\w*)\s*$")
+    CODE_START_WITH_CAPTION_PATTERN = re.compile(r"^```(\w*)\s*(?:\"([^\"]*)\")?\s*$")
 
     @classmethod
     def match_notion(cls, block: Block) -> bool:
@@ -29,7 +31,7 @@ class CodeElement(BaseBlockElement):
         return block.type == BlockType.CODE and block.code
 
     @classmethod
-    def markdown_to_notion(cls, text: str) -> BlockCreateResult:
+    async def markdown_to_notion(cls, text: str) -> BlockCreateResult:
         """Convert opening ```language to Notion code block."""
         if not (match := cls.CODE_START_PATTERN.match(text.strip())):
             return None
@@ -42,7 +44,39 @@ class CodeElement(BaseBlockElement):
         return CreateCodeBlock(code=code_block)
 
     @classmethod
-    def notion_to_markdown(cls, block: Block) -> Optional[str]:
+    def create_from_markdown_block(
+        cls, opening_line: str, code_lines: list[str]
+    ) -> BlockCreateResult:
+        """
+        Create a complete code block from markdown components.
+        """
+        match = cls.CODE_START_WITH_CAPTION_PATTERN.match(opening_line.strip())
+        if not match:
+            return None
+
+        language = (match.group(1) or cls.DEFAULT_LANGUAGE).lower()
+        language = cls._normalize_language(language)
+
+        caption = match.group(2) if match.group(2) else None
+
+        # Create rich text content from code lines
+        rich_text = []
+        if code_lines:
+            content = "\n".join(code_lines)
+            rich_text = [RichTextObject.for_code_block(content)]
+
+        caption_list = []
+        if caption:
+            caption_list = [RichTextObject.for_caption(caption)]
+
+        code_block = CodeBlock(
+            rich_text=rich_text, language=language, caption=caption_list
+        )
+
+        return CreateCodeBlock(code=code_block)
+
+    @classmethod
+    async def notion_to_markdown(cls, block: Block) -> Optional[str]:
         """Convert Notion code block to Markdown."""
         if block.type != BlockType.CODE:
             return None
@@ -98,3 +132,18 @@ class CodeElement(BaseBlockElement):
     def extract_caption(caption_list: list[RichTextObject]) -> str:
         """Extract caption text from caption array."""
         return "".join(rt.plain_text for rt in caption_list if rt.plain_text)
+
+    @classmethod
+    def get_system_prompt_information(cls) -> Optional[BlockElementMarkdownInformation]:
+        """Get system prompt information for code blocks."""
+        return BlockElementMarkdownInformation(
+            block_type=cls.__name__,
+            description="Code blocks display syntax-highlighted code with optional language specification and captions",
+            syntax_examples=[
+                "```\nprint('Hello World')\n```",
+                "```python\nprint('Hello World')\n```",
+                "```python \"Example code\"\nprint('Hello World')\n```",
+                "```javascript\nconsole.log('Hello');\n```",
+            ],
+            usage_guidelines="Use for displaying code snippets. Language specification enables syntax highlighting. Caption in quotes on first line provides description. Supports many programming languages.",
+        )

notionary/blocks/code/code_markdown_node.py

@@ -9,6 +9,8 @@ from notionary.markdown.markdown_node import MarkdownNode
 class CodeMarkdownNode(MarkdownNode):
     """
     Programmatic interface for creating Notion-style Markdown code blocks.
+    Automatically handles indentation normalization for multiline strings.
+
     Example:
         ```python "Basic usage"
         print("Hello, world!")
@@ -39,5 +41,54 @@ class CodeMarkdownNode(MarkdownNode):
         if self.caption:
             opening_fence += f' "{self.caption}"'
 
-        content = f"{opening_fence}\n{self.code}\n```"
+        # Smart indentation normalization
+        normalized_code = self._normalize_indentation(self.code)
+
+        content = f"{opening_fence}\n{normalized_code}\n```"
         return content
+
+    def _normalize_indentation(self, code: str) -> str:
+        """Normalize indentation by removing common leading whitespace."""
+        lines = code.strip().split("\n")
+
+        if self._is_empty_or_single_line(lines):
+            return self._handle_simple_cases(lines)
+
+        min_indentation = self._find_minimum_indentation_excluding_first_line(lines)
+        return self._remove_common_indentation(lines, min_indentation)
+
+    def _is_empty_or_single_line(self, lines: list[str]) -> bool:
+        return not lines or len(lines) == 1
+
+    def _handle_simple_cases(self, lines: list[str]) -> str:
+        if not lines:
+            return ""
+        return lines[0].strip()
+
+    def _find_minimum_indentation_excluding_first_line(self, lines: list[str]) -> int:
+        non_empty_lines_after_first = [line for line in lines[1:] if line.strip()]
+
+        if not non_empty_lines_after_first:
+            return 0
+
+        return min(
+            len(line) - len(line.lstrip()) for line in non_empty_lines_after_first
+        )
+
+    def _remove_common_indentation(self, lines: list[str], min_indentation: int) -> str:
+        normalized_lines = [lines[0].strip()]
+
+        for line in lines[1:]:
+            normalized_line = self._normalize_single_line(line, min_indentation)
+            normalized_lines.append(normalized_line)
+
+        return "\n".join(normalized_lines)
+
+    def _normalize_single_line(self, line: str, min_indentation: int) -> str:
+        if not line.strip():
+            return ""
+
+        if len(line) > min_indentation:
+            return line[min_indentation:]
+
+        return line.strip()

notionary/blocks/column/column_element.py

@@ -1,10 +1,11 @@
 from __future__ import annotations
 
 import re
-from turtle import width
+from typing import Optional
 
 from notionary.blocks.base_block_element import BaseBlockElement
 from notionary.blocks.column.column_models import ColumnBlock, CreateColumnBlock
+from notionary.blocks.syntax_prompt_builder import BlockElementMarkdownInformation
 from notionary.blocks.models import Block, BlockCreateResult, BlockType
 
 
@@ -27,7 +28,7 @@ class ColumnElement(BaseBlockElement):
         return block.type == BlockType.COLUMN and block.column
 
     @classmethod
-    def markdown_to_notion(cls, text: str) -> BlockCreateResult:
+    async def markdown_to_notion(cls, text: str) -> BlockCreateResult:
         """Convert `::: column [ratio]` to Notion ColumnBlock."""
         if not (match := cls.COLUMN_START.match(text.strip())):
             return None
@@ -48,7 +49,7 @@ class ColumnElement(BaseBlockElement):
         return CreateColumnBlock(column=column_content)
 
     @classmethod
-    def notion_to_markdown(cls, block: Block) -> str:
+    async def notion_to_markdown(cls, block: Block) -> str:
         """Convert Notion column to markdown."""
         if not cls.match_notion(block):
             return ""
@@ -57,3 +58,8 @@ class ColumnElement(BaseBlockElement):
             return "::: column"
 
         return f"::: column {block.column.width_ratio}"
+
+    @classmethod
+    def get_system_prompt_information(cls) -> Optional[BlockElementMarkdownInformation]:
+        """Column elements are documented via ColumnListElement - return None to avoid duplication."""
+        return None

notionary/blocks/column/column_list_element.py

@@ -1,9 +1,9 @@
-from __future__ import annotations
-
+from typing import Optional
 import re
 
 from notionary.blocks.base_block_element import BaseBlockElement
 from notionary.blocks.column.column_models import ColumnListBlock, CreateColumnListBlock
+from notionary.blocks.syntax_prompt_builder import BlockElementMarkdownInformation
 from notionary.blocks.models import Block, BlockCreateResult
 from notionary.blocks.types import BlockType
 
@@ -27,7 +27,7 @@ class ColumnListElement(BaseBlockElement):
         return block.type == BlockType.COLUMN_LIST and block.column_list
 
     @classmethod
-    def markdown_to_notion(cls, text: str) -> BlockCreateResult:
+    async def markdown_to_notion(cls, text: str) -> BlockCreateResult:
         """Convert `::: columns` to Notion ColumnListBlock."""
         if not cls.COLUMNS_START.match(text.strip()):
             return None
@@ -35,3 +35,18 @@ class ColumnListElement(BaseBlockElement):
         # Empty ColumnListBlock - children (columns) added by stack processor
         column_list_content = ColumnListBlock()
         return CreateColumnListBlock(column_list=column_list_content)
+
+    @classmethod
+    @classmethod
+    def get_system_prompt_information(cls) -> Optional[BlockElementMarkdownInformation]:
+        """Get system prompt information for column list blocks."""
+        return BlockElementMarkdownInformation(
+            block_type=cls.__name__,
+            description="Column list containers organize multiple columns in side-by-side layouts",
+            syntax_examples=[
+                "::: columns\n::: column\nContent 1\n:::\n::: column\nContent 2\n:::\n:::",
+                "::: columns\n::: column 0.6\nMain content\n:::\n::: column 0.4\nSidebar\n:::\n:::",
+                "::: columns\n::: column 0.25\nLeft\n:::\n::: column 0.5\nCenter\n:::\n::: column 0.25\nRight\n:::\n:::",
+            ],
+            usage_guidelines="Use to create multi-column layouts with at least 2 columns. Column width ratios must add up to 1.0 when specified. Each column can contain any block content. Ends with :::.",
+        )

notionary/blocks/divider/divider_element.py

@@ -6,10 +6,6 @@ from typing import Optional
 from notionary.blocks.base_block_element import BaseBlockElement
 from notionary.blocks.divider.divider_models import CreateDividerBlock, DividerBlock
 from notionary.blocks.models import Block, BlockCreateResult
-from notionary.blocks.paragraph.paragraph_models import (
-    CreateParagraphBlock,
-    ParagraphBlock,
-)
 from notionary.blocks.types import BlockType
 
 
@@ -29,21 +25,17 @@ class DividerElement(BaseBlockElement):
         return block.type == BlockType.DIVIDER and block.divider
 
     @classmethod
-    def markdown_to_notion(cls, text: str) -> BlockCreateResult:
+    async def markdown_to_notion(cls, text: str) -> BlockCreateResult:
         """Convert markdown horizontal rule to Notion divider, with preceding empty paragraph."""
         if not cls.PATTERN.match(text.strip()):
             return None
 
-        empty_para = ParagraphBlock(rich_text=[])
         divider = DividerBlock()
 
-        return [
-            CreateParagraphBlock(paragraph=empty_para),
-            CreateDividerBlock(divider=divider),
-        ]
+        return CreateDividerBlock(divider=divider)
 
     @classmethod
-    def notion_to_markdown(cls, block: Block) -> Optional[str]:
+    async def notion_to_markdown(cls, block: Block) -> Optional[str]:
         if block.type != BlockType.DIVIDER or not block.divider:
             return None
         return "---"

notionary/blocks/embed/embed_element.py

@@ -10,6 +10,7 @@ from notionary.blocks.file.file_element_models import (
     FileUploadFile,
     NotionHostedFile,
 )
+from notionary.blocks.syntax_prompt_builder import BlockElementMarkdownInformation
 from notionary.blocks.models import Block, BlockCreateResult, BlockType
 from notionary.blocks.rich_text.rich_text_models import RichTextObject
 from notionary.blocks.rich_text.text_inline_formatter import TextInlineFormatter
@@ -36,7 +37,7 @@ class EmbedElement(BaseBlockElement):
         return block.type == BlockType.EMBED and block.embed
 
     @classmethod
-    def markdown_to_notion(cls, text: str) -> BlockCreateResult:
+    async def markdown_to_notion(cls, text: str) -> BlockCreateResult:
         """Convert markdown embed syntax to Notion EmbedBlock."""
         match = cls.PATTERN.match(text.strip())
         if not match:
@@ -53,7 +54,7 @@ class EmbedElement(BaseBlockElement):
         return CreateEmbedBlock(embed=embed_block)
 
     @classmethod
-    def notion_to_markdown(cls, block: Block) -> Optional[str]:
+    async def notion_to_markdown(cls, block: Block) -> Optional[str]:
         if block.type != BlockType.EMBED or not block.embed:
             return None
 
@@ -69,9 +70,29 @@ class EmbedElement(BaseBlockElement):
         if not fo.caption:
             return f"[embed]({url})"
 
-        text = "".join(
-            rt.plain_text or TextInlineFormatter.extract_text_with_formatting([rt])
-            for rt in fo.caption
-        )
+        text_parts = []
+        for rt in fo.caption:
+            if rt.plain_text:
+                text_parts.append(rt.plain_text)
+            else:
+                formatted_text = await TextInlineFormatter.extract_text_with_formatting(
+                    [rt]
+                )
+                text_parts.append(formatted_text)
+        text = "".join(text_parts)
 
         return f'[embed]({url} "{text}")'
+
+    @classmethod
+    def get_system_prompt_information(cls) -> Optional[BlockElementMarkdownInformation]:
+        """Get system prompt information for embed blocks."""
+        return BlockElementMarkdownInformation(
+            block_type=cls.__name__,
+            description="Embed blocks display interactive content from external URLs like videos, maps, or widgets",
+            syntax_examples=[
+                "[embed](https://youtube.com/watch?v=123)",
+                '[embed](https://maps.google.com/location "Map Location")',
+                '[embed](https://codepen.io/pen/123 "Interactive Demo")',
+            ],
+            usage_guidelines="Use for embedding interactive content that supports iframe embedding. URL must be from a supported platform. Caption describes the embedded content.",
+        )

notionary/blocks/equation/equation_element.py

@@ -1,70 +1,113 @@
 from __future__ import annotations
 
 import re
+import textwrap
 from typing import Optional
 
 from notionary.blocks.base_block_element import BaseBlockElement
 from notionary.blocks.equation.equation_models import CreateEquationBlock, EquationBlock
+from notionary.blocks.syntax_prompt_builder import BlockElementMarkdownInformation
 from notionary.blocks.models import Block, BlockCreateResult
 from notionary.blocks.types import BlockType
 
 
 class EquationElement(BaseBlockElement):
     """
-    Only supports bracket style (analog zu [video]):
+    Supports standard Markdown equation syntax:
 
-      - [equation](E = mc^2)                    # unquoted: keine ')' oder Newlines
-      - [equation]("E = mc^2 + \\frac{a}{b}")   # quoted: erlaubt ')' & Newlines & \"
+      - $$E = mc^2$$                           # simple equations
+      - $$E = mc^2 + \\frac{a}{b}$$           # complex equations with LaTeX
 
-    No $$...$$ parsing.
+    Uses $$...$$ parsing for block equations.
     """
 
-    _QUOTED_PATTERN = re.compile(
-        r'^\[equation\]\(\s*"(?P<quoted_expr>(?:[^"\\]|\\.)*)"\s*\)$',
+    _EQUATION_PATTERN = re.compile(
+        r"^\$\$\s*(?P<expression>.*?)\s*\$\$$",
         re.DOTALL,
     )
 
-    _UNQUOTED_PATTERN = re.compile(
-        r"^\[equation\]\(\s*(?P<unquoted_expr>[^)\r\n]+?)\s*\)$"
-    )
-
     @classmethod
     def match_notion(cls, block: Block) -> bool:
         return block.type == BlockType.EQUATION and block.equation
 
     @classmethod
-    def markdown_to_notion(cls, text: str) -> BlockCreateResult:
+    async def markdown_to_notion(cls, text: str) -> BlockCreateResult:
         input_text = text.strip()
 
-        # Try quoted form first: [equation]("...")
-        if quoted_match := cls._QUOTED_PATTERN.match(input_text):
-            raw_expression = quoted_match.group("quoted_expr")
-            # Unescape \" and \\ for Notion
-            unescaped_expression = raw_expression.encode("utf-8").decode(
-                "unicode_escape"
-            )
-            unescaped_expression = unescaped_expression.replace('\\"', '"')
-            final_expression = unescaped_expression.strip()
-
-            return (
-                CreateEquationBlock(equation=EquationBlock(expression=final_expression))
-                if final_expression
-                else None
-            )
-
-        # Try unquoted form: [equation](...)
-        if unquoted_match := cls._UNQUOTED_PATTERN.match(input_text):
-            raw_expression = unquoted_match.group("unquoted_expr").strip()
-            return (
-                CreateEquationBlock(equation=EquationBlock(expression=raw_expression))
-                if raw_expression
-                else None
-            )
+        equation_match = cls._EQUATION_PATTERN.match(input_text)
+        if not equation_match:
+            return None
+
+        expression = equation_match.group("expression").strip()
+        if not expression:
+            return None
+
+        return CreateEquationBlock(equation=EquationBlock(expression=expression))
+
+    @classmethod
+    def create_from_markdown_block(
+        cls, opening_line: str, equation_lines: list[str]
+    ) -> BlockCreateResult:
+        """
+        Create a complete equation block from markdown components.
+        Handles multiline equations like:
+        $$
+        some
+        inline formula here
+        $$
+
+        Automatically handles:
+        - Indentation removal from multiline strings
+        - Single backslash conversion to double backslash for LaTeX line breaks
+        """
+        # Check if opening line is just $$
+        if opening_line.strip() != "$$":
+            return None
+
+        # Process equation lines if any exist
+        if equation_lines:
+            # Remove common indentation from all lines
+            raw_content = "\n".join(equation_lines)
+            dedented_content = textwrap.dedent(raw_content)
+
+            # Fix single backslashes at line ends for LaTeX line breaks
+            fixed_lines = cls._fix_latex_line_breaks(dedented_content.splitlines())
+            expression = "\n".join(fixed_lines).strip()
+
+            if expression:
+                return CreateEquationBlock(
+                    equation=EquationBlock(expression=expression)
+                )
 
         return None
 
     @classmethod
-    def notion_to_markdown(cls, block: Block) -> Optional[str]:
+    def _fix_latex_line_breaks(cls, lines: list[str]) -> list[str]:
+        """
+        Fix lines that end with single backslashes by converting them to double backslashes.
+        This makes LaTeX line breaks work correctly when users write single backslashes.
+
+        Examples:
+        - "a = b + c \" -> "a = b + c \\"
+        - "a = b + c \\\\" -> "a = b + c \\\\" (unchanged)
+        """
+        fixed_lines = []
+
+        for line in lines:
+            # Check if line ends with backslashes
+            backslash_match = re.search(r"(\\+)$", line)
+            if backslash_match:
+                backslashes = backslash_match.group(1)
+                # If odd number of backslashes, the last one needs to be doubled
+                if len(backslashes) % 2 == 1:
+                    line = line + "\\"
+
+            fixed_lines.append(line)
+
+        return fixed_lines
+
+    @classmethod
+    async def notion_to_markdown(cls, block: Block) -> Optional[str]:
         if block.type != BlockType.EQUATION or not block.equation:
             return None
 
@@ -72,9 +115,19 @@ class EquationElement(BaseBlockElement):
         if not expression:
             return None
 
-        # Use quoted form if expression contains risky characters
-        if ("\n" in expression) or (")" in expression) or ('"' in expression):
-            escaped_expression = expression.replace("\\", "\\\\").replace('"', r"\"")
-            return f'[equation]("{escaped_expression}")'
+        return f"$${expression}$$"
 
-        return f"[equation]({expression})"
+    @classmethod
+    def get_system_prompt_information(cls) -> Optional[BlockElementMarkdownInformation]:
+        """Get system prompt information for equation blocks."""
+        return BlockElementMarkdownInformation(
+            block_type=cls.__name__,
+            description="Mathematical equations using standard Markdown LaTeX syntax",
+            syntax_examples=[
+                "$$E = mc^2$$",
+                "$$\\frac{a}{b} + \\sqrt{c}$$",
+                "$$\\int_0^\\infty e^{-x} dx = 1$$",
+                "$$\\sum_{i=1}^n i = \\frac{n(n+1)}{2}$$",
+            ],
+            usage_guidelines="Use for mathematical expressions and formulas. Supports LaTeX syntax. Wrap equations in double dollar signs ($$).",
+        )

notionary/blocks/equation/equation_element_markdown_node.py

@@ -12,9 +12,12 @@ class EquationMarkdownBlockParams(BaseModel):
 class EquationMarkdownNode(MarkdownNode):
     """
     Programmatic interface for creating Markdown equation blocks.
-    Example:
-    [equation](E = mc^2)
-    [equation]("f(x) = \\sin(x) + \\cos(x)")
+    Uses standard Markdown equation syntax with double dollar signs.
+
+    Examples:
+    $$E = mc^2$$
+    $$\\frac{a}{b} + \\sqrt{c}$$
+    $$\\int_0^\\infty e^{-x} dx = 1$$
     """
 
     def __init__(self, expression: str):
@@ -27,10 +30,6 @@ class EquationMarkdownNode(MarkdownNode):
     def to_markdown(self) -> str:
         expr = self.expression.strip()
         if not expr:
-            return "[equation]()"
-
-        if ("\n" in expr) or (")" in expr) or ('"' in expr):
-            escaped = expr.replace("\\", "\\\\").replace('"', r"\"")
-            return f'[equation]("{escaped}")'
+            return "$$$$"
 
-        return f"[equation]({expr})"
+        return f"$${expr}$$"