aiko-api 0.1.1__tar.gz

aiko_api-0.1.1/PKG-INFO

@@ -0,0 +1,78 @@
+Metadata-Version: 2.4
+Name: aiko-api
+Version: 0.1.1
+Summary: A clean, efficient Discord API wrapper for bot development.
+Author: Aiko
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Intended Audience :: Developers
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: curl_cffi>=0.7.0
+Requires-Dist: aiohttp>=3.9.0
+Requires-Dist: uvloop>=0.19.0; sys_platform != "win32"
+Requires-Dist: attrs>=23.2.0
+
+# aiko_api
+
+A clean, efficient, and modern Discord API wrapper for Python.
+
+`aiko_api` is designed to be a lightweight and easy-to-use alternative for building Discord bots and selfbots. It features a flat command hierarchy, smart signatures, and a powerful plugin system with hot-reloading.
+
+## Features
+
+- **Flat Sub-command Hierarchy:** Decorate commands with their parent commands for clean nesting.
+- **Smart Signatures:** `self` is optional in Cogs; the library detects if it's needed.
+- **Clean Cog Events:** Automatically register `on_` methods as event listeners.
+- **Advanced Plugin System:** Load Cogs and standalone commands from directories with built-in hot-reloading.
+- **Optimized HTTP:** Built on top of `curl_cffi` for high performance and better impersonation.
+
+## Installation
+
+```bash
+pip install aiko_api
+```
+
+## Quick Start
+
+```python
+import asyncio
+from aiko_api import Bot
+
+bot = Bot(command_prefix="!")
+
+@bot.command()
+async def ping(ctx):
+    await ctx.reply("Pong! 🏓")
+
+@bot.event
+async def on_ready(user):
+    print(f"Logged in as {user.username}")
+
+if __name__ == "__main__":
+    asyncio.run(bot.start("YOUR_TOKEN"))
+```
+
+## Advanced Usage: Cogs and Sub-commands
+
+```python
+from aiko_api import Cog, command
+
+class Moderation(Cog):
+    @command()
+    async def config(self, ctx):
+        await ctx.send("Main config menu.")
+
+    @config
+    async def prefix(self, ctx, new_prefix: str):
+        await ctx.send(f"Prefix updated to {new_prefix}")
+
+bot.add_cog(Moderation(bot))
+```
+
+## License
+
+This project is licensed under the MIT License.

aiko_api-0.1.1/README.md

@@ -0,0 +1,60 @@
+# aiko_api
+
+A clean, efficient, and modern Discord API wrapper for Python.
+
+`aiko_api` is designed to be a lightweight and easy-to-use alternative for building Discord bots and selfbots. It features a flat command hierarchy, smart signatures, and a powerful plugin system with hot-reloading.
+
+## Features
+
+- **Flat Sub-command Hierarchy:** Decorate commands with their parent commands for clean nesting.
+- **Smart Signatures:** `self` is optional in Cogs; the library detects if it's needed.
+- **Clean Cog Events:** Automatically register `on_` methods as event listeners.
+- **Advanced Plugin System:** Load Cogs and standalone commands from directories with built-in hot-reloading.
+- **Optimized HTTP:** Built on top of `curl_cffi` for high performance and better impersonation.
+
+## Installation
+
+```bash
+pip install aiko_api
+```
+
+## Quick Start
+
+```python
+import asyncio
+from aiko_api import Bot
+
+bot = Bot(command_prefix="!")
+
+@bot.command()
+async def ping(ctx):
+    await ctx.reply("Pong! 🏓")
+
+@bot.event
+async def on_ready(user):
+    print(f"Logged in as {user.username}")
+
+if __name__ == "__main__":
+    asyncio.run(bot.start("YOUR_TOKEN"))
+```
+
+## Advanced Usage: Cogs and Sub-commands
+
+```python
+from aiko_api import Cog, command
+
+class Moderation(Cog):
+    @command()
+    async def config(self, ctx):
+        await ctx.send("Main config menu.")
+
+    @config
+    async def prefix(self, ctx, new_prefix: str):
+        await ctx.send(f"Prefix updated to {new_prefix}")
+
+bot.add_cog(Moderation(bot))
+```
+
+## License
+
+This project is licensed under the MIT License.

aiko_api-0.1.1/aiko_api/__init__.py

