Commands

.gitignore

@@ -131,4 +131,6 @@ dmypy.json
 
 #pycharm and vscode folders
 .vscode
-.idea
+.idea
+
+.DS_Store

README.md

@@ -2,4 +2,6 @@
 
 [![Discord Support Server](https://img.shields.io/discord/885214547391180860?label=Disthon%20-%20Support%20Server&color=5865f2&labelColor=5865f2&&logo=discord&logoColor=ffffff&style=flat-square)](https://discord.gg/PtcfyJHKKp)
 
+![Logo](./logo.png?raw=true)
+
 Discord API wrapper for Python built from scratch

discord/__init__.py

@@ -2,6 +2,7 @@
 A work in progress discord wrapper built from scratch
 """
 
-from .api.intents import Intents as Intents
-from .client import Client as Client
-from .embeds import Embed as Embed
+from .api.intents import Intents
+from .client import Client
+from .embeds import Embed
+from .message import Message

discord/abc/abstractuser.py

@@ -2,36 +2,30 @@
 
 from typing import Optional
 
-from discordobject import DiscordObject
-
 from ..message import Message
 from ..types.avatar import Avatar
+from .discordobject import DiscordObject
 
 
 class AbstractUser(DiscordObject):
 
-    avatar: Optional[Avatar]
-    bot: bool
-    username: str
-    discriminator: str
-    id: int
 
     @property
     def tag(self):
         return f"{self.username}#{self.discriminator}"
-    
+
     @property
     def discriminator(self):
         return self.discriminator
 
     @property
     def mention(self):
         return f"<@!{self.id}>"
-    
-    @propery
+
+    @property
     def name(self):
         return self.username
-    
+
     @property
     def id(self):
         return self.id

discord/abc/discordobject.py

@@ -1,19 +1,29 @@
 from __future__ import annotations
-
-from datetime import datetime
+from typing import TYPE_CHECKING
 
 from pydantic import BaseModel
 
 from ..types.snowflake import Snowflake
 
 
-class DiscordObject(BaseModel):
+if TYPE_CHECKING:
+    from discord import Client
+
 
+class DiscordObject(BaseModel):
     id: Snowflake
-    created_at: datetime
+    _client: Client
+
+    class Config:
+        arbitrary_types_allowed = True
+
+    def __init__(self, client, **payload):
+        super().__init__(_client=client, **payload)
+        object.__setattr__(self, "_client", client)  # For some reason pydantic doesn't set the client attribute
+        # So we'll set it manually
 
     def __ne__(self, other):
         return not self.__eq__(other)
 
     def __hash__(self):
-        return self.id.id >> 22
+        return self.id >> 22

discord/abc/messageable.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+import abc
+import typing
+
+import discord
+
+if typing.TYPE_CHECKING:
+    from discord import Client, Embed
+    from discord.interactions import View
+
+
+class Messageable(abc.ABC):
+    id: int
+    _client: Client
+
+    def _get_channel(self):
+        raise NotImplementedError
+
+    async def send(self,
+                   content: typing.Optional[str] = None,
+                   *,
+                   embeds: typing.Union[Embed, typing.List[Embed]] = None,
+                   views: typing.Union[View, typing.List[View]] = None
+                   ):
+        content = str(content) if content is not None else None
+
+        channel = self._get_channel()
+        data = await self._client.httphandler.send_message(channel.id, content=content, embeds=embeds, views=views)
+
+        return discord.message.Message(self._client, **data)

discord/activity/presenseassets.py

@@ -1,8 +1,12 @@
 from __future__ import annotations
 
+from typing import TYPE_CHECKING
+
 from ..types.snowflake import Snowflake
-from .activity import Activity
-from .rawactivityassets import RawActivityAssets
+
+if TYPE_CHECKING:
+    from .activity import Activity
+    from .rawactivityassets import RawActivityAssets
 
 
 class PresenceAssets(dict[Snowflake, str]):

discord/api/dataConverters.py

@@ -0,0 +1,81 @@
+import inspect
+import typing
+
+from discord.types.snowflake import Snowflake
+from ..channels.guildchannel import TextChannel
+
+from ..guild import Guild
+from ..message import Message
+from ..user.user import User
+from ..user.member import Member
+
+
+class DataConverter:
+    def __init__(self, client):
+        self.client = client
+        self.converters = {}
+        for name, func in inspect.getmembers(self):
+            if name.startswith("convert_"):
+                self.converters[name[8:]] = func
+
+    def _get_channel(self, id):
+        return None  # TODO: get channel from cache
+
+    def convert_event_error(self, data):
+        return [data]
+
+    def convert_message_create(self, data):
+        return [Message(self.client, **data)]
+
+    def convert_ready(self, data):
+        return []
+
+    def convert_guild_create(self, data):
+        members = data["members"]
+        guild = Guild(self.client, **data)
+        self.client.ws.guild_cache[Snowflake(data["id"])] = guild
+
+        for member_data in members:
+            user_data = member_data["user"]
+            member_data.pop("user", None)
+            member_data["guild"] = guild
+            member_data["guild_avatar"] = member_data.get("avatar")
+            member_data.pop("avatar", None)
+
+            self.client.ws.member_cache[Snowflake(user_data["id"])] = Member(self.client, **member_data, **user_data)
+            self.client.ws.user_cache[Snowflake(user_data["id"])] = User(self.client, **user_data)
+
+        for channel_data in data["channels"]:
+            self.client.ws.channel_cache[Snowflake(channel_data["id"])] = TextChannel(self.client, **channel_data)
+
+        return [guild]
+
+    def convert_presence_update(self, data):
+        return [data]
+
+    def convert_typing_start(self, data):
+        return [data]
+
+    def convert_guild_member_update(self, data):
+        return [data]
+
+    def convert_interaction_create(self, payload):
+        message = payload.get("message")
+
+        if message:
+            message = Message(self.client, **payload)
+
+        if payload["type"] == 3:
+            component = self.client.httphandler.component_cache.get(payload["data"]["custom_id"])
+
+            # When the bot restarts the previously cached components are gone
+            if component:  # so check if the component is a newly created
+                self.client._loop.create_task(component.run_callback(message, payload["data"]))
+
+        return [payload]
+
+    def convert(self, event, data):
+        func: typing.Callable = self.converters.get(event)
+        if not func:
+            return [data]
+        return func(data)

discord/api/handler.py → discord/api/httphandler.py

@@ -14,11 +14,13 @@
                           DiscordNotFound, DiscordServerError)
 
 
-class Handler:
+class HTTPHandler:
     def __init__(self):
         self.base_url: str = "https://discord.com/api/v9/"
         self.user_agent: str = "Disthon Discord API wrapper V0.0.1b"
 
+        self.component_cache = {}
+
     async def request(
         self,
         method: str,
@@ -79,7 +81,19 @@ async def connect(self, url: str) -> aiohttp.ClientWebSocketResponse:
         return await self._session.ws_connect(url, **kwargs)
 
     async def close(self) -> None:
-        await self._session.close()
+        if self._session:
+            await self._session.close()
+
+    async def get_from_cdn(self, url: str) -> bytes:
+        async with self._session.get(url) as response:
+            if response.status == 200:
+                return await response.read()
+            elif response.status == 404:
+                raise DiscordNotFound("asset not found")
+            elif response.status == 403:
+                raise DiscordForbidden("cannot retrieve asset")
+            else:
+                raise DiscordHTTPException("failed to get asset", response.status)
 
     async def send_message(
         self,
@@ -97,20 +111,30 @@ async def send_message(
 
         if content:
             payload["content"] = content
+
         if embeds:
-            payload["embeds"] = [embed._to_dict() for embed in embeds]
+            payload["embeds"] = [embed.dict() for embed in embeds]
+
         if views:
-            payload["components"] = [view._to_dict() for view in views]
+            def _cache_view_components(view: View):
+                for component in view.components:
+                    self.component_cache[str(component.custom_id)] = component
+                return view._to_dict()
+
+            payload["components"] = [_cache_view_components(view) for view in views]
 
         data = await self.request(
             "POST", f"channels/{channel_id}/messages", data=payload
         )
         try:
             if isinstance(data, dict):
-                if data["code"] == 50008:
-                    raise DiscordChannelNotFound
-                elif data["code"] == 10003:
-                    raise DiscordChannelForbidden
+                code = data["code"]
+                if code == 50008:
+                    raise DiscordChannelNotFound()
+                elif code == 10003:
+                    raise DiscordChannelForbidden()
+                else:
+                    raise DiscordHTTPException(data.get("message"), code)
         except KeyError:
             return data
 

discord/api/websocket.py

@@ -12,6 +12,11 @@
 import aiohttp
 from aiohttp.http_websocket import WSMessage, WSMsgType
 
+from ..cache import LFUCache
+from ..channels.basechannel import BaseChannel
+from ..guild import Guild
+from ..types.snowflake import Snowflake
+
 if typing.TYPE_CHECKING:
     from ..client import Client
 
@@ -39,6 +44,12 @@ def __init__(self, client, token: str) -> None:
         self.token = token
         self.session_id = None
         self.heartbeat_acked = True
+        self.closed: bool = False
+
+        self.guild_cache = LFUCache[Snowflake, Guild](1000)
+        self.channel_cache = LFUCache[Snowflake, BaseChannel](5000)
+        self.member_cache = LFUCache[Snowflake, dict](5000)
+        self.user_cache = LFUCache[Snowflake, dict](5000)
 
     async def start(
         self,
@@ -47,37 +58,43 @@ async def start(
         reconnect: typing.Optional[bool] = False
     ):
         if not url:
-            url = self.client.handler.gateway()
-        self.socket = await self.client.handler.connect(url)
+            url = self.client.httphandler.gateway()
+        self.socket = await self.client.httphandler.connect(url)
         await self.receive_events()
         await self.identify()
         if reconnect:
             await self.resume()
         else:
-            t = threading.Thread(target=self.keep_alive, daemon=True)
-            t.start()
+            self.hb_t: threading.Thread = threading.Thread(target=self.keep_alive, daemon=True)
+            self.hb_stop: threading.Event = threading.Event()
+            self.hb_t.start()
             return self
 
+    async def close(self) -> None:
+        """Closes the websocket"""
+        self.closed = True
+        await self.socket.close()
+        self.hb_stop.set()
+
     def keep_alive(self) -> None:
-        while True:
-            time.sleep(self.hb_int)
+        while not self.hb_stop.wait(self.hb_int):
             if not self.heartbeat_acked:
                 # We have a zombified connection
-                self.socket.close()
+                self.socket.close(code=1000)
                 asyncio.run(self.start(reconnect=True))
             else:
                 asyncio.run(self.heartbeat())
 
-    def on_websocket_message(self, msg: WSMessage) -> dict:
+    def on_websocket_message(self, msg: WSMessage) -> dict: 
         if type(msg) is bytes:
             # always push the message data to your cache
             self.buffer.extend(msg)
 
             # check if last 4 bytes are ZLIB_SUFFIX
             if len(msg) < 4 or msg[-4:] != b"\x00\x00\xff\xff":
-                return
+                return msg
 
-            msg = self.decompress.decompress(self.buffer)
+            msg: bytes = self.decompress.decompress(self.buffer)
             msg = msg.decode("utf-8")
             self.buffer = bytearray()
 
@@ -94,8 +111,11 @@ async def receive_events(self) -> None:
             aiohttp.WSMsgType.CLOSING,
             aiohttp.WSMsgType.CLOSED,
         ):
-            await self.socket.close()
-            raise ConnectionResetError(msg.extra)
+            if not self.closed:
+                await self.socket.close()
+                raise ConnectionResetError(msg.extra)
+            else:
+                return
 
         msg = json.loads(msg)