notionary 0.1.29__py3-none-any.whl → 0.2.0__py3-none-any.whl

notionary/page/notion_page_factory.py

@@ -1,5 +1,4 @@
-import logging
-from typing import List, Optional, Dict, Any
+from typing import List, Optional, Dict, Any, Tuple
 from difflib import SequenceMatcher
 
 from notionary import NotionPage, NotionClient
@@ -13,230 +12,182 @@ class NotionPageFactory(LoggingMixin):
     Provides methods for creating page instances by page ID, URL, or name.
     """
 
-    @classmethod
-    def class_logger(cls):
-        """Class logger - for class methods"""
-        return logging.getLogger(cls.__name__)
+    MATCH_THRESHOLD = 0.6
+    MAX_SUGGESTIONS = 5
 
     @classmethod
-    async def from_page_id(
-        cls, page_id: str, token: Optional[str] = None
-    ) -> NotionPage:
-        """
-        Create a NotionPage from a page ID.
-
-        Args:
-            page_id: The ID of the Notion page
-            token: Optional Notion API token (uses environment variable if not provided)
-
-        Returns:
-            An initialized NotionPage instance
-
-        Raises:
-            NotionError: If there is any error during page creation or connection
-        """
-        logger = cls.class_logger()
-
+    def from_page_id(cls, page_id: str, token: Optional[str] = None) -> NotionPage:
+        """Create a NotionPage from a page ID."""
         try:
             formatted_id = format_uuid(page_id) or page_id
-
             page = NotionPage(page_id=formatted_id, token=token)
-
-            logger.info("Successfully created page instance for ID: %s", formatted_id)
+            cls.logger.info(
+                "Successfully created page instance for ID: %s", formatted_id
+            )
             return page
-
         except Exception as e:
-            error_msg = f"Error connecting to page {page_id}: {str(e)}"
-            logger.error(error_msg)
+            cls.logger.error("Error connecting to page %s: %s", page_id, str(e))
+            raise
 
     @classmethod
-    async def from_url(cls, url: str, token: Optional[str] = None) -> NotionPage:
-        """
-        Create a NotionPage from a Notion URL.
-
-        Args:
-            url: The URL of the Notion page
-            token: Optional Notion API token (uses environment variable if not provided)
-
-        Returns:
-            An initialized NotionPage instance
-
-        Raises:
-            NotionError: If there is any error during page creation or connection
-        """
-        logger = cls.class_logger()
+    def from_url(cls, url: str, token: Optional[str] = None) -> NotionPage:
+        """Create a NotionPage from a Notion URL."""
 
         try:
             page_id = extract_and_validate_page_id(url=url)
             if not page_id:
-                error_msg = f"Could not extract valid page ID from URL: {url}"
-                logger.error(error_msg)
+                cls.logger.error("Could not extract valid page ID from URL: %s", url)
+                raise ValueError(f"Invalid URL: {url}")
 
             page = NotionPage(page_id=page_id, url=url, token=token)
-
-            logger.info(
+            cls.logger.info(
                 "Successfully created page instance from URL for ID: %s", page_id
             )
             return page
-
         except Exception as e:
-            error_msg = f"Error connecting to page with URL {url}: {str(e)}"
-            logger.error(error_msg)
+            cls.logger.error("Error connecting to page with URL %s: %s", url, str(e))
+            raise
 
     @classmethod
     async def from_page_name(
         cls, page_name: str, token: Optional[str] = None
     ) -> NotionPage:
-        """
-        Create a NotionPage by finding a page with a matching name.
-        Uses fuzzy matching to find the closest match to the given name.
-        If no good match is found, suggests closest alternatives ("Did you mean?").
-
-        Args:
-            page_name: The name of the Notion page to search for
-            token: Optional Notion API token (uses environment variable if not provided)
-
-        Returns:
-            An initialized NotionPage instance
-
-        Raises:
-            NotionError: If there is any error during page search or connection
-            NotionPageNotFoundError: If no matching page found, includes suggestions
-        """
-        logger = cls.class_logger()
-        logger.debug("Searching for page with name: %s", page_name)
+        """Create a NotionPage by finding a page with a matching name using fuzzy matching."""
+        cls.logger.debug("Searching for page with name: %s", page_name)
 
         client = NotionClient(token=token)
 
         try:
-            logger.debug("Using search endpoint to find pages")
-
-            search_payload = {
-                "filter": {"property": "object", "value": "page"},
-                "page_size": 100,
-            }
-
-            response = await client.post("search", search_payload)
-
-            if not response or "results" not in response:
-                error_msg = "Failed to fetch pages using search endpoint"
-                logger.error(error_msg)
-
-            pages = response.get("results", [])
-
+            # Fetch pages
+            pages = await cls._search_pages(client)
             if not pages:
-                error_msg = f"No pages found matching '{page_name}'"
-                logger.warning(error_msg)
-
-            logger.debug("Found %d pages, searching for best match", len(pages))
-
-            # Store all matches with their scores for potential suggestions
-            matches = []
-            best_match = None
-            best_score = 0
-
-            for page in pages:
-                title = cls._extract_title_from_page(page)
-                score = SequenceMatcher(None, page_name.lower(), title.lower()).ratio()
-
-                matches.append((page, title, score))
+                cls.logger.warning("No pages found matching '%s'", page_name)
+                raise ValueError(f"No pages found matching '{page_name}'")
 
-                if score > best_score:
-                    best_score = score
-                    best_match = page
+            # Find best match
+            best_match, best_score, suggestions = cls._find_best_match(pages, page_name)
 
-            if best_score < 0.6 or not best_match:
-                # Sort matches by score in descending order
-                matches.sort(key=lambda x: x[2], reverse=True)
-
-                # Take top N suggestions (adjust as needed)
-                suggestions = [title for _, title, _ in matches[:5]]
-
-                error_msg = f"No good match found for '{page_name}'. Did you mean one of these?\n"
-                error_msg += "\n".join(f"- {suggestion}" for suggestion in suggestions)
-
-                logger.warning(
+            # Check if match is good enough
+            if best_score < cls.MATCH_THRESHOLD or not best_match:
+                suggestion_msg = cls._format_suggestions(suggestions)
+                cls.logger.warning(
                     "No good match found for '%s'. Best score: %.2f",
                     page_name,
                     best_score,
                 )
+                raise ValueError(
+                    f"No good match found for '{page_name}'. {suggestion_msg}"
+                )
 
+            # Create page from best match
             page_id = best_match.get("id")
-
             if not page_id:
-                error_msg = "Best match page has no ID"
-                logger.error(error_msg)
+                cls.logger.error("Best match page has no ID")
+                raise ValueError("Best match page has no ID")
 
             matched_name = cls._extract_title_from_page(best_match)
-
-            logger.info(
+            cls.logger.info(
                 "Found matching page: '%s' (ID: %s) with score: %.2f",
                 matched_name,
                 page_id,
                 best_score,
             )
 
-            page = NotionPage(page_id=page_id, title=matched_name, token=token)
+            page = NotionPage.from_page_id(page_id=page_id, token=token)
+            cls.logger.info("Successfully created page instance for '%s'", matched_name)
 
-            logger.info("Successfully created page instance for '%s'", matched_name)
             await client.close()
             return page
 
         except Exception as e:
-            error_msg = f"Error finding page by name: {str(e)}"
-            logger.error(error_msg)
+            cls.logger.error("Error finding page by name: %s", str(e))
+            await client.close()
+            raise
 
     @classmethod
-    def _extract_title_from_page(cls, page: Dict[str, Any]) -> str:
-        """
-        Extract the title from a page object.
+    async def _search_pages(cls, client: NotionClient) -> List[Dict[str, Any]]:
+        """Search for pages using the Notion API."""
+        cls.logger.debug("Using search endpoint to find pages")
+
+        search_payload = {
+            "filter": {"property": "object", "value": "page"},
+            "page_size": 100,
+        }
+
+        response = await client.post("search", search_payload)
+
+        if not response or "results" not in response:
+            cls.logger.error("Failed to fetch pages using search endpoint")
+            raise ValueError("Failed to fetch pages using search endpoint")
+
+        return response.get("results", [])
+
+    @classmethod
+    def _find_best_match(
+        cls, pages: List[Dict[str, Any]], query: str
+    ) -> Tuple[Optional[Dict[str, Any]], float, List[str]]:
+        """Find the best matching page for the given query."""
+        cls.logger.debug("Found %d pages, searching for best match", len(pages))
+
+        matches = []
+        best_match = None
+        best_score = 0
+
+        for page in pages:
+            title = cls._extract_title_from_page(page)
+            score = SequenceMatcher(None, query.lower(), title.lower()).ratio()
+            matches.append((page, title, score))
+
+            if score > best_score:
+                best_score = score
+                best_match = page
 
