notionary 0.2.23__py3-none-any.whl → 0.2.24__py3-none-any.whl

notionary/blocks/numbered_list/numbered_list_models.py

@@ -1,5 +1,5 @@
-from pydantic import BaseModel, Field
-from typing_extensions import Literal
+from pydantic import BaseModel
+from typing import Literal, Optional
 
 from notionary.blocks.models import Block
 from notionary.blocks.rich_text.rich_text_models import RichTextObject
@@ -9,7 +9,7 @@ from notionary.blocks.types import BlockColor
 class NumberedListItemBlock(BaseModel):
     rich_text: list[RichTextObject]
     color: BlockColor = BlockColor.DEFAULT
-    children: list[Block] = Field(default_factory=list)
+    children: Optional[list[Block]] = None
 
 
 class CreateNumberedListItemBlock(BaseModel):

notionary/blocks/paragraph/__init__.py

@@ -1,6 +1,5 @@
 from notionary.blocks.paragraph.paragraph_element import ParagraphElement
 from notionary.blocks.paragraph.paragraph_markdown_node import (
-    ParagraphMarkdownBlockParams,
     ParagraphMarkdownNode,
 )
 from notionary.blocks.paragraph.paragraph_models import (
@@ -13,5 +12,4 @@ __all__ = [
     "ParagraphBlock",
     "CreateParagraphBlock",
     "ParagraphMarkdownNode",
-    "ParagraphMarkdownBlockParams",
 ]

notionary/blocks/paragraph/paragraph_markdown_node.py

@@ -1,26 +1,16 @@
 from __future__ import annotations
 
-from pydantic import BaseModel
-
-from notionary.markdown.markdown_node import MarkdownNode
-
-
-class ParagraphMarkdownBlockParams(BaseModel):
-    text: str
+from notionary.blocks.markdown.markdown_node import MarkdownNode
 
 
 class ParagraphMarkdownNode(MarkdownNode):
     """
+    Enhanced Paragraph node with Pydantic integration.
     Programmatic interface for creating Markdown paragraphs.
     Paragraphs are standard text without special block formatting.
     """
 
-    def __init__(self, text: str):
-        self.text = text
-
-    @classmethod
-    def from_params(cls, params: ParagraphMarkdownBlockParams) -> ParagraphMarkdownNode:
-        return cls(text=params.text)
+    text: str
 
     def to_markdown(self) -> str:
         return self.text

notionary/blocks/pdf/__init__.py

@@ -1,7 +1,6 @@
 from notionary.blocks.pdf.pdf_element import PdfElement
 from notionary.blocks.pdf.pdf_markdown_node import (
     PdfMarkdownNode,
-    PdfMarkdownNodeParams,
 )
 from notionary.blocks.pdf.pdf_models import CreatePdfBlock
 
@@ -9,5 +8,4 @@ __all__ = [
     "PdfElement",
     "CreatePdfBlock",
     "PdfMarkdownNode",
-    "PdfMarkdownNodeParams",
 ]

notionary/blocks/pdf/pdf_element.py

@@ -4,75 +4,111 @@ import re
 from typing import Optional
 
 from notionary.blocks.base_block_element import BaseBlockElement
-from notionary.blocks.file.file_element_models import ExternalFile, FileBlock, FileType
+from notionary.blocks.file.file_element_models import (
+    ExternalFile,
+    FileBlock,
+    FileType,
+    FileUploadFile,
+)
 from notionary.blocks.mixins.captions import CaptionMixin
+from notionary.blocks.mixins.file_upload.file_upload_mixin import FileUploadMixin
 from notionary.blocks.syntax_prompt_builder import BlockElementMarkdownInformation
 from notionary.blocks.models import Block, BlockCreateResult, BlockType
 from notionary.blocks.pdf.pdf_models import CreatePdfBlock
 
 
-class PdfElement(BaseBlockElement, CaptionMixin):
-    """
+class PdfElement(BaseBlockElement, CaptionMixin, FileUploadMixin):
+    r"""
     Handles conversion between Markdown PDF embeds and Notion PDF blocks.
 
+    Supports both external URLs and local PDF file uploads.
+
     Markdown PDF syntax:
     - [pdf](https://example.com/document.pdf) - External URL
-    - [pdf](https://example.com/document.pdf)(caption:Annual Report 2024) - URL with caption
-    - (caption:User Manual)[pdf](https://example.com/manual.pdf) - caption before URL
+    - [pdf](./local/document.pdf) - Local PDF file (will be uploaded)
+    - [pdf](C:\Documents\report.pdf) - Absolute local path (will be uploaded)
+    - [pdf](https://example.com/document.pdf)(caption:Annual Report 2024) - With caption
     - [pdf](notion://file_id_here)(caption:Notion hosted file) - Notion hosted file
     - [pdf](upload://upload_id_here)(caption:File upload) - File upload
-
-    Supports all three PDF types: external, notion-hosted, and file uploads.
     """
 
-    # Flexible pattern that can handle caption in any position
-    PDF_PATTERN = re.compile(r"\[pdf\]\(((?:https?://|notion://|upload://)[^\s\"]+)\)")
+    PDF_PATTERN = re.compile(r"\[pdf\]\(([^)]+)\)")
 
     @classmethod
     def match_notion(cls, block: Block) -> bool:
-        # Notion PDF block covers PDFs
+        """Match Notion PDF blocks."""
         return block.type == BlockType.PDF and block.pdf
 
     @classmethod
-    async def markdown_to_notion(cls, text: str) -> BlockCreateResult:
-        """Convert markdown PDF link to Notion FileBlock (used for PDF)."""
-        # Use our own regex to find the PDF URL
-        pdf_match = cls.PDF_PATTERN.search(text.strip())
-        if not pdf_match:
+    async def markdown_to_notion(cls, text: str) -> Optional[BlockCreateResult]:
+        """Convert markdown PDF link to Notion PDF block."""
+        pdf_path = cls._extract_pdf_path(text.strip())
+
+        if not pdf_path:
             return None
 
-        url = pdf_match.group(1)
+        cls.logger.info(f"Processing PDF: {pdf_path}")
 
-        # Use mixin to extract caption (if present anywhere in text)
+        # Extract caption
         caption_text = cls.extract_caption(text.strip())
         caption_rich_text = cls.build_caption_rich_text(caption_text or "")
 
-        # Build FileBlock using FileType enum (reused for PDF)
-        pdf_block = FileBlock(
-            type=FileType.EXTERNAL,
-            external=ExternalFile(url=url),
-            caption=caption_rich_text,
-        )
+        # Handle different types of PDF sources
+        if pdf_path.startswith(("notion://", "upload://")):
+            # Handle special Notion schemes (existing functionality)
+            cls.logger.info(f"Using special scheme: {pdf_path}")
+            pdf_block = FileBlock(
+                type=FileType.EXTERNAL,
+                external=ExternalFile(url=pdf_path),
+                caption=caption_rich_text,
+            )
+
+        elif cls._is_local_file_path(pdf_path):
+            # Handle local PDF file upload using mixin
+            cls.logger.debug(f"Detected local PDF file: {pdf_path}")
+
+            # Upload the local PDF file with PDF category validation
+            file_upload_id = await cls._upload_local_file(pdf_path, "pdf")
+            if not file_upload_id:
+                cls.logger.error(f"Failed to upload PDF: {pdf_path}")
+                return None
+
+            # Create FILE_UPLOAD block
+            pdf_block = FileBlock(
+                type=FileType.FILE_UPLOAD,
+                file_upload=FileUploadFile(id=file_upload_id),
+                caption=caption_rich_text,
+            )
+
+        else:
+            # Handle external URL
+            cls.logger.debug(f"Using external PDF URL: {pdf_path}")
+
+            pdf_block = FileBlock(
+                type=FileType.EXTERNAL,
+                external=ExternalFile(url=pdf_path),
+                caption=caption_rich_text,
+            )
 
         return CreatePdfBlock(pdf=pdf_block)
 
     @classmethod
     async def notion_to_markdown(cls, block: Block) -> Optional[str]:
+        """Convert Notion PDF block to markdown."""
         if block.type != BlockType.PDF or not block.pdf:
             return None
 
         pb: FileBlock = block.pdf
 
+        # Determine the source for markdown
         if pb.type == FileType.EXTERNAL and pb.external:
-            url = pb.external.url
+            source = pb.external.url
         elif pb.type == FileType.FILE and pb.file:
-            url = pb.file.url
-        elif pb.type == FileType.FILE_UPLOAD:
-            return None
+            source = pb.file.url
         else:
             return None
 
-        result = f"[pdf]({url})"
+        result = f"[pdf]({source})"
 
         # Add caption if present
         caption_markdown = await cls.format_caption_for_markdown(pb.caption or [])
@@ -86,12 +122,25 @@ class PdfElement(BaseBlockElement, CaptionMixin):
         """Get system prompt information for PDF blocks."""
         return BlockElementMarkdownInformation(
             block_type=cls.__name__,
-            description="PDF blocks embed and display PDF documents from external URLs with optional captions",
+            description="PDF blocks embed and display PDF documents from external URLs or upload local PDF files with optional captions",
             syntax_examples=[
                 "[pdf](https://example.com/document.pdf)",
+                "[pdf](./local/report.pdf)",
+                "[pdf](C:\\Documents\\manual.pdf)",
                 "[pdf](https://example.com/report.pdf)(caption:Annual Report 2024)",
-                "(caption:User Manual)[pdf](https://example.com/manual.pdf)",
-                "[pdf](https://example.com/guide.pdf)(caption:**Important** documentation)",
+                "(caption:User Manual)[pdf](./manual.pdf)",
+                "[pdf](./guide.pdf)(caption:**Important** documentation)",
             ],
-            usage_guidelines="Use for embedding PDF documents that can be viewed inline. Supports external URLs and Notion-hosted files. Caption supports rich text formatting and should describe the PDF content.",
+            usage_guidelines="Use for embedding PDF documents that can be viewed inline. Supports both external URLs and local PDF file uploads. Local PDF files will be automatically uploaded to Notion. Caption supports rich text formatting and should describe the PDF content.",
         )
+
+    @classmethod
+    def _extract_pdf_path(cls, text: str) -> Optional[str]:
+        """Extract PDF path/URL from text, handling caption patterns."""
+        clean_text = cls.remove_caption(text)
+
+        match = cls.PDF_PATTERN.search(clean_text)
+        if match:
+            return match.group(1).strip()
+
+        return None

notionary/blocks/pdf/pdf_markdown_node.py

@@ -1,30 +1,17 @@
-from __future__ import annotations
-
 from typing import Optional
 
-from pydantic import BaseModel
-
-from notionary.markdown.markdown_node import MarkdownNode
+from notionary.blocks.markdown.markdown_node import MarkdownNode
 from notionary.blocks.mixins.captions import CaptionMarkdownNodeMixin
 
 
-class PdfMarkdownNodeParams(BaseModel):
-    url: str
-    caption: Optional[str] = None
-
-
 class PdfMarkdownNode(MarkdownNode, CaptionMarkdownNodeMixin):
     """
-    Programmatic interface for creating Notion-style Markdown PDF embeds.
+    Enhanced PDF node with Pydantic integration.
+    Programmatic interface for creating Notion-style PDF blocks.
     """
 
-    def __init__(self, url: str, caption: Optional[str] = None):
-        self.url = url
-        self.caption = caption or ""
-
-    @classmethod
-    def from_params(cls, params: PdfMarkdownNodeParams) -> PdfMarkdownNode:
-        return cls(url=params.url, caption=params.caption)
+    url: str
+    caption: Optional[str] = None
 
     def to_markdown(self) -> str:
         """Return the Markdown representation.

notionary/blocks/quote/__init__.py

@@ -2,7 +2,6 @@
 
 from notionary.blocks.quote.quote_element import QuoteElement
 from notionary.blocks.quote.quote_markdown_node import (
-    QuoteMarkdownBlockParams,
     QuoteMarkdownNode,
 )
 from notionary.blocks.quote.quote_models import CreateQuoteBlock, QuoteBlock
@@ -12,5 +11,4 @@ __all__ = [
     "QuoteBlock",
     "CreateQuoteBlock",
     "QuoteMarkdownNode",
-    "QuoteMarkdownBlockParams",
 ]

notionary/blocks/quote/quote_markdown_node.py

@@ -1,26 +1,16 @@
 from __future__ import annotations
 
-from pydantic import BaseModel
-
-from notionary.markdown.markdown_node import MarkdownNode
-
-
-class QuoteMarkdownBlockParams(BaseModel):
-    text: str
+from notionary.blocks.markdown.markdown_node import MarkdownNode
 
 
 class QuoteMarkdownNode(MarkdownNode):
     """
+    Enhanced Quote node with Pydantic integration.
     Programmatic interface for creating Notion-style quote blocks.
     Example: > This is a quote
     """
 
-    def __init__(self, text: str):
-        self.text = text
-
-    @classmethod
-    def from_params(cls, params: QuoteMarkdownBlockParams) -> QuoteMarkdownNode:
-        return cls(text=params.text)
+    text: str
 
     def to_markdown(self) -> str:
         return f"> {self.text}"

notionary/blocks/registry/__init__.py

@@ -1,4 +1,3 @@
 from .block_registry import BlockRegistry
-from .block_registry_builder import BlockRegistryBuilder
 
-__all__ = ["BlockRegistryBuilder", "BlockRegistry"]
+__all__ = ["BlockRegistry"]

notionary/blocks/registry/block_registry.py

@@ -1,95 +1,150 @@
 from __future__ import annotations
 
-from typing import Optional, Type
+from collections import OrderedDict
+from typing import Type, Set
 
 from notionary.blocks.base_block_element import BaseBlockElement
-from notionary.blocks.registry.block_registry_builder import BlockRegistryBuilder
-from notionary.telemetry import (
-    ProductTelemetry,
-)
+from notionary.telemetry import ProductTelemetry
+
+from notionary.blocks.audio import AudioElement
+from notionary.blocks.bookmark import BookmarkElement
+from notionary.blocks.breadcrumbs import BreadcrumbElement
+from notionary.blocks.bulleted_list import BulletedListElement
+from notionary.blocks.callout import CalloutElement
+from notionary.blocks.child_database import ChildDatabaseElement
+from notionary.blocks.code import CodeElement
+from notionary.blocks.column import ColumnElement, ColumnListElement
+from notionary.blocks.divider import DividerElement
+from notionary.blocks.embed import EmbedElement
+from notionary.blocks.equation import EquationElement
+from notionary.blocks.file import FileElement
+from notionary.blocks.heading import HeadingElement
+from notionary.blocks.image_block import ImageElement
+from notionary.blocks.numbered_list import NumberedListElement
+from notionary.blocks.paragraph import ParagraphElement
+from notionary.blocks.pdf import PdfElement
+from notionary.blocks.quote import QuoteElement
+from notionary.blocks.table import TableElement
+from notionary.blocks.table_of_contents import TableOfContentsElement
+from notionary.blocks.todo import TodoElement
+from notionary.blocks.toggle import ToggleElement
+from notionary.blocks.toggleable_heading import ToggleableHeadingElement
+from notionary.blocks.video import VideoElement
 
 
 class BlockRegistry:
     """Registry of elements that can convert between Markdown and Notion."""
 
-    def __init__(self, builder: Optional[BlockRegistryBuilder] = None):
+    _DEFAULT_ELEMENTS = [
+        HeadingElement,
+        CalloutElement,
+        CodeElement,
+        DividerElement,
+        TableElement,
+        BulletedListElement,
+        NumberedListElement,
+        ToggleElement,
+        ToggleableHeadingElement,
+        QuoteElement,
+        TodoElement,
+        BookmarkElement,
+        ImageElement,
+        VideoElement,
+        EmbedElement,
+        AudioElement,
+        ColumnListElement,
+        ColumnElement,
+        EquationElement,
+        TableOfContentsElement,
+        BreadcrumbElement,
+        ChildDatabaseElement,
+        FileElement,
+        PdfElement,
+        ParagraphElement,  # Must be last as fallback!
+    ]
+
+    def __init__(self, excluded_elements: Set[Type[BaseBlockElement]] = None):
         """
         Initialize a new registry instance.
 
         Args:
-            builder: BlockRegistryBuilder instance to delegate operations to
+            excluded_elements: Set of element classes to exclude from the registry
         """
-        # Import here to avoid circular imports
-        from notionary.blocks.registry.block_registry_builder import (
-            BlockRegistryBuilder,
-        )
-
-        self._builder: BlockRegistryBuilder = builder or BlockRegistryBuilder()
+        self._elements = OrderedDict()
+        self._excluded_elements = excluded_elements or set()
         self.telemetry = ProductTelemetry()
 
+        # Initialize with default elements minus excluded ones
+        self._initialize_default_elements()
+
     @classmethod
-    def create_registry(cls) -> BlockRegistry:
+    def create_registry(
+        cls, excluded_elements: Set[Type[BaseBlockElement]] = None
+    ) -> "BlockRegistry":
         """
         Create a registry with all standard elements in recommended order.
+
+        Args:
+            excluded_elements: Set of element classes to exclude from the registry
+        """
+        return cls(excluded_elements=excluded_elements)
+
+    def _initialize_default_elements(self) -> None:
+        """Initialize registry with default elements minus excluded ones."""
+        for element_class in self._DEFAULT_ELEMENTS:
+            if element_class not in self._excluded_elements:
+                self._elements[element_class.__name__] = element_class
+
+    def exclude_elements(
+        self, *element_classes: Type[BaseBlockElement]
+    ) -> BlockRegistry:
+        """
+        Create a new registry with additional excluded elements.
+
+        Args:
+            element_classes: Element classes to exclude
+
+        Returns:
+            New BlockRegistry instance with excluded elements
         """
-        from notionary.blocks.registry.block_registry_builder import (
-            BlockRegistryBuilder,
-        )
-
-        builder = BlockRegistryBuilder()
-        builder = (
-            builder.with_headings()
-            .with_callouts()
-            .with_code()
-            .with_dividers()
-            .with_tables()
-            .with_bulleted_list()
-            .with_numbered_list()
-            .with_toggles()
-            .with_toggleable_heading_element()
-            .with_quotes()
-            .with_todos()
-            .with_bookmarks()
-            .with_images()
-            .with_videos()
-            .with_embeds()
-            .with_audio()
-            .with_columns()
-            .with_equation()
-            .with_table_of_contents()
-            .with_breadcrumbs()
-            .with_child_database()
-            .with_paragraphs()  # position here is important - its a fallback!
-        )
-
-        return cls(builder=builder)
-
-    @property
-    def builder(self) -> BlockRegistryBuilder:
-        return self._builder
+        new_excluded = self._excluded_elements.copy()
+        new_excluded.update(element_classes)
+        return BlockRegistry(excluded_elements=new_excluded)
 
     def register(self, element_class: Type[BaseBlockElement]) -> bool:
         """
-        Register an element class via builder.
+        Register an element class.
+
+        Args:
+            element_class: The element class to register
+
+        Returns:
+            True if element was added, False if it already existed
         """
-        initial_count = len(self._builder._elements)
-        self._builder._add_element(element_class)
-        return len(self._builder._elements) > initial_count
+        if element_class.__name__ in self._elements:
+            return False
+
+        self._elements[element_class.__name__] = element_class
+        return True
 
-    def deregister(self, element_class: Type[BaseBlockElement]) -> bool:
+    def remove(self, element_class: Type[BaseBlockElement]) -> bool:
         """
-        Deregister an element class via builder.
+        Remove an element class.
         """
-        initial_count = len(self._builder._elements)
-        self._builder.remove_element(element_class)
-        return len(self._builder._elements) < initial_count
+        return self._elements.pop(element_class.__name__, None) is not None
 
     def contains(self, element_class: Type[BaseBlockElement]) -> bool:
         """
         Checks if a specific element is contained in the registry.
         """
-        return element_class.__name__ in self._builder._elements
+        return element_class.__name__ in self._elements
 
     def get_elements(self) -> list[Type[BaseBlockElement]]:
-        """Get all registered elements."""
-        return list(self._builder._elements.values())
+        """Get all registered elements in order."""
+        return list(self._elements.values())
+
+    def is_excluded(self, element_class: Type[BaseBlockElement]) -> bool:
+        """
+        Check if an element class is excluded.
+        """
+        return element_class in self._excluded_elements

notionary/blocks/table/__init__.py

@@ -1,6 +1,5 @@
 from notionary.blocks.table.table_element import TableElement
 from notionary.blocks.table.table_markdown_node import (
-    TableMarkdownBlockParams,
     TableMarkdownNode,
 )
 from notionary.blocks.table.table_models import (
@@ -17,5 +16,4 @@ __all__ = [
     "CreateTableRowBlock",
     "CreateTableBlock",
     "TableMarkdownNode",
-    "TableMarkdownBlockParams",
 ]

notionary/blocks/table/table_markdown_node.py

@@ -1,17 +1,11 @@
-from __future__ import annotations
+from pydantic import field_validator
 
-from pydantic import BaseModel
-
-from notionary.markdown.markdown_node import MarkdownNode
-
-
-class TableMarkdownBlockParams(BaseModel):
-    headers: list[str]
-    rows: list[list[str]]
+from notionary.blocks.markdown.markdown_node import MarkdownNode
 
 
 class TableMarkdownNode(MarkdownNode):
     """
+    Enhanced Table node with Pydantic integration.
     Programmatic interface for creating Markdown tables.
     Example:
         | Header 1 | Header 2 | Header 3 |
@@ -20,15 +14,22 @@ class TableMarkdownNode(MarkdownNode):
         | Cell 4   | Cell 5   | Cell 6   |
     """
 
-    def __init__(self, headers: list[str], rows: list[list[str]]):
-        if not headers or not all(isinstance(row, list) for row in rows):
-            raise ValueError("headers must be a list and rows must be a list of lists")
-        self.headers = headers
-        self.rows = rows
+    headers: list[str]
+    rows: list[list[str]]
+
+    @field_validator("headers")
+    @classmethod
+    def validate_headers(cls, v):
+        if not v:
+            raise ValueError("headers must not be empty")
+        return v
 
+    @field_validator("rows")
     @classmethod
-    def from_params(cls, params: TableMarkdownBlockParams) -> TableMarkdownNode:
-        return cls(headers=params.headers, rows=params.rows)
+    def validate_rows(cls, v):
+        if not all(isinstance(row, list) for row in v):
+            raise ValueError("rows must be a list of lists")
+        return v
 
     def to_markdown(self) -> str:
         col_count = len(self.headers)

notionary/blocks/table_of_contents/__init__.py

@@ -2,7 +2,6 @@ from notionary.blocks.table_of_contents.table_of_contents_element import (
     TableOfContentsElement,
 )
 from notionary.blocks.table_of_contents.table_of_contents_markdown_node import (
-    TableOfContentsMarkdownBlockParams,
     TableOfContentsMarkdownNode,
 )
 from notionary.blocks.table_of_contents.table_of_contents_models import (
@@ -15,5 +14,4 @@ __all__ = [
     "TableOfContentsBlock",
     "CreateTableOfContentsBlock",
     "TableOfContentsMarkdownNode",
-    "TableOfContentsMarkdownBlockParams",
 ]