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

notionary/blocks/column/column_element.py

@@ -1,333 +1,59 @@
+from __future__ import annotations
+
 import re
-from typing import Optional, Callable
+from turtle import width
 
-from notionary.blocks import NotionBlockElement
-from notionary.blocks import (
-    ElementPromptContent,
-    ElementPromptBuilder,
-    NotionBlockResult,
-)
+from notionary.blocks.base_block_element import BaseBlockElement
+from notionary.blocks.column.column_models import ColumnBlock, CreateColumnBlock
+from notionary.blocks.models import Block, BlockCreateResult, BlockType
 
 
-class ColumnElement(NotionBlockElement):
+class ColumnElement(BaseBlockElement):
     """
-    Handles conversion between custom Markdown column syntax and Notion column blocks.
-
-    Markdown column syntax:
-    ::: columns
-    ::: column
-    Content for first column
-    :::
-    ::: column
-    Content for second column
-    :::
-    :::
+    Handles individual `::: column` blocks with optional width ratio.
+    Content is automatically added by the stack processor.
 
-    This creates a column layout in Notion with the specified content in each column.
+    Supported syntax:
+    - `::: column` (equal width)
+    - `::: column 0.5` (50% width)
+    - `::: column 0.25` (25% width)
     """
 
-    COLUMNS_START = re.compile(r"^:::\s*columns\s*$")
-    COLUMN_START = re.compile(r"^:::\s*column\s*$")
-    BLOCK_END = re.compile(r"^:::\s*$")
-
-    _converter_callback = None
-
-    @classmethod
-    def set_converter_callback(
-        cls, callback: Callable[[str], list[dict[str, any]]]
-    ) -> None:
-        """
-        Setze die Callback-Funktion, die zum Konvertieren von Markdown zu Notion-Blöcken verwendet wird.
-
-        Args:
-            callback: Funktion, die Markdown-Text annimmt und eine Liste von Notion-Blöcken zurückgibt
-        """
-        cls._converter_callback = callback
-
-    @staticmethod
-    def match_markdown(text: str) -> bool:
-        """Check if text starts a columns block."""
-        return bool(ColumnElement.COLUMNS_START.match(text.strip()))
-
-    @staticmethod
-    def match_notion(block: dict[str, any]) -> bool:
-        """Check if block is a Notion column_list."""
-        return block.get("type") == "column_list"
-
-    @staticmethod
-    def markdown_to_notion(text: str) -> NotionBlockResult:
-        """
-        Convert markdown column syntax to Notion column blocks.
-
-        Note: This only processes the first line (columns start).
-        The full column content needs to be processed separately.
-        """
-        if not ColumnElement.COLUMNS_START.match(text.strip()):
-            return None
-
-        # Create an empty column_list block
-        # Child columns will be added by the column processor
-        return [{"type": "column_list", "column_list": {"children": []}}]
-
-    @staticmethod
-    def notion_to_markdown(block: dict[str, any]) -> Optional[str]:
-        """Convert Notion column_list block to markdown column syntax."""
-        if block.get("type") != "column_list":
-            return None
-
-        column_children = block.get("column_list", {}).get("children", [])
-
-        # Start the columns block
-        result = ["::: columns"]
-
-        # Process each column
-        for column_block in column_children:
-            if column_block.get("type") == "column":
-                result.append("::: column")
-
-            for _ in column_block.get("column", {}).get("children", []):
-                result.append("  [Column content]")  # Placeholder
-
-                result.append(":::")
-
-        # End the columns block
-        result.append(":::")
-
-        return "\n".join(result)
-
-    @staticmethod
-    def is_multiline() -> bool:
-        """Column blocks span multiple lines."""
-        return True
-
-    @classmethod
-    def find_matches(
-        cls, text: str, converter_callback: Optional[Callable] = None
-    ) -> list[tuple[int, int, dict[str, any]]]:
-        """
-        Find all column block matches in the text and return their positions and blocks.
-
-        Args:
-            text: The input markdown text
-            converter_callback: Optional callback to convert nested content
-
-        Returns:
-            List of tuples (start_pos, end_pos, block)
-        """
-        # Wenn ein Callback übergeben wurde, nutze diesen, sonst die gespeicherte Referenz
-        converter = converter_callback or cls._converter_callback
-        if not converter:
-            raise ValueError(
-                "No converter callback provided for ColumnElement. Call set_converter_callback first or provide converter_callback parameter."
-            )
-
-        matches = []
-        lines = text.split("\n")
-        i = 0
-
-        while i < len(lines):
-            # Skip non-column lines
-            if not ColumnElement.COLUMNS_START.match(lines[i].strip()):
-                i += 1
-                continue
-
-            # Process a column block and add to matches
-            column_block_info = cls._process_column_block(
-                lines=lines, start_index=i, converter_callback=converter
-            )
-            matches.append(column_block_info)
-
-            # Skip to the end of the processed column block
-            i = column_block_info[3]  # i is returned as the 4th element in the tuple
-
-        return [(start, end, block) for start, end, block, _ in matches]
+    COLUMN_START = re.compile(r"^:::\s*column(?:\s+(0?\.\d+|1\.0?))?\s*$")
 
     @classmethod
