jubbio.py 1.0.0__py3-none-any.whl

jubbio/__init__.py

@@ -0,0 +1,59 @@
+__title__ = "jubbio.py"
+__author__ = "Jubbio Community"
+__license__ = "MIT"
+__version__ = "1.0.0"
+
+from .client import Client
+from .models import (
+    User,
+    BotUser,
+    Member,
+    Guild,
+    Channel,
+    Message,
+    Role,
+    Embed,
+    EmbedField,
+    EmbedAuthor,
+    EmbedFooter,
+    EmbedImage,
+    EmbedThumbnail,
+    ActionRow,
+    Button,
+    SelectMenu,
+    SelectOption,
+    Invite,
+    Emoji,
+    Attachment,
+    Webhook,
+    Interaction,
+    InteractionResponse,
+    SlashCommand,
+    SlashCommandOption,
+    PermissionOverwrite,
+    Intents,
+    Color,
+    Mentions,
+    MessageReference,
+)
+from .enums import (
+    ChannelType,
+    ButtonStyle,
+    InteractionType,
+    InteractionCallbackType,
+    CommandOptionType,
+    OverwriteType,
+    Status,
+    Permissions,
+)
+from .errors import (
+    JubbioException,
+    HTTPException,
+    Forbidden,
+    NotFound,
+    RateLimited,
+    LoginFailure,
+    GatewayError,
+    InvalidToken,
+    InvalidArgument,
+)

jubbio/client.py

