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

notionary/page/metadata/notion_page_cover_manager.py

@@ -1,56 +0,0 @@
-import random
-from typing import Any, Dict, Optional
-from notionary.notion_client import NotionClient
-from notionary.util import LoggingMixin
-
-
-class NotionPageCoverManager(LoggingMixin):
-    def __init__(self, page_id: str, client: NotionClient):
-        self.page_id = page_id
-        self._client = client
-
-    async def set_cover(self, external_url: str) -> Optional[str]:
-        """
-        Sets a cover image from an external URL and returns the new URL if successful.
-
-        Args:
-            external_url: The URL to be set as the external cover image.
-
-        Returns:
-            The URL of the new cover image, or None if the request failed.
-        """
-        data = {"cover": {"type": "external", "external": {"url": external_url}}}
-
-        try:
-            updated_page = await self._client.patch_page(self.page_id, data=data)
-            return updated_page.cover.external.url
-        except Exception as e:
-            self.logger.error("Failed to set cover image: %s", str(e))
-            return None
-
-    async def set_random_gradient_cover(self) -> Optional[Dict[str, Any]]:
-        """Sets a random gradient cover from Notion's default gradient covers."""
-        default_notion_covers = [
-            "https://www.notion.so/images/page-cover/gradients_8.png",
-            "https://www.notion.so/images/page-cover/gradients_2.png",
-            "https://www.notion.so/images/page-cover/gradients_11.jpg",
-            "https://www.notion.so/images/page-cover/gradients_10.jpg",
-            "https://www.notion.so/images/page-cover/gradients_5.png",
-            "https://www.notion.so/images/page-cover/gradients_3.png",
-        ]
-
-        random_cover_url = random.choice(default_notion_covers)
-
-        return await self.set_cover(random_cover_url)
-
-    async def get_cover_url(self) -> Optional[str]:
-        """Retrieves the current cover image URL of the page."""
-        page_data = await self._client.get_page(self.page_id)
-
-        if not page_data or not page_data.cover:
-            return None
-
-        if page_data.cover.type == "external":
-            return page_data.cover.external.url
-
-        return None

notionary/page/notion_page_factory.py

