notionary 0.1.5__py3-none-any.whl → 0.1.7__py3-none-any.whl

{notionary-0.1.5.dist-info → notionary-0.1.7.dist-info}/RECORD

@@ -1,5 +1,5 @@
 notionary/__init__.py,sha256=5T16clJlSHFsopcPUnkGrEo8spNDUQ0i-O00UEF7nR8,320
-notionary/core/notion_client.py,sha256=hZLQCAC38veUdOi2NYijxDYTpwOzXHRHDPArEbsXqLk,4776
+notionary/core/notion_client.py,sha256=9o9-Ki1homkSbM1C51nsaAzVPMt2d4r8cPzoX3NK_HQ,4495
 notionary/core/converters/__init__.py,sha256=GOUehJbe4BKHtec1MqL1YGu3AX8zFtkwSZfhYkY5-P0,1798
 notionary/core/converters/markdown_to_notion_converter.py,sha256=PGtg4v5lUvkXXl1Y8E6a3Mf8hEfxfhBrslPs_H_Lq_E,16564
 notionary/core/converters/notion_to_markdown_converter.py,sha256=c8GyWX8-UrNfRDk7OOBKbSEb5qOwljUCwI6g5risO2c,1287
@@ -22,25 +22,31 @@ notionary/core/converters/elements/video_element.py,sha256=xrBLY3e_SgKNamItZkfPN
 notionary/core/converters/registry/block_element_registry.py,sha256=0dpRFMM67UVmXRMP4-Ubc_uCZCVVmRKgxPpueCeknjw,8619
 notionary/core/converters/registry/block_element_registry_builder.py,sha256=yTV1GPKAN7o65r9jHIqPeBCw0ICdaUZnRC5JKNwpRq4,9227
 notionary/core/database/database_info_service.py,sha256=58k7om0UXP8w0jCJHewccG5UbOvELMBAbQvXOm7F1OM,1341
-notionary/core/database/database_query_service.py,sha256=ggD-Sx9GdRTeKn9ytGBxijQw6euYgV__iTpObT24ebo,2442
-notionary/core/database/database_schema_service.py,sha256=aVyguzw8YjgQ632TDyRCDfWWCsIok3vJ4Sx3dnG9pss,1869
-notionary/core/database/notion_database_manager.py,sha256=E3qUxPYEJ1drurmtZaqepskH84Iw-4RN3MyXv8cb8zQ,11443
-notionary/core/database/notion_database_manager_factory.py,sha256=jYQeoWV4VKyfCkbxCMVf0aeShfXDvE2EVTs3Jr--Ro8,8285
-notionary/core/database/notion_database_schema.py,sha256=OtAsKzga7eiWzUa4AasNO2MBOTlQERQ_9Gk22Kc6f64,12599
-notionary/core/database/notion_database_writer.py,sha256=qpKOSDLI89GWL1kDnzLKSY5GVIzQHVYAWUl12_n-nwU,13651
-notionary/core/database/page_service.py,sha256=NzKCU2G-mnmqOitNWCJ6jOr0HSv1vPi1-ScSruvFdqg,5190
+notionary/core/database/notion_database_manager.py,sha256=cEQHf8bTcgA3hLMgsbMGSXhCmccmxWLQ6oOJiINR3ac,8257
+notionary/core/database/notion_database_manager_factory.py,sha256=SoWUiM5zdajmR1ppYHTdPgHrdZbwuTMdoXW3_tBffyU,6831
+notionary/core/database/notion_database_schema.py,sha256=WUIjG7I5kusk4GOOdmVSHIKc2Z8SeOgJ1FuGpTn4avQ,3304
 notionary/core/database/models/page_result.py,sha256=Vmm5_oYpYAkIIJVoTd1ZZGloeC3cmFLMYP255mAmtaw,233