-    def _process_column_block(
-        cls, lines: list[str], start_index: int, converter_callback: Callable
-    ) -> tuple[int, int, dict[str, any], int]:
-        """
-        Process a complete column block structure from the given starting line.
-
-        Args:
-            lines: All lines of the text
-            start_index: Index of the column block start line
-            converter_callback: Callback function to convert markdown to notion blocks
-
-        Returns:
-            Tuple of (start_pos, end_pos, block, next_line_index)
-        """
-        columns_start = start_index
-        columns_blocks = cls.markdown_to_notion(lines[start_index].strip())
-        columns_block = columns_blocks[0] if columns_blocks else None
-        columns_children = []
-
-        next_index = cls._collect_columns(
-            lines, start_index + 1, columns_children, converter_callback
-        )
-
-        # Add columns to the main block
-        if columns_children and columns_block:
-            columns_block["column_list"]["children"] = columns_children
-
-        # Calculate positions
-        start_pos = sum(len(lines[j]) + 1 for j in range(columns_start))
-        end_pos = sum(len(lines[j]) + 1 for j in range(next_index))
-
-        return (start_pos, end_pos, columns_block, next_index)
+    def match_notion(cls, block: Block) -> bool:
+        """Check if block is a Notion column."""
+        return block.type == BlockType.COLUMN and block.column
 
     @classmethod
-    def _collect_columns(
-        cls,
-        lines: list[str],
-        start_index: int,
-        columns_children: list[dict[str, any]],
-        converter_callback: Callable,
-    ) -> int:
-        """
-        Collect all columns within a column block structure.
-
-        Args:
-            lines: All lines of the text
-            start_index: Index to start collecting from
-            columns_children: List to append collected columns to
-            converter_callback: Callback function to convert column content
-
-        Returns:
-            Next line index after all columns have been processed
-        """
-        i = start_index
-        in_column = False
-        column_content = []
-
-        while i < len(lines):
-            current_line = lines[i].strip()
-
-            if cls.COLUMNS_START.match(current_line):
-                break
-
-            if cls.COLUMN_START.match(current_line):
-                cls._finalize_column(
-                    column_content, columns_children, in_column, converter_callback
-                )
-                column_content = []
-                in_column = True
-                i += 1
-                continue
-
-            if cls.BLOCK_END.match(current_line) and in_column:
-                cls._finalize_column(
-                    column_content, columns_children, in_column, converter_callback
-                )
-                column_content = []
-                in_column = False
-                i += 1
-                continue
-
-            if cls.BLOCK_END.match(current_line) and not in_column:
-                i += 1
-                break
-
-            if in_column:
-                column_content.append(lines[i])
-
-            i += 1
-
-        cls._finalize_column(
-            column_content, columns_children, in_column, converter_callback
-        )
-
-        return i
-
-    @staticmethod
-    def _finalize_column(
-        column_content: list[str],
-        columns_children: list[dict[str, any]],
-        in_column: bool,
-        converter_callback: Callable,
-    ) -> None:
-        """
-        Finalize a column by processing its content and adding it to the columns_children list.
-
-        Args:
-            column_content: Content lines of the column
-            columns_children: List to append the column block to
-            in_column: Whether we're currently in a column (if False, does nothing)
-            converter_callback: Callback function to convert column content
-        """
-        if not (in_column and column_content):
-            return
+    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
 
