notionary 0.1.10__py3-none-any.whl → 0.1.12__py3-none-any.whl

notionary/__init__.py

@@ -1,9 +1,20 @@
-from .core.page.notion_page_manager import NotionPageManager
+from .core.notion_client import NotionClient
+
 from .core.database.notion_database_manager import NotionDatabaseManager
 from .core.database.notion_database_manager_factory import NotionDatabaseFactory
+from .core.database.database_discovery import DatabaseDiscovery
+
+from .core.page.notion_page_manager import NotionPageManager
+
+from .core.converters.registry.block_element_registry import BlockElementRegistry
+from .core.converters.registry.block_element_registry_builder import BlockElementRegistryBuilder
 
 __all__ = [
-    "NotionPageManager",
+    "NotionClient",
     "NotionDatabaseManager",
     "NotionDatabaseFactory",
+    "DatabaseDiscovery",
+    "NotionPageManager",
+    "BlockElementRegistry",
+    "BlockElementRegistryBuilder",
 ]

notionary/core/converters/elements/audio_element.py

@@ -0,0 +1,143 @@
+import re
+from typing import Dict, Any, Optional, List
+from notionary.core.converters.elements.notion_block_element import NotionBlockElement
+
+
+class AudioElement(NotionBlockElement):
+    """
+    Handles conversion between Markdown audio embeds and Notion audio blocks.
+
+    Markdown audio syntax (custom format since standard Markdown doesn't support audio):
+    - $[Caption](https://example.com/audio.mp3) - Basic audio with caption
+    - $[](https://example.com/audio.mp3) - Audio without caption
+    - $[Caption](https://storage.googleapis.com/audio_summaries/example.mp3) - CDN hosted audio
+
+    Supports various audio URLs including direct audio file links from CDNs and other sources.
+    """
+
+    # Regex pattern for audio syntax
+    PATTERN = re.compile(
+        r"^\$\[(.*?)\]"  # $[Caption] part
+        + r'\((https?://[^\s"]+)'  # (URL part
+        + r"\)$"  # closing parenthesis
+    )
+
+    # Audio file extensions
+    AUDIO_EXTENSIONS = [".mp3", ".wav", ".ogg", ".m4a", ".flac", ".aac"]
+
+    @staticmethod
+    def match_markdown(text: str) -> bool:
+        """Check if text is a markdown audio embed."""
+        text = text.strip()
+        return text.startswith("$[") and bool(AudioElement.PATTERN.match(text))
+
+    @staticmethod
+    def match_notion(block: Dict[str, Any]) -> bool:
+        """Check if block is a Notion audio."""
+        return block.get("type") == "audio"
+
+    @staticmethod
+    def is_audio_url(url: str) -> bool:
+        """Check if URL points to an audio file."""
+        return (
+            any(url.lower().endswith(ext) for ext in AudioElement.AUDIO_EXTENSIONS)
+            or "audio" in url.lower()
+            or "storage.googleapis.com/audio_summaries" in url.lower()
+        )
+
+    @staticmethod
+    def markdown_to_notion(text: str) -> Optional[Dict[str, Any]]:
+        """Convert markdown audio embed to Notion audio block."""
+        audio_match = AudioElement.PATTERN.match(text.strip())
+        if not audio_match:
+            return None
+
+        caption = audio_match.group(1)
+        url = audio_match.group(2)
+
+        if not url:
+            return None
+
+        # Make sure this is an audio URL
+        if not AudioElement.is_audio_url(url):
+            # If not obviously an audio URL, we'll still accept it as the user might know better
+            pass
+
+        # Prepare the audio block
+        audio_block = {
+            "type": "audio",
+            "audio": {"type": "external", "external": {"url": url}},
+        }
+
+        # Add caption if provided
+        if caption:
+            audio_block["audio"]["caption"] = [
+                {"type": "text", "text": {"content": caption}}
+            ]
+
+        return audio_block
+
+    @staticmethod
+    def notion_to_markdown(block: Dict[str, Any]) -> Optional[str]:
+        """Convert Notion audio block to markdown audio embed."""
+        if block.get("type") != "audio":
+            return None
+
+        audio_data = block.get("audio", {})
+
+        # Handle both external and file (uploaded) audios
+        if audio_data.get("type") == "external":
+            url = audio_data.get("external", {}).get("url", "")
+        elif audio_data.get("type") == "file":
+            url = audio_data.get("file", {}).get("url", "")
+        else:
+            return None
+
+        if not url:
+            return None
+
+        # Extract caption if available
+        caption = ""
+        caption_rich_text = audio_data.get("caption", [])
+        if caption_rich_text:
+            caption = AudioElement._extract_text_content(caption_rich_text)
+
+        return f"$[{caption}]({url})"
+
+    @staticmethod
+    def is_multiline() -> bool:
+        """Audio embeds are single-line elements."""
+        return False
+
+    @staticmethod
+    def _extract_text_content(rich_text: List[Dict[str, Any]]) -> str:
+        """Extract plain text content from Notion rich_text elements."""
+        result = ""
+        for text_obj in rich_text:
+            if text_obj.get("type") == "text":
+                result += text_obj.get("text", {}).get("content", "")
+            elif "plain_text" in text_obj:
+                result += text_obj.get("plain_text", "")
+        return result
+
+    @classmethod
+    def get_llm_prompt_content(cls) -> dict:
+        """Returns information for LLM prompts about this element."""
+        return {
+            "description": "Embeds audio content from external sources like CDNs or direct audio URLs.",
+            "when_to_use": "Use audio embeds when you want to include audio content directly in your document. Audio embeds are useful for podcasts, music, voice recordings, or any content that benefits from audio explanation.",
+            "syntax": [
+                "$[](https://example.com/audio.mp3) - Audio without caption",
+                "$[Caption text](https://example.com/audio.mp3) - Audio with caption",
+            ],
+            "supported_sources": [
+                "Direct links to audio files (.mp3, .wav, .ogg, etc.)",
+                "Google Cloud Storage links (storage.googleapis.com)",
+                "Other audio hosting platforms supported by Notion",
+            ],
+            "examples": [
+                "$[Podcast Episode](https://storage.googleapis.com/audio_summaries/ep_ai_summary_127d02ec-ca12-4312-a5ed-cb14b185480c.mp3)",
+                "$[Voice recording](https://example.com/audio/recording.mp3)",
+                "$[](https://storage.googleapis.com/audio_summaries/example.mp3)",
+            ],
+        }

