pincer.objects.guild.channel.Channel.from_id() - Code Metrics - Inspection of "main" - Pincer-org/Pincer - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — main ( c79b30...1954a0 )

unknown

created 2021-10-25 18:04 UTC

pincer.objects.guild.channel.Channel.from_id() A

↳ Parent: Project

Complexity

Conditions

Size

Total Lines	13
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	10
dl	0
loc	13
rs	9.9
c	0
b	0
f	0
cc	1
nop	3

# Copyright Pincer 2021-Present
# Full MIT License can be found in `LICENSE` at the project root.

from __future__ import annotations

from asyncio import sleep, ensure_future
from dataclasses import dataclass
from enum import IntEnum
from typing import Dict, Optional, List, TYPE_CHECKING, Union, overload

from ..message.embed import Embed
from ..message.user_message import UserMessage
from ..._config import GatewayConfig
from ...utils.api_object import APIObject
from ...utils.conversion import construct_client_dict
from ...utils.convert_message import convert_message
from ...utils.types import MISSING

if TYPE_CHECKING:
    from ..message import Message
    from ..guild.overwrite import Overwrite
    from ..guild.thread import ThreadMetadata
    from ..guild.member import GuildMember
    from ..user import User
    from ... import Client
    from ...utils import APINullable, Snowflake, Timestamp


class ChannelType(IntEnum):
    """Represents a channel its type."""
    GUILD_TEXT = 0
    DM = 1
    GUILD_VOICE = 2
    GROUP_DM = 3
    GUILD_CATEGORY = 4
    GUILD_NEWS = 5
    GUILD_STORE = 6

    if GatewayConfig.version >= 9:
        GUILD_NEWS_THREAD = 10
        GUILD_PUBLIC_THREAD = 11
        GUILD_PRIVATE_THREAD = 12

    GUILD_STAGE_VOICE = 13


