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

notionary/blocks/registry/block_registry.py

@@ -1,102 +1,105 @@
 from __future__ import annotations
-from typing import Dict, Any, Optional, List, Set, Type
 
-from notionary.blocks import NotionBlockElement
-from notionary.page.markdown_syntax_prompt_generator import (
-    MarkdownSyntaxPromptGenerator,
-)
-from notionary.blocks import TextInlineFormatter
+from typing import Optional, Type
 
-from notionary.blocks import NotionBlockElement
+from notionary.blocks.base_block_element import BaseBlockElement
+from notionary.blocks.models import Block, BlockCreateResult
+from notionary.blocks.registry.block_registry_builder import BlockRegistryBuilder
 from notionary.telemetry import (
-    ProductTelemetry,
-    NotionMarkdownSyntaxPromptEvent,
     MarkdownToNotionConversionEvent,
     NotionToMarkdownConversionEvent,
+    ProductTelemetry,
 )
 
 
 class BlockRegistry:
     """Registry of elements that can convert between Markdown and Notion."""
 
-    def __init__(self, elements=None):
+    def __init__(self, builder: Optional[BlockRegistryBuilder] = None):
         """
         Initialize a new registry instance.
 
         Args:
-            elements: Initial elements to register
+            builder: BlockRegistryBuilder instance to delegate operations to
         """
-        self._elements: List[NotionBlockElement] = []
-        self._element_types: Set[Type[NotionBlockElement]] = set()
-
-        if elements:
-            for element in elements:
-                self.register(element)
+        # Import here to avoid circular imports
+        from notionary.blocks.registry.block_registry_builder import (
+            BlockRegistryBuilder,
+        )
 
+        self._builder: BlockRegistryBuilder = builder or BlockRegistryBuilder()
         self.telemetry = ProductTelemetry()
 
     @classmethod
     def create_registry(cls) -> BlockRegistry:
         """
         Create a registry with all standard elements in recommended order.
-
-        This uses the BlockRegistryBuilder internally to construct a complete
-        registry with all available block types.
-
-        Returns:
-            BlockRegistry: A fully configured registry with all standard elements
         """
-        from notionary.blocks import BlockRegistryBuilder
-
-        return BlockRegistryBuilder.create_registry()
-
-    def register(self, element_class: Type[NotionBlockElement]) -> bool:
+        from notionary.blocks.registry.block_registry_builder import (
+            BlockRegistryBuilder,
+        )
+
+        builder = BlockRegistryBuilder()
+        builder = (
+            builder.with_headings()
+            .with_callouts()
+            .with_code()
+            .with_dividers()
+            .with_tables()
+            .with_bulleted_list()
+            .with_numbered_list()
+            .with_toggles()
+            .with_toggleable_heading_element()
+            .with_quotes()
+            .with_todos()
+            .with_bookmarks()
+            .with_images()
+            .with_videos()
+            .with_embeds()
+            .with_audio()
+            .with_columns()
+            .with_equation()
+            .with_table_of_contents()
+            .with_breadcrumbs()
+            .with_paragraphs()  # position here is important - its a fallback!
+        )
+
+        return cls(builder=builder)
+
+    @property
+    def builder(self) -> BlockRegistryBuilder:
+        return self._builder
+
+    def register(self, element_class: Type[BaseBlockElement]) -> bool:
         """
-        Register an element class.
-
-        Args:
-            element_class: The element class to register
-
-        Returns:
-            bool: True if element was added, False if it already existed
+        Register an element class via builder.
         """
-        if element_class in self._element_types:
-            return False
+        initial_count = len(self._builder._elements)
+        self._builder._add_element(element_class)
+        return len(self._builder._elements) > initial_count
 
-        self._elements.append(element_class)
-        self._element_types.add(element_class)
-        return True
-
-    def deregister(self, element_class: Type[NotionBlockElement]) -> bool:
+    def deregister(self, element_class: Type[BaseBlockElement]) -> bool:
         """
-        Deregister an element class.
+        Deregister an element class via builder.
         """
-        if element_class in self._element_types:
-            self._elements.remove(element_class)
-            self._element_types.remove(element_class)
-            return True
-        return False
+        initial_count = len(self._builder._elements)
+        self._builder.remove_element(element_class)
+        return len(self._builder._elements) < initial_count
 