-        Args:
-            page: The page object returned from the Notion API
+        # Get top suggestions
+        matches.sort(key=lambda x: x[2], reverse=True)
+        suggestions = [title for _, title, _ in matches[: cls.MAX_SUGGESTIONS]]
 
-        Returns:
-            The title of the page
+        return best_match, best_score, suggestions
+
+    @classmethod
+    def _format_suggestions(cls, suggestions: List[str]) -> str:
+        """Format suggestions as a readable string."""
+        if not suggestions:
+            return ""
 
-        Raises:
-            NotionError: If the title cannot be extracted
-        """
+        msg = "Did you mean one of these?\n"
+        msg += "\n".join(f"- {suggestion}" for suggestion in suggestions)
+        return msg
+
+    @classmethod
+    def _extract_title_from_page(cls, page: Dict[str, Any]) -> str:
+        """Extract the title from a page object."""
         try:
             if "properties" in page:
                 for prop_value in page["properties"].values():
                     if prop_value.get("type") != "title":
                         continue
                     title_array = prop_value.get("title", [])
-                    if not title_array:
-                        continue
-                    return cls._extract_text_from_rich_text(title_array)
+                    if title_array:
+                        return cls._extract_text_from_rich_text(title_array)
 
+            # Fall back to child_page
             if "child_page" in page:
                 return page.get("child_page", {}).get("title", "Untitled")
 
             return "Untitled"
 
         except Exception as e:
-            error_msg = f"Error extracting page title: {str(e)}"
-            cls.class_logger().warning(error_msg)
+            cls.logger.warning("Error extracting page title: %s", str(e))
             return "Untitled"
 
     @classmethod
     def _extract_text_from_rich_text(cls, rich_text: List[Dict[str, Any]]) -> str:
-        """
-        Extract plain text from a rich text array.
-
-        Args:
-            rich_text: A list of rich text objects from the Notion API
-
-        Returns:
-            The combined plain text content
-        """
+        """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"])
+        text_parts = [
+            text_obj["plain_text"] for text_obj in rich_text if "plain_text" in text_obj
+        ]
 
         return "".join(text_parts)

