symphony_bdk_python 2.10.dev0__py3-none-any.whl → 2.11.0__py3-none-any.whl

symphony/bdk/core/service/message/message_service.py

@@ -1,16 +1,21 @@
-from typing import Union, List, Tuple, IO, AsyncGenerator
+from typing import IO, AsyncGenerator, List, Tuple, Union
 
 from symphony.bdk.core.auth.auth_session import AuthSession
 from symphony.bdk.core.config.model.bdk_retry_config import BdkRetryConfig
+from symphony.bdk.core.retry import retry
 from symphony.bdk.core.service.message.model import Message
-from symphony.bdk.core.service.message.multi_attachments_messages_api import MultiAttachmentsMessagesApi
+from symphony.bdk.core.service.message.multi_attachments_messages_api import (
+    MultiAttachmentsMessagesApi,
+)
 from symphony.bdk.core.service.pagination import offset_based_pagination
 from symphony.bdk.gen.agent_api.attachments_api import AttachmentsApi
 from symphony.bdk.gen.agent_model.message_search_query import MessageSearchQuery
 from symphony.bdk.gen.agent_model.v4_import_response import V4ImportResponse
 from symphony.bdk.gen.agent_model.v4_imported_message import V4ImportedMessage
 from symphony.bdk.gen.agent_model.v4_message import V4Message
-from symphony.bdk.gen.agent_model.v4_message_blast_response import V4MessageBlastResponse
+from symphony.bdk.gen.agent_model.v4_message_blast_response import (
+    V4MessageBlastResponse,
+)
 from symphony.bdk.gen.agent_model.v4_message_import_list import V4MessageImportList
 from symphony.bdk.gen.pod_api.default_api import DefaultApi
 from symphony.bdk.gen.pod_api.message_api import MessageApi
@@ -18,32 +23,40 @@ from symphony.bdk.gen.pod_api.message_suppression_api import MessageSuppressionA
 from symphony.bdk.gen.pod_api.pod_api import PodApi
 from symphony.bdk.gen.pod_api.streams_api import StreamsApi
 from symphony.bdk.gen.pod_model.message_metadata_response import MessageMetadataResponse
-from symphony.bdk.gen.pod_model.message_receipt_detail_response import MessageReceiptDetailResponse
+from symphony.bdk.gen.pod_model.message_receipt_detail_response import (
+    MessageReceiptDetailResponse,
+)
 from symphony.bdk.gen.pod_model.message_status import MessageStatus
-from symphony.bdk.gen.pod_model.message_suppression_response import MessageSuppressionResponse
+from symphony.bdk.gen.pod_model.message_suppression_response import (
+    MessageSuppressionResponse,
+)
 from symphony.bdk.gen.pod_model.stream_attachment_item import StreamAttachmentItem
 
-from symphony.bdk.core.retry import retry
-
 
 class OboMessageService:
     """Class exposing OBO enabled endpoints for message management, e.g. send a message."""
 
-    def __init__(self, messages_api: MultiAttachmentsMessagesApi, message_suppression_api: MessageSuppressionApi,
-                 auth_session: AuthSession,
-                 retry_config: BdkRetryConfig):
+    def __init__(
+        self,
+        messages_api: MultiAttachmentsMessagesApi,
+        message_suppression_api: MessageSuppressionApi,
+        pod_api: PodApi,
+        auth_session: AuthSession,
+        retry_config: BdkRetryConfig,
+    ):
         self._messages_api = messages_api
         self._message_suppression_api = message_suppression_api
+        self._pod_api = pod_api
         self._auth_session = auth_session
         self._retry_config = retry_config
 
     async def send_message(
-            self,
-            stream_id: str,
-            message: Union[str, Message],
-            data=None,
-            version: str = "",
-            attachment: List[Union[IO, Tuple[IO, IO]]] = None
+        self,
+        stream_id: str,
+        message: Union[str, Message],
+        data=None,
+        version: str = "",
+        attachment: List[Union[IO, Tuple[IO, IO]]] = None,
     ) -> V4Message:
         """Send a message to an existing stream.
         See: `Create Message <https://developers.symphony.com/restapi/reference/create-message-v4>`_
@@ -62,20 +75,29 @@ class OboMessageService:
 
         :return: a V4Message object containing the details of the sent message.
         """
