notionary 0.2.27__py3-none-any.whl → 0.3.0__py3-none-any.whl

notionary/base_notion_client.py

@@ -1,219 +0,0 @@
-import asyncio
-import os
-from abc import ABC
-from enum import Enum
-from typing import Any, Dict, Optional, Union
-
-import httpx
-from dotenv import load_dotenv
-
-from notionary.util import LoggingMixin
-
-load_dotenv()
-
-
-class HttpMethod(Enum):
-    """
-    Enumeration of supported HTTP methods for API requests.
-    """
-
-    GET = "get"
-    POST = "post"
-    PATCH = "patch"
-    DELETE = "delete"
-
-
-class BaseNotionClient(LoggingMixin, ABC):
-    """
-    Base client for Notion API operations.
-    Handles connection management and generic HTTP requests.
-    """
-
-    BASE_URL = "https://api.notion.com/v1"
-    NOTION_VERSION = "2022-06-28"
-
-    def __init__(self, token: Optional[str] = None, timeout: int = 30):
-        self.token = token or self._find_token()
-        if not self.token:
-            raise ValueError("Notion API token is required")
-
-        self.headers = {
-            "Authorization": f"Bearer {self.token}",
-            "Content-Type": "application/json",
-            "Notion-Version": self.NOTION_VERSION,
-        }
-
-        self.client: Optional[httpx.AsyncClient] = None
-        self.timeout = timeout
-        self._is_initialized = False
-
-    def __del__(self):
-        """Auto-cleanup when client is destroyed."""
-        if not hasattr(self, "client") or not self.client:
-            return
-
-        try:
-            loop = asyncio.get_event_loop()
-            if not loop.is_running():
-                self.logger.warning(
-                    "Event loop not running, could not auto-close NotionClient"
-                )
-                return
-
-            loop.create_task(self.close())
-            self.logger.debug("Created cleanup task for NotionClient")
-        except RuntimeError:
-            self.logger.warning("No event loop available for auto-closing NotionClient")
-
-    async def __aenter__(self):
-        """Async context manager entry."""
-        await self.ensure_initialized()
-        return self
-
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
-        """Async context manager exit."""
-        await self.close()
-
-    async def ensure_initialized(self) -> None:
-        """
-        Ensures the HTTP client is initialized.
-        """
-        if not self._is_initialized or not self.client:
-            self.client = httpx.AsyncClient(headers=self.headers, timeout=self.timeout)
-            self._is_initialized = True
-            self.logger.debug("NotionClient initialized")
-
-    async def close(self) -> None:
-        """
-        Closes the HTTP client and releases resources.
-        """
-        if not hasattr(self, "client") or not self.client:
-            return
-
-        await self.client.aclose()
-        self.client = None
-        self._is_initialized = False
-        self.logger.debug("NotionClient closed")
-
-    async def get(
-        self, endpoint: str, params: Optional[Dict[str, Any]] = None
-    ) -> Optional[Dict[str, Any]]:
-        """
-        Sends a GET request to the specified Notion API endpoint.
-
-        Args:
-            endpoint: The API endpoint (without base URL)
-            params: Query parameters to include in the request
-        """
-        return await self._make_request(HttpMethod.GET, endpoint, params=params)
-
-    async def post(
-        self, endpoint: str, data: Optional[Dict[str, Any]] = None
-    ) -> Optional[Dict[str, Any]]:
-        """
-        Sends a POST request to the specified Notion API endpoint.
-
-        Args:
-            endpoint: The API endpoint (without base URL)
-            data: Request body data
-        """
-        return await self._make_request(HttpMethod.POST, endpoint, data)
-
-    async def patch(
-        self, endpoint: str, data: Optional[Dict[str, Any]] = None
-    ) -> Optional[Dict[str, Any]]:
-        """
-        Sends a PATCH request to the specified Notion API endpoint.
-
-        Args:
-            endpoint: The API endpoint (without base URL)
-            data: Request body data
-        """
-        return await self._make_request(HttpMethod.PATCH, endpoint, data)
-
-    async def delete(self, endpoint: str) -> bool:
-        """
-        Sends a DELETE request to the specified Notion API endpoint.
-
-        Args:
-            endpoint: The API endpoint (without base URL)
-        """
-        result = await self._make_request(HttpMethod.DELETE, endpoint)
-        return result is not None
-
-    async def _make_request(
-        self,
-        method: Union[HttpMethod, str],
-        endpoint: str,
-        data: Optional[Dict[str, Any]] = None,
-        params: Optional[Dict[str, Any]] = None,
-    ) -> Optional[Dict[str, Any]]:
-        """
-        Executes an HTTP request and returns the data or None on error.
-
-        Args:
-            method: HTTP method to use
-            endpoint: API endpoint
-            data: Request body data (for POST/PATCH)
-            params: Query parameters (for GET requests)
-        """
-        await self.ensure_initialized()
-
-        url = f"{self.BASE_URL}/{endpoint.lstrip('/')}"
-        method_str = (
-            method.value if isinstance(method, HttpMethod) else str(method).lower()
-        )
-
-        try:
-            self.logger.debug("Sending %s request to %s", method_str.upper(), url)
-
-            request_kwargs = {}
-
-            # Add query parameters for GET requests
-            if params:
-                request_kwargs["params"] = params
-
-            if (
-                method_str in [HttpMethod.POST.value, HttpMethod.PATCH.value]
-                and data is not None
-            ):
-                request_kwargs["json"] = data
-
-            response: httpx.Response = await getattr(self.client, method_str)(
-                url, **request_kwargs
-            )
-
-            response.raise_for_status()
-            result_data = response.json()
-            self.logger.debug("Request successful: %s", url)
-            return result_data
-
-        except httpx.HTTPStatusError as e:
-            error_msg = (
-                f"HTTP status error: {e.response.status_code} - {e.response.text}"
-            )
-            self.logger.error("Request failed (%s): %s", url, error_msg)
-            return None
-
-        except httpx.RequestError as e:
-            error_msg = f"Request error: {str(e)}"
-            self.logger.error("Request error (%s): %s", url, error_msg)
-            return None
-
-    def _find_token(self) -> Optional[str]:
-        """
-        Finds the Notion API token from environment variables.
-        """
-        token = next(
-            (
-                os.getenv(var)
-                for var in ("NOTION_SECRET", "NOTION_INTEGRATION_KEY", "NOTION_TOKEN")
-                if os.getenv(var)
-            ),
-            None,
-        )
-        if token:
-            self.logger.debug("Found token in environment variable.")
-            return token
-        self.logger.warning("No Notion API token found in environment variables")
-        return None