notionary/core/converters/elements/embed_element.py

@@ -16,9 +16,7 @@ class EmbedElement(NotionBlockElement):
     """
 
     PATTERN = re.compile(
-        r"^<embed(?:\:(.*?))?>(?:\s*)"
-        + r'\((https?://[^\s"]+)'
-        + r"\)$"
+        r"^<embed(?:\:(.*?))?>(?:\s*)" + r'\((https?://[^\s"]+)' + r"\)$"
     )
 
     @staticmethod
@@ -126,4 +124,4 @@ class EmbedElement(NotionBlockElement):
                 "<embed:Project documentation>(https://github.com/username/repo)",
                 "<embed>(https://example.com/important-reference.pdf)",
             ],
-        }
+        }

notionary/core/converters/elements/toggle_element.py

@@ -6,20 +6,15 @@ from notionary.core.converters.elements.notion_block_element import NotionBlockE
 
 class ToggleElement(NotionBlockElement):
     """
-    Handles conversion between Markdown toggle blocks and Notion toggle blocks.
-
-    Markdown toggle syntax:
-    +++ Toggle title
-       Indented content that belongs to the toggle
-       More indented content
-
-    Non-indented content marks the end of the toggle block.
+    Verbesserte ToggleElement-Klasse, die Kontext berücksichtigt.
     """
 
     TOGGLE_PATTERN = re.compile(r"^[+]{3}\s+(.+)$")
-
     INDENT_PATTERN = re.compile(r"^(\s{2,}|\t+)(.+)$")
 
+    # Ein neues Pattern, um spezifisch nach der "Transcript" Überschrift zu suchen
+    TRANSCRIPT_TOGGLE_PATTERN = re.compile(r"^[+]{3}\s+Transcript$")
+
     @staticmethod
     def match_markdown(text: str) -> bool:
         """Check if text is a markdown toggle."""
@@ -32,11 +27,7 @@ class ToggleElement(NotionBlockElement):
 
     @staticmethod
     def markdown_to_notion(text: str) -> Optional[Dict[str, Any]]:
-        """Convert markdown toggle to Notion toggle block.
-
-        Note: This method only converts the toggle title line.
-        The nested content needs to be processed separately.
-        """
+        """Convert markdown toggle to Notion toggle block."""
         toggle_match = ToggleElement.TOGGLE_PATTERN.match(text.strip())
         if not toggle_match:
             return None
@@ -149,18 +140,21 @@ class ToggleElement(NotionBlockElement):
 
     @classmethod
     def find_matches(
-        cls, text: str, process_nested_content: Callable = None
+        cls,
+        text: str,
+        process_nested_content: Callable = None,
+        context_aware: bool = True,
     ) -> List[Tuple[int, int, Dict[str, Any]]]:
         """