@dataclass
class Channel(APIObject):
    """
    Represents a Discord Channel Mention object

    :param id:
        the id of this channel

    :param type:
        the type of channel

    :param application_id:
        application id of the group DM creator if it is bot-created

    :param bitrate:
        the bitrate (in bits) of the voice channel

    :param default_auto_archive_duration:
        default duration for newly created threads, in minutes, to
        automatically archive the thread after recent activity, can be set to:
        60, 1440, 4320, 10080

    :param guild_id:
        the id of the guild (may be missing for some channel objects received
        over gateway guild dispatches)

    :param icon:
        icon hash

    :param last_message_id:
        the id of the last message sent in this channel (may not point to an
        existing or valid message)

    :param last_pin_timestamp:
        when the last pinned message was pinned. This may be null in events
        such as GUILD_CREATE when a message is not pinned.

    :param member:
        thread member object for the current user, if they have joined the
        thread, only included on certain API endpoints

    :param member_count:
        an approximate count of users in a thread, stops counting at 50

    :param message_count:
        an approximate count of messages in a thread, stops counting at 50

    :param name:
        the name of the channel (1-100 characters)

    :param nsfw:
        whether the channel is nsfw

    :param owner_id:
        id of the creator of the group DM or thread

    :param parent_id:
        for guild channels: id of the parent category for a channel (each
        parent category can contain up to 50 channels), for threads: id of the
        text channel this thread was created

    :param permissions:
        computed permissions for the invoking user in the channel, including
        overwrites, only included when part of the resolved data received on a
        slash command interaction

    :param permission_overwrites:
        explicit permission overwrites for members and roles

    :param position:
        sorting position of the channel

    :param rate_limit_per_user:
        amount of seconds a user has to wait before sending another message
        (0-21600); bots, as well as users with the permission manage_messages
        or manage_channel, are unaffected

    :param recipients:
        the recipients of the DM

    :param rtc_region:
        voice region id for the voice channel, automatic when set to null

    :param thread_metadata:
        thread-specific fields not needed by other channels

    :param topic:
        the channel topic (0-1024 characters)

    :param user_limit:
        the user limit of the voice channel

    :param video_quality_mode:
        the camera video quality mode of the voice channel, 1 when not present

    :param mention:
        structures a string to mention the channel
    """
    id: Snowflake
    type: ChannelType

    application_id: APINullable[Snowflake] = MISSING
    bitrate: APINullable[int] = MISSING
    default_auto_archive_duration: APINullable[int] = MISSING
    guild_id: APINullable[Snowflake] = MISSING
    icon: APINullable[Optional[str]] = MISSING

    last_message_id: APINullable[Optional[Snowflake]] = MISSING
    last_pin_timestamp: APINullable[Optional[Timestamp]] = MISSING
    member: APINullable[GuildMember] = MISSING

    member_count: APINullable[int] = MISSING

    message_count: APINullable[int] = MISSING

    name: APINullable[str] = MISSING
    nsfw: APINullable[bool] = MISSING
    owner_id: APINullable[Snowflake] = MISSING
    parent_id: APINullable[Optional[Snowflake]] = MISSING
    permissions: APINullable[str] = MISSING
    permission_overwrites: APINullable[List[Overwrite]] = MISSING
    position: APINullable[int] = MISSING
    rate_limit_per_user: APINullable[int] = MISSING
    recipients: APINullable[List[User]] = MISSING
    rtc_region: APINullable[Optional[str]] = MISSING
    thread_metadata: APINullable[ThreadMetadata] = MISSING
    topic: APINullable[Optional[str]] = MISSING
    user_limit: APINullable[int] = MISSING
    video_quality_mode: APINullable[int] = MISSING

    @property
    def mention(self):
        return f"<#{self.id}>"

    @classmethod
    async def from_id(cls, client: Client, channel_id: int) -> Channel:
        # TODO: Write docs
        data = (await client.http.get(f"channels/{channel_id}")) or {}

        data.update(construct_client_dict(
            client,
            {"type": ChannelType(data.pop("type"))}
        ))

        channel_cls = _channel_type_map.get(data["type"], Channel)
        return channel_cls.from_dict(data)

    @overload
    async def edit(
            self, *, name: str = None,
            type: ChannelType = None,
            position: int = None, topic: str = None, nsfw: bool = None,
            rate_limit_per_user: int = None, bitrate: int = None,
            user_limit: int = None,
            permissions_overwrites: List[Overwrite] = None,
            parent_id: Snowflake = None, rtc_region: str = None,
            video_quality_mod: int = None,
            default_auto_archive_duration: int = None
    ) -> Channel:
        ...

    async def edit(
            self,
            reason: Optional[str] = None,
            **kwargs
    ):
        # TODO: Write docs

        headers = {}

        if reason:
            headers["X-Audit-Log-Reason"] = str(reason)

        data = await self._http.patch(
            f"channels/{self.id}",
            kwargs,
            headers=headers
        )
        data.update(construct_client_dict(
            self._client,
            {"type": ChannelType(data.pop("type"))}
        ))
        channel_cls = _channel_type_map.get(data["type"], Channel)
        return channel_cls.from_dict(data)

    async def delete(
            self,
            reason: Optional[str] = None,
            /,

            channel_id: Optional[Snowflake] = None
    ):
        """|coro|

        Delete the current channel.

        Parameters
        ----------
        reason Optional[:class:`str`]
            The reason of the channel delete.
        channel_id :class:`~.pincer.utils.Snowflake`
            The id of the channel, defaults to the current object id.
        """
        channel_id = channel_id or self.id

        headers = {}

        if reason:
            headers["X-Audit-Log-Reason"] = str(reason)

        await self._http.delete(
            f"channels/{channel_id}",
            headers
        )

    async def __post_send_handler(self, message: Message):
        """Process a message after it was sent.

        Parameters
        ----------
        message :class:`~.pincer.objects.message.message.Message`
            The message.
        """

        if getattr(message, "delete_after", None):
            await sleep(message.delete_after)
            await self.delete()

    def __post_sent(
            self,
            message: Message
    ):
        """Ensure the `__post_send_handler` method its future.

        Parameters
        ----------
        message :class:`~.pincer.objects.message.message.Message`
            The message.
        """
        ensure_future(self.__post_send_handler(message))

    async def send(self, message: Union[Embed, Message, str]) -> UserMessage:
        """|coro|

        Send a message in the channel.

        Parameters
        ----------
        message :class:`~.pincer.objects.message.message.Message`
            The message which must be sent

        Returns
        -------
        :class:`~.pincer.objects.message.user_message.UserMessage`
            The message that was sent.
        """
        # TODO: Write docs
        content_type, data = convert_message(self._client, message).serialize()

        resp = await self._http.post(
            f"channels/{self.id}/messages",
            data,
            content_type=content_type
        )
        msg = UserMessage.from_dict(resp)
        self.__post_sent(msg)
        return msg

    def __str__(self):
        """return the discord tag when object gets used as a string."""
        return self.name or str(self.id)