notionary/blocks/_bootstrap.py

@@ -1,271 +0,0 @@
-from __future__ import annotations
-
-from typing import Optional, Union
-
-_bootstrapped = False
-
-
-def bootstrap_blocks() -> None:
-    global _bootstrapped
-    if _bootstrapped:
-        return
-
-    from notionary.blocks import (
-        bookmark,
-        breadcrumbs,
-        bulleted_list,
-        callout,
-        child_page,
-        code,
-        column,
-        divider,
-        embed,
-        equation,
-        file,
-        heading,
-        image_block,
-        models,
-        numbered_list,
-        paragraph,
-        quote,
-        table,
-        table_of_contents,
-        todo,
-        toggle,
-        toggleable_heading,
-        video,
-        child_database,
-    )
-
-    # Collect all exports from modules
-    ns = {}
-    for m in (
-        bookmark,
-        breadcrumbs,
-        bulleted_list,
-        callout,
-        child_page,
-        code,
-        column,
-        divider,
-        embed,
-        equation,
-        file,
-        heading,
-        image_block,
-        numbered_list,
-        paragraph,
-        quote,
-        table,
-        todo,
-        toggle,
-        video,
-        toggleable_heading,
-        table_of_contents,
-        child_database,
-    ):
-        ns.update(vars(m))
-
-    # Add missing types that are needed for model rebuilding
-    # These are the types that are only defined in TYPE_CHECKING in block_models
-    from notionary.blocks.bookmark.bookmark_models import (
-        BookmarkBlock,
-        CreateBookmarkBlock,
-    )
-    from notionary.blocks.breadcrumbs.breadcrumb_models import (
-        BreadcrumbBlock,
-        CreateBreadcrumbBlock,
-    )
-    from notionary.blocks.bulleted_list.bulleted_list_models import (
-        BulletedListItemBlock,
-        CreateBulletedListItemBlock,
-    )
-    from notionary.blocks.callout.callout_models import CalloutBlock, CreateCalloutBlock
-    from notionary.blocks.child_page.child_page_models import (
-        ChildPageBlock,
-        CreateChildPageBlock,
-    )
-    from notionary.blocks.code.code_models import CodeBlock, CreateCodeBlock
-    from notionary.blocks.column.column_models import (
-        ColumnBlock,
-        ColumnListBlock,
-        CreateColumnBlock,
-        CreateColumnListBlock,
-    )
-    from notionary.blocks.divider.divider_models import CreateDividerBlock, DividerBlock
-    from notionary.blocks.embed.embed_models import CreateEmbedBlock, EmbedBlock
-    from notionary.blocks.equation.equation_models import (
-        CreateEquationBlock,
-        EquationBlock,
-    )
-    from notionary.blocks.file.file_element_models import CreateFileBlock, FileBlock
-    from notionary.blocks.heading.heading_models import (
-        CreateHeading1Block,
-        CreateHeading2Block,
-        CreateHeading3Block,
-        HeadingBlock,
-    )
-    from notionary.blocks.image_block.image_models import CreateImageBlock
-    from notionary.blocks.numbered_list.numbered_list_models import (
-        CreateNumberedListItemBlock,
-        NumberedListItemBlock,
-    )
-    from notionary.blocks.paragraph.paragraph_models import (
-        CreateParagraphBlock,
-        ParagraphBlock,
-    )
-    from notionary.blocks.pdf.pdf_models import CreatePdfBlock
-    from notionary.blocks.quote.quote_models import CreateQuoteBlock, QuoteBlock
-    from notionary.blocks.table.table_models import TableBlock, TableRowBlock
-    from notionary.blocks.table_of_contents.table_of_contents_models import (
-        CreateTableOfContentsBlock,
-        TableOfContentsBlock,
-    )
-    from notionary.blocks.todo.todo_models import CreateToDoBlock, ToDoBlock
-    from notionary.blocks.toggle.toggle_models import CreateToggleBlock, ToggleBlock
-    from notionary.blocks.types import BlockType
-    from notionary.blocks.video.video_element_models import CreateVideoBlock
-    from notionary.blocks.child_database.child_database_models import (
-        CreateChildDatabaseBlock,
-        ChildDatabaseBlock,
-    )
-
-    # Define the Union types that are needed for model rebuilding
-    BlockCreateRequest = Union[
-        CreateBookmarkBlock,
-        CreateBreadcrumbBlock,
-        CreateBulletedListItemBlock,
-        CreateCalloutBlock,
-        CreateChildPageBlock,
-        CreateCodeBlock,
-        CreateColumnListBlock,
-        CreateColumnBlock,
-        CreateDividerBlock,
-        CreateEmbedBlock,
-        CreateEquationBlock,
-        CreateFileBlock,
-        CreateHeading1Block,
-        CreateHeading2Block,
-        CreateHeading3Block,
-        CreateImageBlock,
-        CreateNumberedListItemBlock,
-        CreateParagraphBlock,
-        CreateQuoteBlock,
-        CreateToDoBlock,
-        CreateToggleBlock,
-        CreateVideoBlock,
-        CreateTableOfContentsBlock,
-        CreatePdfBlock,
-        CreateChildDatabaseBlock,
-    ]
-
-    BlockCreateResult = Optional[BlockCreateRequest]
-
-    # Add all block types to namespace
-    ns.update(
-        {
-            "BlockType": BlockType,
-            "BookmarkBlock": BookmarkBlock,
-            "CreateBookmarkBlock": CreateBookmarkBlock,
-            "BreadcrumbBlock": BreadcrumbBlock,
-            "CreateBreadcrumbBlock": CreateBreadcrumbBlock,
-            "BulletedListItemBlock": BulletedListItemBlock,
-            "CreateBulletedListItemBlock": CreateBulletedListItemBlock,
-            "CalloutBlock": CalloutBlock,
-            "CreateCalloutBlock": CreateCalloutBlock,
-            "ChildPageBlock": ChildPageBlock,
-            "CreateChildPageBlock": CreateChildPageBlock,
-            "CodeBlock": CodeBlock,
-            "CreateCodeBlock": CreateCodeBlock,
-            "ColumnBlock": ColumnBlock,
-            "ColumnListBlock": ColumnListBlock,
-            "CreateColumnBlock": CreateColumnBlock,
-            "CreateColumnListBlock": CreateColumnListBlock,
-            "DividerBlock": DividerBlock,
-            "CreateDividerBlock": CreateDividerBlock,
-            "EmbedBlock": EmbedBlock,
-            "CreateEmbedBlock": CreateEmbedBlock,
-            "EquationBlock": EquationBlock,
-            "CreateEquationBlock": CreateEquationBlock,
-            "FileBlock": FileBlock,
-            "CreateFileBlock": CreateFileBlock,
-            "HeadingBlock": HeadingBlock,
-            "CreateHeading1Block": CreateHeading1Block,
-            "CreateHeading2Block": CreateHeading2Block,
-            "CreateHeading3Block": CreateHeading3Block,
-            "CreateImageBlock": CreateImageBlock,
-            "NumberedListItemBlock": NumberedListItemBlock,
-            "CreateNumberedListItemBlock": CreateNumberedListItemBlock,
-            "ParagraphBlock": ParagraphBlock,
-            "CreateParagraphBlock": CreateParagraphBlock,
-            "QuoteBlock": QuoteBlock,
-            "CreateQuoteBlock": CreateQuoteBlock,
-            "TableBlock": TableBlock,
-            "TableRowBlock": TableRowBlock,
-            "ToDoBlock": ToDoBlock,
-            "CreateToDoBlock": CreateToDoBlock,
-            "ToggleBlock": ToggleBlock,
-            "CreateToggleBlock": CreateToggleBlock,
-            "CreateVideoBlock": CreateVideoBlock,
-            "TableOfContentsBlock": TableOfContentsBlock,
-            "CreateTableOfContentsBlock": CreateTableOfContentsBlock,
-            "ChildDatabaseBlock": ChildDatabaseBlock,
-            # Add the Union types
-            "BlockCreateRequest": BlockCreateRequest,
-            "BlockCreateResult": BlockCreateResult,
-        }
-    )
-
-    # Now rebuild with complete namespace
-    models.Block.model_rebuild(_types_namespace=ns)
-    models.BlockChildrenResponse.model_rebuild(_types_namespace=ns)
-
-    # Rebuild all individual block models
-    BookmarkBlock.model_rebuild()
-    BreadcrumbBlock.model_rebuild()
-    BulletedListItemBlock.model_rebuild()
-    CalloutBlock.model_rebuild()
-    ChildPageBlock.model_rebuild()
-    CodeBlock.model_rebuild()
-    ColumnBlock.model_rebuild()
-    ColumnListBlock.model_rebuild()
-    DividerBlock.model_rebuild()
-    EmbedBlock.model_rebuild()
-    EquationBlock.model_rebuild()
-    FileBlock.model_rebuild()
-    HeadingBlock.model_rebuild()
-    NumberedListItemBlock.model_rebuild()
-    ParagraphBlock.model_rebuild()
-    QuoteBlock.model_rebuild()
-    TableBlock.model_rebuild()
-    TableRowBlock.model_rebuild()
-    ToDoBlock.model_rebuild()
-    ToggleBlock.model_rebuild()
-    TableOfContentsBlock.model_rebuild()
-
-    # Rebuild create models
-    CreateBookmarkBlock.model_rebuild()
-    CreateBreadcrumbBlock.model_rebuild()
-    CreateBulletedListItemBlock.model_rebuild()
-    CreateCalloutBlock.model_rebuild()
-    CreateChildPageBlock.model_rebuild()
-    CreateCodeBlock.model_rebuild()
-    CreateColumnListBlock.model_rebuild()
-    CreateColumnBlock.model_rebuild()
-    CreateDividerBlock.model_rebuild()
-    CreateEmbedBlock.model_rebuild()
-    CreateEquationBlock.model_rebuild()
-    CreateFileBlock.model_rebuild()
-    CreateHeading1Block.model_rebuild()
-    CreateHeading2Block.model_rebuild()
-    CreateHeading3Block.model_rebuild()
-    CreateImageBlock.model_rebuild()
-    CreateNumberedListItemBlock.model_rebuild()
-    CreateParagraphBlock.model_rebuild()
-    CreateQuoteBlock.model_rebuild()
-    CreateToDoBlock.model_rebuild()
-    CreateToggleBlock.model_rebuild()
-    CreateVideoBlock.model_rebuild()
-    CreateTableOfContentsBlock.model_rebuild()
-
-    _bootstrapped = True