-    def contains(self, element_class: Type[NotionBlockElement]) -> bool:
+    def contains(self, element_class: Type[BaseBlockElement]) -> bool:
         """
         Checks if a specific element is contained in the registry.
-
-        Args:
-            element_class: The element class to check.
-
-        Returns:
-            bool: True if the element is contained, otherwise False.
         """
-        return element_class in self._elements
+        return element_class.__name__ in self._builder._elements
 
-    def find_markdown_handler(self, text: str) -> Optional[Type[NotionBlockElement]]:
+    def find_markdown_handler(self, text: str) -> Optional[Type[BaseBlockElement]]:
         """Find an element that can handle the given markdown text."""
-        for element in self._elements:
+        for element in self._builder._elements.values():
             if element.match_markdown(text):
                 return element
         return None
 
-    def markdown_to_notion(self, text: str) -> Optional[Dict[str, Any]]:
+    def markdown_to_notion(self, text: str) -> "BlockCreateResult":
         """Convert markdown to Notion block using registered elements."""
         handler = self.find_markdown_handler(text)
 
@@ -110,47 +113,28 @@ class BlockRegistry:
             return handler.markdown_to_notion(text)
         return None
 
-    def notion_to_markdown(self, block: Dict[str, Any]) -> Optional[str]:
+    def notion_to_markdown(self, block: "Block") -> Optional[str]:
         """Convert Notion block to markdown using registered elements."""
         handler = self._find_notion_handler(block)
 
-        if handler:
-            self.telemetry.capture(
-                NotionToMarkdownConversionEvent(
-                    handler_element_name=handler.__name__,
-                )
-            )
+        if not handler:
+            return None
 
-            return handler.notion_to_markdown(block)
-        return None
+        self.telemetry.capture(
+            NotionToMarkdownConversionEvent(
+                handler_element_name=handler.__name__,
+            )
+        )
 
-    def get_multiline_elements(self) -> List[Type[NotionBlockElement]]:
-        """Get all registered multiline elements."""
-        return [element for element in self._elements if element.is_multiline()]
+        return handler.notion_to_markdown(block)
 
-    def get_elements(self) -> List[Type[NotionBlockElement]]:
+    def get_elements(self) -> list[Type[BaseBlockElement]]:
         """Get all registered elements."""
-        return self._elements.copy()
-
-    def get_notion_markdown_syntax_prompt(self) -> str:
-        """
-        Generates an LLM system prompt that describes the Markdown syntax of all registered elements.
-        """
-        element_classes = self._elements.copy()
-
-        formatter_names = [e.__name__ for e in element_classes]
-        if "TextInlineFormatter" not in formatter_names:
-            element_classes = element_classes + [TextInlineFormatter]
-
-        self.telemetry.capture(NotionMarkdownSyntaxPromptEvent())
-
-        return MarkdownSyntaxPromptGenerator.generate_system_prompt(element_classes)
+        return list(self._builder._elements.values())
 
-    def _find_notion_handler(
-        self, block: Dict[str, Any]
-    ) -> Optional[Type[NotionBlockElement]]:
+    def _find_notion_handler(self, block: Block) -> Optional[Type[BaseBlockElement]]:
         """Find an element that can handle the given Notion block."""
-        for element in self._elements:
+        for element in self._builder._elements.values():
             if element.match_notion(block):
                 return element
         return None

notionary/blocks/registry/block_registry_builder.py

@@ -1,32 +1,33 @@
 from __future__ import annotations
-from typing import Type, TYPE_CHECKING, Self
-from collections import OrderedDict
 