-        message_object = message if isinstance(message, Message) else Message(content=message, data=data,
-                                                                              version=version, attachments=attachment)
-        return await self._send_message(stream_id, message_object.content, message_object.data, message_object.version,
-                                        message_object.attachments, message_object.previews)
+        message_object = (
+            message
+            if isinstance(message, Message)
+            else Message(content=message, data=data, version=version, attachments=attachment)
+        )
+        return await self._send_message(
+            stream_id,
+            message_object.content,
+            message_object.data,
+            message_object.version,
+            message_object.attachments,
+            message_object.previews,
+        )
 
     @retry
     async def _send_message(
-            self,
-            stream_id: str,
-            message: str,
-            data: str = "",
-            version: str = "",
-            attachment: List[IO] = None,
-            preview: List[IO] = None
+        self,
+        stream_id: str,
+        message: str,
+        data: str = "",
+        version: str = "",
+        attachment: List[IO] = None,
+        preview: List[IO] = None,
     ) -> V4Message:
         """Send a message to an existing stream.
         See: `Create Message <https://developers.symphony.com/restapi/reference/create-message-v4>`_
@@ -98,7 +120,7 @@ class OboMessageService:
             "key_manager_token": await self._auth_session.key_manager_token,
             "message": message,
             "data": data,
-            "version": version
+            "version": version,
         }
         if attachment is not None:
             params["attachment"] = attachment if isinstance(attachment, list) else [attachment]
@@ -108,10 +130,7 @@ class OboMessageService:
         return await self._messages_api.v4_stream_sid_multi_attachment_message_create_post(**params)
 
     @retry
-    async def suppress_message(
-            self,
-            message_id: str
-    ) -> MessageSuppressionResponse:
+    async def suppress_message(self, message_id: str) -> MessageSuppressionResponse:
         """Suppresses a message, preventing its contents from being displayed to users.
         See: `Suppress Message <https://developers.symphony.com/restapi/reference/suppress-message>`_
 
@@ -122,9 +141,55 @@ class OboMessageService:
         """
         params = {
             "id": message_id,
-            "session_token": await self._auth_session.session_token
+            "session_token": await self._auth_session.session_token,
         }
-        return await self._message_suppression_api.v1_admin_messagesuppression_id_suppress_post(**params)
+        return await self._message_suppression_api.v1_admin_messagesuppression_id_suppress_post(
+            **params
+        )
+
+    @retry
+    async def update_message(
+        self,
+        stream_id: str,
+        message_id: str,
+        message: Union[str, Message],
+        data=None,
+        version: str = "",
+        silent=True,
+    ) -> V4Message:
+        """Update an existing message. The existing message must be a valid social message, that has not been deleted.
+        See: `Update Message <https://developers.symphony.com/restapi/reference/update-message-v4>`_
+
+        :param stream_id: The ID of the stream where the message is being updated.
+        :param message_id: The ID of the message that is being updated.
+        :param message: a :py:class:`Message` instance or a string containing the MessageML content to be sent.
+          If it is a :py:class:`Message` instance, other parameters will be ignored.
+          If it is a string, ``<messageML>`` tags can be omitted.
+        :param data: an object (e.g. dict) that will be serialized into JSON using ``json.dumps``.
+        :param silent: a bool flag that will determine if the updated message is going to be marked as read (when true,
+          which is default value) or unread (when false).
+        :param version: Optional message version in the format "major.minor".
+          If empty, defaults to the latest supported version.
+
+        :return: a V4Message object containing the details of the updated message.
+        """
+        message_object = (
+            message
+            if isinstance(message, Message)
+            else Message(content=message, data=data, silent=silent, version=version)
+        )
+
+        params = {
+            "sid": stream_id,
+            "mid": message_id,
+            "session_token": await self._auth_session.session_token,
+            "key_manager_token": await self._auth_session.key_manager_token,
+            "message": message_object.content,
+            "data": message_object.data,
+            "version": message_object.version,
+            "silent": str(message_object.silent),
+        }
+        return await self._messages_api.v4_stream_sid_message_mid_update_post(**params)
 
     @retry
     async def get_attachment_types(self) -> List[str]:
@@ -134,19 +199,17 @@ class OboMessageService:
         :return: a list of String containing all allowed file extensions for attachments.
 
         """
-        params = {
-            "session_token": await self._auth_session.session_token
-        }
+        params = {"session_token": await self._auth_session.session_token}
         type_list = await self._pod_api.v1_files_allowed_types_get(**params)
         return type_list.value