@@ -0,0 +1,11 @@
+__title__ = 'aiko_api'
+__author__ = 'Aiko'
+__license__ = 'MIT'
+__version__ = '0.1.0'
+
+from .client import Client
+from .common.errors import *
+from .common.models import User, Message, Guild, Channel, Member, Activity
+from .common.constants import ActivityType, OpCode
+from .commands import Bot, Context, Command, Cog, command, cog
+from .katlog import get_logger

aiko_api-0.1.1/aiko_api/actions/guilds.py

@@ -0,0 +1,61 @@
+# aiko_api/actions/guilds.py
+from typing import Union, Optional
+import datetime
+
+class GuildActions:
+    def __init__(self, state):
+        self._state = state
+        self._http = state.http
+
+    async def leave(self, guild_id: Union[int, str]):
+        """Leaves a guild."""
+        return await self._http.delete(f"/users/@me/guilds/{guild_id}")
+
+    async def get_guild(self, guild_id: Union[int, str]):
+        """Fetches guild information."""
+        return await self._http.get(f"/guilds/{guild_id}")
+
+    async def get_channels(self, guild_id: Union[int, str]):
+        """Fetches channels in a guild."""
+        return await self._http.get(f"/guilds/{guild_id}/channels")
+
+    async def kick(self, guild_id: Union[int, str], user_id: Union[int, str], reason: Optional[str] = None):
+        """Kicks a member from the guild."""
+        headers = {}
+        if reason:
+            from urllib.parse import quote
+            headers["X-Audit-Log-Reason"] = quote(reason)
+        return await self._http.delete(f"/guilds/{guild_id}/members/{user_id}", headers=headers)
+
+    async def ban(self, guild_id: Union[int, str], user_id: Union[int, str], delete_message_days: int = 0, reason: Optional[str] = None):
+        """Bans a member from the guild."""
+        headers = {}
+        if reason:
+            from urllib.parse import quote
+            headers["X-Audit-Log-Reason"] = quote(reason)
+        
+        payload = {"delete_message_days": delete_message_days}
+        return await self._http.put(f"/guilds/{guild_id}/bans/{user_id}", json=payload, headers=headers)
+
+    async def unban(self, guild_id: Union[int, str], user_id: Union[int, str], reason: Optional[str] = None):
+        """Unbans a member from the guild."""
+        headers = {}
+        if reason:
+            from urllib.parse import quote
+            headers["X-Audit-Log-Reason"] = quote(reason)
+        return await self._http.delete(f"/guilds/{guild_id}/bans/{user_id}", headers=headers)
+
+    async def edit_member(self, guild_id: Union[int, str], user_id: Union[int, str], payload: dict, reason: Optional[str] = None):
+        """Edits a member (nick, roles, mute, deaf, communication_disabled_until)."""
+        headers = {}
+        if reason:
+            from urllib.parse import quote
+            headers["X-Audit-Log-Reason"] = quote(reason)
+        return await self._http.patch(f"/guilds/{guild_id}/members/{user_id}", json=payload, headers=headers)
+
+    async def timeout(self, guild_id: Union[int, str], user_id: Union[int, str], until: Optional[datetime.datetime], reason: Optional[str] = None):
+        """Timeouts a member until a specific datetime (ISO8601). Set until to None to remove timeout."""
+        payload = {
+            "communication_disabled_until": until.isoformat() if until else None
+        }
+        return await self.edit_member(guild_id, user_id, payload, reason=reason)

aiko_api-0.1.1/aiko_api/actions/messages.py

