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

notionary/data_source/schema/registry.py

@@ -13,36 +13,52 @@ class DatabasePropertyTypeDescriptorRegistry:
     def __init__(self):
         self._DESCRIPTORS = {
             PropertyType.TITLE: PropertyTypeDescriptor(
-                display_name="Title", description="Required field for the main heading of the entry"
+                display_name="Title",
+                description="Required field for the main heading of the entry",
             ),
             PropertyType.RICH_TEXT: PropertyTypeDescriptor(
-                display_name="Rich Text", description="Free-form text field for additional information"
+                display_name="Rich Text",
+                description="Free-form text field for additional information",
+            ),
+            PropertyType.NUMBER: PropertyTypeDescriptor(
+                display_name="Number", description="Numeric value field"
             ),
-            PropertyType.NUMBER: PropertyTypeDescriptor(display_name="Number", description="Numeric value field"),
             PropertyType.CHECKBOX: PropertyTypeDescriptor(
                 display_name="Checkbox", description="Boolean value (true/false)"
             ),
-            PropertyType.DATE: PropertyTypeDescriptor(display_name="Date", description="Date or date range field"),
-            PropertyType.URL: PropertyTypeDescriptor(display_name="URL", description="Web address field"),
-            PropertyType.EMAIL: PropertyTypeDescriptor(display_name="Email", description="Email address field"),
+            PropertyType.DATE: PropertyTypeDescriptor(
+                display_name="Date", description="Date or date range field"
+            ),
+            PropertyType.URL: PropertyTypeDescriptor(
+                display_name="URL", description="Web address field"
+            ),
+            PropertyType.EMAIL: PropertyTypeDescriptor(
+                display_name="Email", description="Email address field"
+            ),
             PropertyType.PHONE_NUMBER: PropertyTypeDescriptor(
                 display_name="Phone Number", description="Phone number field"
             ),
             PropertyType.FILES: PropertyTypeDescriptor(
                 display_name="Files & Media", description="Upload or link to files"
             ),
-            PropertyType.PEOPLE: PropertyTypeDescriptor(display_name="People", description="Reference to Notion users"),
+            PropertyType.PEOPLE: PropertyTypeDescriptor(
+                display_name="People", description="Reference to Notion users"
+            ),
             PropertyType.SELECT: PropertyTypeDescriptor(
-                display_name="Single Select", description="Choose one option from available choices"
+                display_name="Single Select",
+                description="Choose one option from available choices",
             ),
             PropertyType.MULTI_SELECT: PropertyTypeDescriptor(
-                display_name="Multi Select", description="Choose multiple options from available choices"
+                display_name="Multi Select",
+                description="Choose multiple options from available choices",
             ),
             PropertyType.STATUS: PropertyTypeDescriptor(
-                display_name="Status", description="Track status with predefined options"
+                display_name="Status",
+                description="Track status with predefined options",
             ),
             PropertyType.RELATION: PropertyTypeDescriptor(
-                display_name="Relation", description="Link to entries in another database"
+                display_name="Relation",
+                description="Link to entries in another database",
             ),
             PropertyType.CREATED_TIME: PropertyTypeDescriptor(
                 display_name="Created Time",
@@ -97,7 +113,10 @@ class DatabasePropertyTypeDescriptorRegistry:
     def get_descriptor(self, property_type: PropertyType) -> PropertyTypeDescriptor:
         return self._DESCRIPTORS.get(
             property_type,
-            PropertyTypeDescriptor(display_name=self._format_unknown_type_name(property_type), description=""),
+            PropertyTypeDescriptor(
+                display_name=self._format_unknown_type_name(property_type),
+                description="",
+            ),
         )
 
     def _format_unknown_type_name(self, property_type: PropertyType) -> str:

notionary/data_source/schema/service.py

@@ -8,7 +8,10 @@ from notionary.data_source.properties.schemas import (
     DataSourceSelectProperty,
     DataSourceStatusProperty,
 )
-from notionary.data_source.schema.registry import DatabasePropertyTypeDescriptorRegistry, PropertyTypeDescriptor
+from notionary.data_source.schema.registry import (
+    DatabasePropertyTypeDescriptorRegistry,
+    PropertyTypeDescriptor,
+)
 from notionary.shared.properties.type import PropertyType
 
 
@@ -17,12 +20,16 @@ class PropertyFormatter:
 
     def __init__(
         self,
-        relation_options_fetcher: Callable[[DataSourceRelationProperty], Awaitable[list[str]]],
+        relation_options_fetcher: Callable[
+            [DataSourceRelationProperty], Awaitable[list[str]]
+        ],
         type_descriptor_registry: DatabasePropertyTypeDescriptorRegistry | None = None,
         data_source_resolver: DataSourceNameIdResolver | None = None,
     ) -> None:
         self._relation_options_fetcher = relation_options_fetcher
-        self._type_descriptor_registry = type_descriptor_registry or DatabasePropertyTypeDescriptorRegistry()
+        self._type_descriptor_registry = (
+            type_descriptor_registry or DatabasePropertyTypeDescriptorRegistry()
+        )
         self._data_source_resolver = data_source_resolver or DataSourceNameIdResolver()
 
     async def format_property(self, prop: DataSourceProperty) -> list[str]:
@@ -32,22 +39,35 @@ class PropertyFormatter:
             return [*specific_details, *self._format_custom_description(prop)]
 
         descriptor = self._type_descriptor_registry.get_descriptor(prop.type)
-        return [*self._format_property_description(descriptor), *self._format_custom_description(prop)]
-
-    def _format_property_description(self, descriptor: PropertyTypeDescriptor) -> list[str]:
+        return [
+            *self._format_property_description(descriptor),
+            *self._format_custom_description(prop),
+        ]
+
+    def _format_property_description(
+        self, descriptor: PropertyTypeDescriptor
+    ) -> list[str]:
         if not descriptor.description:
             return []
         return [f"{self.INDENTATION}{descriptor.description}"]
 
-    async def _format_property_specific_details(self, prop: DataSourceProperty) -> list[str]:
+    async def _format_property_specific_details(
+        self, prop: DataSourceProperty
+    ) -> list[str]:
         if isinstance(prop, DataSourceSelectProperty):
-            return self._format_available_options("Choose one option from", prop.option_names)
+            return self._format_available_options(
+                "Choose one option from", prop.option_names
+            )
 
         if isinstance(prop, DataSourceMultiSelectProperty):
-            return self._format_available_options("Choose multiple options from", prop.option_names)
+            return self._format_available_options(
+                "Choose multiple options from", prop.option_names
+            )
 
         if isinstance(prop, DataSourceStatusProperty):
-            return self._format_available_options("Available statuses", prop.option_names)
+            return self._format_available_options(
+                "Available statuses", prop.option_names
+            )
 
         if isinstance(prop, DataSourceRelationProperty):
             return await self._format_relation_details(prop)
@@ -63,11 +83,15 @@ class PropertyFormatter:
         options_text = ", ".join(options)
         return [f"{self.INDENTATION}{label}: {options_text}"]
 
-    async def _format_relation_details(self, prop: DataSourceRelationProperty) -> list[str]:
+    async def _format_relation_details(
+        self, prop: DataSourceRelationProperty
+    ) -> list[str]:
         if not prop.related_data_source_id:
             return []
 
-        data_source_name = await self._data_source_resolver.resolve_id_to_name(prop.related_data_source_id)
+        data_source_name = await self._data_source_resolver.resolve_id_to_name(
+            prop.related_data_source_id
+        )
         data_source_display = data_source_name or prop.related_data_source_id
         lines = [f"{self.INDENTATION}Links to datasource: {data_source_display}"]
 
@@ -78,7 +102,9 @@ class PropertyFormatter:
 
         return lines
 
-    async def _fetch_relation_entries(self, prop: DataSourceRelationProperty) -> list[str] | None:
+    async def _fetch_relation_entries(
+        self, prop: DataSourceRelationProperty
+    ) -> list[str] | None:
         try:
             return await self._relation_options_fetcher(prop)
         except Exception:
@@ -88,14 +114,22 @@ class PropertyFormatter:
 class DataSourcePropertySchemaFormatter:
     def __init__(
         self,
-        relation_options_fetcher: Callable[[DataSourceRelationProperty], Awaitable[list[str]]] | None = None,
+        relation_options_fetcher: Callable[
+            [DataSourceRelationProperty], Awaitable[list[str]]
+        ]
+        | None = None,
         data_source_resolver: DataSourceNameIdResolver | None = None,
     ) -> None:
         self._property_formatter = PropertyFormatter(
             relation_options_fetcher, data_source_resolver=data_source_resolver
         )
 
-    async def format(self, title: str, description: str | None, properties: dict[str, DataSourceProperty]) -> str:
+    async def format(
+        self,
+        title: str,
+        description: str | None,
+        properties: dict[str, DataSourceProperty],
+    ) -> str:
         lines = self._format_header(title, description)
         lines.append("Properties:")
         lines.append("")
@@ -112,7 +146,9 @@ class DataSourcePropertySchemaFormatter:
 
         return lines
 
-    async def _format_properties(self, properties: dict[str, DataSourceProperty]) -> list[str]:
+    async def _format_properties(
+        self, properties: dict[str, DataSourceProperty]
+    ) -> list[str]:
         lines = []
         sorted_properties = self._sort_with_title_first(properties)
 
@@ -121,14 +157,24 @@ class DataSourcePropertySchemaFormatter:
 
         return lines
 
-    def _sort_with_title_first(self, properties: dict[str, DataSourceProperty]) -> list[tuple[str, DataSourceProperty]]:
-        return sorted(properties.items(), key=lambda item: (self._is_not_title_property(item[1]), item[0]))
+    def _sort_with_title_first(
+        self, properties: dict[str, DataSourceProperty]
+    ) -> list[tuple[str, DataSourceProperty]]:
+        return sorted(
+            properties.items(),
+            key=lambda item: (self._is_not_title_property(item[1]), item[0]),
+        )
 
     def _is_not_title_property(self, prop: DataSourceProperty) -> bool:
         return prop.type != PropertyType.TITLE
 
-    async def _format_single_property(self, index: int, name: str, prop: DataSourceProperty) -> list[str]:
-        lines = [f"{index}. - Property Name: '{name}'", f"   - Property Type: '{prop.type.value}'"]
+    async def _format_single_property(
+        self, index: int, name: str, prop: DataSourceProperty
+    ) -> list[str]:
+        lines = [
+            f"{index}. - Property Name: '{name}'",
+            f"   - Property Type: '{prop.type.value}'",
+        ]
 
         lines.extend(await self._property_formatter.format_property(prop))
         lines.append("")

notionary/data_source/service.py

@@ -4,9 +4,13 @@ import asyncio
 from collections.abc import AsyncIterator, Callable
 from typing import TYPE_CHECKING, Self
 
-from notionary.blocks.rich_text.rich_text_markdown_converter import RichTextToMarkdownConverter
+from notionary.blocks.rich_text.rich_text_markdown_converter import (
+    RichTextToMarkdownConverter,
+)
 from notionary.data_source.http.client import DataSourceClient
-from notionary.data_source.http.data_source_instance_client import DataSourceInstanceClient
+from notionary.data_source.http.data_source_instance_client import (
+    DataSourceInstanceClient,
+)
 from notionary.data_source.properties.schemas import (
     DataSourceMultiSelectProperty,
     DataSourceProperty,
@@ -16,10 +20,17 @@ from notionary.data_source.properties.schemas import (
     DataSourceSelectProperty,
     DataSourceStatusProperty,
 )
-from notionary.data_source.query import DataSourceQueryBuilder, DataSourceQueryParams, QueryResolver
+from notionary.data_source.query import (
+    DataSourceQueryBuilder,
+    DataSourceQueryParams,
+    QueryResolver,
+)
 from notionary.data_source.schema.service import DataSourcePropertySchemaFormatter
 from notionary.data_source.schemas import DataSourceDto
-from notionary.exceptions.data_source.properties import DataSourcePropertyNotFound, DataSourcePropertyTypeError
+from notionary.exceptions.data_source.properties import (
+    DataSourcePropertyNotFound,
+    DataSourcePropertyTypeError,
+)
 from notionary.file_upload.service import NotionFileUpload
 from notionary.page.properties.schemas import PageTitleProperty
 from notionary.page.schemas import NotionPageDto
@@ -27,7 +38,9 @@ from notionary.shared.entity.dto_parsers import (
     extract_description,
     extract_title,
 )
-from notionary.shared.entity.entity_metadata_update_client import EntityMetadataUpdateClient
+from notionary.shared.entity.entity_metadata_update_client import (
+    EntityMetadataUpdateClient,
+)
 from notionary.shared.entity.service import Entity
 from notionary.user.service import UserService
 from notionary.workspace.query.service import WorkspaceQueryService
@@ -48,7 +61,9 @@ class NotionDataSource(Entity):
         user_service: UserService | None = None,
         file_upload_service: NotionFileUpload | None = None,
     ) -> None:
-        super().__init__(dto=dto, user_service=user_service, file_upload_service=file_upload_service)
+        super().__init__(
+            dto=dto, user_service=user_service, file_upload_service=file_upload_service
+        )
 
         self._parent_database: NotionDatabase | None = None
         self._title = title
@@ -146,7 +161,9 @@ class NotionDataSource(Entity):
         self._archived = False
 
     async def update_description(self, description: str) -> None:
-        self._description = await self._data_source_client.update_description(description)
+        self._description = await self._data_source_client.update_description(
+            description
+        )
 
     async def get_options_for_property_by_name(self, property_name: str) -> list[str]:
         prop = self._properties.get(property_name)
@@ -169,22 +186,36 @@ class NotionDataSource(Entity):
         return []
 
     def get_select_options_by_property_name(self, property_name: str) -> list[str]:
-        select_prop = self._get_typed_property_or_raise(property_name, DataSourceSelectProperty)
+        select_prop = self._get_typed_property_or_raise(
+            property_name, DataSourceSelectProperty
+        )
         return select_prop.option_names
 
-    def get_multi_select_options_by_property_name(self, property_name: str) -> list[DataSourcePropertyOption]:
-        multi_select_prop = self._get_typed_property_or_raise(property_name, DataSourceMultiSelectProperty)
+    def get_multi_select_options_by_property_name(
+        self, property_name: str
+    ) -> list[DataSourcePropertyOption]:
+        multi_select_prop = self._get_typed_property_or_raise(
+            property_name, DataSourceMultiSelectProperty
+        )
         return multi_select_prop.option_names
 
     def get_status_options_by_property_name(self, property_name: str) -> list[str]:
-        status_prop = self._get_typed_property_or_raise(property_name, DataSourceStatusProperty)
+        status_prop = self._get_typed_property_or_raise(
+            property_name, DataSourceStatusProperty
+        )
         return status_prop.option_names
 
-    async def get_relation_options_by_property_name(self, property_name: str) -> list[str]:
-        relation_prop = self._get_typed_property_or_raise(property_name, DataSourceRelationProperty)
+    async def get_relation_options_by_property_name(
+        self, property_name: str
+    ) -> list[str]:
+        relation_prop = self._get_typed_property_or_raise(
+            property_name, DataSourceRelationProperty
+        )
         return await self._get_relation_options(relation_prop)
 
-    async def _get_relation_options(self, relation_prop: DataSourceRelationProperty) -> list[str]:
+    async def _get_relation_options(
+        self, relation_prop: DataSourceRelationProperty
+    ) -> list[str]:
         related_data_source_id = relation_prop.related_data_source_id
         if not related_data_source_id:
             return []
@@ -205,7 +236,11 @@ class NotionDataSource(Entity):
             return None
 
         title_property = next(
-            (prop for prop in page.properties.values() if isinstance(prop, PageTitleProperty)),
+            (
+                prop
+                for prop in page.properties.values()
+                if isinstance(prop, PageTitleProperty)
+            ),
             None,
         )
 
@@ -214,7 +249,9 @@ class NotionDataSource(Entity):
 
         return "".join(item.plain_text for item in title_property.title)
 
-    def _get_typed_property_or_raise(self, name: str, property_type: type[DataSourcePropertyT]) -> DataSourcePropertyT:
+    def _get_typed_property_or_raise(
+        self, name: str, property_type: type[DataSourcePropertyT]
+    ) -> DataSourcePropertyT:
         prop = self._properties.get(name)
 
         if prop is None:
@@ -225,7 +262,9 @@ class NotionDataSource(Entity):
 
         if not isinstance(prop, property_type):
             raise DataSourcePropertyTypeError(
-                property_name=name, expected_type=property_type.__name__, actual_type=type(prop).__name__
+                property_name=name,
+                expected_type=property_type.__name__,
+                actual_type=type(prop).__name__,
             )
 
         return prop
@@ -236,7 +275,8 @@ class NotionDataSource(Entity):
     async def get_pages(
         self,
         *,
-        filter_fn: Callable[[DataSourceQueryBuilder], DataSourceQueryBuilder] | None = None,
+        filter_fn: Callable[[DataSourceQueryBuilder], DataSourceQueryBuilder]
+        | None = None,
         query_params: DataSourceQueryParams | None = None,
     ) -> list[NotionPage]:
         from notionary import NotionPage
@@ -250,13 +290,16 @@ class NotionDataSource(Entity):
             query_params = configured_builder.build()
 
         resolved_params = await self._resolve_query_params_if_needed(query_params)
-        query_response = await self._data_source_client.query(query_params=resolved_params)
+        query_response = await self._data_source_client.query(
+            query_params=resolved_params
+        )
         return [await NotionPage.from_id(page.id) for page in query_response.results]
 
     async def iter_pages(
         self,
         *,
-        filter_fn: Callable[[DataSourceQueryBuilder], DataSourceQueryBuilder] | None = None,
+        filter_fn: Callable[[DataSourceQueryBuilder], DataSourceQueryBuilder]
+        | None = None,
         query_params: DataSourceQueryParams | None = None,
     ) -> AsyncIterator[NotionPage]:
         from notionary import NotionPage
@@ -271,7 +314,9 @@ class NotionDataSource(Entity):
 
         resolved_params = await self._resolve_query_params_if_needed(query_params)
 
-        async for page in self._data_source_client.query_stream(query_params=resolved_params):
+        async for page in self._data_source_client.query_stream(
+            query_params=resolved_params
+        ):
             yield await NotionPage.from_id(page.id)
 
     async def _resolve_query_params_if_needed(
@@ -284,5 +329,11 @@ class NotionDataSource(Entity):
         return await self.query_resolver.resolve_params(query_params)
 
     async def get_schema_description(self) -> str:
-        formatter = DataSourcePropertySchemaFormatter(relation_options_fetcher=self._get_relation_options)
-        return await formatter.format(title=self._title, description=self._description, properties=self._properties)
+        formatter = DataSourcePropertySchemaFormatter(
+            relation_options_fetcher=self._get_relation_options
+        )
+        return await formatter.format(
+            title=self._title,
+            description=self._description,
+            properties=self._properties,
+        )

notionary/database/client.py

@@ -1,4 +1,6 @@
-from notionary.blocks.rich_text.rich_text_markdown_converter import RichTextToMarkdownConverter
+from notionary.blocks.rich_text.rich_text_markdown_converter import (
+    RichTextToMarkdownConverter,
+)
 from notionary.database.schemas import (
     NotionDatabaseDto,
     NotionDatabaseUpdateDto,
@@ -15,14 +17,20 @@ class NotionDatabaseHttpClient(NotionHttpClient):
         response = await self.get(f"databases/{self._database_id}")
         return NotionDatabaseDto.model_validate(response)
 
-    async def patch_database(self, update_database_dto: NotionDatabaseUpdateDto) -> NotionDatabaseDto:
+    async def patch_database(
+        self, update_database_dto: NotionDatabaseUpdateDto
+    ) -> NotionDatabaseDto:
         update_database_dto_dict = update_database_dto.model_dump(exclude_none=True)
 
-        response = await self.patch(f"databases/{self._database_id}", data=update_database_dto_dict)
+        response = await self.patch(
+            f"databases/{self._database_id}", data=update_database_dto_dict
+        )
         return NotionDatabaseDto.model_validate(response)
 
     async def update_database_title(self, title: str) -> NotionDatabaseDto:
-        from notionary.blocks.rich_text.markdown_rich_text_converter import MarkdownRichTextConverter
+        from notionary.blocks.rich_text.markdown_rich_text_converter import (
+            MarkdownRichTextConverter,
+        )
 
         markdown_rich_text_formatter = MarkdownRichTextConverter()
         database_rich_text = await markdown_rich_text_formatter.to_rich_text(title)
@@ -31,13 +39,23 @@ class NotionDatabaseHttpClient(NotionHttpClient):
         return await self.patch_database(database_title_update_dto)
 
     async def update_database_description(self, description: str) -> str:
-        from notionary.blocks.rich_text.markdown_rich_text_converter import MarkdownRichTextConverter
+        from notionary.blocks.rich_text.markdown_rich_text_converter import (
+            MarkdownRichTextConverter,
+        )
 
         markdown_to_rich_text_converter = MarkdownRichTextConverter()
-        rich_text_description = await markdown_to_rich_text_converter.to_rich_text(description)
+        rich_text_description = await markdown_to_rich_text_converter.to_rich_text(
+            description
+        )
 
-        database_description_update_dto = NotionDatabaseUpdateDto(description=rich_text_description)
-        update_database_response = await self.patch_database(database_description_update_dto)
+        database_description_update_dto = NotionDatabaseUpdateDto(
+            description=rich_text_description
+        )
+        update_database_response = await self.patch_database(
+            database_description_update_dto
+        )
 
         rich_text_to_markdown_converter = RichTextToMarkdownConverter()
-        return await rich_text_to_markdown_converter.to_markdown(update_database_response.description)
+        return await rich_text_to_markdown_converter.to_markdown(
+            update_database_response.description
+        )

notionary/database/database_metadata_update_client.py

@@ -2,7 +2,9 @@ from typing import override
 
 from notionary.database.schemas import NotionDatabaseDto
 from notionary.http.client import NotionHttpClient
-from notionary.shared.entity.entity_metadata_update_client import EntityMetadataUpdateClient
+from notionary.shared.entity.entity_metadata_update_client import (
+    EntityMetadataUpdateClient,
+)
 from notionary.shared.entity.schemas import NotionEntityUpdateDto
 
 
@@ -12,8 +14,14 @@ class DatabaseMetadataUpdateClient(NotionHttpClient, EntityMetadataUpdateClient)
         self._database_id = database_id
 
     @override
-    async def patch_metadata(self, updated_data: NotionEntityUpdateDto) -> NotionDatabaseDto:
-        updated_data_dict = updated_data.model_dump(exclude_unset=True, exclude_none=True)
+    async def patch_metadata(
+        self, updated_data: NotionEntityUpdateDto
+    ) -> NotionDatabaseDto:
+        updated_data_dict = updated_data.model_dump(
+            exclude_unset=True, exclude_none=True
+        )
 
-        response_dict = await self.patch(f"databases/{self._database_id}", data=updated_data_dict)
+        response_dict = await self.patch(
+            f"databases/{self._database_id}", data=updated_data_dict
+        )
         return NotionDatabaseDto.model_validate(response_dict)

notionary/database/service.py

@@ -2,10 +2,14 @@ import asyncio
 from collections.abc import Awaitable, Callable
 from typing import Self
 
-from notionary.blocks.rich_text.rich_text_markdown_converter import RichTextToMarkdownConverter
+from notionary.blocks.rich_text.rich_text_markdown_converter import (
+    RichTextToMarkdownConverter,
+)
 from notionary.data_source.service import NotionDataSource
 from notionary.database.client import NotionDatabaseHttpClient
-from notionary.database.database_metadata_update_client import DatabaseMetadataUpdateClient
+from notionary.database.database_metadata_update_client import (
+    DatabaseMetadataUpdateClient,
+)
 from notionary.database.schemas import NotionDatabaseDto
 from notionary.shared.entity.dto_parsers import (
     extract_description,
@@ -71,7 +75,8 @@ class NotionDatabase(Entity):
         client: NotionDatabaseHttpClient,
     ) -> Self:
         title, description = await asyncio.gather(
-            extract_title(dto, rich_text_converter), extract_description(dto, rich_text_converter)
+            extract_title(dto, rich_text_converter),
+            extract_description(dto, rich_text_converter),
         )
 
         metadata_update_client = DatabaseMetadataUpdateClient(database_id=dto.id)
@@ -120,5 +125,7 @@ class NotionDatabase(Entity):
         self._title = result.title[0].plain_text if result.title else ""
 
     async def set_description(self, description: str) -> None:
-        updated_description = await self.client.update_database_description(description=description)
+        updated_description = await self.client.update_database_description(
+            description=description
+        )
         self._description = updated_description

notionary/exceptions/__init__.py

@@ -8,10 +8,22 @@ from .api import (
     NotionValidationError,
 )
 from .base import NotionaryException
-from .block_parsing import InsufficientColumnsError, InvalidColumnRatioSumError, UnsupportedVideoFormatError
+from .block_parsing import (
+    InsufficientColumnsError,
+    InvalidColumnRatioSumError,
+    UnsupportedVideoFormatError,
+)
 from .data_source import DataSourcePropertyNotFound, DataSourcePropertyTypeError
-from .file_upload import FileSizeException, NoFileExtensionException, UnsupportedFileTypeException
-from .properties import AccessPagePropertyWithoutDataSourceError, PagePropertyNotFoundError, PagePropertyTypeError
+from .file_upload import (
+    FileSizeException,
+    NoFileExtensionException,
+    UnsupportedFileTypeException,
+)
+from .properties import (
+    AccessPagePropertyWithoutDataSourceError,
+    PagePropertyNotFoundError,
+    PagePropertyTypeError,
+)
 from .search import DatabaseNotFound, DataSourceNotFound, EntityNotFound, PageNotFound
 
 __all__ = [

notionary/exceptions/block_parsing.py

@@ -6,14 +6,18 @@ RATIO_TOLERANCE = 0.0001
 class InsufficientColumnsError(NotionaryException):
     def __init__(self, column_count: int) -> None:
         self.column_count = column_count
-        super().__init__(f"Columns container must contain at least 2 column blocks, but only {column_count} found")
+        super().__init__(
+            f"Columns container must contain at least 2 column blocks, but only {column_count} found"
+        )
 
 
 class InvalidColumnRatioSumError(NotionaryException):
     def __init__(self, total: float, tolerance: float = RATIO_TOLERANCE) -> None:
         self.total = total
         self.tolerance = tolerance
-        super().__init__(f"Width ratios must sum to 1.0 (±{tolerance}), but sum is {total}")
+        super().__init__(
+            f"Width ratios must sum to 1.0 (±{tolerance}), but sum is {total}"
+        )
 
 
 class UnsupportedVideoFormatError(ValueError):

notionary/exceptions/data_source/builder.py

@@ -67,7 +67,11 @@ class MissingRequiredValue(QueryBuilderError):
     def __init__(
         self,
         property_name: str,
-        operator: StringOperator | NumberOperator | BooleanOperator | DateOperator | ArrayOperator,
+        operator: StringOperator
+        | NumberOperator
+        | BooleanOperator
+        | DateOperator
+        | ArrayOperator,
     ) -> None:
         self.operator = operator
 
@@ -79,7 +83,11 @@ class ValueNotAllowedForOperator(QueryBuilderError):
     def __init__(
         self,
         property_name: str,
-        operator: StringOperator | NumberOperator | BooleanOperator | DateOperator | ArrayOperator,
+        operator: StringOperator
+        | NumberOperator
+        | BooleanOperator
+        | DateOperator
+        | ArrayOperator,
     ) -> None:
         self.operator = operator
 
@@ -144,9 +152,7 @@ class NoPropertySelected(QueryBuilderError):
 
 class EmptyOrGroupError(QueryBuilderError):
     def __init__(self) -> None:
-        message = (
-            "Cannot create an OR group with no conditions. Add at least one filter condition before using .or_where()"
-        )
+        message = "Cannot create an OR group with no conditions. Add at least one filter condition before using .or_where()"
         super().__init__(message)
 
 

notionary/exceptions/data_source/properties.py

@@ -29,6 +29,8 @@ class DataSourcePropertyNotFound(NotionaryException):
 
 
 class DataSourcePropertyTypeError(NotionaryException):
-    def __init__(self, property_name: str, expected_type: str, actual_type: str) -> None:
+    def __init__(
+        self, property_name: str, expected_type: str, actual_type: str
+    ) -> None:
         message = f"Property '{property_name}' has the wrong type. Expected: '{expected_type}', found: '{actual_type}'."
         super().__init__(message)