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

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

@@ -1,9 +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

@@ -3,78 +3,132 @@ 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.service import SyntaxRegistry
+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
 
+class ColumnSyntaxPreProcessor(PreProcessor, LoggingMixin):
+    _RATIO_TOLERANCE = 0.0001
+    _MINIMUM_COLUMNS = 2
 
-class ColumnSyntaxPreProcessor(PreProcessor):
-    def __init__(self, syntax_registry: SyntaxRegistry | None = None) -> None:
+    def __init__(
+        self, syntax_registry: SyntaxRegistry | None = None, markdown_grammar: MarkdownGrammar | None = None
+    ) -> None:
+        super().__init__()
         self._syntax_registry = syntax_registry or SyntaxRegistry()
-        self._column_list_syntax = self._syntax_registry.get_column_list_syntax()
-        self._column_syntax = self._syntax_registry.get_column_syntax()
+        self._markdown_grammar = markdown_grammar or MarkdownGrammar()
+
+        self._spaces_per_nesting_level = self._markdown_grammar.spaces_per_nesting_level
+        self._column_list_delimiter = self._syntax_registry.get_column_list_syntax().start_delimiter
+        self._column_delimiter = self._syntax_registry.get_column_syntax().start_delimiter
+        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._has_columns_blocks(markdown_text):
+        if not self._contains_column_lists(markdown_text):
             return markdown_text
 
-        columns_blocks = self._extract_columns_blocks(markdown_text)
-
-        for content in columns_blocks:
-            column_matches = self._find_column_blocks(content)
-            column_count = len(column_matches)
-            self._validate_minimum_columns(column_count)
-            ratios = self._extract_ratios(column_matches)
-            self._validate_ratios(ratios, column_count)
+        self._validate_all_column_lists(markdown_text)
         return markdown_text
 
-    def _has_columns_blocks(self, markdown_text: str) -> bool:
-        return self._column_list_syntax.start_delimiter in markdown_text
+    def _contains_column_lists(self, markdown_text: str) -> bool:
+        return self._column_list_delimiter in markdown_text
+
+    def _validate_all_column_lists(self, markdown_text: str) -> None:
+        column_list_blocks = self._extract_column_list_blocks(markdown_text)
+
+        for block in column_list_blocks:
+            self._validate_column_list_block(block)
 
-    def _extract_columns_blocks(self, markdown_text: str) -> list[str]:
-        columns_blocks = []
+    def _extract_column_list_blocks(self, markdown_text: str) -> list[str]:
         lines = markdown_text.split("\n")
+        blocks = []
+
         for index, line in enumerate(lines):
-            if line.strip() == self._column_list_syntax.start_delimiter:
-                content = self._extract_block_content(lines, index + 1)
-                if content is not None:
-                    columns_blocks.append(content)
-        return columns_blocks
-
-    def _extract_block_content(self, lines: list[str], start_index: int) -> str | None:
-        depth = 1
-        end_index = start_index
-        block_start = self._column_list_syntax.start_delimiter.split()[0]
-        while end_index < len(lines) and depth > 0:
-            line = lines[end_index].strip()
-            if line.startswith(f"{block_start} "):
-                depth += 1
-            elif line == self._column_list_syntax.end_delimiter:
-                depth -= 1
-            end_index += 1
-        if depth == 0:
-            return "\n".join(lines[start_index : end_index - 1])
-        return None
-
-    def _find_column_blocks(self, content: str) -> list[re.Match]:
-        return list(self._column_syntax.regex_pattern.finditer(content))
-
-    def _validate_minimum_columns(self, column_count: int) -> None:
-        if column_count < 2:
+            if self._is_column_list_start(line):
+                block_content = self._extract_indented_block(lines, index + 1)
+                blocks.append(block_content)
+
+        return blocks
+
+    def _is_column_list_start(self, line: str) -> bool:
+        return line.strip() == self._column_list_delimiter
+
+    def _extract_indented_block(self, lines: list[str], start_index: int) -> str:
+        if start_index >= len(lines):
+            return ""
+
+        base_indentation = self._get_indentation_level(lines[start_index])
+        base_spaces = base_indentation * self._spaces_per_nesting_level
+        block_lines = []
+
+        for line in lines[start_index:]:
+            if self._is_empty_line(line):
+                block_lines.append(line)
+                continue
+
+            current_indentation = self._get_indentation_level(line)
+
+            if current_indentation < base_indentation:
+                break
+
+            block_lines.append(line[base_spaces:] if len(line) >= base_spaces else line)
+
+        return "\n".join(block_lines)
+
+    def _is_empty_line(self, line: str) -> bool:
+        return not line.strip()
+
+    def _get_indentation_level(self, line: str) -> int:
+        leading_spaces = len(line) - len(line.lstrip())
+        return leading_spaces // self._spaces_per_nesting_level
+
+    def _validate_column_list_block(self, block_content: str) -> None:
+        column_matches = self._find_all_columns(block_content)
+        column_count = len(column_matches)
+
+        self._validate_minimum_column_count(column_count)
+
+        ratios = self._extract_column_ratios(column_matches)
+        self._validate_ratio_sum(ratios, column_count)
+
+    def _find_all_columns(self, content: str) -> list[re.Match]:
+        return list(self._column_pattern.finditer(content))
+
+    def _validate_minimum_column_count(self, column_count: int) -> None:
+        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_ratios(self, column_matches: list[re.Match]) -> list[float]:
+    def _extract_column_ratios(self, column_matches: list[re.Match]) -> list[float]:
         ratios = []