-        processed_content = ColumnElement._preprocess_column_content(column_content)
+        ratio_str = match.group(1)
+        width_ratio = None
 
-        column_blocks = converter_callback("\n".join(processed_content))
+        if ratio_str:
+            try:
+                width_ratio = float(ratio_str)
+                # Validate ratio is between 0 and 1
+                if not (0 < width_ratio <= 1.0):
+                    width_ratio = None  # Invalid ratio, use default
+            except ValueError:
+                width_ratio = None  # Invalid format, use default
 
-        # Create column block
-        column_block = {"type": "column", "column": {"children": column_blocks}}
-        columns_children.append(column_block)
+        column_content = ColumnBlock(width_ratio=width_ratio)
+        return CreateColumnBlock(column=column_content)
 
     @classmethod
-    def is_multiline(cls) -> bool:
-        """Column blocks span multiple lines."""
-        return True
+    def notion_to_markdown(cls, block: Block) -> str:
+        """Convert Notion column to markdown."""
+        if not cls.match_notion(block):
+            return ""
 
-    @staticmethod
-    def _preprocess_column_content(lines: list[str]) -> list[str]:
-        """Remove all spacer markers from column content."""
-        return [line for line in lines if line.strip() != "---spacer---"]
+        if not block.column.width_ratio:
+            return "::: column"
 
-    @classmethod
-    def get_llm_prompt_content(cls) -> ElementPromptContent:
-        """
-        Returns structured LLM prompt metadata for the column layout element.
-        """
-        return (
-            ElementPromptBuilder()
-            .with_description(
-                "Creates a multi-column layout that displays content side by side."
-            )
-            .with_usage_guidelines(
-                "Use columns sparingly, only for direct comparisons or when parallel presentation significantly improves readability. "
-                "Best for pros/cons lists, feature comparisons, or pairing images with descriptions."
-            )
-            .with_avoidance_guidelines(
-                "Avoid overusing as it can complicate document structure. Do not use for simple content that works better in linear format."
-            )
-            .with_syntax(
-                "::: columns\n"
-                "::: column\n"
-                "Content for first column\n"
-                ":::\n"
-                "::: column\n"
-                "Content for second column\n"
-                ":::\n"
-                ":::"
-            )
-            .with_examples(
-                [
-                    "::: columns\n"
-                    "::: column\n"
-                    "## Features\n"
-                    "- Fast response time\n"
-                    "- Intuitive interface\n"
-                    "- Regular updates\n"
-                    ":::\n"
-                    "::: column\n"
-                    "## Benefits\n"
-                    "- Increased productivity\n"
-                    "- Better collaboration\n"
-                    "- Simplified workflows\n"
-                    ":::\n"
-                    ":::",
-                    "::: columns\n"
-                    "::: column\n"
-                    "![Image placeholder](/api/placeholder/400/320)\n"
-                    ":::\n"
-                    "::: column\n"
-                    "This text appears next to the image, creating a media-with-caption style layout.\n"
-                    ":::\n"
-                    ":::",
-                ]
-            )
-            .build()
-        )
+        return f"::: column {block.column.width_ratio}"

notionary/blocks/column/column_list_element.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+import re
+
+from notionary.blocks.base_block_element import BaseBlockElement
+from notionary.blocks.column.column_models import ColumnListBlock, CreateColumnListBlock
+from notionary.blocks.models import Block, BlockCreateResult
+from notionary.blocks.types import BlockType
+
+
+class ColumnListElement(BaseBlockElement):
+    """
+    Handles the `::: columns` container.
+    Individual columns are handled by ColumnElement.
+    """
+
+    COLUMNS_START = re.compile(r"^:::\s*columns\s*$")
+
+    @classmethod
+    def match_markdown(cls, text: str) -> bool:
+        """Check if text starts a columns container."""
+        return bool(cls.COLUMNS_START.match(text.strip()))
+
+    @classmethod
+    def match_notion(cls, block: Block) -> bool:
+        """Check if block is a Notion column_list."""
+        return block.type == BlockType.COLUMN_LIST and block.column_list
+
+    @classmethod
+    def markdown_to_notion(cls, text: str) -> BlockCreateResult:
+        """Convert `::: columns` to Notion ColumnListBlock."""
+        if not cls.COLUMNS_START.match(text.strip()):
+            return None
+
+        # Empty ColumnListBlock - children (columns) added by stack processor
+        column_list_content = ColumnListBlock()
+        return CreateColumnListBlock(column_list=column_list_content)

