notionary 0.2.12__py3-none-any.whl → 0.2.14__py3-none-any.whl

notionary/__init__.py

@@ -1,30 +1,13 @@
-__version__ = "0.2.10"
-
-from .notion_client import NotionClient
+__version__ = "0.2.14"
 
 from .database.notion_database import NotionDatabase
-from .database.notion_database_factory import NotionDatabaseFactory
-from .database.database_discovery import DatabaseDiscovery
 
 from .page.notion_page import NotionPage
-from .page.notion_page_factory import NotionPageFactory
-
-from .elements.registry.block_registry import BlockRegistry
-from .elements.registry.block_registry_builder import (
-    BlockRegistryBuilder,
-)
-
-from .telemetry.telemetry import NotionaryTelemetry
+from .workspace import NotionWorkspace
 
-_telemetry = NotionaryTelemetry()
 
 __all__ = [
-    "NotionClient",
     "NotionDatabase",
-    "NotionDatabaseFactory",
-    "DatabaseDiscovery",
     "NotionPage",
-    "NotionPageFactory",
-    "BlockRegistry",
-    "BlockRegistryBuilder",
+    "NotionWorkspace",
 ]

notionary/{notion_client.py → base_notion_client.py}

@@ -1,32 +1,37 @@
 import asyncio
 import os
-import weakref
+from abc import ABC
 from enum import Enum
 from typing import Dict, Any, Optional, Union
 import httpx
 from dotenv import load_dotenv
-from notionary.models.notion_database_response import NotionDatabaseResponse
-from notionary.models.notion_page_response import NotionPageResponse
 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 NotionClient(LoggingMixin):
-    """Verbesserter Notion-Client mit automatischer Ressourcenverwaltung."""
+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"
-    _instances = weakref.WeakSet()
 
     def __init__(self, token: Optional[str] = None, timeout: int = 30):
-        load_dotenv()
-        self.token = token or os.getenv("NOTION_SECRET", "")
+        self.token = token or self._find_token()
         if not self.token:
             raise ValueError("Notion API token is required")
 
@@ -36,64 +41,66 @@ class NotionClient(LoggingMixin):
             "Notion-Version": self.NOTION_VERSION,
         }
 
-        self.client = httpx.AsyncClient(headers=self.headers, timeout=timeout)
+        self.client: Optional[httpx.AsyncClient] = None
+        self.timeout = timeout
+        self._is_initialized = False
 
-        self._instances.add(self)
+    def __del__(self):
+        """Auto-cleanup when client is destroyed."""
+        if not hasattr(self, "client") or not self.client:
+            return
 
-    @classmethod
-    async def close_all(cls):
-        """
-        Closes all active NotionClient instances and releases resources.
-        """
-        for instance in list(cls._instances):
-            await instance.close()
+        try:
+            loop = asyncio.get_event_loop()
+            if not loop.is_running():
+                self.logger.warning(
+                    "Event loop not running, could not auto-close NotionClient"
+                )
+                return
 
-    async def close(self):
-        """
-        Closes the HTTP client for this instance and releases resources.
-        """
-        if hasattr(self, "client") and self.client:
-            await self.client.aclose()
-            self.client = None
+            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")
 
-    # Das hier für die unterschiedlichen responses hier noch richtig typne wäre gut.
-    async def get(self, endpoint: str) -> Optional[Dict[str, Any]]:
-        """
-        Sends a GET request to the specified Notion API endpoint.
+    async def __aenter__(self):
+        """Async context manager entry."""
+        await self.ensure_initialized()
+        return self
 
-        Args:
-            endpoint: The relative API path (e.g., 'databases/<id>').
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Async context manager exit."""
+        await self.close()
 
-        Returns:
-            A dictionary with the response data, or None if the request failed.
+    async def ensure_initialized(self) -> None:
         """
-        return await self._make_request(HttpMethod.GET, endpoint)
-
-    async def get_database(self, database_id: str) -> NotionDatabaseResponse:
+        Ensures the HTTP client is initialized.
         """
-        Ruft die Metadaten einer Notion-Datenbank anhand ihrer ID ab und gibt sie als NotionPageResponse zurück.
+        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")
 