+
         for match in column_matches:
-            ratio_str = match.group(1)
-            if ratio_str and ratio_str != "1":
-                ratios.append(float(ratio_str))
+            ratio_text = match.group(1)
+            if self._has_explicit_ratio(ratio_text):
+                ratios.append(float(ratio_text))
+
         return ratios
 
-    def _validate_ratios(self, ratios: list[float], column_count: int) -> None:
-        if not ratios or len(ratios) != column_count:
+    def _has_explicit_ratio(self, ratio_text: str | None) -> bool:
+        return ratio_text is not None and ratio_text != "1"
+
+    def _validate_ratio_sum(self, ratios: list[float], column_count: int) -> None:
+        if not self._should_validate_ratios(ratios, column_count):
             return
-        total = sum(ratios)
-        if abs(total - 1.0) > RATIO_TOLERANCE:
-            raise InvalidColumnRatioSumError(total, RATIO_TOLERANCE)
+
+        total_ratio = sum(ratios)
+
+        if not self._is_ratio_sum_valid(total_ratio):
+            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) <= self._RATIO_TOLERANCE

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

@@ -0,0 +1,86 @@
+import math
+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
+
+
+class IndentationNormalizer(PreProcessor, LoggingMixin):
+    def __init__(
+        self, syntax_registry: SyntaxRegistry | None = None, markdown_grammar: MarkdownGrammar | None = None
+    ) -> None:
+        super().__init__()
+        self._syntax_registry = syntax_registry or SyntaxRegistry()
+        self._markdown_grammar = markdown_grammar or MarkdownGrammar()
+
+        self._spaces_per_nesting_level = self._markdown_grammar.spaces_per_nesting_level
+        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 ""
+
+        normalized = self._normalize_to_markdown_indentation(markdown_text)
+
+        if normalized != markdown_text:
+            self.logger.warning(
+                "Corrected non-standard indentation. Check the result for formatting errors and use consistent indentation in the source."
+            )
+
+        return normalized
+
+    def _is_empty(self, text: str) -> bool:
+        return not text
+
+    def _normalize_to_markdown_indentation(self, markdown_text: str) -> str:
+        lines = markdown_text.split("\n")
+        processed_lines = []
+        inside_code_block = False
+
+        for line in lines:
+            if self._is_code_fence(line):
+                inside_code_block = not inside_code_block
+                processed_lines.append(line)
+            elif inside_code_block:
+                processed_lines.append(line)
+            else:
+                processed_lines.append(self._normalize_to_standard_indentation(line))
+
+        return "\n".join(processed_lines)
+
+    def _is_code_fence(self, line: str) -> bool:
+        return line.lstrip().startswith(self._code_block_start_delimiter)
+
+    def _normalize_to_standard_indentation(self, line: str) -> str:
+        if self._is_blank_line(line):
+            return ""
+
+        indentation_level = self._round_to_nearest_indentation_level(line)
+        content = self._extract_content(line)
+
+        return self._build_indented_line(indentation_level, content)
+
+    def _is_blank_line(self, line: str) -> bool:
+        return not line.strip()
+
+    def _round_to_nearest_indentation_level(self, line: str) -> int:
+        leading_spaces = self._count_leading_spaces(line)
+        return math.ceil(leading_spaces / self._spaces_per_nesting_level)
+
+    def _count_leading_spaces(self, line: str) -> int:
+        return len(line) - len(line.lstrip())
+
+    def _extract_content(self, line: str) -> str:
+        return line.lstrip()
+
+    def _build_indented_line(self, level: int, content: str) -> str:
+        standard_indent = self._create_standard_indent(level)
+        return standard_indent + content
+
+    def _create_standard_indent(self, level: int) -> str:
+        spaces = level * self._spaces_per_nesting_level
+        return " " * spaces

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