notionary/blocks/column/column_list_markdown_node.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from notionary.blocks.column.column_markdown_node import ColumnMarkdownNode
+from notionary.markdown.markdown_document_model import MarkdownBlock
+from notionary.markdown.markdown_node import MarkdownNode
+
+
+class ColumnListMarkdownBlockParams(BaseModel):
+    columns: list[list[MarkdownBlock]]
+    model_config = {"arbitrary_types_allowed": True}
+
+
+class ColumnListMarkdownNode(MarkdownNode):
+    """
+    Programmatic interface for creating a Markdown column list container.
+    This represents the `::: columns` container that holds multiple columns.
+
+    Example:
+    ::: columns
+    ::: column
+    Left content
+    with nested lines
+    :::
+
+    ::: column 0.3
+    Right content (30% width)
+    with nested lines
+    :::
+    :::
+    """
+
+    def __init__(self, columns: list[ColumnMarkdownNode]):
+        self.columns = columns
+
+    @classmethod
+    def from_params(
+        cls, params: ColumnListMarkdownBlockParams
+    ) -> ColumnListMarkdownNode:
+        return cls(columns=params.columns)
+
+    def to_markdown(self) -> str:
+        if not self.columns:
+            return "::: columns\n:::"
+
+        column_parts = [column.to_markdown() for column in self.columns]
+        columns_content = "\n\n".join(column_parts)
+
+        return f"::: columns\n{columns_content}\n:::"

notionary/blocks/column/column_markdown_node.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from typing import Optional
+
+from pydantic import BaseModel
+
+from notionary.markdown.markdown_node import MarkdownNode
+
+
+class ColumnMarkdownBlockParams(BaseModel):
+    children: list[MarkdownNode]
+    width_ratio: Optional[float] = None
+    model_config = {"arbitrary_types_allowed": True}
+
+
+class ColumnMarkdownNode(MarkdownNode):
+    """
+    Programmatic interface for creating a single Markdown column block
+    with nested content and optional width ratio.
+
+    Example:
+        ::: column
+        # Column Title
+
+        Some content here
+        :::
+
+        ::: column 0.7
+        # Wide Column (70%)
+
+        This column takes 70% width
+        :::
+    """
+
+    def __init__(
+        self, children: list[MarkdownNode], width_ratio: Optional[float] = None
+    ):
+        self.children = children
+        self.width_ratio = width_ratio
+
+    @classmethod
+    def from_params(cls, params: ColumnMarkdownBlockParams) -> ColumnMarkdownNode:
+        return cls(children=params.children, width_ratio=params.width_ratio)
+
+    def to_markdown(self) -> str:
+        # Start tag with optional width ratio
+        if self.width_ratio is not None:
+            start_tag = f"::: column {self.width_ratio}"
+        else:
+            start_tag = "::: column"
+
+        if not self.children:
+            return f"{start_tag}\n:::"
+
+        # Convert children to markdown
+        content_parts = [child.to_markdown() for child in self.children]
+        content_text = "\n\n".join(content_parts)
+
+        return f"{start_tag}\n{content_text}\n:::"

notionary/blocks/column/column_models.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from typing import Literal, Optional
+
+from pydantic import BaseModel, Field
+
+from notionary.blocks.models import BlockCreateRequest
+
+
+class ColumnBlock(BaseModel):
+    width_ratio: Optional[float] = None
+    children: list[BlockCreateRequest] = Field(default_factory=list)
+
+
+class CreateColumnBlock(BaseModel):
+    type: Literal["column"] = "column"
+    column: ColumnBlock
+
+
+class ColumnListBlock(BaseModel):
+    children: list[CreateColumnBlock] = Field(default_factory=list)
+
+
+class CreateColumnListBlock(BaseModel):
+    type: Literal["column_list"] = "column_list"
+    column_list: ColumnListBlock

notionary/blocks/divider/__init__.py

