notionary 0.2.23__py3-none-any.whl → 0.2.24__py3-none-any.whl

notionary/{markdown → blocks/markdown}/markdown_builder.py

@@ -8,107 +8,47 @@ Maps 1:1 to the available blocks with clear, expressive method names.
 
 from __future__ import annotations
 
-from typing import Any, Callable, Optional, Self
+from typing import Callable, Optional, Self
 
-from notionary.blocks.audio import AudioMarkdownBlockParams, AudioMarkdownNode
-from notionary.blocks.bookmark import BookmarkMarkdownBlockParams, BookmarkMarkdownNode
+from notionary.blocks.bookmark import BookmarkMarkdownNode
 from notionary.blocks.breadcrumbs import BreadcrumbMarkdownNode
-from notionary.blocks.bulleted_list import (
-    BulletedListMarkdownBlockParams,
-    BulletedListMarkdownNode,
-)
-from notionary.blocks.callout import CalloutMarkdownBlockParams, CalloutMarkdownNode
-from notionary.blocks.code import CodeBlock, CodeLanguage, CodeMarkdownNode
-from notionary.blocks.column import (
-    ColumnListMarkdownBlockParams,
-    ColumnListMarkdownNode,
-    ColumnMarkdownNode,
-)
-from notionary.blocks.divider import DividerMarkdownBlockParams, DividerMarkdownNode
-from notionary.blocks.embed import EmbedMarkdownBlockParams, EmbedMarkdownNode
-from notionary.blocks.equation import EquationMarkdownBlockParams, EquationMarkdownNode
-from notionary.blocks.file import FileMarkdownNode, FileMarkdownNodeParams
-from notionary.blocks.heading import HeadingMarkdownBlockParams, HeadingMarkdownNode
-from notionary.blocks.image_block import ImageMarkdownBlockParams, ImageMarkdownNode
-from notionary.blocks.numbered_list import (
-    NumberedListMarkdownBlockParams,
-    NumberedListMarkdownNode,
-)
-from notionary.blocks.paragraph import (
-    ParagraphMarkdownBlockParams,
-    ParagraphMarkdownNode,
-)
-from notionary.blocks.pdf import PdfMarkdownNode, PdfMarkdownNodeParams
-from notionary.blocks.quote import QuoteMarkdownBlockParams, QuoteMarkdownNode
-from notionary.blocks.table import TableMarkdownBlockParams, TableMarkdownNode
-from notionary.blocks.table_of_contents import (
-    TableOfContentsMarkdownBlockParams,
-    TableOfContentsMarkdownNode,
-)
-from notionary.blocks.todo import TodoMarkdownBlockParams, TodoMarkdownNode
-from notionary.blocks.toggle import ToggleMarkdownBlockParams, ToggleMarkdownNode
-from notionary.blocks.toggleable_heading import (
-    ToggleableHeadingMarkdownBlockParams,
-    ToggleableHeadingMarkdownNode,
-)
-from notionary.blocks.types import BlockType, MarkdownBlockType
-from notionary.blocks.video import VideoMarkdownBlockParams, VideoMarkdownNode
-from notionary.markdown.markdown_document_model import (
-    MarkdownBlock,
-    MarkdownDocumentModel,
-)
-from notionary.markdown.markdown_node import MarkdownNode
+from notionary.blocks.bulleted_list import BulletedListMarkdownNode
+from notionary.blocks.callout import CalloutMarkdownNode
+from notionary.blocks.code import CodeLanguage, CodeMarkdownNode
+from notionary.blocks.column import ColumnListMarkdownNode, ColumnMarkdownNode
+from notionary.blocks.divider import DividerMarkdownNode
+from notionary.blocks.embed import EmbedMarkdownNode
+from notionary.blocks.equation import EquationMarkdownNode
+from notionary.blocks.file import FileMarkdownNode
+from notionary.blocks.heading import HeadingMarkdownNode
+from notionary.blocks.image_block import ImageMarkdownNode
+from notionary.blocks.numbered_list import NumberedListMarkdownNode
+from notionary.blocks.paragraph import ParagraphMarkdownNode
+from notionary.blocks.pdf import PdfMarkdownNode
+from notionary.blocks.quote import QuoteMarkdownNode
+from notionary.blocks.table import TableMarkdownNode
+from notionary.blocks.table_of_contents import TableOfContentsMarkdownNode
+from notionary.blocks.todo import TodoMarkdownNode
+from notionary.blocks.toggle import ToggleMarkdownNode
+from notionary.blocks.toggleable_heading import ToggleableHeadingMarkdownNode
+from notionary.blocks.video import VideoMarkdownNode
+from notionary.blocks.audio import AudioMarkdownNode
+
+from notionary.blocks.markdown.markdown_node import MarkdownNode
 
 
 class MarkdownBuilder:
     """
     Fluent interface builder for creating Notion content with clean, direct methods.
+
+    Focuses on the developer API for programmatic content creation.
+    Model processing is handled by MarkdownModelProcessor.
     """
 
     def __init__(self) -> None:
+        """Initialize builder with empty children list."""
         self.children: list[MarkdownNode] = []
 
-        self._block_processors: dict[str, Callable[[Any], None]] = {
-            MarkdownBlockType.HEADING_1: self._add_heading,
-            MarkdownBlockType.HEADING_2: self._add_heading,
-            MarkdownBlockType.HEADING_3: self._add_heading,
-            MarkdownBlockType.PARAGRAPH: self._add_paragraph,
-            MarkdownBlockType.QUOTE: self._add_quote,
-            MarkdownBlockType.BULLETED_LIST_ITEM: self._add_bulleted_list,
-            MarkdownBlockType.NUMBERED_LIST_ITEM: self._add_numbered_list,
-            MarkdownBlockType.TO_DO: self._add_todo,
-            MarkdownBlockType.CALLOUT: self._add_callout,
-            MarkdownBlockType.CODE: self._add_code,
-            MarkdownBlockType.IMAGE: self._add_image,
-            MarkdownBlockType.VIDEO: self._add_video,
-            MarkdownBlockType.AUDIO: self._add_audio,
-            MarkdownBlockType.FILE: self._add_file,
-            MarkdownBlockType.PDF: self._add_pdf,
-            MarkdownBlockType.BOOKMARK: self._add_bookmark,
-            MarkdownBlockType.EMBED: self._add_embed,
-            MarkdownBlockType.TABLE: self._add_table,
-            MarkdownBlockType.DIVIDER: self._add_divider,
-            MarkdownBlockType.EQUATION: self._add_equation,
-            MarkdownBlockType.TABLE_OF_CONTENTS: self._add_table_of_contents,
-            MarkdownBlockType.TOGGLE: self._add_toggle,
-            MarkdownBlockType.COLUMN_LIST: self._add_columns,
-            MarkdownBlockType.BREADCRUMB: self._add_breadcrumb,
-            MarkdownBlockType.HEADING: self._add_heading,
-            MarkdownBlockType.BULLETED_LIST: self._add_bulleted_list,
-            MarkdownBlockType.NUMBERED_LIST: self._add_numbered_list,
-            MarkdownBlockType.TODO: self._add_todo,
-            MarkdownBlockType.TOGGLEABLE_HEADING: self._add_toggleable_heading,
-            MarkdownBlockType.COLUMNS: self._add_columns,
-            MarkdownBlockType.SPACE: self._add_space,
-        }
-
-    @classmethod
-    def from_model(cls, model: MarkdownDocumentModel) -> Self:
-        """Create MarkdownBuilder from a Pydantic model."""
-        builder = cls()
-        builder._process_blocks(model.blocks)
-        return builder
-
     def h1(self, text: str) -> Self:
         """
         Add an H1 heading.
@@ -583,147 +523,3 @@ class MarkdownBuilder:
         return "\n\n".join(
             child.to_markdown() for child in self.children if child is not None
         )
-
-    def _add_heading(self, params: HeadingMarkdownBlockParams) -> None:
-        """Add a heading block."""
-        self.children.append(HeadingMarkdownNode.from_params(params))
-
-    def _add_paragraph(self, params: ParagraphMarkdownBlockParams) -> None:
-        """Add a paragraph block."""
-        self.children.append(ParagraphMarkdownNode.from_params(params))
-
-    def _add_quote(self, params: QuoteMarkdownBlockParams) -> None:
-        """Add a quote block."""
-        self.children.append(QuoteMarkdownNode.from_params(params))
-
-    def _add_bulleted_list(self, params: BulletedListMarkdownBlockParams) -> None:
-        """Add a bulleted list block."""
-        self.children.append(BulletedListMarkdownNode.from_params(params))
-
-    def _add_numbered_list(self, params: NumberedListMarkdownBlockParams) -> None:
-        """Add a numbered list block."""
-        self.children.append(NumberedListMarkdownNode.from_params(params))
-
-    def _add_todo(self, params: TodoMarkdownBlockParams) -> None:
-        """Add a todo block."""
-        self.children.append(TodoMarkdownNode.from_params(params))
-
-    def _add_callout(self, params: CalloutMarkdownBlockParams) -> None:
-        """Add a callout block."""
-        self.children.append(CalloutMarkdownNode.from_params(params))
-
-    def _add_code(self, params: CodeBlock) -> None:
-        """Add a code block."""
-        self.children.append(CodeMarkdownNode.from_params(params))
-
-    def _add_image(self, params: ImageMarkdownBlockParams) -> None:
-        """Add an image block."""
-        self.children.append(ImageMarkdownNode.from_params(params))
-
-    def _add_video(self, params: VideoMarkdownBlockParams) -> None:
-        """Add a video block."""
-        self.children.append(VideoMarkdownNode.from_params(params))
-
-    def _add_audio(self, params: AudioMarkdownBlockParams) -> None:
-        """Add an audio block."""
-        self.children.append(AudioMarkdownNode.from_params(params))
-
-    def _add_file(self, params: FileMarkdownNodeParams) -> None:
-        """Add a file block."""
-        self.children.append(FileMarkdownNode.from_params(params))
-
-    def _add_pdf(self, params: PdfMarkdownNodeParams) -> None:
-        """Add a PDF block."""
-        self.children.append(PdfMarkdownNode.from_params(params))
-
-    def _add_bookmark(self, params: BookmarkMarkdownBlockParams) -> None:
-        """Add a bookmark block."""
-        self.children.append(BookmarkMarkdownNode.from_params(params))
-
-    def _add_embed(self, params: EmbedMarkdownBlockParams) -> None:
-        """Add an embed block."""
-        self.children.append(EmbedMarkdownNode.from_params(params))
-
-    def _add_table(self, params: TableMarkdownBlockParams) -> None:
-        """Add a table block."""
-        self.children.append(TableMarkdownNode.from_params(params))
-
-    def _add_divider(self, params: DividerMarkdownBlockParams) -> None:
-        """Add a divider block."""
-        self.children.append(DividerMarkdownNode.from_params(params))
-
-    def _add_equation(self, params: EquationMarkdownBlockParams) -> None:
-        """Add an equation block."""
-        self.children.append(EquationMarkdownNode.from_params(params))
-
-    def _add_table_of_contents(
-        self, params: TableOfContentsMarkdownBlockParams
-    ) -> None:
-        """Add a table of contents block."""
-        self.children.append(TableOfContentsMarkdownNode.from_params(params))
-
-    def _add_toggle(self, params: ToggleMarkdownBlockParams) -> None:
-        """Add a toggle block."""
-        child_builder = MarkdownBuilder()
-        child_builder._process_blocks(params.children)
-        self.children.append(
-            ToggleMarkdownNode(title=params.title, children=child_builder.children)
-        )
-
-    def _add_toggleable_heading(
-        self, params: ToggleableHeadingMarkdownBlockParams
-    ) -> None:
-        """Add a toggleable heading block."""
-        # Create nested builder for children
-        child_builder = MarkdownBuilder()
-        child_builder._process_blocks(params.children)
-        self.children.append(
-            ToggleableHeadingMarkdownNode(
-                text=params.text, level=params.level, children=child_builder.children
-            )
-        )
-
-    def _add_columns(self, params: ColumnListMarkdownBlockParams) -> None:
-        """Add a columns block."""
-        column_nodes = []
-
-        for i, column_blocks in enumerate(params.columns):
-            width_ratio = (
-                params.width_ratios[i]
-                if params.width_ratios and i < len(params.width_ratios)
-                else None
-            )
-
-            col_builder = MarkdownBuilder()
-            col_builder._process_blocks(column_blocks)
-
-            # Erstelle ColumnMarkdownNode
-            column_nodes.append(
-                ColumnMarkdownNode(
-                    children=col_builder.children, width_ratio=width_ratio
-                )
-            )
-
-        self.children.append(ColumnListMarkdownNode(columns=column_nodes))
-
-    def _add_breadcrumb(self, params) -> None:
-        """Add a breadcrumb block."""
-        self.children.append(BreadcrumbMarkdownNode())
-
-    def _add_space(self, params) -> None:
-        """Add a space block."""
-        self.children.append(ParagraphMarkdownNode(text=""))
-
-    def _process_blocks(self, blocks: list[MarkdownBlock]) -> None:
-        """Process blocks using explicit mapping - type-safe and clear."""
-        for block in blocks:
-            processor = self._block_processors.get(block.type)
-            if processor:
-                processor(block.params)
-            else:
-                # More explicit error handling
-                available_types = ", ".join(sorted(self._block_processors.keys()))
-                raise ValueError(
-                    f"Unsupported block type '{block.type}'. "
-                    f"Available types: {available_types}"
-                )

notionary/blocks/markdown/markdown_node.py

@@ -0,0 +1,25 @@
+from abc import ABC, abstractmethod
+from pydantic import BaseModel
+
+
+class MarkdownNode(BaseModel, ABC):
+    """
+    Enhanced base class for all Markdown nodes with Pydantic integration.
+
+    This class serves dual purposes:
+    1. Runtime representation for markdown generation
+    2. Serializable model for structured output (LLM/API)
+
+    The 'type' field acts as a discriminator for Union types and processing.
+    """
+
+    @abstractmethod
+    def to_markdown(self) -> str:
+        """
+        Returns the Markdown representation of the block.
+        Must be implemented by subclasses.
+        """
+        pass
+
+    def __str__(self):
+        return self.to_markdown()

notionary/blocks/mixins/file_upload/__init__.py

@@ -0,0 +1,3 @@
+from .file_upload_mixin import FileUploadMixin
+
+__all__ = ["FileUploadMixin"]

notionary/blocks/mixins/file_upload/file_upload_mixin.py

@@ -0,0 +1,320 @@
+from urllib.parse import urlparse
+from pathlib import Path
+from typing import Optional
+from notionary.file_upload import NotionFileUploadClient
+from notionary.file_upload.models import UploadMode
+from notionary.page.page_context import get_page_context
+from notionary.util.logging_mixin import LoggingMixin
+
+
+# TOOD: Hier überlegen wirklich nur was common ist hier in den mixin ansonstne dediziert handeln.
+class FileUploadMixin(LoggingMixin):
+    """
+    Mixin to add file upload functionality to all media block elements.
+
+    Supports uploading local files for:
+    - file blocks
+    - image blocks
+    - pdf blocks
+    - audio blocks
+    - video blocks
+    """
+
+    @classmethod
+    def _get_file_upload_client(cls) -> NotionFileUploadClient:
+        """Get the file upload client from the current page context."""
+        context = get_page_context()
+        return context.file_upload_client
+
+    @classmethod
+    def _is_local_file_path(cls, path: str) -> bool:
+        """Determine if the path is a local file rather than a URL."""
+        if path.startswith(("http://", "https://", "ftp://")):
+            return False
+
+        return (
+            "/" in path
+            or "\\" in path
+            or path.startswith("./")
+            or path.startswith("../")
+            or ":" in path[:3]
+        )  # Windows drive letters like C:
+
+    @classmethod
+    def _should_upload_file(cls, path: str, expected_category: str = "file") -> bool:
+        """
+        Determine if a path should be uploaded vs used as external URL.
+
+        Args:
+            path: File path or URL
+            expected_category: Expected file category
+
+        Returns:
+            True if file should be uploaded
+        """
+        if not cls._is_local_file_path(path):
+            return False
+
+        file_path = Path(path)
+        if not file_path.exists():
+            return False
+
+        return True
+
+    @classmethod
+    def _get_content_type(cls, file_path: Path) -> str:
+        """Get MIME type based on file extension."""
+        extension_map = {
+            # Documents
+            ".pdf": "application/pdf",
+            ".doc": "application/msword",
+            ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+            ".xls": "application/vnd.ms-excel",
+            ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+            ".ppt": "application/vnd.ms-powerpoint",
+            ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+            ".txt": "text/plain",
+            ".csv": "text/csv",
+            ".json": "application/json",
+            ".xml": "application/xml",
+            ".zip": "application/zip",
+            ".rar": "application/vnd.rar",
+            ".7z": "application/x-7z-compressed",
+            # Images
+            ".png": "image/png",
+            ".jpg": "image/jpeg",
+            ".jpeg": "image/jpeg",
+            ".gif": "image/gif",
+            ".webp": "image/webp",
+            ".bmp": "image/bmp",
+            ".tiff": "image/tiff",
+            ".tif": "image/tiff",
+            ".svg": "image/svg+xml",
+            ".ico": "image/x-icon",
+            ".heic": "image/heic",
+            ".heif": "image/heif",
+            # Audio
+            ".mp3": "audio/mpeg",
+            ".wav": "audio/wav",
+            ".ogg": "audio/ogg",
+            ".m4a": "audio/mp4",
+            ".aac": "audio/aac",
+            ".flac": "audio/flac",
+            ".wma": "audio/x-ms-wma",
+            ".opus": "audio/opus",
+            # Video
+            ".mp4": "video/mp4",
+            ".avi": "video/x-msvideo",
+            ".mov": "video/quicktime",
+            ".wmv": "video/x-ms-wmv",
+            ".flv": "video/x-flv",
+            ".webm": "video/webm",
+            ".mkv": "video/x-matroska",
+            ".m4v": "video/mp4",
+            ".3gp": "video/3gpp",
+        }
+
+        suffix = file_path.suffix.lower()
+        return extension_map.get(suffix, "application/octet-stream")
+
+    @classmethod
+    def _get_file_category(cls, file_path: Path) -> str:
+        """
+        Determine the category of file based on extension.
+
+        Returns:
+            One of: 'image', 'audio', 'video', 'pdf', 'document', 'archive', 'other'
+        """
+        suffix = file_path.suffix.lower()
+
+        # Define extension sets for each category
+        extension_categories = {
+            "image": {
+                ".png",
+                ".jpg",
+                ".jpeg",
+                ".gif",
+                ".webp",
+                ".bmp",
+                ".tiff",
+                ".tif",
+                ".svg",
+                ".ico",
+                ".heic",
+                ".heif",
+            },
+            "audio": {".mp3", ".wav", ".ogg", ".m4a", ".aac", ".flac", ".wma", ".opus"},
+            "video": {
+                ".mp4",
+                ".avi",
+                ".mov",
+                ".wmv",
+                ".flv",
+                ".webm",
+                ".mkv",
+                ".m4v",
+                ".3gp",
+            },
+            "pdf": {".pdf"},
+            "document": {
+                ".doc",
+                ".docx",
+                ".xls",
+                ".xlsx",
+                ".ppt",
+                ".pptx",
+                ".txt",
+                ".csv",
+                ".json",
+                ".xml",
+            },
+            "archive": {".zip", ".rar", ".7z"},
+        }
+
+        # Find matching category
+        for category, extensions in extension_categories.items():
+            if suffix in extensions:
+                return category
+
+        return "other"
+
+    @classmethod
+    def _is_supported_file_type(cls, file_path: Path, expected_category: str) -> bool:
+        """
+        Check if the file type matches the expected category.
+
+        Args:
+            file_path: Path to the file
+            expected_category: Expected category ('image', 'audio', 'video', 'pdf', 'file')
+
+        Returns:
+            True if file type matches expected category
+        """
+        # 'file' category accepts any file type
+        if expected_category == "file":
+            return True
+
+        actual_category = cls._get_file_category(file_path)
+        return actual_category == expected_category
+
+    @classmethod
+    async def _upload_local_file(
+        cls, file_path_str: str, expected_category: str = "file"
+    ) -> Optional[str]:
+        """
+        Upload a local file and return the file upload ID.
+
+        Args:
+            file_path_str: String path to the local file
+            expected_category: Expected file category for validation
+
+        Returns:
+            File upload ID if successful, None otherwise
+        """
+        try:
+            file_upload_client = cls._get_file_upload_client()
+            file_path = Path(file_path_str)
+
+            # Pre-upload validation
+            if not cls._validate_file_for_upload(file_path, expected_category):
+                return None
+
+            # Get file metadata
+            file_size = file_path.stat().st_size
+            content_type = cls._get_content_type(file_path)
+
+            cls.logger.info(
+                f"Uploading {expected_category} file: {file_path.name} "
+                f"({file_size} bytes, {content_type})"
+            )
+
+            # Create and execute upload
+            upload_id = await cls._execute_upload(
+                file_upload_client, file_path, content_type, file_size
+            )
+
+            if upload_id:
+                cls.logger.info(
+                    f"File upload completed: {upload_id} ({file_path.name})"
+                )
+
+            return upload_id
+
+        except Exception as e:
+            cls.logger.error(
+                f"Error uploading {expected_category} file {file_path_str}: {e}"
+            )
+            cls.logger.debug("Upload error traceback:", exc_info=True)
+            return None
+
+    @classmethod
+    def _validate_file_for_upload(cls, file_path: Path, expected_category: str) -> bool:
+        """Validate file exists and type matches expected category."""
+        # Check if file exists
+        if not file_path.exists():
+            cls.logger.error(f"File not found: {file_path}")
+            return False
+
+        # Validate file type if needed
+        if not cls._is_supported_file_type(file_path, expected_category):
+            actual_category = cls._get_file_category(file_path)
+            cls.logger.warning(
+                f"File type mismatch: expected {expected_category}, "
+                f"got {actual_category} for {file_path} - proceeding anyway"
+            )
+
+        return True
+
+    @classmethod
+    async def _execute_upload(
+        cls,
+        file_upload_client: NotionFileUploadClient,
+        file_path: Path,
+        content_type: str,
+        file_size: int,
+    ) -> Optional[str]:
+        """Execute the actual file upload process."""
+        # Step 1: Create file upload
+        upload_response = await file_upload_client.create_file_upload(
+            filename=file_path.name,
+            content_type=content_type,
+            content_length=file_size,
+            mode=UploadMode.SINGLE_PART,
+        )
+
+        if not upload_response:
+            cls.logger.error(f"Failed to create file upload for {file_path.name}")
+            return None
+
+        cls.logger.debug(f"Created file upload with ID: {upload_response.id}")
+
+        # Step 2: Send file content
+        success = await file_upload_client.send_file_from_path(
+            file_upload_id=upload_response.id, file_path=file_path
+        )
+
+        if not success:
+            cls.logger.error(f"Failed to send file content for {file_path.name}")
+            return None
+
+        cls.logger.debug(f"File content sent successfully for {file_path.name}")
+        return upload_response.id
+
+    @classmethod
+    def _get_upload_error_message(
+        cls, file_path_str: str, expected_category: str
+    ) -> str:
+        """Get a user-friendly error message for upload failures."""
+        file_path = Path(file_path_str)
+
+        if not file_path.exists():
+            return f"File not found: {file_path_str}"
+
+        actual_category = cls._get_file_category(file_path)
+        if actual_category != expected_category and expected_category != "file":
+            return (
+                f"Invalid file type for {expected_category} block: "
+                f"{file_path.suffix} (detected as {actual_category})"
+            )
+
+        return f"Failed to upload {expected_category} file: {file_path_str}"

notionary/blocks/numbered_list/__init__.py

@@ -1,6 +1,5 @@
 from notionary.blocks.numbered_list.numbered_list_element import NumberedListElement
 from notionary.blocks.numbered_list.numbered_list_markdown_node import (
-    NumberedListMarkdownBlockParams,
     NumberedListMarkdownNode,
 )
 from notionary.blocks.numbered_list.numbered_list_models import (

notionary/blocks/numbered_list/numbered_list_markdown_node.py

@@ -1,16 +1,9 @@
-from __future__ import annotations
-
-from pydantic import BaseModel
-
-from notionary.markdown.markdown_node import MarkdownNode
-
-
-class NumberedListMarkdownBlockParams(BaseModel):
-    texts: list[str]
+from notionary.blocks.markdown.markdown_node import MarkdownNode
 
 
 class NumberedListMarkdownNode(MarkdownNode):
     """
+    Enhanced NumberedList node with Pydantic integration.
     Programmatic interface for creating Markdown numbered list items.
     Example:
     1. First step
@@ -18,14 +11,7 @@ class NumberedListMarkdownNode(MarkdownNode):
     3. Third step
     """
 
-    def __init__(self, texts: list[str]):
-        self.texts = texts
-
-    @classmethod
-    def from_params(
-        cls, params: NumberedListMarkdownBlockParams
-    ) -> NumberedListMarkdownNode:
-        return cls(texts=params.texts)
+    texts: list[str]
 
     def to_markdown(self) -> str:
         return "\n".join(f"{i + 1}. {text}" for i, text in enumerate(self.texts))