notionary 0.1.2__py3-none-any.whl → 0.1.3__py3-none-any.whl

notionary/core/converters/registry/block_element_registry.py

@@ -0,0 +1,234 @@
+from typing import Dict, Any, Optional, List, Type
+
+from notionary.core.converters.elements.notion_block_element import NotionBlockElement
+from notionary.core.converters.elements.text_inline_formatter import TextInlineFormatter
+
+
+class BlockElementRegistry:
+    """Registry of elements that can convert between Markdown and Notion."""
+
+    def __init__(self, elements=None):
+        """
+        Initialize a new registry instance.
+
+        Args:
+            elements: Optional list of NotionBlockElement classes to register at creation
+        """
+        self._elements = []
+
+        # Register initial elements if provided
+        if elements:
+            for element in elements:
+                self.register(element)
+
+    def register(self, element_class: Type[NotionBlockElement]):
+        """Register an element class."""
+        self._elements.append(element_class)
+        return self
+
+    def deregister(self, element_class: Type[NotionBlockElement]) -> bool:
+        """
+        Deregister an element class.
+
+        Args:
+            element_class: The element class to remove from the registry
+
+        Returns:
+            bool: True if the element was removed, False if it wasn't in the registry
+        """
+        if element_class in self._elements:
+            self._elements.remove(element_class)
+            return True
+        return False
+
+    def clear(self):
+        """Clear the registry completely."""
+        self._elements.clear()
+        return self
+
+    def find_markdown_handler(self, text: str) -> Optional[Type[NotionBlockElement]]:
+        """Find an element that can handle the given markdown text."""
+        for element in self._elements:
+            if element.match_markdown(text):
+                return element
+        return None
+
+    def find_notion_handler(
+        self, block: Dict[str, Any]
+    ) -> Optional[Type[NotionBlockElement]]:
+        """Find an element that can handle the given Notion block."""
+        for element in self._elements:
+            if element.match_notion(block):
+                return element
+        return None
+
+    def markdown_to_notion(self, text: str) -> Optional[Dict[str, Any]]:
+        """Convert markdown to Notion block using registered elements."""
+        handler = self.find_markdown_handler(text)
+        if handler:
+            return handler.markdown_to_notion(text)
+        return None
+
+    def notion_to_markdown(self, block: Dict[str, Any]) -> Optional[str]:
+        """Convert Notion block to markdown using registered elements."""
+        handler = self.find_notion_handler(block)
+        if handler:
+            return handler.notion_to_markdown(block)
+        return None
+
+    def get_multiline_elements(self) -> List[Type[NotionBlockElement]]:
+        """Get all registered multiline elements."""
+        return [element for element in self._elements if element.is_multiline()]
+
+    def get_elements(self) -> List[Type[NotionBlockElement]]:
+        """Get all registered elements."""
+        return self._elements.copy()
+
+    def generate_llm_prompt(self) -> str:
+        """
+        Generates an LLM system prompt that describes the Markdown syntax of all registered elements.
+
+        TextInlineFormatter is automatically added if not already registered.
+
+        Returns:
+            A complete system prompt for an LLM that should understand Notion-Markdown syntax
+        """
+        # Create a copy of registered elements
+        element_classes = self._elements.copy()
+        print("Elements in registry:", element_classes)
+
+        formatter_names = [e.__name__ for e in element_classes]
+        if "TextInlineFormatter" not in formatter_names:
+            element_classes = [TextInlineFormatter] + element_classes
+
+        return MarkdownSyntaxPromptBuilder.generate_system_prompt(element_classes)
+
+
+class MarkdownSyntaxPromptBuilder:
+    """
+    Generator for LLM system prompts that describe Notion-Markdown syntax.
+
+    This class extracts information about supported Markdown patterns
+    and formats them optimally for LLMs.
+    """
+
+    # Standard system prompt template
+    SYSTEM_PROMPT_TEMPLATE = """You are a knowledgeable assistant that helps users create content for Notion pages.
+Notion supports standard Markdown with some special extensions for creating rich content.
+
+{element_docs}
+
+Important usage guidelines:
+
+1. The backtick code fence syntax (```) should ONLY be used when creating actual code blocks or diagrams.
+Do not wrap examples or regular content in backticks unless you're showing code.
+
+2. Use inline formatting (bold, italic, highlights, etc.) across all content to enhance readability.
+The highlight syntax (==text== and ==color:text==) is especially useful for emphasizing important points.
+
+3. Notion's extensions to Markdown (like callouts, bookmarks, toggles) provide richer formatting options
+than standard Markdown while maintaining the familiar Markdown syntax for basic elements.
+
+4. You can use these Markdown extensions alongside standard Markdown to create visually appealing
+and well-structured content.
+
+5. Remember that features like highlighting with ==yellow:important== work in all text blocks including
+paragraphs, lists, quotes, etc.
+"""
+
+    @staticmethod
+    def generate_element_doc(element_class: Type[NotionBlockElement]) -> str:
+        """
+        Generates documentation for a specific NotionBlockElement.
+
+        Uses the element's get_llm_prompt_content method if available.
+        """
+        class_name = element_class.__name__
+        element_name = class_name.replace("Element", "")
+
+        # Start with element name as header
+        result = [f"## {element_name}"]
+
+        # Use get_llm_prompt_content if available
+        if hasattr(element_class, "get_llm_prompt_content") and callable(
+            getattr(element_class, "get_llm_prompt_content")
+        ):
+            content = element_class.get_llm_prompt_content()
+
+            if content.get("description"):
+                result.append(content["description"])
+
+            if content.get("syntax"):
+                result.append("\n### Syntax:")
+                for syntax_item in content["syntax"]:
+                    result.append(f"{syntax_item}")
+
+            if content.get("examples"):
+                result.append("\n### Examples:")
+                for example in content["examples"]:
+                    result.append(example)
+
+            # Add any additional custom sections
+            for key, value in content.items():
+                if key not in ["description", "syntax", "examples"] and isinstance(
+                    value, str
+                ):
+                    result.append(f"\n### {key.replace('_', ' ').title()}:")
+                    result.append(value)
+
+        return "\n".join(result)
+
+    @classmethod
+    def generate_element_docs(
+        cls,
+        element_classes: List[Type[NotionBlockElement]],
+    ) -> str:
+        """
+        Generates complete documentation for all provided element classes.
+
+        Args:
+            element_classes: List of NotionBlockElement classes
+
+        Returns:
+            Documentation text for all elements
+        """
+        docs = [
+            "# Custom Markdown Syntax for Notion Blocks",
+            "The following custom Markdown patterns are supported for creating Notion blocks:",
+        ]
+
+        text_formatter = None
+        other_elements = []
+
+        for element in element_classes:
+            if element.__name__ == "TextInlineFormatter":
+                text_formatter = element
+            else:
+                other_elements.append(element)
+
+        if text_formatter:
+            docs.append("\n" + cls.generate_element_doc(text_formatter))
+
+        for element in other_elements:
+            if element.__name__ != "InlineFormattingElement":
+                docs.append("\n" + cls.generate_element_doc(element))
+
+        return "\n".join(docs)
+
+    @classmethod
+    def generate_system_prompt(
+        cls,
+        element_classes: List[Type[NotionBlockElement]],
+    ) -> str:
+        """
+        Generates a complete system prompt for LLMs.
+
+        Args:
+            element_classes: List of element classes to document
+
+        Returns:
+            Complete system prompt for an LLM
+        """
+        element_docs = cls.generate_element_docs(element_classes)
+
+        return cls.SYSTEM_PROMPT_TEMPLATE.format(element_docs=element_docs)