@@ -1,7 +1,14 @@
-from .divider_element import DividerElement
-from .divider_markdown_node import DividerMarkdownNode
+from notionary.blocks.divider.divider_element import DividerElement
+from notionary.blocks.divider.divider_markdown_node import (
+    DividerMarkdownBlockParams,
+    DividerMarkdownNode,
+)
+from notionary.blocks.divider.divider_models import CreateDividerBlock, DividerBlock
 
 __all__ = [
     "DividerElement",
+    "DividerBlock",
+    "CreateDividerBlock",
     "DividerMarkdownNode",
+    "DividerMarkdownBlockParams",
 ]

notionary/blocks/divider/divider_element.py

@@ -1,15 +1,19 @@
-import re
-from typing import Dict, Any, Optional
+from __future__ import annotations
 
-from notionary.blocks import NotionBlockElement
-from notionary.blocks import (
-    ElementPromptContent,
-    ElementPromptBuilder,
-    NotionBlockResult,
+import re
+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
 
 
-class DividerElement(NotionBlockElement):
+class DividerElement(BaseBlockElement):
     """
     Handles conversion between Markdown horizontal dividers and Notion divider blocks.
 
@@ -20,53 +24,26 @@ class DividerElement(NotionBlockElement):
     PATTERN = re.compile(r"^\s*-{3,}\s*$")
 
     @classmethod
-    def match_markdown(cls, text: str) -> bool:
-        """Check if text is a markdown divider."""
-        return bool(DividerElement.PATTERN.match(text))
+    def match_notion(cls, block: Block) -> bool:
+        """Check if this element can handle the given Notion block."""
+        return block.type == BlockType.DIVIDER and block.divider
 
     @classmethod
-    def match_notion(cls, block: Dict[str, Any]) -> bool:
-        """Check if block is a Notion divider."""
-        return block.get("type") == "divider"
-
-    @classmethod
-    def markdown_to_notion(cls, text: str) -> NotionBlockResult:
-        """Convert markdown divider to Notion divider block."""
-        if not DividerElement.match_markdown(text):
+    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_paragraph = {"type": "paragraph", "paragraph": {"rich_text": []}}
-
-        divider_block = {"type": "divider", "divider": {}}
+        empty_para = ParagraphBlock(rich_text=[])
+        divider = DividerBlock()
 
-        return [empty_paragraph, divider_block]
+        return [
+            CreateParagraphBlock(paragraph=empty_para),
+            CreateDividerBlock(divider=divider),
+        ]
 
     @classmethod
-    def notion_to_markdown(cls, block: Dict[str, Any]) -> Optional[str]:
-        """Convert Notion divider block to markdown divider."""
-        if block.get("type") != "divider":
+    def notion_to_markdown(cls, block: Block) -> Optional[str]:
+        if block.type != BlockType.DIVIDER or not block.divider:
             return None
-
         return "---"
-
-    @classmethod
-    def is_multiline(cls) -> bool:
-        return False
-
-    @classmethod
-    def get_llm_prompt_content(cls) -> ElementPromptContent:
-        """Returns structured LLM prompt metadata for the divider element."""
-        return (
-            ElementPromptBuilder()
-            .with_description(
-                "Creates a horizontal divider line to visually separate sections of content."
-            )
-            .with_usage_guidelines(
-                "Use dividers only sparingly and only when the user explicitly asks for them. Dividers create strong visual breaks between content sections, so they should not be used unless specifically requested by the user."
-            )
-            .with_syntax("---")
-            .with_examples(
-                ["## Section 1\nContent\n\n---\n\n## Section 2\nMore content"]
-            )
-            .build()
-        )

notionary/blocks/divider/divider_markdown_node.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
 from pydantic import BaseModel
-from notionary.blocks.markdown_node import MarkdownNode
+
+from notionary.markdown.markdown_node import MarkdownNode
 
 
 class DividerMarkdownBlockParams(BaseModel):

notionary/blocks/divider/divider_models.py

@@ -0,0 +1,12 @@
+from typing import Literal
+
+from pydantic import BaseModel
+
+
+class DividerBlock(BaseModel):
+    pass
+
+
+class CreateDividerBlock(BaseModel):
+    type: Literal["divider"] = "divider"
+    divider: DividerBlock