@@ -0,0 +1,191 @@
+from __future__ import annotations
+import asyncio
+import logging
+from typing import Callable, Dict, List, Optional
+
+from .http import HTTPClient
+from .gateway import Gateway
+from .models import (
+    User, BotUser, Member, Guild, Channel, Message, Role,
+    Embed, ActionRow, Mentions, MessageReference, Emoji,
+    Invite, Webhook, Interaction, SlashCommand, Intents,
+)
+from .errors import LoginFailure
+
+log = logging.getLogger(__name__)
+
+
+class Client:
+
+    def __init__(self, intents: Intents = None):
+        self.intents = intents or Intents.default()
+        self._http: Optional[HTTPClient] = None
+        self._gateway: Optional[Gateway] = None
+        self._token: Optional[str] = None
+        self._closed = False
+        self._ready = asyncio.Event()
+        self._event_handlers: Dict[str, Callable] = {}
+        self._command_handlers: Dict[str, Callable] = {}
+        self._component_handlers: Dict[str, Callable] = {}
+        self.user: Optional[BotUser] = None
+        self.application_id: Optional[str] = None
+        self.guilds: List[Guild] = []
+
+    def event(self, func: Callable) -> Callable:
+        if not asyncio.iscoroutinefunction(func):
+            raise TypeError("Olay dinleyicisi async olmalıdır")
+        self._event_handlers[func.__name__] = func
+        return func
+
+    def command(self, name: str = None):
+        def decorator(func: Callable) -> Callable:
+            if not asyncio.iscoroutinefunction(func):
+                raise TypeError("Komut dinleyicisi async olmalıdır")
+            self._command_handlers[name or func.__name__] = func
+            return func
+        return decorator
+
+    def component(self, custom_id: str):
+        def decorator(func: Callable) -> Callable:
+            if not asyncio.iscoroutinefunction(func):
+                raise TypeError("Bileşen dinleyicisi async olmalıdır")
+            self._component_handlers[custom_id] = func
+            return func
+        return decorator
+
+    def on(self, event_name: str):
+        def decorator(func: Callable) -> Callable:
+            if not asyncio.iscoroutinefunction(func):
+                raise TypeError("Olay dinleyicisi async olmalıdır")
+            full_name = f"on_{event_name}" if not event_name.startswith("on_") else event_name
+            self._event_handlers[full_name] = func
+            return func
+        return decorator
+
+    async def _handle_ready(self, data: dict):
+        user_data = data.get("user", data.get("bot", {}))
+        self.user = BotUser(user_data)
+        self.application_id = self.user.application_id
+        self.guilds = [Guild(g, http=self._http) for g in data.get("guilds", [])]
+        self._ready.set()
+
+        if "on_ready" in self._event_handlers:
+            await self._event_handlers["on_ready"]()
+
+    async def _dispatch(self, event_name: str, data: dict):
+        try:
+            if event_name == "on_message":
+                message = Message(data, http=self._http)
+                if message.author.id == (self.user.id if self.user else None):
+                    return
+                if event_name in self._event_handlers:
+                    await self._event_handlers[event_name](message)
+
+            elif event_name == "on_interaction":
+                interaction = Interaction(data, http=self._http)
+                if interaction.type == 2 and interaction.command_name in self._command_handlers:
+                    await self._command_handlers[interaction.command_name](interaction)
+                elif interaction.type == 3 and interaction.custom_id in self._component_handlers:
+                    await self._component_handlers[interaction.custom_id](interaction)
+                elif event_name in self._event_handlers:
+                    await self._event_handlers[event_name](interaction)
+
+            elif event_name in ("on_guild_join", "on_guild_remove"):
+                guild = Guild(data, http=self._http)
+                if event_name in self._event_handlers:
+                    await self._event_handlers[event_name](guild)
+
+            elif event_name in ("on_member_ban", "on_member_unban", "on_member_join", "on_member_remove"):
+                member = Member(data, guild_id=data.get("guild_id", ""), http=self._http)
+                if event_name in self._event_handlers:
+                    await self._event_handlers[event_name](member)
+
+            elif event_name in ("on_invite_create", "on_invite_delete"):
+                if event_name in self._event_handlers:
+                    await self._event_handlers[event_name](Invite(data))
+
+            else:
+                if event_name in self._event_handlers:
+                    await self._event_handlers[event_name](data)
+
+        except Exception as e:
+            log.error("Olay hatası (%s): %s", event_name, e, exc_info=True)
+            if "on_error" in self._event_handlers:
+                await self._event_handlers["on_error"](event_name, e)
+
+    async def start(self, token: str):
+        self._token = token
+        self._http = HTTPClient(token, client=self)
+        self._gateway = Gateway(self, token)
+
+        try:
+            self.user = await self._http.get_me()
+            self.application_id = self.user.application_id
+        except Exception as e:
+            raise LoginFailure(f"Giriş başarısız: {e}") from e
+
+        await self._gateway.connect()
+
+        try:
+            while not self._closed:
+                await asyncio.sleep(1)
+        except asyncio.CancelledError:
+            pass
+
+    def run(self, token: str):
+        async def runner():
+            try:
+                await self.start(token)
+            except KeyboardInterrupt:
+                pass
+            finally:
+                await self.close()
+
+        try:
+            asyncio.run(runner())
+        except KeyboardInterrupt:
+            pass
+
+    async def close(self):
+        self._closed = True
+        if self._gateway:
+            await self._gateway.close()
+        if self._http:
+            await self._http.close()
+
+    async def wait_until_ready(self):
+        await self._ready.wait()
+
+    async def get_user(self, user_id: str) -> User:
+        return await self._http.get_user(user_id)
+
+    async def get_guild(self, guild_id: str) -> Guild:
+        return await self._http.get_guild(guild_id)
+
+    async def send_dm(self, user_id: str, content: str = None, **kwargs) -> Message:
+        return await self._http.send_dm(user_id, content, **kwargs)
+
+    async def get_invite(self, code: str) -> Invite:
+        return await self._http.get_invite(code)
+
+    async def register_command(self, command: SlashCommand, guild_id: str = None):
+        if not self.application_id:
+            raise RuntimeError("Bot henüz hazır değil")
+        if guild_id:
+            return await self._http.register_guild_command(self.application_id, guild_id, command.to_dict())
+        return await self._http.register_global_command(self.application_id, command.to_dict())
+
+    async def delete_command(self, command_id: str, guild_id: str = None):
+        if not self.application_id:
+            raise RuntimeError("Bot henüz hazır değil")
+        if guild_id:
+            await self._http.delete_guild_command(self.application_id, guild_id, command_id)
+        else:
+            await self._http.delete_global_command(self.application_id, command_id)
+
+    async def get_commands(self, guild_id: str = None) -> list:
+        if not self.application_id:
+            raise RuntimeError("Bot henüz hazır değil")
+        if guild_id:
+            return await self._http.get_guild_commands(self.application_id, guild_id)
+        return await self._http.get_global_commands(self.application_id)

