notionary 0.4.0__py3-none-any.whl → 0.4.2__py3-none-any.whl

notionary/exceptions/file_upload.py

@@ -2,7 +2,12 @@ from notionary.exceptions.base import NotionaryException
 
 
 class UnsupportedFileTypeException(NotionaryException):
-    def __init__(self, extension: str, filename: str, supported_extensions_by_category: dict[str, list[str]]):
+    def __init__(
+        self,
+        extension: str,
+        filename: str,
+        supported_extensions_by_category: dict[str, list[str]],
+    ):
         supported_exts = []
         for category, extensions in supported_extensions_by_category.items():
             supported_exts.append(f"{category}: {', '.join(extensions[:5])}...")
@@ -44,7 +49,9 @@ class FileNotFoundError(NotionaryException):
 
 class FilenameTooLongError(NotionaryException):
     def __init__(self, filename: str, filename_bytes: int, max_filename_bytes: int):
-        super().__init__(f"Filename too long: {filename_bytes} bytes (max {max_filename_bytes}). Filename: {filename}")
+        super().__init__(
+            f"Filename too long: {filename_bytes} bytes (max {max_filename_bytes}). Filename: {filename}"
+        )
         self.filename = filename
         self.filename_bytes = filename_bytes
         self.max_filename_bytes = max_filename_bytes
@@ -62,6 +69,8 @@ class UploadFailedError(NotionaryException):
 
 class UploadTimeoutError(NotionaryException):
     def __init__(self, file_upload_id: str, timeout_seconds: int):
-        super().__init__(f"Upload timeout after {timeout_seconds}s for file_upload_id: {file_upload_id}")
+        super().__init__(
+            f"Upload timeout after {timeout_seconds}s for file_upload_id: {file_upload_id}"
+        )
         self.file_upload_id = file_upload_id
         self.timeout_seconds = timeout_seconds

notionary/exceptions/properties.py

@@ -50,7 +50,9 @@ class AccessPagePropertyWithoutDataSourceError(NotionaryException):
     }
 
     def __init__(self, parent_type: ParentType) -> None:
-        parent_desc = self._PARENT_DESCRIPTIONS.get(parent_type, f"its parent type is '{parent_type}'")
+        parent_desc = self._PARENT_DESCRIPTIONS.get(
+            parent_type, f"its parent type is '{parent_type}'"
+        )
         message = (
             f"Cannot access properties other than title because this page's parent is {parent_desc}. "
             "To use operations like property reading/writing, you need to use a page whose parent is a data source."

notionary/exceptions/search.py

@@ -2,7 +2,9 @@ from notionary.exceptions.base import NotionaryException
 
 
 class EntityNotFound(NotionaryException):
-    def __init__(self, entity_type: str, query: str, available_titles: list[str] | None = None) -> None:
+    def __init__(
+        self, entity_type: str, query: str, available_titles: list[str] | None = None
+    ) -> None:
         self.entity_type = entity_type
         self.query = query
         self.available_titles = available_titles or []
@@ -41,7 +43,9 @@ class NoUsersInWorkspace(NotionaryException):
 
 
 class UserNotFound(NotionaryException):
-    def __init__(self, user_type: str, query: str, available_names: list[str] | None = None) -> None:
+    def __init__(
+        self, user_type: str, query: str, available_names: list[str] | None = None
+    ) -> None:
         self.user_type = user_type
         self.query = query
         self.available_names = available_names or []

notionary/file_upload/client.py

@@ -11,7 +11,11 @@ from notionary.file_upload.schemas import (
     UploadMode,
 )
 from notionary.http.client import NotionHttpClient
-from notionary.utils.pagination import PaginatedResponse, paginate_notion_api, paginate_notion_api_generator
+from notionary.utils.pagination import (
+    PaginatedResponse,
+    paginate_notion_api,
+    paginate_notion_api_generator,
+)
 
 
 class FileUploadHttpClient(NotionHttpClient):

notionary/file_upload/config/config.py

@@ -22,11 +22,18 @@ class FileUploadConfig(BaseModel):
     )
 
     max_upload_timeout: int = Field(
-        default=300, gt=0, description="Maximum time in seconds to wait for an upload to complete."
+        default=300,
+        gt=0,
+        description="Maximum time in seconds to wait for an upload to complete.",
     )
 
-    poll_interval: int = Field(default=2, gt=0, description="Interval in seconds for polling the upload status.")
+    poll_interval: int = Field(
+        default=2,
+        gt=0,
+        description="Interval in seconds for polling the upload status.",
+    )
 
     base_upload_path: Path | None = Field(
-        default=None, description="Optional default base path for resolving relative file uploads."
+        default=None,
+        description="Optional default base path for resolving relative file uploads.",
     )