-notionary/core/page/notion_page_manager.py,sha256=fvEomwMMOkjUBnE6QdTfrzfNsqTTuVi-7a9ehC3U29Q,4865
-notionary/core/page/page_content_manager.py,sha256=wx-2bW4znIaBVZeFwtoVrmlGUwHMLBPOLkQCZDIV3sA,3180
-notionary/core/page/property_formatter.py,sha256=X70Yfg0Y8HYLrFH7Y_BZVhhc_6b369jjn02bc5IZBBI,3780
-notionary/core/page/meta_data/metadata_editor.py,sha256=FpB7BA5cicWmEictwdn7EuRBMX7bGvSxbdM5Grs-jLI,1347
+notionary/core/page/notion_page_manager.py,sha256=NH4mNZ9jgRxmc3gay1ymG0Qcc5k_YX9eSkCMUnB9ghw,13247
+notionary/core/page/content/page_content_manager.py,sha256=CZGb8vXWADxwo_xBrZ7mmKEW_HSFhlVNjOgWMfYgGJc,3142
+notionary/core/page/metadata/metadata_editor.py,sha256=U3Ff9GRk28dqT9M1xsl6Q3Cj47-hB1n2pNJzeDXy4ks,4938
+notionary/core/page/metadata/notion_icon_manager.py,sha256=v9pUG61TOT8x9UzDqBtQW6S5XQzWostq7IwrURnWvF4,1499
+notionary/core/page/metadata/notion_page_cover_manager.py,sha256=nDWXeEztKyPscq5dRxIZ6d6IqV7E3vR-Qg1N8KzP_fo,1831
+notionary/core/page/properites/database_property_service.py,sha256=z_HTt_HdB75ffYW5XNwfthZrjLEBXYqKrrK-iGHblek,12073
+notionary/core/page/properites/page_property_manager.py,sha256=jMiSt9uzr9bKXYhZMg60LVLewp03OFYCeD_qQhKmFT0,6806
+notionary/core/page/properites/property_formatter.py,sha256=N7GGf-ecUuMLvgt5T_KxabjmvUN7uJrMYFCL7438AZo,3665
+notionary/core/page/properites/property_operation_result.py,sha256=BVje4SnWf2EdWQYH8sv_6rGd2dL0Owsixfn9SuJY0bk,3961
+notionary/core/page/properites/property_value_extractor.py,sha256=IG8hKon83CZJ0zYJ-EtgHd2wbjoKOHdA3jB2vmR50Mw,2035
+notionary/core/page/relations/notion_page_relation_manager.py,sha256=EHavK75Semzh8d7edI1ubh0SJyD8E0loNWVIsfxGAY4,12685
+notionary/core/page/relations/notion_page_title_resolver.py,sha256=bV0ecP2dikr3vbTEXXsx_4jEtQtpQAHvG-wulASqj3o,1679
+notionary/core/page/relations/page_database_relation.py,sha256=2WO1HFyIMQwgYoxvxBDUa_iTnJu-Y3Wkzy4JGJ4loME,2420
+notionary/core/page/relations/relation_operation_result.py,sha256=XkO4rK0ha_FRsfq_Vlwp4a2cE-dGVPBrVxCXOlWqfwk,5258
 notionary/exceptions/database_exceptions.py,sha256=I-Tx6bYRLpi5pjGPtbT-Mqxvz3BFgYTiuZxknJeLxtI,2638
 notionary/exceptions/page_creation_exception.py,sha256=4v7IuZD6GsQLrqhDLriGjuG3ML638gAO53zDCrLePuU,281
 notionary/util/logging_mixin.py,sha256=fKsx9t90bwvL74ZX3dU-sXdC4TZCQyO6qU9I8txkw_U,1369
+notionary/util/page_id_utils.py,sha256=vgCEp6BdsSJuEtLZVjrRAU9p6moLW-vymM7va8fhErI,1220
 notionary/util/singleton_decorator.py,sha256=GTNMfIlVNRUVMw_c88xqd12-DcqZJjmyidN54yqiNVw,472