-    
+
     async def blast_message(
-            self,
-            stream_ids: List[str],
-            message: Union[str, Message],
-            data=None,
-            version: str = "",
-            attachment: List[Union[IO, Tuple[IO, IO]]] = None
+        self,
+        stream_ids: List[str],
+        message: Union[str, Message],
+        data=None,
+        version: str = "",
+        attachment: List[Union[IO, Tuple[IO, IO]]] = None,
     ) -> V4MessageBlastResponse:
         """Send a message to multiple existing streams.
         See: `Blast Message <https://developers.symphony.com/restapi/reference/blast-message>`_
@@ -164,20 +227,29 @@ class OboMessageService:
           The limit is set to 30Mb total size; also, it is recommended not to exceed 25 files.
         :return:
         """
-        message_object = message if isinstance(message, Message) else Message(content=message, data=data,
-                                                                              version=version, attachments=attachment)
-        return await self._blast_message(stream_ids, message_object.content, message_object.data,
-                                         message_object.version, message_object.attachments, message_object.previews)
-        
+        message_object = (
+            message
+            if isinstance(message, Message)
+            else Message(content=message, data=data, version=version, attachments=attachment)
+        )
+        return await self._blast_message(
+            stream_ids,
+            message_object.content,
+            message_object.data,
+            message_object.version,
+            message_object.attachments,
+            message_object.previews,
+        )
+
     @retry
     async def _blast_message(
-            self,
-            stream_ids: [str],
-            message: str,
-            data: str = "",
-            version: str = "",
-            attachment: List[IO] = None,
-            preview: List[IO] = None
+        self,
+        stream_ids: List[str],
+        message: str,
+        data: str = "",
+        version: str = "",
+        attachment: List[IO] = None,
+        preview: List[IO] = None,
     ) -> V4MessageBlastResponse:
         """Send a message to multiple existing streams.
         See: `Blast Message <https://developers.symphony.com/restapi/reference/blast-message>`_
@@ -200,7 +272,7 @@ class OboMessageService:
             "key_manager_token": await self._auth_session.key_manager_token,
             "message": message,
             "data": data,
-            "version": version
+            "version": version,
         }
         if attachment is not None:
             params["attachment"] = attachment if isinstance(attachment, list) else [attachment]
@@ -211,33 +283,30 @@ class OboMessageService:
 
 
 class MessageService(OboMessageService):
-    """Service class for managing messages.
-    """
-
-    def __init__(self, messages_api: MultiAttachmentsMessagesApi,
-                 message_api: MessageApi,
-                 message_suppression_api: MessageSuppressionApi,
-                 streams_api: StreamsApi,
-                 pod_api: PodApi,
-                 attachment_api: AttachmentsApi,
-                 default_api: DefaultApi,
-                 auth_session: AuthSession,
-                 retry_config: BdkRetryConfig):
-        super().__init__(messages_api, message_suppression_api, auth_session, retry_config)
+    """Service class for managing messages."""
+
+    def __init__(
+        self,
+        messages_api: MultiAttachmentsMessagesApi,
+        message_api: MessageApi,
+        message_suppression_api: MessageSuppressionApi,
+        streams_api: StreamsApi,
+        pod_api: PodApi,
+        attachment_api: AttachmentsApi,
+        default_api: DefaultApi,
+        auth_session: AuthSession,
+        retry_config: BdkRetryConfig,
+    ):
+        super().__init__(messages_api, message_suppression_api, pod_api, auth_session, retry_config)
         self._message_api = message_api
         self._message_suppression_api = message_suppression_api
         self._streams_api = streams_api
-        self._pod_api = pod_api
         self._attachment_api = attachment_api
         self._default_api = default_api
 
     @retry
     async def list_messages(
-            self,
-            stream_id: str,
-            since: int = 0,
-            skip: int = 0,
-            limit: int = 50
+        self, stream_id: str, since: int = 0, skip: int = 0, limit: int = 50
     ) -> [V4Message]:
         """Get messages from an existing stream. Additionally returns any attachments associated with the message.
         See: `Messages <https://developers.symphony.com/restapi/reference/messages-v4>`_
@@ -256,16 +325,13 @@ class MessageService(OboMessageService):
             "session_token": await self._auth_session.session_token,
             "key_manager_token": await self._auth_session.key_manager_token,
             "skip": skip,
