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

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

@@ -0,0 +1,156 @@
+import re
+from enum import IntEnum
+from typing import override
+
+from notionary.page.content.renderer.post_processing.port import PostProcessor
+from notionary.page.content.syntax.grammar import MarkdownGrammar
+
+
+class _NumberingStyle(IntEnum):
+    NUMERIC = 0
+    ALPHABETIC = 1
+    ROMAN = 2
+
+
+class _ListNumberingState:
+    def __init__(self):
+        self._counters_by_level: dict[int, int] = {}
+        self._current_level = -1
+
+    def advance_to_level(self, new_level: int) -> None:
+        self._forget_deeper_levels_than(new_level)
+        self._increment_counter_at_level(new_level)
+        self._current_level = new_level
+
+    def get_number_for_current_level(self) -> str:
+        counter = self._counters_by_level[self._current_level]
+        style = self._determine_numbering_style(self._current_level)
+        return self._format_number(counter, style)
+
+    def reset(self) -> None:
+        self._counters_by_level.clear()
+        self._current_level = -1
+
+    def _forget_deeper_levels_than(self, level: int) -> None:
+        self._counters_by_level = {
+            existing_level: count
+            for existing_level, count in self._counters_by_level.items()
+            if existing_level <= level
+        }
+
+    def _increment_counter_at_level(self, level: int) -> None:
+        self._counters_by_level[level] = self._counters_by_level.get(level, 0) + 1
+
+    def _determine_numbering_style(self, nesting_level: int) -> _NumberingStyle:
+        return _NumberingStyle(nesting_level % 3)
+
+    def _format_number(self, counter: int, style: _NumberingStyle) -> str:
+        if style == _NumberingStyle.NUMERIC:
+            return str(counter)
+        elif style == _NumberingStyle.ALPHABETIC:
+            return self._to_alphabetic(counter)
+        else:
+            return self._to_roman(counter)
+
+    def _to_alphabetic(self, number: int) -> str:
+        result = ""
+        number -= 1
+        while number >= 0:
+            result = chr(ord("a") + (number % 26)) + result
+            number = number // 26 - 1
+        return result
+
+    def _to_roman(self, number: int) -> str:
+        conversions = [
+            (1000, "m"),
+            (900, "cm"),
+            (500, "d"),
+            (400, "cd"),
+            (100, "c"),
+            (90, "xc"),
+            (50, "l"),
+            (40, "xl"),
+            (10, "x"),
+            (9, "ix"),
+            (5, "v"),
+            (4, "iv"),
+            (1, "i"),
+        ]
+
+        result = ""
+        for arabic, roman in conversions:
+            while number >= arabic:
+                result += roman
+                number -= arabic
+        return result
+
+
+class NumberedListPlaceholderReplacerPostProcessor(PostProcessor):
+    def __init__(self, markdown_grammar: MarkdownGrammar | None = None) -> None:
+        self._markdown_grammar = markdown_grammar or MarkdownGrammar()
+        self._spaces_per_nesting_level = self._markdown_grammar.spaces_per_nesting_level
+        self._numbered_list_placeholder = self._markdown_grammar.numbered_list_placeholder
+
+    @override
+    def process(self, markdown_text: str) -> str:
+        lines = markdown_text.splitlines()
+        return self._convert_placeholder_lists_to_numbered_lists(lines)
+
+    def _convert_placeholder_lists_to_numbered_lists(self, lines: list[str]) -> str:
+        result = []
+        list_state = _ListNumberingState()
+
+        for line_index, line in enumerate(lines):
+            if self._is_placeholder_list_item(line):
+                numbered_line = self._convert_to_numbered_item(line, list_state)
+                result.append(numbered_line)
+            elif self._is_blank_between_list_items(lines, line_index, result):
+                continue
+            else:
+                list_state.reset()
+                result.append(line)
+
+        return "\n".join(result)
+
+    def _convert_to_numbered_item(self, line: str, state: _ListNumberingState) -> str:
+        indentation = self._extract_indentation(line)
+        content = self._extract_content(line)
+        nesting_level = self._calculate_nesting_level(indentation)
+
+        state.advance_to_level(nesting_level)
+        number = state.get_number_for_current_level()
+
+        return f"{indentation}{number}. {content}"
+
+    def _calculate_nesting_level(self, indentation: str) -> int:
+        return len(indentation) // self._spaces_per_nesting_level
+
+    def _extract_indentation(self, line: str) -> str:
+        match = re.match(rf"^(\s*){re.escape(self._numbered_list_placeholder)}\.", line)
+        return match.group(1) if match else ""
+
+    def _extract_content(self, line: str) -> str:
+        match = re.match(rf"^\s*{re.escape(self._numbered_list_placeholder)}\.\s*(.*)", line)
+        return match.group(1) if match else ""
+
+    def _is_placeholder_list_item(self, line: str) -> bool:
+        return bool(re.match(rf"^\s*{re.escape(self._numbered_list_placeholder)}\.", line))
+
+    def _is_blank_between_list_items(self, lines: list[str], current_index: int, processed_lines: list[str]) -> bool:
+        if not self._is_blank(lines[current_index]):
+            return False
+
+        previous_line_was_list_item = processed_lines and self._looks_like_numbered_list_item(processed_lines[-1])
+        if not previous_line_was_list_item:
+            return False
+
+        next_line_is_list_item = current_index + 1 < len(lines) and self._is_placeholder_list_item(
+            lines[current_index + 1]
+        )
+        return next_line_is_list_item
+
+    def _is_blank(self, line: str) -> bool:
+        return not line.strip()
+
+    def _looks_like_numbered_list_item(self, line: str) -> bool:
+        return bool(re.match(r"^\s*(\d+|[a-z]+|[ivxlcdm]+)\.\s+", line))