@@ -0,0 +1,66 @@
+import re
+from typing import override
+from urllib.parse import urlparse
+
+from notionary.blocks.enums import VideoFileType
+from notionary.exceptions import UnsupportedVideoFormatError
+from notionary.page.content.parser.pre_processsing.handlers.port import PreProcessor
+from notionary.page.content.syntax import SyntaxRegistry
+from notionary.utils.decorators import time_execution_sync
+from notionary.utils.mixins.logging import LoggingMixin
+
+
+class VideoFormatPreProcessor(PreProcessor, LoggingMixin):
+    YOUTUBE_WATCH_PATTERN = re.compile(r"^https?://(?:www\.)?youtube\.com/watch\?.*v=[\w-]+", re.IGNORECASE)
+    YOUTUBE_EMBED_PATTERN = re.compile(r"^https?://(?:www\.)?youtube\.com/embed/[\w-]+", re.IGNORECASE)
+
+    def __init__(self, syntax_registry: SyntaxRegistry | None = None) -> None:
+        super().__init__()
+        self._syntax_registry = syntax_registry or SyntaxRegistry()
+        self._video_syntax = self._syntax_registry.get_video_syntax()
+
+    @override
+    @time_execution_sync()
+    def process(self, markdown_text: str) -> str:
+        lines = markdown_text.split("\n")
+        validated_lines = [self._validate_or_reject_line(line) for line in lines]
+        return "\n".join(validated_lines)
+
+    def _validate_or_reject_line(self, line: str) -> str:
+        if not self._contains_video_block(line):
+            return line
+
+        url = self._extract_url_from_video_block(line)
+
+        if self._is_supported_video_url(url):
+            return line
+
+        supported_formats = list(VideoFileType.get_all_extensions())
+        raise UnsupportedVideoFormatError(url, supported_formats)
+
+    def _contains_video_block(self, line: str) -> bool:
+        return self._video_syntax.regex_pattern.search(line) is not None
+
+    def _extract_url_from_video_block(self, line: str) -> str:
+        match = self._video_syntax.regex_pattern.search(line)
+        return match.group(1).strip() if match else ""
+
+    def _is_supported_video_url(self, url: str) -> bool:
+        return (
+            self._is_youtube_video(url)
+            or self._has_valid_video_extension(url)
+            or self._url_path_has_valid_extension(url)
+        )
+
+    def _is_youtube_video(self, url: str) -> bool:
+        return bool(self.YOUTUBE_WATCH_PATTERN.match(url) or self.YOUTUBE_EMBED_PATTERN.match(url))
+
+    def _has_valid_video_extension(self, url: str) -> bool:
+        return VideoFileType.is_valid_extension(url)
+
+    def _url_path_has_valid_extension(self, url: str) -> bool:
+        try:
+            parsed_url = urlparse(url)
+            return VideoFileType.is_valid_extension(parsed_url.path.lower())
+        except Exception:
+            return False

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

@@ -1,10 +1,12 @@
 from typing import override
 
 from notionary.page.content.parser.pre_processsing.handlers.port import PreProcessor
+from notionary.utils.decorators import time_execution_sync
 
 
 class WhitespacePreProcessor(PreProcessor):
     @override
+    @time_execution_sync()
     def process(self, markdown_text: str) -> str:
         if not markdown_text:
             return ""
@@ -12,23 +14,34 @@ class WhitespacePreProcessor(PreProcessor):
         lines = markdown_text.split("\n")
         processed_lines = []
         code_block_lines = []
+        non_code_lines = []
         in_code_block = False
 
         for line in lines:
             if self._is_code_fence(line):
                 if in_code_block:
+                    # Format and add code block
                     processed_lines.extend(self._format_code_block(code_block_lines))
                     processed_lines.append("```")
                     code_block_lines = []
                     in_code_block = False
                 else:
+                    # Format accumulated non-code lines before starting code block
+                    if non_code_lines:
+                        processed_lines.extend(self._format_code_block(non_code_lines))
+                        non_code_lines = []
+
                     language = self._extract_language(line)
                     processed_lines.append(f"```{language}")
                     in_code_block = True
             elif in_code_block:
                 code_block_lines.append(line)
             else:
-                processed_lines.append(line.lstrip())
+                non_code_lines.append(line)
+
+        # Format remaining non-code lines at the end
+        if non_code_lines:
+            processed_lines.extend(self._format_code_block(non_code_lines))
 
         return "\n".join(processed_lines)
 
@@ -39,12 +52,6 @@ class WhitespacePreProcessor(PreProcessor):
         return fence_line.lstrip().removeprefix("```").strip()
 
     def _format_code_block(self, lines: list[str]) -> list[str]:
-        """
-        Format code block by removing common leading whitespace.
-
-        Preserves relative indentation between lines.
-        Empty lines are preserved as-is.
-        """
         if not lines:
             return []
 

notionary/page/content/parser/service.py

@@ -33,6 +33,8 @@ class MarkdownToNotionConverter(LoggingMixin):
         parent_stack: list[ParentBlockContext] = []
 
         current_line_index = 0
+        previous_line_was_empty = False
+
         while current_line_index < len(lines):
             line = lines[current_line_index]
 
