From fca7a9cf7904ff1d698451ac368f63048e341b48 Mon Sep 17 00:00:00 2001 From: grey-cat-1908 Date: Fri, 15 Apr 2022 18:39:02 +0300 Subject: [PATCH] feat(utils): models parsing new method, not work properly now --- melisa/models/guild/channel.py | 111 ++++++++++++++++++++++++++++++++- melisa/utils/api_model.py | 31 --------- 2 files changed, 110 insertions(+), 32 deletions(-) diff --git a/melisa/models/guild/channel.py b/melisa/models/guild/channel.py index 155a18f..7f6e737 100644 --- a/melisa/models/guild/channel.py +++ b/melisa/models/guild/channel.py @@ -681,6 +681,47 @@ class MessageableChannel(Channel): class TextChannel(MessageableChannel): """A subclass of ``Channel`` representing text channels with all the same attributes.""" + @classmethod + def from_dict(cls, data: Dict[str, Any]): + """Generate an text channel from the given data. + + Parameters + ---------- + data: :class:`dict` + The dictionary to convert into a text channel. + """ + self: TextChannel = super().__new__(cls) + + self.id = data["id"] + self.type = data["type"] + self.guild_id = Snowflake(data["guild_id"]) + self.position = data["position"] + self.permission_overwrites = data["permission_overwrites"] + self.name = data["name"] + self.topic = data.get("topic") + self.nsfw = data["nsfw"] + + if data.get("last_message_id") is not None: + self.last_message_id = Snowflake(data["last_message_id"]) + else: + self.last_message_id = None + + self.rate_limit_per_user = data.get("rate_limit_per_user") + + if data.get("parent_id") is not None: + self.parent_id = Snowflake(data["parent_id"]) + else: + self.parent_id = None + + if data.get("last_pin_timestamp") is not None: + self.last_pin_timestamp = Snowflake(data["last_pin_timestamp"]) + else: + self.last_pin_timestamp = None + + self.default_auto_archive_duration = data.get("default_auto_archive_duration") + + return self + @overload async def edit( self, @@ -752,6 +793,59 @@ class TextChannel(MessageableChannel): class Thread(MessageableChannel): """A subclass of ``Channel`` for threads with all the same attributes.""" + @classmethod + def from_dict(cls, data: Dict[str, Any]): + """Generate an thread from the given data. + + Parameters + ---------- + data: :class:`dict` + The dictionary to convert into a thread. + """ + self: Thread = super().__new__(cls) + self.id = int(data["id"]) + self.parent_id = int(data.get("parent_id")) + self.owner_id = Snowflake(data.get("owner_id")) + self.name = data["name"] + self.type = ChannelType(data.pop("type")) + + if data.get("last_message_id") is not None: + self.last_message_id = Snowflake(data["last_message_id"]) + else: + self.last_message_id = None + + self.slowmode_delay = data.get("rate_limit_per_user", 0) + self.message_count = data.get("message_count") + self.member_count = data.get("member_count") + + if data.get("last_pin_timestamp") is not None: + self.last_pin_timestamp = Snowflake(data["last_pin_timestamp"]) + else: + self.last_pin_timestamp = None + + self.flags = data.get("flags", 0) + self.__unroll_metadata(data["thread_metadata"]) + + self.me = data.get("member") + + return self + + def __unroll_metadata(self, data: Dict[str, Any]): + """Unroll metadata method, yup yup, you should't see this""" + self.archived = data["archived"] + self.auto_archive_duration = data["auto_archive_duration"] + self.locked = data.get("locked", False) + + if data.get("create_timestamp") is not None: + self.create_timestamp = Timestamp(data["create_timestamp"]) + else: + self.create_timestamp = None + + if data.get("archive_timestamp") is not None: + self.archive_timestamp = Timestamp(data["archive_timestamp"]) + else: + self.archive_timestamp = None + async def add_user(self, user_id: Snowflake): """|coro| @@ -846,7 +940,22 @@ class ThreadsList(APIModelBase): threads: List[Thread] members: List[ThreadMember] - has_more: APINullable[bool] = UNDEFINED + has_more: bool + + @classmethod + def from_dict(cls, data: Dict[str, Any]): + """Generate an threads list from the given dict. + + Parameters + ---------- + data: :class:`dict` + The dictionary to convert into an threads list. + """ + self: ThreadsList = super().__new__(cls) + self.threads = [Thread.from_dict(thread) for thread in data["threads"]] + self.members = [ThreadMember.from_dict(member) for member in data["members"]] + self.has_more = data.get("has_more", False) + return self # noinspection PyTypeChecker diff --git a/melisa/utils/api_model.py b/melisa/utils/api_model.py index 1edd5dd..f0b3e1d 100644 --- a/melisa/utils/api_model.py +++ b/melisa/utils/api_model.py @@ -196,37 +196,6 @@ class APIModelBase: return super().__str__() - @classmethod - def from_dict( - cls: Generic[T], data: Dict[str, Union[str, bool, int, Any]] - ) -> T: - """ - Parse an API object from a dictionary. - """ - if isinstance(data, cls): - return data - - # Disable inspection for IDE because this is valid code for the - # inherited classes: - # noinspection PyArgumentList - return cls( - **dict( - map( - lambda key: ( - key, - data[key].value - if isinstance(data[key], Enum) - else data[key], - ), - filter( - lambda object_argument: data.get(object_argument) - is not None, - getfullargspec(cls.__init__).args, - ), - ) - ) - ) - def to_dict(self) -> Dict: """ Transform the current object to a dictionary representation. Parameters that