notionary/page/notion_to_markdown_converter.py

@@ -1,8 +1,8 @@
 from typing import Dict, Any, List, Optional
 
-from notionary.elements.registry.block_element_registry import BlockElementRegistry
-from notionary.elements.registry.block_element_registry_builder import (
-    BlockElementRegistryBuilder,
+from notionary.elements.registry.block_registry import BlockRegistry
+from notionary.elements.registry.block_registry_builder import (
+    BlockRegistryBuilder,
 )
 
 
@@ -12,12 +12,12 @@ class NotionToMarkdownConverter:
     TOGGLE_ELEMENT_TYPES = ["toggle", "toggleable_heading"]
     LIST_ITEM_TYPES = ["numbered_list_item", "bulleted_list_item"]
 
-    def __init__(self, block_registry: Optional[BlockElementRegistry] = None):
+    def __init__(self, block_registry: Optional[BlockRegistry] = None):
         """
         Initialize the NotionToMarkdownConverter.
         """
         self._block_registry = (
-            block_registry or BlockElementRegistryBuilder().create_full_registry()
+            block_registry or BlockRegistryBuilder().create_full_registry()
         )
 
     def convert(self, blocks: List[Dict[str, Any]]) -> str:

notionary/page/properites/database_property_service.py

@@ -21,7 +21,7 @@ class DatabasePropertyService(LoggingMixin):
         self._client = client
         self._schema = None
 
-    async def load_schema(self, force_refresh=False) -> bool:
+    async def load_schema(self, force_refresh: bool = False) -> bool:
         """
         Loads the database schema.
 
@@ -29,24 +29,22 @@ class DatabasePropertyService(LoggingMixin):
             force_refresh: Whether to force a refresh of the schema
 
         Returns:
-            bool: True if schema loaded successfully, False otherwise
+            True if schema loaded successfully, False otherwise.
         """
         if self._schema is not None and not force_refresh:
             return True
 
         try:
-            database = await self._client.get(f"databases/{self._database_id}")
-            if database and "properties" in database:
-                self._schema = database["properties"]
-                self.logger.debug("Loaded schema for database %s", self._database_id)
-                return True
-            else:
-                self.logger.error(
-                    "Failed to load schema: missing 'properties' in response"
-                )
-                return False
+            database = await self._client.get_database(self._database_id)
+
+            self._schema = database.properties
+            self.logger.debug("Loaded schema for database %s", self._database_id)
+            return True
+
         except Exception as e:
-            self.logger.error("Error loading database schema: %s", str(e))
+            self.logger.error(
+                "Error loading database schema for %s: %s", self._database_id, str(e)
+            )
             return False
 
     async def _ensure_schema_loaded(self) -> None:
@@ -302,45 +300,3 @@ class DatabasePropertyService(LoggingMixin):
                     )
 
         return True, None, None