@@ -42,9 +44,11 @@ class MarkdownToNotionConverter(LoggingMixin):
                 line_index=current_line_index,
                 result_blocks=result_blocks,
                 parent_stack=parent_stack,
+                is_previous_line_empty=previous_line_was_empty,
             )
 
             await self._line_parser.handle(context)
+            previous_line_was_empty = self._is_processed_line_empty(line)
 
             current_line_index += 1 + context.lines_consumed
 
@@ -57,6 +61,7 @@ class MarkdownToNotionConverter(LoggingMixin):
         line_index: int,
         result_blocks: list[BlockCreatePayload],
         parent_stack: list[ParentBlockContext],
+        is_previous_line_empty: bool = False,
     ) -> BlockParsingContext:
         return BlockParsingContext(
             line=line,
@@ -66,4 +71,8 @@ class MarkdownToNotionConverter(LoggingMixin):
             all_lines=lines,
             current_line_index=line_index,
             lines_consumed=0,
+            is_previous_line_empty=is_previous_line_empty,
         )
+
+    def _is_processed_line_empty(self, line: str) -> bool:
+        return line.strip() == ""

notionary/page/content/renderer/context.py

@@ -1,6 +1,7 @@
 from collections.abc import Awaitable, Callable
 
 from notionary.blocks.schemas import Block
+from notionary.page.content.syntax.grammar import MarkdownGrammar
 
 ConvertChildrenCallback = Callable[[list[Block], int], Awaitable[str]]
 
@@ -11,13 +12,15 @@ class MarkdownRenderingContext:
         block: Block,
         indent_level: int,
         convert_children_callback: ConvertChildrenCallback | None = None,
+        markdown_grammar: MarkdownGrammar | None = None,
     ) -> None:
         self.block = block
         self.indent_level = indent_level
         self.convert_children_callback = convert_children_callback
+        markdown_grammar = markdown_grammar or MarkdownGrammar()
+        self._spaces_per_nesting_level = markdown_grammar.spaces_per_nesting_level
 
         self.markdown_result: str | None = None
-        self._markdown_indentation_multiplier = 4
 
     async def render_children(self) -> str:
         return await self._convert_children_to_markdown(self.indent_level)
@@ -43,6 +46,6 @@ class MarkdownRenderingContext:
         if not text:
             return text
 
-        spaces = " " * self._markdown_indentation_multiplier * self.indent_level
+        spaces = " " * self._spaces_per_nesting_level * self.indent_level
         lines = text.split("\n")
         return "\n".join(f"{spaces}{line}" if line.strip() else line for line in lines)

notionary/page/content/renderer/factory.py

@@ -26,11 +26,10 @@ from notionary.page.content.renderer.renderers import (
     TableRenderer,
     TableRowHandler,
     TodoRenderer,
-    ToggleableHeadingRenderer,
     ToggleRenderer,
     VideoRenderer,
 )
-from notionary.page.content.syntax.service import SyntaxRegistry
+from notionary.page.content.syntax import SyntaxRegistry
 
 
 class RendererChainFactory:
@@ -45,7 +44,6 @@ class RendererChainFactory:
     def create(self) -> BlockRenderer:
         # Strukturelle Blocks
         toggle_handler = self._create_toggle_renderer()
-        toggleable_heading_handler = self._create_toggleable_heading_renderer()
         heading_handler = self._create_heading_renderer()
 
         # Content Blocks
@@ -83,8 +81,7 @@ class RendererChainFactory:
 
         # Chain verketten - most specific first, fallback last
         (
-            toggle_handler.set_next(toggleable_heading_handler)
-            .set_next(heading_handler)
+            toggle_handler.set_next(heading_handler)
             .set_next(callout_handler)
             .set_next(code_handler)
             .set_next(quote_handler)
@@ -119,12 +116,6 @@ class RendererChainFactory:
             rich_text_markdown_converter=self._rich_text_markdown_converter,
         )
 
-    def _create_toggleable_heading_renderer(self) -> ToggleableHeadingRenderer:
-        return ToggleableHeadingRenderer(
-            syntax_registry=self._syntax_registry,
-            rich_text_markdown_converter=self._rich_text_markdown_converter,
-        )
-
     def _create_heading_renderer(self) -> HeadingRenderer:
         return HeadingRenderer(
             syntax_registry=self._syntax_registry,

notionary/page/content/renderer/post_processing/handlers/__init__.py

@@ -1,5 +1,5 @@
-from .numbered_list_placeholdere import NumberedListPlaceholderReplaceerPostProcessor
+from .numbered_list import NumberedListPlaceholderReplacerPostProcessor
 
 __all__ = [
-    "NumberedListPlaceholderReplaceerPostProcessor",
+    "NumberedListPlaceholderReplacerPostProcessor",
 ]