notionary/core/converters/registry/block_element_registry_builder.py

@@ -0,0 +1,280 @@
+from typing import List, Type
+from collections import OrderedDict
+
+from notionary.core.converters.elements.notion_block_element import NotionBlockElement
+from notionary.core.converters.registry.block_element_registry import (
+    BlockElementRegistry,
+)
+
+from notionary.core.converters.elements.paragraph_element import ParagraphElement
+from notionary.core.converters.elements.heading_element import HeadingElement
+from notionary.core.converters.elements.callout_element import CalloutElement
+from notionary.core.converters.elements.code_block_element import CodeBlockElement
+from notionary.core.converters.elements.divider_element import DividerElement
+from notionary.core.converters.elements.table_element import TableElement
+from notionary.core.converters.elements.todo_lists import TodoElement
+from notionary.core.converters.elements.list_element import (
+    BulletedListElement,
+    NumberedListElement,
+)
+from notionary.core.converters.elements.qoute_element import QuoteElement
+from notionary.core.converters.elements.image_element import ImageElement
+from notionary.core.converters.elements.video_element import VideoElement
+from notionary.core.converters.elements.toggle_element import ToggleElement
+from notionary.core.converters.elements.bookmark_element import BookmarkElement
+from notionary.core.converters.elements.column_element import ColumnElement
+
+
+class BlockElementRegistryBuilder:
+    """
+    True builder for constructing BlockElementRegistry instances.
+
+    This builder allows for incremental construction of registry instances
+    with specific configurations of block elements.
+    """
+
+    def __init__(self):
+        """Initialize a new builder with an empty element list."""
+        # Use OrderedDict to maintain insertion order while ensuring uniqueness
+        self._elements = OrderedDict()
+
+    # Profile methods - create a base configuration
+
+    @classmethod
+    def start_empty(cls) -> "BlockElementRegistryBuilder":
+        """
+        Start with a completely empty registry builder.
+
+        Returns:
+            A new builder instance with no elements
+        """
+        return cls()
+
+    @classmethod
+    def start_minimal(cls) -> "BlockElementRegistryBuilder":
+        """
+        Start with a minimal set of essential elements.
+
+        Returns:
+            A new builder instance with basic elements
+        """
+        builder = cls()
+        return (
+            builder.add_element(HeadingElement)
+            .add_element(BulletedListElement)
+            .add_element(NumberedListElement)
+            .add_element(ParagraphElement)
+        )  # Add paragraph last as fallback
+
+    @classmethod
+    def start_standard(cls) -> "BlockElementRegistryBuilder":
+        """
+        Start with all standard elements in recommended order.
+
+        Returns:
+            A new builder instance with all standard elements
+        """
+        builder = cls()
+        return (
+            builder.add_element(HeadingElement)
+            .add_element(CalloutElement)
+            .add_element(CodeBlockElement)
+            .add_element(DividerElement)
+            .add_element(TableElement)
+            .add_element(ColumnElement)
+            .add_element(BulletedListElement)
+            .add_element(NumberedListElement)
+            .add_element(ToggleElement)
+            .add_element(QuoteElement)
+            .add_element(TodoElement)
+            .add_element(BookmarkElement)
+            .add_element(ImageElement)
+            .add_element(VideoElement)
+            .add_element(ParagraphElement)
+        )  # Add paragraph last as fallback
+
+    # Element manipulation methods
+
+    def add_element(
+        self, element_class: Type[NotionBlockElement]
+    ) -> "BlockElementRegistryBuilder":
+        """
+        Add an element class to the registry configuration.
+        If the element already exists, it's moved to the end.
+
+        Args:
+            element_class: The element class to add
+
+        Returns:
+            Self for method chaining
+        """
+        # Remove if exists (to update the order) and add to the end
+        self._elements.pop(element_class.__name__, None)
+        self._elements[element_class.__name__] = element_class
+        return self
+
+    def add_elements(
+        self, element_classes: List[Type[NotionBlockElement]]
+    ) -> "BlockElementRegistryBuilder":
+        """
+        Add multiple element classes to the registry configuration.
+
+        Args:
+            element_classes: List of element classes to add
+
+        Returns:
+            Self for method chaining
+        """
+        for element_class in element_classes:
+            self.add_element(element_class)
+        return self
+
+    def remove_element(
+        self, element_class: Type[NotionBlockElement]
+    ) -> "BlockElementRegistryBuilder":
+        """
+        Remove an element class from the registry configuration.
+
+        Args:
+            element_class: The element class to remove
+
+        Returns:
+            Self for method chaining
+        """
+        self._elements.pop(element_class.__name__, None)
+        return self
+
+    def move_element_to_end(
+        self, element_class: Type[NotionBlockElement]
+    ) -> "BlockElementRegistryBuilder":
+        """
+        Move an existing element to the end of the registry.
+        If the element doesn't exist, it will be added.
+
+        Args:
+            element_class: The element class to move
+
+        Returns:
+            Self for method chaining
+        """
+        return self.add_element(element_class)  # add_element already handles this logic
+
+    def ensure_paragraph_at_end(self) -> "BlockElementRegistryBuilder":
+        """
+        Ensure ParagraphElement is the last element in the registry.
+        If it doesn't exist, it will be added.
+
+        Returns:
+            Self for method chaining
+        """
+        return self.move_element_to_end(ParagraphElement)
+
+    # Specialized configuration methods
+
+    def with_list_support(self) -> "BlockElementRegistryBuilder":
+        """
+        Add support for list elements.
+
+        Returns:
+            Self for method chaining
+        """
+        return self.add_element(BulletedListElement).add_element(NumberedListElement)
+
+    def with_code_support(self) -> "BlockElementRegistryBuilder":
+        """
+        Add support for code blocks.
+
+        Returns:
+            Self for method chaining
+        """
+        return self.add_element(CodeBlockElement)
+
+    def with_table_support(self) -> "BlockElementRegistryBuilder":
+        """
+        Add support for tables.
+
+        Returns:
+            Self for method chaining
+        """
+        return self.add_element(TableElement)
+
+    def with_rich_content(self) -> "BlockElementRegistryBuilder":
+        """
+        Add support for rich content elements (callouts, toggles, etc.).
+
+        Returns:
+            Self for method chaining
+        """
+        return (
+            self.add_element(CalloutElement)
+            .add_element(ToggleElement)
+            .add_element(QuoteElement)
+        )
+
+    def with_media_support(self) -> "BlockElementRegistryBuilder":
+        """
+        Add support for media elements (images, videos).
+
+        Returns:
+            Self for method chaining
+        """
+        return self.add_element(ImageElement).add_element(VideoElement)
+
+    def with_task_support(self) -> "BlockElementRegistryBuilder":
+        """
+        Add support for task-related elements (todos).
+
+        Returns:
+            Self for method chaining
+        """
+        return self.add_element(TodoElement)
+
+    def build(self) -> BlockElementRegistry:
+        """
+        Build and return the configured BlockElementRegistry instance.
+
+        Returns:
+            A configured BlockElementRegistry instance
+        """
+        registry = BlockElementRegistry()
+
+        # Add elements in the recorded order
+        for element_class in self._elements.values():
+            registry.register(element_class)
+
+        return registry
+
+    @classmethod
+    def create_standard_registry(cls) -> BlockElementRegistry:
+        """
+        Factory method to directly create a standard registry.
+
+        Returns:
+            A fully configured registry instance
+        """
+        return cls.start_standard().build()
+
+    @classmethod
+    def create_minimal_registry(cls) -> BlockElementRegistry:
+        """
+        Factory method to directly create a minimal registry.
+
+        Returns:
+            A minimal registry instance
+        """
+        return cls.start_minimal().build()
+
+    @classmethod
+    def create_custom_registry(
+        cls, element_classes: List[Type[NotionBlockElement]]
+    ) -> BlockElementRegistry:
+        """
+        Factory method to directly create a custom registry.
+
+        Args:
+            element_classes: List of element classes to register
+
+        Returns:
+            A custom configured registry instance
+        """
+        return cls().add_elements(element_classes).build()