-        Find all toggle elements in the text and process them.
+        Verbesserte find_matches-Methode, die Kontext beim Finden von Toggles berücksichtigt.
 
         Args:
-            text: The text to search in
-            process_nested_content: Optional callback function to process nested content
-                It should accept a string and return a list of Notion blocks
+            text: Der zu durchsuchende Text
+            process_nested_content: Optionale Callback-Funktion zur Verarbeitung verschachtelter Inhalte
+            context_aware: Ob der Kontext (vorhergehende Zeilen) beim Finden von Toggles berücksichtigt werden soll
 
         Returns:
-            List of (start_pos, end_pos, block) tuples
+            Liste von (start_pos, end_pos, block) Tupeln
         """
         if not text:
             return []
@@ -177,6 +171,20 @@ class ToggleElement(NotionBlockElement):
                 i += 1
                 continue
 
+            # Wenn context_aware aktiviert ist, prüfen wir für "Transcript"-Toggles
+            # ob sie direkt nach einem Bullet Point kommen
+            is_transcript_toggle = cls.TRANSCRIPT_TOGGLE_PATTERN.match(line.strip())
+
+            if context_aware and is_transcript_toggle:
+                # Prüfen, ob der Toggle in einem gültigen Kontext ist (nach Bullet Point)
+                if i > 0 and lines[i - 1].strip().startswith("- "):
+                    # Gültiger Kontext, fahre fort
+                    pass
+                else:
+                    # Ungültiger Kontext für Transcript-Toggle, überspringe ihn
+                    i += 1
+                    continue
+
             start_pos = 0
             for j in range(i):
                 start_pos += len(lines[j]) + 1

notionary/core/converters/markdown_to_notion_converter.py

@@ -12,6 +12,8 @@ class MarkdownToNotionConverter:
     SPACER_MARKER = "<!-- spacer -->"
     MULTILINE_CONTENT_MARKER = "<!-- REMOVED_MULTILINE_CONTENT -->"
     TOGGLE_MARKER = "<!-- toggle_content -->"
+    TOGGLE_MARKER_PREFIX = "<!-- toggle_"
+    TOGGLE_MARKER_SUFFIX = " -->"
 
     def __init__(self, block_registry: Optional[BlockElementRegistry] = None):
         """
@@ -46,38 +48,48 @@ class MarkdownToNotionConverter:
         if not markdown_text:
             return []
 
-        # Process toggles first
-        processed_text, toggle_blocks = self._extract_toggle_elements(markdown_text)
+        # We'll process all blocks in order, preserving their original positions
+        all_blocks = []
+
+        # First, identify all toggle blocks
+        toggle_blocks = self._identify_toggle_blocks(markdown_text)
+
+        # If we have toggles, process them and extract positions
+        if toggle_blocks:
+            all_blocks.extend(toggle_blocks)
 
         # Process other multiline elements
-        processed_text, multiline_blocks = self._extract_multiline_elements(
-            processed_text
-        )
+        multiline_blocks = self._identify_multiline_blocks(markdown_text, toggle_blocks)
+        if multiline_blocks:
+            all_blocks.extend(multiline_blocks)
 
         # Process remaining text line by line
-        line_blocks = self._process_text_lines(processed_text)
+        line_blocks = self._process_text_lines(
+            markdown_text, toggle_blocks + multiline_blocks
+        )
+        if line_blocks:
+            all_blocks.extend(line_blocks)
 
-        # Combine and sort all blocks
-        all_blocks = toggle_blocks + multiline_blocks + line_blocks
+        # Sort all blocks by their position in the text
         all_blocks.sort(key=lambda x: x[0])
 
-        # Extract just the blocks from position tuples
+        # Extract just the blocks without position information
         blocks = [block for _, _, block in all_blocks]
 
         # Process spacing between blocks
         return self._process_block_spacing(blocks)
 
-    def _extract_toggle_elements(
+    def _identify_toggle_blocks(
         self, text: str
-    ) -> Tuple[str, List[Tuple[int, int, Dict[str, Any]]]]:
+    ) -> List[Tuple[int, int, Dict[str, Any]]]:
         """
-        Extract toggle elements and their nested content using the ToggleElement class.
+        Identify all toggle blocks in the text without replacing them.
 
         Args:
             text: The text to process
 
         Returns:
-            Tuple of (processed text, list of (start_pos, end_pos, block) tuples)
+            List of (start_pos, end_pos, block) tuples
         """
         # Find toggle element in registry
         toggle_element = None
@@ -91,67 +103,28 @@ class MarkdownToNotionConverter:
                 break
 
         if not toggle_element:
