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

notionary/page/content/page_content_manager.py

@@ -1,180 +0,0 @@
-import json
-from typing import Any, Dict, List, Optional
-
-from notionary.elements.registry.block_element_registry import BlockElementRegistry
-from notionary.notion_client import NotionClient
-
-from notionary.page.markdown_to_notion_converter import (
-    MarkdownToNotionConverter,
-)
-from notionary.page.notion_to_markdown_converter import (
-    NotionToMarkdownConverter,
-)
-from notionary.page.content.notion_page_content_chunker import (
-    NotionPageContentChunker,
-)
-from notionary.util.logging_mixin import LoggingMixin
-
-
-class PageContentManager(LoggingMixin):
-    def __init__(
-        self,
-        page_id: str,
-        client: NotionClient,
-        block_registry: Optional[BlockElementRegistry] = None,
-    ):
-        self.page_id = page_id
-        self._client = client
-        self._markdown_to_notion_converter = MarkdownToNotionConverter(
-            block_registry=block_registry
-        )
-        self._notion_to_markdown_converter = NotionToMarkdownConverter(
-            block_registry=block_registry
-        )
-        self._chunker = NotionPageContentChunker()
-
-    async def append_markdown(self, markdown_text: str) -> str:
-        """
-        Append markdown text to a Notion page, automatically handling content length limits.
-        First strips out triple backtick markdown fences if they wrap the entire content.
-
-        Args:
-            markdown_text: The markdown text to append
-            append_divider: If True, appends a divider after the markdown content (default: False)
-        """
-        try:
-            blocks = self._markdown_to_notion_converter.convert(markdown_text)
-            fixed_blocks = self._chunker.fix_blocks_content_length(blocks)
-
-            result = await self._client.patch(
-                f"blocks/{self.page_id}/children", {"children": fixed_blocks}
-            )
-            return (
-                "Successfully added text to the page."
-                if result
-                else "Failed to add text."
-            )
-        except Exception as e:
-            self.logger.error("Error appending markdown: %s", str(e))
-            raise
-
-    async def has_database_descendant(self, block_id: str) -> bool:
-        """
-        Check if a block or any of its descendants is a database.
-        """
-        resp = await self._client.get(f"blocks/{block_id}/children")
-        children = resp.get("results", []) if resp else []
-
-        for child in children:
-            block_type = child.get("type")
-            if block_type in ["child_database", "database", "linked_database"]:
-                return True
-
-            if child.get("has_children", False):
-                if await self.has_database_descendant(child["id"]):
-                    return True
-
-        return False
-
-    async def delete_block_with_children(
-        self, block: Dict[str, Any], skip_databases: bool
-    ) -> tuple[int, int]:
-        """
-        Delete a block and all its children, optionally skipping databases.
-        Returns a tuple of (deleted_count, skipped_count).
-        """
-        deleted = 0
-        skipped = 0
-
-        block_type = block.get("type")
-        if skip_databases and block_type in [
-            "child_database",
-            "database",
-            "linked_database",
-        ]:
-            return 0, 1
-
-        if skip_databases and await self.has_database_descendant(block["id"]):
-            return 0, 1
-
-        # Process children first
-        if block.get("has_children", False):
-            children_resp = await self._client.get(f"blocks/{block['id']}/children")
-            for child in children_resp.get("results", []):
-                child_deleted, child_skipped = await self.delete_block_with_children(
-                    child, skip_databases
-                )
-                deleted += child_deleted
-                skipped += child_skipped
-
-        # Then delete the block itself
-        if await self._client.delete(f"blocks/{block['id']}"):
-            deleted += 1
-
-        return deleted, skipped
-
-    async def clear(self, skip_databases: bool = True) -> str:
-        """
-        Clear the content of the page, optionally preserving databases.
-        """
-        blocks_resp = await self._client.get(f"blocks/{self.page_id}/children")
-        results = blocks_resp.get("results", []) if blocks_resp else []
-
-        total_deleted = 0
-        total_skipped = 0
-
-        for block in results:
-            deleted, skipped = await self.delete_block_with_children(
-                block, skip_databases
-            )
-            total_deleted += deleted
-            total_skipped += skipped
-
-        return (
-            f"Deleted {total_deleted} blocks. Skipped {total_skipped} database blocks."
-        )
-
-    async def get_blocks(self) -> List[Dict[str, Any]]:
-        result = await self._client.get(f"blocks/{self.page_id}/children")
-        if not result:
-            self.logger.error("Error retrieving page content: %s", result.error)
-            return []
-        return result.get("results", [])
-
-    async def get_block_children(self, block_id: str) -> List[Dict[str, Any]]:
-        result = await self._client.get(f"blocks/{block_id}/children")
-        if not result:
-            self.logger.error("Error retrieving block children: %s", result.error)
-            return []
-        return result.get("results", [])
-
-    async def get_page_blocks_with_children(
-        self, parent_id: Optional[str] = None
-    ) -> List[Dict[str, Any]]:
-        blocks = (
-            await self.get_blocks()
-            if parent_id is None
-            else await self.get_block_children(parent_id)
-        )
-
-        if not blocks:
-            return []
-
-        for block in blocks:
-            if not block.get("has_children"):
-                continue
-
-            block_id = block.get("id")
-            if not block_id:
-                continue
-
-            # Recursive call for nested blocks
-            children = await self.get_page_blocks_with_children(block_id)
-            if children:
-                block["children"] = children
-
-        return blocks
-
-    async def get_text(self) -> str:
-        blocks = await self.get_page_blocks_with_children()
-        return self._notion_to_markdown_converter.convert(blocks)