class TextChannel(Channel):
    @overload
    async def edit(
            self, name: str = None, type: ChannelType = None,
            position: int = None, topic: str = None, nsfw: bool = None,
            rate_limit_per_user: int = None,
            permissions_overwrites: List[Overwrite] = None,
            parent_id: Snowflake = None,
            default_auto_archive_duration: int = None
    ) -> Union[TextChannel, NewsChannel]:
        ...

    async def edit(self, **kwargs):
        return await super().edit(**kwargs)

    @property
    def mention(self) -> str:
        """Return a channel mention."""
        return f"<#{self.id}>"


class VoiceChannel(Channel):
    @overload
    async def edit(
            self, name: str = None, position: int = None, bitrate: int = None,
            user_limit: int = None,
            permissions_overwrites: List[Overwrite] = None,
            rtc_region: str = None, video_quality_mod: int = None
    ) -> VoiceChannel:
        ...

    async def edit(self, **kwargs):
        return await super().edit(**kwargs)


class CategoryChannel(Channel):
    pass


class NewsChannel(Channel):
    @overload
    async def edit(
            self, name: str = None, type: ChannelType = None,
            position: int = None, topic: str = None, nsfw: bool = None,
            permissions_overwrites: List[Overwrite] = None,
            parent_id: Snowflake = None,
            default_auto_archive_duration: int = None
    ) -> Union[TextChannel, NewsChannel]:
        ...

    async def edit(self, **kwargs):
        return await super().edit(**kwargs)


@dataclass
class ChannelMention(APIObject):
    """
    Represents a Discord Channel Mention object

    :param id:
        id of the channel

    :param guild_id:
        id of the guild containing the channel

    :param type:
        the type of channel

    :param name:
        the name of the channel
    """
    id: Snowflake
    guild_id: Snowflake
    type: ChannelType
    name: str


# noinspection PyTypeChecker
_channel_type_map: Dict[ChannelType, Channel] = {
    ChannelType.GUILD_TEXT: TextChannel,
    ChannelType.GUILD_VOICE: VoiceChannel,
    ChannelType.GUILD_CATEGORY: CategoryChannel,
    ChannelType.GUILD_NEWS: NewsChannel
}