-        Args:
-            database_id: Die Notion-Datenbank-ID.
-
-        Returns:
-            Ein NotionPageResponse-Objekt mit den Datenbankmetadaten.
+    async def close(self) -> None:
         """
-        return NotionDatabaseResponse.model_validate(
-            await self.get(f"databases/{database_id}")
-        )
+        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_page(self, page_id: str) -> NotionPageResponse:
+    async def get(self, endpoint: str) -> Optional[Dict[str, Any]]:
         """
-        Ruft die Metadaten einer Notion-Seite anhand ihrer ID ab und gibt sie als NotionPageResponse zurück.
+        Sends a GET request to the specified Notion API endpoint.
 
         Args:
-            page_id: Die Notion-Seiten-ID.
-
-        Returns:
-            Ein NotionPageResponse-Objekt mit den Seitenmetadaten.
+            endpoint: The API endpoint (without base URL)
         """
-        return NotionPageResponse.model_validate(await self.get(f"pages/{page_id}"))
+        return await self._make_request(HttpMethod.GET, endpoint)
 
     async def post(
         self, endpoint: str, data: Optional[Dict[str, Any]] = None
@@ -102,11 +109,8 @@ class NotionClient(LoggingMixin):
         Sends a POST request to the specified Notion API endpoint.
 
         Args:
-            endpoint: The relative API path.
-            data: Optional dictionary payload to send with the request.
-
-        Returns:
-            A dictionary with the response data, or None if the request failed.
+            endpoint: The API endpoint (without base URL)
+            data: Request body data
         """
         return await self._make_request(HttpMethod.POST, endpoint, data)
 
@@ -117,37 +121,17 @@ class NotionClient(LoggingMixin):
         Sends a PATCH request to the specified Notion API endpoint.
 
         Args:
-            endpoint: The relative API path.
-            data: Optional dictionary payload to send with the request.
-
-        Returns:
-            A dictionary with the response data, or None if the request failed.
+            endpoint: The API endpoint (without base URL)
+            data: Request body data
         """
         return await self._make_request(HttpMethod.PATCH, endpoint, data)
 
-    async def patch_page(
-        self, page_id: str, data: Optional[Dict[str, Any]] = None
-    ) -> NotionPageResponse:
-        """
-        Sends a PATCH request to update a Notion page.
-
-        Args:
-            page_id: The ID of the page to update.
-            data: Optional dictionary payload to send with the request.
-        """
-        return NotionPageResponse.model_validate(
-            await self.patch(f"pages/{page_id}", data=data)
-        )
-
     async def delete(self, endpoint: str) -> bool:
         """
         Sends a DELETE request to the specified Notion API endpoint.
 
         Args:
-            endpoint: The relative API path.
-
-        Returns:
-            True if the request was successful, False otherwise.
+            endpoint: The API endpoint (without base URL)
         """
         result = await self._make_request(HttpMethod.DELETE, endpoint)
         return result is not None
@@ -159,8 +143,15 @@ class NotionClient(LoggingMixin):
         data: Optional[Dict[str, Any]] = None,
     ) -> Optional[Dict[str, Any]]:
         """