notionary/page/properites/property_operation_result.py

@@ -1,116 +0,0 @@
-from typing import Any, Dict, List, Optional
-from dataclasses import dataclass
-
-
-@dataclass
-class PropertyOperationResult:
-    """
-    Result of a property operation in Notion.
-
-    Attributes:
-        success: Whether the operation was successful
-        property_name: Name of the affected property
-        value: The value that was set or retrieved
-        error: Error message, if any
-        available_options: Available options for select-like properties
-        api_response: The original API response
-    """
-
-    success: bool
-    property_name: str
-    value: Optional[Any] = None
-    error: Optional[str] = None
-    available_options: Optional[List[str]] = None
-    api_response: Optional[Dict[str, Any]] = None
-
-    # Common error messages
-    NO_API_RESPONSE = "Failed to set property (no API response)"
-    RELATION_TYPE_ERROR = "Property '{}' is of type 'relation'. Relations must be set using the RelationManager."
-
-    @classmethod
-    def from_success(
-        cls, property_name: str, value: Any, api_response: Dict[str, Any]
-    ) -> "PropertyOperationResult":
-        """Creates a success result."""
-        return cls(
-            success=True,
-            property_name=property_name,
-            value=value,
-            api_response=api_response,
-        )
-
-    @classmethod
-    def from_error(
-        cls,
-        property_name: str,
-        error: str,
-        value: Optional[Any] = None,
-        available_options: Optional[List[str]] = None,
-    ) -> "PropertyOperationResult":
-        """Creates an error result."""
-        return cls(
-            success=False,
-            property_name=property_name,
-            value=value,
-            error=error,
-            available_options=available_options or [],
-        )
-
-    @classmethod
-    def from_api_error(
-        cls, property_name: str, api_response: Dict[str, Any]
-    ) -> "PropertyOperationResult":
-        """Creates a result from an API error response."""
-        return cls(
-            success=False,
-            property_name=property_name,
-            error=api_response.get("message", "Unknown API error"),
-            api_response=api_response,
-        )
-
-    @classmethod
-    def from_no_api_response(
-        cls, property_name: str, value: Optional[Any] = None
-    ) -> "PropertyOperationResult":
-        """Creates a standardized result for missing API responses."""
-        return cls.from_error(property_name, cls.NO_API_RESPONSE, value)
-
-    @classmethod
-    def from_relation_type_error(
-        cls, property_name: str, value: Optional[Any] = None
-    ) -> "PropertyOperationResult":
-        """Creates a standardized error result for relation type properties."""
-        error_msg = cls.RELATION_TYPE_ERROR.format(property_name)
-        return cls.from_error(property_name, error_msg, value)
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Converts the result to a dictionary."""
-        result = {
-            "success": self.success,
-            "property": self.property_name,
-        }
-
-        if self.value is not None:
-            result["value"] = self.value
-
-        if not self.success:
-            result["error"] = self.error
-
-            if self.available_options:
-                result["available_options"] = self.available_options
-
-        if self.api_response:
-            result["api_response"] = self.api_response
-
-        return result
-
-    def __str__(self) -> str:
-        """String representation of the result."""
-        if self.success:
-            return f"Success: Property '{self.property_name}' set to '{self.value}'"
-
-        if self.available_options:
-            options = "', '".join(self.available_options)
-            return f"Error: {self.error}\nAvailable options for '{self.property_name}': '{options}'"
-
-        return f"Error: {self.error}"

notionary/page/relations/relation_operation_result.py

@@ -1,144 +0,0 @@
-from typing import Any, Dict, List, Optional
-from dataclasses import dataclass, field
-
-
-@dataclass
-class RelationOperationResult:
-    """
-    Result of a relation operation in Notion.
-
-    Attributes:
-        success: Whether the operation was successful overall
-        property_name: Name of the affected relation property
-        found_pages: List of page titles/IDs that were successfully found
-        not_found_pages: List of page titles that could not be found
-        page_ids_added: List of page IDs that were added to the relation
-        error: Error message, if any
-        api_response: The original API response
-    """
-
-    success: bool
-    property_name: str
-    found_pages: List[str] = field(default_factory=list)
-    not_found_pages: List[str] = field(default_factory=list)
-    page_ids_added: List[str] = field(default_factory=list)
-    error: Optional[str] = None
-    api_response: Optional[Dict[str, Any]] = None
-
-    NO_API_RESPONSE = "Failed to update relation (no API response)"
-    NO_PAGES_FOUND = "No valid pages found for relation"
-
-    @classmethod
-    def from_success(
-        cls,
-        property_name: str,
-        found_pages: List[str],
-        page_ids_added: List[str],
-        api_response: Dict[str, Any],
-        not_found_pages: Optional[List[str]] = None,
-    ) -> "RelationOperationResult":
-        """Creates a success result."""
-        return cls(
-            success=True,
-            property_name=property_name,
-            found_pages=found_pages,
-            not_found_pages=not_found_pages or [],
-            page_ids_added=page_ids_added,
-            api_response=api_response,
-        )
-
-    @classmethod
-    def from_error(
-        cls,
-        property_name: str,
-        error: str,
-        found_pages: Optional[List[str]] = None,
-        not_found_pages: Optional[List[str]] = None,
-        page_ids_added: Optional[List[str]] = None,
-    ) -> "RelationOperationResult":
-        """Creates an error result."""
-        return cls(
-            success=False,
-            property_name=property_name,
-            found_pages=found_pages or [],
-            not_found_pages=not_found_pages or [],
-            page_ids_added=page_ids_added or [],
-            error=error,
-        )
-
-    @classmethod
-    def from_no_pages_found(
-        cls, property_name: str, not_found_pages: List[str]
-    ) -> "RelationOperationResult":
-        """Creates a standardized result for when no pages were found."""
-        return cls.from_error(
-            property_name=property_name,
-            error=cls.NO_PAGES_FOUND,
-            not_found_pages=not_found_pages,
-        )
-
-    @classmethod
-    def from_no_api_response(
-        cls, property_name: str, found_pages: List[str], page_ids_added: List[str]
-    ) -> "RelationOperationResult":
-        """Creates a standardized result for a missing API response."""
-        return cls.from_error(
-            property_name=property_name,
-            error=cls.NO_API_RESPONSE,
-            found_pages=found_pages,
-            page_ids_added=page_ids_added,
-        )
-
-    @property
-    def has_not_found_pages(self) -> bool:
-        """Returns True if there were any pages that couldn't be found."""
-        return len(self.not_found_pages) > 0
-
-    @property
-    def has_found_pages(self) -> bool:
-        """Returns True if any pages were found."""
-        return len(self.found_pages) > 0
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Converts the result to a dictionary."""
-        result = {
-            "success": self.success,
-            "property": self.property_name,
-        }
-
-        if self.found_pages:
-            result["found_pages"] = self.found_pages
-
-        if self.not_found_pages:
-            result["not_found_pages"] = self.not_found_pages
-
-        if self.page_ids_added:
-            result["page_ids_added"] = self.page_ids_added
-
-        if not self.success:
-            result["error"] = self.error
-
-        if self.api_response:
-            result["api_response"] = self.api_response
-
-        return result
-
-    def __str__(self) -> str:
-        """String representation of the result."""
-        if self.success:
-            base = f"Success: Added {len(self.page_ids_added)} relation(s) to property '{self.property_name}'"
-
-            if self.not_found_pages:
-                pages_str = "', '".join(self.not_found_pages)
-                base += f"\nWarning: Could not find pages: '{pages_str}'"
-
-            return base
-
-        if not self.found_pages and self.not_found_pages:
-            pages_str = "', '".join(self.not_found_pages)
-            return f"Error: {self.error}\nNone of the requested pages were found: '{pages_str}'"
-
-        if self.found_pages and not self.page_ids_added:
-            return f"Error: {self.error}\nPages were found but could not be added to the relation."
-
-        return f"Error: {self.error}"

notionary-0.1.28.dist-info/RECORD

@@ -1,58 +0,0 @@
-notionary/__init__.py,sha256=ypCkbF1YEcwy5aE2kGFmtJOZq41Vs01lahJNqRO27fU,735
-notionary/notion_client.py,sha256=6YhaDK9UjH18Q0f1bxVVNGMbCvpQhatse6WRVIARGCE,6035
-notionary/database/database_discovery.py,sha256=qDGFhXG9s-_6CXdRg8tMiwX4dvX7jLjgAUFPSNlYtlI,4506
-notionary/database/database_info_service.py,sha256=Ig6gx8jUSPYORJvfgEV5kV6t72pZQsWU8HPMqd43B-o,1336
-notionary/database/notion_database.py,sha256=YCOuzrWfKRJvMiWdVfEt8i3NAEqpKDwHj5SX4GUraEk,8017
-notionary/database/notion_database_factory.py,sha256=Af57yaUHidD8TKJ8uyXOc2nnqHm7on6VGFdDRjxiq9o,6692
-notionary/database/models/page_result.py,sha256=Vmm5_oYpYAkIIJVoTd1ZZGloeC3cmFLMYP255mAmtaw,233
-notionary/elements/audio_element.py,sha256=WpcUpIv4U9grZegiCAmyc-Gj3XM3TQVFKr9PQM-QErg,5352
-notionary/elements/bookmark_element.py,sha256=MS2K3pD-hMmS4Fmk1W8BwNL_-j4baHF42EoOWMNIfXw,8152
-notionary/elements/bulleted_list_element.py,sha256=VdMKlxDlixTeYVQIqwM4vQ55xHqABtqzZDqIUATG9oE,2875
-notionary/elements/callout_element.py,sha256=11qr9XGpF7jWle0wbog5eUrE4SAkThDdK9s4oplOxX0,4499
-notionary/elements/code_block_element.py,sha256=6E-fc9zJegSQ_FjB08HImXL2rDQnmkFoRwoPuN-7PwI,6247
-notionary/elements/divider_element.py,sha256=fLWU7Pn0JXIV8tPcuxvMMua4S54JOi2hQRjLcbVwC7g,2218
-notionary/elements/embed_element.py,sha256=NEQopRLMzMIybVLbTt_y1cgaH1-VZW14xkbGJIDirkE,4586
-notionary/elements/heading_element.py,sha256=Su4OUYeDvb9kvAFCmzagKQCNgkwvxsUn1KXJFTuYTFE,3186
-notionary/elements/image_element.py,sha256=Qo94TavAnmJzGveDfdSkOAZeypij-zqbxsJ14rfbKIc,4765
-notionary/elements/mention_element.py,sha256=B88AcU4XqpEXfhXywS_3K7TJIgoJT_3tWzJ_KcdJ4V4,8234
-notionary/elements/notion_block_element.py,sha256=HN1Bu9wAaFsRIN6jkZSclo6KgB4nNvcVx7hlPWIhmy8,1265
-notionary/elements/numbered_list_element.py,sha256=zW1MjNU_02mJBDGnaQFkAESY_i1rCYgp9o4zl6Au0DQ,2865
-notionary/elements/paragraph_element.py,sha256=JuAN4cFRsJkePD7s7TNhDdSuojZtr6WOaCTGzJsBEGg,3262
-notionary/elements/qoute_element.py,sha256=jG4FkD7Ieec3piBWcOeCZPgvw0GF0KZlxzdx2svQC0M,6129
-notionary/elements/table_element.py,sha256=ujlo6bwrmKrQWRWGuUQebeDS-1T-c_R0SkzaPEPy2m8,11256
-notionary/elements/text_inline_formatter.py,sha256=RdegEHvS5_AzDtqYxKb4b0uDbcpp3UhxHo6GyR84NFc,7780
-notionary/elements/todo_element.py,sha256=cWuu8R55hNj6ubjrLu2yJpoeij7UfWhvmaklqcx8AI8,4131
-notionary/elements/toggle_element.py,sha256=o7Utj0nKZAW5MzF_RMyD36HSWMj1cZmLEmqfGH-BFuY,11089
-notionary/elements/toggleable_heading_element.py,sha256=EAkL9mU6u13JEgUOx6CeAhD8P3L_q6L_M_C8qZ_OTSs,9967
-notionary/elements/video_element.py,sha256=2WwvZuG_UOVBnpEikZFxupe_x321QkczrodZHd5IeCw,5734
-notionary/elements/prompts/element_prompt_content.py,sha256=Snha2FMtWO94kl1KwIJp6n7pY6Z8K-9_zVj1TUyaNNA,3729
-notionary/elements/prompts/synthax_prompt_builder.py,sha256=W3ex5RDszlhMgYPGpemxiEI653hQKl147B-bh_ynR9g,6656
-notionary/elements/registry/block_element_registry.py,sha256=r1V6waYQxZ_4bF6Mx_HmQ42-yhh8E54v-yNRT4PsnLk,3570
-notionary/elements/registry/block_element_registry_builder.py,sha256=C6W64CwFqZBu31hZZqoD-uCZCOMOOXeFVk_SHKSp58U,9048
-notionary/exceptions/database_exceptions.py,sha256=I-Tx6bYRLpi5pjGPtbT-Mqxvz3BFgYTiuZxknJeLxtI,2638
-notionary/exceptions/page_creation_exception.py,sha256=4v7IuZD6GsQLrqhDLriGjuG3ML638gAO53zDCrLePuU,281
-notionary/page/markdown_to_notion_converter.py,sha256=LFnv98uU3QRzxH7sZI0AE5_QxeHkNQZMxVcab-r8Qls,15877
-notionary/page/notion_page.py,sha256=OXE2sw9Drkqduy96uVvXT3vHwHPh5FMJk6QyPRADoFU,17653
-notionary/page/notion_page_factory.py,sha256=UUEZ-cyEWL0OMVPrgjc4vJdcplEa1bO2yHCYooACYC8,8189
-notionary/page/notion_to_markdown_converter.py,sha256=EUiHeurQb73zQJ5Gatvf_67vWd-vOI8qg3yFLz8bf8Q,6452
-notionary/page/content/notion_page_content_chunker.py,sha256=xRks74Dqec-De6-AVTxMPnXs-MSJBzSm1HfJfaHiKr8,3330
-notionary/page/content/page_content_manager.py,sha256=0Bl52mEqKuhDGuJhOEMhGjJWHgxCiqGYjrqO1LqYzJM,6403
-notionary/page/metadata/metadata_editor.py,sha256=61uiw8oB25O8ePhytoJvZDetuof5sjPoM6aoHZGo4wc,4949
-notionary/page/metadata/notion_icon_manager.py,sha256=I4MczURRYc1PV0qDFwbCCzicqiDyOhKpdk9E2b9lWMc,1579
-notionary/page/metadata/notion_page_cover_manager.py,sha256=hasXPIbTy9rD55tHr_zzF2yj_lD0RsULz5UP0rNRx4g,1929
-notionary/page/properites/database_property_service.py,sha256=AJuBGahbb53VQa6IGGHxBMoOgCy6vFZg08uR_eDjNUs,11570
-notionary/page/properites/page_property_manager.py,sha256=Xl8Cwn8WVszqpFXT_NvASkmP5igpCTEgRVhG_F45424,6914
-notionary/page/properites/property_formatter.py,sha256=d_Nr5XQxgjB6VIS0u3ey14MOUKY416o_BvdXjbkUNAQ,3667
-notionary/page/properites/property_operation_result.py,sha256=PhxHJJxxG2BdDl7aswhWnMSmf9RQtoinKkRHDoqxwCs,3913
-notionary/page/properites/property_value_extractor.py,sha256=1BfyCYrFzfIUmNTozavrLTjG--6P6Dy2tkewf6rHHwQ,2353
-notionary/page/relations/notion_page_relation_manager.py,sha256=ooN-WxXNPBE_vkNJgbc1wH8iIWBlKa9FHgiMeJjbYdw,13032
-notionary/page/relations/notion_page_title_resolver.py,sha256=XQpa5XY4hoh5UYqpewTYaaftNX52WHyk2XmM4r8B2uY,3016
-notionary/page/relations/page_database_relation.py,sha256=F9aGXFjjL8ZLNbfTGeGm_QAyXhz2AEOw7GgDLdprEcE,2313
-notionary/page/relations/relation_operation_result.py,sha256=NDxBzGntOxc_89ti-HG8xDSqfY6PwyGHKHrrKbCzNjM,5010
-notionary/util/logging_mixin.py,sha256=fKsx9t90bwvL74ZX3dU-sXdC4TZCQyO6qU9I8txkw_U,1369
-notionary/util/page_id_utils.py,sha256=EYNMxgf-7ghzL5K8lKZBZfW7g5CsdY0Xuj4IYmU8RPk,1381
-notionary-0.1.28.dist-info/licenses/LICENSE,sha256=zOm3cRT1qD49eg7vgw95MI79rpUAZa1kRBFwL2FkAr8,1120
-notionary-0.1.28.dist-info/METADATA,sha256=09cAT-X3imeOHrG-VKtcOLSUJ_pPLiioAnxJ2e4cdwg,8342
-notionary-0.1.28.dist-info/WHEEL,sha256=GHB6lJx2juba1wDgXDNlMTyM13ckjBMKf-OnwgKOCtA,91
-notionary-0.1.28.dist-info/top_level.txt,sha256=fhONa6BMHQXqthx5PanWGbPL0b8rdFqhrJKVLf_adSs,10
-notionary-0.1.28.dist-info/RECORD,,