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

notionary/blocks/code/code_models.py

@@ -0,0 +1,94 @@
+from enum import Enum
+from typing import Literal
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from notionary.blocks.rich_text.rich_text_models import RichTextObject
+
+
+class CodeLanguage(str, Enum):
+    ABAP = "abap"
+    ARDUINO = "arduino"
+    BASH = "bash"
+    BASIC = "basic"
+    C = "c"
+    CLOJURE = "clojure"
+    COFFEESCRIPT = "coffeescript"
+    CPP = "c++"
+    CSHARP = "c#"
+    CSS = "css"
+    DART = "dart"
+    DIFF = "diff"
+    DOCKER = "docker"
+    ELIXIR = "elixir"
+    ELM = "elm"
+    ERLANG = "erlang"
+    FLOW = "flow"
+    FORTRAN = "fortran"
+    FSHARP = "f#"
+    GHERKIN = "gherkin"
+    GLSL = "glsl"
+    GO = "go"
+    GRAPHQL = "graphql"
+    GROOVY = "groovy"
+    HASKELL = "haskell"
+    HTML = "html"
+    JAVA = "java"
+    JAVASCRIPT = "javascript"
+    JSON = "json"
+    JULIA = "julia"
+    KOTLIN = "kotlin"
+    LATEX = "latex"
+    LESS = "less"
+    LISP = "lisp"
+    LIVESCRIPT = "livescript"
+    LUA = "lua"
+    MAKEFILE = "makefile"
+    MARKDOWN = "markdown"
+    MARKUP = "markup"
+    MATLAB = "matlab"
+    MERMAID = "mermaid"
+    NIX = "nix"
+    OBJECTIVE_C = "objective-c"
+    OCAML = "ocaml"
+    PASCAL = "pascal"
+    PERL = "perl"
+    PHP = "php"
+    PLAIN_TEXT = "plain text"
+    POWERSHELL = "powershell"
+    PROLOG = "prolog"
+    PROTOBUF = "protobuf"
+    PYTHON = "python"
+    R = "r"
+    REASON = "reason"
+    RUBY = "ruby"
+    RUST = "rust"
+    SASS = "sass"
+    SCALA = "scala"
+    SCHEME = "scheme"
+    SCSS = "scss"
+    SHELL = "shell"
+    SQL = "sql"
+    SWIFT = "swift"
+    TYPESCRIPT = "typescript"
+    VB_NET = "vb.net"
+    VERILOG = "verilog"
+    VHDL = "vhdl"
+    VISUAL_BASIC = "visual basic"
+    WEBASSEMBLY = "webassembly"
+    XML = "xml"
+    YAML = "yaml"
+    JAVA_C_CPP_CSHARP = "java/c/c++/c#"
+
+
+class CodeBlock(BaseModel):
+    caption: list[RichTextObject] = Field(default_factory=list)
+    rich_text: list[RichTextObject]
+    language: CodeLanguage = CodeLanguage.PLAIN_TEXT
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+
+class CreateCodeBlock(BaseModel):
+    type: Literal["code"] = "code"
+    code: CodeBlock

notionary/blocks/column/__init__.py

@@ -1,5 +1,29 @@
-from .column_element import ColumnElement
+from notionary.blocks.column.column_element import ColumnElement
+from notionary.blocks.column.column_list_element import ColumnListElement
+from notionary.blocks.column.column_list_markdown_node import (
+    ColumnListMarkdownBlockParams,
+    ColumnListMarkdownNode,
+)
+from notionary.blocks.column.column_markdown_node import (
+    ColumnMarkdownBlockParams,
+    ColumnMarkdownNode,
+)
+from notionary.blocks.column.column_models import (
+    ColumnBlock,
+    ColumnListBlock,
+    CreateColumnBlock,
+    CreateColumnListBlock,
+)
 
 __all__ = [
     "ColumnElement",
+    "ColumnListElement",
+    "ColumnBlock",
+    "CreateColumnBlock",
+    "ColumnListBlock",
+    "CreateColumnListBlock",
+    "ColumnMarkdownNode",
+    "ColumnMarkdownBlockParams",
+    "ColumnListMarkdownNode",
+    "ColumnListMarkdownBlockParams",
 ]

notionary/blocks/column/column_element.py

@@ -1,333 +1,65 @@
+from __future__ import annotations
+
 import re
-from typing import Optional, Callable
+from typing import Optional
 
-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.syntax_prompt_builder import BlockElementMarkdownInformation
+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
+    COLUMN_START = re.compile(r"^:::\s*column(?:\s+(0?\.\d+|1\.0?))?\s*$")
 
     @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]
+    def match_notion(cls, block: Block) -> bool:
+        """Check if block is a Notion column."""
+        return block.type == BlockType.COLUMN and block.column
 
     @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
-        )
+    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
 
-        # Add columns to the main block
-        if columns_children and columns_block:
-            columns_block["column_list"]["children"] = columns_children
+        ratio_str = match.group(1)
+        width_ratio = None
 
-        # 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))
+        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
 
-        return (start_pos, end_pos, columns_block, next_index)
+        column_content = ColumnBlock(width_ratio=width_ratio)
+        return CreateColumnBlock(column=column_content)
 
     @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
+    async def notion_to_markdown(cls, block: Block) -> str:
+        """Convert Notion column to markdown."""
+        if not cls.match_notion(block):
+            return ""
 
-            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
-
-        processed_content = ColumnElement._preprocess_column_content(column_content)
-
-        column_blocks = converter_callback("\n".join(processed_content))
-
-        # Create column block
-        column_block = {"type": "column", "column": {"children": column_blocks}}
-        columns_children.append(column_block)
-
-    @classmethod
-    def is_multiline(cls) -> bool:
-        """Column blocks span multiple lines."""
-        return True
+        if not block.column.width_ratio:
+            return "::: column"
 
-    @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---"]
+        return f"::: column {block.column.width_ratio}"
 
     @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()
-        )
+    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

@@ -0,0 +1,52 @@
+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
+
+
+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
+    async 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)
+
+    @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/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