jubbio/enums.py

@@ -0,0 +1,84 @@
+from enum import IntEnum, IntFlag
+
+
+class ChannelType(IntEnum):
+    TEXT = 0
+    DM = 1
+    VOICE = 2
+    CATEGORY = 4
+
+
+class ButtonStyle(IntEnum):
+    PRIMARY = 1
+    SECONDARY = 2
+    SUCCESS = 3
+    DANGER = 4
+    LINK = 5
+
+
+class InteractionType(IntEnum):
+    PING = 1
+    APPLICATION_COMMAND = 2
+    MESSAGE_COMPONENT = 3
+
+
+class InteractionCallbackType(IntEnum):
+    PONG = 1
+    CHANNEL_MESSAGE_WITH_SOURCE = 4
+    DEFERRED_CHANNEL_MESSAGE_WITH_SOURCE = 5
+    DEFERRED_UPDATE_MESSAGE = 6
+    UPDATE_MESSAGE = 7
+
+
+class CommandOptionType(IntEnum):
+    SUB_COMMAND = 1
+    SUB_COMMAND_GROUP = 2
+    STRING = 3
+    INTEGER = 4
+    BOOLEAN = 5
+    USER = 6
+    CHANNEL = 7
+    ROLE = 8
+    NUMBER = 10
+
+
+class OverwriteType(IntEnum):
+    ROLE = 0
+    MEMBER = 1
+
+
+class Status(IntEnum):
+    ONLINE = 1
+    IDLE = 2
+    DND = 3
+    OFFLINE = 4
+
+
+class Permissions(IntFlag):
+    ADMINISTRATOR = 1 << 0
+    MANAGE_GUILD = 1 << 1
+    MANAGE_CHANNELS = 1 << 2
+    MANAGE_ROLES = 1 << 3
+    MANAGE_MESSAGES = 1 << 4
+    KICK_MEMBERS = 1 << 5
+    BAN_MEMBERS = 1 << 6
+    SEND_MESSAGES = 1 << 7
+    READ_MESSAGES = 1 << 8
+    EMBED_LINKS = 1 << 9
+    ATTACH_FILES = 1 << 10
+    MENTION_EVERYONE = 1 << 11
+    USE_EXTERNAL_EMOJIS = 1 << 12
+    ADD_REACTIONS = 1 << 13
+    CONNECT = 1 << 14
+    SPEAK = 1 << 15
+    MUTE_MEMBERS = 1 << 16
+    DEAFEN_MEMBERS = 1 << 17
+    MOVE_MEMBERS = 1 << 18
+    MANAGE_NICKNAMES = 1 << 19
+    MANAGE_WEBHOOKS = 1 << 20
+    CREATE_INVITES = 1 << 21
+    VIEW_AUDIT_LOG = 1 << 22
+    MANAGE_EMOJIS = 1 << 23
+    USE_SLASH_COMMANDS = 1 << 24
+    NONE = 0
+    ALL = (1 << 25) - 1

jubbio/errors.py

