python-yappy 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

{python_yappy-0.1.0.dist-info → python_yappy-0.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: python-yappy
-Version: 0.1.0
+Version: 0.1.1
 Summary: API Bindings for Yapper!
 Author: H1387Lmao
 Requires-Dist: aiohttp>=3.14.5
@@ -28,56 +28,47 @@ YapPy brings a Python-friendly interface to [Yapper](https://yapper.website), a
 
 ## Installation
 
-Install YapPy using your project's preferred method.
-
-If the package is available on PyPI:
-
-```bash
-pip install yappy
-```
-
-If you are working from a local checkout, install the project from its repository directory:
 
 ```bash
-pip install .
-```
-
-The example below uses [`python-dotenv`](https://pypi.org/project/python-dotenv/) to load the bot token from a `.env` file:
-
-```bash
-pip install python-dotenv
+pip install python-yappy
 ```
 
 ## Quick start
 
-Create a file named `bot.py`:
+This example uses the dotenv module from `pip install load_dotenv`
+Create a file named `main.py`:
 
 ```python
+from yappy import App
 import os
-
 from dotenv import load_dotenv
-from yappy import App
-
 load_dotenv()
-
 bot = App(verbose=True)
-
-
-@bot.event("message")
+@bot.event(
+	"message"
+)
 async def on_message(ctx):
-    if ctx.is_bot:
-        return
-
-    await ctx.reply("Hi!")
-
-
+	if ctx.is_bot:
+		return
+	await bot.process_command(ctx)
 @bot.command(
-    name="ping",
-    description="replies with 'Pong!'",
+	name="ping",
+    description="replies with 'Pong!'"
 )
 async def ping(ctx):
-    await ctx.reply("Pong!")
+	await ctx.reply("Pong!")	
 
+@bot.command(
+	name="react",
+	description="React your message with a certain emoji!"
+)
+async def react(ctx, emoji: str):
+	await ctx.message.react(emoji)
+@bot.event(
+	"ready"
+)
+async def on_ready():
+	print("Logged as", bot.user.name)
 
 bot.run(os.getenv("TOKEN"))
 ```
@@ -123,7 +114,7 @@ async def on_message(ctx):
     if ctx.is_bot:
         return
 
-    await ctx.reply("Hello!")
+    await ctx.process.command(ctx)
 ```
 
 The event name and handler arguments should match the event interface supported by the installed YapPy version.
@@ -153,6 +144,8 @@ YapPy currently provides these core models:
 | `Message` | Represents a message. |
 | `Channel` | Represents a channel. |
 | `User` | Represents a user. |
+| `Guild` | Represents a guild / server |
+| `Role` | Represents a role |
 
 The example uses the context object (`ctx`) to check `ctx.is_bot` and send a reply with `ctx.reply(...)`. Consult the source code for the currently available attributes and methods of each model.
 

python_yappy-0.1.1.dist-info/RECORD

@@ -0,0 +1,11 @@
+yappy/__init__.py,sha256=BZU8ktPMVc9XeJ5YJeeCAPCjRyaxYIU_zusvjiSi5_Q,21
+yappy/api.py,sha256=_v1r9xPqrqmNwiz7ESnIsrRrzXNrm34eem7XUa4UAWU,2392
+yappy/app.py,sha256=vT4MKygpFmZoc6yu8Uu16hxldNjt5cE2NB-EgFvhifc,11651
+yappy/consts.py,sha256=0pIUIY1Ayo6_q3XhWr9hvKLgOT7TC9RgsjPZNVYy8QQ,51
+yappy/core.py,sha256=quCOfJPjVzUbwdK2NeH3IN3Yr8sNOaQ6JZoMVtELPDk,8110
+yappy/errors.py,sha256=BZ42Du8XWA_SY9tR5Ye8gVWWVKAvRDZZ8Grt_CoOOZs,133
+yappy/parser.py,sha256=XgMXkXHyuL_-oH6rpsbQcnmO5KQrNADIT20GH4-C1LM,2583
+yappy/utils.py,sha256=s7wmPTflqTAIgeAtf0a-gWgEfkQaZGKWYEqm2i4MsUM,129
+python_yappy-0.1.1.dist-info/WHEEL,sha256=lrO5MD1WVAWzcbNy_L2BwtfPrcM3KfUFpbKYXLkJX4A,80
+python_yappy-0.1.1.dist-info/METADATA,sha256=gNceBXMHD6CuuMQO07gR6nTMTINHeVP98VmGIG7la98,4663
+python_yappy-0.1.1.dist-info/RECORD,,

yappy/api.py

@@ -1,5 +1,7 @@
 from .consts import BASE_URL
 import aiohttp
+import random
+import asyncio
 
 async def api_push(session: aiohttp.ClientSession, method: str, path: str, body=None, tries=3):
     headers = {
@@ -25,20 +27,36 @@ async def api_push(session: aiohttp.ClientSession, method: str, path: str, body=
         if 0 < wait <= 60 and tries > 1:
             print(f"{'busy' if busy else 'rate limited'}, retrying in {wait}s")
             await asyncio.sleep(wait * (1 + random.random() * 0.5))
-            return await api(session, method, path, body, tries - 1)
+            return await api_push(session, method, path, body, tries - 1)
                     
         raise RuntimeError(f"{method} {path} failed ({e.status}): {msg or e.message}") from None
-        
-class api:
+
+class API:
     @staticmethod
-    async def put(session, path="", body=None, tries=3):
-        await api_push(session, "PUT", path, body, tries)
+    async def _request(session, method, path="", body=None, tries=3):
+        return await api_push(session, method, path, body, tries)
+
     @staticmethod
     async def get(session, path="", body=None, tries=3):
-        return await api_push(session, "GET", path, body, tries)
+        return await API._request(session, "GET", path, body, tries)
+
     @staticmethod
     async def post(session, path="", body=None, tries=3):
-        await api_push(session, "POST", path, body, tries)
+        return await API._request(session, "POST", path, body, tries)
+
+    @staticmethod
+    async def put(session, path="", body=None, tries=3):
+        return await API._request(session, "PUT", path, body, tries)
+
+    @staticmethod
+    async def patch(session, path="", body=None, tries=3):
+        return await API._request(session, "PATCH", path, body, tries)
+
     @staticmethod
-    async def send(session, channel_id=0, data=None, tries=3):
-        await api_push(session, "POST", f"/channels/{channel_id}/messages", data, tries)
+    async def delete(session, path="", body=None, tries=3):
+        return await API._request(session, "DELETE", path, body, tries)
+
+    @staticmethod
+    async def send(session, channel_id=0, body=None, tries=3):
+        return await API._request(session, "POST", f"/channels/{channel_id}/messages", body, tries)
+        

yappy/app.py

@@ -1,37 +1,47 @@
 from .core import *
 from .consts import BASE_URL
 from .api import *
-from .errors import ImproperToken, InvalidSignature
+from .errors import ImproperToken, InvalidSignature, UnknownCommand
+from .parser import parser
 
 import inspect
 import asyncio
 import aiohttp
+import traceback
 from functools import wraps
 from typing import Callable
 
 class App:
-    def __init__(self, verbose=False):
+    def __init__(
+        self, verbose=False,
+        prefix = "!"
+    ):
         self.__commands = {}
-        self.__event_handlers = {}
+        self.__event_handlers = {
+            "message": self.on_message
+        }
+        self.__aliases = {}
 
         self.user  = None
+        self.prefix = prefix
+
         self._token = None
 
         self._verbose = verbose
 
-        self.__cache = {"users":{}}
+        self.__cache = {
+            "users":{}, "channels":{},
+            "guilds": {}, "roles": {}
+        }
 
     async def _load_bot_info(self):
-        my_info = await api.get(self.session, "/me")
-
-        if self._verbose:
-            print(my_info)
+        my_info = await API.get(self.session, "/me")
 
         return Bot(
             name=my_info["username"],
             display_name=my_info["display_name"],
             id=my_info["id"],
-            profile=Profile(
+            assets=Assets(
                 avatar=my_info["avatar_url"],
                 banner=my_info["banner_url"],
             ),
@@ -42,29 +52,193 @@ class App:
             is_bot=True
         )
 
-    def get_user(
-        self,
-        id,
-        _data
+    async def _cache_members(
+        self, id
     ):
-        if id in self.__cache["users"]:
-            return self.__cache["users"]
-        user = User(
-            name=_data["author"],
-            id=id
+        _members_data = (await API.get(
+            self.session, f"/servers/{id}/members"
+        ))["members"]
+
+        members = []
+
+        for _user_data in _members_data:
+            roles = [
+                self.__cache["roles"][role_id]
+                for role_id in _user_data["roles"]
+                if role_id in self.__cache["roles"]
+            ]
+    
+            members.append(
+                Member(
+                    bot=self,
+                    guild=None, roles=roles,
+                    id=id,
+                    name = _user_data["username"],
+                    display_name = _user_data["display_name"],
+                    badges = _user_data["badges"],
+                    joined_at = _user_data["joined_at"],
+                    nickname = _user_data["nickname"],
+                    assets = Assets(
+                        avatar = "https://files.yapper.website/avatars/"+_user_data.get("avatar_path",""),
+                        banner = "https://files.yapper.website/banners/"+_user_data.get("banner_path", "")
+                    )
+                )
+            )
+
+        return members
+
+    async def _cache_roles(
+        self, id
+    ):
+        _roles_data = (await API.get(
+            self.session, f"/servers/{id}/roles"
+        ))
+
+        roles = []
+
+        for role in _roles_data["roles"]:
+            roles.append(
+                r:= Role(
+                    id = role["id"],
+                    name = role["name"],
+                    color = role["color"],
+                    permissions = Permissions(
+                        manage_server=role["manage_server"],
+                        manage_messages=role["manage_messages"],
+                        **role["perms"]
+                    ),
+                    auto = role["auto"],
+                    position = role["position"]
+                )
+            )
+            self.__cache["roles"][id]=r
+        return roles
+
+    def get_role(self, rid):
+        return self.__cache["roles"].get(id)
+       
+    async def fetch_guild(
+        self, id
+    ) -> Guild:
+        _guild_data = (await API.get(
+            self.session, f"/servers/{id}"
+        ))["server"]
+
+        roles = await self._cache_roles(id)
+        members = await self._cache_members(id)
+
+        return Guild(
+            self,
+            id = id,
+            name=_guild_data["name"],
+            owner=await self.find_user(
+                _guild_data["owner_id"]
+            ),
+            member_count = _guild_data["member_count"],
+            discoverable = _guild_data["discoverable"],
+            created_at = _guild_data["created_at"],
+            assets = Assets(
+                icon = _guild_data["icon_path"],
+                banner = _guild_data["banner_path"]
+            ),
+            roles = roles,
+            members = members
+        )
+    async def find_guild(
+        self, id
+    ):
+        guild = self.get_guild(id)
+        if guild is None:
+            guild = await self.fetch_guild(id)
+            self.__cache["guilds"]=guild
+        return guild
+
+    def get_guild(
+        self, id
+    ):
+        return self.__cache["guilds"].get(id)
+
+    async def fetch_channel(
+        self, id
+    ) -> Channel:
+        _channel_data = (await API.get(
+            self.session, f"/channels/{id}"
+        ))["channel"]
+
+        return Channel(
+            self,
+            id=_channel_data["id"],
+            kind=_channel_data["kind"],
+            name=_channel_data["name"],
+            slowmode=_channel_data["slowmode"],
+            private=_channel_data["private"],
+            guild=await self.find_guild(
+                _channel_data["server_id"]
+            ),
+            read_only=_channel_data["read_only"],
+            category_id=_channel_data["category_id"]
         )
 
-        self.__cache[id]=user
+    async def find_channel(
+        self, id
+    ):
+        channel = self.get_channel(id)
+        if channel is None:
+            channel = await self.fetch_channel(id)
+            self.__cache["channels"][id] = channel
+        return channel
+
+    def get_channel(
+        self, id
+    ):
+        return self.__cache["channels"].get(id)
+
+    async def fetch_user(
+        self,
+        id
+    ) -> User:
+        _user_data = (await API.get(
+            self.session, f"/users/{id}"
+        ))["user"]
+
+        return User(
+            bot=self,
+            id=id,
+            name = _user_data["username"],
+            display_name = _user_data["display_name"],
+            badges = _user_data["badges"],
+            created_at = _user_data["created_at"],
+            bio = _user_data["bio"],
+            pronouns = _user_data["pronouns"],
+            assets = Assets(
+                avatar = _user_data["avatar_path"],
+                banner = _user_data["banner_path"]
+            )
+        )
+
+    async def find_user(
+        self,
+        id,
+    ) -> User:
+        user = self.get_user(id)
+
+        if user is None:
+            user = await self.fetch_user(
+                id
+            )
+
+            self.__cache["users"][id]=user
         return user
 
-    def _build_context(self, ev):
+    def get_user(
+        self, id
+    ):
+        return self.__cache["users"].get(id)
+
+    async def _build_context(self, ev):
         d = ev["data"]
         
-        channel=Channel(
-            self,
-            id=d["channel_id"],
-            name=d["channel_name"]
-        )
+        channel = await self.find_channel(d["channel_id"])
 
         return Context(
             self,
@@ -72,8 +246,8 @@ class App:
             message=Message(
                 self,
                 id=d["id"],
-                author=self.get_user(
-                    d["author_id"], d
+                author=await channel.guild.find_member(
+                    d["author_id"]
                 ),
                 channel=channel,
                 created_at=d["created_at"],
@@ -82,35 +256,55 @@ class App:
             channel=channel
         )
 
+    async def _parse_arguments(self, content):
+        return await parser.parse_args(self, content)
+
+    async def _handle_prefix_command(self, ctx):
+        if ctx.message.content.startswith(self.prefix):
+            if " " in ctx.message.content:
+                name, raw = ctx.message.content.removeprefix(self.prefix).split(" ", maxsplit=1)
+            else:
+                name = ctx.message.content.removeprefix(self.prefix)
+                raw = ""
+            arguments = await self._parse_arguments(
+                raw
+            )
+
+            cmd = None
+            if name in self.__commands:
+                cmd = self.__commands[name.lower()]
+            elif name in self.__aliases:
+                cmd = self.__aliases[name.lower()]
+            else:
+                raise UnknownCommand(
+                    f"Unhandled command '{name.lower()}'!"
+                )
+                
+            await cmd.func(
+                ctx, *arguments
+            )
+
+            return True
+        return False
+
+    async def process_command(self, ctx):
+        await self._handle_prefix_command(
+            ctx
+        )
+
+    async def on_message(self, ctx):
+        if ctx.is_bot: return
+        await process_command(ctx)
+
     async def _handle_event(self, session: aiohttp.ClientSession, ev):
-        if self._verbose:
-            print(ev)
         d = ev["data"]
 
         if ev["type"] in self.__event_handlers:
-            if (cmd_name:=d.get("command")):
-                if cmd_name in self.__commands:
-                    await self.__commands[cmd_name].func(
-                        self._build_context(
-                            ev
-                        )
-                    )
-                elif cmd_name in self.__aliases:
-                    await self.__aliases[cmd_name](
-                        self._build_context(
-                            ev
-                        )
-                    )
-                else:
-                    raise UnknownCommand(
-                        f"Unhandled command '{cmd_name}'!"
-                    )
-            else:
-                await self.__event_handlers[ev["type"]](
-                    self._build_context(
-                        ev
-                    )
+            await self.__event_handlers[ev["type"]](
+                await self._build_context(
+                    ev
                 )
+            )
 
     async def _init_commands(self):
         _commands = []
@@ -119,7 +313,7 @@ class App:
                 {"name": name, "description": func.description}
             )
             
-        await api.put(
+        await API.put(
             self.session,
             "/commands",
             {"commands": _commands}
@@ -128,17 +322,20 @@ class App:
     async def _event_loop(self):
         async with aiohttp.ClientSession() as self.session:
             self.session._bearer_token=self._token
-        
+
             self.user = await self._load_bot_info()
             await self._init_commands()
 
-            events_init = await api.get(self.session, "/events?after=0&wait=0")
+            events_init = await API.get(self.session, "/events?after=0&wait=0")
             last = events_init["last"]
             fails = 0
 
+            if "ready" in self.__event_handlers:
+                await self.__event_handlers["ready"]()
+
             while True:
                 try:
-                    out = await api.get(self.session, f"/events?after={last}&wait=25")
+                    out = await API.get(self.session, f"/events?after={last}&wait=25")
                     fails = 0
                 except Exception as e:
                     fails += 1
@@ -157,7 +354,7 @@ class App:
                     try:
                         await self._handle_event(self.session, ev)
                     except Exception as e: 
-                        print("error handling", ev["type"], "event:", e)
+                        traceback.print_exc()
                                         
 
     def event(self, event_type: str):
@@ -180,7 +377,7 @@ class App:
         ):
            if not inspect.iscoroutinefunction(func):
                 raise InvalidSignature(f"Expected command handler for '{name}' to be a coroutine!")
-           self.__commands[name]=Command(
+           self.__commands[name.lower()]=Command(
                 name=name,
                 aliases=aliases,
                 description=description,
@@ -188,8 +385,7 @@ class App:
             )
 
            for alias in aliases:
-               self.__aliases[alias] = self.__commands[name]
-
+               self.__aliases[alias.lower()] = self.__commands[name.lower()]
         return wrapper
 
     def run(self, token: str):
@@ -202,3 +398,4 @@ class App:
             self._yappy_loop.run_until_complete(self._event_loop())
         finally:
             self._yappy_loop.close()
+__all__=["App"]

yappy/core.py

@@ -1,28 +1,36 @@
 from .api import *
 from typing import Callable
+import urllib.parse
+from .utils import get_asset_url
 
-class Profile:
+class Assets:
     def __init__(self,
         avatar: str = "",
-        banner: str = ""
+        banner: str = "",
+        icon: str = ""
     ):
-        self.avatar = avatar
-        self.banner = banner
+        self.avatar = get_asset_url("avatar", avatar)
+        self.banner = get_asset_url("banner", banner)
+        self.icon = get_asset_url("icon", icon)
 
 class User:
     def __init__(self,
+        bot = None,
         name: str ="",
         display_name: str = "",
         id=0,
-        profile: Profile | None = None,
+        assets: Assets | None = None,
         created_at: str = "",
         bio: str = "",
+        pronouns: str = "",
+        badges: list = [],
         is_bot: bool = True
     ):
+        self.bot = bot
         self.name = name
         self.id = id
-        self.profile = profile
-        self.display_name = display_name
+        self.assets = assets
+        self.display_name = display_name or name
         self.is_bot = is_bot
         self.bio = bio
 
@@ -43,15 +51,163 @@ class Command:
         self.description = description
         self.func = func
 
+class Permissions:
+    def __init__(self, **perms):
+        self._perms = perms
+    def has_perm(self, perm):
+        return self._perms.get(perm, False)
+
+class Role:
+    def __init__(self,
+        id: str = "",
+        name: str = "",
+        color: str = "",
+        permissions: Permissions | None = None,
+        auto: None = None, # unused
+        position: int = 0,
+        
+    ):
+        self.id = id
+        self.name = name
+        self.color = color
+        self.permissions = permissions
+        self.auto = auto
+        self.position = position
+
+class Guild:
+    def __init__(self,
+        bot,
+        id: str = "",
+        name: str = "",
+        created_at: str = "",
+        discoverable: bool = True,
+        member_count: int = 1,
+        owner: User | None = None,
+        assets: Assets | None = None,
+        roles: list[Role] = [],
+        members: list[Member] = []
+    ):
+        self.id = id
+        self.name = name
+        self.created_at = created_at
+        self.member_count = member_count
+        self.owner = owner
+        self.assets = assets
+        self.discoverable = discoverable
+        self.roles = roles
+        self.bot = bot
+        
+        self.members = members
+
+        self._cache={"members": {}, "roles": {
+            r.id: r for r in roles
+        }}
+
+        for m in members:
+            self._cache[m.id] = m
+            m. guild = self
+    async def find_member(self, mid):
+        member = self.get_member(mid)
+        if member is None:
+            _user_data = (await API.get(
+                self.bot.session,
+                f"/servers/{self.id}/members/{mid}"
+            ))["member"]
+
+            roles = [
+                self._cache["roles"][role_id]
+                for role_id in _user_data["roles"]
+                if role_id in self._cache["roles"]
+            ]
+            
+            member = Member(
+                bot=self.bot,
+                guild=self, roles=roles,
+                id=id,
+                name = _user_data["username"],
+                display_name = _user_data["display_name"],
+                badges = _user_data["badges"],
+                joined_at = _user_data["joined_at"],
+                nickname = _user_data["nickname"],
+                assets = Assets(
+                    avatar = "https://files.yapper.website/avatars/"+_user_data.get("avatar_path",""),
+                    banner = "https://files.yapper.website/banners/"+_user_data.get("banner_path", "")
+                ),
+            )
+
+            self._cache["members"][mid] = member
+            
+        return member
+    def get_member(self, mid):
+        return self._cache.get(mid, None)
+
 class Channel:
     def __init__(self,
         bot,
         id=0,
-        name: str = ""
+        name: str = "",
+        kind: str = "",
+        private: bool = False,
+        slowmode: int = 0,
+        category_id: str = "",
+        guild: Guild | None = None,
+        read_only: bool = False
     ):
         self.id = id
         self.bot = bot
         self.name = name
+        self.kind = kind
+        self.private = private
+        self.slowmode = slowmode
+        self.category_id = category_id
+        self.guild = guild
+        self.read_only = read_only
+        
+    async def send(self, content, embeds=[], components=[]):
+        await API.send(
+            self.bot.session, self.id, {
+                "content": content,
+                "embeds": embeds,
+                "components": components,
+                "reply_to": None
+            }
+        )
+
+class Member(User):
+    def __init__(
+        self,
+        guild: guild | None = None,
+        roles: list[Role] = [],
+        joined_at: str = "",
+        nickname: str = "",
+        *args, **kwargs
+    ):
+        super().__init__(*args, **kwargs)
+        self.guild = guild
+        self.roles = roles
+        self.joined_at = joined_at
+        self.nickname = nickname or self.display_name
+
+    async def add_role(self, role):
+        role_id = role if isinstance(role, str) else role.id
+        return API.put(self.bot.session, f"/servers/{self.guild.id}/members/{self.id}/roles/{role_id}")
+    
+    async def remove_role(self, role):
+        role_id = role if isinstance(role, str) else role.id
+        return API.delete(self.bot.session, f"/servers/{self.guild.id}/members/{self.id}/roles/{role_id}")
+    
+    async def kick(self):
+        return API.post(self.bot.session, f"/servers/{self.guild.id}/", {"user_id": self.id})
+    
+    async def ban(self):
+        return API.post(self.bot.session, f"/servers/{self.guild.id}/bans", {"user_id": self.id})
+    
+    async def unban(self):
+        return API.delete(self.bot.session, f"/servers/{self.guild.id}/bans/{self.id}")
+    
+    async def timeout(self, minutes, reason=""):
+        return API.post(self.bot.session, f"/servers/{self.guild.id}/timeouts", {"user_id": self._id, "minutes": minutes, "reason": reason})
+    
 
 class Message:
     def __init__(self,
@@ -69,37 +225,48 @@ class Message:
         self.content = content
 
         self.author = author
+    async def reply(self, content, embeds=[], components=[]):
+        await API.send(
+            self.bot.session, self.channel.id, {
+                "content": content,
+                "embeds": embeds,
+                "components": components,
+                "reply_to": self.id
+            }
+        )
+    async def delete(self):
+        await API.delete(self.bot.session, f"/channels/{self.channel.id}/messages/{self.id}")
+    async def edit(self, content, embeds=[], components=[]):
+        await API.patch(self.bot.session, f"/channels/{self.channels.id}/messages/{self.id}", {
+            "content": content,
+            "embeds": embeds,
+            "components": components
+        })
+    async def send(self, content, embeds=[], components=[]):
+        await self.channel.send(*args, **kwargs)
+    async def react(self, emoji):
+        return await API.put(
+            self.bot.session,
+            f"/channels/{self.channel.id}/messages/{self.id}/reactions/{urllib.parse.quote(emoji)}"
+        )
+
 
 class Context:
     def __init__(self,
         bot,
         is_bot: bool = False,
         message: Message | None = None,
-        channel: Channel | None = None
+        channel: Channel | None = None,
+        author: Member | None = None
     ):
         self.bot = bot
         self.is_bot = is_bot
         self.message = message
         self.channel = channel
-        
-    async def reply(
-        self,
-        content: str = "Hi"
-    ):
-        await api.send(
-            self.bot.session, self.channel.id, data={
-                "content": content,
-                "reply_to": self.message.id
-            }
-        )
+        self.author = author
 
-    async def send(
-        self,
-        content: str = "Hi"
-    ):
-        await api.send(
-            self.bot.session, self.channel.id, data={
-                "content": content,
-                "reply_to": None
-            }
-        )
+        self.reply = self.message.reply
+        self.delete = self.message.delete
+        self.edit = self.message.edit
+        self.react = self.message.react
+        self.send = self.message.send

yappy/parser.py

@@ -0,0 +1,69 @@
+import re
+from typing import Any, List, Union
+
+class CommandParser:
+    def __init__(self):
+        self.token_regex = re.compile(
+            r'"([^"\\]*(?:\\.[^"\\]*)*)"|'
+            r"'([^'\\]*(?:\\.[^'\\]*)*)'|"
+            r'(<[#@&!]+[^\s>]+>)|'
+            r'([^\s"\']+)'
+        )
+        self.user_regex = re.compile(r'^<@!?([0-9\-]+)>$|^<@!(.+)>$')
+        self.channel_regex = re.compile(r'^<#([0-9\-]+)>$|^<#(.+)>$')
+        self.role_regex = re.compile(r'^<@&([0-9\-]+)>$|^<@&(.+)>$')
+
+    async def parse_args(self, bot, text: str) -> List[Any]:
+        parsed_arguments = []
+        
+        for match in self.token_regex.finditer(text):
+            dq_str, sq_str, _raw, unquoted = match.groups()
+            
+            if dq_str is not None:
+                parsed_arguments.append(dq_str.encode().decode('unicode_escape'))
+                continue
+            if sq_str is not None:
+                parsed_arguments.append(sq_str.encode().decode('unicode_escape'))
+                continue
+                
+            if _raw is not None:
+                parsed_arguments.append(await self._process_mentions(bot, _raw))
+                continue
+                
+            if unquoted is not None:
+                parsed_arguments.append(self._parse_primitive(unquoted))
+                
+        return parsed_arguments
+
+    async def _process_mentions(self, bot, token: str) -> Any:
+        if user_match := self.user_regex.match(token):
+            user_id = user_match.group(1) or user_match.group(2)
+            return await self._parse_user(bot, user_id)
+            
+        if channel_match := self.channel_regex.match(token):
+            channel_id = channel_match.group(1) or channel_match.group(2)
+            return await self._parse_channel(bot, channel_id)
+            
+        if role_match := self.role_regex.match(token):
+            role_id = role_match.group(1) or role_match.group(2)
+            return await self._parse_role(bot, role_id)
+            
+        return token
+
+    def _parse_primitive(self, token: str) -> Union[int, float, str]:
+        if re.match(r'^-?\d+$', token):
+            return int(token)
+        if re.match(r'^-?\d*\.\d+$', token):
+            return float(token)
+        return token
+
+    async def _parse_user(self, bot, user_id: str):
+        return await bot.find_user(user_id)
+
+    async def _parse_channel(self, bot, channel_id: str):
+        return await bot.find_channel(channel_id)
+
+    async def _parse_role(self, bot, role_id: str):
+        return await bot.find_role(role_id)
+
+parser = CommandParser()

yappy/utils.py

@@ -0,0 +1,4 @@
+def get_asset_url(type: str, path: str):
+    if not path: return None
+
+    return f"https://files.yapper.website/{type}s/{path}"

python_yappy-0.1.0.dist-info/RECORD

@@ -1,9 +0,0 @@
-yappy/__init__.py,sha256=BZU8ktPMVc9XeJ5YJeeCAPCjRyaxYIU_zusvjiSi5_Q,21
-yappy/api.py,sha256=KP7ma6tpqgsExCx4KccUetbQC3PWnio0Mo1bvnh4JGs,1862
-yappy/app.py,sha256=zM17fXaZne5f9n7dp2SqcNxIkD28QP40SEPRd39fKa4,5932
-yappy/consts.py,sha256=0pIUIY1Ayo6_q3XhWr9hvKLgOT7TC9RgsjPZNVYy8QQ,51
-yappy/core.py,sha256=xdPKbg_evRvadOP1bzNOuiV8BJxhnWLmqX99qobfCL0,2347
-yappy/errors.py,sha256=BZ42Du8XWA_SY9tR5Ye8gVWWVKAvRDZZ8Grt_CoOOZs,133
-python_yappy-0.1.0.dist-info/WHEEL,sha256=lrO5MD1WVAWzcbNy_L2BwtfPrcM3KfUFpbKYXLkJX4A,80
-python_yappy-0.1.0.dist-info/METADATA,sha256=1Y5i62UYKOYX1MxGmDFAyh_qzzlDHo-wA81ustUSxYg,4668
-python_yappy-0.1.0.dist-info/RECORD,,