notionary 0.2.13__py3-none-any.whl → 0.2.15__py3-none-any.whl

notionary/{prompting/element_prompt_content.py → blocks/prompts/element_prompt_builder.py}

@@ -1,44 +1,5 @@
-from dataclasses import field, dataclass
 from typing import Optional, List, Self
-
-
-@dataclass
-class ElementPromptContent:
-    """
-    Dataclass defining the standardized structure for element prompt content.
-    This ensures consistent formatting across all Notion block elements.
-    """
-
-    description: str
-    """Concise explanation of what the element is and its purpose in Notion."""
-
-    syntax: str
-    """The exact markdown syntax pattern used to create this element."""
-
-    when_to_use: str
-    """Guidelines explaining the appropriate scenarios for using this element."""
-
-    examples: List[str] = field(default_factory=list)
-    """List of practical usage examples showing the element in context."""
-
-    avoid: Optional[str] = None
-    """Optional field listing scenarios when this element should be avoided."""
-
-    is_standard_markdown: bool = False
-    """Indicates whether this element follows standard Markdown syntax (and does not require full examples)."""
-
-    def __post_init__(self):
-        """Validates that the content meets minimum requirements."""
-        if not self.description:
-            raise ValueError("Description is required")
-        if not self.syntax:
-            raise ValueError("Syntax is required")
-        if not self.examples and not self.is_standard_markdown:
-            raise ValueError(
-                "At least one example is required unless it's standard markdown."
-            )
-        if not self.when_to_use:
-            raise ValueError("Usage guidelines are required")
+from notionary.blocks.prompts.element_prompt_content import ElementPromptContent
 
 
 class ElementPromptBuilder:

notionary/blocks/prompts/element_prompt_content.py

@@ -0,0 +1,41 @@
+from dataclasses import field, dataclass
+from typing import Optional, List
+
+
+@dataclass
+class ElementPromptContent:
+    """
+    Dataclass defining the standardized structure for element prompt content.
+    This ensures consistent formatting across all Notion block elements.
+    """
+
+    description: str
+    """Concise explanation of what the element is and its purpose in Notion."""
+
+    syntax: str
+    """The exact markdown syntax pattern used to create this element."""
+
+    when_to_use: str
+    """Guidelines explaining the appropriate scenarios for using this element."""
+
+    examples: List[str] = field(default_factory=list)
+    """List of practical usage examples showing the element in context."""
+
+    avoid: Optional[str] = None
+    """Optional field listing scenarios when this element should be avoided."""
+
+    is_standard_markdown: bool = False
+    """Indicates whether this element follows standard Markdown syntax (and does not require full examples)."""
+
+    def __post_init__(self):
+        """Validates that the content meets minimum requirements."""
+        if not self.description:
+            raise ValueError("Description is required")
+        if not self.syntax:
+            raise ValueError("Syntax is required")
+        if not self.examples and not self.is_standard_markdown:
+            raise ValueError(
+                "At least one example is required unless it's standard markdown."
+            )
+        if not self.when_to_use:
+            raise ValueError("Usage guidelines are required")

notionary/{elements → blocks}/qoute_element.py

@@ -1,10 +1,9 @@
 import re
 from typing import Dict, Any, Optional, List, Tuple
-from notionary.elements.notion_block_element import NotionBlockElement
-from notionary.prompting.element_prompt_content import (
-    ElementPromptBuilder,
-    ElementPromptContent,
-)
+
+from notionary.blocks import NotionBlockElement
+from notionary.blocks import ElementPromptContent, ElementPromptBuilder
+
 
 class QuoteElement(NotionBlockElement):
     """Class for converting between Markdown blockquotes and Notion quote blocks."""

notionary/{elements → blocks}/registry/block_registry.py

@@ -1,13 +1,13 @@
 from __future__ import annotations
 from typing import Dict, Any, Optional, List, Set, Type
 