notionary/core/database/database_info_service.py

@@ -0,0 +1,43 @@
+from typing import Optional
+from notionary.core.notion_client import NotionClient
+
+
+class DatabaseInfoService:
+    """Service für den Zugriff auf Datenbankinformationen"""
+
+    def __init__(self, client: NotionClient, database_id: str):
+        self._client = client
+        self.database_id = database_id
+        self._title = None
+
+    async def fetch_database_title(self) -> str:
+        """
+        Fetch the database title from the Notion API.
+
+        Returns:
+            The database title or "Untitled" if no title is found
+        """
+        db_details = await self._client.get(f"databases/{self.database_id}")
+        if not db_details:
+            return "Untitled"
+
+        title = "Untitled"
+        if "title" in db_details:
+            title_parts = []
+            for text_obj in db_details["title"]:
+                if "plain_text" in text_obj:
+                    title_parts.append(text_obj["plain_text"])
+
+            if title_parts:
+                title = "".join(title_parts)
+
+        return title
+
+    @property
+    def title(self) -> Optional[str]:
+        return self._title
+
+    async def load_title(self) -> str:
+        """Lädt den Titel der Datenbank und speichert ihn im Cache"""
+        self._title = await self.fetch_database_title()
+        return self._title

notionary/core/database/database_query_service.py

