python-yappy 0.1.0__tar.gz → 0.1.1__tar.gz

{python_yappy-0.1.0 → python_yappy-0.1.1}/PKG-INFO

@@ -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.0 → python_yappy-0.1.1}/README.md

@@ -17,56 +17,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"))
 ```
@@ -112,7 +103,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.
@@ -142,6 +133,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.0 → python_yappy-0.1.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "python-yappy"
-version = "0.1.0"
+version = "0.1.1"
 description = "API Bindings for Yapper!"
 readme = "README.md"
 requires-python = ">=3.14"

{python_yappy-0.1.0 → python_yappy-0.1.1}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "python-yappy"
-version = "0.1.0"
+version = "0.1.1"
 description = "API Bindings for Yapper!"
 readme = "README.md"
 authors = [

{python_yappy-0.1.0 → python_yappy-0.1.1}/src/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)
+        

python_yappy-0.1.1/src/yappy/app.py

@@ -0,0 +1,401 @@
+from .core import *
+from .consts import BASE_URL
+from .api import *
+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,
+        prefix = "!"
+    ):
+        self.__commands = {}
+        self.__event_handlers = {
+            "message": self.on_message
+        }
+        self.__aliases = {}
+
+        self.user  = None
+        self.prefix = prefix
+
+        self._token = None
+
+        self._verbose = verbose
+
+        self.__cache = {
+            "users":{}, "channels":{},
+            "guilds": {}, "roles": {}
+        }
+
+    async def _load_bot_info(self):
+        my_info = await API.get(self.session, "/me")
+
+        return Bot(
+            name=my_info["username"],
+            display_name=my_info["display_name"],
+            id=my_info["id"],
+            assets=Assets(
+                avatar=my_info["avatar_url"],
+                banner=my_info["banner_url"],
+            ),
+            bio=my_info["bio"],
+            created_at=my_info["created_at"],
+            
+            owner_id=my_info["bot"]["owner_id"],
+            is_bot=True
+        )
+
+    async def _cache_members(
+        self, 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"]
+        )
+
+    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 get_user(
+        self, id
+    ):
+        return self.__cache["users"].get(id)
+
+    async def _build_context(self, ev):
+        d = ev["data"]
+        
+        channel = await self.find_channel(d["channel_id"])
+
+        return Context(
+            self,
+            is_bot=ev.get("author_bot", False),
+            message=Message(
+                self,
+                id=d["id"],
+                author=await channel.guild.find_member(
+                    d["author_id"]
+                ),
+                channel=channel,
+                created_at=d["created_at"],
+                content=d["content"]
+            ),
+            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):
+        d = ev["data"]
+
+        if ev["type"] in self.__event_handlers:
+            await self.__event_handlers[ev["type"]](
+                await self._build_context(
+                    ev
+                )
+            )
+
+    async def _init_commands(self):
+        _commands = []
+        for name, func in self.__commands.items():
+            _commands.append(
+                {"name": name, "description": func.description}
+            )
+            
+        await API.put(
+            self.session,
+            "/commands",
+            {"commands": _commands}
+        )
+
+    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")
+            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")
+                    fails = 0
+                except Exception as e:
+                    fails += 1
+                    if "(401)" in str(e):
+                        raise ImproperToken("Please check if your token is correctly used!")
+                    wait = min(30, 2 ** fails)
+                    
+                    print(f"retrying in {wait}s:", e)
+                    
+                    await asyncio.sleep(wait)
+                    continue
+                for ev in out["events"]:
+                    if ev["id"] <= last:
+                        continue
+                    last = ev["id"]
+                    try:
+                        await self._handle_event(self.session, ev)
+                    except Exception as e: 
+                        traceback.print_exc()
+                                        
+
+    def event(self, event_type: str):
+        def wrapper(func):
+            if not inspect.iscoroutinefunction(func):
+                raise InvalidSignature(f"Expected event handler for '{event_type}' to be a coroutine!")
+            self.__event_handlers[
+                event_type
+            ] = func
+        return wrapper
+
+    def command(
+        self,
+        name, *,
+        aliases=[],
+        description=""
+    ):
+        def wrapper(
+            func
+        ):
+           if not inspect.iscoroutinefunction(func):
+                raise InvalidSignature(f"Expected command handler for '{name}' to be a coroutine!")
+           self.__commands[name.lower()]=Command(
+                name=name,
+                aliases=aliases,
+                description=description,
+                func=func
+            )
+
+           for alias in aliases:
+               self.__aliases[alias.lower()] = self.__commands[name.lower()]
+        return wrapper
+
+    def run(self, token: str):
+        self._token = token
+
+        self._yappy_loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(self._yappy_loop)
+
+        try:
+            self._yappy_loop.run_until_complete(self._event_loop())
+        finally:
+            self._yappy_loop.close()
+__all__=["App"]

python_yappy-0.1.1/src/yappy/core.py

@@ -0,0 +1,272 @@
+from .api import *
+from typing import Callable
+import urllib.parse
+from .utils import get_asset_url
+
+class Assets:
+    def __init__(self,
+        avatar: str = "",
+        banner: str = "",
+        icon: str = ""
+    ):
+        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,
+        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.assets = assets
+        self.display_name = display_name or name
+        self.is_bot = is_bot
+        self.bio = bio
+
+class Bot(User):
+    def __init__(self, owner_id=None, **kwargs):
+        super().__init__(**kwargs)
+        self.owner_id = owner_id
+
+class Command:
+    def __init__(self,
+        name: str,
+        aliases: list[str] = [],
+        description: str = "",
+        func: Callable = None,
+    ):
+        self.name = name
+        self.aliases = aliases
+        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 = "",
+        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,
+        bot,
+        id=0,
+        channel: Channel | None = None,
+        author: User | None = None,
+        created_at: str = "",
+        content: str = ""
+    ):
+        self.id = id
+        self.channel = channel
+        self.bot = bot
+        self.created_at = created_at
+        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,
+        author: Member | None = None
+    ):
+        self.bot = bot
+        self.is_bot = is_bot
+        self.message = message
+        self.channel = channel
+        self.author = author
+
+        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

python_yappy-0.1.1/src/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()

python_yappy-0.1.1/src/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/src/yappy/app.py

@@ -1,204 +0,0 @@
-from .core import *
-from .consts import BASE_URL
-from .api import *
-from .errors import ImproperToken, InvalidSignature
-
-import inspect
-import asyncio
-import aiohttp
-from functools import wraps
-from typing import Callable
-
-class App:
-    def __init__(self, verbose=False):
-        self.__commands = {}
-        self.__event_handlers = {}
-
-        self.user  = None
-        self._token = None
-
-        self._verbose = verbose
-
-        self.__cache = {"users":{}}
-
-    async def _load_bot_info(self):
-        my_info = await api.get(self.session, "/me")
-
-        if self._verbose:
-            print(my_info)
-
-        return Bot(
-            name=my_info["username"],
-            display_name=my_info["display_name"],
-            id=my_info["id"],
-            profile=Profile(
-                avatar=my_info["avatar_url"],
-                banner=my_info["banner_url"],
-            ),
-            bio=my_info["bio"],
-            created_at=my_info["created_at"],
-            
-            owner_id=my_info["bot"]["owner_id"],
-            is_bot=True
-        )
-
-    def get_user(
-        self,
-        id,
-        _data
-    ):
-        if id in self.__cache["users"]:
-            return self.__cache["users"]
-        user = User(
-            name=_data["author"],
-            id=id
-        )
-
-        self.__cache[id]=user
-        return user
-
-    def _build_context(self, ev):
-        d = ev["data"]
-        
-        channel=Channel(
-            self,
-            id=d["channel_id"],
-            name=d["channel_name"]
-        )
-
-        return Context(
-            self,
-            is_bot=ev.get("author_bot", False),
-            message=Message(
-                self,
-                id=d["id"],
-                author=self.get_user(
-                    d["author_id"], d
-                ),
-                channel=channel,
-                created_at=d["created_at"],
-                content=d["content"]
-            ),
-            channel=channel
-        )
-
-    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
-                    )
-                )
-
-    async def _init_commands(self):
-        _commands = []
-        for name, func in self.__commands.items():
-            _commands.append(
-                {"name": name, "description": func.description}
-            )
-            
-        await api.put(
-            self.session,
-            "/commands",
-            {"commands": _commands}
-        )
-
-    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")
-            last = events_init["last"]
-            fails = 0
-
-            while True:
-                try:
-                    out = await api.get(self.session, f"/events?after={last}&wait=25")
-                    fails = 0
-                except Exception as e:
-                    fails += 1
-                    if "(401)" in str(e):
-                        raise ImproperToken("Please check if your token is correctly used!")
-                    wait = min(30, 2 ** fails)
-                    
-                    print(f"retrying in {wait}s:", e)
-                    
-                    await asyncio.sleep(wait)
-                    continue
-                for ev in out["events"]:
-                    if ev["id"] <= last:
-                        continue
-                    last = ev["id"]
-                    try:
-                        await self._handle_event(self.session, ev)
-                    except Exception as e: 
-                        print("error handling", ev["type"], "event:", e)
-                                        
-
-    def event(self, event_type: str):
-        def wrapper(func):
-            if not inspect.iscoroutinefunction(func):
-                raise InvalidSignature(f"Expected event handler for '{event_type}' to be a coroutine!")
-            self.__event_handlers[
-                event_type
-            ] = func
-        return wrapper
-
-    def command(
-        self,
-        name, *,
-        aliases=[],
-        description=""
-    ):
-        def wrapper(
-            func
-        ):
-           if not inspect.iscoroutinefunction(func):
-                raise InvalidSignature(f"Expected command handler for '{name}' to be a coroutine!")
-           self.__commands[name]=Command(
-                name=name,
-                aliases=aliases,
-                description=description,
-                func=func
-            )
-
-           for alias in aliases:
-               self.__aliases[alias] = self.__commands[name]
-
-        return wrapper
-
-    def run(self, token: str):
-        self._token = token
-
-        self._yappy_loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(self._yappy_loop)
-
-        try:
-            self._yappy_loop.run_until_complete(self._event_loop())
-        finally:
-            self._yappy_loop.close()

python_yappy-0.1.0/src/yappy/core.py

@@ -1,105 +0,0 @@
-from .api import *
-from typing import Callable
-
-class Profile:
-    def __init__(self,
-        avatar: str = "",
-        banner: str = ""
-    ):
-        self.avatar = avatar
-        self.banner = banner
-
-class User:
-    def __init__(self,
-        name: str ="",
-        display_name: str = "",
-        id=0,
-        profile: Profile | None = None,
-        created_at: str = "",
-        bio: str = "",
-        is_bot: bool = True
-    ):
-        self.name = name
-        self.id = id
-        self.profile = profile
-        self.display_name = display_name
-        self.is_bot = is_bot
-        self.bio = bio
-
-class Bot(User):
-    def __init__(self, owner_id=None, **kwargs):
-        super().__init__(**kwargs)
-        self.owner_id = owner_id
-
-class Command:
-    def __init__(self,
-        name: str,
-        aliases: list[str] = [],
-        description: str = "",
-        func: Callable = None,
-    ):
-        self.name = name
-        self.aliases = aliases
-        self.description = description
-        self.func = func
-
-class Channel:
-    def __init__(self,
-        bot,
-        id=0,
-        name: str = ""
-    ):
-        self.id = id
-        self.bot = bot
-        self.name = name
-
-class Message:
-    def __init__(self,
-        bot,
-        id=0,
-        channel: Channel | None = None,
-        author: User | None = None,
-        created_at: str = "",
-        content: str = ""
-    ):
-        self.id = id
-        self.channel = channel
-        self.bot = bot
-        self.created_at = created_at
-        self.content = content
-
-        self.author = author
-
-class Context:
-    def __init__(self,
-        bot,
-        is_bot: bool = False,
-        message: Message | None = None,
-        channel: Channel | 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
-            }
-        )
-
-    async def send(
-        self,
-        content: str = "Hi"
-    ):
-        await api.send(
-            self.bot.session, self.channel.id, data={
-                "content": content,
-                "reply_to": None
-            }
-        )