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

notionary/database/database_discovery.py

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

notionary/database/notion_database_factory.py

@@ -1,193 +0,0 @@
-from typing import List, Optional, Dict, Any
-from difflib import SequenceMatcher
-
-from notionary.database.notion_database import NotionDatabase
-from notionary.notion_client import NotionClient
-from notionary.exceptions.database_exceptions import (
-    DatabaseConnectionError,
-    DatabaseInitializationError,
-    DatabaseNotFoundException,
-    DatabaseParsingError,
-    NotionDatabaseException,
-)
-from notionary.telemetry import track_usage
-from notionary.util import LoggingMixin
-from notionary.util import format_uuid
-from notionary.util import singleton
-
-
-@singleton
-class NotionDatabaseFactory(LoggingMixin):
-    """
-    Factory class for creating NotionDatabaseManager instances.
-    Provides methods for creating managers by database ID or name.
-    """
-
-    @classmethod
-    @track_usage('page_factory_method_used', {'method': 'from_page_id'})
-    def from_database_id(
-        cls, database_id: str, token: Optional[str] = None
-    ) -> NotionDatabase:
-        """
-        Create a NotionDatabaseManager from a database ID.
-
-        Args:
-            database_id: The ID of the Notion database
-            token: Optional Notion API token (uses environment variable if not provided)
-
-        Returns:
-            An initialized NotionDatabaseManager instance
-        """
-
-        try:
-            formatted_id = format_uuid(database_id) or database_id
-
-            manager = NotionDatabase(formatted_id, token)
-
-            cls.logger.info(
-                "Successfully created database manager for ID: %s", formatted_id
-            )
-            return manager
-
-        except DatabaseInitializationError:
-            raise
-        except NotionDatabaseException:
-            raise
-        except Exception as e:
-            error_msg = f"Error connecting to database {database_id}: {str(e)}"
-            cls.logger.error(error_msg)
-            raise DatabaseConnectionError(error_msg) from e
-
-    @classmethod
-    @track_usage('page_factory_method_used', {'method': 'from_url'})
-    async def from_database_name(
-        cls, database_name: str, token: Optional[str] = None
-    ) -> NotionDatabase:
-        """
-        Create a NotionDatabaseManager by finding a database with a matching name.
-        Uses fuzzy matching to find the closest match to the given name.
-
-        Args:
-            database_name: The name of the Notion database to search for
-            token: Optional Notion API token (uses environment variable if not provided)
-
-        Returns:
-            An initialized NotionDatabaseManager instance
-        """
-        cls.logger.debug("Searching for database with name: %s", database_name)
-
-        client = NotionClient(token=token)
-        
-        try:
-            cls.logger.debug("Using search endpoint to find databases")
-
-            search_payload = {
-                "filter": {"property": "object", "value": "database"},
-                "page_size": 100,
-            }
-
-            response = await client.post("search", search_payload)
-
-            if not response or "results" not in response:
-                error_msg = "Failed to fetch databases using search endpoint"
-                cls.logger.error(error_msg)
-                raise DatabaseConnectionError(error_msg)
-
-            databases = response.get("results", [])
-
-            if not databases:
-                error_msg = "No databases found"
-                cls.logger.warning(error_msg)
-                raise DatabaseNotFoundException(database_name, error_msg)
-
-            cls.logger.debug(
-                "Found %d databases, searching for best match", len(databases)
-            )
-
-            best_match = None
-            best_score = 0
-
-            for db in databases:
-                title = cls._extract_title_from_database(db)
-
-                score = SequenceMatcher(
-                    None, database_name.lower(), title.lower()
-                ).ratio()
-
-                if score > best_score:
-                    best_score = score
-                    best_match = db
-
-            if best_score < 0.6 or not best_match:
-                error_msg = f"No good database name match found for '{database_name}'. Best match had score {best_score:.2f}"
-                cls.logger.warning(error_msg)
-                raise DatabaseNotFoundException(database_name, error_msg)
-
-            database_id = best_match.get("id")
-
-            if not database_id:
-                error_msg = "Best match database has no ID"
-                cls.logger.error(error_msg)
-                raise DatabaseParsingError(error_msg)
-
-            matched_name = cls._extract_title_from_database(best_match)
-
-            cls.logger.info(
-                "Found matching database: '%s' (ID: %s) with score: %.2f",
-                matched_name,
-                database_id,
-                best_score,
-            )
-
-            manager = NotionDatabase(database_id, token)
-
-            cls.logger.info(
-                "Successfully created database manager for '%s'", matched_name
-            )
-            await client.close()
-            return manager
-
-        except NotionDatabaseException:
-            await client.close()
-            raise
-        except Exception as e:
-            error_msg = f"Error finding database by name: {str(e)}"
-            cls.logger.error(error_msg)
-            await client.close()
-            raise DatabaseConnectionError(error_msg) from e
-
-    @classmethod
-    def _extract_title_from_database(cls, database: Dict[str, Any]) -> str:
-        """
-        Extract the title from a database object.
-        """
-        try:
-            if "title" in database:
-                return cls._extract_text_from_rich_text(database["title"])
-
-            if "properties" in database and "title" in database["properties"]:
-                title_prop = database["properties"]["title"]
-                if "title" in title_prop:
-                    return cls._extract_text_from_rich_text(title_prop["title"])
-
-            return "Untitled"
-
-        except Exception as e:
-            error_msg = f"Error extracting database title: {str(e)}"
-            cls.class_logger().warning(error_msg)
-            raise DatabaseParsingError(error_msg) from e
-
-    @classmethod
-    def _extract_text_from_rich_text(cls, rich_text: List[Dict[str, Any]]) -> str:
-        """
-        Extract plain text from a rich text array.
-        """
-        if not rich_text:
-            return ""
-
-        text_parts = []
-        for text_obj in rich_text:
-            if "plain_text" in text_obj:
-                text_parts.append(text_obj["plain_text"])
-
-        return "".join(text_parts)

