pincer.objects.message.message

Complexity

Total Complexity

21

Size/Duplication

Total Lines	173
Duplicated Lines	0 %

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	Message.isempty()	0	8	1
A	Message.__str__()	0	2	1
C	Message.__post_init__()	0	28	9
A	Message.serialize()	0	34	5
A	Message.to_dict()	0	26	5

# Copyright Pincer 2021-Present

Missing module docstring

# Full MIT License can be found in `LICENSE` at the project root.

from __future__ import annotations

from dataclasses import dataclass
from typing import TYPE_CHECKING

from ..message.file import File, create_form
from ...exceptions import CommandReturnIsEmpty

if TYPE_CHECKING:
    from typing import Dict, Union, List, Optional, Tuple

    from aiohttp import Payload

Unable to import 'aiohttp'

    from .embed import Embed
    from .component import MessageComponent
    from ..app.interactions import InteractionFlags
    from ..message.user_message import AllowedMentions
    from ...objects.app import CallbackType

PILLOW_IMPORT = True

try:
    from PIL.Image import Image
except (ModuleNotFoundError, ImportError):
    PILLOW_IMPORT = False


@dataclass(repr=False)
class Message:

Too many instance attributes (8/7)

    """A discord message that will be sent to discord

    Attributes
    ----------
    content: :class:`str`
        The text in the message.
        |default| ``""``
    attachments: Optional[List[:class:`~pincer.objects.message.file.File`]]
        Attachments on the message. This is a File object. You can also attach
        a Pillow Image or string. Pillow images will be converted to PNGs. They
        will use the naming scheme ``image%`` where % is the images index in the
        attachments array. Strings will be read as a filepath. The name of the
        file that the string points to will be used as the name.
    tts: Optional[:class:`bool`]
        Whether the message should be spoken to the user.
        |default| :data:`False`
    embeds: Optional[List[:class:`~pincer.objects.message.embed.Embed`]]
        Embed attached to the message. This is an Embed object.
    allowed_mentions: Optional[:class:`~pincer.objects.message.message.AllowedMentions`]
        The allowed mentions for the message.
    components: Optional[List[:class:`~pincer.objects.message.component.MessageComponent`]]
        The components of the message.
    flags: Optional[:class:`~pincer.objects.app.interactions.InteractionFlags`]
        The interaction flags for the message.
    type: Optional[:class:`~pincer.objects.app.interaction_base.CallbackType`]
        The type of the callback.
    """  # noqa: E501

    content: Optional[str] = None
    attachments: Optional[List[File]] = None
    tts: Optional[bool] = None
    embeds: Optional[List[Embed]] = None
    allowed_mentions: Optional[AllowedMentions] = None
    components: Optional[List[MessageComponent]] = None
    flags: Optional[InteractionFlags] = None
    delete_after: Optional[float] = None

    def __post_init__(self):
        if self.delete_after and self.delete_after < 0:
            raise ValueError(
                "Message can not be deleted after a negative amount of "
                "seconds!"
            )

        if not self.attachments:
            return

        attachment = []

        for count, value in enumerate(self.attachments):
            if isinstance(value, File):
                attachment.append(value)
            elif PILLOW_IMPORT and isinstance(value, Image):
                attachment.append(
                    File.from_pillow_image(
                        value,
                        f"image{count}.png",
                    )
                )
            elif isinstance(value, str):
                attachment.append(File.from_file(value))
            else:
                raise ValueError(f"Attachment {count} is invalid type.")

        self.attachments = attachment

    @property
    def isempty(self) -> bool:
        """:class:`bool`: If the message is empty."""

        return (
            (not self.content or not self.content.strip())
            and not self.embeds
            and not self.attachments
        )

    def to_dict(self):

Missing function or method docstring

        allowed_mentions = (
            self.allowed_mentions.to_dict() if self.allowed_mentions else {}
        )

        # Attachments aren't serialized
        # because they are not sent as part of the json
        resp = {
            "content": self.content,
            "tts": self.tts,
            "flags": self.flags,
            "embeds": [embed.to_dict() for embed in self.embeds]
            if self.embeds is not None

Wrong continued indentation (add 10 spaces).

            else None,

Wrong continued indentation (add 10 spaces).

            "allowed_mentions": allowed_mentions,
            "components": [
                components.to_dict() for components in self.components
            ]
            if self.components is not None

Wrong continued indentation (add 14 spaces).

            else None,

Wrong continued indentation (add 14 spaces).

        }

        # IDE does not recognise return type of filter properly.
        # noinspection PyTypeChecker
        return dict(filter(lambda kv: kv[1] is not None, resp.items()))

    def serialize(
        self,

Wrong hanging indentation before block (add 4 spaces).

        message_type: Optional[CallbackType] = None,

Wrong hanging indentation before block (add 4 spaces).

        allow_empty: bool = False,

Wrong hanging indentation before block (add 4 spaces).

    ) -> Tuple[str, Union[Payload, Dict]]:
        """
        Parameters
        ----------
        message_type : Optional[:class:`pincer.objects.app.CallbackType`]
            Callback type of message.

        Returns
        -------
        Tuple[str, Union[Payload, Dict]]
            (content_type, data)

        Raises
        ------
        :class:`pincer.exceptions.CommandReturnIsEmpty`
            Command does not have content, an embed, or attachment.
        """
        if not allow_empty and self.isempty:
            raise CommandReturnIsEmpty("Cannot return empty message.")

        json_payload = self.to_dict()

        if message_type is not None:
            json_data = json_payload
            json_payload = {"data": json_data, "type": message_type}

        if not self.attachments:
            return "application/json", json_payload

        return create_form(json_payload, self.attachments)

    def __str__(self):
        return self.content