@@ -0,0 +1,73 @@
+from typing import Any, AsyncGenerator, Dict, List, Optional
+from notionary.core.database.notion_database_schema import NotionDatabaseSchema
+from notionary.core.page.notion_page_manager import NotionPageManager
+
+
+class DatabaseQueryService:
+    """Service für Datenbankabfragen und Iterations"""
+
+    def __init__(self, schema: NotionDatabaseSchema):
+        self._schema = schema
+
+    async def get_pages(
+        self,
+        database_id: str,
+        limit: int = 100,
+        filter_conditions: Optional[Dict[str, Any]] = None,
+        sorts: Optional[List[Dict[str, Any]]] = None,
+    ) -> List[NotionPageManager]:
+        """
+        Get all pages from the database.
+
+        Args:
+            database_id: The database ID to query
+            limit: Maximum number of pages to retrieve
+            filter_conditions: Optional filter to apply to the database query
+            sorts: Optional sort instructions for the database query
+
+        Returns:
+            List of NotionPageManager instances for each page
+        """
+        pages: List[NotionPageManager] = []
+        count = 0
+
+        async for page in self.iter_pages(
+            database_id,
+            page_size=min(limit, 100),
+            filter_conditions=filter_conditions,
+            sorts=sorts,
+        ):
+            pages.append(page)
+            count += 1
+
+            if count >= limit:
+                break
+
+        return pages
+
+    async def iter_pages(
+        self,
+        database_id: str,
+        page_size: int = 100,
+        filter_conditions: Optional[Dict[str, Any]] = None,
+        sorts: Optional[List[Dict[str, Any]]] = None,
+    ) -> AsyncGenerator[NotionPageManager, None]:
+        """
+        Asynchronous generator that yields pages from the database.
+
+        Args:
+            database_id: The database ID to query
+            page_size: Number of pages to fetch per request
+            filter_conditions: Optional filter to apply to the database query
+            sorts: Optional sort instructions for the database query
+
+        Yields:
+            NotionPageManager instances for each page
+        """
+        async for page_manager in self._schema.iter_database_pages(
+            database_id=database_id,
+            page_size=page_size,
+            filter_conditions=filter_conditions,
+            sorts=sorts,
+        ):
+            yield page_manager