-        Führt eine HTTP-Anfrage aus und gibt direkt die Daten zurück oder None bei Fehler.
+        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)
         """
+        await self.ensure_initialized()
+
         url = f"{self.BASE_URL}/{endpoint.lstrip('/')}"
         method_str = (
             method.value if isinstance(method, HttpMethod) else str(method).lower()
@@ -173,9 +164,11 @@ class NotionClient(LoggingMixin):
                 method_str in [HttpMethod.POST.value, HttpMethod.PATCH.value]
                 and data is not None
             ):
-                response = await getattr(self.client, method_str)(url, json=data)
+                response: httpx.Response = await getattr(self.client, method_str)(
+                    url, json=data
+                )
             else:
-                response = await getattr(self.client, method_str)(url)
+                response: httpx.Response = await getattr(self.client, method_str)(url)
 
             response.raise_for_status()
             result_data = response.json()
@@ -194,19 +187,20 @@ class NotionClient(LoggingMixin):
             self.logger.error("Request error (%s): %s", url, error_msg)
             return None
 
-    def __del__(self):
-        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")
+    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_API_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/__init__.py

@@ -0,0 +1,61 @@
+# Order is important here, as some imports depend on others.
+from .prompts.element_prompt_content import ElementPromptContent
+from .prompts.element_prompt_builder import ElementPromptBuilder
+
+from .notion_block_element import NotionBlockElement
+
+
+from .audio_element import AudioElement
+from .bulleted_list_element import BulletedListElement
+from .callout_element import CalloutElement
+from .code_block_element import CodeBlockElement
+from .column_element import ColumnElement
+from .divider_element import DividerElement
+from .embed_element import EmbedElement
+from .heading_element import HeadingElement
+from .image_element import ImageElement
+from .numbered_list_element import NumberedListElement
+from .paragraph_element import ParagraphElement
+from .table_element import TableElement
+from .toggle_element import ToggleElement
+from .todo_element import TodoElement
+from .video_element import VideoElement
+from .toggleable_heading_element import ToggleableHeadingElement
+from .bookmark_element import BookmarkElement
+from .divider_element import DividerElement
+from .heading_element import HeadingElement
+from .mention_element import MentionElement
+from .qoute_element import QuoteElement
+
+from .registry.block_registry import BlockRegistry
+from .registry.block_registry_builder import BlockRegistryBuilder
+from .notion_block_client import NotionBlockClient
+
+
+__all__ = [
+    "ElementPromptContent",
+    "ElementPromptBuilder",
+    "NotionBlockElement",
+    "AudioElement",
+    "BulletedListElement",
+    "CalloutElement",
+    "CodeBlockElement",
+    "ColumnElement",
+    "DividerElement",
+    "EmbedElement",
+    "HeadingElement",
+    "ImageElement",
+    "NumberedListElement",
+    "ParagraphElement",
+    "TableElement",
+    "ToggleElement",
+    "TodoElement",
+    "VideoElement",
+    "ToggleableHeadingElement",
+    "BookmarkElement",
+    "MentionElement",
+    "QuoteElement",
+    "BlockRegistry",
+    "BlockRegistryBuilder",
+    "NotionBlockClient",
+]

notionary/{elements → blocks}/audio_element.py

@@ -1,12 +1,14 @@
-import re
+from __future__ import annotations
 from typing import Dict, Any, Optional, List
-from notionary.elements.notion_block_element import NotionBlockElement, auto_track_conversions
-from notionary.prompting.element_prompt_content import (
+import re
+
+from notionary.blocks.notion_block_element import NotionBlockElement
+from notionary.blocks import (
     ElementPromptBuilder,
     ElementPromptContent,
 )
 
-@auto_track_conversions
+
 class AudioElement(NotionBlockElement):
     """
     Handles conversion between Markdown audio embeds and Notion audio blocks.

notionary/{elements → blocks}/bookmark_element.py

@@ -1,13 +1,10 @@
 import re
 from typing import Dict, Any, Optional, List, Tuple
 
-from notionary.elements.notion_block_element import NotionBlockElement, auto_track_conversions
-from notionary.prompting.element_prompt_content import (
-    ElementPromptBuilder,
-    ElementPromptContent,
-)
+from notionary.blocks import NotionBlockElement
+from notionary.blocks import ElementPromptContent, ElementPromptBuilder
+
 
