notionary 0.2.17__py3-none-any.whl → 0.2.19__py3-none-any.whl

notionary/blocks/{notion_block_element.py → shared/notion_block_element.py}

@@ -1,18 +1,21 @@
-from typing import Dict, Any, Optional
+from typing import Optional, Any, TypeAlias, Union
 from abc import ABC
 
 from notionary.blocks.prompts.element_prompt_content import ElementPromptContent
 
+NotionBlock: TypeAlias = dict[str, Any]
+NotionBlockResult: TypeAlias = Optional[Union[list[dict[str, Any]], dict[str, Any]]]
+
 
 class NotionBlockElement(ABC):
     """Base class for elements that can be converted between Markdown and Notion."""
 
     @classmethod
-    def markdown_to_notion(cls, text: str) -> Optional[Dict[str, Any]]:
-        """Convert markdown to Notion block."""
+    def markdown_to_notion(cls, text: str) -> NotionBlockResult:
+        """Convert markdown to Notion blocks (can return multiple blocks or single block)."""
 
     @classmethod
-    def notion_to_markdown(cls, block: Dict[str, Any]) -> Optional[str]:
+    def notion_to_markdown(cls, block: dict[str, any]) -> Optional[str]:
         """Convert Notion block to markdown."""
 
     @classmethod
@@ -21,7 +24,7 @@ class NotionBlockElement(ABC):
         return bool(cls.markdown_to_notion(text))  # Now calls the class's version
 
     @classmethod
-    def match_notion(cls, block: Dict[str, Any]) -> bool:
+    def match_notion(cls, block: dict[str, any]) -> bool:
         """Check if this element can handle the given Notion block."""
         return bool(cls.notion_to_markdown(block))  # Now calls the class's version
 

notionary/blocks/{text_inline_formatter.py → shared/text_inline_formatter.py}

@@ -1,4 +1,4 @@
-from typing import Dict, Any, List, Tuple
+from typing import Any
 import re
 
 from notionary.blocks import ElementPromptBuilder, ElementPromptContent
@@ -30,7 +30,7 @@ class TextInlineFormatter:
     ]
 
     @classmethod
-    def parse_inline_formatting(cls, text: str) -> List[Dict[str, Any]]:
+    def parse_inline_formatting(cls, text: str) -> list[dict[str, Any]]:
         """
         Parse inline text formatting into Notion rich_text format.
 
@@ -38,7 +38,7 @@ class TextInlineFormatter:
             text: Markdown text with inline formatting
 
         Returns:
-            List of Notion rich_text objects
+            list of Notion rich_text objects
         """
         if not text:
             return []
@@ -47,17 +47,17 @@ class TextInlineFormatter:
 
     @classmethod
     def _split_text_into_segments(
-        cls, text: str, format_patterns: List[Tuple]
-    ) -> List[Dict[str, Any]]:
+        cls, text: str, format_patterns: list[tuple]
+    ) -> list[dict[str, Any]]:
         """
         Split text into segments by formatting markers and convert to Notion rich_text format.
 
         Args:
             text: Text to split
-            format_patterns: List of (regex pattern, formatting dict) tuples
+            format_patterns: list of (regex pattern, formatting dict) tuples
 
         Returns:
-            List of Notion rich_text objects
+            list of Notion rich_text objects
         """
         segments = []
         remaining_text = text
@@ -107,8 +107,8 @@ class TextInlineFormatter:
 
     @classmethod
     def _create_text_element(
-        cls, text: str, formatting: Dict[str, Any]
-    ) -> Dict[str, Any]:
+        cls, text: str, formatting: dict[str, Any]
+    ) -> dict[str, Any]:
         """
         Create a Notion text element with formatting.
 
@@ -136,7 +136,7 @@ class TextInlineFormatter:
         }
 
     @classmethod
-    def _create_link_element(cls, text: str, url: str) -> Dict[str, Any]:
+    def _create_link_element(cls, text: str, url: str) -> dict[str, Any]:
         """
         Create a Notion link element.
 
@@ -155,7 +155,7 @@ class TextInlineFormatter:
         }
 
     @classmethod
-    def _create_mention_element(cls, id: str) -> Dict[str, Any]:
+    def _create_mention_element(cls, id: str) -> dict[str, Any]:
         """
         Create a Notion mention element.
 
@@ -172,12 +172,12 @@ class TextInlineFormatter:
         }
 
     @classmethod
-    def extract_text_with_formatting(cls, rich_text: List[Dict[str, Any]]) -> str:
+    def extract_text_with_formatting(cls, rich_text: list[dict[str, Any]]) -> str:
         """
         Convert Notion rich_text elements back to Markdown formatted text.
 
         Args:
-            rich_text: List of Notion rich_text elements
+            rich_text: list of Notion rich_text elements
 
         Returns:
             Markdown formatted text
@@ -214,7 +214,7 @@ class TextInlineFormatter:
         return "".join(formatted_parts)
 
     @classmethod
-    def _default_annotations(cls) -> Dict[str, bool]:
+    def _default_annotations(cls) -> dict[str, bool]:
         """
         Create default annotations object.
 

notionary/blocks/shared/text_inline_formatter_new.py

@@ -0,0 +1,139 @@
+from typing import Optional
+import re
+
+# TODO: Use this inline formatting here
+from notionary.blocks.shared.models import (
+    MentionRichText,
+    RichTextObject,
+    TextAnnotations,
+    TextContent,
+)
+
+FORMAT_PATTERNS = [
+    (r"\*\*(.+?)\*\*", {"bold": True}),
+    (r"\*(.+?)\*", {"italic": True}),
+    (r"_(.+?)_", {"italic": True}),
+    (r"__(.+?)__", {"underline": True}),
+    (r"~~(.+?)~~", {"strikethrough": True}),
+    (r"`(.+?)`", {"code": True}),
+    (r"\[(.+?)\]\((.+?)\)", {"link": True}),
+    (r"@\[([0-9a-f-]+)\]", {"mention": True}),
+]
+
+
+def parse_inline_formatting(text: str) -> list[dict[str, any]]:
+    """Parse inline text formatting into Notion rich_text format."""
+    if not text:
+        return []
+
+    return _split_text_into_segments(text)
+
+
+def _split_text_into_segments(text: str) -> list[dict[str, any]]:
+    """Split text into segments by formatting markers."""
+    segments = []
+    remaining_text = text
+
+    while remaining_text:
+        match_info = _find_earliest_match(remaining_text)
+
+        # No more formatting found - add remaining text and exit
+        if not match_info:
+            segments.append(_create_plain_text(remaining_text))
+            break
+
+        match, formatting, pos = match_info
+
+        # Add text before match if exists
+        if pos > 0:
+            segments.append(_create_plain_text(remaining_text[:pos]))
+
+        # Add formatted segment
+        segments.append(_create_formatted_segment(match, formatting))
+
+        # Update remaining text
+        remaining_text = remaining_text[pos + len(match.group(0)) :]
+
+    return segments
+
+
+def _find_earliest_match(text: str) -> Optional[tuple]:
+    """Find the earliest formatting match in text."""
+    earliest_match = None
+    earliest_format = None
+    earliest_pos = len(text)
+
+    for pattern, formatting in FORMAT_PATTERNS:
+        match = re.search(pattern, text)
+        if match and match.start() < earliest_pos:
+            earliest_match = match
+            earliest_format = formatting
+            earliest_pos = match.start()
+
+    return (earliest_match, earliest_format, earliest_pos) if earliest_match else None
+
+
+def _create_formatted_segment(match: re.Match, formatting: dict) -> dict[str, any]:
+    """Create a formatted segment based on match and formatting."""
+    if "link" in formatting:
+        return _create_link_text(match.group(1), match.group(2))
+    elif "mention" in formatting:
+        return _create_mention_text(match.group(1))
+    else:
+        return _create_formatted_text(match.group(1), **formatting)
+
+
+def _create_plain_text(content: str) -> dict[str, any]:
+    """Create plain text rich text object."""
+    return RichTextObject.from_plain_text(content).model_dump()
+
+
+def _create_formatted_text(content: str, **formatting) -> dict[str, any]:
+    """Create formatted text rich text object."""
+    return RichTextObject.from_plain_text(content, **formatting).model_dump()
+
+
+def _create_link_text(content: str, url: str) -> dict[str, any]:
+    """Create link text rich text object."""
+    text_content = TextContent(content=content, link=url)
+    annotations = TextAnnotations()
+
+    rich_text = RichTextObject(
+        text=text_content, annotations=annotations, plain_text=content, href=url
+    )
+    return rich_text.model_dump()
+
+
+def _create_mention_text(page_id: str) -> dict[str, any]:
+    """Create mention rich text object."""
+    return MentionRichText.from_page_id(page_id).model_dump()
+
+
+def extract_text_with_formatting(rich_text: list[dict[str, any]]) -> str:
+    """Convert Notion rich_text elements back to Markdown."""
+    return "".join(_rich_text_to_markdown(item) for item in rich_text)
+
+
+def _rich_text_to_markdown(text_obj: dict[str, any]) -> str:
+    """Convert single rich text object to markdown."""
+    content = text_obj.get("plain_text", text_obj.get("text", {}).get("content", ""))
+    annotations = text_obj.get("annotations", {})
+
+    # Apply formatting in reverse order
+    if annotations.get("code", False):
+        content = f"`{content}`"
+    if annotations.get("strikethrough", False):
+        content = f"~~{content}~~"
+    if annotations.get("underline", False):
+        content = f"__{content}__"
+    if annotations.get("italic", False):
+        content = f"*{content}*"
+    if annotations.get("bold", False):
+        content = f"**{content}**"
+
+    # Handle links
+    link_data = text_obj.get("text", {}).get("link")
+    if link_data and link_data.get("url"):
+        content = f"[{content}]({link_data['url']})"
+
+    return content

notionary/blocks/table/__init__.py

@@ -0,0 +1,7 @@
+from .table_element import TableElement
+from .table_markdown_node import TableMarkdownNode
+
+__all__ = [
+    "TableElement",
+    "TableMarkdownNode",
+]

notionary/blocks/{table_element.py → table/table_element.py}

@@ -1,9 +1,13 @@
 import re
 from typing import Dict, Any, Optional, List, Tuple
 
-from notionary.blocks import NotionBlockElement
-from notionary.blocks.text_inline_formatter import TextInlineFormatter
-from notionary.blocks import ElementPromptContent, ElementPromptBuilder
+from notionary.blocks import (
+    NotionBlockElement,
+    NotionBlockResult,
+    ElementPromptContent,
+    ElementPromptBuilder,
+)
+from notionary.blocks.shared.text_inline_formatter import TextInlineFormatter
 
 
 class TableElement(NotionBlockElement):
@@ -24,17 +28,20 @@ class TableElement(NotionBlockElement):
 
     @classmethod
     def match_markdown(cls, text: str) -> bool:
-        """Check if text contains a markdown table."""
+        """
+        Check if text contains a markdown table.
+        Accepts tables with only header + separator, as well as header + separator + data rows.
+        """
         lines = text.split("\n")
 
-        if len(lines) < 3:
+        if len(lines) < 2:
             return False
 
-        for i, line in enumerate(lines[:-2]):
+        # Akzeptiere Header + Separator auch ohne Datenzeile
+        for i, line in enumerate(lines[:-1]):
             if (
-                TableElement.ROW_PATTERN.match(line)
-                and TableElement.SEPARATOR_PATTERN.match(lines[i + 1])
-                and TableElement.ROW_PATTERN.match(lines[i + 2])
+                cls.ROW_PATTERN.match(line)
+                and cls.SEPARATOR_PATTERN.match(lines[i + 1])
             ):
                 return True
 
@@ -46,7 +53,7 @@ class TableElement(NotionBlockElement):
         return block.get("type") == "table"
 
     @classmethod
-    def markdown_to_notion(cls, text: str) -> Optional[Dict[str, Any]]:
+    def markdown_to_notion(cls, text: str) -> NotionBlockResult:
         """Convert markdown table to Notion table block."""
         if not TableElement.match_markdown(text):
             return None
@@ -67,7 +74,7 @@ class TableElement(NotionBlockElement):
         column_count = len(rows[0])
         TableElement._normalize_row_lengths(rows, column_count)
 
-        return {
+        table_block = {
             "type": "table",
             "table": {
                 "table_width": column_count,
@@ -77,6 +84,11 @@ class TableElement(NotionBlockElement):
             },
         }
 
+        # Leerer Paragraph nach der Tabelle
+        empty_paragraph = {"type": "paragraph", "paragraph": {"rich_text": []}}
+
+        return [table_block, empty_paragraph]
+
     @classmethod
     def notion_to_markdown(cls, block: Dict[str, Any]) -> Optional[str]:
         """Convert Notion table block to markdown table."""

notionary/blocks/table/table_markdown_node.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+from notionary.blocks.markdown_node import MarkdownNode
+
+
+class TableMarkdownBlockParams(BaseModel):
+    headers: list[str]
+    rows: list[list[str]]
+
+
+class TableMarkdownNode(MarkdownNode):
+    """
+    Programmatic interface for creating Markdown tables.
+    Example:
+        | Header 1 | Header 2 | Header 3 |
+        | -------- | -------- | -------- |
+        | Cell 1   | Cell 2   | Cell 3   |
+        | Cell 4   | Cell 5   | Cell 6   |
+    """
+
+    def __init__(self, headers: list[str], rows: list[list[str]]):
+        if not headers or not all(isinstance(row, list) for row in rows):
+            raise ValueError("headers must be a list and rows must be a list of lists")
+        self.headers = headers
+        self.rows = rows
+
+    @classmethod
+    def from_params(cls, params: TableMarkdownBlockParams) -> TableMarkdownNode:
+        return cls(headers=params.headers, rows=params.rows)
+
+    def to_markdown(self) -> str:
+        col_count = len(self.headers)
+        # Header row
+        header = "| " + " | ".join(self.headers) + " |"
+        # Separator row
+        separator = "| " + " | ".join(["--------"] * col_count) + " |"
+        # Data rows
+        data_rows = ["| " + " | ".join(row) + " |" for row in self.rows]
+        return "\n".join([header, separator] + data_rows)

notionary/blocks/todo/__init__.py

@@ -0,0 +1,7 @@
+from .todo_element import TodoElement
+from .todo_markdown_node import TodoMarkdownNode
+
+__all__ = [
+    "TodoElement",
+    "TodoMarkdownNode",
+]

notionary/blocks/{todo_element.py → todo/todo_element.py}

@@ -1,9 +1,13 @@
 import re
 from typing import Dict, Any, Optional
 
-from notionary.blocks import NotionBlockElement
-from notionary.blocks import ElementPromptContent, ElementPromptBuilder
-from notionary.blocks.text_inline_formatter import TextInlineFormatter
+from notionary.blocks import (
+    ElementPromptContent,
+    ElementPromptBuilder,
+    NotionBlockResult,
+    NotionBlockElement,
+)
+from notionary.blocks.shared.text_inline_formatter import TextInlineFormatter
 
 
 class TodoElement(NotionBlockElement):
@@ -34,7 +38,7 @@ class TodoElement(NotionBlockElement):
         return block.get("type") == "to_do"
 
     @classmethod
-    def markdown_to_notion(cls, text: str) -> Optional[Dict[str, Any]]:
+    def markdown_to_notion(cls, text: str) -> NotionBlockResult:
         """Convert markdown todo item to Notion to_do block."""
         done_match = TodoElement.DONE_PATTERN.match(text)
         if done_match:

notionary/blocks/todo/todo_markdown_node.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+from notionary.blocks.markdown_node import MarkdownNode
+
+
+class TodoMarkdownBlockParams(BaseModel):
+    text: str
+    checked: bool = False
+    marker: str = "-"
+
+
+class TodoMarkdownNode(MarkdownNode):
+    """
+    Programmatic interface for creating Markdown todo items (checkboxes).
+    Supports checked and unchecked states.
+    Example: - [ ] Task, - [x] Done
+    """
+
+    def __init__(self, text: str, checked: bool = False, marker: str = "-"):
+        self.text = text
+        self.checked = checked
+        self.marker = marker if marker in {"-", "*", "+"} else "-"
+
+    @classmethod
+    def from_params(cls, params: TodoMarkdownBlockParams) -> TodoMarkdownNode:
+        return cls(text=params.text, checked=params.checked, marker=params.marker)
+
+    def to_markdown(self) -> str:
+        checkbox = "[x]" if self.checked else "[ ]"
+        return f"{self.marker} {checkbox} {self.text}"

notionary/blocks/toggle/__init__.py

@@ -0,0 +1,4 @@
+from .toggle_element import ToggleElement
+from .toggle_markdown_node import ToggleMarkdownNode, ToggleMarkdownBlockParams
+
+__all__ = ["ToggleElement", "ToggleMarkdownNode", "ToggleMarkdownBlockParams"]

notionary/blocks/{toggle_element.py → toggle/toggle_element.py}

@@ -1,8 +1,12 @@
 import re
 from typing import Dict, Any, Optional, List, Tuple, Callable
 
-from notionary.blocks import NotionBlockElement
-from notionary.blocks import ElementPromptContent, ElementPromptBuilder
+from notionary.blocks import (
+    NotionBlockElement,
+    NotionBlockResult,
+    ElementPromptContent,
+    ElementPromptBuilder,
+)
 
 
 class ToggleElement(NotionBlockElement):
@@ -26,7 +30,7 @@ class ToggleElement(NotionBlockElement):
         return block.get("type") == "toggle"
 
     @classmethod
-    def markdown_to_notion(cls, text: str) -> Optional[Dict[str, Any]]:
+    def markdown_to_notion(cls, text: str) -> NotionBlockResult:
         """Convert markdown toggle line to Notion toggle block."""
         toggle_match = ToggleElement.TOGGLE_PATTERN.match(text.strip())
         if not toggle_match:

notionary/blocks/toggle/toggle_markdown_node.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from typing import Optional, List
+from pydantic import BaseModel
+from notionary.blocks.markdown_node import MarkdownNode
+
+
+class ToggleMarkdownBlockParams(BaseModel):
+    title: str
+    content: Optional[List[str]] = None
+
+
+class ToggleMarkdownNode(MarkdownNode):
+    """
+    Programmatic interface for creating Notion-style Markdown toggle blocks
+    with pipe-prefixed nested content.
+    Example:
+        +++ Details
+        | Here are the details.
+        | You can add more lines.
+    """
+
+    def __init__(self, title: str, content: Optional[List[str]] = None):
+        self.title = title
+        self.content = content or []
+
+    @classmethod
+    def from_params(cls, params: ToggleMarkdownBlockParams) -> ToggleMarkdownNode:
+        return cls(title=params.title, content=params.content)
+
+    def to_markdown(self) -> str:
+        result = f"+++ {self.title}"
+        if self.content:
+            result += "\n" + "\n".join([f"| {line}" for line in self.content])
+        return result

notionary/blocks/toggleable_heading/__init__.py

@@ -0,0 +1,9 @@
+from .toggleable_heading_element import ToggleableHeadingElement
+from .toggleable_heading_markdown_node import (
+    ToggleableHeadingMarkdownNode,
+)
+
+__all__ = [
+    "ToggleableHeadingElement",
+    "ToggleableHeadingMarkdownNode",
+]

notionary/blocks/{toggleable_heading_element.py → toggleable_heading/toggleable_heading_element.py}

@@ -1,9 +1,13 @@
 import re
 from typing import Dict, Any, Optional, List, Tuple, Callable
 
-from notionary.blocks import NotionBlockElement
-from notionary.blocks import ElementPromptContent, ElementPromptBuilder
-from notionary.blocks.text_inline_formatter import TextInlineFormatter
+from notionary.blocks import (
+    ElementPromptContent,
+    ElementPromptBuilder,
+    NotionBlockElement,
+    NotionBlockResult,
+)
+from notionary.blocks.shared.text_inline_formatter import TextInlineFormatter
 
 
 class ToggleableHeadingElement(NotionBlockElement):
@@ -29,7 +33,7 @@ class ToggleableHeadingElement(NotionBlockElement):
         return heading_data.get("is_toggleable", False) is True
 
     @staticmethod
-    def markdown_to_notion(text: str) -> Optional[Dict[str, Any]]:
+    def markdown_to_notion(text: str) -> NotionBlockResult:
         """Convert markdown collapsible heading to Notion toggleable heading block."""
         header_match = ToggleableHeadingElement.PATTERN.match(text)
         if not header_match:

notionary/blocks/toggleable_heading/toggleable_heading_markdown_node.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from typing import Optional, List
+from pydantic import BaseModel
+from notionary.blocks.markdown_node import MarkdownNode
+
+
+class ToggleableHeadingMarkdownBlockParams(BaseModel):
+    text: str
+    level: int = 1
+    content: Optional[List[str]] = None
+
+
+class ToggleableHeadingMarkdownNode(MarkdownNode):
+    """
+    Programmatic interface for creating collapsible Markdown headings (toggleable headings).
+    Pipe-prefixed lines are used for the collapsible content.
+    Example:
+        +# Section
+        | Hidden content
+        +## Subsection
+        | Details
+    """
+
+    def __init__(self, text: str, level: int = 1, content: Optional[list[str]] = None):
+        if not (1 <= level <= 3):
+            raise ValueError("Only heading levels 1-3 are supported (H1, H2, H3)")
+        self.text = text
+        self.level = level
+        self.content = content or []
+
+    @classmethod
+    def from_params(
+        cls, params: ToggleableHeadingMarkdownBlockParams
+    ) -> ToggleableHeadingMarkdownNode:
+        return cls(text=params.text, level=params.level, content=params.content)
+
+    def to_markdown(self) -> str:
+        prefix = "+" + ("#" * self.level)
+        result = f"{prefix} {self.text}"
+        if self.content:
+            result += "\n" + "\n".join([f"| {line}" for line in self.content])
+        return result

notionary/blocks/video/__init__.py

@@ -0,0 +1,7 @@
+from .video_element import VideoElement
+from .video_markdown_node import VideoMarkdownNode
+
+__all__ = [
+    "VideoElement",
+    "VideoMarkdownNode",
+]