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

notionary/page/relations/notion_page_relation_manager.py

@@ -1,350 +0,0 @@
-import asyncio
-from typing import Any, Dict, List, Optional
-from notionary.models.notion_page_response import DatabaseParent, NotionPageResponse
-from notionary.notion_client import NotionClient
-from notionary.page.relations.notion_page_title_resolver import (
-    NotionPageTitleResolver,
-)
-from notionary.util import LoggingMixin
-
-
-class NotionPageRelationManager(LoggingMixin):
-    """
-    Manager for relation properties of a Notion page.
-    Manages links between pages and loads available relation options.
-    """
-
-    def __init__(
-        self, page_id: str, client: NotionClient, database_id: Optional[str] = None
-    ):
-        """
-        Initializes the relation manager.
-        """
-        self._page_id = page_id
-        self._client = client
-        self._database_id = database_id
-        self._page_properties = None
-
-        self._page_title_resolver = NotionPageTitleResolver(client=client)
-
-    async def get_relation_property_ids(self) -> List[str]:
-        """
-        Returns a list of all relation property names.
-
-        Returns:
-            List[str]: Names of all relation properties
-        """
-        properties = await self._get_page_properties()
-
-        return [
-            prop_name
-            for prop_name, prop_data in properties.items()
-            if prop_data.get("type") == "relation"
-        ]
-
-    async def get_relation_values(self, property_name: str) -> List[str]:
-        """
-        Returns the titles of the pages linked via a relation property.
-
-        Args:
-            property_name: Name of the relation property
-
-        Returns:
-            List[str]: List of linked page titles
-        """
-        properties = await self._get_page_properties()
-
-        if property_name not in properties:
-            return []
-
-        prop_data = properties[property_name]
-
-        if prop_data.get("type") != "relation" or "relation" not in prop_data:
-            return []
-
-        resolver = NotionPageTitleResolver(self._client)
-        titles = []
-
-        for rel in prop_data["relation"]:
-            page_id = rel.get("id")
-            if not page_id:
-                continue
-
-            title = await resolver.get_title_by_page_id(page_id)
-            if not title:
-                continue
-
-            titles.append(title)
-
-        return titles
-
-    async def get_relation_database_id(self, property_name: str) -> Optional[str]:
-        """
-        Returns the ID of the linked database for a relation property.
-
-        Args:
-            property_name: Name of the relation property
-
-        Returns:
-            Optional[str]: ID of the linked database or None
-        """
-        relation_details = await self._get_relation_details(property_name)
-
-        if not relation_details:
-            return None
-
-        return relation_details.get("database_id")
-
-    async def get_relation_options(
-        self, property_name: str, limit: int = 100
-    ) -> List[str]:
-        """
-        Returns available title options for a relation property.
-
-        Args:
-            property_name: Name of the relation property
-            limit: Maximum number of options to return
-
-        Returns:
-            List[str]: List of page titles that can be used for this relation
-        """
-        related_db_id = await self.get_relation_database_id(property_name)
-
-        if not related_db_id:
-            return []
-
-        try:
-            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 []
-
-            titles = []
-            for page in query_result["results"]:
-                title = self._extract_title_from_page(page)
-                if title:
-                    titles.append(title)
-
-            return titles
-        except Exception as e:
-            self.logger.error("Error retrieving relation options: %s", str(e))
-            return []
-
-    async def set_relation_values_by_page_titles(
-        self, property_name: str, page_titles: List[str]
-    ) -> List[str]:
-        """
-        Sets relation values based on page titles, replacing any existing relations.
-
-        Args:
-            property_name: Name of the relation property
-            page_titles: List of page titles to set as relations
-
-        Returns:
-            List[str]: List of page titles that were successfully set as relations
-        """
-        self.logger.info(
-            "Setting %d relation(s) for property '%s'",
-            len(page_titles),
-            property_name,
-        )
-
-        resolution_results = await asyncio.gather(
-            *(
-                self._page_title_resolver.get_page_id_by_title(title)
-                for title in page_titles
-            )
-        )
-
-        found_pages = []
-        page_ids = []
-        not_found_pages = []
-
-        for title, page_id in zip(page_titles, resolution_results):
-            if page_id:
-                found_pages.append(title)
-                page_ids.append(page_id)
-                self.logger.debug("Found page ID %s for title '%s'", page_id, title)
-            else:
-                not_found_pages.append(title)
-                self.logger.warning("No page found with title '%s'", title)
-
-        self.logger.debug("Page IDs being sent to API: %s", page_ids)
-
-        if not page_ids:
-            self.logger.warning(
-                "No valid page IDs found for any of the titles, no changes applied"
-            )
-            return []
-
-        api_response = await self._set_relations_by_page_ids(property_name, page_ids)
-
-        if not api_response:
-            self.logger.error(
-                "Failed to set relations for '%s' (API error)", property_name
-            )
-            return []
-
-        if not_found_pages:
-            not_found_str = "', '".join(not_found_pages)
-            self.logger.info(
-                "Set %d relation(s) for '%s', but couldn't find pages: '%s'",
-                len(page_ids),
-                property_name,
-                not_found_str,
-            )
-        else:
-            self.logger.info(
-                "Successfully set all %d relation(s) for '%s'",
-                len(page_ids),
-                property_name,
-            )
-
-        return found_pages
-
-    async def get_all_relations(self) -> Dict[str, List[str]]:
-        """
-        Returns all relation properties and their values.
-
-        Returns:
-            Dict[str, List[str]]: Dictionary of property names and their values
-        """
-        relation_properties = await self.get_relation_property_ids()
-
-        if not relation_properties:
-            return {}
-
-        result = {}
-        for prop_name in relation_properties:
-            result[prop_name] = await self.get_relation_values(prop_name)
-
-        return result
-
-    async def _get_relation_details(
-        self, property_name: str
-    ) -> Optional[Dict[str, Any]]:
-        """
-        Returns details about the relation property, including the linked database.
-
-        Args:
-            property_name: Name of the relation property
-
-        Returns:
-            The "relation" field of the property, or None if not found or not of type "relation".
-        """
-        database_id = await self._ensure_database_id()
-        if not database_id:
-            return None
-
-        try:
-            database = await self._client.get_database(database_id)
-
-            prop_data = database.properties.get(property_name)
-            if not prop_data:
-                return None
-
-            if prop_data.get("type") != "relation":
-                return None
-
-            return prop_data.get("relation")
-
-        except Exception as e:
-            self.logger.error("Error retrieving relation details: %s", str(e))
-            return None
-
-    async def _get_page_properties(self, force_refresh: bool = False) -> Dict[str, Any]:
-        """
-        Loads the properties of the page.
-
-        Args:
-            force_refresh: If True, a new API call will be made.
-
-        Returns:
-            Dict[str, Any]: The properties of the page.
-        """
-        if self._page_properties is None or force_refresh:
-            page_data = await self._client.get_page(self._page_id)
-            if page_data:
-                self._page_properties = page_data.properties or {}
-            else:
-                self._page_properties = {}
-
-        return self._page_properties
-
-    async def _ensure_database_id(self) -> Optional[str]:
-        """
-        Ensures the database_id is available. Loads it if necessary.
-
-        Returns:
-            Optional[str]: The database ID or None
-        """
-        if self._database_id:
-            return self._database_id
-
-        page_data = await self._client.get_page(self._page_id)
-
-        if not page_data or not page_data.parent:
-            return None
-
-        if isinstance(page_data.parent, DatabaseParent):
-            self._database_id = page_data.parent.database_id
-            return self._database_id
-
-        return None
-
-    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 the Notion API
-
-        Returns:
-            Optional[str]: The page title or None
-        """
-        if "properties" not in page:
-            return None
-
-        properties = page["properties"]
-
-        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 _set_relations_by_page_ids(
-        self, property_name: str, page_ids: List[str]
-    ) -> Optional[NotionPageResponse]:
-        """
-        Adds one or more relations.
-
-        Args:
-            property_name: Name of the relation property
-            page_ids: List of page IDs to add
-
-        Returns:
-            Optional[NotionPageResponse]: API response or None on error
-        """
-        relation_payload = {"relation": [{"id": page_id} for page_id in page_ids]}
-
-        try:
-            page_response: NotionPageResponse = await self._client.patch_page(
-                self._page_id,
-                {"properties": {property_name: relation_payload}},
-            )
-
-            self._page_properties = None
-
-            return page_response
-        except Exception as e:
-            self.logger.error("Error adding relation: %s", str(e))
-            return None

notionary/page/relations/notion_page_title_resolver.py

@@ -1,104 +0,0 @@
-from typing import Optional, Dict, Any, List
-from notionary.notion_client import NotionClient
-from notionary.util import LoggingMixin
-
-
-class NotionPageTitleResolver(LoggingMixin):
-    def __init__(self, client: NotionClient):
-        self._client = client
-
-    async def get_page_id_by_title(self, title: str) -> Optional[str]:
-        """
-        Searches for a Notion page by its title and returns the corresponding page ID if found.
-        """
-        try:
-            search_results = await self._client.post(
-                "search",
-                {"query": title, "filter": {"value": "page", "property": "object"}},
-            )
-
-            results = search_results.get("results", [])
-
-            if not results:
-                self.logger.debug(f"No page found with title '{title}'")
-                return None
-
-            # Durchsuche die Ergebnisse nach dem passenden Titel
-            for result in results:
-                properties = result.get("properties", {})
-                page_title = self._extract_page_title_from_properties(properties)
-
-                if page_title == title:
-                    return result.get("id")
-
-            self.logger.debug(f"No matching page found with title '{title}'")
-            return None
-
-        except Exception as e:
-            self.logger.error(f"Error while searching for page '{title}': {e}")
-            return None
-
-    async def get_title_by_page_id(self, page_id: str) -> Optional[str]:
-        """
-        Retrieves the title of a Notion page by its page ID.
-
-        Args:
-            page_id: The ID of the Notion page.
-
-        Returns:
-            The title of the page, or None if not found.
-        """
-        try:
-            page = await self._client.get_page(page_id)
-            return self._extract_page_title_from_properties(page.properties)
-
-        except Exception as e:
-            self.logger.error(f"Error retrieving title for page ID '{page_id}': {e}")
-            return None
-
-    async def get_page_titles_by_ids(self, page_ids: List[str]) -> Dict[str, str]:
-        """
-        Retrieves titles for multiple page IDs at once.
-
-        Args:
-            page_ids: List of page IDs to get titles for
-
-        Returns:
-            Dictionary mapping page IDs to their titles
-        """
-        result = {}
-        for page_id in page_ids:
-            title = await self.get_title_by_page_id(page_id)
-            if title:
-                result[page_id] = title
-        return result
-
-    def _extract_page_title_from_properties(self, properties: Dict[str, Any]) -> str:
-        """
-        Extract title from properties dictionary.
-
-        Args:
-            properties: The properties dictionary from a Notion page
-
-        Returns:
-            str: The extracted title or "Untitled" if not found
-        """
-        try:
-            for prop_value in properties.values():
-                if not isinstance(prop_value, dict):
-                    continue
-
-                if prop_value.get("type") != "title":
-                    continue
-
-                title_array = prop_value.get("title", [])
-                if not title_array:
-                    continue
-
-                for text_obj in title_array:
-                    if "plain_text" in text_obj:
-                        return text_obj["plain_text"]
-        except Exception as e:
-            self.logger.error(f"Error extracting page title from properties: {e}")
-
-        return "Untitled"

notionary/page/relations/page_database_relation.py

@@ -1,68 +0,0 @@
-from typing import Dict, Optional, Any
-from notionary.models.notion_page_response import DatabaseParent, NotionPageResponse
-from notionary.notion_client import NotionClient
-from notionary.util import LoggingMixin
-
-
-class PageDatabaseRelation(LoggingMixin):
-    """
-    Manages the relationship between a Notion page and its parent database.
-    Provides methods to access database schema and property options.
-    """
-
-    def __init__(self, page_id: str, client: NotionClient):
-        """
-        Initialize the page-database relationship handler.
-
-        Args:
-            page_id: ID of the Notion page
-            client: Instance of NotionClient
-        """
-        self._page_id = page_id
-        self._client = client
-        self._parent_database_id = None
-        self._database_schema = None
-        self._page_data = None
-
-    async def _get_page_data(self, force_refresh=False) -> NotionPageResponse:
-        """
-        Gets the page data and caches it for future use.
-
-        Args:
-            force_refresh: Whether to force a refresh of the page data
-
-        Returns:
-            Dict[str, Any]: The page data
-        """
-        if self._page_data is None or force_refresh:
-            self._page_data = await self._client.get_page(self._page_id)
-        return self._page_data
-
-    async def get_parent_database_id(self) -> Optional[str]:
-        """
-        Returns the ID of the database this page belongs to, if any.
-        """
-        if self._parent_database_id is not None:
-            return self._parent_database_id
-
-        page_data = await self._get_page_data()
-
-        if not page_data:
-            return None
-
-        parent = page_data.parent
-        if isinstance(parent, DatabaseParent):
-            self._parent_database_id = parent.database_id
-            return self._parent_database_id
-
-        return None
-
-    async def is_database_page(self) -> bool:
-        """
-        Checks if this page belongs to a database.
-
-        Returns:
-            bool: True if the page belongs to a database, False otherwise
-        """
-        database_id = await self.get_parent_database_id()
-        return database_id is not None

notionary/util/warn_direct_constructor_usage.py

@@ -1,54 +0,0 @@
-import functools
-import inspect
-from typing import Callable, Any, TypeVar, cast
-
-F = TypeVar("F", bound=Callable[..., Any])
-
-
-def warn_direct_constructor_usage(func: F) -> F:
-    """
-    Method decorator that logs a warning when the constructor is called directly
-    instead of through a factory method.
-
-    This is an advisory decorator - it only logs a warning and doesn't
-    prevent direct constructor usage.
-    """
-
-    @functools.wraps(func)
-    def wrapper(self, *args, **kwargs):
-        # Get the call stack
-        stack = inspect.stack()
-
-        self._from_factory = False
-
-        search_depth = min(6, len(stack))
-
-        for i in range(1, search_depth):
-            if i >= len(stack):
-                break
-
-            caller_frame = stack[i]
-            caller_name = caller_frame.function
-
-            # Debug logging might be helpful during development
-            # print(f"Frame {i}: {caller_name}")
-
-            # If called from a factory method, mark it and break
-            if caller_name.startswith("create_from_") or caller_name.startswith(
-                "from_"
-            ):
-                self._from_factory = True
-                break
-
-        # If not from factory, log warning
-        if not self._from_factory and hasattr(self, "logger"):
-            self.logger.warning(
-                "Advisory: Direct constructor usage is discouraged. "
-                "Consider using factory methods like create_from_page_id(), "
-                "create_from_url(), or create_from_page_name() instead."
-            )
-
-        # Call the original __init__
-        return func(self, *args, **kwargs)
-
-    return cast(F, wrapper)