notionary 0.3.0__py3-none-any.whl → 0.3.1__py3-none-any.whl

notionary/__init__.py

@@ -2,6 +2,13 @@ from .data_source.service import NotionDataSource
 from .database.service import NotionDatabase
 from .page.content.markdown.builder import MarkdownBuilder
 from .page.service import NotionPage
-from .workspace import NotionWorkspace
+from .workspace import NotionWorkspace, NotionWorkspaceQueryConfigBuilder
 
-__all__ = ["MarkdownBuilder", "NotionDataSource", "NotionDatabase", "NotionPage", "NotionWorkspace", "NotionWorkspace"]
+__all__ = [
+    "MarkdownBuilder",
+    "NotionDataSource",
+    "NotionDatabase",
+    "NotionPage",
+    "NotionWorkspace",
+    "NotionWorkspaceQueryConfigBuilder",
+]

notionary/blocks/enums.py

@@ -165,3 +165,30 @@ class CodingLanguage(StrEnum):
                 return member
 
         return default if default is not None else cls.PLAIN_TEXT
+
+
+class VideoFileType(StrEnum):
+    AMV = ".amv"
+    ASF = ".asf"
+    AVI = ".avi"
+    F4V = ".f4v"
+    FLV = ".flv"
+    GIFV = ".gifv"
+    MKV = ".mkv"
+    MOV = ".mov"
+    MPG = ".mpg"
+    MPEG = ".mpeg"
+    MPV = ".mpv"
+    MP4 = ".mp4"
+    M4V = ".m4v"
+    QT = ".qt"
+    WMV = ".wmv"
+
+    @classmethod
+    def get_all_extensions(cls) -> set[str]:
+        return {ext.value for ext in cls}
+
+    @classmethod
+    def is_valid_extension(cls, filename: str) -> bool:
+        lower_filename = filename.lower()
+        return any(lower_filename.endswith(ext.value) for ext in cls)

notionary/comments/client.py

@@ -18,20 +18,17 @@ class CommentClient(NotionHttpClient):
     async def iter_comments(
         self,
         block_id: str,
-        *,
-        page_size: int = 100,
+        total_results_limit: int | None = None,
     ) -> AsyncGenerator[CommentDto]:
-        """
-        Iterates through all comments for a block, yielding each comment individually.
-        Uses pagination to handle large result sets efficiently without loading everything into memory.
-        """
         async for comment in paginate_notion_api_generator(
-            self._list_comments_page, block_id=block_id, page_size=page_size
+            self._list_comments_page, block_id=block_id, total_results_limit=total_results_limit
         ):
             yield comment
 
-    async def get_all_comments(self, block_id: str, *, page_size: int = 100) -> list[CommentDto]:
-        all_comments = await paginate_notion_api(self._list_comments_page, block_id=block_id, page_size=page_size)
+    async def get_all_comments(self, block_id: str, *, total_results_limit: int | None = None) -> list[CommentDto]:
+        all_comments = await paginate_notion_api(
+            self._list_comments_page, block_id=block_id, total_results_limit=total_results_limit
+        )
 
         self.logger.debug("Retrieved %d total comments for block %s", len(all_comments), block_id)
         return all_comments

notionary/data_source/http/data_source_instance_client.py

@@ -58,10 +58,10 @@ class DataSourceInstanceClient(NotionHttpClient, EntityMetadataUpdateClient):
 
     async def query(self, query_params: DataSourceQueryParams | None = None) -> QueryDataSourceResponse:
         query_params_dict = query_params.to_api_params() if query_params else {}