@@ -0,0 +1,57 @@
+class JubbioException(Exception):
+    pass
+
+
+class HTTPException(JubbioException):
+    def __init__(self, response, message=None):
+        self.response = response
+        self.status = response.status
+        self.code = 0
+
+        if isinstance(message, dict):
+            self.code = message.get("code", 0)
+            self.text = message.get("message", "")
+        else:
+            self.text = message or ""
+
+        fmt = f"{self.status} {self.response.reason}"
+        if self.text:
+            fmt += f": {self.text}"
+        if self.code:
+            fmt += f" (error code: {self.code})"
+
+        super().__init__(fmt)
+
+
+class Forbidden(HTTPException):
+    pass
+
+
+class NotFound(HTTPException):
+    pass
+
+
+class RateLimited(HTTPException):
+    def __init__(self, response, message=None):
+        super().__init__(response, message)
+        self.retry_after = 0.0
+        if isinstance(message, dict):
+            self.retry_after = message.get("retry_after", 0.0)
+
+
+class LoginFailure(JubbioException):
+    pass
+
+
+class GatewayError(JubbioException):
+    def __init__(self, message=None, code=None):
+        self.code = code
+        super().__init__(message or f"Gateway hatası (kod: {code})")
+
+
+class InvalidToken(LoginFailure):
+    pass
+
+
+class InvalidArgument(JubbioException):
+    pass

jubbio/gateway.py

