notionary 0.1.11__tar.gz → 0.1.12__tar.gz

{notionary-0.1.11 → notionary-0.1.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: notionary
-Version: 0.1.11
+Version: 0.1.12
 Summary: A toolkit to convert between Markdown and Notion blocks
 Home-page: https://github.com/mathisarends/notionary
 Author: Mathis Arends

notionary-0.1.12/notionary/__init__.py

@@ -0,0 +1,20 @@
+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__ = [
+    "NotionClient",
+    "NotionDatabaseManager",
+    "NotionDatabaseFactory",
+    "DatabaseDiscovery",
+    "NotionPageManager",
+    "BlockElementRegistry",
+    "BlockElementRegistryBuilder",
+]

{notionary-0.1.11 → notionary-0.1.12}/notionary/core/converters/elements/audio_element.py

@@ -39,9 +39,11 @@ class AudioElement(NotionBlockElement):
     @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()
+        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]]:
@@ -138,4 +140,4 @@ class AudioElement(NotionBlockElement):
                 "$[Voice recording](https://example.com/audio/recording.mp3)",
                 "$[](https://storage.googleapis.com/audio_summaries/example.mp3)",
             ],
-        }
+        }

{notionary-0.1.11 → notionary-0.1.12}/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-0.1.11 → notionary-0.1.12}/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-0.1.11 → notionary-0.1.12}/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-0.1.11 → notionary-0.1.12}/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]
@@ -233,4 +233,4 @@ paragraphs, lists, quotes, etc.
         """
         element_docs = cls.generate_element_docs(element_classes)
 
-        return cls.SYSTEM_PROMPT_TEMPLATE.format(element_docs=element_docs)
+        return cls.SYSTEM_PROMPT_TEMPLATE.format(element_docs=element_docs)

notionary-0.1.12/notionary/core/database/database_discovery.py

@@ -0,0 +1,140 @@
+from typing import (
+    AsyncGenerator,
+    Dict,
+    List,
+    Optional,
+    Any,
+    Tuple,
+)
+from notionary.core.notion_client import NotionClient
+from notionary.util.logging_mixin import LoggingMixin
+
+
+class DatabaseDiscovery(LoggingMixin):
+    """
+    A utility class that discovers Notion databases accessible to your integration.
+    Focused on efficiently retrieving essential database information.
+    """
+
+    def __init__(self, client: Optional[NotionClient] = None) -> None:
+        """
+        Initialize the database discovery with a NotionClient.
+
+        Args:
+            client: NotionClient instance for API communication
+        """
+        self._client = client if client else NotionClient()
+        self.logger.info("DatabaseDiscovery initialized")
+
+    async def discover(self, page_size: int = 100) -> List[Tuple[str, str]]:
+        """
+        Discover all accessible databases and return their titles and IDs.
+
+        Args:
+            page_size: The number of databases to fetch per request
+
+        Returns:
+            List of tuples containing (database_title, database_id)
+        """
+        databases = []
+        
+        async for database in self._iter_databases(page_size):
+            db_id = database.get("id")
+            if not db_id:
+                continue
+                
+            title = self._extract_database_title(database)
+            databases.append((title, db_id))
+            
+        return databases
+        
+    async def discover_and_print(self, page_size: int = 100) -> List[Tuple[str, str]]:
+        """
+        Discover databases and print the results in a nicely formatted way.
+        
+        This is a convenience method that discovers databases and handles
+        the formatting and printing of results.
+        
+        Args:
+            page_size: The number of databases to fetch per request
+            
+        Returns:
+            The same list of databases as discover() for further processing
+        """
+        databases = await self.discover(page_size)
+        
+        if not databases:
+            print("\n⚠️ No databases found!")
+            print("Please ensure your Notion integration has access to databases.")
+            print("You need to share the databases with your integration in Notion settings.")
+            return databases
+            
+        print(f"✅ Found {len(databases)} databases:")
+        
+        for i, (title, db_id) in enumerate(databases, 1):
+            print(f"{i}. {title} (ID: {db_id})")
+        
+        return databases
+
+    async def _iter_databases(
+        self, page_size: int = 100
+    ) -> AsyncGenerator[Dict[str, Any], None]:
+        """
+        Asynchronous generator that yields Notion databases one by one.
+
+        Uses the Notion API to provide paginated access to all databases
+        without loading all of them into memory at once.
+
+        Args:
+            page_size: The number of databases to fetch per request
+
+        Yields:
+            Individual database objects from the Notion API
+        """
+        start_cursor: Optional[str] = None
+
+        while True:
+            body: Dict[str, Any] = {
+                "filter": {"value": "database", "property": "object"},
+                "page_size": page_size,
+            }
+
+            if start_cursor:
+                body["start_cursor"] = start_cursor
+
+            result = await self._client.post("search", data=body)
+
+            if not result or "results" not in result:
+                self.logger.error("Error fetching databases")
+                return
+
+            for database in result["results"]:
+                yield database
+
+            if not result.get("has_more") or not result.get("next_cursor"):
+                return
+                
+            start_cursor = result["next_cursor"]
+
+    def _extract_database_title(self, database: Dict[str, Any]) -> str:
+        """
+        Extract the database title from a Notion API response.
+
+        Args:
+            database: The database object from the Notion API
+
+        Returns:
+            The extracted title or "Untitled" if no title is found
+        """
+        if "title" not in database:
+            return "Untitled"
+            
+        title_parts = []
+        for text_obj in database["title"]:
+            if "plain_text" in text_obj:
+                title_parts.append(text_obj["plain_text"])
+
+        if not title_parts:
+            return "Untitled"
+            
+        return "".join(title_parts)