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

notionary/page/writer/handler/toggleable_heading_handler.py

@@ -32,21 +32,21 @@ class ToggleableHeadingHandler(LineHandler):
             or self._is_toggleable_heading_content(context)
         )
 
-    def _process(self, context: LineProcessingContext) -> None:
+    async def _process(self, context: LineProcessingContext) -> None:
         """Process toggleable heading start, end, or content with unified handling."""
 
-        def _handle(action):
-            action(context)
+        async def _handle(action):
+            await action(context)
             context.was_processed = True
             context.should_continue = True
             return True
 
         if self._is_toggleable_heading_start(context):
-            return _handle(self._start_toggleable_heading)
+            return await _handle(self._start_toggleable_heading)
         if self._is_toggleable_heading_end(context):
-            return _handle(self._finalize_toggleable_heading)
+            return await _handle(self._finalize_toggleable_heading)
         if self._is_toggleable_heading_content(context):
-            return _handle(self._add_toggleable_heading_content)
+            return await _handle(self._add_toggleable_heading_content)
 
     def _is_toggleable_heading_start(self, context: LineProcessingContext) -> bool:
         """Check if line starts a toggleable heading (+++# "Title")."""
@@ -64,16 +64,16 @@ class ToggleableHeadingHandler(LineHandler):
         current_parent = context.parent_stack[-1]
         return issubclass(current_parent.element_type, ToggleableHeadingElement)
 
-    def _start_toggleable_heading(self, context: LineProcessingContext) -> None:
+    async def _start_toggleable_heading(self, context: LineProcessingContext) -> None:
         """Start a new toggleable heading block."""
         toggleable_heading_element = ToggleableHeadingElement()
 
         # Create the block
-        result = toggleable_heading_element.markdown_to_notion(context.line)
+        result = await toggleable_heading_element.markdown_to_notion(context.line)
         if not result:
             return
 