-from notionary.blocks import (
-    ParagraphElement,
-    AudioElement,
-    BulletedListElement,
-    CalloutElement,
-    CodeElement,
-    ColumnElement,
-    DividerElement,
-    EmbedElement,
-    HeadingElement,
-    ImageElement,
-    MentionElement,
-    NumberedListElement,
-    TableElement,
-    TodoElement,
-    ToggleElement,
-    ToggleableHeadingElement,
-    VideoElement,
-    BookmarkElement,
-    QuoteElement,
-    NotionBlockElement,
-)
+from collections import OrderedDict
+from typing import TYPE_CHECKING, Self, Type
+
+from notionary.blocks.audio import AudioElement
+from notionary.blocks.base_block_element import BaseBlockElement
+from notionary.blocks.bookmark import BookmarkElement
+from notionary.blocks.breadcrumbs import BreadcrumbElement
+from notionary.blocks.bulleted_list import BulletedListElement
+from notionary.blocks.callout import CalloutElement
+from notionary.blocks.code import CodeElement
+from notionary.blocks.column import ColumnElement, ColumnListElement
+from notionary.blocks.divider import DividerElement
+from notionary.blocks.embed import EmbedElement
+from notionary.blocks.equation import EquationElement
+from notionary.blocks.heading import HeadingElement
+from notionary.blocks.image_block import ImageElement
+from notionary.blocks.numbered_list import NumberedListElement
+from notionary.blocks.paragraph import ParagraphElement
+from notionary.blocks.quote import QuoteElement
+from notionary.blocks.table import TableElement
+from notionary.blocks.table_of_contents import TableOfContentsElement
+from notionary.blocks.todo import TodoElement
+from notionary.blocks.toggle import ToggleElement
+from notionary.blocks.toggleable_heading import ToggleableHeadingElement
+from notionary.blocks.video import VideoElement
 
 if TYPE_CHECKING:
-    from notionary.blocks import BlockRegistry
+    from notionary.blocks.registry.block_registry import BlockRegistry
 
 
 class BlockRegistryBuilder:
@@ -63,13 +64,15 @@ class BlockRegistryBuilder:
             .with_videos()
             .with_embeds()
             .with_audio()
-            .with_columns()
-            .with_mention()
             .with_paragraphs()
             .with_toggleable_heading_element()
+            .with_columns()
+            .with_equation()
+            .with_table_of_contents()
+            .with_breadcrumbs()
         ).build()
 
-    def remove_element(self, element_class: Type[NotionBlockElement]) -> Self:
+    def remove_element(self, element_class: Type[BaseBlockElement]) -> Self:
         """
         Remove an element class from the registry configuration.
 
@@ -84,92 +87,137 @@ class BlockRegistryBuilder:
 
     # WITH methods (existing)
     def with_paragraphs(self) -> Self:
-        """Add support for paragraph elements."""
         return self._add_element(ParagraphElement)
 
     def with_headings(self) -> Self:
-        """Add support for heading elements."""
         return self._add_element(HeadingElement)
 
     def with_callouts(self) -> Self:
-        """Add support for callout elements."""
         return self._add_element(CalloutElement)
 
     def with_code(self) -> Self:
-        """Add support for code blocks."""
         return self._add_element(CodeElement)
 
     def with_dividers(self) -> Self:
-        """Add support for divider elements."""
         return self._add_element(DividerElement)
 
     def with_tables(self) -> Self:
-        """Add support for tables."""
         return self._add_element(TableElement)
 
     def with_bulleted_list(self) -> Self:
-        """Add support for bulleted list elements (unordered lists)."""
         return self._add_element(BulletedListElement)
 
     def with_numbered_list(self) -> Self:
-        """Add support for numbered list elements (ordered lists)."""
         return self._add_element(NumberedListElement)
 
     def with_toggles(self) -> Self:
-        """Add support for toggle elements."""
         return self._add_element(ToggleElement)
 
     def with_quotes(self) -> Self:
-        """Add support for quote elements."""
         return self._add_element(QuoteElement)
 
     def with_todos(self) -> Self:
-        """Add support for todo elements."""
         return self._add_element(TodoElement)
 
     def with_bookmarks(self) -> Self:
-        """Add support for bookmark elements."""
         return self._add_element(BookmarkElement)
 
     def with_images(self) -> Self:
-        """Add support for image elements."""
         return self._add_element(ImageElement)
 
     def with_videos(self) -> Self:
-        """Add support for video elements."""
         return self._add_element(VideoElement)
 
     def with_embeds(self) -> Self:
-        """Add support for embed elements."""
         return self._add_element(EmbedElement)
 
     def with_audio(self) -> Self:
-        """Add support for audio elements."""
         return self._add_element(AudioElement)
 
-    def with_mention(self) -> Self:
-        """Add support for mention elements."""
-        return self._add_element(MentionElement)
-
     def with_toggleable_heading_element(self) -> Self:
-        """Add support for toggleable heading elements."""
         return self._add_element(ToggleableHeadingElement)
 
     def with_columns(self) -> Self:
-        """Add support for column elements."""
-        return self._add_element(ColumnElement)
+        self._add_element(ColumnListElement)
+        self._add_element(ColumnElement)
+        return self
+
+    def with_equation(self) -> Self:
+        return self._add_element(EquationElement)
+
+    def with_table_of_contents(self) -> Self:
+        return self._add_element(TableOfContentsElement)
+
+    def with_breadcrumbs(self) -> Self:
+        return self._add_element(BreadcrumbElement)
+
+    def without_headings(self) -> Self:
+        return self.remove_element(HeadingElement)
+
+    def without_callouts(self) -> Self:
+        return self.remove_element(CalloutElement)
+
+    def without_code(self) -> Self:
+        return self.remove_element(CodeElement)
+
+    def without_dividers(self) -> Self:
+        return self.remove_element(DividerElement)
+
+    def without_tables(self) -> Self:
+        return self.remove_element(TableElement)
+
+    def without_bulleted_list(self) -> Self:
+        return self.remove_element(BulletedListElement)
+
+    def without_numbered_list(self) -> Self:
+        return self.remove_element(NumberedListElement)
+
+    def without_toggles(self) -> Self:
+        return self.remove_element(ToggleElement)
+
+    def without_quotes(self) -> Self:
+        return self.remove_element(QuoteElement)
+
+    def without_todos(self) -> Self:
+        return self.remove_element(TodoElement)
+
+    def without_bookmarks(self) -> Self:
+        return self.remove_element(BookmarkElement)
+
+    def without_images(self) -> Self:
+        return self.remove_element(ImageElement)
+
+    def without_videos(self) -> Self:
+        return self.remove_element(VideoElement)
+
+    def without_embeds(self) -> Self:
+        return self.remove_element(EmbedElement)
+
+    def without_audio(self) -> Self:
+        return self.remove_element(AudioElement)
+
+    def without_toggleable_heading_element(self) -> Self:
+        return self.remove_element(ToggleableHeadingElement)
+
+    def without_columns(self) -> Self:
+        self.remove_element(ColumnListElement)
+        self.remove_element(ColumnElement)
+        return self
+
+    def without_equation(self) -> Self:
+        return self.remove_element(EquationElement)
+
+    def without_table_of_contents(self) -> Self:
+        return self.remove_element(TableOfContentsElement)
+
+    def without_breadcrumbs(self) -> Self:
+        return self.remove_element(BreadcrumbElement)
 
     def build(self) -> BlockRegistry:
         """
         Build and return the configured BlockRegistry instance.