-@auto_track_conversions
 class BookmarkElement(NotionBlockElement):
     """
     Handles conversion between Markdown bookmarks and Notion bookmark blocks.

notionary/{elements → blocks}/bulleted_list_element.py

@@ -1,13 +1,11 @@
 import re
 from typing import Dict, Any, Optional
-from notionary.elements.notion_block_element import NotionBlockElement, auto_track_conversions
-from notionary.prompting.element_prompt_content import (
-    ElementPromptBuilder,
-    ElementPromptContent,
-)
-from notionary.elements.text_inline_formatter import TextInlineFormatter
+from notionary.blocks import NotionBlockElement
+from notionary.blocks import ElementPromptContent, ElementPromptBuilder
+
+from notionary.blocks.text_inline_formatter import TextInlineFormatter
+
 
-@auto_track_conversions
 class BulletedListElement(NotionBlockElement):
     """Class for converting between Markdown bullet lists and Notion bulleted list items."""
 

notionary/{elements → blocks}/callout_element.py

@@ -1,14 +1,11 @@
 import re
 from typing import Dict, Any, Optional
 
-from notionary.prompting.element_prompt_content import (
-    ElementPromptBuilder,
-    ElementPromptContent,
-)
-from notionary.elements.text_inline_formatter import TextInlineFormatter
-from notionary.elements.notion_block_element import NotionBlockElement, auto_track_conversions
-
-@auto_track_conversions
+from notionary.blocks import ElementPromptContent, ElementPromptBuilder
+from notionary.blocks.text_inline_formatter import TextInlineFormatter
+from notionary.blocks.notion_block_element import NotionBlockElement
+
+
 class CalloutElement(NotionBlockElement):
     """
     Handles conversion between Markdown callouts and Notion callout blocks.

notionary/{elements → blocks}/code_block_element.py

@@ -1,12 +1,10 @@
 import re
+
 from typing import Dict, Any, Optional, List, Tuple
-from notionary.elements.notion_block_element import NotionBlockElement, auto_track_conversions
-from notionary.prompting.element_prompt_content import (
-    ElementPromptBuilder,
-    ElementPromptContent,
-)
+from notionary.blocks import NotionBlockElement
+from notionary.blocks import ElementPromptContent, ElementPromptBuilder
+
 
-@auto_track_conversions
 class CodeBlockElement(NotionBlockElement):
     """
     Handles conversion between Markdown code blocks and Notion code blocks.

notionary/{elements → blocks}/column_element.py

@@ -1,14 +1,11 @@
 import re
 from typing import Dict, Any, Optional, List, Tuple, Callable
 
-from notionary.elements.notion_block_element import NotionBlockElement, auto_track_conversions
+from notionary.blocks import NotionBlockElement
 from notionary.page.formatting.spacer_rules import SPACER_MARKER
-from notionary.prompting.element_prompt_content import (
-    ElementPromptBuilder,
-    ElementPromptContent,
-)
+from notionary.blocks import ElementPromptContent, ElementPromptBuilder
+
 
-@auto_track_conversions
 class ColumnElement(NotionBlockElement):
     """
     Handles conversion between custom Markdown column syntax and Notion column blocks.

notionary/{elements → blocks}/divider_element.py

@@ -1,13 +1,10 @@
 import re
 from typing import Dict, Any, Optional
 
-from notionary.elements.notion_block_element import NotionBlockElement, auto_track_conversions
-from notionary.prompting.element_prompt_content import (
-    ElementPromptBuilder,
-    ElementPromptContent,
-)
+from notionary.blocks import NotionBlockElement
+from notionary.blocks import ElementPromptContent, ElementPromptBuilder
+
 
-@auto_track_conversions
 class DividerElement(NotionBlockElement):
     """
     Handles conversion between Markdown horizontal dividers and Notion divider blocks.

notionary/{elements → blocks}/embed_element.py

@@ -1,12 +1,10 @@
 import re
+
 from typing import Dict, Any, Optional, List
-from notionary.elements.notion_block_element import NotionBlockElement, auto_track_conversions
-from notionary.prompting.element_prompt_content import (
-    ElementPromptBuilder,
-    ElementPromptContent,
-)
+from notionary.blocks import NotionBlockElement
+from notionary.blocks import ElementPromptContent, ElementPromptBuilder
+
 
-@auto_track_conversions
 class EmbedElement(NotionBlockElement):
     """
     Handles conversion between Markdown embeds and Notion embed blocks.

notionary/{elements → blocks}/heading_element.py

@@ -1,14 +1,11 @@
 import re
 from typing import Dict, Any, Optional
 
-from notionary.elements.notion_block_element import NotionBlockElement, auto_track_conversions
-from notionary.prompting.element_prompt_content import (
-    ElementPromptBuilder,
-    ElementPromptContent,
-)
-from notionary.elements.text_inline_formatter import TextInlineFormatter
-
-@auto_track_conversions
+from notionary.blocks import NotionBlockElement
+from notionary.blocks import ElementPromptContent, ElementPromptBuilder
+from notionary.blocks.text_inline_formatter import TextInlineFormatter
+
+
 class HeadingElement(NotionBlockElement):
     """Handles conversion between Markdown headings and Notion heading blocks."""
 