@@ -1,328 +0,0 @@
-from typing import List, Optional, Dict, Any, Tuple
-from difflib import SequenceMatcher
-
-from notionary import NotionPage, NotionClient
-from notionary.util import LoggingMixin
-from notionary.util import format_uuid, extract_and_validate_page_id
-from notionary.util import singleton
-
-@singleton
-class NotionPageFactory(LoggingMixin):
-    """
-    Factory class for creating NotionPage instances.
-    Provides methods for creating page instances by page ID, URL, or name.
-    """
-
-    MATCH_THRESHOLD = 0.6
-    MAX_SUGGESTIONS = 5
-    PAGE_SIZE = 100
-    EARLY_STOP_THRESHOLD = 0.95
-
-    @classmethod
-    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)
-            cls.logger.info(
-                "Successfully created page instance for ID: %s", formatted_id
-            )
-            return page
-        except Exception as e:
-            cls.logger.error("Error connecting to page %s: %s", page_id, str(e))
-            raise
-
-    @classmethod
-    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:
-                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)
-            cls.logger.info(
-                "Successfully created page instance from URL for ID: %s", page_id
-            )
-            return page
-        except Exception as e:
-            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 using fuzzy matching."""
-        cls.logger.debug("Searching for page with name: %s", page_name)
-
-        client = NotionClient(token=token)
-        
-        try:
-            # Search with pagination and early stopping
-            best_match, best_score, all_suggestions = (
-                await cls._search_pages_with_matching(client, page_name)
-            )
-
-            # Check if match is good enough
-            if best_score < cls.MATCH_THRESHOLD or not best_match:
-                suggestion_msg = cls._format_suggestions(all_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:
-                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)
-            cls.logger.info(
-                "Found matching page: '%s' (ID: %s) with score: %.2f",
-                matched_name,
-                page_id,
-                best_score,
-            )
-
-            page = NotionPage.from_page_id(page_id=page_id, token=token)
-            cls.logger.info("Successfully created page instance for '%s'", matched_name)
-
-            await client.close()
-            return page
-
-        except Exception as e:
-            cls.logger.error("Error finding page by name: %s", str(e))
-            await client.close()
-            raise
-
-    @classmethod
-    async def _search_pages_with_matching(
-        cls, client: NotionClient, query: str
-    ) -> Tuple[Optional[Dict[str, Any]], float, List[str]]:
-        """
-        Search for pages with pagination and find the best match.
-        Includes early stopping for performance optimization.
-        """
-        cls.logger.debug("Starting paginated search for query: %s", query)
-
-        best_match = None
-        best_score = 0
-        all_suggestions = []
-        page_count = 0
-
-        # Track suggestions across all pages
-        all_matches = []
-
-        next_cursor = None
-
-        while True:
-            # Fetch current page batch
-            pages_batch = await cls._fetch_pages_batch(client, next_cursor)
-
-            if not pages_batch:
-                cls.logger.debug("No more pages to fetch")
-                break
-
-            pages = pages_batch.get("results", [])
-            page_count += len(pages)
-            cls.logger.debug(
-                "Processing batch of %d pages (total processed: %d)",
-                len(pages),
-                page_count,
-            )
-
-            # Process current batch
-            batch_match, batch_score, batch_suggestions = cls._find_best_match_in_batch(
-                pages, query, best_score
-            )
-
-            # Update global best if we found a better match
-            if batch_score > best_score:
-                best_score = batch_score
-                best_match = batch_match
-                cls.logger.debug("New best match found with score: %.2f", best_score)
-
-            # Collect all matches for suggestions
-            for page in pages:
-                title = cls._extract_title_from_page(page)
-                score = SequenceMatcher(None, query.lower(), title.lower()).ratio()
-                all_matches.append((title, score))
-
-            # Early stopping: if we found a very good match, stop searching
-            if best_score >= cls.EARLY_STOP_THRESHOLD:
-                cls.logger.info(
-                    "Early stopping: found excellent match with score %.2f", best_score
-                )
-                break
-
-            # Check for next page
-            next_cursor = pages_batch.get("next_cursor")
-            if not next_cursor:
-                cls.logger.debug("Reached end of pages")
-                break
-
-        # Generate final suggestions from all matches
-        all_matches.sort(key=lambda x: x[1], reverse=True)
-        all_suggestions = [title for title, _ in all_matches[: cls.MAX_SUGGESTIONS]]
-
-        cls.logger.info(
-            "Search completed. Processed %d pages. Best score: %.2f",
-            page_count,
-            best_score,
-        )
-
-        return best_match, best_score, all_suggestions
-
-    @classmethod
-    async def _fetch_pages_batch(
-        cls, client: NotionClient, next_cursor: Optional[str] = None
-    ) -> Dict[str, Any]:
-        """Fetch a single batch of pages from the Notion API."""
-        search_payload = {
-            "filter": {"property": "object", "value": "page"},
-            "page_size": cls.PAGE_SIZE,
-        }
-
-        if next_cursor:
-            search_payload["start_cursor"] = next_cursor
-
-        try:
-            response = await client.post("search", search_payload)
-
-            if not response:
-                cls.logger.error("Empty response from search endpoint")
-                return {}
-
-            return response
-
-        except Exception as e:
-            cls.logger.error("Error fetching pages batch: %s", str(e))
-            raise
-
-    @classmethod
-    def _find_best_match_in_batch(
-        cls, pages: List[Dict[str, Any]], query: str, current_best_score: float
-    ) -> Tuple[Optional[Dict[str, Any]], float, List[str]]:
-        """Find the best matching page in a single batch."""
-        batch_best_match = None
-        batch_best_score = current_best_score
-
-        for page in pages:
-            title = cls._extract_title_from_page(page)
-            score = SequenceMatcher(None, query.lower(), title.lower()).ratio()
-
-            if score > batch_best_score:
-                batch_best_score = score
-                batch_best_match = page
-
-        # Get batch suggestions (not used in the main algorithm but kept for compatibility)
-        batch_suggestions = []
-
-        return batch_best_match, batch_best_score, batch_suggestions
-
-    @classmethod
-    async def _search_pages(cls, client: NotionClient) -> List[Dict[str, Any]]:
-        """
-        Legacy method - kept for backward compatibility.
-        Now uses the paginated approach internally.
-        """
-        cls.logger.warning(
-            "_search_pages is deprecated. Use _search_pages_with_matching instead."
-        )
-
-        all_pages = []
-        next_cursor = None
-
-        while True:
-            batch = await cls._fetch_pages_batch(client, next_cursor)
-            if not batch:
-                break
-
-            pages = batch.get("results", [])
-            all_pages.extend(pages)
-
-            next_cursor = batch.get("next_cursor")
-            if not next_cursor:
-                break
-
-        cls.logger.info("Loaded %d total pages", len(all_pages))
-        return all_pages
-
-    @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
-
-        # Get top suggestions
-        matches.sort(key=lambda x: x[2], reverse=True)
-        suggestions = [title for _, title, _ in matches[: cls.MAX_SUGGESTIONS]]
-
-        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 ""
-
-        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 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:
-            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."""
-        if not rich_text:
-            return ""
-
-        text_parts = [
-            text_obj["plain_text"] for text_obj in rich_text if "plain_text" in text_obj
-        ]
-
-        return "".join(text_parts)

