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

notionary/blocks/code/code_element.py

@@ -1,117 +1,74 @@
+from __future__ import annotations
+
 import re
+from typing import Optional
 
-from typing import Optional, Any
-from notionary.blocks import NotionBlockElement
-from notionary.blocks import (
-    ElementPromptContent,
-    ElementPromptBuilder,
-    NotionBlockResult,
-)
-from notionary.blocks.shared.models import RichTextObject
+from notionary.blocks.base_block_element import BaseBlockElement
+from notionary.blocks.code.code_models import CodeBlock, CodeLanguage, CreateCodeBlock
+from notionary.blocks.models import Block, BlockCreateResult, BlockType
+from notionary.blocks.rich_text.rich_text_models import RichTextObject
 
 
-class CodeElement(NotionBlockElement):
+class CodeElement(BaseBlockElement):
     """
     Handles conversion between Markdown code blocks and Notion code blocks.
+    Now integrated into the LineProcessor stack system.
 
     Markdown code block syntax:
     ```language
-    code content
+    [code content as child lines]
     ```
-    Caption: optional caption text
-
-    Where:
-    - language is optional and specifies the programming language
-    - code content is the code to be displayed
-    - Caption line is optional and must appear immediately after the closing ```
     """
 
-    PATTERN = re.compile(
-        r"```(\w*)\n([\s\S]+?)```(?:\n(?:Caption|caption):\s*(.+))?", re.MULTILINE
-    )
+    DEFAULT_LANGUAGE = "plain text"
+    CODE_START_PATTERN = re.compile(r"^```(\w*)\s*$")
 
     @classmethod
-    def match_markdown(cls, text: str) -> bool:
-        """Check if text contains a markdown code block."""
-        return bool(cls.PATTERN.search(text))
-
-    @classmethod
-    def match_notion(cls, block: dict[str, any]) -> bool:
+    def match_notion(cls, block: Block) -> bool:
         """Check if block is a Notion code block."""
-        return block.get("type") == "code"
+        return block.type == BlockType.CODE and block.code
 
     @classmethod
-    def markdown_to_notion(cls, text: str) -> NotionBlockResult:
-        """Convert markdown code block to Notion code block."""
-        match = cls.PATTERN.search(text)
-        if not match:
+    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
 
-        language = match.group(1) or "plain text"
-        content = match.group(2)
-        caption = match.group(3)
-
-        if content.endswith("\n"):
-            content = content[:-1]
+        language = (match.group(1) or cls.DEFAULT_LANGUAGE).lower()
+        language = cls._normalize_language(language)
 
-        # Create code block with rich text
-        content_rich_text = RichTextObject.from_plain_text(content)
-
-        block = {
-            "type": "code",
-            "code": {
-                "rich_text": [content_rich_text.model_dump()],
-                "language": language,
-            },
-        }
-
-        # Add caption if provided
-        if caption and caption.strip():
-            caption_rich_text = RichTextObject.from_plain_text(caption.strip())
-            block["code"]["caption"] = [caption_rich_text.model_dump()]
-
-        # Leerer Paragraph nach dem Code-Block
-        empty_paragraph = {"type": "paragraph", "paragraph": {"rich_text": []}}
-
-        return [block, empty_paragraph]
+        # Create empty CodeBlock - content will be added by stack processor
+        code_block = CodeBlock(rich_text=[], language=language, caption=[])
+        return CreateCodeBlock(code=code_block)
 
     @classmethod
-    def notion_to_markdown(cls, block: dict[str, Any]) -> Optional[str]:
+    def notion_to_markdown(cls, block: Block) -> Optional[str]:
         """Convert Notion code block to Markdown."""
-        if block.get("type") != "code":
+        if block.type != BlockType.CODE:
+            return None
+
+        if not block.code:
             return None
 