@@ -88,7 +85,6 @@ class HeadingElement(NotionBlockElement):
             .with_avoidance_guidelines(
                 "Only H1-H3 syntax is supported. H4 and deeper heading levels are not available."
             )
-            .with_syntax("## Your Heading Text")
             .with_standard_markdown()
             .build()
         )

notionary/{elements → blocks}/image_element.py

@@ -1,12 +1,10 @@
 import re
+
 from typing import Dict, Any, Optional, List
-from notionary.elements.notion_block_element import NotionBlockElement, auto_track_conversions
-from notionary.prompting.element_prompt_content import (
-    ElementPromptBuilder,
-    ElementPromptContent,
-)
+from notionary.blocks import NotionBlockElement
+from notionary.blocks import ElementPromptContent, ElementPromptBuilder
+
 
-@auto_track_conversions
 class ImageElement(NotionBlockElement):
     """
     Handles conversion between Markdown images and Notion image blocks.

notionary/{elements → blocks}/mention_element.py

@@ -1,14 +1,10 @@
 import re
 from typing import Dict, Any, Optional, List
-from typing_extensions import override
 
-from notionary.elements.notion_block_element import NotionBlockElement, auto_track_conversions
-from notionary.prompting.element_prompt_content import (
-    ElementPromptBuilder,
-    ElementPromptContent,
-)
+from notionary.blocks import NotionBlockElement
+from notionary.blocks import ElementPromptContent, ElementPromptBuilder
+
 
-@auto_track_conversions
 class MentionElement(NotionBlockElement):
     """
     Handles conversion between Markdown mentions and Notion mention elements.

notionary/blocks/notion_block_client.py

@@ -0,0 +1,26 @@
+from typing import Dict, Any, List
+from notionary.base_notion_client import BaseNotionClient
+from notionary.util import singleton
+
+
+# TODO: Tyoe the block api (fix registry as well)
+@singleton
+class NotionBlockClient(BaseNotionClient):
+    """
+    Client for Notion page-specific operations.
+    Inherits base HTTP functionality from BaseNotionClient.
+    """
+
+    async def get_page_blocks(self, page_id: str) -> List[Dict[str, Any]]:
+        """
+        Retrieves all blocks of a Notion page.
+        """
+        response = await self.get(f"blocks/{page_id}/children")
+        return response.get("results", [])
+
+    async def get_block_children(self, block_id: str) -> List[Dict[str, Any]]:
+        """
+        Retrieves all children blocks of a specific block.
+        """
+        response = await self.get(f"blocks/{block_id}/children")
+        return response.get("results", [])

notionary/blocks/notion_block_element.py

@@ -0,0 +1,34 @@
+from typing import Dict, Any, Optional
+from abc import ABC
+
+from notionary.blocks.prompts.element_prompt_content import ElementPromptContent
+
+
+class NotionBlockElement(ABC):
+    """Base class for elements that can be converted between Markdown and Notion."""
+
+    @classmethod
+    def markdown_to_notion(cls, text: str) -> Optional[Dict[str, Any]]:
+        """Convert markdown to Notion block."""
+
+    @classmethod
+    def notion_to_markdown(cls, block: Dict[str, Any]) -> Optional[str]:
+        """Convert Notion block to markdown."""
+
+    @classmethod
+    def match_markdown(cls, text: str) -> bool:
+        """Check if this element can handle the given markdown text."""
+        return bool(cls.markdown_to_notion(text))  # Now calls the class's version
+
+    @classmethod
+    def match_notion(cls, block: Dict[str, Any]) -> bool:
+        """Check if this element can handle the given Notion block."""
+        return bool(cls.notion_to_markdown(block))  # Now calls the class's version
+
+    @classmethod
+    def is_multiline(cls) -> bool:
+        return False
+
+    @classmethod
+    def get_llm_prompt_content(cls) -> ElementPromptContent:
+        """Returns a dictionary with information for LLM prompts about this element."""