-
-        This automatically ensures that ParagraphElement is at the end
-        of the registry as a fallback element.
-
-        Returns:
-            A configured BlockRegistry instance
         """
-        from notionary.blocks import BlockRegistry
+        from notionary.blocks.registry.block_registry import BlockRegistry
 
         # Ensure ParagraphElement is always present and at the end
         self._ensure_paragraph_at_end()
@@ -191,7 +239,7 @@ class BlockRegistryBuilder:
         self._elements.pop(ParagraphElement.__name__, None)
         self._elements[ParagraphElement.__name__] = ParagraphElement
 
-    def _add_element(self, element_class: Type[NotionBlockElement]) -> Self:
+    def _add_element(self, element_class: Type[BaseBlockElement]) -> Self:
         """
         Add an element class to the registry configuration.
         If the element already exists, it's moved to the end.

notionary/blocks/rich_text/__init__.py

@@ -0,0 +1,33 @@
+"""Rich text handling for Notionary."""
+
+from notionary.blocks.rich_text.rich_text_models import (
+    EquationObject,
+    LinkObject,
+    MentionDatabaseRef,
+    MentionDate,
+    MentionLinkPreview,
+    MentionObject,
+    MentionPageRef,
+    MentionTemplateMention,
+    MentionUserRef,
+    RichTextObject,
+    TextAnnotations,
+    TextContent,
+)
+from notionary.blocks.rich_text.text_inline_formatter import TextInlineFormatter
+
+__all__ = [
+    "RichTextObject",
+    "TextAnnotations",
+    "LinkObject",
+    "TextContent",
+    "EquationObject",
+    "MentionUserRef",
+    "MentionPageRef",
+    "MentionDatabaseRef",
+    "MentionLinkPreview",
+    "MentionDate",
+    "MentionTemplateMention",
+    "MentionObject",
+    "TextInlineFormatter",
+]