-        code_data = block.get("code", {})
-        language = code_data.get("language", "")
-        rich_text = code_data.get("rich_text", [])
-        caption = code_data.get("caption", [])
-
-        def extract_content(rich_text_list):
-            """Extract code content from rich_text array."""
-            return "".join(
-                text.get("text", {}).get("content", "")
-                if text.get("type") == "text"
-                else text.get("plain_text", "")
-                for text in rich_text_list
-            )
-
-        def extract_caption(caption_list):
-            """Extract caption text from caption array."""
-            return "".join(
-                c.get("text", {}).get("content", "")
-                for c in caption_list
-                if c.get("type") == "text"
-            )
-
-        code_content = extract_content(rich_text)
-        caption_text = extract_caption(caption)
+        language_enum = block.code.language
+        rich_text = block.code.rich_text or []
+        caption = block.code.caption or []
+
+        code_content = cls.extract_content(rich_text)
+        caption_text = cls.extract_caption(caption)
+
+        # Convert enum to string value
+        language = language_enum.value if language_enum else ""
 
         # Handle language - convert "plain text" back to empty string for markdown
-        if language == "plain text":
+        if language == cls.DEFAULT_LANGUAGE:
             language = ""
 
         # Build markdown code block
-        result = f"```{language}\n{code_content}\n```" if language else f"```\n{code_content}\n```"
+        if language:
+            result = f"```{language}\n{code_content}\n```"
+        else:
+            result = f"```\n{code_content}\n```"
 
         # Add caption if present
         if caption_text:
@@ -120,115 +77,24 @@ class CodeElement(NotionBlockElement):
         return result
 
     @classmethod
-    def find_matches(cls, text: str) -> list[tuple[int, int, dict[str, any]]]:
+    def _normalize_language(cls, language: str) -> CodeLanguage:
         """
-        Find all code block matches in the text and return their positions.
-
-        Args:
-            text: The text to search in
-
-        Returns:
-            List of tuples with (start_pos, end_pos, block)
+        Normalize the language string to a valid CodeLanguage enum or default.
         """
-        matches = []
-        for match in CodeElement.PATTERN.finditer(text):
-            language = match.group(1) or "plain text"
-            content = match.group(2)
-            caption = match.group(3)
-
-            # Remove trailing newline if present
-            if content.endswith("\n"):
-                content = content[:-1]
-
-            block = {
-                "type": "code",
-                "code": {
-                    "rich_text": [
-                        {
-                            "type": "text",
-                            "text": {"content": content},
-                            "plain_text": content,
-                        }
-                    ],
-                    "language": language,
-                },
-            }
-
-            # Add caption if provided
-            if caption and caption.strip():
-                block["code"]["caption"] = [
-                    {
-                        "type": "text",
-                        "text": {"content": caption.strip()},
-                        "plain_text": caption.strip(),
-                    }
-                ]
-
-            matches.append((match.start(), match.end(), block))
-
-        return matches
+        # Try to find matching enum by value
+        for lang_enum in CodeLanguage:
+            if lang_enum.value.lower() == language.lower():
+                return lang_enum
 