-            "limit": limit
+            "limit": limit,
         }
         message_list = await self._messages_api.v4_stream_sid_message_get(**params)
         return message_list.value
 
     @retry
-    async def import_messages(
-            self,
-            messages: List[V4ImportedMessage]
-    ) -> [V4ImportResponse]:
+    async def import_messages(self, messages: List[V4ImportedMessage]) -> [V4ImportResponse]:
         """Imports a list of messages to Symphony.
         See: `Import Message <https://developers.symphony.com/restapi/reference/import-message-v4>`_
 
@@ -277,17 +343,12 @@ class MessageService(OboMessageService):
         params = {
             "message_list": V4MessageImportList(value=messages),
             "session_token": await self._auth_session.session_token,
-            "key_manager_token": await self._auth_session.key_manager_token
+            "key_manager_token": await self._auth_session.key_manager_token,
         }
         import_response_list = await self._messages_api.v4_message_import_post(**params)
         return import_response_list.value
 
-    async def get_attachment(
-            self,
-            stream_id: str,
-            message_id: str,
-            attachment_id: str
-    ) -> str:
+    async def get_attachment(self, stream_id: str, message_id: str, attachment_id: str) -> str:
         """Downloads the attachment body by the stream ID, message ID and attachment ID.
         See: `Attachment <https://developers.symphony.com/restapi/reference/attachment>`_
 
@@ -303,14 +364,11 @@ class MessageService(OboMessageService):
             "file_id": attachment_id,
             "message_id": message_id,
             "session_token": await self._auth_session.session_token,
-            "key_manager_token": await self._auth_session.key_manager_token
+            "key_manager_token": await self._auth_session.key_manager_token,
         }
         return await self._attachment_api.v1_stream_sid_attachment_get(**params)
 
-    async def get_message_status(
-            self,
-            message_id: str
-    ) -> MessageStatus:
+    async def get_message_status(self, message_id: str) -> MessageStatus:
         """Get the status of a particular message, i.e the list of users who the message was sent to,
         delivered to and the list of users who read the message.
         See: `Message Status <https://developers.symphony.com/restapi/reference/message-status>`_
@@ -322,15 +380,12 @@ class MessageService(OboMessageService):
         """
         params = {
             "mid": message_id,
-            "session_token": await self._auth_session.session_token
+            "session_token": await self._auth_session.session_token,
         }
         return await self._message_api.v1_message_mid_status_get(**params)
 
     @retry
-    async def get_message(
-            self,
-            message_id: str
-    ) -> V4Message:
+    async def get_message(self, message_id: str) -> V4Message:
         """Retrieves the details of a message given its message ID.
         See: `Get Message <https://developers.symphony.com/restapi/reference/get-message-v1>`_
 
@@ -342,18 +397,18 @@ class MessageService(OboMessageService):
         params = {
             "id": message_id,
             "session_token": await self._auth_session.session_token,
-            "key_manager_token": await self._auth_session.key_manager_token
+            "key_manager_token": await self._auth_session.key_manager_token,
         }
         return await self._messages_api.v1_message_id_get(**params)
 
     @retry
     async def list_attachments(
-            self,
-            stream_id: str,
-            since: int = None,
-            to: int = None,
-            limit: int = 50,
-            sort_dir: str = "ASC"
+        self,
+        stream_id: str,
+        since: int = None,
+        to: int = None,
+        limit: int = 50,
+        sort_dir: str = "ASC",
     ) -> List[StreamAttachmentItem]:
         """List attachments in a particular stream.
         See: `List Attachments <https://developers.symphony.com/restapi/reference/list-attachments>`_
@@ -372,7 +427,7 @@ class MessageService(OboMessageService):
             "sid": stream_id,
             "session_token": await self._auth_session.session_token,
             "limit": limit,
-            "sort_dir": sort_dir
+            "sort_dir": sort_dir,
         }
         if since is not None:
             params["since"] = since
@@ -382,10 +437,7 @@ class MessageService(OboMessageService):
         return attachment_list.value
 
     @retry
-    async def list_message_receipts(
-            self,
-            message_id: str
-    ) -> MessageReceiptDetailResponse:
+    async def list_message_receipts(self, message_id: str) -> MessageReceiptDetailResponse:
         """Fetches receipts details from a specific message.
         See: `List Message Receipts <https://developers.symphony.com/restapi/reference/list-message-receipts>`_
 
@@ -396,15 +448,12 @@ class MessageService(OboMessageService):
         """
         params = {
             "message_id": message_id,
-            "session_token": await self._auth_session.session_token
+            "session_token": await self._auth_session.session_token,
         }
         return await self._default_api.v1_admin_messages_message_id_receipts_get(**params)
 
     @retry