-            # No toggle element found, return text as is
-            return text, []
+            return []
 
-        # Use the find_matches method of ToggleElement to find and process all toggles
+        # Use the find_matches method with context awareness
         # Pass the converter's convert method as a callback to process nested content
-        toggle_blocks = toggle_element.find_matches(text, self.convert)
-
-        if not toggle_blocks:
-            return text, []
-
-        # Create a processed text with toggle markers
-        lines = text.split("\n")
-        processed_lines = lines.copy()
-
-        # Replace toggle content with markers
-        for start_pos, end_pos, _ in reversed(toggle_blocks):
-            # Calculate line indices for this toggle
-            start_line_index = 0
-            current_pos = 0
-            for i, line in enumerate(lines):
-                line_length = len(line) + 1  # +1 for newline
-                if current_pos <= start_pos < current_pos + line_length:
-                    start_line_index = i
-                    break
-                current_pos += line_length
-
-            end_line_index = start_line_index
-            current_pos = 0
-            for i, line in enumerate(lines):
-                line_length = len(line) + 1  # +1 for newline
-                if current_pos <= end_pos < current_pos + line_length:
-                    end_line_index = i
-                    break
-                current_pos += line_length
-
-            # Replace toggle content with markers
-            num_lines = end_line_index - start_line_index + 1
-            for i in range(start_line_index, start_line_index + num_lines):
-                processed_lines[i] = self.TOGGLE_MARKER
-
-        processed_text = "\n".join(processed_lines)
-        return processed_text, toggle_blocks
+        toggle_blocks = toggle_element.find_matches(
+            text, self.convert, context_aware=True
+        )
+        return toggle_blocks
 
-    def _extract_multiline_elements(
-        self, text: str
-    ) -> Tuple[str, List[Tuple[int, int, Dict[str, Any]]]]:
+    def _identify_multiline_blocks(
+        self, text: str, exclude_blocks: List[Tuple[int, int, Dict[str, Any]]]
+    ) -> List[Tuple[int, int, Dict[str, Any]]]:
         """
-        Extract multiline elements and remove them from the text.
+        Identify all multiline blocks (except toggle blocks) without altering the text.
 
         Args:
             text: The text to process
+            exclude_blocks: Blocks to exclude (e.g., already identified toggle blocks)
 
         Returns:
-            Tuple of (processed text, list of (start_pos, end_pos, block) tuples)
+            List of (start_pos, end_pos, block) tuples
         """
-        if not text:
-            return text, []
-
-        multiline_blocks = []
-        processed_text = text
-
         # Get all multiline elements except ToggleElement
         multiline_elements = [
             element
@@ -160,51 +133,45 @@ class MarkdownToNotionConverter:
         ]
 
         if not multiline_elements:
-            return text, []
+            return []
 
+        # Create a set of ranges to exclude
+        exclude_ranges = set()
+        for start, end, _ in exclude_blocks:
+            exclude_ranges.update(range(start, end + 1))
+
+        multiline_blocks = []
         for element in multiline_elements:
             if not hasattr(element, "find_matches"):
                 continue
 
-            # Find all matches for this element (pass the convert method as callback if needed)
+            # Find all matches for this element
             if hasattr(element, "set_converter_callback"):
-                matches = element.find_matches(processed_text, self.convert)
+                matches = element.find_matches(text, self.convert)
             else:
-                matches = element.find_matches(processed_text)
+                matches = element.find_matches(text)
 
             if not matches:
                 continue
 
-            multiline_blocks.extend(matches)
+            # Add only blocks that don't overlap with excluded ranges
+            for start, end, block in matches:
+                # Check if this block overlaps with any excluded range
+                if any(start <= i <= end for i in exclude_ranges):
+                    continue
+                multiline_blocks.append((start, end, block))
 
-            # Remove matched content from the text to avoid processing it again
-            processed_text = self._replace_matched_content_with_markers(
-                processed_text, matches
-            )
-
-        return processed_text, multiline_blocks
-
-    def _replace_matched_content_with_markers(
-        self, text: str, matches: List[Tuple[int, int, Dict[str, Any]]]
-    ) -> str:
-        """Replace matched content with marker placeholders to preserve line structure."""
-        for start, end, _ in reversed(matches):
-            num_newlines = text[start:end].count("\n")
-            text = (
-                text[:start]
-                + "\n"
-                + self.MULTILINE_CONTENT_MARKER
-                + "\n" * num_newlines
-                + text[end:]
-            )
-        return text
+        return multiline_blocks
 