notionary/elements/notion_block_element.py

@@ -1,70 +0,0 @@
-from functools import wraps
-from typing import Dict, Any, Optional
-from abc import ABC
-
-from notionary.prompting.element_prompt_content import ElementPromptContent
-from notionary.telemetry import track_usage
-
-
-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."""
-
-
-def auto_track_conversions(cls):
-    """
-    Decorator der sich auch auf Subklassen vererbt.
-    """
-    conversion_methods = ['markdown_to_notion', 'notion_to_markdown']
-    
-    original_init_subclass = getattr(cls, '__init_subclass__', None)
-    
-    @classmethod
-    def __init_subclass__(cls_inner, **kwargs):
-        # Original __init_subclass__ aufrufen
-        if original_init_subclass:
-            original_init_subclass(**kwargs)
-        
-        # Tracking für Subklasse hinzufügen
-        for method_name in conversion_methods:
-            if hasattr(cls_inner, method_name):
-                original_method = getattr(cls_inner, method_name)
-                
-                if isinstance(original_method, classmethod):
-                    func = original_method.__func__
-                    
-                    @track_usage(f"{cls_inner.__name__.lower()}_{method_name}")
-                    @classmethod
-                    @wraps(func)
-                    def tracked_method(cls_ref, *args, **kwargs):
-                        return func(cls_ref, *args, **kwargs)
-                    
-                    setattr(cls_inner, method_name, tracked_method)
-    
-    cls.__init_subclass__ = __init_subclass__
-    return cls

notionary/exceptions/database_exceptions.py

@@ -1,76 +0,0 @@
-from typing import Optional
-
-
-class NotionDatabaseException(Exception):
-    """Base exception for all Notion database operations."""
-
-    pass
-
-
-class DatabaseNotFoundException(NotionDatabaseException):
-    """Exception raised when a database is not found."""
-
-    def __init__(self, identifier: str, message: str = None):
-        self.identifier = identifier
-        self.message = message or f"Database not found: {identifier}"
-        super().__init__(self.message)
-
-
-class DatabaseInitializationError(NotionDatabaseException):
-    """Exception raised when a database manager fails to initialize."""
-
-    def __init__(self, database_id: str, message: str = None):
-        self.database_id = database_id
-        self.message = (
-            message or f"Failed to initialize database manager for ID: {database_id}"
-        )
-        super().__init__(self.message)
-
-
-class DatabaseConnectionError(NotionDatabaseException):
-    """Exception raised when there's an error connecting to Notion API."""
-
-    def __init__(self, message: str = None):
-        self.message = message or "Error connecting to Notion API"
-        super().__init__(self.message)
-
-
-class DatabaseParsingError(NotionDatabaseException):
-    """Exception raised when there's an error parsing database data."""
-
-    def __init__(self, message: str = None):
-        self.message = message or "Error parsing database data"
-        super().__init__(self.message)
-
-
-class PageNotFoundException(NotionDatabaseException):
-    """Raised when a page is not found or cannot be accessed."""
-
-    def __init__(self, page_id: str, message: Optional[str] = None):
-        self.page_id = page_id
-        self.message = message or f"Page not found: {page_id}"
-        super().__init__(self.message)
-
-
-class PageOperationError(NotionDatabaseException):
-    """Raised when an operation on a page fails."""
-
-    def __init__(self, page_id: str, operation: str, message: Optional[str] = None):
-        self.page_id = page_id
-        self.operation = operation
-        self.message = message or f"Failed to {operation} page {page_id}"
-        super().__init__(self.message)
-
-
-class PropertyError(NotionDatabaseException):
-    """Raised when there's an error with database properties."""
-
-    def __init__(
-        self, property_name: Optional[str] = None, message: Optional[str] = None
-    ):
-        self.property_name = property_name
-        self.message = (
-            message
-            or f"Error with property{' ' + property_name if property_name else ''}"
-        )
-        super().__init__(self.message)