@@ -0,0 +1,60 @@
+# aiko_api/actions/messages.py
+import json
+import os
+from typing import Optional, List, Any, Union, Tuple
+
+class MessageActions:
+    def __init__(self, state):
+        self._state = state
+        self._http = state.http
+
+    async def send(
+        self, 
+        channel_id: Union[int, str], 
+        content: str, 
+        files: Optional[List[Union[str, Tuple[str, Any]]]] = None, 
+        message_reference: Optional[dict] = None
+    ):
+        payload = {"content": content}
+        if message_reference:
+            payload["message_reference"] = message_reference
+
+        if files:
+            file_data = {}
+            for i, item in enumerate(files):
+                if isinstance(item, tuple):
+                    filename, fp = item
+                    file_data[f"file{i}"] = (filename, fp)
+                else:
+                    file_data[f"file{i}"] = item
+            
+            return await self._http.post(
+                f"/channels/{channel_id}/messages", 
+                json=payload, 
+                files=file_data
+            )
+
+        return await self._http.post(f"/channels/{channel_id}/messages", json=payload)
+
+    async def reply(self, channel_id, message_id, content, **kwargs):
+        return await self.send(
+            channel_id, 
+            content, 
+            message_reference={"message_id": str(message_id)}, 
+            **kwargs
+        )
+
+    async def edit(self, channel_id, message_id, content):
+        return await self._http.patch(
+            f"/channels/{channel_id}/messages/{message_id}", 
+            json={"content": content}
+        )
+
+    async def delete(self, channel_id, message_id):
+        return await self._http.delete(f"/channels/{channel_id}/messages/{message_id}")
+
+    async def add_reaction(self, channel_id, message_id, emoji):
+        from urllib.parse import quote
+        return await self._http.put(
+            f"/channels/{channel_id}/messages/{message_id}/reactions/{quote(emoji)}/@me"
+        )

aiko_api-0.1.1/aiko_api/actions/user.py

@@ -0,0 +1,71 @@
+# aiko_api/actions/user.py
+import re
+import io
+from typing import Optional
+from curl_cffi import requests
+
+class UserActions:
+    def __init__(self, state):
+        self._state = state
+        self._http = state.http
+
+    async def static_login(self, token):
+        return await self._http.get("/users/@me")
+
+    async def edit_profile(self, payload):
+        return await self._http.patch("/users/@me", json=payload)
+
+    async def edit_settings(self, payload):
+        return await self._http.patch("/users/@me/settings", json=payload)
+
+    async def create_dm(self, recipient_id):
+        return await self._http.post("/users/@me/channels", json={"recipient_id": recipient_id})
+
+    async def get_relationships(self):
+        return await self._http.get("/users/@me/relationships")
+
+    async def add_friend(self, user_id):
+        return await self._http.put(f"/users/@me/relationships/{user_id}", json={})
+
+    async def remove_relationship(self, user_id):
+        return await self._http.delete(f"/users/@me/relationships/{user_id}")
+
+    async def block_user(self, user_id):
+        return await self._http.put(f"/users/@me/relationships/{user_id}", json={"type": 2})
+
+    async def change_presence(self, activity=None, status="online", since=0, afk=False):
+        if activity and activity.assets:
+            for key in ("large_image", "small_image"):
+                if activity.assets.get(key) and activity.assets[key].startswith("http"):
+                    new_asset = await self.upload_asset(activity.assets[key])
+                    if new_asset: activity.assets[key] = new_asset
+        
+        if self._state.ws:
+            await self._state.ws.change_presence(activity, status, since, afk)
+
+    async def upload_asset(self, image_url: str) -> Optional[str]:
+        discord_cdn_pattern = r"https?://(?:cdn\.discordapp\.com|media\.discordapp\.net)/attachments/(\d+)/(\d+)/(.+)"
+        match = re.search(discord_cdn_pattern, image_url)
+        if match:
+            channel_id, attachment_id, filename = match.groups()
+            return f"mp:attachments/{channel_id}/{attachment_id}/{filename}"
+
+        try:
+            async with requests.AsyncSession() as session:
+                r = await session.get(image_url, proxies={"http": self._http.proxy, "https": self._http.proxy} if self._http.proxy else None)
+                if r.status_code != 200: return None
+                image_bytes = r.content
+                filename = image_url.split("/")[-1].split("?")[0] or "asset.png"
+
+                dm_channel = await self.create_dm(self._state.user.id)
+                message = await self._state.messages.send(dm_channel["id"], "", files=[(filename, io.BytesIO(image_bytes))])
+                
+                if not message.get("attachments"): return None
+                new_url = message["attachments"][0]["url"]
+                new_match = re.search(discord_cdn_pattern, new_url)
+                if not new_match: return None
+                
+                cid, aid, fname = new_match.groups()
+                return f"mp:attachments/{cid}/{aid}/{fname}"
+        except Exception:
+            return None

aiko_api-0.1.1/aiko_api/cache.py