notionary/file_upload/query/builder.py

@@ -42,12 +42,16 @@ class FileUploadQueryBuilder:
         return value
 
     def with_total_results_limit(self, total_results_limit: int) -> Self:
-        self._query.total_results_limit = self._validate_total_results_limit(total_results_limit)
+        self._query.total_results_limit = self._validate_total_results_limit(
+            total_results_limit
+        )
         return self
 
     def _validate_total_results_limit(self, value: int) -> int:
         if not (1 <= value <= 100):
-            raise ValueError(f"total_results_limit must be between 1 and 100, got {value}")
+            raise ValueError(
+                f"total_results_limit must be between 1 and 100, got {value}"
+            )
         return value
 
     def build(self) -> FileUploadQuery:

notionary/file_upload/schemas.py

@@ -52,7 +52,9 @@ class FileUploadCreateRequest(BaseModel):
         if self.mode == UploadMode.MULTI_PART and self.number_of_parts is None:
             raise ValueError("number_of_parts is required when mode is 'multi_part'")
         if self.mode == UploadMode.SINGLE_PART and self.number_of_parts is not None:
-            raise ValueError("number_of_parts should not be provided for 'single_part' mode")
+            raise ValueError(
+                "number_of_parts should not be provided for 'single_part' mode"
+            )
         return self
 
     def model_dump(self, **kwargs):

notionary/file_upload/service.py

@@ -27,7 +27,9 @@ class NotionFileUpload(LoggingMixin):
         self._config = config or FileUploadConfig()
         self._file_reader = file_reader or FileContentReader(config=self._config)
 
-    async def upload_file(self, file_path: Path, filename: str | None = None) -> FileUploadResponse:
+    async def upload_file(
+        self, file_path: Path, filename: str | None = None
+    ) -> FileUploadResponse:
         file_path = Path(file_path)
 
         if not file_path.is_absolute() and self._config.base_upload_path:
@@ -43,10 +45,15 @@ class NotionFileUpload(LoggingMixin):
 
         if self._fits_in_single_part(file_size):
             content = await self._file_reader.read_full_file(file_path)