notionary/exceptions/page_creation_exception.py

@@ -1,9 +0,0 @@
-from typing import Optional
-
-
-class PageCreationException(Exception):
-    """Exception raised when page creation in Notion fails."""
-
-    def __init__(self, message: str, response: Optional[dict] = None):
-        super().__init__(message)
-        self.response = response

notionary/page/metadata/metadata_editor.py

@@ -1,150 +0,0 @@
-from typing import Any, Dict, Optional
-from notionary.notion_client import NotionClient
-from notionary.page.properites.property_formatter import NotionPropertyFormatter
-from notionary.util import LoggingMixin
-
-
-class MetadataEditor(LoggingMixin):
-    """
-    Manages and edits the metadata and properties of a Notion page.
-    """
-
-    def __init__(self, page_id: str, client: NotionClient):
-        """
-        Initialize the metadata editor.
-
-        Args:
-            page_id: The ID of the Notion page
-            client: The Notion API client
-        """
-        self.page_id = page_id
-        self._client = client
-        self._property_formatter = NotionPropertyFormatter()
-
-    async def set_title(self, title: str) -> Optional[str]:
-        """
-        Sets the title of the page.
-
-        Args:
-            title: The new title for the page.
-
-        Returns:
-            Optional[str]: The new title if successful, None otherwise.
-        """
-        try:
-            data = {
-                "properties": {
-                    "title": {"title": [{"type": "text", "text": {"content": title}}]}
-                }
-            }
-
-            result = await self._client.patch_page(self.page_id, data)
-
-            if result:
-                return title
-            return None
-        except Exception as e:
-            self.logger.error("Error setting page title: %s", str(e))
-            return None
-
-    async def set_property_by_name(
-        self, property_name: str, value: Any
-    ) -> Optional[str]:
-        """
-        Sets a property value based on the property name, automatically detecting the property type.
-
-        Args:
-            property_name: The name of the property in Notion
-            value: The value to set
-
-        Returns:
-            Optional[str]: The property name if successful, None if operation fails
-        """
-        property_schema = await self._get_property_schema()
-
-        if property_name not in property_schema:
-            self.logger.warning(
-                "Property '%s' not found in database schema", property_name
-            )
-            return None
-
-        property_type = property_schema[property_name]["type"]
-        return await self._set_property(property_name, value, property_type)
-
-    async def _set_property(
-        self, property_name: str, property_value: Any, property_type: str
-    ) -> Optional[str]:
-        """
-        Generic method to set any property on a Notion page.
-
-        Args:
-            property_name: The name of the property in Notion
-            property_value: The value to set
-            property_type: The type of property ('select', 'multi_select', 'status', 'relation', etc.)
-
-        Returns:
-            Optional[str]: The property name if successful, None if operation fails
-        """
-        property_payload = self._property_formatter.format_value(
-            property_type, property_value
-        )
-
-        if not property_payload:
-            self.logger.warning(
-                "Could not create payload for property type: %s", property_type
-            )
-            return None
-
-        try:
-            result = await self._client.patch_page(
-                self.page_id, {"properties": {property_name: property_payload}}
-            )
-
-            if result:
-                return property_name
-            return None
-        except Exception as e:
-            self.logger.error("Error setting property '%s': %s", property_name, str(e))
-            return None
-
-    async def _get_property_schema(self) -> Dict[str, Dict[str, Any]]:
-        """
-        Retrieves the schema for all properties of the page.
-
-        Returns:
-            Dict[str, Dict[str, Any]]: A dictionary mapping property names to their schema
-        """
-        page_data = await self._client.get_page(self.page_id)
-        property_schema = {}
-
-        # Property types that can have options
-        option_types = {
-            "select": "select",
-            "multi_select": "multi_select",
-            "status": "status",
-        }
-
-        for prop_name, prop_data in page_data.properties.items():
-            prop_type = prop_data.get("type")
-
-            schema_entry = {
-                "id": prop_data.get("id"),
-                "type": prop_type,
-                "name": prop_name,
-            }
-
-            # Check if this property type can have options
-            if prop_type in option_types:
-                option_key = option_types[prop_type]
-                try:
-                    prop_type_data = prop_data.get(option_key, {})
-                    if isinstance(prop_type_data, dict):
-                        schema_entry["options"] = prop_type_data.get("options", [])
-                except Exception as e:
-                    self.logger.warning(
-                        "Error processing property schema for '%s': %s", prop_name, e
-                    )
-
-            property_schema[prop_name] = schema_entry
-
-        return property_schema