notionary 0.4.0__tar.gz → 0.4.2__tar.gz

{notionary-0.4.0 → notionary-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: notionary
-Version: 0.4.0
+Version: 0.4.2
 Summary: Python library for programmatic Notion workspace management - databases, pages, and content with advanced Markdown support
 Project-URL: Homepage, https://github.com/mathisarends/notionary
 Author-email: Mathis Arends <mathisarends27@gmail.com>

notionary-0.4.2/notionary/__init__.py

@@ -0,0 +1,62 @@
+from .data_source.service import NotionDataSource
+from .database.service import NotionDatabase
+from .file_upload import FileUploadQuery, FileUploadQueryBuilder, NotionFileUpload
+from .page.content import SyntaxPromptRegistry
+from .page.content.markdown.builder import MarkdownBuilder
+from .page.content.markdown.structured_output import (
+    MarkdownDocumentSchema,
+    StructuredOutputMarkdownConverter,
+)
+from .page.service import NotionPage
+from .workspace import (
+    NotionWorkspace,
+    NotionWorkspaceQueryConfigBuilder,
+    WorkspaceQueryConfig,
+)
+
+__all__ = [
+    "AudioSchema",
+    "BookmarkSchema",
+    "BreadcrumbSchema",
+    "BulletedListItemSchema",
+    "BulletedListSchema",
+    "CalloutSchema",
+    "CodeSchema",
+    "ColumnSchema",
+    "ColumnsSchema",
+    "DividerSchema",
+    "EmbedSchema",
+    "EquationSchema",
+    "FileSchema",
+    "FileUploadQuery",
+    "FileUploadQueryBuilder",
+    "Heading1Schema",
+    "Heading2Schema",
+    "Heading3Schema",
+    "ImageSchema",
+    "MarkdownBuilder",
+    "MarkdownDocumentSchema",
+    "MarkdownNodeSchema",
+    "MermaidSchema",
+    "NotionDataSource",
+    "NotionDatabase",
+    "NotionFileUpload",
+    "NotionPage",
+    "NotionWorkspace",
+    "NotionWorkspaceQueryConfigBuilder",
+    "NumberedListItemSchema",
+    "NumberedListSchema",
+    "ParagraphSchema",
+    "PdfSchema",
+    "QuoteSchema",
+    "SpaceSchema",
+    "StructuredOutputMarkdownConverter",
+    "SyntaxPromptRegistry",
+    "TableOfContentsSchema",
+    "TableSchema",
+    "TodoListSchema",
+    "TodoSchema",
+    "ToggleSchema",
+    "VideoSchema",
+    "WorkspaceQueryConfig",
+]

{notionary-0.4.0 → notionary-0.4.2}/notionary/blocks/client.py

@@ -31,9 +31,13 @@ class NotionBlockHttpClient(NotionHttpClient):
     async def get_all_block_children(self, parent_block_id: str) -> list[Block]:
         self.logger.debug("Retrieving all children for block: %s", parent_block_id)
 
-        all_blocks = await paginate_notion_api(self.get_block_children, block_id=parent_block_id)
+        all_blocks = await paginate_notion_api(
+            self.get_block_children, block_id=parent_block_id
+        )
 
-        self.logger.debug("Retrieved %d total children for block %s", len(all_blocks), parent_block_id)
+        self.logger.debug(
+            "Retrieved %d total children for block %s", len(all_blocks), parent_block_id
+        )
         return all_blocks
 
     async def get_block_children(
@@ -64,11 +68,17 @@ class NotionBlockHttpClient(NotionHttpClient):
 
         if len(batches) == 1:
             children_dicts = self._serialize_blocks(batches[0])
-            return await self._send_append_request(block_id, children_dicts, insert_after_block_id)
+            return await self._send_append_request(
+                block_id, children_dicts, insert_after_block_id
+            )
 
-        return await self._send_batched_append_requests(block_id, batches, insert_after_block_id)
+        return await self._send_batched_append_requests(
+            block_id, batches, insert_after_block_id
+        )
 
-    def _split_into_batches(self, blocks: list[BlockCreatePayload]) -> list[list[BlockCreatePayload]]:
+    def _split_into_batches(
+        self, blocks: list[BlockCreatePayload]
+    ) -> list[list[BlockCreatePayload]]:
         batches = []
         for i in range(0, len(blocks), self.BATCH_SIZE):
             batch = blocks[i : i + self.BATCH_SIZE]
@@ -89,19 +99,31 @@ class NotionBlockHttpClient(NotionHttpClient):
         return BlockChildrenResponse.model_validate(response)
 
     async def _send_batched_append_requests(
-        self, block_id: str, batches: list[list[BlockCreatePayload]], initial_after_block_id: str | None = None
+        self,
+        block_id: str,
+        batches: list[list[BlockCreatePayload]],
+        initial_after_block_id: str | None = None,
     ) -> BlockChildrenResponse:
         total_blocks = sum(len(batch) for batch in batches)
-        self.logger.info("Appending %d blocks in %d batches", total_blocks, len(batches))
+        self.logger.info(
+            "Appending %d blocks in %d batches", total_blocks, len(batches)
+        )
 
         all_responses = []
         after_block_id = initial_after_block_id
 
         for batch_index, batch in enumerate(batches, start=1):
-            self.logger.debug("Processing batch %d/%d (%d blocks)", batch_index, len(batches), len(batch))
+            self.logger.debug(
+                "Processing batch %d/%d (%d blocks)",
+                batch_index,
+                len(batches),
+                len(batch),
+            )
 
             children_dicts = self._serialize_blocks(batch)
-            response = await self._send_append_request(block_id, children_dicts, after_block_id)
+            response = await self._send_append_request(
+                block_id, children_dicts, after_block_id
+            )
             all_responses.append(response)
 
             if response.results:
@@ -112,9 +134,13 @@ class NotionBlockHttpClient(NotionHttpClient):
         self.logger.info("Successfully appended all blocks in %d batches", len(batches))
         return self._merge_responses(all_responses)
 
-    def _merge_responses(self, responses: list[BlockChildrenResponse]) -> BlockChildrenResponse:
+    def _merge_responses(
+        self, responses: list[BlockChildrenResponse]
+    ) -> BlockChildrenResponse:
         if not responses:
-            raise ValueError("Cannot merge empty response list - this should never happen")
+            raise ValueError(
+                "Cannot merge empty response list - this should never happen"
+            )
 
         first_response = responses[0]
         all_results = [block for response in responses for block in response.results]

{notionary-0.4.0 → notionary-0.4.2}/notionary/blocks/rich_text/markdown_rich_text_converter.py

@@ -4,7 +4,12 @@ from dataclasses import dataclass
 from re import Match
 from typing import ClassVar
 
-from notionary.blocks.rich_text.models import MentionType, RichText, RichTextType, TextAnnotations
+from notionary.blocks.rich_text.models import (
+    MentionType,
+    RichText,
+    RichTextType,
+    TextAnnotations,
+)
 from notionary.blocks.rich_text.name_id_resolver import (
     DatabaseNameIdResolver,
     DataSourceNameIdResolver,
@@ -58,17 +63,32 @@ class MarkdownRichTextConverter:
         return [
             PatternHandler(RichTextPatterns.BOLD, self._handle_bold_pattern),
             PatternHandler(RichTextPatterns.ITALIC, self._handle_italic_pattern),
-            PatternHandler(RichTextPatterns.ITALIC_UNDERSCORE, self._handle_italic_pattern),
+            PatternHandler(
+                RichTextPatterns.ITALIC_UNDERSCORE, self._handle_italic_pattern
+            ),
             PatternHandler(RichTextPatterns.UNDERLINE, self._handle_underline_pattern),
-            PatternHandler(RichTextPatterns.STRIKETHROUGH, self._handle_strikethrough_pattern),
+            PatternHandler(
+                RichTextPatterns.STRIKETHROUGH, self._handle_strikethrough_pattern
+            ),
             PatternHandler(RichTextPatterns.CODE, self._handle_code_pattern),
             PatternHandler(RichTextPatterns.LINK, self._handle_link_pattern),
-            PatternHandler(RichTextPatterns.INLINE_EQUATION, self._handle_equation_pattern),
+            PatternHandler(
+                RichTextPatterns.INLINE_EQUATION, self._handle_equation_pattern
+            ),
             PatternHandler(RichTextPatterns.COLOR, self._handle_color_pattern),
-            PatternHandler(RichTextPatterns.PAGE_MENTION, self._handle_page_mention_pattern),
-            PatternHandler(RichTextPatterns.DATABASE_MENTION, self._handle_database_mention_pattern),
-            PatternHandler(RichTextPatterns.DATASOURCE_MENTION, self._handle_data_source_mention_pattern),
-            PatternHandler(RichTextPatterns.USER_MENTION, self._handle_user_mention_pattern),
+            PatternHandler(
+                RichTextPatterns.PAGE_MENTION, self._handle_page_mention_pattern
+            ),
+            PatternHandler(
+                RichTextPatterns.DATABASE_MENTION, self._handle_database_mention_pattern
+            ),
+            PatternHandler(
+                RichTextPatterns.DATASOURCE_MENTION,
+                self._handle_data_source_mention_pattern,
+            ),
+            PatternHandler(
+                RichTextPatterns.USER_MENTION, self._handle_user_mention_pattern
+            ),
         ]
 
     async def to_rich_text(self, text: str) -> list[RichText]:
@@ -106,12 +126,16 @@ class MarkdownRichTextConverter:
         for pattern_handler in self.format_handlers:
             match = re.search(pattern_handler.pattern, text)
             if match and match.start() < earliest_position:
-                earliest_match = PatternMatch(match=match, handler=pattern_handler.handler, position=match.start())
+                earliest_match = PatternMatch(
+                    match=match, handler=pattern_handler.handler, position=match.start()
+                )
                 earliest_position = match.start()
 
         return earliest_match
 
-    async def _process_pattern_match(self, pattern_match: PatternMatch) -> RichText | list[RichText]:
+    async def _process_pattern_match(
+        self, pattern_match: PatternMatch
+    ) -> RichText | list[RichText]:
         handler_method = pattern_match.handler
 
         if self._is_async_handler(handler_method):
@@ -169,9 +193,13 @@ class MarkdownRichTextConverter:
     def _apply_color_to_link_segment(self, segment: RichText, color: str) -> RichText:
         formatting = self._extract_formatting_attributes(segment.annotations)
 
-        return RichText.for_link(segment.plain_text, segment.text.link.url, color=color, **formatting)
+        return RichText.for_link(
+            segment.plain_text, segment.text.link.url, color=color, **formatting
+        )
 
-    def _apply_color_to_plain_text_segment(self, segment: RichText, color: str) -> RichText:
+    def _apply_color_to_plain_text_segment(
+        self, segment: RichText, color: str
+    ) -> RichText:
         if segment.type != RichTextType.TEXT:
             return segment
 
@@ -179,7 +207,9 @@ class MarkdownRichTextConverter:
 
         return RichText.from_plain_text(segment.plain_text, color=color, **formatting)
 
-    def _extract_formatting_attributes(self, annotations: TextAnnotations) -> dict[str, bool]:
+    def _extract_formatting_attributes(
+        self, annotations: TextAnnotations
+    ) -> dict[str, bool]:
         if not annotations:
             return {
                 "bold": False,
@@ -246,13 +276,17 @@ class MarkdownRichTextConverter:
             if resolved_id:
                 return create_mention_func(resolved_id)
             else:
-                return self._create_unresolved_mention_fallback(identifier, mention_type)
+                return self._create_unresolved_mention_fallback(
+                    identifier, mention_type
+                )
 
         except Exception:
             # If resolution throws an error, fallback to plain text
             return self._create_unresolved_mention_fallback(identifier, mention_type)
 
-    def _create_unresolved_mention_fallback(self, identifier: str, mention_type: MentionType) -> RichText:
+    def _create_unresolved_mention_fallback(
+        self, identifier: str, mention_type: MentionType
+    ) -> RichText:
         fallback_text = f"@{mention_type.value}[{identifier}]"
         return RichText.for_caption(fallback_text)
 

{notionary-0.4.0 → notionary-0.4.2}/notionary/blocks/rich_text/models.py

@@ -140,7 +140,9 @@ class RichText(BaseModel):
     def mention_user(cls, user_id: str) -> Self:
         return cls(
             type=RichTextType.MENTION,
-            mention=MentionObject(type=MentionType.USER, user=MentionUserRef(id=user_id)),
+            mention=MentionObject(
+                type=MentionType.USER, user=MentionUserRef(id=user_id)
+            ),
             annotations=TextAnnotations(),
         )
 
@@ -148,7 +150,9 @@ class RichText(BaseModel):
     def mention_page(cls, page_id: str) -> Self:
         return cls(
             type=RichTextType.MENTION,
-            mention=MentionObject(type=MentionType.PAGE, page=MentionPageRef(id=page_id)),
+            mention=MentionObject(
+                type=MentionType.PAGE, page=MentionPageRef(id=page_id)
+            ),
             annotations=TextAnnotations(),
         )
 
@@ -156,7 +160,9 @@ class RichText(BaseModel):
     def mention_database(cls, database_id: str) -> Self:
         return cls(
             type=RichTextType.MENTION,
-            mention=MentionObject(type=MentionType.DATABASE, database=MentionDatabaseRef(id=database_id)),
+            mention=MentionObject(
+                type=MentionType.DATABASE, database=MentionDatabaseRef(id=database_id)
+            ),
             annotations=TextAnnotations(),
         )
 
@@ -164,7 +170,10 @@ class RichText(BaseModel):
     def mention_data_source(cls, data_source_id: str) -> Self:
         return cls(
             type=RichTextType.MENTION,
-            mention=MentionObject(type=MentionType.DATASOURCE, data_source=MentionDataSourceRef(id=data_source_id)),
+            mention=MentionObject(
+                type=MentionType.DATASOURCE,
+                data_source=MentionDataSourceRef(id=data_source_id),
+            ),
             annotations=TextAnnotations(),
         )
 

{notionary-0.4.0 → notionary-0.4.2}/notionary/blocks/rich_text/name_id_resolver/data_source.py

@@ -6,8 +6,12 @@ from notionary.workspace.query.service import WorkspaceQueryService
 
 # !!! in the notion api mentions that reference datasources are not provided yet (it's a limiation of the API as of now)
 class DataSourceNameIdResolver(NameIdResolver):
-    def __init__(self, workspace_query_service: WorkspaceQueryService | None = None) -> None:
-        self._workspace_query_service = workspace_query_service or WorkspaceQueryService()
+    def __init__(
+        self, workspace_query_service: WorkspaceQueryService | None = None
+    ) -> None:
+        self._workspace_query_service = (
+            workspace_query_service or WorkspaceQueryService()
+        )
 
     @override
     async def resolve_name_to_id(self, name: str) -> str | None:
@@ -15,7 +19,9 @@ class DataSourceNameIdResolver(NameIdResolver):
             return None
 
         cleaned_name = name.strip()
-        data_source = await self._workspace_query_service.find_data_source(query=cleaned_name)
+        data_source = await self._workspace_query_service.find_data_source(
+            query=cleaned_name
+        )
         return data_source.id if data_source else None
 
     @override

{notionary-0.4.0 → notionary-0.4.2}/notionary/blocks/rich_text/name_id_resolver/person.py

@@ -6,7 +6,9 @@ from notionary.user.person import PersonUser
 
 
 class PersonNameIdResolver(NameIdResolver):
-    def __init__(self, person_user_factory=None, http_client: UserHttpClient | None = None) -> None:
+    def __init__(
+        self, person_user_factory=None, http_client: UserHttpClient | None = None
+    ) -> None:
         if person_user_factory is None:
             person_user_factory = PersonUser
         self.person_user_factory = person_user_factory
@@ -31,7 +33,9 @@ class PersonNameIdResolver(NameIdResolver):
             return None
 
         try:
-            user = await self.person_user_factory.from_id(user_id.strip(), self.http_client)
+            user = await self.person_user_factory.from_id(
+                user_id.strip(), self.http_client
+            )
             return user.name if user else None
         except Exception:
             return None

{notionary-0.4.0 → notionary-0.4.2}/notionary/blocks/rich_text/rich_text_markdown_converter.py

@@ -69,7 +69,9 @@ class RichTextToMarkdownConverter:
             return await self._extract_database_mention_markdown(mention.database.id)
 
         elif mention.type == MentionType.DATASOURCE and mention.data_source:
-            return await self._extract_data_source_mention_markdown(mention.data_source.id)
+            return await self._extract_data_source_mention_markdown(
+                mention.data_source.id
+            )
 
         elif mention.type == MentionType.USER and mention.user:
             return await self._extract_user_mention_markdown(mention.user.id)
@@ -88,7 +90,9 @@ class RichTextToMarkdownConverter:
         return f"@database[{database_name or database_id}]"
 
     async def _extract_data_source_mention_markdown(self, data_source_id: str) -> str:
-        data_source_name = await self.data_source_resolver.resolve_id_to_name(data_source_id)
+        data_source_name = await self.data_source_resolver.resolve_id_to_name(
+            data_source_id
+        )
         return f"@datasource[{data_source_name or data_source_id}]"
 
     async def _extract_user_mention_markdown(self, user_id: str) -> str:
@@ -121,7 +125,10 @@ class RichTextToMarkdownConverter:
         if annotations.bold:
             content = f"**{content}**"
 
-        if annotations.color != BlockColor.DEFAULT and annotations.color in self.VALID_COLORS:
+        if (
+            annotations.color != BlockColor.DEFAULT
+            and annotations.color in self.VALID_COLORS
+        ):
             content = f"({annotations.color}:{content})"
 
         return content

{notionary-0.4.0 → notionary-0.4.2}/notionary/blocks/schemas.py

@@ -34,7 +34,8 @@ class FileUploadFileWithCaption(CaptionMixin, FileUploadFile):
 
 
 type FileWithCaption = Annotated[
-    ExternalFileWithCaption | NotionHostedFileWithCaption | FileUploadFileWithCaption, Field(discriminator="type")
+    ExternalFileWithCaption | NotionHostedFileWithCaption | FileUploadFileWithCaption,
+    Field(discriminator="type"),
 ]
 
 

{notionary-0.4.0 → notionary-0.4.2}/notionary/comments/client.py

@@ -8,7 +8,10 @@ from notionary.comments.schemas import (
     CommentListResponse,
 )
 from notionary.http.client import NotionHttpClient
-from notionary.utils.pagination import paginate_notion_api, paginate_notion_api_generator
+from notionary.utils.pagination import (
+    paginate_notion_api,
+    paginate_notion_api_generator,
+)
 
 
 class CommentClient(NotionHttpClient):
@@ -21,16 +24,24 @@ class CommentClient(NotionHttpClient):
         total_results_limit: int | None = None,
     ) -> AsyncGenerator[CommentDto]:
         async for comment in paginate_notion_api_generator(
-            self._list_comments_page, block_id=block_id, total_results_limit=total_results_limit
+            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, *, total_results_limit: int | None = None) -> list[CommentDto]:
+    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._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)
+        self.logger.debug(
+            "Retrieved %d total comments for block %s", len(all_comments), block_id
+        )
         return all_comments
 
     async def _list_comments_page(
@@ -65,7 +76,9 @@ class CommentClient(NotionHttpClient):
         rich_text: list[RichText],
         discussion_id: str,
     ) -> CommentDto:
-        request = CommentCreateRequest.for_discussion(discussion_id=discussion_id, rich_text=rich_text)
+        request = CommentCreateRequest.for_discussion(
+            discussion_id=discussion_id, rich_text=rich_text
+        )
 
         body = request.model_dump(exclude_unset=True, exclude_none=True)
 

{notionary-0.4.0 → notionary-0.4.2}/notionary/comments/factory.py

@@ -1,6 +1,8 @@
 import asyncio
 
-from notionary.blocks.rich_text.rich_text_markdown_converter import RichTextToMarkdownConverter
+from notionary.blocks.rich_text.rich_text_markdown_converter import (
+    RichTextToMarkdownConverter,
+)
 from notionary.comments.models import Comment
 from notionary.comments.schemas import CommentDto
 from notionary.user.base import BaseUser
@@ -20,7 +22,9 @@ class CommentFactory(LoggingMixin):
         self.markdown_converter = markdown_converter or RichTextToMarkdownConverter()
 
     async def create_from_dto(self, dto: CommentDto) -> Comment:
-        author_name, content = await asyncio.gather(self._resolve_user_name(dto), self._resolve_content(dto))
+        author_name, content = await asyncio.gather(
+            self._resolve_user_name(dto), self._resolve_content(dto)
+        )
 
         return Comment(author_name=author_name, content=content)
 
@@ -30,7 +34,10 @@ class CommentFactory(LoggingMixin):
         try:
             return await BaseUser.from_id_auto(created_by_id, self.http_client)
         except Exception:
-            self.logger.warning(f"Failed to resolve user name for user_id: {created_by_id}", exc_info=True)
+            self.logger.warning(
+                f"Failed to resolve user name for user_id: {created_by_id}",
+                exc_info=True,
+            )
 
         return self.UNKNOWN_AUTHOR
 

{notionary-0.4.0 → notionary-0.4.2}/notionary/comments/schemas.py

@@ -61,7 +61,9 @@ class CommentAttachmentFileUploadType(StrEnum):
 
 class CommentAttachmentInput(BaseModel):
     file_upload_id: str
-    type: Literal[CommentAttachmentFileUploadType.FILE_UPLOAD] = CommentAttachmentFileUploadType.FILE_UPLOAD
+    type: Literal[CommentAttachmentFileUploadType.FILE_UPLOAD] = (
+        CommentAttachmentFileUploadType.FILE_UPLOAD
+    )
 
 
 # ---------------------------
@@ -80,7 +82,9 @@ class CustomDisplayName(BaseModel):
 
 
 class IntegrationDisplayName(BaseModel):
-    type: Literal[CommentDisplayNameType.INTEGRATION] = CommentDisplayNameType.INTEGRATION
+    type: Literal[CommentDisplayNameType.INTEGRATION] = (
+        CommentDisplayNameType.INTEGRATION
+    )
 
 
 class UserDisplayName(BaseModel):
@@ -92,7 +96,9 @@ class CustomCommentDisplayName(BaseModel):
     custom: CustomDisplayName
 
 
-type CommentDisplayNameInput = IntegrationDisplayName | UserDisplayName | CustomCommentDisplayName
+type CommentDisplayNameInput = (
+    IntegrationDisplayName | UserDisplayName | CustomCommentDisplayName
+)
 
 
 class CommentDisplayNameDto(BaseModel):

{notionary-0.4.0 → notionary-0.4.2}/notionary/comments/service.py

@@ -1,6 +1,8 @@
 import asyncio
 
-from notionary.blocks.rich_text.markdown_rich_text_converter import MarkdownRichTextConverter
+from notionary.blocks.rich_text.markdown_rich_text_converter import (
+    MarkdownRichTextConverter,
+)
 from notionary.comments.client import CommentClient
 from notionary.comments.factory import CommentFactory
 from notionary.comments.models import Comment
@@ -20,15 +22,21 @@ class CommentService:
     async def list_all_comments_for_page(self, page_id: str) -> list[Comment]:
         comment_dtos = [dto async for dto in self.client.iter_comments(page_id)]
 
-        comments = await asyncio.gather(*(self.factory.create_from_dto(dto) for dto in comment_dtos))
+        comments = await asyncio.gather(
+            *(self.factory.create_from_dto(dto) for dto in comment_dtos)
+        )
         return comments
 
     async def create_comment_on_page(self, page_id: str, text: str) -> Comment:
         rich_text = await self._converter.to_rich_text(text)
-        comment_dto = await self.client.create_comment_for_page(rich_text=rich_text, page_id=page_id)
+        comment_dto = await self.client.create_comment_for_page(
+            rich_text=rich_text, page_id=page_id
+        )
         return await self.factory.create_from_dto(comment_dto)
 
     async def reply_to_discussion_by_id(self, discussion_id: str, text: str) -> Comment:
         rich_text = await self._converter.to_rich_text(text)
-        comment_dto = await self.client.create_comment_for_discussion(rich_text=rich_text, discussion_id=discussion_id)
+        comment_dto = await self.client.create_comment_for_discussion(
+            rich_text=rich_text, discussion_id=discussion_id
+        )
         return await self.factory.create_from_dto(comment_dto)