@@ -0,0 +1,190 @@
+from __future__ import annotations
+import asyncio
+import json
+import logging
+from typing import TYPE_CHECKING, Optional
+
+import aiohttp
+
+from .errors import GatewayError, InvalidToken
+
+if TYPE_CHECKING:
+    from .client import Client
+
+log = logging.getLogger(__name__)
+
+GATEWAY_URL = "wss://realtime.jubbio.com/ws/bot"
+RECONNECTABLE_CLOSE_CODES = {4000, 4001, 4002, 4003}
+FATAL_CLOSE_CODES = {4004}
+
+
+class Gateway:
+
+    def __init__(self, client: "Client", token: str):
+        self._client = client
+        self._token = token
+        self._ws: Optional[aiohttp.ClientWebSocketResponse] = None
+        self._session: Optional[aiohttp.ClientSession] = None
+        self._heartbeat_task: Optional[asyncio.Task] = None
+        self._receive_task: Optional[asyncio.Task] = None
+        self._reconnect_count = 0
+        self._max_reconnects = 5
+        self._closed = False
+        self._ready = asyncio.Event()
+
+    @property
+    def is_connected(self) -> bool:
+        return self._ws is not None and not self._ws.closed
+
+    async def connect(self):
+        self._closed = False
+        self._reconnect_count = 0
+        await self._connect()
+
+    async def _connect(self):
+        try:
+            if self._session is None or self._session.closed:
+                self._session = aiohttp.ClientSession()
+
+            self._ws = await self._session.ws_connect(
+                GATEWAY_URL,
+                headers={"Authorization": f"Bot {self._token}"},
+                heartbeat=30.0,
+            )
+
+            await self._identify()
+            self._receive_task = asyncio.create_task(self._receive_loop())
+
+        except Exception as e:
+            log.error("Gateway bağlantı hatası: %s", e)
+            await self._try_reconnect()
+
+    async def _identify(self):
+        identify_data = {"token": self._token}
+        if hasattr(self._client, "intents") and self._client.intents:
+            identify_data["intents"] = self._client.intents.value
+
+        await self._send({"op": 2, "d": identify_data})
+
+    async def _send(self, data: dict):
+        if self._ws and not self._ws.closed:
+            await self._ws.send_json(data)
+
+    async def _receive_loop(self):
+        try:
+            async for msg in self._ws:
+                if msg.type == aiohttp.WSMsgType.TEXT:
+                    await self._handle_message(json.loads(msg.data))
+                elif msg.type == aiohttp.WSMsgType.BINARY:
+                    await self._handle_message(json.loads(msg.data))
+                elif msg.type == aiohttp.WSMsgType.ERROR:
+                    log.error("WebSocket hatası: %s", self._ws.exception())
+                    break
+                elif msg.type in (aiohttp.WSMsgType.CLOSE, aiohttp.WSMsgType.CLOSING, aiohttp.WSMsgType.CLOSED):
+                    break
+        except asyncio.CancelledError:
+            return
+        except Exception as e:
+            log.error("Receive loop hatası: %s", e)
+
+        if not self._closed:
+            close_code = self._ws.close_code if self._ws else None
+            await self._handle_close(close_code)
+
+    async def _handle_message(self, data: dict):
+        op = data.get("op")
+        event_type = data.get("t")
+        event_data = data.get("d", {})
+
+        if op == 11:
+            return
+
+        if op == 10:
+            interval = event_data.get("heartbeat_interval", 30000) / 1000
+            self._start_heartbeat(interval)
+            return
+
+        if op == 0 and event_type:
+            await self._dispatch_event(event_type, event_data)
+
+    async def _dispatch_event(self, event_type: str, data: dict):
+        event_map = {
+            "READY": "on_ready",
+            "MESSAGE_CREATE": "on_message",
+            "INTERACTION_CREATE": "on_interaction",
+            "GUILD_CREATE": "on_guild_join",
+            "GUILD_DELETE": "on_guild_remove",
+            "GUILD_BAN_ADD": "on_member_ban",
+            "GUILD_BAN_REMOVE": "on_member_unban",
+            "INVITE_CREATE": "on_invite_create",
+            "INVITE_DELETE": "on_invite_delete",
+            "PRESENCE_UPDATE": "on_presence_update",
+            "GUILD_MEMBER_ADD": "on_member_join",
+            "GUILD_MEMBER_REMOVE": "on_member_remove",
+        }
+
+        if event_type == "READY":
+            self._ready.set()
+            self._reconnect_count = 0
+            if hasattr(self._client, "_handle_ready"):
+                await self._client._handle_ready(data)
+            return
+
+        handler_name = event_map.get(event_type)
+        if handler_name and hasattr(self._client, "_dispatch"):
+            await self._client._dispatch(handler_name, data)
+
+    def _start_heartbeat(self, interval: float):
+        if self._heartbeat_task and not self._heartbeat_task.done():
+            self._heartbeat_task.cancel()
+        self._heartbeat_task = asyncio.create_task(self._heartbeat_loop(interval))
+
+    async def _heartbeat_loop(self, interval: float):
+        try:
+            while not self._closed and self.is_connected:
+                await self._send({"op": 1, "d": None})
+                await asyncio.sleep(interval)
+        except asyncio.CancelledError:
+            pass
+        except Exception as e:
+            log.error("Heartbeat hatası: %s", e)
+
+    async def _handle_close(self, code: int = None):
+        if code in FATAL_CLOSE_CODES:
+            self._closed = True
+            raise InvalidToken("Geçersiz bot token'ı!")
+
+        if code in RECONNECTABLE_CLOSE_CODES or code is None:
+            await self._try_reconnect()
+
+    async def _try_reconnect(self):
+        if self._closed:
+            return
+
+        if self._reconnect_count >= self._max_reconnects:
+            self._closed = True
+            raise GatewayError(f"Gateway'e {self._max_reconnects} denemeden sonra bağlanılamadı", code=None)
+
+        self._reconnect_count += 1
+        wait_time = min(2 ** self._reconnect_count, 60)
+        log.warning("Yeniden bağlanma %d/%d - %ds bekleniyor...", self._reconnect_count, self._max_reconnects, wait_time)
+        await asyncio.sleep(wait_time)
+        await self._cleanup()
+        await self._connect()
+
+    async def _cleanup(self):
+        if self._heartbeat_task and not self._heartbeat_task.done():
+            self._heartbeat_task.cancel()
+        if self._receive_task and not self._receive_task.done():
+            self._receive_task.cancel()
+        if self._ws and not self._ws.closed:
+            await self._ws.close()
+
+    async def close(self):
+        self._closed = True
+        await self._cleanup()
+        if self._session and not self._session.closed:
+            await self._session.close()
+
+    async def wait_until_ready(self):
+        await self._ready.wait()