notionary/blocks/audio/__init__.py

@@ -1,11 +0,0 @@
-from notionary.blocks.audio.audio_element import AudioElement
-from notionary.blocks.audio.audio_markdown_node import (
-    AudioMarkdownNode,
-)
-from notionary.blocks.audio.audio_models import CreateAudioBlock
-
-__all__ = [
-    "AudioElement",
-    "CreateAudioBlock",
-    "AudioMarkdownNode",
-]

notionary/blocks/audio/audio_element.py

@@ -1,158 +0,0 @@
-from __future__ import annotations
-
-import re
-from pathlib import Path
-from typing import Optional
-
-from notionary.blocks.audio.audio_models import CreateAudioBlock
-from notionary.blocks.base_block_element import BaseBlockElement
-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.util.logging_mixin import LoggingMixin
-
-
-class AudioElement(BaseBlockElement, FileUploadMixin, LoggingMixin, CaptionMixin):
-    r"""
-    Handles conversion between Markdown audio embeds and Notion audio blocks.
-
-    Supports both external URLs and local audio file uploads.
-
-    Markdown audio syntax:
-    - [audio](https://example.com/audio.mp3) - External URL
-    - [audio](./local/song.mp3) - Local audio file (will be uploaded)
-    - [audio](C:\Music\podcast.wav) - Absolute local path (will be uploaded)
-    - [audio](https://example.com/audio.mp3)(caption:Episode 1) - URL with caption
-    """
-
-    AUDIO_PATTERN = re.compile(r"\[audio\]\(([^)]+)\)")
-    SUPPORTED_EXTENSIONS = {".mp3", ".wav", ".ogg", ".oga", ".m4a"}
-
-    @classmethod
-    def match_notion(cls, block: Block) -> bool:
-        """Check if this element can handle the given Notion block."""
-        return block.type == BlockType.AUDIO
-
-    @classmethod
-    async def markdown_to_notion(cls, text: str) -> Optional[BlockCreateResult]:
-        """Convert markdown audio embed to Notion audio block."""
-        # Extract the path/URL
-        path = cls._extract_audio_path(text.strip())
-        if not path:
-            return None
-
-        # Check if it's a local file path
-        if cls._is_local_file_path(path):
-            # Verify file exists and has supported extension
-            audio_path = Path(path)
-            if not audio_path.exists():
-                cls.logger.warning(f"Audio file not found: {path}")
-                return None
-
-            if audio_path.suffix.lower() not in cls.SUPPORTED_EXTENSIONS:
-                cls.logger.warning(f"Unsupported audio format: {audio_path.suffix}")
-                return None
-
-            cls.logger.info(f"Uploading local audio file: {path}")
-
-            # Upload the local audio file
-            file_upload_id = await cls._upload_local_file(path, "audio")
-            if not file_upload_id:
-                cls.logger.error(f"Failed to upload audio file: {path}")
-                return None
-
-            cls.logger.info(
-                f"Successfully uploaded audio file with ID: {file_upload_id}"
-            )
-
-            # Use mixin to extract caption (if present anywhere in text)
-            caption_text = cls.extract_caption(text.strip())
-            caption_rich_text = cls.build_caption_rich_text(caption_text or "")
-
-            audio_content = FileBlock(
-                type=FileType.FILE_UPLOAD,
-                file_upload=FileUploadFile(id=file_upload_id),
-                caption=caption_rich_text,
-            )
-
-            return CreateAudioBlock(audio=audio_content)
-
-        else:
-            # Handle external URL - accept any URL (validation happens at API level)
-            # Use mixin to extract caption (if present anywhere in text)
-            caption_text = cls.extract_caption(text.strip())
-            caption_rich_text = cls.build_caption_rich_text(caption_text or "")
-
-            audio_content = FileBlock(
-                type=FileType.EXTERNAL,
-                external=ExternalFile(url=path),
-                caption=caption_rich_text,
-            )
-
-            return CreateAudioBlock(audio=audio_content)
-
-    @classmethod
-    async def notion_to_markdown(cls, block: Block) -> Optional[str]:
-        """Convert Notion audio block to markdown audio embed."""
-        if block.type != BlockType.AUDIO or block.audio is None:
-            return None
-
-        audio = block.audio
-        url = None
-
-        # Handle both external URLs and uploaded files
-        if audio.type == FileType.EXTERNAL and audio.external is not None:
-            url = audio.external.url
-        elif audio.type == FileType.FILE_UPLOAD and audio.file_upload is not None:
-            url = audio.file_upload.url
-
-        if not url:
-            return None
-
-        result = f"[audio]({url})"
-
-        # Add caption if present
-        caption_markdown = await cls.format_caption_for_markdown(audio.caption or [])
-        if caption_markdown:
-            result += caption_markdown
-
-        return result
-
-    @classmethod
-    def get_system_prompt_information(cls) -> Optional[BlockElementMarkdownInformation]:
-        """Get system prompt information for audio blocks."""
-        return BlockElementMarkdownInformation(
-            block_type=cls.__name__,
-            description="Audio blocks embed audio files from external URLs or local files with optional captions",
-            syntax_examples=[
-                "[audio](https://example.com/song.mp3)",
-                "[audio](./local/podcast.wav)",
-                "[audio](C:\\Music\\interview.mp3)",
-                "[audio](https://example.com/podcast.wav)(caption:Episode 1)",
-                "(caption:Background music)[audio](./song.mp3)",
-                "[audio](./interview.mp3)(caption:**Live** interview)",
-            ],
-            usage_guidelines="Use for embedding audio files like music, podcasts, or sound effects. Supports both external URLs and local file uploads. Supports common audio formats (mp3, wav, ogg, m4a). Caption supports rich text formatting and is optional.",
-        )
-
-    @classmethod
-    def _is_likely_audio_url(cls, url: str) -> bool:
-        return any(url.lower().endswith(ext) for ext in cls.SUPPORTED_EXTENSIONS)
-
-    @classmethod
-    def _extract_audio_path(cls, text: str) -> Optional[str]:
-        """Extract audio path/URL from text, handling caption patterns."""
-        clean_text = cls.remove_caption(text)
-
-        match = cls.AUDIO_PATTERN.search(clean_text)
-        if match:
-            return match.group(1).strip()
-
-        return None

notionary/blocks/audio/audio_markdown_node.py

@@ -1,24 +0,0 @@
-from typing import Optional
-
-from notionary.blocks.markdown.markdown_node import MarkdownNode
-from notionary.blocks.mixins.captions import CaptionMarkdownNodeMixin
-
-
-class AudioMarkdownNode(MarkdownNode, CaptionMarkdownNodeMixin):
-    """
-    Enhanced Audio node with Pydantic integration.
-    Programmatic interface for creating Notion-style audio blocks.
-    """
-
-    url: str
-    caption: Optional[str] = None
-
-    def to_markdown(self) -> str:
-        """Return the Markdown representation.
-
-        Examples:
-        - [audio](https://example.com/song.mp3)
-        - [audio](https://example.com/song.mp3)(caption:Background music)
-        """
-        base_markdown = f"[audio]({self.url})"
-        return self.append_caption_to_markdown(base_markdown, self.caption)

notionary/blocks/audio/audio_models.py

@@ -1,10 +0,0 @@
-from typing import Literal
-
-from pydantic import BaseModel
-
-from notionary.blocks.file.file_element_models import FileBlock
-
-
-class CreateAudioBlock(BaseModel):
-    type: Literal["audio"] = "audio"
-    audio: FileBlock