-        block = result if not isinstance(result, list) else result[0]
+        block = result
 
         # Push to parent stack
         parent_context = ParentBlockContext(
@@ -96,16 +96,20 @@ class ToggleableHeadingHandler(LineHandler):
         line = context.line.strip()
         return not (self._start_pattern.match(line) or self._end_pattern.match(line))
 
-    def _add_toggleable_heading_content(self, context: LineProcessingContext) -> None:
+    async def _add_toggleable_heading_content(
+        self, context: LineProcessingContext
+    ) -> None:
         """Add content to the current toggleable heading context."""
         context.parent_stack[-1].add_child_line(context.line)
 
-    def _finalize_toggleable_heading(self, context: LineProcessingContext) -> None:
+    async def _finalize_toggleable_heading(
+        self, context: LineProcessingContext
+    ) -> None:
         """Finalize a toggleable heading block and add it to result_blocks."""
         heading_context = context.parent_stack.pop()
 
         if heading_context.has_children():
-            all_children = self._get_all_children(
+            all_children = await self._get_all_children(
                 heading_context, context.block_registry
             )
             self._assign_heading_children(heading_context.block, all_children)
@@ -123,7 +127,7 @@ class ToggleableHeadingHandler(LineHandler):
             # No parent, add to top level
             context.result_blocks.append(heading_context.block)
 
-    def _get_all_children(
+    async def _get_all_children(
         self, parent_context: ParentBlockContext, block_registry
     ) -> list:
         """Helper method to combine text-based and direct block children."""
@@ -132,7 +136,9 @@ class ToggleableHeadingHandler(LineHandler):
         # Process text lines
         if parent_context.child_lines:
             children_text = "\n".join(parent_context.child_lines)
-            text_blocks = self._convert_children_text(children_text, block_registry)
+            text_blocks = await self._convert_children_text(
+                children_text, block_registry
+            )
             children_blocks.extend(text_blocks)
 
         # Add direct blocks
@@ -154,7 +160,7 @@ class ToggleableHeadingHandler(LineHandler):
         elif block_type == BlockType.HEADING_3:
             parent_block.heading_3.children = children
 
-    def _convert_children_text(self, text: str, block_registry) -> list:
+    async def _convert_children_text(self, text: str, block_registry) -> list:
         """Convert children text to blocks."""
         from notionary.page.writer.markdown_to_notion_converter import (
             MarkdownToNotionConverter,
@@ -164,4 +170,4 @@ class ToggleableHeadingHandler(LineHandler):
             return []
 
         child_converter = MarkdownToNotionConverter(block_registry)
-        return child_converter._process_lines(text)
+        return await child_converter.process_lines(text)

notionary/page/writer/markdown_to_notion_converter.py

@@ -1,10 +1,10 @@
 from notionary.blocks.models import BlockCreateRequest
 from notionary.blocks.registry.block_registry import BlockRegistry
-from notionary.page.notion_text_length_utils import fix_blocks_content_length
 from notionary.page.writer.handler import (
     CodeHandler,
     ColumnHandler,
     ColumnListHandler,
+    EquationHandler,
     LineProcessingContext,
     ParentBlockContext,
     RegularLineHandler,
@@ -12,6 +12,12 @@ from notionary.page.writer.handler import (
     ToggleableHeadingHandler,
     ToggleHandler,
 )
+from notionary.page.writer.markdown_to_notion_formatting_post_processor import (
+    MarkdownToNotionFormattingPostProcessor,
+)
+from notionary.page.writer.notion_text_length_processor import (
+    NotionTextLengthProcessor,
+)
 
 
 class MarkdownToNotionConverter:
@@ -19,10 +25,14 @@ class MarkdownToNotionConverter:
 
     def __init__(self, block_registry: BlockRegistry) -> None:
         self._block_registry = block_registry
+        self._formatting_post_processor = MarkdownToNotionFormattingPostProcessor()
+        self._text_length_post_processor = NotionTextLengthProcessor()
+
         self._setup_handler_chain()
 
     def _setup_handler_chain(self) -> None:
         code_handler = CodeHandler()
+        equation_handler = EquationHandler()
         table_handler = TableHandler()
         column_list_handler = ColumnListHandler()
         column_handler = ColumnHandler()
@@ -31,22 +41,31 @@ class MarkdownToNotionConverter:
         regular_handler = RegularLineHandler()
 
         # register more specific elements first
-        code_handler.set_next(table_handler).set_next(column_list_handler).set_next(
-            column_handler
-        ).set_next(toggleable_heading_handler).set_next(toggle_handler).set_next(
+        code_handler.set_next(equation_handler).set_next(table_handler).set_next(
+            column_list_handler
+        ).set_next(column_handler).set_next(toggleable_heading_handler).set_next(
+            toggle_handler
+        ).set_next(
             regular_handler
         )
 
         self._handler_chain = code_handler
 
-    def convert(self, markdown_text: str) -> list[BlockCreateRequest]:
+    async def convert(self, markdown_text: str) -> list[BlockCreateRequest]:
         if not markdown_text.strip():
             return []
 
-        all_blocks = self._process_lines(markdown_text)
-        return fix_blocks_content_length(all_blocks)
+        all_blocks = await self.process_lines(markdown_text)
+
+        # Apply formatting post-processing (empty paragraphs)
+        all_blocks = self._formatting_post_processor.process(all_blocks)
+
+        # Apply text length post-processing (truncation)
+        all_blocks = self._text_length_post_processor.process(all_blocks)
+
+        return all_blocks
 
-    def _process_lines(self, text: str) -> list[BlockCreateRequest]:
+    async def process_lines(self, text: str) -> list[BlockCreateRequest]:
         lines = text.split("\n")
         result_blocks: list[BlockCreateRequest] = []
         parent_stack: list[ParentBlockContext] = []
@@ -65,7 +84,7 @@ class MarkdownToNotionConverter:
                 lines_consumed=0,
             )
 
-            self._handler_chain.handle(context)
+            await self._handler_chain.handle(context)
 
             # Skip consumed lines
             i += 1 + context.lines_consumed

notionary/page/writer/markdown_to_notion_converter_context.py

@@ -0,0 +1,30 @@
+# notionary/blocks/context/conversion_context.py
+from __future__ import annotations
+
+from typing import Optional, TYPE_CHECKING
+from dataclasses import dataclass
+
+if TYPE_CHECKING:
+    from notionary.database.client import NotionDatabaseClient
+
+
+@dataclass
+class ConverterContext:
+    """
+    Context object that provides dependencies for block conversion operations.
+    """
+
+    page_id: Optional[str] = None
+    database_client: Optional["NotionDatabaseClient"] = None
+
+    def require_database_client(self) -> NotionDatabaseClient:
+        """Get database client or raise if not available."""
+        if self.database_client is None:
+            raise ValueError("Database client required but not provided in context")
+        return self.database_client
+
+    def require_page_id(self) -> str:
+        """Get parent page ID or raise if not available."""
+        if self.page_id is None:
+            raise ValueError("Parent page ID required but not provided in context")
+        return self.page_id

notionary/page/writer/markdown_to_notion_formatting_post_processor.py

@@ -0,0 +1,73 @@
+"""
+Post-processor for handling block formatting in Markdown to Notion conversion.
+
+Handles block formatting tasks like adding empty paragraphs before media blocks
+and other formatting-related post-processing.
+"""
+
+from typing import cast
+
+from notionary.blocks.models import BlockCreateRequest
+from notionary.blocks.types import BlockType
+from notionary.blocks.paragraph.paragraph_models import (
+    CreateParagraphBlock,
+    ParagraphBlock,
+)
+
+
+class MarkdownToNotionFormattingPostProcessor:
+    """Handles block formatting post-processing for Notion blocks."""
+
+    BLOCKS_NEEDING_EMPTY_PARAGRAPH: set[BlockType] = {
+        BlockType.DIVIDER,
+        BlockType.FILE,
+        BlockType.IMAGE,
+        BlockType.PDF,
+        BlockType.VIDEO,
+    }
+
+    def process(self, blocks: list[BlockCreateRequest]) -> list[BlockCreateRequest]:
+        """Process blocks with all formatting steps."""
+        if not blocks:
+            return blocks
+
+        return self._add_empty_paragraphs_for_media_blocks(blocks)
+
+    def _add_empty_paragraphs_for_media_blocks(
+        self, blocks: list[BlockCreateRequest]
+    ) -> list[BlockCreateRequest]:
+        """Add empty paragraphs before configured block types."""
+        if not blocks:
+            return blocks
+
+        result: list[BlockCreateRequest] = []
+
+        for i, block in enumerate(blocks):
+            block_type = block.type
+
+            if (
+                block_type in self.BLOCKS_NEEDING_EMPTY_PARAGRAPH
+                and i > 0
+                and not self._is_empty_paragraph(result[-1] if result else None)
+            ):
+
+                # Create empty paragraph block inline
+                empty_paragraph = CreateParagraphBlock(
+                    paragraph=ParagraphBlock(rich_text=[])
+                )
+                result.append(empty_paragraph)
+
+            result.append(block)
+
+        return result
+
+    def _is_empty_paragraph(self, block: BlockCreateRequest | None) -> bool:
+        if not block or block.type != BlockType.PARAGRAPH:
+            return False
+        if not isinstance(block, CreateParagraphBlock):
+            return False
+
+        para_block = cast(CreateParagraphBlock, block)
+        paragraph: ParagraphBlock | None = para_block.paragraph
+        if not paragraph:
+            return False

notionary/page/writer/notion_text_length_processor.py

@@ -0,0 +1,150 @@
+"""
+Post-processor for handling Notion API text length limitations.
+
+Handles text length validation and truncation for blocks that exceed
+Notion's rich_text character limit of 2000 characters per element.
+"""
+
+from typing import TypeGuard, Union
+
+from notionary.blocks.models import BlockCreateRequest
+from notionary.blocks.rich_text.rich_text_models import RichTextObject
+from notionary.blocks.types import HasRichText, HasChildren
+from notionary.util import LoggingMixin
+
+
+class NotionTextLengthProcessor(LoggingMixin):
+    """
+    Processes Notion blocks to ensure text content doesn't exceed API limits.
+
+    The Notion API has a limit of 2000 characters per rich_text element.
+    This processor truncates content that exceeds the specified limit.
+    """
+
+    DEFAULT_MAX_LENGTH = 1900  # Leave some buffer under the 2000 limit
+
+    def __init__(self, max_text_length: int = DEFAULT_MAX_LENGTH) -> None:
+        """
+        Initialize the processor.
+
+        Args:
+            max_text_length: Maximum allowed text length (default: 1900)
+        """
+        if max_text_length <= 0:
+            raise ValueError("max_text_length must be positive")
+        if max_text_length > 2000:
+            self.logger.warning(
+                "max_text_length (%d) exceeds Notion's limit of 2000 characters",
+                max_text_length,
+            )
+
+        self.max_text_length = max_text_length
+
+    def process(self, blocks: list[BlockCreateRequest]) -> list[BlockCreateRequest]:
+        """
+        Process blocks to fix text length limits.
+        """
+        if not blocks:
+            return blocks
+
+        flattened_blocks = self._flatten_block_list(blocks)
+        return [self._process_single_block(block) for block in flattened_blocks]
+
+    def _process_single_block(self, block: BlockCreateRequest) -> BlockCreateRequest:
+        """
+        Process a single block to fix text length issues.
+        """
+        block_copy = block.model_copy(deep=True)
+
+        block_content = self._extract_block_content(block_copy)
+
+        if block_content is not None:
+            self._fix_content_text_lengths(block_content)
+
+        return block_copy
+
+    def _extract_block_content(self, block: BlockCreateRequest) -> object | None:
+        """
+        Extract the content object from a block using type-safe attribute access.
+        """
+        # Get the block's content using the block type as attribute name
+        # We assume block.type always exists as per the BlockCreateRequest structure
+        content = getattr(block, block.type, None)
+
+        # Verify it's a valid content object (has rich_text or children)
+        if content and (
+            self._is_rich_text_container(content)
+            or self._is_children_container(content)
+        ):
+            return content
+
+        return None
+
+    def _fix_content_text_lengths(self, content: object) -> None:
+        """
+        Fix text lengths in a content object and its children recursively.
+        """
+        # Process rich_text if present
+        if self._is_rich_text_container(content):
+            self._truncate_rich_text_content(content.rich_text)
+
+        # Process children recursively if present
+        if self._is_children_container(content):
+            for child in content.children:
+                child_content = self._extract_block_content(child)
+                if child_content:
+                    self._fix_content_text_lengths(child_content)
+
+    def _truncate_rich_text_content(self, rich_text_list: list[RichTextObject]) -> None:
+        """
+        Truncate text content in rich text objects that exceed the limit.
+        """
+        for rich_text_obj in rich_text_list:
+            if not self._is_text_rich_text_object(rich_text_obj):
+                continue
+
+            content = rich_text_obj.text.content
+            if len(content) > self.max_text_length:
+                self.logger.warning(
+                    "Truncating text content from %d to %d characters",
+                    len(content),
+                    self.max_text_length,
+                )
+                # Truncate the content
+                rich_text_obj.text.content = content[: self.max_text_length]
+
+    def _flatten_block_list(
+        self, blocks: list[Union[BlockCreateRequest, list]]
+    ) -> list[BlockCreateRequest]:
+        """
+        Flatten a potentially nested list of blocks.
+        """
+        flattened: list[BlockCreateRequest] = []
+
+        for item in blocks:
+            if isinstance(item, list):
+                # Recursively flatten nested lists
+                flattened.extend(self._flatten_block_list(item))
+            else:
+                # Add individual block
+                flattened.append(item)
+
+        return flattened
+
+    def _is_rich_text_container(self, obj: object) -> TypeGuard[HasRichText]:
+        """Type guard to check if an object has rich_text attribute."""
+        return hasattr(obj, "rich_text") and isinstance(getattr(obj, "rich_text"), list)
+
+    def _is_children_container(self, obj: object) -> TypeGuard[HasChildren]:
+        """Type guard to check if an object has children attribute."""
+        return hasattr(obj, "children") and isinstance(getattr(obj, "children"), list)
+
+    def _is_text_rich_text_object(
+        self, rich_text_obj: RichTextObject
+    ) -> TypeGuard[RichTextObject]:
+        """Type guard to check if a RichTextObject is of type 'text' with content."""
+        return (
+            rich_text_obj.type == "text"
+            and rich_text_obj.text is not None
+            and rich_text_obj.text.content is not None
+        )

notionary/telemetry/service.py

@@ -1,7 +1,6 @@
 import os
 import uuid
 from pathlib import Path
-from typing import Any, Dict, Optional
 
 from dotenv import load_dotenv
 from posthog import Posthog

notionary/user/notion_user_manager.py

@@ -1,7 +1,6 @@
-from typing import Any, Dict, List, Optional
+from typing import Optional
 
 from notionary.user.client import NotionUserClient
-from notionary.user.models import NotionUsersListResponse
 from notionary.user.notion_user import NotionUser
 from notionary.util import LoggingMixin
 
@@ -18,72 +17,52 @@ class NotionUserManager(LoggingMixin):
         """Initialize the user manager."""
         self.client = NotionUserClient(token=token)
 
-    async def get_current_bot_user(self) -> Optional[NotionUser]:
-        """
-        Get the current bot user from the API token.
-        """
-        return await NotionUser.current_bot_user(token=self.client.token)
-
     async def get_user_by_id(self, user_id: str) -> Optional[NotionUser]:
         """
         Get a specific user by their ID.
         """
         return await NotionUser.from_user_id(user_id, token=self.client.token)
 
-    async def list_users(
-        self, page_size: int = 100, start_cursor: Optional[str] = None
-    ) -> Optional[NotionUsersListResponse]:
-        """
-        List users in the workspace (paginated).
-
-        Note: Guests are not included in the response.
-        """
-        try:
-            response = await self.client.list_users(page_size, start_cursor)
-            if response is None:
-                self.logger.error("Failed to list users")
-                return None
-
-            self.logger.info(
-                "Retrieved %d users (has_more: %s)",
-                len(response.results),
-                response.has_more,
-            )
-            return response
-
-        except Exception as e:
-            self.logger.error("Error listing users: %s", str(e))
-            return None
-
-    async def get_all_users(self) -> List[NotionUser]:
+    async def get_all_users(self) -> list[NotionUser]:
         """
         Get all users in the workspace as NotionUser objects.
         Automatically handles pagination and converts responses to NotionUser instances.
+        Only returns person users, excludes bots and integrations.
         """
         try:
             # Get raw user responses
             user_responses = await self.client.get_all_users()
 
-            # Convert to NotionUser objects
+            # Filter for person users only and convert to NotionUser objects
             notion_users = []
             for user_response in user_responses:
+                # Skip bot users and integrations
+                if user_response.type != "person":
+                    self.logger.debug(
+                        "Skipping non-person user %s (type: %s)",
+                        user_response.id,
+                        user_response.type,
+                    )
+                    continue
+
                 try:
                     # Use the internal creation method to convert response to NotionUser
-                    notion_user = NotionUser.from_notion_user_response(
+                    notion_user = NotionUser.from_user_response(
                         user_response, self.client.token
                     )
                     notion_users.append(notion_user)
                 except Exception as e:
                     self.logger.warning(
-                        "Failed to convert user %s to NotionUser: %s",
+                        "Failed to convert person user %s to NotionUser: %s",
                         user_response.id,
                         str(e),
                     )
                     continue
 
             self.logger.info(
-                "Successfully converted %d users to NotionUser objects",
+                "Successfully converted %d person users to NotionUser objects (skipped %d non-person users)",
                 len(notion_users),
+                len(user_responses) - len(notion_users),
             )
             return notion_users
 
@@ -91,68 +70,16 @@ class NotionUserManager(LoggingMixin):
             self.logger.error("Error getting all users: %s", str(e))
             return []
 
-    async def get_users_by_type(self, user_type: str = "person") -> List[NotionUser]:
-        """
-        Get all users of a specific type (person or bot).
-        """
-        try:
-            all_users = await self.get_all_users()
-            filtered_users = [user for user in all_users if user.user_type == user_type]
-
-            self.logger.info(
-                "Found %d users of type '%s' out of %d total users",
-                len(filtered_users),
-                user_type,
-                len(all_users),
-            )
-            return filtered_users
-
-        except Exception as e:
-            self.logger.error("Error filtering users by type: %s", str(e))
-            return []
-
-    # TODO: Type this
-    async def get_workspace_info(self) -> Optional[Dict[str, Any]]:
-        """
-        Get available workspace information from the bot user.
-        """
-        bot_user = await self.get_current_bot_user()
-        if bot_user is None:
-            self.logger.error("Failed to get bot user for workspace info")
-            return None
-
-        workspace_info = {
-            "workspace_name": bot_user.workspace_name,
-            "bot_user_id": bot_user.id,
-            "bot_user_name": bot_user.name,
-            "bot_user_type": bot_user.user_type,
-        }
-
-        # Add workspace limits if available
-        if bot_user.is_bot:
-            limits = await bot_user.get_workspace_limits()
-            if limits:
-                workspace_info["workspace_limits"] = limits
-
-        # Add user count statistics
-        try:
-            all_users = await self.get_all_users()
-            workspace_info["total_users"] = len(all_users)
-            workspace_info["person_users"] = len([u for u in all_users if u.is_person])
-            workspace_info["bot_users"] = len([u for u in all_users if u.is_bot])
-        except Exception as e:
-            self.logger.warning("Could not get user statistics: %s", str(e))
-
-        return workspace_info
-
-    async def find_users_by_name(self, name_pattern: str) -> List[NotionUser]:
+    async def find_users_by_name(self, name_pattern: str) -> list[NotionUser]:
         """
-        Find users by name pattern (case-insensitive partial match).
+        Find person users by name pattern (case-insensitive partial match).
+        Only returns person users, excludes bots and integrations.
 
         Note: The API doesn't support server-side filtering, so this fetches all users
         and filters client-side.
         """
         try:
+            # get_all_users() already filters for person users only
             all_users = await self.get_all_users()
             pattern_lower = name_pattern.lower()
 
@@ -163,7 +90,7 @@ class NotionUserManager(LoggingMixin):
             ]
 
             self.logger.info(
-                "Found %d users matching pattern '%s'",
+                "Found %d person users matching pattern '%s'",
                 len(matching_users),
                 name_pattern,
             )

notionary/workspace.py

@@ -1,5 +1,5 @@
 import asyncio
-from typing import List, Optional
+from typing import Optional
 
 from notionary import NotionDatabase, NotionPage
 from notionary.database.client import NotionDatabaseClient
@@ -24,7 +24,7 @@ class NotionWorkspace(LoggingMixin):
         self.page_client = NotionPageClient(token=token)
         self.user_manager = NotionUserManager(token=token)
 
-    async def search_pages(self, query: str, limit=100) -> List[NotionPage]:
+    async def search_pages(self, query: str, limit=100) -> list[NotionPage]:
         """
         Search for pages globally across Notion workspace.
         """
@@ -35,7 +35,7 @@ class NotionWorkspace(LoggingMixin):
 
     async def search_databases(
         self, query: str, limit: int = 100
-    ) -> List[NotionDatabase]:
+    ) -> list[NotionDatabase]:
         """
         Search for databases globally across the Notion workspace.
         """
@@ -58,7 +58,7 @@ class NotionWorkspace(LoggingMixin):
 
         return databases[0] if databases else None
 
-    async def list_all_databases(self, limit: int = 100) -> List[NotionDatabase]:
+    async def list_all_databases(self, limit: int = 100) -> list[NotionDatabase]:
         """
         List all databases in the workspace.
         Returns a list of NotionDatabase instances.