-    def _process_text_lines(self, text: str) -> List[Tuple[int, int, Dict[str, Any]]]:
+    def _process_text_lines(
+        self, text: str, exclude_blocks: List[Tuple[int, int, Dict[str, Any]]]
+    ) -> List[Tuple[int, int, Dict[str, Any]]]:
         """
-        Process text line by line for single-line elements.
+        Process text line by line, excluding ranges already processed.
 
         Args:
             text: The text to process
+            exclude_blocks: Blocks to exclude (e.g., already identified toggle and multiline blocks)
 
         Returns:
             List of (start_pos, end_pos, block) tuples
@@ -212,6 +179,11 @@ class MarkdownToNotionConverter:
         if not text:
             return []
 
+        # Create a set of excluded positions
+        exclude_positions = set()
+        for start, end, _ in exclude_blocks:
+            exclude_positions.update(range(start, end + 1))
+
         line_blocks = []
         lines = text.split("\n")
 
@@ -222,9 +194,10 @@ class MarkdownToNotionConverter:
 
         for line in lines:
             line_length = len(line) + 1  # +1 for newline
+            line_end = current_pos + line_length - 1
 
-            # Skip marker lines
-            if self._is_marker_line(line):
+            # Skip lines that are part of excluded blocks
+            if any(current_pos <= pos <= line_end for pos in exclude_positions):
                 current_pos += line_length
                 continue
 
@@ -233,7 +206,7 @@ class MarkdownToNotionConverter:
                 line_blocks.append(
                     (
                         current_pos,
-                        current_pos + line_length,
+                        current_pos + line_length - 1,
                         self._create_empty_paragraph(),
                     )
                 )
@@ -273,7 +246,7 @@ class MarkdownToNotionConverter:
                     current_paragraph, paragraph_start, current_pos, line_blocks
                 )
                 line_blocks.append(
-                    (current_pos, current_pos + line_length, special_block)
+                    (current_pos, current_pos + line_length - 1, special_block)
                 )
                 current_paragraph = []
                 current_pos += line_length
@@ -292,18 +265,6 @@ class MarkdownToNotionConverter:
 
         return line_blocks
 
-    def _is_marker_line(self, line: str) -> bool:
-        """Check if a line is any kind of marker line that should be skipped."""
-        return self._is_multiline_marker(line) or self._is_toggle_marker(line)
-
-    def _is_multiline_marker(self, line: str) -> bool:
-        """Check if a line is a multiline content marker."""
-        return line.strip() == self.MULTILINE_CONTENT_MARKER
-
-    def _is_toggle_marker(self, line: str) -> bool:
-        """Check if a line is a toggle content marker."""
-        return line.strip() == self.TOGGLE_MARKER
-
     def _is_spacer_marker(self, line: str) -> bool:
         """Check if a line is a spacer marker."""
         return line.strip() == self.SPACER_MARKER
@@ -343,7 +304,7 @@ class MarkdownToNotionConverter:
             )
             current_paragraph.clear()
 
-        line_blocks.append((current_pos, current_pos + line_length, todo_block))
+        line_blocks.append((current_pos, current_pos + line_length - 1, todo_block))
 
     def _extract_special_block(self, line: str) -> Optional[Dict[str, Any]]:
         """

notionary/core/converters/registry/block_element_registry.py

@@ -95,8 +95,8 @@ class BlockElementRegistry:
         """
         # Create a copy of registered elements
         element_classes = self._elements.copy()
-        
-        # TODO: Das hier besser formattieren und über debug level lösen . ) 
+
+        # TODO: Das hier besser formattieren und über debug level lösen . )
         print("Elements in registry:", element_classes)
 
         formatter_names = [e.__name__ for e in element_classes]
@@ -234,7 +234,3 @@ paragraphs, lists, quotes, etc.
         element_docs = cls.generate_element_docs(element_classes)
 
         return cls.SYSTEM_PROMPT_TEMPLATE.format(element_docs=element_docs)
-
-
-
-# TODO: Testen ob der Inline Formatter hier überhaupt funktionieren tut:

notionary/core/converters/registry/block_element_registry_builder.py

@@ -1,6 +1,7 @@
 from typing import List, Type
 from collections import OrderedDict
 
+from notionary.core.converters.elements.audio_element import AudioElement
 from notionary.core.converters.elements.embed_element import EmbedElement
 from notionary.core.converters.elements.notion_block_element import NotionBlockElement
 from notionary.core.converters.registry.block_element_registry import (
@@ -92,6 +93,7 @@ class BlockElementRegistryBuilder:
             .add_element(ImageElement)
             .add_element(VideoElement)
             .add_element(EmbedElement)
+            .add_element(AudioElement)
             .add_element(ParagraphElement)
         )  # Add paragraph last as fallback