-
-    async def get_database_metadata(
-        self, include_types: Optional[List[str]] = None
-    ) -> Dict[str, Any]:
-        """
-        Gets the complete metadata of the database, including property options.
-
-        Args:
-            include_types: List of property types to include (if None, include all)
-
-        Returns:
-            Dict[str, Any]: The database metadata
-        """
-        await self._ensure_schema_loaded()
-
-        if not self._schema:
-            return {"properties": {}}
-
-        metadata = {"properties": {}}
-
-        for prop_name, prop_data in self._schema.items():
-            prop_type = prop_data.get("type")
-
-            # Skip if we're filtering and this type isn't included
-            if include_types and prop_type not in include_types:
-                continue
-
-            prop_metadata = {"type": prop_type, "options": []}
-
-            # Include options for select, multi_select, status
-            if prop_type in ["select", "multi_select", "status"]:
-                prop_metadata["options"] = prop_data.get(prop_type, {}).get(
-                    "options", []
-                )
-
-            # For relation properties, we might want to include related database info
-            elif prop_type == "relation":
-                prop_metadata["relation_details"] = prop_data.get("relation", {})
-
-            metadata["properties"][prop_name] = prop_metadata
-
-        return metadata

notionary/page/properites/page_property_manager.py

@@ -1,12 +1,7 @@
 from typing import Dict, Any, List, Optional
+from notionary.models.notion_page_response import NotionPageResponse
 from notionary.notion_client import NotionClient
 from notionary.page.metadata.metadata_editor import MetadataEditor
-from notionary.page.properites.property_operation_result import (
-    PropertyOperationResult,
-)
-from notionary.page.relations.notion_page_title_resolver import (
-    NotionPageTitleResolver,
-)
 from notionary.page.properites.database_property_service import (
     DatabasePropertyService,
 )
@@ -34,15 +29,7 @@ class PagePropertyManager(LoggingMixin):
         self._db_relation = db_relation
         self._db_property_service = None
 
-        self._extractor = PropertyValueExtractor(self.logger)
-        self._title_resolver = NotionPageTitleResolver(client)
-
-    async def get_properties(self) -> Dict[str, Any]:
-        """Retrieves all properties of the page."""
-        page_data = await self._get_page_data()
-        if page_data and "properties" in page_data:
-            return page_data["properties"]
-        return {}
+        self._extractor = PropertyValueExtractor()
 
     async def get_property_value(self, property_name: str, relation_getter=None) -> Any:
         """
@@ -52,7 +39,7 @@ class PagePropertyManager(LoggingMixin):
             property_name: Name of the property to get
             relation_getter: Optional callback function to get relation values
         """
-        properties = await self.get_properties()
+        properties = await self._get_properties()
         if property_name not in properties:
             return None
 
@@ -61,7 +48,7 @@ class PagePropertyManager(LoggingMixin):
 
     async def set_property_by_name(
         self, property_name: str, value: Any
-    ) -> PropertyOperationResult:
+    ) -> Optional[Any]:
         """
         Set a property value by name, automatically detecting the property type.
 
@@ -70,72 +57,57 @@ class PagePropertyManager(LoggingMixin):
             value: Value to set
 
         Returns:
-            PropertyOperationResult: Result of the operation with status, error messages,
-                                    and available options if applicable
+            Optional[Any]: The new value if successful, None if failed
         """
         property_type = await self.get_property_type(property_name)
 
         if property_type == "relation":