@@ -0,0 +1,136 @@
+from typing import Dict, Optional, Any, Deque, List
+from collections import deque
+from .common.models import User, Guild, Message, Channel, Member
+
+class Cache:
+    def __init__(self, client):
+        self.client = client
+        self.users: Dict[str, User] = {}
+        self.guilds: Dict[str, Guild] = {}
+        self.channels: Dict[str, Channel] = {}
+        self.messages: Deque[Message] = deque(maxlen=1000)
+        
+    def store_user(self, data: Dict[str, Any]) -> User:
+        user_id = data['id']
+        if user_id in self.users:
+            user = self.users[user_id]
+            user.username = data.get('username', user.username)
+            user.discriminator = data.get('discriminator', user.discriminator)
+            user.avatar = data.get('avatar', user.avatar)
+            return user
+
+        user = User(
+            id=user_id,
+            username=data['username'],
+            discriminator=data.get('discriminator', '0000'),
+            avatar=data.get('avatar'),
+            bot=data.get('bot', False),
+            _state=self.client
+        )
+        self.users[user.id] = user
+        return user
+
+    def get_user(self, user_id: str) -> Optional[User]:
+        return self.users.get(user_id)
+
+    def store_member(self, guild_id: str, data: Dict[str, Any]) -> Member:
+        user_data = data.get('user')
+        if not user_data:
+            user_data = data
+            
+        user = self.store_user(user_data)
+        member = Member(
+            id=user.id,
+            username=user.username,
+            discriminator=user.discriminator,
+            avatar=user.avatar,
+            bot=user.bot,
+            nick=data.get('nick'),
+            roles=data.get('roles', []),
+            joined_at=data.get('joined_at'),
+            _state=self.client
+        )
+        
+        guild = self.get_guild(guild_id)
+        if guild:
+            guild.members[member.id] = member
+            
+        return member
+
+    def store_guild(self, data: Dict[str, Any]) -> Guild:
+        guild_id = data['id']
+        guild = self.guilds.get(guild_id)
+        
+        if not guild:
+            guild = Guild(
+                id=guild_id,
+                name=data['name'],
+                icon=data.get('icon'),
+                owner_id=data.get('owner_id', ''),
+                _state=self.client
+            )
+            self.guilds[guild.id] = guild
+
+        guild.name = data.get('name', guild.name)
+        guild.icon = data.get('icon', guild.icon)
+        guild.owner_id = data.get('owner_id', guild.owner_id)
+
+        for channel_data in data.get('channels', []):
+            channel_data['guild_id'] = guild_id
+            self.store_channel(channel_data)
+
+        for member_data in data.get('members', []):
+            self.store_member(guild_id, member_data)
+
+        return guild
+
+    def get_guild(self, guild_id: str) -> Optional[Guild]:
+        return self.guilds.get(guild_id)
+
+    def store_channel(self, data: Dict[str, Any]) -> Channel:
+        channel_id = data['id']
+        channel = Channel(
+            id=channel_id,
+            name=data.get('name', 'unknown'),
+            type=data.get('type', 0),
+            guild_id=data.get('guild_id'),
+            _state=self.client
+        )
+        self.channels[channel.id] = channel
+        
+        if channel.guild_id:
+            guild = self.get_guild(channel.guild_id)
+            if guild:
+                guild.channels[channel.id] = channel
+                
+        return channel
+
+    def get_channel(self, channel_id: str) -> Optional[Channel]:
+        return self.channels.get(channel_id)
+
+    def store_message(self, data: Dict[str, Any]) -> Message:
+        author_data = data.get('author')
+        author = self.store_user(author_data) if author_data else None
+
+        message = Message(
+            id=data['id'],
+            channel_id=data['channel_id'],
+            guild_id=data.get('guild_id'),
+            author=author,
+            content=data.get('content', ''),
+            timestamp=data['timestamp'],
+            tts=data.get('tts', False),
+            mention_everyone=data.get('mention_everyone', False),
+            attachments=data.get('attachments', []),
+            embeds=data.get('embeds', []),
+            reactions=data.get('reactions', []),
+            _state=self.client
+        )
+        self.messages.append(message)
+        return message
+        
+    def clear(self):
+        self.users.clear()
+        self.guilds.clear()
+        self.channels.clear()
+        self.messages.clear()