1			# Copyright Pincer 2021-Present
2			# Full MIT License can be found in `LICENSE` at the project root.
3
4			from __future__ import annotations
5
6			from asyncio import sleep, ensure_future
7			from dataclasses import dataclass
8			from enum import IntEnum
9			from typing import Dict, Optional, List, TYPE_CHECKING, Union, overload
10
11			from ..message.embed import Embed
12			from ..message.user_message import UserMessage
13			from ..._config import GatewayConfig
14			from ...utils.api_object import APIObject
15			from ...utils.conversion import construct_client_dict
16			from ...utils.convert_message import convert_message
17			from ...utils.types import MISSING
18
19			if TYPE_CHECKING:
20			from ..message import Message
21			from ..guild.overwrite import Overwrite
22			from ..guild.thread import ThreadMetadata
23			from ..guild.member import GuildMember
24			from ..user import User
25			from ... import Client
26			from ...utils import APINullable, Snowflake, Timestamp
27
28
29			class ChannelType(IntEnum):
30			"""Represents a channel its type."""
31			GUILD_TEXT = 0
32			DM = 1
33			GUILD_VOICE = 2
34			GROUP_DM = 3
35			GUILD_CATEGORY = 4
36			GUILD_NEWS = 5
37			GUILD_STORE = 6
38
39			if GatewayConfig.version >= 9:
40			GUILD_NEWS_THREAD = 10
41			GUILD_PUBLIC_THREAD = 11
42			GUILD_PRIVATE_THREAD = 12
43
44			GUILD_STAGE_VOICE = 13
45
46
47			@dataclass
48			class Channel(APIObject):
49			"""
50			Represents a Discord Channel Mention object
51
52			:param id:
53			the id of this channel
54
55			:param type:
56			the type of channel
57
58			:param application_id:
59			application id of the group DM creator if it is bot-created
60
61			:param bitrate:
62			the bitrate (in bits) of the voice channel
63
64			:param default_auto_archive_duration:
65			default duration for newly created threads, in minutes, to
66			automatically archive the thread after recent activity, can be set to:
67			60, 1440, 4320, 10080
68
69			:param guild_id:
70			the id of the guild (may be missing for some channel objects received
71			over gateway guild dispatches)
72
73			:param icon:
74			icon hash
75
76			:param last_message_id:
77			the id of the last message sent in this channel (may not point to an
78			existing or valid message)
79
80			:param last_pin_timestamp:
81			when the last pinned message was pinned. This may be null in events
82			such as GUILD_CREATE when a message is not pinned.
83
84			:param member:
85			thread member object for the current user, if they have joined the
86			thread, only included on certain API endpoints
87
88			:param member_count:
89			an approximate count of users in a thread, stops counting at 50
90
91			:param message_count:
92			an approximate count of messages in a thread, stops counting at 50
93
94			:param name:
95			the name of the channel (1-100 characters)
96
97			:param nsfw:
98			whether the channel is nsfw
99
100			:param owner_id:
101			id of the creator of the group DM or thread
102
103			:param parent_id:
104			for guild channels: id of the parent category for a channel (each
105			parent category can contain up to 50 channels), for threads: id of the
106			text channel this thread was created
107
108			:param permissions:
109			computed permissions for the invoking user in the channel, including
110			overwrites, only included when part of the resolved data received on a
111			slash command interaction
112
113			:param permission_overwrites:
114			explicit permission overwrites for members and roles
115
116			:param position:
117			sorting position of the channel
118
119			:param rate_limit_per_user:
120			amount of seconds a user has to wait before sending another message
121			(0-21600); bots, as well as users with the permission manage_messages
122			or manage_channel, are unaffected
123
124			:param recipients:
125			the recipients of the DM
126
127			:param rtc_region:
128			voice region id for the voice channel, automatic when set to null
129
130			:param thread_metadata:
131			thread-specific fields not needed by other channels
132
133			:param topic:
134			the channel topic (0-1024 characters)
135
136			:param user_limit:
137			the user limit of the voice channel
138
139			:param video_quality_mode:
140			the camera video quality mode of the voice channel, 1 when not present
141
142			:param mention:
143			structures a string to mention the channel
144			"""
145			id: Snowflake
146			type: ChannelType
147
148			application_id: APINullable[Snowflake] = MISSING
149			bitrate: APINullable[int] = MISSING
150			default_auto_archive_duration: APINullable[int] = MISSING
151			guild_id: APINullable[Snowflake] = MISSING
152			icon: APINullable[Optional[str]] = MISSING
153
154			last_message_id: APINullable[Optional[Snowflake]] = MISSING
155			last_pin_timestamp: APINullable[Optional[Timestamp]] = MISSING
156			member: APINullable[GuildMember] = MISSING
157
158			member_count: APINullable[int] = MISSING
159
160			message_count: APINullable[int] = MISSING
161
162			name: APINullable[str] = MISSING
163			nsfw: APINullable[bool] = MISSING
164			owner_id: APINullable[Snowflake] = MISSING
165			parent_id: APINullable[Optional[Snowflake]] = MISSING
166			permissions: APINullable[str] = MISSING
167			permission_overwrites: APINullable[List[Overwrite]] = MISSING
168			position: APINullable[int] = MISSING
169			rate_limit_per_user: APINullable[int] = MISSING
170			recipients: APINullable[List[User]] = MISSING
171			rtc_region: APINullable[Optional[str]] = MISSING
172			thread_metadata: APINullable[ThreadMetadata] = MISSING
173			topic: APINullable[Optional[str]] = MISSING
174			user_limit: APINullable[int] = MISSING
175			video_quality_mode: APINullable[int] = MISSING
176
177			@property
178			def mention(self):
179			return f"<#{self.id}>"
180
181			@classmethod
182			async def from_id(cls, client: Client, channel_id: int) -> Channel:
183			# TODO: Write docs
184			data = (await client.http.get(f"channels/{channel_id}")) or {}
185
186			data.update(construct_client_dict(
187			client,
188			{"type": ChannelType(data.pop("type"))}
189			))
190
191			channel_cls = _channel_type_map.get(data["type"], Channel)
192			return channel_cls.from_dict(data)
193
194			@overload
195			async def edit(
196			self, *, name: str = None,
197			type: ChannelType = None,
198			position: int = None, topic: str = None, nsfw: bool = None,
199			rate_limit_per_user: int = None, bitrate: int = None,
200			user_limit: int = None,
201			permissions_overwrites: List[Overwrite] = None,
202			parent_id: Snowflake = None, rtc_region: str = None,
203			video_quality_mod: int = None,
204			default_auto_archive_duration: int = None
205			) -> Channel:
206			...
207
208			async def edit(
209			self,
210			reason: Optional[str] = None,
211			**kwargs
212			):
213			# TODO: Write docs
214
215			headers = {}
216
217			if reason:
218			headers["X-Audit-Log-Reason"] = str(reason)
219
220			data = await self._http.patch(
221			f"channels/{self.id}",
222			kwargs,
223			headers=headers
224			)
225			data.update(construct_client_dict(
226			self._client,
227			{"type": ChannelType(data.pop("type"))}
228			))
229			channel_cls = _channel_type_map.get(data["type"], Channel)
230			return channel_cls.from_dict(data)
231
232			async def delete(
233			self,
234			reason: Optional[str] = None,
235			/,
			0 ignored issues – show introduced 2021-10-22 14:25 UTC by Report Bug Copy Issue Report invalid syntax (<unknown>, line 235) Loading history...
236			channel_id: Optional[Snowflake] = None
237			):
238			"""\|coro\|
239
240			Delete the current channel.
241
242			Parameters
243			----------
244			reason Optional[:class:`str`]
245			The reason of the channel delete.
246			channel_id :class:`~.pincer.utils.Snowflake`
247			The id of the channel, defaults to the current object id.
248			"""
249			channel_id = channel_id or self.id
250
251			headers = {}
252
253			if reason:
254			headers["X-Audit-Log-Reason"] = str(reason)
255
256			await self._http.delete(
257			f"channels/{channel_id}",
258			headers
259			)
260
261			async def __post_send_handler(self, message: Message):
262			"""Process a message after it was sent.
263
264			Parameters
265			----------
266			message :class:`~.pincer.objects.message.message.Message`
267			The message.
268			"""
269
270			if getattr(message, "delete_after", None):
271			await sleep(message.delete_after)
272			await self.delete()
273
274			def __post_sent(
275			self,
276			message: Message
277			):
278			"""Ensure the `__post_send_handler` method its future.
279
280			Parameters
281			----------
282			message :class:`~.pincer.objects.message.message.Message`
283			The message.
284			"""
285			ensure_future(self.__post_send_handler(message))
286
287			async def send(self, message: Union[Embed, Message, str]) -> UserMessage:
288			"""\|coro\|
289
290			Send a message in the channel.
291
292			Parameters
293			----------
294			message :class:`~.pincer.objects.message.message.Message`
295			The message which must be sent
296
297			Returns
298			-------
299			:class:`~.pincer.objects.message.user_message.UserMessage`
300			The message that was sent.
301			"""
302			# TODO: Write docs
303			content_type, data = convert_message(self._client, message).serialize()
304
305			resp = await self._http.post(
306			f"channels/{self.id}/messages",
307			data,
308			content_type=content_type
309			)
310			msg = UserMessage.from_dict(resp)
311			self.__post_sent(msg)
312			return msg
313
314			def __str__(self):
315			"""return the discord tag when object gets used as a string."""
316			return self.name or str(self.id)
317
318
319			class TextChannel(Channel):
320			@overload
321			async def edit(
322			self, name: str = None, type: ChannelType = None,
323			position: int = None, topic: str = None, nsfw: bool = None,
324			rate_limit_per_user: int = None,
325			permissions_overwrites: List[Overwrite] = None,
326			parent_id: Snowflake = None,
327			default_auto_archive_duration: int = None
328			) -> Union[TextChannel, NewsChannel]:
329			...
330
331			async def edit(self, **kwargs):
332			return await super().edit(**kwargs)
333
334			@property
335			def mention(self) -> str:
336			"""Return a channel mention."""
337			return f"<#{self.id}>"
338
339
340			class VoiceChannel(Channel):
341			@overload
342			async def edit(
343			self, name: str = None, position: int = None, bitrate: int = None,
344			user_limit: int = None,
345			permissions_overwrites: List[Overwrite] = None,
346			rtc_region: str = None, video_quality_mod: int = None
347			) -> VoiceChannel:
348			...
349
350			async def edit(self, **kwargs):
351			return await super().edit(**kwargs)
352
353
354			class CategoryChannel(Channel):
355			pass
356
357
358			class NewsChannel(Channel):
359			@overload
360			async def edit(
361			self, name: str = None, type: ChannelType = None,
362			position: int = None, topic: str = None, nsfw: bool = None,
363			permissions_overwrites: List[Overwrite] = None,
364			parent_id: Snowflake = None,
365			default_auto_archive_duration: int = None
366			) -> Union[TextChannel, NewsChannel]:
367			...
368
369			async def edit(self, **kwargs):
370			return await super().edit(**kwargs)
371
372
373			@dataclass
374			class ChannelMention(APIObject):
375			"""
376			Represents a Discord Channel Mention object
377
378			:param id:
379			id of the channel
380
381			:param guild_id:
382			id of the guild containing the channel
383
384			:param type:
385			the type of channel
386
387			:param name:
388			the name of the channel
389			"""
390			id: Snowflake
391			guild_id: Snowflake
392			type: ChannelType
393			name: str
394
395
396			# noinspection PyTypeChecker
397			_channel_type_map: Dict[ChannelType, Channel] = {
398			ChannelType.GUILD_TEXT: TextChannel,
399			ChannelType.GUILD_VOICE: VoiceChannel,
400			ChannelType.GUILD_CATEGORY: CategoryChannel,
401			ChannelType.GUILD_NEWS: NewsChannel
402			}
403

Pincer-org / Pincer

Push — main ( c79b30...1954a0 )

pincer.objects.guild.channel.Channel.from_id() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like