notionary/core/database/database_schema_service.py

@@ -0,0 +1,57 @@
+from typing import Dict, List
+from notionary.core.database.notion_database_schema import NotionDatabaseSchema
+
+
+class DatabaseSchemaService:
+    """Service für den Zugriff auf Datenbankschema-Informationen"""
+
+    def __init__(self, schema: NotionDatabaseSchema):
+        self._schema = schema
+
+    async def get_property_types(self) -> Dict[str, str]:
+        """
+        Get all property types for the database.
+
+        Returns:
+            Dictionary mapping property names to their types
+        """
+        return await self._schema.get_property_types()
+
+    async def get_select_options(self, property_name: str) -> List[Dict[str, str]]:
+        """
+        Get options for a select, multi-select, or status property.
+
+        Args:
+            property_name: Name of the property
+
+        Returns:
+            List of select options with name, id, and color (if available)
+        """
+        options = await self._schema.get_select_options(property_name)
+        return [
+            {
+                "name": option.get("name", ""),
+                "id": option.get("id", ""),
+                "color": option.get("color", ""),
+            }
+            for option in options
+        ]
+
+    async def get_relation_options(
+        self, property_name: str, limit: int = 100
+    ) -> List[Dict[str, str]]:
+        """
+        Get available options for a relation property.
+
+        Args:
+            property_name: Name of the relation property
+            limit: Maximum number of options to retrieve
+
+        Returns:
+            List of relation options with id and title
+        """
+        options = await self._schema.get_relation_options(property_name, limit)
+        return [
+            {"id": option.get("id", ""), "title": option.get("title", "")}
+            for option in options
+        ]

notionary/core/database/models/page_result.py

@@ -0,0 +1,10 @@
+from typing import Optional, TypedDict
+
+
+class PageResult(TypedDict, total=False):
+    """Type definition for page operation results."""
+
+    success: bool
+    page_id: str
+    url: Optional[str]
+    message: Optional[str]