-notionary/util/uuid_utils.py,sha256=qS2tdJSqw_gLyQxVIqlIdmkzGa7b9bJ-vw88RiQ-oGc,680
-notionary-0.1.5.dist-info/licenses/LICENSE,sha256=zOm3cRT1qD49eg7vgw95MI79rpUAZa1kRBFwL2FkAr8,1120
-notionary-0.1.5.dist-info/METADATA,sha256=wePE3ZKB5XAgi4VYe_zUBc1NnA-R0R3q3hAkG5jFnVA,6153
-notionary-0.1.5.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-notionary-0.1.5.dist-info/top_level.txt,sha256=fhONa6BMHQXqthx5PanWGbPL0b8rdFqhrJKVLf_adSs,10
-notionary-0.1.5.dist-info/RECORD,,
+notionary-0.1.7.dist-info/licenses/LICENSE,sha256=zOm3cRT1qD49eg7vgw95MI79rpUAZa1kRBFwL2FkAr8,1120
+notionary-0.1.7.dist-info/METADATA,sha256=l0WogkR1uSHB6R6ZMCQPIlE4ajYyQ9HfnUDbccNYYfg,6153
+notionary-0.1.7.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+notionary-0.1.7.dist-info/top_level.txt,sha256=fhONa6BMHQXqthx5PanWGbPL0b8rdFqhrJKVLf_adSs,10
+notionary-0.1.7.dist-info/RECORD,,

notionary/core/database/database_query_service.py

@@ -1,73 +0,0 @@
-from typing import Any, AsyncGenerator, Dict, List, Optional
-from notionary.core.database.notion_database_schema import NotionDatabaseSchema
-from notionary.core.page.notion_page_manager import NotionPageManager
-
-
-class DatabaseQueryService:
-    """Service für Datenbankabfragen und Iterations"""
-
-    def __init__(self, schema: NotionDatabaseSchema):
-        self._schema = schema
-
-    async def get_pages(
-        self,
-        database_id: str,
-        limit: int = 100,
-        filter_conditions: Optional[Dict[str, Any]] = None,
-        sorts: Optional[List[Dict[str, Any]]] = None,
-    ) -> List[NotionPageManager]:
-        """
-        Get all pages from the database.
-
-        Args:
-            database_id: The database ID to query
-            limit: Maximum number of pages to retrieve
-            filter_conditions: Optional filter to apply to the database query
-            sorts: Optional sort instructions for the database query
-
-        Returns:
-            List of NotionPageManager instances for each page
-        """
-        pages: List[NotionPageManager] = []
-        count = 0
-
-        async for page in self.iter_pages(
-            database_id,
-            page_size=min(limit, 100),
-            filter_conditions=filter_conditions,
-            sorts=sorts,
-        ):
-            pages.append(page)
-            count += 1
-
-            if count >= limit:
-                break
-
-        return pages
-
-    async def iter_pages(
-        self,
-        database_id: str,
-        page_size: int = 100,
-        filter_conditions: Optional[Dict[str, Any]] = None,
-        sorts: Optional[List[Dict[str, Any]]] = None,
-    ) -> AsyncGenerator[NotionPageManager, None]:
-        """
-        Asynchronous generator that yields pages from the database.
-
-        Args:
-            database_id: The database ID to query
-            page_size: Number of pages to fetch per request
-            filter_conditions: Optional filter to apply to the database query
-            sorts: Optional sort instructions for the database query
-
-        Yields:
-            NotionPageManager instances for each page
-        """
-        async for page_manager in self._schema.iter_database_pages(
-            database_id=database_id,
-            page_size=page_size,
-            filter_conditions=filter_conditions,
-            sorts=sorts,
-        ):
-            yield page_manager

notionary/core/database/database_schema_service.py

@@ -1,57 +0,0 @@
-from typing import Dict, List
-from notionary.core.database.notion_database_schema import NotionDatabaseSchema
-
-
-class DatabaseSchemaService:
-    """Service für den Zugriff auf Datenbankschema-Informationen"""
-
-    def __init__(self, schema: NotionDatabaseSchema):
-        self._schema = schema
-
-    async def get_property_types(self) -> Dict[str, str]:
-        """
-        Get all property types for the database.
-
-        Returns:
-            Dictionary mapping property names to their types
-        """
-        return await self._schema.get_property_types()
-
-    async def get_select_options(self, property_name: str) -> List[Dict[str, str]]:
-        """
-        Get options for a select, multi-select, or status property.
-
-        Args:
-            property_name: Name of the property
-
-        Returns:
-            List of select options with name, id, and color (if available)
-        """
-        options = await self._schema.get_select_options(property_name)
-        return [
-            {
-                "name": option.get("name", ""),
-                "id": option.get("id", ""),
-                "color": option.get("color", ""),
-            }
-            for option in options
-        ]
-
-    async def get_relation_options(
-        self, property_name: str, limit: int = 100
-    ) -> List[Dict[str, str]]:
-        """
-        Get available options for a relation property.
-
-        Args:
-            property_name: Name of the relation property
-            limit: Maximum number of options to retrieve
-
-        Returns:
-            List of relation options with id and title
-        """
-        options = await self._schema.get_relation_options(property_name, limit)
-        return [
-            {"id": option.get("id", ""), "title": option.get("title", "")}
-            for option in options
-        ]