-    async def get_message_relationships(
-            self,
-            message_id: str
-    ) -> MessageMetadataResponse:
+    async def get_message_relationships(self, message_id: str) -> MessageMetadataResponse:
         """Gets the message metadata relationship.
         This API allows users to track the relationship between a message and all the forwards and replies of that
         message.
@@ -418,13 +467,20 @@ class MessageService(OboMessageService):
         params = {
             "message_id": message_id,
             "session_token": await self._auth_session.session_token,
-            "user_agent": ""
+            "user_agent": "",
         }
-        return await self._default_api.v1_admin_messages_message_id_metadata_relationships_get(**params)
+        return await self._default_api.v1_admin_messages_message_id_metadata_relationships_get(
+            **params
+        )
 
     @retry
-    async def search_messages(self, query: MessageSearchQuery, sort_dir: str = "desc", skip: int = 0,
-                              limit: int = 50) -> List[V4Message]:
+    async def search_messages(
+        self,
+        query: MessageSearchQuery,
+        sort_dir: str = "desc",
+        skip: int = 0,
+        limit: int = 50,
+    ) -> List[V4Message]:
         """Searches for messages in the context of a specified user, given an argument-based query and pagination
         attributes (skip and limit parameters).
         See: `Message Search (using POST) <https://developers.symphony.com/restapi/reference/message-search-post>`_
@@ -442,13 +498,18 @@ class MessageService(OboMessageService):
             "query": query,
             "sort_dir": sort_dir,
             "skip": skip,
-            "limit": limit
+            "limit": limit,
         }
         message_list = await self._messages_api.v1_message_search_post(**params)
         return message_list.value  # endpoint returns empty list when no values found
 