notionary/page/content/renderer/renderers/__init__.py

@@ -23,7 +23,6 @@ from .table_of_contents import TableOfContentsRenderer
 from .table_row import TableRowHandler
 from .todo import TodoRenderer
 from .toggle import ToggleRenderer
-from .toggleable_heading import ToggleableHeadingRenderer
 from .video import VideoRenderer
 
 __all__ = [
@@ -52,6 +51,5 @@ __all__ = [
     "TableRowHandler",
     "TodoRenderer",
     "ToggleRenderer",
-    "ToggleableHeadingRenderer",
     "VideoRenderer",
 ]

notionary/page/content/renderer/renderers/base.py

@@ -4,7 +4,7 @@ from abc import ABC, abstractmethod
 
 from notionary.blocks.schemas import Block
 from notionary.page.content.renderer.context import MarkdownRenderingContext
-from notionary.page.content.syntax.service import SyntaxRegistry
+from notionary.page.content.syntax import SyntaxRegistry
 
 
 class BlockRenderer(ABC):

notionary/page/content/renderer/renderers/bulleted_list.py

@@ -4,7 +4,7 @@ from notionary.blocks.rich_text.rich_text_markdown_converter import RichTextToMa
 from notionary.blocks.schemas import Block, BlockType
 from notionary.page.content.renderer.context import MarkdownRenderingContext
 from notionary.page.content.renderer.renderers.base import BlockRenderer
-from notionary.page.content.syntax.service import SyntaxRegistry
+from notionary.page.content.syntax import SyntaxRegistry
 
 
 class BulletedListRenderer(BlockRenderer):

notionary/page/content/renderer/renderers/callout.py

@@ -4,7 +4,7 @@ from notionary.blocks.rich_text.rich_text_markdown_converter import RichTextToMa
 from notionary.blocks.schemas import Block, BlockType
 from notionary.page.content.renderer.context import MarkdownRenderingContext
 from notionary.page.content.renderer.renderers.base import BlockRenderer
-from notionary.page.content.syntax.service import SyntaxRegistry
+from notionary.page.content.syntax import SyntaxRegistry
 
 
 class CalloutRenderer(BlockRenderer):
@@ -22,37 +22,22 @@ class CalloutRenderer(BlockRenderer):
 
     @override
     async def _process(self, context: MarkdownRenderingContext) -> None:
-        icon = await self._extract_callout_icon(context.block)
         content = await self._extract_callout_content(context.block)
 
         if not content:
             context.markdown_result = ""
             return
 
-        syntax = self._syntax_registry.get_callout_syntax()
-
-        # Build callout structure
-        # Extract just the base part before the regex pattern
-        callout_type = syntax.start_delimiter.split()[1]  # Gets "callout" from "::: callout"
-        callout_header = f"{self._syntax_registry.MULTI_LINE_BLOCK_DELIMITER} {callout_type}"
-        if icon:
-            callout_header = f"{self._syntax_registry.MULTI_LINE_BLOCK_DELIMITER} {callout_type} {icon}"
+        icon = await self._extract_callout_icon(context.block)
 
-        if context.indent_level > 0:
-            callout_header = context.indent_text(callout_header)
+        callout_start_delimiter = self._syntax_registry.get_callout_syntax().start_delimiter
 
-        # Process children if they exist
-        children_markdown = await context.render_children()
+        result = f'{callout_start_delimiter}({content} "{icon}")' if icon else f"{callout_start_delimiter}({content})"
 
-        callout_end = syntax.end_delimiter
         if context.indent_level > 0:
-            callout_end = context.indent_text(callout_end)
+            result = context.indent_text(result)
 
-        # Combine content
-        if children_markdown:
-            context.markdown_result = f"{callout_header}\n{content}\n{children_markdown}\n{callout_end}"
-        else:
-            context.markdown_result = f"{callout_header}\n{content}\n{callout_end}"
+        context.markdown_result = result
 
     async def _extract_callout_icon(self, block: Block) -> str:
         if not block.callout or not block.callout.icon:

notionary/page/content/renderer/renderers/captioned_block.py

@@ -5,7 +5,7 @@ from notionary.blocks.rich_text.rich_text_markdown_converter import RichTextToMa
 from notionary.blocks.schemas import Block
 from notionary.page.content.renderer.context import MarkdownRenderingContext
 from notionary.page.content.renderer.renderers.base import BlockRenderer
-from notionary.page.content.syntax.service import SyntaxRegistry
+from notionary.page.content.syntax import SyntaxRegistry
 
 
 class CaptionedBlockRenderer(BlockRenderer):

notionary/page/content/renderer/renderers/column.py

@@ -13,32 +13,41 @@ class ColumnRenderer(BlockRenderer):
 
     @override
     async def _process(self, context: MarkdownRenderingContext) -> None:
-        column_start = self._extract_column_start(context.block)
+        column_start = self._format_column_start(context.block, context.indent_level)
+        children_markdown = await self._render_children_with_indentation(context)
 
-        if context.indent_level > 0:
-            column_start = context.indent_text(column_start)
+        if children_markdown:
+            context.markdown_result = f"{column_start}\n{children_markdown}"
+        else:
+            context.markdown_result = column_start
 
-        children_markdown = await context.render_children()
+    def _format_column_start(self, block: Block, indent_level: int) -> str:
+        column_start = self._build_column_start_tag(block)
 
-        syntax = self._syntax_registry.get_column_syntax()
-        column_end = syntax.end_delimiter
-        if context.indent_level > 0:
-            column_end = context.indent_text(column_end, spaces=context.indent_level * 4)
+        if indent_level > 0:
+            indent = "    " * indent_level
+            column_start = f"{indent}{column_start}"
 
-        if children_markdown:
-            context.markdown_result = f"{column_start}\n{children_markdown}\n{column_end}"
-        else:
-            context.markdown_result = f"{column_start}\n{column_end}"
+        return column_start
 
-    def _extract_column_start(self, block: Block) -> str:
-        syntax = self._syntax_registry.get_column_syntax()
-        base_start = syntax.start_delimiter
+    def _build_column_start_tag(self, block: Block) -> str:
+        delimiter = self._syntax_registry.get_column_syntax().start_delimiter
 
         if not block.column:
-            return base_start
+            return delimiter
 
         width_ratio = block.column.width_ratio
         if width_ratio:
-            return f"{base_start} {width_ratio}"
-        else:
-            return base_start
+            return f"{delimiter} {width_ratio}"
+
+        return delimiter
+
+    async def _render_children_with_indentation(self, context: MarkdownRenderingContext) -> str:
+        original_indent = context.indent_level
+        context.indent_level += 1
+
+        children_markdown = await context.render_children()
+
+        context.indent_level = original_indent
+
+        return children_markdown

notionary/page/content/renderer/renderers/column_list.py

@@ -13,19 +13,32 @@ class ColumnListRenderer(BlockRenderer):
 
     @override
     async def _process(self, context: MarkdownRenderingContext) -> None:
-        syntax = self._syntax_registry.get_column_list_syntax()
-        column_list_start = syntax.start_delimiter
+        column_list_start = self._format_column_list_start(context.indent_level)
+        children_markdown = await self._render_children_with_indentation(context)
 
-        if context.indent_level > 0:
-            column_list_start = context.indent_text(column_list_start)
+        if children_markdown:
+            context.markdown_result = f"{column_list_start}\n{children_markdown}"
+        else:
+            context.markdown_result = column_list_start
+
+    def _format_column_list_start(self, indent_level: int) -> str:
+        delimiter = self._get_column_list_delimiter()
+
+        if indent_level > 0:
+            indent = "    " * indent_level
+            return f"{indent}{delimiter}"
+
+        return delimiter
+
+    def _get_column_list_delimiter(self) -> str:
+        return self._syntax_registry.get_column_list_syntax().start_delimiter
+
+    async def _render_children_with_indentation(self, context: MarkdownRenderingContext) -> str:
+        original_indent = context.indent_level
+        context.indent_level += 1
 
         children_markdown = await context.render_children()
 
-        column_list_end = syntax.end_delimiter
-        if context.indent_level > 0:
-            column_list_end = context.indent_text(column_list_end)
+        context.indent_level = original_indent
 
-        if children_markdown:
-            context.markdown_result = f"{column_list_start}\n{children_markdown}\n{column_list_end}"
-        else:
-            context.markdown_result = f"{column_list_start}\n{column_list_end}"
+        return children_markdown

notionary/page/content/renderer/renderers/heading.py

@@ -1,13 +1,16 @@
 from typing import override
 
 from notionary.blocks.rich_text.rich_text_markdown_converter import RichTextToMarkdownConverter
-from notionary.blocks.schemas import Block, BlockType
+from notionary.blocks.schemas import Block, BlockType, HeadingData
 from notionary.page.content.renderer.context import MarkdownRenderingContext
 from notionary.page.content.renderer.renderers.base import BlockRenderer
-from notionary.page.content.syntax.service import SyntaxRegistry
+from notionary.page.content.syntax import SyntaxRegistry
 
 
 class HeadingRenderer(BlockRenderer):
+    MIN_HEADING_LEVEL = 1
+    MAX_HEADING_LEVEL = 3
+
     def __init__(
         self,
         syntax_registry: SyntaxRegistry | None = None,
@@ -19,29 +22,47 @@ class HeadingRenderer(BlockRenderer):
 
     @override
     def _can_handle(self, block: Block) -> bool:
-        if block.type == BlockType.HEADING_1:
-            return not block.heading_1.is_toggleable
-        if block.type == BlockType.HEADING_2:
-            return not block.heading_2.is_toggleable
-        if block.type == BlockType.HEADING_3:
-            return not block.heading_3.is_toggleable
-
-        return False
+        return block.type in (BlockType.HEADING_1, BlockType.HEADING_2, BlockType.HEADING_3)
 
     @override
     async def _process(self, context: MarkdownRenderingContext) -> None:
         level = self._get_heading_level(context.block)
         title = await self._get_heading_title(context.block)
 
-        if not title or level == 0:
+        if not self._is_valid_heading(level, title):
             return
 
-        heading_markdown = f"{self._syntax.start_delimiter * level} {title}"
+        heading_markdown = self._format_heading(level, title, context.indent_level)
+
+        if self._is_toggleable(context.block):
+            context.markdown_result = await self._render_toggleable_heading(heading_markdown, context)
+        else:
+            context.markdown_result = heading_markdown
+
+    def _is_valid_heading(self, level: int, title: str) -> bool:
+        return self.MIN_HEADING_LEVEL <= level <= self.MAX_HEADING_LEVEL and bool(title)
+
+    def _format_heading(self, level: int, title: str, indent_level: int) -> str:
+        heading_prefix = self._syntax.start_delimiter * level
+        heading_markdown = f"{heading_prefix} {title}"
+
+        if indent_level > 0:
+            indent = "    " * indent_level
+            heading_markdown = f"{indent}{heading_markdown}"
+
+        return heading_markdown
+
+    async def _render_toggleable_heading(self, heading_markdown: str, context: MarkdownRenderingContext) -> str:
+        original_indent = context.indent_level
+        context.indent_level += 1
+
+        children_markdown = await context.render_children()
 
-        if context.indent_level > 0:
-            heading_markdown = context.indent_text(heading_markdown)
+        context.indent_level = original_indent
 
-        context.markdown_result = heading_markdown
+        if children_markdown:
+            return f"{heading_markdown}\n{children_markdown}"
+        return heading_markdown
 
     def _get_heading_level(self, block: Block) -> int:
         if block.type == BlockType.HEADING_1:
@@ -50,20 +71,25 @@ class HeadingRenderer(BlockRenderer):
             return 2
         elif block.type == BlockType.HEADING_3:
             return 3
-        else:
-            return 0
+        return 0
+
+    def _is_toggleable(self, block: Block) -> bool:
+        heading_data = self._get_heading_data(block)
+        return heading_data.is_toggleable if heading_data else False
 
     async def _get_heading_title(self, block: Block) -> str:
-        if block.type == BlockType.HEADING_1:
-            heading_content = block.heading_1
-        elif block.type == BlockType.HEADING_2:
-            heading_content = block.heading_2
-        elif block.type == BlockType.HEADING_3:
-            heading_content = block.heading_3
-        else:
-            return ""
+        heading_data = self._get_heading_data(block)
 
-        if not heading_content or not heading_content.rich_text:
+        if not heading_data or not heading_data.rich_text:
             return ""
 
-        return await self._rich_text_markdown_converter.to_markdown(heading_content.rich_text)
+        return await self._rich_text_markdown_converter.to_markdown(heading_data.rich_text)
+
+    def _get_heading_data(self, block: Block) -> HeadingData | None:
+        if block.type == BlockType.HEADING_1:
+            return block.heading_1
+        elif block.type == BlockType.HEADING_2:
+            return block.heading_2
+        elif block.type == BlockType.HEADING_3:
+            return block.heading_3
+        return None

notionary/page/content/renderer/renderers/numbered_list.py

@@ -6,21 +6,22 @@ from notionary.blocks.rich_text.rich_text_markdown_converter import (
 from notionary.blocks.schemas import Block, BlockType
 from notionary.page.content.renderer.context import MarkdownRenderingContext
 from notionary.page.content.renderer.renderers.base import BlockRenderer
-from notionary.page.content.syntax.service import SyntaxRegistry
+from notionary.page.content.syntax import MarkdownGrammar, SyntaxRegistry
 
 
 class NumberedListRenderer(BlockRenderer):
-    # Placeholder for numbered list fixer (post processing)
-    NUMBERED_LIST_PLACEHOLDER = "__NUM__"
-
     def __init__(
         self,
         syntax_registry: SyntaxRegistry | None = None,
         rich_text_markdown_converter: RichTextToMarkdownConverter | None = None,
+        markdown_grammar: MarkdownGrammar | None = None,
     ) -> None:
         super().__init__(syntax_registry=syntax_registry)
         self._rich_text_markdown_converter = rich_text_markdown_converter or RichTextToMarkdownConverter()
 
+        markdown_grammar = markdown_grammar or MarkdownGrammar()
+        self._numbered_list_placeholder = markdown_grammar.numbered_list_placeholder
+
     @override
     def _can_handle(self, block: Block) -> bool:
         return block.type == BlockType.NUMBERED_LIST_ITEM
@@ -31,7 +32,7 @@ class NumberedListRenderer(BlockRenderer):
         rich_text = list_item_data.rich_text if list_item_data else []
         content = await self._rich_text_markdown_converter.to_markdown(rich_text)
 
-        item_line = context.indent_text(f"{self.NUMBERED_LIST_PLACEHOLDER}. {content}")
+        item_line = context.indent_text(f"{self._numbered_list_placeholder}. {content}")
 
         children_markdown = await context.render_children_with_additional_indent(1)
 

notionary/page/content/renderer/renderers/quote.py

@@ -4,7 +4,7 @@ from notionary.blocks.rich_text.rich_text_markdown_converter import RichTextToMa
 from notionary.blocks.schemas import Block, BlockType
 from notionary.page.content.renderer.context import MarkdownRenderingContext
 from notionary.page.content.renderer.renderers.base import BlockRenderer
-from notionary.page.content.syntax.service import SyntaxRegistry
+from notionary.page.content.syntax import SyntaxRegistry
 
 
 class QuoteRenderer(BlockRenderer):

notionary/page/content/renderer/renderers/todo.py

@@ -5,7 +5,7 @@ from notionary.blocks.rich_text.rich_text_markdown_converter import RichTextToMa
 from notionary.blocks.schemas import Block
 from notionary.page.content.renderer.context import MarkdownRenderingContext
 from notionary.page.content.renderer.renderers.base import BlockRenderer
-from notionary.page.content.syntax.service import SyntaxRegistry
+from notionary.page.content.syntax import SyntaxRegistry
 
 
 class TodoRenderer(BlockRenderer):

notionary/page/content/renderer/renderers/toggle.py

@@ -5,7 +5,7 @@ from notionary.blocks.rich_text.rich_text_markdown_converter import RichTextToMa
 from notionary.blocks.schemas import Block
 from notionary.page.content.renderer.context import MarkdownRenderingContext
 from notionary.page.content.renderer.renderers.base import BlockRenderer
-from notionary.page.content.syntax.service import SyntaxRegistry
+from notionary.page.content.syntax import SyntaxRegistry
 
 
 class ToggleRenderer(BlockRenderer):
@@ -34,16 +34,15 @@ class ToggleRenderer(BlockRenderer):
         if context.indent_level > 0:
             toggle_start = context.indent_text(toggle_start)
 
+        original_indent = context.indent_level
+        context.indent_level += 1
         children_markdown = await context.render_children()
-
-        toggle_end = syntax.end_delimiter
-        if context.indent_level > 0:
-            toggle_end = context.indent_text(toggle_end)
+        context.indent_level = original_indent
 
         if children_markdown:
-            context.markdown_result = f"{toggle_start}\n{children_markdown}\n{toggle_end}"
+            context.markdown_result = f"{toggle_start}\n{children_markdown}"
         else:
-            context.markdown_result = f"{toggle_start}\n{toggle_end}"
+            context.markdown_result = toggle_start
 
     async def _extract_toggle_title(self, block: Block) -> str:
         if not block.toggle or not block.toggle.rich_text:

notionary/page/content/service.py

@@ -6,7 +6,7 @@ from notionary.blocks.schemas import Block
 from notionary.page.content.markdown.builder import MarkdownBuilder
 from notionary.page.content.parser.service import MarkdownToNotionConverter
 from notionary.page.content.renderer.service import NotionToMarkdownConverter
-from notionary.utils.async_retry import async_retry
+from notionary.utils.decorators import async_retry, time_execution_async
 from notionary.utils.mixins.logging import LoggingMixin
 
 
@@ -23,10 +23,12 @@ class PageContentService(LoggingMixin):
         self._markdown_converter = markdown_converter
         self._notion_to_markdown_converter = notion_to_markdown_converter
 
+    @time_execution_async()
     async def get_as_markdown(self) -> str:
         blocks = await self._block_client.get_block_tree(parent_block_id=self._page_id)
         return await self._notion_to_markdown_converter.convert(blocks=blocks)
 
+    @time_execution_async()
     async def clear(self) -> None:
         children_response = await self._block_client.get_block_children(block_id=self._page_id)
 
@@ -41,6 +43,7 @@ class PageContentService(LoggingMixin):
         self.logger.debug("Deleting block: %s", block.id)
         await self._block_client.delete_block(block.id)
 
+    @time_execution_async()
     async def append_markdown(self, content: str | Callable[[MarkdownBuilder], MarkdownBuilder]) -> None:
         markdown = self._extract_markdown(content)
         if not markdown:

notionary/page/content/syntax/__init__.py

@@ -0,0 +1,4 @@
+from .grammar import MarkdownGrammar
+from .registry import SyntaxRegistry
+
+__all__ = ["MarkdownGrammar", "SyntaxRegistry"]

notionary/page/content/syntax/grammar.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class MarkdownGrammar:
+    spaces_per_nesting_level = 4
+    numbered_list_placeholder = "__NUM__"
+    column_delimiter = ":::"
+    toggle_delimiter = "+++"
+    table_delimiter = "|"

notionary/page/content/syntax/models.py

@@ -64,5 +64,3 @@ class SyntaxDefinition:
     end_delimiter: str
     regex_pattern: re.Pattern
     end_regex_pattern: re.Pattern | None = None
-    is_multiline_block: bool = False
-    is_inline: bool = False