-    @classmethod
-    def is_multiline(cls) -> bool:
-        return True
-
-    @classmethod
-    def get_llm_prompt_content(cls) -> ElementPromptContent:
-        """
-        Returns structured LLM prompt metadata for the code block element.
-        """
-        return (
-            ElementPromptBuilder()
-            .with_description(
-                "Use fenced code blocks to format content as code. Supports language annotations like "
-                "'python', 'json', or 'mermaid'. Useful for displaying code, configurations, command-line "
-                "examples, or diagram syntax. Also suitable for explaining or visualizing systems with diagram languages. "
-                "Code blocks can include optional captions for better documentation."
-            )
-            .with_usage_guidelines(
-                "Use code blocks when you want to present technical content like code snippets, terminal commands, "
-                "JSON structures, or system diagrams. Especially helpful when structure and formatting are essential. "
-                "Add captions to provide context, explanations, or titles for your code blocks."
-            )
-            .with_syntax(
-                "```language\ncode content\n```\nCaption: optional caption text\n\n"
-                "OR\n\n"
-                "```language\ncode content\n```"
-            )
-            .with_examples(
-                [
-                    "```python\nprint('Hello, world!')\n```\nCaption: Basic Python greeting example",
-                    '```json\n{"name": "Alice", "age": 30}\n```\nCaption: User data structure',
-                    "```mermaid\nflowchart TD\n  A --> B\n```\nCaption: Simple flow diagram",
-                    '```bash\ngit commit -m "Initial commit"\n```',
-                ]
-            )
-            .with_avoidance_guidelines(
-                "NEVER EVER wrap markdown content with ```markdown. Markdown should be written directly without code block formatting. "
-                "NEVER use ```markdown under any circumstances. "
-                "For Mermaid diagrams, use ONLY the default styling without colors, backgrounds, or custom styling attributes. "
-                "Keep Mermaid diagrams simple and minimal without any styling or color modifications. "
-                "Captions must appear immediately after the closing ``` on a new line starting with 'Caption:' - "
-                "no empty lines between the code block and the caption."
-            )
-            .build()
-        )
+        # Return default if not found
+        return CodeLanguage.PLAIN_TEXT
 
     @staticmethod
-    def extract_content(rich_text_list: list[dict[str, Any]]) -> str:
+    def extract_content(rich_text_list: list[RichTextObject]) -> str:
         """Extract code content from rich_text array."""
-        return "".join(
-            text.get("text", {}).get("content", "")
-            if text.get("type") == "text"
-            else text.get("plain_text", "")
-            for text in rich_text_list
-        )
+        return "".join(rt.plain_text for rt in rich_text_list if rt.plain_text)
 
     @staticmethod
-    def extract_caption(caption_list: list[dict[str, Any]]) -> str:
+    def extract_caption(caption_list: list[RichTextObject]) -> str:
         """Extract caption text from caption array."""
-        return "".join(
-            c.get("text", {}).get("content", "")
-            for c in caption_list
-            if c.get("type") == "text"
-        )
+        return "".join(rt.plain_text for rt in caption_list if rt.plain_text)

notionary/blocks/code/code_markdown_node.py

@@ -1,24 +1,18 @@
 from __future__ import annotations
 
 from typing import Optional
-from pydantic import BaseModel
-from notionary.blocks.markdown_node import MarkdownNode
 
-
-class CodeMarkdownBlockParams(BaseModel):
-    code: str
-    language: Optional[str] = None
-    caption: Optional[str] = None
+from notionary.blocks.code.code_models import CodeBlock
+from notionary.markdown.markdown_node import MarkdownNode
 
 
 class CodeMarkdownNode(MarkdownNode):
     """
     Programmatic interface for creating Notion-style Markdown code blocks.
     Example:
-        ```python
+        ```python "Basic usage"
         print("Hello, world!")
         ```
-        Caption: Basic usage
     """
 
     def __init__(
@@ -32,12 +26,18 @@ class CodeMarkdownNode(MarkdownNode):
         self.caption = caption
 
     @classmethod
-    def from_params(cls, params: CodeMarkdownBlockParams) -> CodeMarkdownNode:
-        return cls(code=params.code, language=params.language, caption=params.caption)
+    def from_params(cls, params: CodeBlock) -> CodeMarkdownNode:
+        return cls(
+            code=params.rich_text, language=params.language, caption=params.caption
+        )
 
     def to_markdown(self) -> str:
         lang = self.language or ""
-        content = f"```{lang}\n{self.code}\n```"
+
+        # Build the opening fence with optional caption
+        opening_fence = f"```{lang}"
         if self.caption:
-            content += f"\nCaption: {self.caption}"
+            opening_fence += f' "{self.caption}"'
+
+        content = f"{opening_fence}\n{self.code}\n```"
         return content

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",
 ]