-    async def search_all_messages(self, query: MessageSearchQuery, sort_dir: str = "desc", chunk_size: int = 50,
-                                  max_number: int = None) -> AsyncGenerator[V4Message, None]:
+    async def search_all_messages(
+        self,
+        query: MessageSearchQuery,
+        sort_dir: str = "desc",
+        chunk_size: int = 50,
+        max_number: int = None,
+    ) -> AsyncGenerator[V4Message, None]:
         """Searches for messages in the context of a specified user, given an argument-based query.
         See: `Message Search (using POST) <https://developers.symphony.com/restapi/reference/message-search-post>`_
 
@@ -464,48 +525,22 @@ class MessageService(OboMessageService):
 
         return offset_based_pagination(search_messages_one_page, chunk_size, max_number)
 
-    @retry
-    async def update_message(self, stream_id: str, message_id: str, message: Union[str, Message], data=None,
-                             version: str = "", silent=True) -> V4Message:
-        """Update an existing message. The existing message must be a valid social message, that has not been deleted.
-        See: `Update Message <https://developers.symphony.com/restapi/reference/update-message-v4>`_
-
-        :param stream_id: The ID of the stream where the message is being updated.
-        :param message_id: The ID of the message that is being updated.
-        :param message: a :py:class:`Message` instance or a string containing the MessageML content to be sent.
-          If it is a :py:class:`Message` instance, other parameters will be ignored.
-          If it is a string, ``<messageML>`` tags can be omitted.
-        :param data: an object (e.g. dict) that will be serialized into JSON using ``json.dumps``.
-        :param silent: a bool flag that will determine if the updated message is going to be marked as read (when true,
-          which is default value) or unread (when false).
-        :param version: Optional message version in the format "major.minor".
-          If empty, defaults to the latest supported version.
-
-        :return: a V4Message object containing the details of the updated message.
-        """
-        message_object = message if isinstance(message, Message) else Message(content=message, data=data, silent=silent,
-                                                                              version=version)
-
-        params = {
-            "sid": stream_id,
-            "mid": message_id,
-            "session_token": await self._auth_session.session_token,
-            "key_manager_token": await self._auth_session.key_manager_token,
-            "message": message_object.content,
-            "data": message_object.data,
-            "version": message_object.version,
-            "silent": str(message_object.silent)
-        }
-        return await self._messages_api.v4_stream_sid_message_mid_update_post(**params)
-
     @staticmethod
     def _validate_message_search_query(query: MessageSearchQuery):
         # Check streamType value among accepted ones if specified
-        if query.stream_type is not None and query.stream_type not in ["CHAT", "IM", "MIM", "ROOM", "POST"]:
-            raise ValueError(f"Wrong stream type {query.stream_type}. "
-                             f"Accepted values are: CHAT (1-1 instant messages and multi-party instant messages), "
-                             f"IM (1-1 instant message), MIM (multi-party instant message), "
-                             f"ROOM or POST (user profile wall posts)")
+        if query.stream_type is not None and query.stream_type not in [
+            "CHAT",
+            "IM",
+            "MIM",
+            "ROOM",
+            "POST",
+        ]:
+            raise ValueError(
+                f"Wrong stream type {query.stream_type}. "
+                f"Accepted values are: CHAT (1-1 instant messages and multi-party instant messages), "
+                f"IM (1-1 instant message), MIM (multi-party instant message), "
+                f"ROOM or POST (user profile wall posts)"
+            )
 
         # Text queries require streamId to be provided
         if query.text is not None and query.stream_id is None:

symphony/bdk/core/service/message/messageml_util.py

@@ -1,10 +1,10 @@
-"""This module handles pre-processing for an outgoing message in order to have a valid messageML format.
-"""
+"""This module handles pre-processing for an outgoing message in order to have a valid messageML format."""
+
 import re
 
 
 def escape_special_chars(raw_text: str) -> str:
-    """ Replace all special characters placed within the messageML that must be HTML-escaped
+    """Replace all special characters placed within the messageML that must be HTML-escaped
     to have a valid MessageML format.
 
     :param raw_text: text to be parsed
@@ -14,7 +14,7 @@ def escape_special_chars(raw_text: str) -> str:
     parsed_text = ""
     matches = re.finditer(_pattern(), raw_text)
     for match in matches:
-        parsed_text += raw_text[current_parsed_index:match.start()] + _replacement(match.group(0))
+        parsed_text += raw_text[current_parsed_index : match.start()] + _replacement(match.group(0))
         current_parsed_index = match.end()
     return parsed_text + raw_text[current_parsed_index:]
 
@@ -32,7 +32,7 @@ _special_chars_dict = {
     "<": "&lt;",
     ">": "&gt;",
     "'": "&apos;",
-    "\"": "&quot;",
+    '"': "&quot;",
     "#": "&#35;",
     "\\$": "&#36;",
     "%": "&#37;",
@@ -47,5 +47,5 @@ _special_chars_dict = {
     "\\]": "&#93;",
     "`": "&#96;",
     "\\{": "&#123;",
-    "\\}": "&#125;"
+    "\\}": "&#125;",
 }

symphony/bdk/core/service/message/model.py

@@ -1,5 +1,5 @@
 import json
-from typing import List, Tuple, Union, IO
+from typing import IO, List, Tuple, Union
 
 from symphony.bdk.core.service.exception import MessageCreationError
 
@@ -14,8 +14,14 @@ class Message:
     `Create Message <https://developers.symphony.com/restapi/reference/create-message-v4>`_.
     """
 
-    def __init__(self, content: str, data=None, silent=True,
-                 attachments: List[Union[IO, Tuple[IO, IO]]] = None, version: str = ""):
+    def __init__(
+        self,
+        content: str,
+        data=None,
+        silent=True,
+        attachments: List[Union[IO, Tuple[IO, IO]]] = None,
+        version: str = "",
+    ):
         """Builds a message.
 
         :param content: the MessageML content to be sent. This is mandatory
@@ -89,7 +95,9 @@ class Message:
     def _get_content(content):
         if content is None:
             raise MessageCreationError("Message content is mandatory")
-        if not content.startswith(MESSAGE_ML_START_TAG) and not content.endswith(MESSAGE_ML_END_TAG):
+        if not content.startswith(MESSAGE_ML_START_TAG) and not content.endswith(
+            MESSAGE_ML_END_TAG
+        ):
             return MESSAGE_ML_START_TAG + content + MESSAGE_ML_END_TAG
         return content
 
@@ -109,6 +117,8 @@ class Message:
                 attachments.append(item)
 
         if previews and len(previews) != len(attachments):
-            raise MessageCreationError("Message should contain either no preview or as many previews as attachments")
+            raise MessageCreationError(
+                "Message should contain either no preview or as many previews as attachments"
+            )
 
         return attachments, previews