-from notionary.elements.notion_block_element import NotionBlockElement
-from notionary.prompting.markdown_syntax_prompt_generator import (
+from notionary.blocks.notion_block_element import NotionBlockElement
+from notionary.page.markdown_syntax_prompt_generator import (
     MarkdownSyntaxPromptGenerator,
 )
-from notionary.elements.text_inline_formatter import TextInlineFormatter
+from notionary.blocks.text_inline_formatter import TextInlineFormatter
 
-from notionary.elements.notion_block_element import NotionBlockElement
+from notionary.blocks import NotionBlockElement
 
 
 class BlockRegistry:
@@ -28,28 +28,6 @@ class BlockRegistry:
             for element in elements:
                 self.register(element)
 
-    def to_builder(self):
-        """
-        Convert this registry to a builder for modifications.
-        Imports only when needed to avoid circular imports.
-        """
-        from notionary.elements.registry.block_registry_builder import (
-            BlockRegistryBuilder,
-        )
-
-        builder = BlockRegistryBuilder()
-        for element in self._elements:
-            builder.add_element(element)
-        return builder
-
-    @property
-    def builder(self):
-        """
-        Returns a new builder pre-configured with the current registry elements.
-        Uses lazy import to avoid circular dependencies.
-        """
-        return self.to_builder()
-
     def register(self, element_class: Type[NotionBlockElement]) -> bool:
         """
         Register an element class.

notionary/{elements → blocks}/registry/block_registry_builder.py

@@ -1,33 +1,32 @@
 from __future__ import annotations
-from typing import List, Type
+from typing import List, Type, TYPE_CHECKING
 from collections import OrderedDict
 
-from notionary.elements.column_element import ColumnElement
-from notionary.elements.notion_block_element import NotionBlockElement
-
-from notionary.elements.audio_element import AudioElement
-from notionary.elements.bulleted_list_element import BulletedListElement
-from notionary.elements.embed_element import EmbedElement
-from notionary.elements.mention_element import MentionElement
-from notionary.elements.notion_block_element import NotionBlockElement
-from notionary.elements.numbered_list_element import NumberedListElement
-from notionary.elements.registry.block_registry import (
-    BlockRegistry,
+from notionary.blocks import (
+    ParagraphElement,
+    AudioElement,
+    BulletedListElement,
+    CalloutElement,
+    CodeBlockElement,
+    ColumnElement,
+    DividerElement,
+    EmbedElement,
+    HeadingElement,
+    ImageElement,
+    MentionElement,
+    NumberedListElement,
+    TableElement,
+    TodoElement,
+    ToggleElement,
+    ToggleableHeadingElement,
+    VideoElement,
+    BookmarkElement,
+    QuoteElement,
+    NotionBlockElement,
 )
 
-from notionary.elements.paragraph_element import ParagraphElement
-from notionary.elements.heading_element import HeadingElement
-from notionary.elements.callout_element import CalloutElement
-from notionary.elements.code_block_element import CodeBlockElement
-from notionary.elements.divider_element import DividerElement
-from notionary.elements.table_element import TableElement
-from notionary.elements.todo_element import TodoElement
-from notionary.elements.qoute_element import QuoteElement
-from notionary.elements.image_element import ImageElement
-from notionary.elements.toggleable_heading_element import ToggleableHeadingElement
-from notionary.elements.video_element import VideoElement
-from notionary.elements.toggle_element import ToggleElement
-from notionary.elements.bookmark_element import BookmarkElement
+if TYPE_CHECKING:
+    from notionary.blocks import BlockRegistry
 
 
 class BlockRegistryBuilder:
@@ -281,6 +280,8 @@ class BlockRegistryBuilder:
         Returns:
             A configured BlockRegistry instance
         """
+        from notionary.blocks import BlockRegistry
+
         if ParagraphElement.__name__ not in self._elements:
             self.add_element(ParagraphElement)
         else:

notionary/{elements → blocks}/table_element.py

@@ -1,11 +1,10 @@
 import re
 from typing import Dict, Any, Optional, List, Tuple
-from notionary.elements.notion_block_element import NotionBlockElement
-from notionary.elements.text_inline_formatter import TextInlineFormatter
-from notionary.prompting.element_prompt_content import (
-    ElementPromptBuilder,
-    ElementPromptContent,
-)
+
+from notionary.blocks import NotionBlockElement
+from notionary.blocks.text_inline_formatter import TextInlineFormatter
+from notionary.blocks import ElementPromptContent, ElementPromptBuilder
+
 
 class TableElement(NotionBlockElement):
     """

notionary/{elements → blocks}/text_inline_formatter.py

@@ -1,10 +1,7 @@
 from typing import Dict, Any, List, Tuple
 import re
 
-from notionary.prompting.element_prompt_content import (
-    ElementPromptBuilder,
-    ElementPromptContent,
-)
+from notionary.blocks import ElementPromptBuilder, ElementPromptContent
 
 
 class TextInlineFormatter:

notionary/{elements → blocks}/todo_element.py

@@ -1,11 +1,10 @@
 import re
 from typing import Dict, Any, Optional
-from notionary.elements.notion_block_element import NotionBlockElement
-from notionary.prompting.element_prompt_content import (
-    ElementPromptBuilder,
-    ElementPromptContent,
-)
-from notionary.elements.text_inline_formatter import TextInlineFormatter
+
+from notionary.blocks import NotionBlockElement
+from notionary.blocks import ElementPromptContent, ElementPromptBuilder
+from notionary.blocks.text_inline_formatter import TextInlineFormatter
+
 
 class TodoElement(NotionBlockElement):
     """

notionary/{elements → blocks}/toggle_element.py

@@ -1,11 +1,9 @@
 import re
 from typing import Dict, Any, Optional, List, Tuple, Callable
 
-from notionary.elements.notion_block_element import NotionBlockElement
-from notionary.prompting.element_prompt_content import (
-    ElementPromptBuilder,
-    ElementPromptContent,
-)
+from notionary.blocks import NotionBlockElement
+from notionary.blocks import ElementPromptContent, ElementPromptBuilder
+
 
 class ToggleElement(NotionBlockElement):
     """

notionary/{elements → blocks}/toggleable_heading_element.py

@@ -1,12 +1,10 @@
 import re
 from typing import Dict, Any, Optional, List, Tuple, Callable
 
-from notionary.elements.notion_block_element import NotionBlockElement
-from notionary.prompting.element_prompt_content import (
-    ElementPromptBuilder,
-    ElementPromptContent,
-)
-from notionary.elements.text_inline_formatter import TextInlineFormatter
+from notionary.blocks import NotionBlockElement
+from notionary.blocks import ElementPromptContent, ElementPromptBuilder
+from notionary.blocks.text_inline_formatter import TextInlineFormatter
+
 
 class ToggleableHeadingElement(NotionBlockElement):
     """Handles conversion between Markdown collapsible headings and Notion toggleable heading blocks with pipe syntax."""

notionary/{elements → blocks}/video_element.py

@@ -1,10 +1,9 @@
 import re
 from typing import Dict, Any, Optional, List
-from notionary.elements.notion_block_element import NotionBlockElement
-from notionary.prompting.element_prompt_content import (
-    ElementPromptBuilder,
-    ElementPromptContent,
-)
+
+from notionary.blocks import NotionBlockElement
+from notionary.blocks import ElementPromptContent, ElementPromptBuilder
+
 
 class VideoElement(NotionBlockElement):
     """

notionary/database/client.py

@@ -0,0 +1,132 @@
+from typing import Dict, Any, Optional
+from dotenv import load_dotenv
+from notionary.base_notion_client import BaseNotionClient
+
+from notionary.models.notion_database_response import (
+    NotionDatabaseResponse,
+    NotionDatabaseSearchResponse,
+    NotionPageResponse,
+    NotionQueryDatabaseResponse,
+)
+from notionary.util import singleton
+
+load_dotenv()
+
+
+@singleton
+class NotionDatabaseClient(BaseNotionClient):
+    """
+    Specialized Notion client for database operations.
+    Inherits connection management and HTTP methods from BaseNotionClient.
+    """
+
+    def __init__(self, token: Optional[str] = None, timeout: int = 30):
+        super().__init__(token, timeout)
+
+    async def get_database(self, database_id: str) -> NotionDatabaseResponse:
+        """
+        Gets metadata for a Notion database by its ID.
+        """
+        response = await self.get(f"databases/{database_id}")
+        return NotionDatabaseResponse.model_validate(response)
+
+    async def patch_database(
+        self, database_id: str, data: Dict[str, Any]
+    ) -> NotionDatabaseResponse:
+        """
+        Updates a Notion database with the provided data.
+        """
+        response = await self.patch(f"databases/{database_id}", data=data)
+        return NotionDatabaseResponse.model_validate(response)
+
+    async def query_database(
+        self, database_id: str, query_data: Dict[str, Any] = None
+    ) -> NotionQueryDatabaseResponse:
+        """
+        Queries a Notion database with the provided filter and sorts.
+        """
+        response = await self.post(f"databases/{database_id}/query", data=query_data)
+        return NotionQueryDatabaseResponse.model_validate(response)
+
+    async def query_database_by_title(
+        self, database_id: str, page_title: str
+    ) -> NotionQueryDatabaseResponse:
+        """
+        Queries a Notion database by title.
+        """
+        query_data = {
+            "filter": {"property": "title", "title": {"contains": page_title}}
+        }
+
+        return await self.query_database(database_id=database_id, query_data=query_data)
+
+    async def search_databases(
+        self, query: str = "", sort_ascending: bool = True, limit: int = 100
+    ) -> NotionDatabaseSearchResponse:
+        """
+        Searches for databases in Notion using the search endpoint.
+
+        Args:
+            query: Search query string
+            sort_ascending: Whether to sort in ascending order
+            limit: Maximum number of results to return
+        """
+        search_data = {
+            "query": query,
+            "filter": {"value": "database", "property": "object"},
+            "sort": {
+                "direction": "ascending" if sort_ascending else "descending",
+                "timestamp": "last_edited_time",
+            },
+            "page_size": limit,
+        }
+
+        response = await self.post("search", search_data)
+        return NotionDatabaseSearchResponse.model_validate(response)
+
+    async def create_page(self, parent_database_id: str) -> NotionPageResponse:
+        """
+        Creates a new blank page in the given database with minimal properties.
+        """
+        page_data = {
+            "parent": {"database_id": parent_database_id},
+            "properties": {},
+        }
+        response = await self.post("pages", page_data)
+        return NotionPageResponse.model_validate(response)
+
+    async def update_database_title(
+        self, database_id: str, title: str
+    ) -> NotionDatabaseResponse:
+        """
+        Updates the title of a database.
+        """
+        data = {"title": [{"text": {"content": title}}]}
+        return await self.patch_database(database_id, data)
+
+    async def update_database_emoji(
+        self, database_id: str, emoji: str
+    ) -> NotionDatabaseResponse:
+        """
+        Updates the emoji/icon of a database.
+        """
+        data = {"icon": {"type": "emoji", "emoji": emoji}}
+        return await self.patch_database(database_id, data)
+
+    async def update_database_cover_image(
+        self, database_id: str, image_url: str
+    ) -> NotionDatabaseResponse:
+        """
+        Updates the cover image of a database.
+        """
+        data = {"cover": {"type": "external", "external": {"url": image_url}}}
+        return await self.patch_database(database_id, data)
+
+    async def update_database_external_icon(
+        self, database_id: str, icon_url: str
+    ) -> NotionDatabaseResponse:
+        """
+        Updates the database icon with an external image URL.
+        """
+        data = {"icon": {"type": "external", "external": {"url": icon_url}}}
+        return await self.patch_database(database_id, data)

notionary/database/database_exceptions.py

@@ -0,0 +1,13 @@
+class NotionDatabaseException(Exception):
+    """Base exception for all Notion database operations."""
+
+    pass
+
+
+class DatabaseNotFoundException(NotionDatabaseException):
+    """Exception raised when a database is not found."""
+
+    def __init__(self, identifier: str, message: str = None):
+        self.identifier = identifier
+        self.message = message or f"Database not found: {identifier}"
+        super().__init__(self.message)

notionary/database/filter_builder.py

@@ -0,0 +1,175 @@
+from __future__ import annotations
+
+from typing import Any, Dict, List
+from datetime import datetime, timedelta
+from dataclasses import dataclass, field
+
+
+@dataclass
+class FilterConfig:
+    """Einfache Konfiguration für Notion Database Filter."""
+
+    conditions: List[Dict[str, Any]] = field(default_factory=list)
+    page_size: int = 100
+
+    def to_filter_dict(self) -> Dict[str, Any]:
+        """Konvertiert zu einem Notion-Filter-Dictionary."""
+        if len(self.conditions) == 0:
+            return {}
+        if len(self.conditions) == 1:
+            return self.conditions[0]
+
+        return {"and": self.conditions}
+
+
+class FilterBuilder:
+    """
+    Builder class for creating complex Notion filters with comprehensive property type support.
+    """
+
+    def __init__(self, config: FilterConfig = None):
+        self.config = config or FilterConfig()
+
+    def with_page_object_filter(self) -> FilterBuilder:
+        """Filter: Nur Datenbank-Objekte (Notion API search)."""
+        self.config.conditions.append({"value": "page", "property": "object"})
+        return self
+
+    def with_database_object_filter(self) -> FilterBuilder:
+        """Filter: Nur Datenbank-Objekte (Notion API search)."""
+        self.config.conditions.append({"value": "database", "property": "object"})
+        return self
+
+    # TIMESTAMP FILTERS (Created/Updated)
+    def with_created_after(self, date: datetime) -> FilterBuilder:
+        """Add condition: created after specific date."""
+        self.config.conditions.append(
+            {"timestamp": "created_time", "created_time": {"after": date.isoformat()}}
+        )
+        return self
+
+    def with_created_before(self, date: datetime) -> FilterBuilder:
+        """Add condition: created before specific date."""
+        self.config.conditions.append(
+            {"timestamp": "created_time", "created_time": {"before": date.isoformat()}}
+        )
+        return self
+
+    def with_updated_after(self, date: datetime) -> FilterBuilder:
+        """Add condition: updated after specific date."""
+        self.config.conditions.append(
+            {
+                "timestamp": "last_edited_time",
+                "last_edited_time": {"after": date.isoformat()},
+            }
+        )
+        return self
+
+    def with_created_last_n_days(self, days: int) -> FilterBuilder:
+        """In den letzten N Tagen erstellt."""
+        cutoff = datetime.now() - timedelta(days=days)
+        return self.with_created_after(cutoff)
+
+    def with_updated_last_n_hours(self, hours: int) -> FilterBuilder:
+        """In den letzten N Stunden bearbeitet."""
+        cutoff = datetime.now() - timedelta(hours=hours)
+        return self.with_updated_after(cutoff)
+
+    # RICH TEXT FILTERS
+    def with_text_contains(self, property_name: str, value: str) -> FilterBuilder:
+        """Rich text contains value."""
+        self.config.conditions.append(
+            {"property": property_name, "rich_text": {"contains": value}}
+        )
+        return self
+
+    def with_text_equals(self, property_name: str, value: str) -> FilterBuilder:
+        """Rich text equals value."""
+        self.config.conditions.append(
+            {"property": property_name, "rich_text": {"equals": value}}
+        )
+        return self
+
+    # TITLE FILTERS
+    def with_title_contains(self, value: str) -> FilterBuilder:
+        """Title contains value."""
+        self.config.conditions.append(
+            {"property": "title", "title": {"contains": value}}
+        )
+        return self
+
+    def with_title_equals(self, value: str) -> FilterBuilder:
+        """Title equals value."""
+        self.config.conditions.append({"property": "title", "title": {"equals": value}})
+        return self
+
+    # SELECT FILTERS (Single Select)
+    def with_select_equals(self, property_name: str, value: str) -> FilterBuilder:
+        """Select equals value."""
+        self.config.conditions.append(
+            {"property": property_name, "select": {"equals": value}}
+        )
+        return self
+
+    def with_select_is_empty(self, property_name: str) -> FilterBuilder:
+        """Select is empty."""
+        self.config.conditions.append(
+            {"property": property_name, "select": {"is_empty": True}}
+        )
+        return self
+
+    def with_multi_select_contains(
+        self, property_name: str, value: str
+    ) -> FilterBuilder:
+        """Multi-select contains value."""
+        self.config.conditions.append(
+            {"property": property_name, "multi_select": {"contains": value}}
+        )
+        return self
+
+    def with_status_equals(self, property_name: str, value: str) -> FilterBuilder:
+        """Status equals value."""
+        self.config.conditions.append(
+            {"property": property_name, "status": {"equals": value}}
+        )
+        return self
+
+    def with_page_size(self, size: int) -> FilterBuilder:
+        """Set page size for pagination."""
+        self.config.page_size = size
+        return self
+
+    def with_or_condition(self, *builders: FilterBuilder) -> FilterBuilder:
+        """Add OR condition with multiple sub-conditions."""
+        or_conditions = []
+        for builder in builders:
+            filter_dict = builder.build()
+            if filter_dict:
+                or_conditions.append(filter_dict)
+
+        if len(or_conditions) > 1:
+            self.config.conditions.append({"or": or_conditions})
+        elif len(or_conditions) == 1:
+            self.config.conditions.append(or_conditions[0])
+
+        return self
+
+    def build(self) -> Dict[str, Any]:
+        """Build the final filter dictionary."""
+        return self.config.to_filter_dict()
+
+    def get_config(self) -> FilterConfig:
+        """Get the underlying FilterConfig."""
+        return self.config
+
+    def copy(self) -> FilterBuilder:
+        """Create a copy of the builder."""
+        new_config = FilterConfig(
+            conditions=self.config.conditions.copy(), page_size=self.config.page_size
+        )
+        return FilterBuilder(new_config)
+
+    def reset(self) -> FilterBuilder:
+        """Reset all conditions."""
+        self.config = FilterConfig()
+        return self