notionary/page/properites/database_property_service.py

@@ -1,302 +0,0 @@
-from typing import Dict, List, Optional, Any, Tuple
-from notionary.notion_client import NotionClient
-from notionary.util import LoggingMixin
-
-
-class DatabasePropertyService(LoggingMixin):
-    """
-    Service for working with Notion database properties and options.
-    Provides specialized methods for retrieving property information and validating values.
-    """
-
-    def __init__(self, database_id: str, client: NotionClient):
-        """
-        Initialize the database property service.
-
-        Args:
-            database_id: ID of the Notion database
-            client: Instance of NotionClient
-        """
-        self._database_id = database_id
-        self._client = client
-        self._schema = None
-
-    async def load_schema(self, force_refresh: bool = False) -> bool:
-        """
-        Loads the database schema.
-
-        Args:
-            force_refresh: Whether to force a refresh of the schema
-
-        Returns:
-            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_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 for %s: %s", self._database_id, str(e)
-            )
-            return False
-
-    async def _ensure_schema_loaded(self) -> None:
-        """
-        Ensures the schema is loaded before accessing it.
-        """
-        if self._schema is None:
-            await self.load_schema()
-
-    async def get_schema(self) -> Dict[str, Any]:
-        """
-        Gets the database schema.
-
-        Returns:
-            Dict[str, Any]: The database schema
-        """
-        await self._ensure_schema_loaded()
-        return self._schema or {}
-
-    async def get_property_types(self) -> Dict[str, str]:
-        """
-        Gets all property types for the database.
-
-        Returns:
-            Dict[str, str]: Dictionary mapping property names to their types
-        """
-        await self._ensure_schema_loaded()
-
-        if not self._schema:
-            return {}
-
-        return {
-            prop_name: prop_data.get("type", "unknown")
-            for prop_name, prop_data in self._schema.items()
-        }
-
-    async def get_property_schema(self, property_name: str) -> Optional[Dict[str, Any]]:
-        """
-        Gets the schema for a specific property.
-
-        Args:
-            property_name: The name of the property
-
-        Returns:
-            Optional[Dict[str, Any]]: The property schema or None if not found
-        """
-        await self._ensure_schema_loaded()
-
-        if not self._schema or property_name not in self._schema:
-            return None
-
-        return self._schema[property_name]
-
-    async def get_property_type(self, property_name: str) -> Optional[str]:
-        """
-        Gets the type of a specific property.
-
-        Args:
-            property_name: The name of the property
-
-        Returns:
-            Optional[str]: The property type or None if not found
-        """
-        property_schema = await self.get_property_schema(property_name)
-
-        if not property_schema:
-            return None
-
-        return property_schema.get("type")
-
-    async def property_exists(self, property_name: str) -> bool:
-        """
-        Checks if a property exists in the database.
-
-        Args:
-            property_name: The name of the property
-
-        Returns:
-            bool: True if the property exists, False otherwise
-        """
-        property_schema = await self.get_property_schema(property_name)
-        return property_schema is not None
-
-    async def get_property_options(self, property_name: str) -> List[Dict[str, Any]]:
-        """
-        Gets the available options for a property (select, multi_select, status).
-
-        Args:
-            property_name: The name of the property
-
-        Returns:
-            List[Dict[str, Any]]: List of available options with their metadata
-        """
-        property_schema = await self.get_property_schema(property_name)
-
-        if not property_schema:
-            return []
-
-        property_type = property_schema.get("type")
-
-        if property_type in ["select", "multi_select", "status"]:
-            return property_schema.get(property_type, {}).get("options", [])
-
-        return []
-
-    async def get_option_names(self, property_name: str) -> List[str]:
-        """
-        Gets the available option names for a property (select, multi_select, status).
-
-        Args:
-            property_name: The name of the property
-
-        Returns:
-            List[str]: List of available option names
-        """
-        options = await self.get_property_options(property_name)
-        return [option.get("name", "") for option in options]
-
-    async def get_relation_details(
-        self, property_name: str
-    ) -> Optional[Dict[str, Any]]:
-        """
-        Gets details about a relation property, including the related database.
-
-        Args:
-            property_name: The name of the property
-
-        Returns:
-            Optional[Dict[str, Any]]: The relation details or None if not a relation
-        """
-        property_schema = await self.get_property_schema(property_name)
-
-        if not property_schema or property_schema.get("type") != "relation":
-            return None
-
-        return property_schema.get("relation", {})
-
-    async def get_relation_options(
-        self, property_name: str, limit: int = 100
-    ) -> List[Dict[str, Any]]:
-        """
-        Gets available options for a relation property by querying the related database.
-
-        Args:
-            property_name: The name of the relation property
-            limit: Maximum number of options to retrieve
-
-        Returns:
-            List[Dict[str, Any]]: List of pages from the related database
-        """
-        relation_details = await self.get_relation_details(property_name)
-
-        if not relation_details or "database_id" not in relation_details:
-            return []
-
-        related_db_id = relation_details["database_id"]
-
-        try:
-            # Query the related database to get options
-            query_result = await self._client.post(
-                f"databases/{related_db_id}/query",
-                {
-                    "page_size": limit,
-                },
-            )
-
-            if not query_result or "results" not in query_result:
-                return []
-
-            # Extract relevant information from each page
-            options = []
-            for page in query_result["results"]:
-                page_id = page.get("id")
-                title = self._extract_title_from_page(page)
-
-                if page_id and title:
-                    options.append({"id": page_id, "name": title})
-
-            return options
-        except Exception as e:
-            self.logger.error(f"Error getting relation options: {str(e)}")
-            return []
-
-    def _extract_title_from_page(self, page: Dict[str, Any]) -> Optional[str]:
-        """
-        Extracts the title from a page object.
-
-        Args:
-            page: The page object from Notion API
-
-        Returns:
-            Optional[str]: The page title or None if not found
-        """
-        if "properties" not in page:
-            return None
-
-        properties = page["properties"]
-
-        # Look for a title property
-        for prop_data in properties.values():
-            if prop_data.get("type") == "title" and "title" in prop_data:
-                title_parts = prop_data["title"]
-                return "".join(
-                    [text_obj.get("plain_text", "") for text_obj in title_parts]
-                )
-
-        return None
-
-    async def validate_property_value(
-        self, property_name: str, value: Any
-    ) -> Tuple[bool, Optional[str], Optional[List[str]]]:
-        """
-        Validates a value for a property.
-
-        Args:
-            property_name: The name of the property
-            value: The value to validate
-
-        Returns:
-            Tuple[bool, Optional[str], Optional[List[str]]]:
-                - Boolean indicating if valid
-                - Error message if invalid
-                - Available options if applicable
-        """
-        property_schema = await self.get_property_schema(property_name)
-
-        if not property_schema:
-            return False, f"Property '{property_name}' does not exist", None
-
-        property_type = property_schema.get("type")
-
-        # Validate select, multi_select, status properties
-        if property_type in ["select", "status"]:
-            options = await self.get_option_names(property_name)
-
-            if isinstance(value, str) and value not in options:
-                return (
-                    False,
-                    f"Invalid {property_type} option. Value '{value}' is not in the available options.",
-                    options,
-                )
-
-        elif property_type == "multi_select":
-            options = await self.get_option_names(property_name)
-
-            if isinstance(value, list):
-                invalid_values = [val for val in value if val not in options]
-                if invalid_values:
-                    return (
-                        False,
-                        f"Invalid multi_select options: {', '.join(invalid_values)}",
-                        options,
-                    )
-
-        return True, None, None