-            return await self._upload_single_part_content(content, filename, content_type)
+            return await self._upload_single_part_content(
+                content, filename, content_type
+            )
         else:
             return await self._upload_multi_part_content(
-                filename, content_type, file_size, self._file_reader.read_file_chunks(file_path)
+                filename,
+                content_type,
+                file_size,
+                self._file_reader.read_file_chunks(file_path),
             )
 
     async def upload_from_bytes(
@@ -66,10 +73,15 @@ class NotionFileUpload(LoggingMixin):
         content_type = content_type or self._guess_content_type(filename)
 
         if self._fits_in_single_part(file_size):
-            return await self._upload_single_part_content(file_content, filename, content_type)
+            return await self._upload_single_part_content(
+                file_content, filename, content_type
+            )
 
         return await self._upload_multi_part_content(
-            filename, content_type, file_size, self._file_reader.bytes_to_chunks(file_content)
+            filename,
+            content_type,
+            file_size,
+            self._file_reader.bytes_to_chunks(file_content),
         )
 
     async def _upload_single_part_content(
@@ -86,7 +98,10 @@ class NotionFileUpload(LoggingMixin):
             filename=filename,
         )
 
-        self.logger.info("Single-part content sent, waiting for completion... (ID: %s)", file_upload.id)
+        self.logger.info(
+            "Single-part content sent, waiting for completion... (ID: %s)",
+            file_upload.id,
+        )
         return await self._wait_for_completion(file_upload.id)
 
     async def _upload_multi_part_content(
@@ -108,7 +123,10 @@ class NotionFileUpload(LoggingMixin):
 
         await self._client.complete_upload(file_upload.id)
 
-        self.logger.info("Multi-part content sent, waiting for completion... (ID: %s)", file_upload.id)
+        self.logger.info(
+            "Multi-part content sent, waiting for completion... (ID: %s)",
+            file_upload.id,
+        )
         return await self._wait_for_completion(file_upload.id)
 
     async def _send_parts(
@@ -133,7 +151,8 @@ class NotionFileUpload(LoggingMixin):
 
         except Exception as e:
             raise UploadFailedError(
-                file_upload_id=file_upload_id, reason=f"Failed to upload part {part_number}/{total_parts}: {e}"
+                file_upload_id=file_upload_id,
+                reason=f"Failed to upload part {part_number}/{total_parts}: {e}",
             ) from e
 
     def _fits_in_single_part(self, file_size: int) -> bool:
@@ -144,7 +163,9 @@ class NotionFileUpload(LoggingMixin):
         return content_type
 
     def _calculate_part_count(self, file_size: int) -> int:
-        return (file_size + self._config.multi_part_chunk_size - 1) // self._config.multi_part_chunk_size
+        return (
+            file_size + self._config.multi_part_chunk_size - 1
+        ) // self._config.multi_part_chunk_size
 
     async def get_upload_status(self, file_upload_id: str) -> str:
         try:
@@ -161,12 +182,16 @@ class NotionFileUpload(LoggingMixin):
         timeout = timeout_seconds or self._config.max_upload_timeout
 
         try:
-            return await asyncio.wait_for(self._poll_status_until_complete(file_upload_id), timeout=timeout)
+            return await asyncio.wait_for(
+                self._poll_status_until_complete(file_upload_id), timeout=timeout
+            )
 
         except TimeoutError as e:
             raise UploadTimeoutError(file_upload_id, timeout) from e
 
-    async def _poll_status_until_complete(self, file_upload_id: str) -> FileUploadResponse:
+    async def _poll_status_until_complete(
+        self, file_upload_id: str
+    ) -> FileUploadResponse:
         while True:
             upload_info = await self._client.get_file_upload(file_upload_id)
 
@@ -182,7 +207,8 @@ class NotionFileUpload(LoggingMixin):
     async def get_uploads(
         self,
         *,
-        filter_fn: Callable[[FileUploadQueryBuilder], FileUploadQueryBuilder] | None = None,
+        filter_fn: Callable[[FileUploadQueryBuilder], FileUploadQueryBuilder]
+        | None = None,
         query: FileUploadQuery | None = None,
     ) -> list[FileUploadResponse]:
         resolved_query = self._resolve_query(filter_fn=filter_fn, query=query)
@@ -191,7 +217,8 @@ class NotionFileUpload(LoggingMixin):
     async def iter_uploads(
         self,
         *,
-        filter_fn: Callable[[FileUploadQueryBuilder], FileUploadQueryBuilder] | None = None,
+        filter_fn: Callable[[FileUploadQueryBuilder], FileUploadQueryBuilder]
+        | None = None,
         query: FileUploadQuery | None = None,
     ) -> AsyncIterator[FileUploadResponse]:
         resolved_query = self._resolve_query(filter_fn=filter_fn, query=query)
@@ -200,7 +227,8 @@ class NotionFileUpload(LoggingMixin):
 
     def _resolve_query(
         self,
-        filter_fn: Callable[[FileUploadQueryBuilder], FileUploadQueryBuilder] | None = None,
+        filter_fn: Callable[[FileUploadQueryBuilder], FileUploadQueryBuilder]
+        | None = None,
         query: FileUploadQuery | None = None,
     ) -> FileUploadQuery:
         if filter_fn and query:

notionary/file_upload/validation/factory.py

@@ -60,5 +60,7 @@ def _create_extension_validator(filename: str) -> FileExtensionValidator:
     return FileExtensionValidator(filename=filename)
 
 
-def _create_size_validator(filename: str, file_size_bytes: int) -> FileUploadLimitValidator:
+def _create_size_validator(
+    filename: str, file_size_bytes: int
+) -> FileUploadLimitValidator:
     return FileUploadLimitValidator(filename=filename, file_size_bytes=file_size_bytes)

notionary/file_upload/validation/impl/file_name_length.py

@@ -6,7 +6,9 @@ from notionary.file_upload.validation.port import FileUploadValidator
 
 
 class FileNameLengthValidator(FileUploadValidator):
-    def __init__(self, filename: str, file_upload_config: FileUploadConfig | None = None) -> None:
+    def __init__(
+        self, filename: str, file_upload_config: FileUploadConfig | None = None
+    ) -> None:
         self._filename = filename
 
         file_upload_config = file_upload_config or FileUploadConfig()

notionary/file_upload/validation/models.py

@@ -53,14 +53,24 @@ class DocumentMimeType(StrEnum):
     PLAIN_TEXT = "text/plain"
     JSON = "application/json"
     MSWORD = "application/msword"
-    WORD_DOCUMENT = "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
-    WORD_TEMPLATE = "application/vnd.openxmlformats-officedocument.wordprocessingml.template"
+    WORD_DOCUMENT = (
+        "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+    )
+    WORD_TEMPLATE = (
+        "application/vnd.openxmlformats-officedocument.wordprocessingml.template"
+    )
     EXCEL = "application/vnd.ms-excel"
     EXCEL_SHEET = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
-    EXCEL_TEMPLATE = "application/vnd.openxmlformats-officedocument.spreadsheetml.template"
+    EXCEL_TEMPLATE = (
+        "application/vnd.openxmlformats-officedocument.spreadsheetml.template"
+    )
     POWERPOINT = "application/vnd.ms-powerpoint"
-    POWERPOINT_PRESENTATION = "application/vnd.openxmlformats-officedocument.presentationml.presentation"
-    POWERPOINT_TEMPLATE = "application/vnd.openxmlformats-officedocument.presentationml.template"
+    POWERPOINT_PRESENTATION = (
+        "application/vnd.openxmlformats-officedocument.presentationml.presentation"
+    )
+    POWERPOINT_TEMPLATE = (
+        "application/vnd.openxmlformats-officedocument.presentationml.template"
+    )
 
 
 class ImageExtension(StrEnum):

notionary/file_upload/validation/validators/file_extension.py

@@ -1,7 +1,10 @@
 from pathlib import Path
 from typing import ClassVar, override
 
-from notionary.exceptions.file_upload import NoFileExtensionException, UnsupportedFileTypeException
+from notionary.exceptions.file_upload import (
+    NoFileExtensionException,
+    UnsupportedFileTypeException,
+)
 from notionary.file_upload.validation.models import (
     AudioExtension,
     AudioMimeType,
@@ -94,7 +97,9 @@ class FileExtensionValidator(FileUploadValidator):
 
         if not self._is_supported(extension):
             supported_by_category = self._get_supported_extensions_by_category()
-            raise UnsupportedFileTypeException(extension, self.filename, supported_by_category)
+            raise UnsupportedFileTypeException(
+                extension, self.filename, supported_by_category
+            )
 
     @staticmethod
     def _extract_extension(filename: str) -> str:
@@ -117,6 +122,10 @@ class FileExtensionValidator(FileUploadValidator):
     def _get_supported_extensions_by_category(self) -> dict[str, list[str]]:
         result = {}
         for category in FileCategory:
-            extensions = [ext for ext, cat in self.EXTENSION_TO_CATEGORY.items() if cat == category]
+            extensions = [
+                ext
+                for ext, cat in self.EXTENSION_TO_CATEGORY.items()
+                if cat == category
+            ]
             result[category.value] = extensions
         return result

notionary/http/client.py

@@ -50,13 +50,17 @@ class NotionHttpClient(LoggingMixin):
         try:
             loop = asyncio.get_event_loop()
             if not loop.is_running():
-                self.logger.warning("Event loop not running, could not auto-close NotionHttpClient")
+                self.logger.warning(
+                    "Event loop not running, could not auto-close NotionHttpClient"
+                )
                 return
 
             loop.create_task(self.close())
             self.logger.debug("Created cleanup task for NotionHttpClient")
         except RuntimeError:
-            self.logger.warning("No event loop available for auto-closing NotionHttpClient")
+            self.logger.warning(
+                "No event loop available for auto-closing NotionHttpClient"
+            )
 
     async def __aenter__(self):
         await self._ensure_initialized()
@@ -74,13 +78,19 @@ class NotionHttpClient(LoggingMixin):
         self._is_initialized = False
         self.logger.debug("NotionHttpClient closed")
 
-    async def get(self, endpoint: str, params: JsonDict | None = None) -> JsonDict | None:
+    async def get(
+        self, endpoint: str, params: JsonDict | None = None
+    ) -> JsonDict | None:
         return await self._make_request(HttpMethod.GET, endpoint, params=params)
 
-    async def post(self, endpoint: str, data: JsonDict | None = None) -> JsonDict | None:
+    async def post(
+        self, endpoint: str, data: JsonDict | None = None
+    ) -> JsonDict | None:
         return await self._make_request(HttpMethod.POST, endpoint, data)
 
-    async def patch(self, endpoint: str, data: JsonDict | None = None) -> JsonDict | None:
+    async def patch(
+        self, endpoint: str, data: JsonDict | None = None
+    ) -> JsonDict | None:
         return await self._make_request(HttpMethod.PATCH, endpoint, data)
 
     async def delete(self, endpoint: str) -> JsonDict | None:
@@ -105,10 +115,15 @@ class NotionHttpClient(LoggingMixin):
             if params:
                 request_kwargs["params"] = params
 
-            if method.value in [HttpMethod.POST.value, HttpMethod.PATCH.value] and data is not None:
+            if (
+                method.value in [HttpMethod.POST.value, HttpMethod.PATCH.value]
+                and data is not None
+            ):
                 request_kwargs["json"] = data
 
-            response: httpx.Response = await getattr(self.client, method.value)(url, **request_kwargs)
+            response: httpx.Response = await getattr(self.client, method.value)(
+                url, **request_kwargs
+            )
 
             response.raise_for_status()
             result_data = response.json()
@@ -173,7 +188,11 @@ class NotionHttpClient(LoggingMixin):
 
     def _find_token(self) -> str | None:
         token = next(
-            (os.getenv(var) for var in ("NOTION_SECRET", "NOTION_INTEGRATION_KEY", "NOTION_TOKEN") if os.getenv(var)),
+            (
+                os.getenv(var)
+                for var in ("NOTION_SECRET", "NOTION_INTEGRATION_KEY", "NOTION_TOKEN")
+                if os.getenv(var)
+            ),
             None,
         )
         if token:

notionary/page/content/__init__.py

@@ -0,0 +1,9 @@
+from .factory import PageContentServiceFactory
+from .service import PageContentService
+from .syntax.prompts import SyntaxPromptRegistry
+
+__all__ = [
+    "PageContentService",
+    "PageContentServiceFactory",
+    "SyntaxPromptRegistry",
+]

notionary/page/content/factory.py

@@ -1,6 +1,8 @@
 from notionary.blocks.client import NotionBlockHttpClient
 from notionary.page.content.parser.factory import ConverterChainFactory
-from notionary.page.content.parser.post_processing.handlers import RichTextLengthTruncationPostProcessor
+from notionary.page.content.parser.post_processing.handlers import (
+    RichTextLengthTruncationPostProcessor,
+)
 from notionary.page.content.parser.post_processing.service import BlockPostProcessor
 from notionary.page.content.parser.pre_processsing.handlers import (
     ColumnSyntaxPreProcessor,
@@ -11,8 +13,12 @@ from notionary.page.content.parser.pre_processsing.handlers import (
 from notionary.page.content.parser.pre_processsing.service import MarkdownPreProcessor
 from notionary.page.content.parser.service import MarkdownToNotionConverter
 from notionary.page.content.renderer.factory import RendererChainFactory
-from notionary.page.content.renderer.post_processing.handlers import NumberedListPlaceholderReplacerPostProcessor
-from notionary.page.content.renderer.post_processing.service import MarkdownRenderingPostProcessor
+from notionary.page.content.renderer.post_processing.handlers import (
+    NumberedListPlaceholderReplacerPostProcessor,
+)
+from notionary.page.content.renderer.post_processing.service import (
+    MarkdownRenderingPostProcessor,
+)
 from notionary.page.content.renderer.service import NotionToMarkdownConverter
 from notionary.page.content.service import PageContentService
 
@@ -23,10 +29,14 @@ class PageContentServiceFactory:
         converter_chain_factory: ConverterChainFactory | None = None,
         renderer_chain_factory: RendererChainFactory | None = None,
     ) -> None:
-        self._converter_chain_factory = converter_chain_factory or ConverterChainFactory()
+        self._converter_chain_factory = (
+            converter_chain_factory or ConverterChainFactory()
+        )
         self._renderer_chain_factory = renderer_chain_factory or RendererChainFactory()
 
-    def create(self, page_id: str, block_client: NotionBlockHttpClient) -> PageContentService:
+    def create(
+        self, page_id: str, block_client: NotionBlockHttpClient
+    ) -> PageContentService:
         markdown_converter = self._create_markdown_to_notion_converter()
         notion_to_markdown_converter = self._create_notion_to_markdown_converter()
 
@@ -50,7 +60,9 @@ class PageContentServiceFactory:
 
     def _create_notion_to_markdown_converter(self) -> NotionToMarkdownConverter:
         renderer_chain = self._renderer_chain_factory.create()
-        markdown_rendering_post_processor = self._create_markdown_rendering_post_processor()
+        markdown_rendering_post_processor = (
+            self._create_markdown_rendering_post_processor()
+        )
         return NotionToMarkdownConverter(
             renderer_chain=renderer_chain,
             post_processor=markdown_rendering_post_processor,
@@ -69,7 +81,9 @@ class PageContentServiceFactory:
         post_processor.register(RichTextLengthTruncationPostProcessor())
         return post_processor
 
-    def _create_markdown_rendering_post_processor(self) -> MarkdownRenderingPostProcessor:
+    def _create_markdown_rendering_post_processor(
+        self,
+    ) -> MarkdownRenderingPostProcessor:
         post_processor = MarkdownRenderingPostProcessor()
         post_processor.register(NumberedListPlaceholderReplacerPostProcessor())
         return post_processor