-            result = PropertyOperationResult.from_relation_type_error(
-                property_name, value
+            self.logger.warning(
+                "Property '%s' is of type 'relation'. Relations must be set using the RelationManager.",
+                property_name,
             )
-            self.logger.warning(result.error)
-            return result
+            return None
 
-        if not await self._db_relation.is_database_page():
-            api_response = await self._metadata_editor.set_property_by_name(
-                property_name, value
-            )
-            if api_response:
-                await self.invalidate_cache()
-                return PropertyOperationResult.from_success(
-                    property_name, value, api_response
-                )
-            return PropertyOperationResult.from_no_api_response(property_name, value)
+        is_db_page = await self._db_relation.is_database_page()
+        db_service = None
 
-        db_service = await self._init_db_property_service()
+        if is_db_page:
+            db_service = await self._init_db_property_service()
 
-        if not db_service:
-            api_response = await self._metadata_editor.set_property_by_name(
-                property_name, value
+        if db_service:
+            is_valid, error_message, available_options = (
+                await db_service.validate_property_value(property_name, value)
             )
-            if api_response:
-                await self.invalidate_cache()
-                return PropertyOperationResult.from_success(
-                    property_name, value, api_response
-                )
-            return PropertyOperationResult.from_no_api_response(property_name, value)
-
-        is_valid, error_message, available_options = (
-            await db_service.validate_property_value(property_name, value)
-        )
 
-        if not is_valid:
-            if available_options:
-                options_str = "', '".join(available_options)
-                detailed_error = f"{error_message}\nAvailable options for '{property_name}': '{options_str}'"
-                self.logger.warning(detailed_error)
-            else:
-                self.logger.warning(
-                    "%s\nNo valid options available for '%s'",
-                    error_message,
-                    property_name,
-                )
-
-            return PropertyOperationResult.from_error(
-                property_name, error_message, value, available_options
-            )
+            if not is_valid:
+                if available_options:
+                    options_str = "', '".join(available_options)
+                    self.logger.warning(
+                        "%s\nAvailable options for '%s': '%s'",
+                        error_message,
+                        property_name,
+                        options_str,
+                    )
+                else:
+                    self.logger.warning(
+                        "%s\nNo valid options available for '%s'",
+                        error_message,
+                        property_name,
+                    )
+                return None
 
         api_response = await self._metadata_editor.set_property_by_name(
             property_name, value
         )
+
         if api_response:
             await self.invalidate_cache()
-            return PropertyOperationResult.from_success(
-                property_name, value, api_response
-            )
+            return value
 
-        return PropertyOperationResult.from_no_api_response(property_name, value)
+        self.logger.warning(
+            "Failed to set property '%s' (no API response)", property_name
+        )
+        return None
 
     async def get_property_type(self, property_name: str) -> Optional[str]:
         """Gets the type of a specific property."""
@@ -151,7 +123,7 @@ class PagePropertyManager(LoggingMixin):
             return await db_service.get_option_names(property_name)
         return []
 
-    async def _get_page_data(self, force_refresh=False) -> Dict[str, Any]:
+    async def _get_page_data(self, force_refresh=False) -> NotionPageResponse:
         """Gets the page data and caches it for future use."""
         if self._page_data is None or force_refresh:
             self._page_data = await self._client.get_page(self._page_id)
@@ -173,3 +145,8 @@ class PagePropertyManager(LoggingMixin):
         self._db_property_service = DatabasePropertyService(database_id, self._client)
         await self._db_property_service.load_schema()
         return self._db_property_service
+
+    async def _get_properties(self) -> Dict[str, Any]:
+        """Retrieves all properties of the page."""
+        page_data = await self._get_page_data()
+        return page_data.properties if page_data.properties else {}

notionary/page/properites/property_value_extractor.py

@@ -1,10 +1,10 @@
 import asyncio
 from typing import Any, Awaitable, Callable
 
+from notionary.util.logging_mixin import LoggingMixin
 
-class PropertyValueExtractor:
-    def __init__(self, logger=None):
-        self.logger = logger
+
+class PropertyValueExtractor(LoggingMixin):
 
     async def extract(
         self,