notionary/core/database/notion_database_writer.py

@@ -1,390 +0,0 @@
-from typing import Any, Dict, List, Optional, Union, TypedDict, cast
-from notionary.core.database.notion_database_schema import NotionDatabaseSchema
-from notionary.core.notion_client import NotionClient
-from notionary.core.page.property_formatter import NotionPropertyFormatter
-from notionary.util.logging_mixin import LoggingMixin
-
-
-class NotionRelationItem(TypedDict):
-    id: str
-
-
-class NotionRelationProperty(TypedDict):
-    relation: List[NotionRelationItem]
-
-
-class NotionFormattedValue(TypedDict, total=False):
-    title: List[Dict[str, Any]]
-    rich_text: List[Dict[str, Any]]
-    select: Dict[str, str]
-    multi_select: List[Dict[str, str]]
-    relation: List[NotionRelationItem]
-    number: Union[int, float]
-    date: Dict[str, str]
-    checkbox: bool
-    url: str
-    email: str
-    phone_number: str
-
-
-class PageCreationResponse(TypedDict):
-    id: str
-    parent: Dict[str, str]
-    properties: Dict[str, Any]
-
-
-class NotionRelationHandler(LoggingMixin):
-    """
-    Handler for managing relations in Notion databases.
-    Provides a unified interface for working with relations.
-    """
-
-    def __init__(self, client: NotionClient, db_schema: NotionDatabaseSchema) -> None:
-        self._client = client
-        self._db_schema = db_schema
-        self._formatter = NotionPropertyFormatter()
-
-    async def find_relation_by_title(
-        self, database_id: str, relation_prop_name: str, title: str
-    ) -> Optional[str]:
-        """
-        Finds a relation ID based on the title of the entry in the target database.
-        """
-        target_db_id = await self._db_schema.get_relation_database_id(
-            relation_prop_name
-        )
-        if not target_db_id:
-            self.logger.error(
-                "No target database found for relation '%s' in database %s",
-                relation_prop_name,
-                database_id,
-            )
-            return None
-
-        options = await self._db_schema.get_relation_options(relation_prop_name)
-
-        for option in options:
-            if option["title"].lower() == title.lower():
-                self.logger.debug("Relation entry '%s' found: %s", title, option["id"])
-                return option["id"]
-
-        self.logger.warning("Relation entry '%s' not found", title)
-        return None
-
-    async def _get_title_properties(
-        self, database_id: str, title: str
-    ) -> Optional[Dict[str, NotionFormattedValue]]:
-        """
-        Determines the title property for a database and formats the value.
-        """
-        if not await self._db_schema.load():
-            self.logger.error("Could not load database schema for %s", database_id)
-            return None
-
-        property_types = await self._db_schema.get_property_types()
-
-        title_prop_name: Optional[str] = None
-        for name, prop_type in property_types.items():
-            if prop_type == "title":
-                title_prop_name = name
-                break
-
-        if not title_prop_name:
-            self.logger.error("No title property found in database %s", database_id)
-            return None
-
-        formatted_title = self._formatter.format_value("title", title)
-        if not formatted_title:
-            self.logger.error("Could not format title '%s'", title)
-            return None
-
-        return {title_prop_name: cast(NotionFormattedValue, formatted_title)}
-
-
-class DatabaseWritter(LoggingMixin):
-    """
-    Enhanced class for creating and updating pages in Notion databases.
-    Supports both simple properties and relations.
-    """
-
-    def __init__(
-        self, client: NotionClient, db_schema: Optional[NotionDatabaseSchema] = None
-    ) -> None:
-        """
-        Initialize with a NotionClient and optionally a NotionDatabaseSchema.
-
-        Args:
-            client: The Notion API client
-            db_schema: Optional database schema instance
-        """
-        self._client = client
-        self._formatter = NotionPropertyFormatter()
-
-        self._active_schema: Optional[NotionDatabaseSchema] = db_schema
-        self._relation_handler: Optional[NotionRelationHandler] = None
-
-        if db_schema:
-            self._relation_handler = NotionRelationHandler(client, db_schema)
-
-    async def _ensure_schema_for_database(self, database_id: str) -> bool:
-        """
-        Stellt sicher, dass ein Schema für die angegebene Datenbank geladen ist.
-
-        Args:
-            database_id: ID der Datenbank
-
-        Returns:
-            True, wenn das Schema erfolgreich geladen wurde
-        """
-        if self._active_schema and self._active_schema.database_id == database_id:
-            return True
-
-        self._active_schema = NotionDatabaseSchema(database_id, self._client)
-        self._relation_handler = NotionRelationHandler(
-            self._client, self._active_schema
-        )
-
-        return await self._active_schema.load()
-
-    async def create_page(
-        self,
-        database_id: str,
-        properties: Dict[str, Any],
-        relations: Optional[Dict[str, Union[str, List[str]]]] = None,
-    ) -> Optional[PageCreationResponse]:
-        """
-        Creates a new page in a database with support for relations.
-        """
-        # Stelle sicher, dass wir ein Schema für diese Datenbank haben
-        if not await self._ensure_schema_for_database(database_id):
-            self.logger.error("Could not load schema for database %s", database_id)
-            return None
-
-        formatted_props = await self._format_properties(database_id, properties)
-        if not formatted_props:
-            return None
-
-        if relations:
-            relation_props = await self._process_relations(database_id, relations)
-            if relation_props:
-                formatted_props.update(relation_props)
-
-        data: Dict[str, Any] = {
-            "parent": {"database_id": database_id},
-            "properties": formatted_props,
-        }
-
-        result = await self._client.post("pages", data)
-        if not result:
-            self.logger.error("Error creating page in database %s", database_id)
-            return None
-
-        self.logger.info("Page successfully created in database %s", database_id)
-        return cast(PageCreationResponse, result)
-
-    async def update_page(
-        self,
-        page_id: str,
-        properties: Optional[Dict[str, Any]] = None,
-        relations: Optional[Dict[str, Union[str, List[str]]]] = None,
-    ) -> Optional[Dict[str, Any]]:
-        """
-        Updates a page with support for relations.
-        """
-        page_data = await self._client.get(f"pages/{page_id}")
-        if (
-            not page_data
-            or "parent" not in page_data
-            or "database_id" not in page_data["parent"]
-        ):
-            self.logger.error("Could not determine database ID for page %s", page_id)
-            return None
-
-        database_id = page_data["parent"]["database_id"]
-
-        # Stelle sicher, dass wir ein Schema für diese Datenbank haben
-        if not await self._ensure_schema_for_database(database_id):
-            self.logger.error("Could not load schema for database %s", database_id)
-            return None
-
-        if not properties and not relations:
-            self.logger.warning("No properties or relations specified for update")
-            return page_data
-
-        update_props: Dict[str, NotionFormattedValue] = {}
-
-        if properties:
-            formatted_props = await self._format_properties(database_id, properties)
-            if formatted_props:
-                update_props.update(formatted_props)
-
-        if relations:
-            relation_props = await self._process_relations(database_id, relations)
-            if relation_props:
-                update_props.update(relation_props)
-
-        if not update_props:
-            self.logger.warning("No valid properties to update for page %s", page_id)
-            return None
-
-        data = {"properties": update_props}
-
-        result = await self._client.patch(f"pages/{page_id}", data)
-        if not result:
-            self.logger.error("Error updating page %s", page_id)
-            return None
-
-        self.logger.info("Page %s successfully updated", page_id)
-        return result
-
-    async def delete_page(self, page_id: str) -> bool:
-        """
-        Deletes a page (archives it in Notion).
-        """
-        data = {"archived": True}
-
-        result = await self._client.patch(f"pages/{page_id}", data)
-        if not result:
-            self.logger.error("Error deleting page %s", page_id)
-            return False
-
-        self.logger.info("Page %s successfully deleted (archived)", page_id)
-        return True
-
-    async def _format_properties(
-        self, database_id: str, properties: Dict[str, Any]
-    ) -> Optional[Dict[str, NotionFormattedValue]]:
-        """
-        Formats properties according to their types in the database.
-        """
-        if not self._active_schema:
-            self.logger.error("No active schema available for database %s", database_id)
-            return None
-
-        property_types = await self._active_schema.get_property_types()
-        if not property_types:
-            self.logger.error(
-                "Could not get property types for database %s", database_id
-            )
-            return None
-
-        formatted_props: Dict[str, NotionFormattedValue] = {}
-
-        for prop_name, value in properties.items():
-            if prop_name not in property_types:
-                self.logger.warning(
-                    "Property '%s' does not exist in database %s",
-                    prop_name,
-                    database_id,
-                )
-                continue
-
-            prop_type = property_types[prop_name]
-
-            formatted_value = self._formatter.format_value(prop_type, value)
-            if formatted_value:
-                formatted_props[prop_name] = cast(NotionFormattedValue, formatted_value)
-            else:
-                self.logger.warning(
-                    "Could not format value for property '%s' of type '%s'",
-                    prop_name,
-                    prop_type,
-                )
-
-        return formatted_props
-
-    async def _process_relations(
-        self, database_id: str, relations: Dict[str, Union[str, List[str]]]
-    ) -> Dict[str, NotionRelationProperty]:
-        """
-        Processes relation properties and converts titles to IDs.
-        """
-        if not self._relation_handler:
-            self.logger.error("No relation handler available")
-            return {}
-
-        formatted_relations: Dict[str, NotionRelationProperty] = {}
-        property_types = (
-            await self._active_schema.get_property_types()
-            if self._active_schema
-            else {}
-        )
-
-        for prop_name, titles in relations.items():
-            relation_property = await self._process_single_relation(
-                database_id, prop_name, titles, property_types
-            )
-            if relation_property:
-                formatted_relations[prop_name] = relation_property
-
-        return formatted_relations
-
-    async def _process_single_relation(
-        self,
-        database_id: str,
-        prop_name: str,
-        titles: Union[str, List[str]],
-        property_types: Dict[str, str],
-    ) -> Optional[NotionRelationProperty]:
-        """
-        Process a single relation property and convert titles to IDs.
-
-        Args:
-            database_id: The database ID
-            prop_name: The property name
-            titles: The title or list of titles to convert
-            property_types: Dictionary of property types
-
-        Returns:
-            A formatted relation property or None if invalid
-        """
-        if prop_name not in property_types:
-            self.logger.warning(
-                "Property '%s' does not exist in database %s", prop_name, database_id
-            )
-            return None
-
-        prop_type = property_types[prop_name]
-        if prop_type != "relation":
-            self.logger.warning(
-                "Property '%s' is not a relation (type: %s)", prop_name, prop_type
-            )
-            return None
-
-        title_list: List[str] = [titles] if isinstance(titles, str) else titles
-        relation_ids = await self._get_relation_ids(database_id, prop_name, title_list)
-
-        if not relation_ids:
-            return None
-
-        return {"relation": [{"id": rel_id} for rel_id in relation_ids]}
-
-    async def _get_relation_ids(
-        self, database_id: str, prop_name: str, titles: List[str]
-    ) -> List[str]:
-        """
-        Get relation IDs for a list of titles.
-
-        Args:
-            database_id: The database ID
-            prop_name: The property name
-            titles: List of titles to convert
-
-        Returns:
-            List of relation IDs
-        """
-        relation_ids: List[str] = []
-
-        for title in titles:
-            relation_id = await self._relation_handler.find_relation_by_title(
-                database_id, prop_name, title
-            )
-
-            if relation_id:
-                relation_ids.append(relation_id)
-            else:
-                self.logger.warning(
-                    "Could not find relation ID for '%s' in '%s'", title, prop_name
-                )
-
-        return relation_ids