-        page_size = query_params.page_size if query_params else None
+        total_result_limit = query_params.total_results_limit if query_params else None
 
         all_results = await paginate_notion_api(
-            self._make_query_request, query_data=query_params_dict or {}, page_size=page_size
+            self._make_query_request, query_data=query_params_dict or {}, total_result_limit=total_result_limit
         )
 
         return QueryDataSourceResponse(
@@ -72,10 +72,10 @@ class DataSourceInstanceClient(NotionHttpClient, EntityMetadataUpdateClient):
 
     async def query_stream(self, query_params: DataSourceQueryParams | None = None) -> AsyncIterator[Any]:
         query_params_dict = query_params.model_dump() if query_params else {}
-        page_size = query_params.page_size if query_params else None
+        total_result_limit = query_params.total_results_limit if query_params else None
 
         async for result in paginate_notion_api_generator(
-            self._make_query_request, query_data=query_params_dict or {}, page_size=page_size
+            self._make_query_request, query_data=query_params_dict or {}, total_results_limit=total_result_limit
         ):
             yield result
 

notionary/data_source/query/__init__.py

@@ -0,0 +1,9 @@
+from .builder import DataSourceQueryBuilder
+from .resolver import QueryResolver
+from .schema import DataSourceQueryParams
+
+__all__ = [
+    "DataSourceQueryBuilder",
+    "DataSourceQueryParams",
+    "QueryResolver",
+]

notionary/data_source/query/builder.py

@@ -46,6 +46,7 @@ class DataSourceQueryBuilder:
         self._negate_next = False
         self._or_group: list[FilterCondition] | None = None
         self._page_size: int | None = None
+        self._total_results_limit: int | None = None
 
     def where(self, property_name: str) -> Self:
         self._finalize_current_or_group()
@@ -193,9 +194,15 @@ class DataSourceQueryBuilder:
         self._sorts.append(sort)
         return self
 
-    def limit(self, page_size: int) -> Self:
-        if page_size < 1:
+    def total_results_limit(self, total_result_limit: int) -> Self:
+        if total_result_limit < 1:
             raise ValueError("Limit must be at least 1")
+        self._total_results_limit = total_result_limit
+        return self
+
+    def page_size(self, page_size: int) -> Self:
+        if page_size < 1:
+            raise ValueError("Page size must be at least 1")
         self._page_size = page_size
         return self
 
@@ -203,7 +210,9 @@ class DataSourceQueryBuilder:
         self._finalize_current_or_group()
         notion_filter = self._create_notion_filter_if_needed()
         sorts = self._create_sorts_if_needed()
-        return DataSourceQueryParams(filter=notion_filter, sorts=sorts, page_size=self._page_size)
+        return DataSourceQueryParams(
+            filter=notion_filter, sorts=sorts, page_size=self._page_size, total_results_limit=self._total_results_limit
+        )
 
     def _select_property_without_negation(self, property_name: str) -> None:
         self._current_property = property_name

notionary/data_source/query/schema.py

@@ -289,6 +289,8 @@ class DataSourceQueryParams(BaseModel):
     sorts: list[NotionSort] | None = None
     page_size: int | None = None
 
+    total_results_limit: int | None = None
+
     @model_serializer
     def to_api_params(self) -> JsonDict:
         result: JsonDict = {}
@@ -299,4 +301,7 @@ class DataSourceQueryParams(BaseModel):
         if self.sorts is not None and len(self.sorts) > 0:
             result["sorts"] = [sort.model_dump() for sort in self.sorts]
 
+        if self.page_size is not None:
+            result["page_size"] = self.page_size
+
         return result

notionary/data_source/service.py

@@ -16,27 +16,18 @@ from notionary.data_source.properties.schemas import (
     DataSourceSelectProperty,
     DataSourceStatusProperty,
 )
-from notionary.data_source.query.builder import DataSourceQueryBuilder
-from notionary.data_source.query.resolver import QueryResolver
-from notionary.data_source.query.schema import (
-    DataSourceQueryParams,
-)
+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.page.properties.models import PageTitleProperty
 from notionary.page.schemas import NotionPageDto
 from notionary.shared.entity.dto_parsers import (
-    extract_cover_image_url_from_dto,
-    extract_database_id,
     extract_description,
-    extract_emoji_icon_from_dto,
-    extract_external_icon_url_from_dto,
     extract_title,
 )
 from notionary.shared.entity.entity_metadata_update_client import EntityMetadataUpdateClient
 from notionary.shared.entity.service import Entity
-from notionary.user.schemas import PartialUserDto
 from notionary.workspace.query.service import WorkspaceQueryService
 
 if TYPE_CHECKING:
@@ -46,45 +37,21 @@ if TYPE_CHECKING:
 class NotionDataSource(Entity):
     def __init__(
         self,
-        id: str,
+        dto: DataSourceDto,
         title: str,
-        created_time: str,
-        created_by: PartialUserDto,
-        last_edited_time: str,
-        last_edited_by: PartialUserDto,
-        archived: bool,
-        in_trash: bool,
-        url: str,
+        description: str | None,
         properties: dict[str, DataSourceProperty],
-        parent_database_id: str | None,
-        emoji_icon: str | None = None,
-        external_icon_url: str | None = None,
-        cover_image_url: str | None = None,
-        description: str | None = None,
-        public_url: str | None = None,
-        data_source_instance_client: DataSourceInstanceClient | None = None,
+        data_source_instance_client: DataSourceInstanceClient,
         query_resolver: QueryResolver | None = None,
     ) -> None:
-        super().__init__(
-            id=id,
-            created_time=created_time,
-            created_by=created_by,
-            last_edited_time=last_edited_time,
-            last_edited_by=last_edited_by,
-            in_trash=in_trash,
-            emoji_icon=emoji_icon,
-            external_icon_url=external_icon_url,
-            cover_image_url=cover_image_url,
-        )
-        self._parent_database_id = parent_database_id
+        super().__init__(dto=dto)
+
         self._parent_database: NotionDatabase | None = None
         self._title = title
-        self._archived = archived
-        self._url = url
-        self._public_url = public_url
+        self._archived = dto.archived
         self._description = description
         self._properties = properties or {}
-        self._data_source_client = data_source_instance_client or DataSourceInstanceClient(data_source_id=id)
+        self._data_source_client = data_source_instance_client
         self.query_resolver = query_resolver or QueryResolver()
 
     @classmethod
@@ -111,73 +78,21 @@ class NotionDataSource(Entity):
     @classmethod
     async def _create_from_dto(
         cls,
-        response: DataSourceDto,
+        dto: DataSourceDto,
         rich_text_converter: RichTextToMarkdownConverter,
     ) -> Self:
         title, description = await asyncio.gather(
-            extract_title(response, rich_text_converter),
-            extract_description(response, rich_text_converter),
+            extract_title(dto, rich_text_converter),
+            extract_description(dto, rich_text_converter),
         )
 
-        parent_database_id = extract_database_id(response)
+        data_source_instance_client = DataSourceInstanceClient(data_source_id=dto.id)
 
-        return cls._create(
-            id=response.id,
-            title=title,
-            description=description,
-            created_time=response.created_time,
-            created_by=response.created_by,
-            last_edited_time=response.last_edited_time,
-            last_edited_by=response.last_edited_by,
-            archived=response.archived,
-            in_trash=response.in_trash,
-            url=response.url,
-            properties=response.properties,
-            parent_database_id=parent_database_id,
-            emoji_icon=extract_emoji_icon_from_dto(response),
-            external_icon_url=extract_external_icon_url_from_dto(response),
-            cover_image_url=extract_cover_image_url_from_dto(response),
-            public_url=response.url,
-        )
-
-    @classmethod
-    def _create(
-        cls,
-        id: str,
-        title: str,
-        created_time: str,
-        created_by: PartialUserDto,
-        last_edited_time: str,
-        last_edited_by: PartialUserDto,
-        archived: bool,
-        in_trash: bool,
-        url: str,
-        properties: dict[str, DataSourceProperty],
-        parent_database_id: str | None,
-        emoji_icon: str | None = None,
-        external_icon_url: str | None = None,
-        cover_image_url: str | None = None,
-        description: str | None = None,
-        public_url: str | None = None,
-    ) -> Self:
-        data_source_instance_client = DataSourceInstanceClient(data_source_id=id)
         return cls(
-            id=id,
+            dto=dto,
             title=title,
-            created_time=created_time,
-            created_by=created_by,
-            last_edited_time=last_edited_time,
-            last_edited_by=last_edited_by,
-            archived=archived,
-            in_trash=in_trash,
-            url=url,
-            parent_database_id=parent_database_id,
-            emoji_icon=emoji_icon,
-            external_icon_url=external_icon_url,
-            cover_image_url=cover_image_url,
             description=description,
-            public_url=public_url,
-            properties=properties,
+            properties=dto.properties,
             data_source_instance_client=data_source_instance_client,
         )
 
@@ -201,19 +116,6 @@ class NotionDataSource(Entity):
     def properties(self) -> dict[str, DataSourceProperty]:
         return self._properties
 
-    @property
-    def url(self) -> str:
-        return self._url
-
-    @property
-    def public_url(self) -> str | None:
-        return self._public_url
-
-    async def get_parent_database(self) -> NotionDatabase | None:
-        if self._parent_database is None and self._parent_database_id:
-            self._parent_database = await NotionDatabase.from_id(self._parent_database_id)
-        return self._parent_database
-
     async def create_blank_page(self, title: str | None = None) -> NotionPage:
         return await self._data_source_client.create_blank_page(title=title)
 

notionary/database/service.py

@@ -10,14 +10,10 @@ from notionary.database.client import NotionDatabaseHttpClient
 from notionary.database.database_metadata_update_client import DatabaseMetadataUpdateClient
 from notionary.database.schemas import NotionDatabaseDto
 from notionary.shared.entity.dto_parsers import (
-    extract_cover_image_url_from_dto,
     extract_description,
-    extract_emoji_icon_from_dto,
-    extract_external_icon_url_from_dto,
     extract_title,
 )
 from notionary.shared.entity.service import Entity
-from notionary.user.schemas import PartialUserDto
 from notionary.workspace.query.service import WorkspaceQueryService
 
 type DataSourceFactory = Callable[[str], Awaitable[NotionDataSource]]
@@ -26,46 +22,24 @@ type DataSourceFactory = Callable[[str], Awaitable[NotionDataSource]]
 class NotionDatabase(Entity):
     def __init__(
         self,
-        id: str,
+        dto: NotionDatabaseDto,
         title: str,
-        created_time: str,
-        created_by: PartialUserDto,
-        last_edited_time: str,
-        last_edited_by: PartialUserDto,
-        url: str,
-        in_trash: bool,
-        is_inline: bool,
+        description: str | None,
         data_source_ids: list[str],
-        public_url: str | None = None,
-        emoji_icon: str | None = None,
-        external_icon_url: str | None = None,
-        cover_image_url: str | None = None,
-        description: str | None = None,
-        client: NotionDatabaseHttpClient | None = None,
-        metadata_update_client: DatabaseMetadataUpdateClient | None = None,
+        client: NotionDatabaseHttpClient,
+        metadata_update_client: DatabaseMetadataUpdateClient,
     ) -> None:
-        super().__init__(
-            id=id,
-            created_time=created_time,
-            created_by=created_by,
-            last_edited_time=last_edited_time,
-            last_edited_by=last_edited_by,
-            in_trash=in_trash,
-            emoji_icon=emoji_icon,
-            external_icon_url=external_icon_url,
-            cover_image_url=cover_image_url,
-        )
+        super().__init__(dto=dto)
+
         self._title = title
-        self._url = url
-        self._public_url = public_url
         self._description = description
-        self._is_inline = is_inline
+        self._is_inline = dto.is_inline
 
         self._data_sources: list[NotionDataSource] | None = None
         self._data_source_ids = data_source_ids
 
-        self.client = client or NotionDatabaseHttpClient(database_id=id)
-        self._metadata_update_client = metadata_update_client or DatabaseMetadataUpdateClient(database_id=id)
+        self.client = client
+        self._metadata_update_client = metadata_update_client
 
     @classmethod
     async def from_id(
@@ -94,31 +68,23 @@ class NotionDatabase(Entity):
     @classmethod
     async def _create_from_dto(
         cls,
-        response: NotionDatabaseDto,
+        dto: NotionDatabaseDto,
         rich_text_converter: RichTextToMarkdownConverter,
         client: NotionDatabaseHttpClient,
     ) -> Self:
         title, description = await asyncio.gather(
-            extract_title(response, rich_text_converter), extract_description(response, rich_text_converter)
+            extract_title(dto, rich_text_converter), extract_description(dto, rich_text_converter)
         )
 
+        metadata_update_client = DatabaseMetadataUpdateClient(database_id=dto.id)
+
         return cls(
-            id=response.id,
+            dto=dto,
             title=title,
             description=description,
-            created_time=response.created_time,
-            created_by=response.created_by,
-            last_edited_time=response.last_edited_time,
-            last_edited_by=response.last_edited_by,
-            in_trash=response.in_trash,
-            is_inline=response.is_inline,
-            url=response.url,
-            public_url=response.public_url,
-            emoji_icon=extract_emoji_icon_from_dto(response),
-            external_icon_url=extract_external_icon_url_from_dto(response),
-            cover_image_url=extract_cover_image_url_from_dto(response),
-            data_source_ids=[ds.id for ds in response.data_sources],
+            data_source_ids=[ds.id for ds in dto.data_sources],
             client=client,
+            metadata_update_client=metadata_update_client,
         )
 
     @property
@@ -129,14 +95,6 @@ class NotionDatabase(Entity):
     def title(self) -> str:
         return self._title
 
-    @property
-    def url(self) -> str:
-        return self._url
-
-    @property
-    def public_url(self) -> str | None:
-        return self._public_url
-
     @property
     def is_inline(self) -> bool:
         return self._is_inline

notionary/exceptions/__init__.py

@@ -8,6 +8,7 @@ from .api import (
     NotionValidationError,
 )
 from .base import NotionaryError
+from .block_parsing import InsufficientColumnsError, InvalidColumnRatioSumError, UnsupportedVideoFormatError
 from .data_source import DataSourcePropertyNotFound, DataSourcePropertyTypeError
 from .properties import AccessPagePropertyWithoutDataSourceError, PagePropertyNotFoundError, PagePropertyTypeError
 from .search import DatabaseNotFound, DataSourceNotFound, EntityNotFound, PageNotFound
@@ -19,6 +20,8 @@ __all__ = [
     "DataSourcePropertyTypeError",
     "DatabaseNotFound",
     "EntityNotFound",
+    "InsufficientColumnsError",
+    "InvalidColumnRatioSumError",
     "NotionApiError",
     "NotionAuthenticationError",
     "NotionConnectionError",
@@ -30,4 +33,5 @@ __all__ = [
     "PageNotFound",
     "PagePropertyNotFoundError",
     "PagePropertyTypeError",
+    "UnsupportedVideoFormatError",
 ]

notionary/exceptions/block_parsing.py

@@ -14,3 +14,24 @@ class InvalidColumnRatioSumError(NotionaryError):
         self.total = total
         self.tolerance = tolerance
         super().__init__(f"Width ratios must sum to 1.0 (±{tolerance}), but sum is {total}")
+
+
+class UnsupportedVideoFormatError(ValueError):
+    def __init__(self, url: str, supported_formats: list[str]) -> None:
+        self.url = url
+        self.supported_formats = supported_formats
+        super().__init__(self._create_user_friendly_message())
+
+    def _create_user_friendly_message(self) -> str:
+        formats = ", ".join(self.supported_formats[:5])
+        remaining = len(self.supported_formats) - 5
+
+        if remaining > 0:
+            formats += f" and {remaining} more"
+
+        return (
+            f"The video URL '{self.url}' uses an unsupported format.\n"
+            f"Supported formats include: {formats}.\n"
+            f"YouTube embed and watch URLs are also supported."
+            f"Also see https://developers.notion.com/reference/block#video for more information."
+        )

notionary/http/client.py

@@ -158,7 +158,7 @@ class NotionHttpClient(LoggingMixin):
             )
         if status_code == 404:
             raise NotionResourceNotFoundError(
-                "The requested resource was not found. Please verify the page/database ID.",
+                "The requested resource was not found. Please verify the page/database/datasource ID.",
                 status_code=status_code,
                 response_text=response_text,
             )

notionary/page/content/factory.py

@@ -5,6 +5,7 @@ from notionary.page.content.parser.post_processing.service import BlockPostProce
 from notionary.page.content.parser.pre_processsing.handlers import (
     ColumnSyntaxPreProcessor,
     IndentationNormalizer,
+    VideoFormatPreProcessor,
     WhitespacePreProcessor,
 )
 from notionary.page.content.parser.pre_processsing.service import MarkdownPreProcessor
@@ -60,6 +61,7 @@ class PageContentServiceFactory:
         pre_processor.register(ColumnSyntaxPreProcessor())
         pre_processor.register(WhitespacePreProcessor())
         pre_processor.register(IndentationNormalizer())
+        pre_processor.register(VideoFormatPreProcessor())
         return pre_processor
 
     def _create_post_processor(self) -> BlockPostProcessor:

notionary/page/content/parser/pre_processsing/handlers/__init__.py

@@ -1,11 +1,13 @@
 from .column_syntax import ColumnSyntaxPreProcessor
 from .indentation import IndentationNormalizer
 from .port import PreProcessor
+from .video_syntax import VideoFormatPreProcessor
 from .whitespace import WhitespacePreProcessor
 
 __all__ = [
     "ColumnSyntaxPreProcessor",
     "IndentationNormalizer",
     "PreProcessor",
+    "VideoFormatPreProcessor",
     "WhitespacePreProcessor",
 ]

notionary/page/content/parser/pre_processsing/handlers/column_syntax.py

@@ -4,13 +4,14 @@ from typing import override
 from notionary.exceptions.block_parsing import InsufficientColumnsError, InvalidColumnRatioSumError
 from notionary.page.content.parser.pre_processsing.handlers.port import PreProcessor
 from notionary.page.content.syntax import MarkdownGrammar, SyntaxRegistry
+from notionary.utils.decorators import time_execution_sync
 from notionary.utils.mixins.logging import LoggingMixin
 
-RATIO_TOLERANCE = 0.0001
-MINIMUM_COLUMNS = 2
-
 
 class ColumnSyntaxPreProcessor(PreProcessor, LoggingMixin):
+    _RATIO_TOLERANCE = 0.0001
+    _MINIMUM_COLUMNS = 2
+
     def __init__(
         self, syntax_registry: SyntaxRegistry | None = None, markdown_grammar: MarkdownGrammar | None = None
     ) -> None:
@@ -24,6 +25,7 @@ class ColumnSyntaxPreProcessor(PreProcessor, LoggingMixin):
         self._column_pattern = self._syntax_registry.get_column_syntax().regex_pattern
 
     @override
+    @time_execution_sync()
     def process(self, markdown_text: str) -> str:
         if not self._contains_column_lists(markdown_text):
             return markdown_text
@@ -96,8 +98,10 @@ class ColumnSyntaxPreProcessor(PreProcessor, LoggingMixin):
         return list(self._column_pattern.finditer(content))
 
     def _validate_minimum_column_count(self, column_count: int) -> None:
-        if column_count < MINIMUM_COLUMNS:
-            self.logger.error(f"Column list must contain at least {MINIMUM_COLUMNS} columns, found {column_count}")
+        if column_count < self._MINIMUM_COLUMNS:
+            self.logger.error(
+                f"Column list must contain at least {self._MINIMUM_COLUMNS} columns, found {column_count}"
+            )
             raise InsufficientColumnsError(column_count)
 
     def _extract_column_ratios(self, column_matches: list[re.Match]) -> list[float]:
@@ -120,11 +124,11 @@ class ColumnSyntaxPreProcessor(PreProcessor, LoggingMixin):
         total_ratio = sum(ratios)
 
         if not self._is_ratio_sum_valid(total_ratio):
-            self.logger.error(f"Column ratios must sum to 1.0 (±{RATIO_TOLERANCE}), but sum to {total_ratio:.4f}")
-            raise InvalidColumnRatioSumError(total_ratio, RATIO_TOLERANCE)
+            self.logger.error(f"Column ratios must sum to 1.0 (±{self._RATIO_TOLERANCE}), but sum to {total_ratio:.4f}")
+            raise InvalidColumnRatioSumError(total_ratio, self._RATIO_TOLERANCE)
 
     def _should_validate_ratios(self, ratios: list[float], column_count: int) -> bool:
         return len(ratios) > 0 and len(ratios) == column_count
 
     def _is_ratio_sum_valid(self, total: float) -> bool:
-        return abs(total - 1.0) <= RATIO_TOLERANCE
+        return abs(total - 1.0) <= self._RATIO_TOLERANCE

notionary/page/content/parser/pre_processsing/handlers/indentation.py

@@ -3,6 +3,7 @@ from typing import override
 
 from notionary.page.content.parser.pre_processsing.handlers.port import PreProcessor
 from notionary.page.content.syntax import MarkdownGrammar, SyntaxRegistry
+from notionary.utils.decorators import time_execution_sync
 from notionary.utils.mixins.logging import LoggingMixin
 
 
@@ -18,6 +19,7 @@ class IndentationNormalizer(PreProcessor, LoggingMixin):
         self._code_block_start_delimiter = self._syntax_registry.get_code_syntax().start_delimiter
 
     @override
+    @time_execution_sync()
     def process(self, markdown_text: str) -> str:
         if self._is_empty(markdown_text):
             return ""