aiko_api-0.1.1/aiko_api/client.py

@@ -0,0 +1,125 @@
+# aiko_api/client.py
+import asyncio
+from typing import Optional
+
+try:
+    import uvloop
+except ImportError:
+    uvloop = None
+
+from .katlog import get_logger
+from .core.http import HTTPClient
+from .gateway import DiscordWebSocket
+from .cache import Cache
+from .actions.messages import MessageActions
+from .actions.user import UserActions
+from .actions.guilds import GuildActions
+
+log = get_logger("aiko_api", level="DEBUG")
+
+class Client:
+    def __init__(self, loop=None, proxy=None):
+        self.loop = loop
+        self.proxy = proxy
+        self.http = HTTPClient(proxy=proxy)
+        
+        # Action components
+        self.messages = MessageActions(self)
+        self.user_actions = UserActions(self)
+        self.guilds = GuildActions(self)
+        
+        self.ws = None
+        self._events = {}
+        self._event_map = {
+            "READY": "on_ready",
+            "MESSAGE_CREATE": "on_message_create",
+            "GUILD_CREATE": "on_guild_create",
+        }
+        self.user = None
+        self.cache = Cache(self)
+        self._waiters = {}
+        self._stop_event = asyncio.Event()
+
+    def event(self, coro):
+        if not asyncio.iscoroutinefunction(coro):
+            raise TypeError("event registered must be a coroutine function")
+        name = coro.__name__
+        if name not in self._events:
+            self._events[name] = []
+        self._events[name].append(coro)
+        return coro
+
+    async def dispatch(self, event, data):
+        method_name = self._event_map.get(event, f"on_{event.lower()}")
+        
+        event_arg = data
+        if event == "MESSAGE_CREATE":
+            event_arg = self.cache.store_message(data)
+        elif event == "READY":
+            event_arg = self.user
+
+        # Handle waiters
+        if event.lower() in self._waiters:
+            for future, check in self._waiters[event.lower()][:]:
+                if not future.cancelled():
+                    try:
+                        if check(event_arg):
+                            future.set_result(event_arg)
+                            self._waiters[event.lower()].remove((future, check))
+                    except Exception as e:
+                        future.set_exception(e)
+                        self._waiters[event.lower()].remove((future, check))
+
+        if method_name in self._events:
+            for coro in self._events[method_name]:
+                try:
+                    await coro(event_arg)
+                except Exception as e:
+                    log.error(f"Error in event {method_name}: {e}")
+
+    async def wait_for(self, event, check=None, timeout=None):
+        if not check: check = lambda *args: True
+        future = self.loop.create_future()
+        event = event.lower()
+        if event not in self._waiters: self._waiters[event] = []
+        self._waiters[event].append((future, check))
+        try: return await asyncio.wait_for(future, timeout=timeout)
+        except asyncio.TimeoutError:
+            if event in self._waiters: self._waiters[event].remove((future, check))
+            raise
+
+    async def start(self, token):
+        if self.loop is None: self.loop = asyncio.get_running_loop()
+        self.http.token = token
+        self.http.headers.token = token
+        await self.user_actions.static_login(token)
+        self.ws = DiscordWebSocket(self, self.loop)
+        await self.ws.connect()
+        await self._stop_event.wait()
+
+    def run(self, token):
+        if self.loop is None:
+            try: self.loop = asyncio.get_event_loop()
+            except RuntimeError:
+                self.loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(self.loop)
+        if uvloop: asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
+        try: self.loop.run_until_complete(self.start(token))
+        except (KeyboardInterrupt, SystemExit): pass
+        finally:
+            self.loop.run_until_complete(self.close())
+            self.loop.close()
+
+    async def close(self):
+        self._stop_event.set()
+        if self.ws: await self.ws.close()
+        await self.http.close()
+
+    # Legacy/Shortcut methods
+    async def send_message(self, *args, **kwargs): return await self.messages.send(*args, **kwargs)
+    def send_message_bg(self, *args, **kwargs):
+        task = asyncio.create_task(self.send_message(*args, **kwargs))
+        task.add_done_callback(lambda t: t.exception() and log.error(f"BG send failed: {t.exception()}"))
+        return task
+    
+    async def change_presence(self, *args, **kwargs): return await self.user_actions.change_presence(*args, **kwargs)