micup 0.0.1__tar.gz → 0.1.0__tar.gz

micup-0.1.0/PKG-INFO

@@ -0,0 +1,55 @@
+Metadata-Version: 2.4
+Name: micup
+Version: 0.1.0
+Summary: Micup platformu için Python kütüphanesi.
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: aiohttp>=3.9
+Requires-Dist: livekit
+
+# micup
+
+Micup platformu için Python kütüphanesi. Bot yazmak için mesaj, komut, olay, yetki ve ses yönetimini tek yerden sağlar.
+
+## Kurulum
+
+```
+pip install micup
+```
+
+## Hızlı başlangıç
+
+```python
+from micup import Bot
+
+bot = Bot()  # token MICUP_TOKEN ortam değişkeninden okunur
+
+@bot.command("!ping")
+async def ping(msg):
+    return "pong"
+
+bot.run()
+```
+
+Token'ı kodun içine yazma. PowerShell'de:
+
+```powershell
+$env:MICUP_TOKEN = "uygulama_id.gizli_anahtar"
+python bot.py
+```
+
+## Özellikler
+
+- Gateway bağlantısı, kopunca otomatik yeniden bağlanma (resume destekli)
+- Komutlar ve olaylar: `@bot.command(...)`, `@bot.on(...)`
+- Mesaj işlemleri: gönder, düzenle, sil, toplu sil, listele
+- Ham REST erişimi: `bot.rest(...)`
+- Ses: kanala katılma, ayrılma, durum okuma (LiveKit medya bağlantısı dahil)
+- Durum: `bot.set_presence(...)`
+- Yetki bitleri ve snowflake yardımcıları
+
+Ayrıntılı kullanım için dokümantasyona bak.
+
+## Lisans
+
+Henüz belirlenmedi.

micup-0.1.0/README.md

@@ -0,0 +1,46 @@
+# micup
+
+Micup platformu için Python kütüphanesi. Bot yazmak için mesaj, komut, olay, yetki ve ses yönetimini tek yerden sağlar.
+
+## Kurulum
+
+```
+pip install micup
+```
+
+## Hızlı başlangıç
+
+```python
+from micup import Bot
+
+bot = Bot()  # token MICUP_TOKEN ortam değişkeninden okunur
+
+@bot.command("!ping")
+async def ping(msg):
+    return "pong"
+
+bot.run()
+```
+
+Token'ı kodun içine yazma. PowerShell'de:
+
+```powershell
+$env:MICUP_TOKEN = "uygulama_id.gizli_anahtar"
+python bot.py
+```
+
+## Özellikler
+
+- Gateway bağlantısı, kopunca otomatik yeniden bağlanma (resume destekli)
+- Komutlar ve olaylar: `@bot.command(...)`, `@bot.on(...)`
+- Mesaj işlemleri: gönder, düzenle, sil, toplu sil, listele
+- Ham REST erişimi: `bot.rest(...)`
+- Ses: kanala katılma, ayrılma, durum okuma (LiveKit medya bağlantısı dahil)
+- Durum: `bot.set_presence(...)`
+- Yetki bitleri ve snowflake yardımcıları
+
+Ayrıntılı kullanım için dokümantasyona bak.
+
+## Lisans
+
+Henüz belirlenmedi.

micup-0.1.0/micup/__init__.py

@@ -0,0 +1,12 @@
+from .client import Bot
+from .errors import MicupAPIError, MicupError
+from .models import Message, User
+from .permissions import Permissions
+from .utils import snowflake_to_datetime
+from .voice import Voice
+
+__version__ = "0.1.0"
+__all__ = [
+    "Bot", "Message", "User", "Voice", "Permissions",
+    "MicupAPIError", "MicupError", "snowflake_to_datetime",
+]

micup-0.1.0/micup/client.py

@@ -0,0 +1,384 @@
+import asyncio
+import json
+import logging
+import os
+import random
+import aiohttp
+from typing import Any, Callable, Dict, List, Optional
+from .constants import DEFAULT_IGNORED_EVENTS, DEFAULT_ORIGIN, FATAL_CLOSE_CODES, RATE_LIMIT_CLOSE_CODE, RESET_CLOSE_CODES, log
+from .errors import MicupAPIError
+from .models import Message, User
+from .voice import Voice
+
+
+class Bot:
+    def __init__(
+        self,
+        token: Optional[str] = None,
+        *,
+        ignored_events: Optional[List[str]] = None,
+        origin: str = DEFAULT_ORIGIN,
+        presence: Optional[Dict[str, Any]] = None,
+    ):
+        self.token = token or os.environ.get("MICUP_TOKEN")
+        if not self.token:
+            raise ValueError("Token yok. Bot(token) ver ya da MICUP_TOKEN ortam değişkenini ayarla.")
+
+        self.origin = origin.rstrip("/")
+        self.ignored_events = list(DEFAULT_IGNORED_EVENTS if ignored_events is None else ignored_events)
+        self.presence = presence
+
+        self.user: Optional[User] = None
+        self.session_id: Optional[str] = None
+        self.sequence: Optional[int] = None
+        self.voice = Voice(self)
+
+        self._api_url: Optional[str] = None
+        self._gateway_url: Optional[str] = None
+        self._http: Optional[aiohttp.ClientSession] = None
+        self._ws: Optional[aiohttp.ClientWebSocketResponse] = None
+        self._heartbeat_interval: Optional[float] = None
+        self._running = False
+        self._ready = False
+        self._handlers: Dict[str, List[Callable]] = {}
+        self._commands: Dict[str, Callable] = {}
+
+
+    def command(self, prefix: str):
+        def decorator(func: Callable):
+            self._commands[prefix] = func
+            return func
+        return decorator
+
+    def on(self, event: str):
+        def decorator(func: Callable):
+            self._handlers.setdefault(event.lower(), []).append(func)
+            return func
+        return decorator
+
+    def is_ready(self) -> bool:
+        return self._ready
+
+
+    async def _request(self, method: str, path: str, **kwargs) -> Any:
+        if self._http is None or self._api_url is None:
+            raise RuntimeError("Bot bağlı değil. Önce bot.run() ile başlat.")
+        headers = {"Authorization": f"Bot {self.token}"}
+        url = f"{self._api_url}{path}"
+
+        for _ in range(5):
+            async with self._http.request(method, url, headers=headers, **kwargs) as resp:
+                if resp.status == 204:
+                    return None
+                try:
+                    data = await resp.json(content_type=None)
+                except Exception:
+                    data = None
+
+                if resp.status == 429:
+                    body = data if isinstance(data, dict) else {}
+                    wait = float(body.get("retry_after", 1))
+                    log.warning("Rate limit: %.2f sn bekleniyor (%s)", wait, path)
+                    await asyncio.sleep(wait + 0.05)
+                    continue
+
+                if resp.status >= 400:
+                    body = data if isinstance(data, dict) else {}
+                    raise MicupAPIError(
+                        resp.status,
+                        body.get("code", ""),
+                        body.get("message", resp.reason or ""),
+                        body,
+                    )
+                return data
+
+        raise MicupAPIError(429, "RATE_LIMITED", "Çok fazla yeniden deneme")
+
+    async def rest(self, method: str, path: str, body: Any = None) -> Any:
+        kwargs: Dict[str, Any] = {}
+        if body is not None:
+            kwargs["json"] = body
+        return await self._request(method.upper(), f"/v1{path}", **kwargs)
+
+    async def send_message(
+        self,
+        channel_id: str,
+        content: Optional[str] = None,
+        reply_to: Optional[str] = None,
+        **fields: Any,
+    ) -> Message:
+        body: Dict[str, Any] = {k: v for k, v in fields.items() if v is not None}
+        if content is not None:
+            body["content"] = content
+        body.setdefault("allowed_mentions", {"parse": []})
+        if reply_to:
+            body["message_reference"] = {"message_id": reply_to, "channel_id": channel_id}
+        data = await self._request("POST", f"/v1/channels/{channel_id}/messages", json=body)
+        return Message(data, self)
+
+    async def edit_message(self, channel_id: str, message_id: str, content: str) -> Message:
+        data = await self._request(
+            "PATCH", f"/v1/channels/{channel_id}/messages/{message_id}", json={"content": content}
+        )
+        return Message(data, self)
+
+    async def delete_message(self, channel_id: str, message_id: str) -> None:
+        await self._request("DELETE", f"/v1/channels/{channel_id}/messages/{message_id}")
+
+    async def bulk_delete(self, channel_id: str, message_ids: List[str]) -> int:
+        ids = list(message_ids)
+        for i in range(0, len(ids), 100):
+            await self._request(
+                "POST",
+                f"/v1/channels/{channel_id}/messages/bulk-delete",
+                json={"message_ids": ids[i:i + 100]},
+            )
+        return len(ids)
+
+    async def get_messages(
+        self,
+        channel_id: str,
+        limit: int = 50,
+        before: Optional[str] = None,
+        after: Optional[str] = None,
+        around: Optional[str] = None,
+    ) -> List[Message]:
+        params: Dict[str, Any] = {"limit": max(1, min(int(limit), 100))}
+        if before:
+            params["before"] = before
+        if after:
+            params["after"] = after
+        if around:
+            params["around"] = around
+        data = await self._request("GET", f"/v1/channels/{channel_id}/messages", params=params)
+        return [Message(m, self) for m in data or []]
+
+    async def get_channel(self, channel_id: str) -> Dict[str, Any]:
+        return await self._request("GET", f"/v1/channels/{channel_id}")
+
+    async def get_user(self, user_id: str) -> User:
+        return User(await self._request("GET", f"/v1/users/{user_id}"))
+
+
+    async def set_presence(
+        self,
+        status: str,
+        *,
+        afk: bool = False,
+        mobile: bool = False,
+        custom_status: Optional[Any] = None,
+    ) -> None:
+        valid = {"online", "idle", "dnd", "invisible", "offline"}
+        if status not in valid:
+            raise ValueError(f"Geçersiz durum: {status}. Şunlardan biri olmalı: {sorted(valid)}")
+        d: Dict[str, Any] = {"status": status, "afk": afk, "mobile": mobile}
+        if custom_status is not None:
+            d["custom_status"] = {"text": custom_status} if isinstance(custom_status, str) else custom_status
+        await self._send({"op": 3, "d": d})
+
+    async def _discover(self) -> None:
+        async with aiohttp.ClientSession() as session:
+            async with session.get(f"{self.origin}/.well-known/fluxer") as resp:
+                if resp.status != 200:
+                    raise MicupAPIError(resp.status, "DISCOVERY_FAILED", "Keşif belgesi alınamadı")
+                data = await resp.json(content_type=None)
+        self._api_url = data["endpoints"]["api_public"].rstrip("/")
+        self._gateway_url = data["endpoints"]["gateway"]
+
+    async def _send(self, payload: Dict[str, Any]) -> None:
+        if self._ws is None:
+            raise RuntimeError("Gateway bağlantısı yok")
+        await self._ws.send_json(payload)
+
+    async def _heartbeat(self, ws: aiohttp.ClientWebSocketResponse) -> None:
+        try:
+            await asyncio.sleep(self._heartbeat_interval * random.random())
+            while True:
+                await ws.send_json({"op": 1, "d": self.sequence})
+                await asyncio.sleep(self._heartbeat_interval)
+        except Exception:
+            return
+
+    async def _identify(self) -> None:
+        await self._send({
+            "op": 2,
+            "d": {
+                "token": self.token,
+                "properties": {"os": "linux", "browser": "micup.py", "device": "micup.py"},
+                "presence": self.presence or {"status": "online", "afk": False, "mobile": False},
+                "ignored_events": self.ignored_events,
+                "flags": 0,
+            },
+        })
+
+    async def _resume(self) -> None:
+        await self._send({
+            "op": 6,
+            "d": {"token": self.token, "session_id": self.session_id, "seq": self.sequence},
+        })
+
+    async def _connect(self) -> Optional[int]:
+        async with self._http.ws_connect(f"{self._gateway_url}?v=1&encoding=json", max_msg_size=0) as ws:
+            self._ws = ws
+            hello = await ws.receive_json()
+            if hello.get("op") != 10:
+                raise MicupAPIError(0, "INVALID_HELLO", "Hello (op 10) bekleniyordu")
+            self._heartbeat_interval = hello["d"]["heartbeat_interval"] / 1000.0
+
+            hb = asyncio.create_task(self._heartbeat(ws))
+            try:
+                if self.session_id and self.sequence is not None:
+                    await self._resume()
+                else:
+                    await self._identify()
+
+                async for raw in ws:
+                    if raw.type == aiohttp.WSMsgType.TEXT:
+                        await self._handle(json.loads(raw.data))
+                    elif raw.type in (aiohttp.WSMsgType.CLOSED, aiohttp.WSMsgType.ERROR):
+                        break
+            finally:
+                hb.cancel()
+                self._ws = None
+
+        close_code = ws.close_code
+        if close_code in RESET_CLOSE_CODES:
+            self.session_id = None
+            self.sequence = None
+        return close_code
+
+    async def _handle(self, msg: Dict[str, Any]) -> None:
+        op = msg.get("op")
+        if op == 0:
+            await self._dispatch(msg.get("t"), msg.get("d") or {}, msg.get("s"))
+        elif op == 1:
+            await self._send({"op": 1, "d": self.sequence})
+        elif op == 7:
+            await self._ws.close()
+        elif op == 9:
+            if not msg.get("d"):
+                self.session_id = None
+                self.sequence = None
+            await self._ws.close()
+        elif op == 11:
+            pass
+        else:
+            log.debug("Bilinmeyen opcode: %s", op)
+
+    async def _dispatch(self, event: Optional[str], data: Dict[str, Any], seq: Optional[int]) -> None:
+        if seq is not None:
+            self.sequence = seq
+        if not event:
+            return
+
+        if event == "READY":
+            self.session_id = data.get("session_id")
+            self.user = User(data.get("user") or {})
+            self._ready = True
+            log.info("Bağlandı: %s", self.user.username)
+            await self._emit("ready", self)
+            return
+
+        if event == "RESUMED":
+            self._ready = True
+            log.info("Oturum devam ettirildi")
+            return
+
+        if event == "MESSAGE_CREATE":
+            msg = Message(data, self)
+            await self._emit("message_create", msg)
+            try:
+                await self._run_commands(msg)
+            except Exception:
+                log.exception("Komut işlenirken hata")
+            return
+
+        if event == "GUILD_CREATE":
+            self.voice._load_guild(data)
+        elif event == "VOICE_STATE_UPDATE":
+            self.voice._on_state(data)
+        elif event == "VOICE_SERVER_UPDATE":
+            self.voice._on_server(data)
+
+        await self._emit(event.lower(), data)
+
+    async def _emit(self, name: str, *args: Any) -> None:
+        for handler in self._handlers.get(name, []):
+            await self._call(handler, *args)
+
+    async def _call(self, func: Callable, *args: Any) -> Any:
+        try:
+            result = func(*args)
+            if asyncio.iscoroutine(result):
+                result = await result
+            return result
+        except Exception:
+            log.exception("Handler hatası: %s", getattr(func, "__name__", func))
+            return None
+
+    async def _run_commands(self, msg: Message) -> None:
+        if msg.author.bot or (self.user and msg.author.id == self.user.id):
+            return
+        for prefix in sorted(self._commands, key=len, reverse=True):
+            if msg.content == prefix or msg.content.startswith(prefix + " "):
+                result = await self._call(self._commands[prefix], msg)
+                if isinstance(result, str) and result:
+                    await msg.reply(result)
+                return
+
+
+    async def start(self) -> None:
+        self._running = True
+        self._http = aiohttp.ClientSession()
+        delay = 1.0
+        try:
+            while self._running:
+                try:
+                    await self._discover()
+                    code = await self._connect()
+                    self._ready = False
+                    await self._emit("disconnect", code, "")
+                    if not self._running:
+                        break
+                    if code in FATAL_CLOSE_CODES:
+                        log.error("Gateway kalıcı olarak kapattı (%s). Bot durduruldu.", code)
+                        break
+                    if code == RATE_LIMIT_CLOSE_CODE:
+                        log.warning("Çok sık bağlanıldı, 30 sn bekleniyor.")
+                        await asyncio.sleep(30)
+                    else:
+                        await asyncio.sleep(1)
+                    delay = 1.0
+                except asyncio.CancelledError:
+                    raise
+                except Exception as e:
+                    self._ready = False
+                    if not self._running:
+                        break
+                    await self._emit("error", e)
+                    log.warning("Bağlantı hatası: %s (%.0f sn sonra tekrar)", e, delay)
+                    await asyncio.sleep(delay)
+                    delay = min(delay * 2, 60)
+        finally:
+            self._running = False
+            self._ready = False
+            if self._http is not None:
+                await self._http.close()
+                self._http = None
+
+    async def close(self) -> None:
+        self._running = False
+        await self.voice.disconnect_all()
+        if self._ws is not None and not self._ws.closed:
+            await self._ws.close()
+
+    async def destroy(self) -> None:
+        await self.close()
+
+    def run(self) -> None:
+        if not logging.getLogger().handlers:
+            logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
+        try:
+            asyncio.run(self.start())
+        except KeyboardInterrupt:
+            log.info("Bot durduruldu")

micup-0.1.0/micup/constants.py

@@ -0,0 +1,13 @@
+import logging
+
+
+DEFAULT_ORIGIN = "https://micup.gg"
+SNOWFLAKE_EPOCH_MS = 1420070400000
+
+DEFAULT_IGNORED_EVENTS = ["TYPING_START", "PRESENCE_UPDATE"]
+
+FATAL_CLOSE_CODES = {4004, 4010, 4011, 4012}
+RESET_CLOSE_CODES = {4001, 4002, 4003, 4005, 4007}
+RATE_LIMIT_CLOSE_CODE = 4008
+
+log = logging.getLogger("micup")

micup-0.1.0/micup/errors.py

@@ -0,0 +1,14 @@
+from typing import Any
+
+
+class MicupAPIError(Exception):
+
+    def __init__(self, status: int, code: str, message: str, body: Any = None):
+        super().__init__(f"HTTP {status} {code}: {message}")
+        self.status = status
+        self.code = code
+        self.message = message
+        self.body = body
+
+
+MicupError = MicupAPIError

micup-0.1.0/micup/models.py

@@ -0,0 +1,50 @@
+from typing import Any, Dict, List, Optional
+from .utils import snowflake_to_datetime
+
+
+class User:
+
+    def __init__(self, data: Dict[str, Any]):
+        self.raw = data
+        self.id: Optional[str] = data.get("id")
+        self.username: Optional[str] = data.get("username")
+        self.global_name: Optional[str] = data.get("global_name")
+        self.bot: bool = bool(data.get("bot", False))
+
+    def __repr__(self) -> str:
+        return f"<User {self.username} ({self.id})>"
+
+
+class Message:
+
+    def __init__(self, data: Dict[str, Any], bot: "Bot"):
+        self._bot = bot
+        self.raw = data
+        self.id: str = data["id"]
+        self.channel_id: str = data["channel_id"]
+        self.guild_id: Optional[str] = data.get("guild_id")
+        self.member: Optional[Dict[str, Any]] = data.get("member")
+        self.content: str = data.get("content", "")
+        self.author = User(data.get("author") or {})
+        self.pinned: bool = bool(data.get("pinned", False))
+        self.created_at = snowflake_to_datetime(self.id)
+
+    @property
+    def is_bot(self) -> bool:
+        return self.author.bot
+
+    @property
+    def args(self) -> List[str]:
+        return self.content.split()[1:]
+
+    async def reply(self, content: Optional[str] = None, **fields: Any) -> "Message":
+        return await self._bot.send_message(self.channel_id, content, reply_to=self.id, **fields)
+
+    async def send(self, content: Optional[str] = None, **fields: Any) -> "Message":
+        return await self._bot.send_message(self.channel_id, content, **fields)
+
+    async def edit(self, content: str) -> "Message":
+        return await self._bot.edit_message(self.channel_id, self.id, content)
+
+    async def delete(self) -> None:
+        await self._bot.delete_message(self.channel_id, self.id)

micup-0.1.0/micup/permissions.py

@@ -0,0 +1,30 @@
+from typing import Any
+
+
+class Permissions:
+
+    ADMINISTRATOR = 1 << 3
+    MANAGE_CHANNELS = 1 << 4
+    ADD_REACTIONS = 1 << 6
+    VIEW_CHANNEL = 1 << 10
+    SEND_MESSAGES = 1 << 11
+    MANAGE_MESSAGES = 1 << 13
+    EMBED_LINKS = 1 << 14
+    ATTACH_FILES = 1 << 15
+    READ_MESSAGE_HISTORY = 1 << 16
+    MENTION_EVERYONE = 1 << 17
+    CONNECT = 1 << 20
+    SPEAK = 1 << 21
+    MUTE_MEMBERS = 1 << 22
+    DEAFEN_MEMBERS = 1 << 23
+    MOVE_MEMBERS = 1 << 24
+    MANAGE_ROLES = 1 << 28
+    STREAM = 1 << 37
+    PIN_MESSAGES = 1 << 51
+
+    @staticmethod
+    def has(mask: Any, perm: int) -> bool:
+        mask = int(mask)
+        if mask & Permissions.ADMINISTRATOR:
+            return True
+        return (mask & perm) == perm

micup-0.1.0/micup/utils.py

@@ -0,0 +1,7 @@
+from datetime import datetime, timezone
+from .constants import SNOWFLAKE_EPOCH_MS
+
+
+def snowflake_to_datetime(snowflake: str) -> datetime:
+    ms = (int(snowflake) >> 22) + SNOWFLAKE_EPOCH_MS
+    return datetime.fromtimestamp(ms / 1000, tz=timezone.utc)

micup-0.1.0/micup/voice.py

@@ -0,0 +1,190 @@
+import asyncio
+from typing import Any, Dict, List, Optional
+from .constants import log
+from .errors import MicupAPIError
+
+
+class Voice:
+
+    def __init__(self, bot: "Bot"):
+        self._bot = bot
+        self._states: Dict[str, Dict[str, Dict[str, Any]]] = {}
+        self._grants: Dict[str, asyncio.Future] = {}
+        self._mine: Dict[str, Dict[str, Any]] = {}
+        self._rooms: Dict[str, Any] = {}
+
+    async def _connect_media(self, guild_id: str, grant: Dict[str, Any]) -> None:
+        try:
+            from livekit import rtc
+        except ImportError:
+            raise MicupAPIError(0, "LIVEKIT_MISSING", "Ses medyası için 'pip install livekit' gerekli")
+
+        old = self._rooms.pop(guild_id, None)
+        if old is not None:
+            await old.disconnect()
+
+        room = rtc.Room()
+        await room.connect(grant["endpoint"], grant["token"])
+        self._rooms[guild_id] = room
+        log.info("LiveKit odasına bağlandı (guild %s)", guild_id)
+
+    async def disconnect_all(self) -> None:
+        for guild_id in list(self._rooms):
+            room = self._rooms.pop(guild_id)
+            try:
+                await room.disconnect()
+            except Exception as e:
+                log.warning("LiveKit kapatma hatası (%s): %s", guild_id, e)
+
+
+    def _load_guild(self, guild: Dict[str, Any]) -> None:
+        gid = guild.get("id")
+        for st in guild.get("voice_states") or []:
+            self._on_state(dict(st, guild_id=st.get("guild_id") or gid))
+
+    def _on_state(self, st: Dict[str, Any]) -> None:
+        gid = st.get("guild_id")
+        if gid is None:
+            return
+        key = st.get("connection_id") or st.get("user_id")
+        if not key:
+            return
+        states = self._states.setdefault(gid, {})
+        is_me = self._bot.user is not None and st.get("user_id") == self._bot.user.id
+        if st.get("channel_id") is None:
+            states.pop(key, None)
+            if is_me:
+                self._mine.pop(gid, None)
+        else:
+            states[key] = st
+            if is_me and gid in self._mine and st.get("connection_id") == self._mine[gid].get("connection_id"):
+                self._mine[gid]["channel_id"] = st.get("channel_id")
+
+    def _on_server(self, data: Dict[str, Any]) -> None:
+        fut = self._grants.get(data.get("channel_id"))
+        if fut is not None and not fut.done():
+            fut.set_result(data)
+
+
+    def _own_state(self, guild_id: str) -> Optional[Dict[str, Any]]:
+        if self._bot.user is None:
+            return None
+        for st in self._states.get(guild_id, {}).values():
+            if st.get("user_id") == self._bot.user.id:
+                return st
+        return None
+
+
+    def get_states(self, guild_id: str) -> List[Dict[str, Any]]:
+        return list(self._states.get(guild_id, {}).values())
+
+    async def join(
+        self,
+        guild_id: str,
+        channel_id: str,
+        *,
+        self_mute: bool = False,
+        self_deaf: bool = False,
+        self_video: bool = False,
+        timeout: float = 15.0,
+        state_timeout: float = 60.0,
+        media: bool = True,
+    ) -> Dict[str, Any]:
+        fut = asyncio.get_running_loop().create_future()
+        self._grants[channel_id] = fut
+        try:
+            await self._bot._send({
+                "op": 4,
+                "d": {
+                    "guild_id": guild_id,
+                    "channel_id": channel_id,
+                    "self_mute": self_mute,
+                    "self_deaf": self_deaf,
+                    "self_video": self_video,
+                    "self_stream": False,
+                },
+            })
+            grant = await asyncio.wait_for(fut, timeout)
+        except asyncio.TimeoutError:
+            raise MicupAPIError(0, "VOICE_TIMEOUT", f"{channel_id} için ses bilgisi gelmedi")
+        finally:
+            self._grants.pop(channel_id, None)
+
+        if media:
+            await self._connect_media(guild_id, grant)
+
+        connection_id = grant.get("connection_id")
+        waited = 0.0
+        while connection_id not in self._states.get(guild_id, {}):
+            if waited >= state_timeout:
+                print(f"[micup] UYARI: {state_timeout:.0f} sn içinde kendi ses durumu gelmedi, grant ile devam ediliyor")
+                break
+            await asyncio.sleep(0.5)
+            waited += 0.5
+        own = self._own_state(guild_id) or {}
+        self._mine[guild_id] = {
+            "channel_id": channel_id,
+            "connection_id": connection_id,
+            "self_mute": self_mute,
+            "self_deaf": self_deaf,
+            "self_video": self_video,
+            "self_stream": False,
+        }
+        return {
+            "guild_id": grant.get("guild_id", guild_id),
+            "channel_id": channel_id,
+            "connection_id": connection_id,
+            "session_id": own.get("session_id"),
+            "endpoint": grant.get("endpoint"),
+            "token": grant.get("token"),
+        }
+
+    def _own_link(self, guild_id: str) -> Optional[Dict[str, Any]]:
+        if guild_id in self._mine:
+            return self._mine[guild_id]
+        st = self._own_state(guild_id)
+        if st and st.get("connection_id"):
+            return {
+                "channel_id": st.get("channel_id"),
+                "connection_id": st["connection_id"],
+                "self_mute": st.get("self_mute", False),
+                "self_deaf": st.get("self_deaf", False),
+                "self_video": st.get("self_video", False),
+                "self_stream": st.get("self_stream", False),
+            }
+        return None
+
+    async def leave(self, guild_id: str) -> None:
+        link = self._own_link(guild_id)
+        if not link or not link.get("connection_id"):
+            raise MicupAPIError(0, "VOICE_NOT_CONNECTED", "Bu sunucuda bağlı bir ses bağlantın yok")
+        await self._bot._send({
+            "op": 4,
+            "d": {"guild_id": guild_id, "channel_id": None, "connection_id": link["connection_id"]},
+        })
+        self._mine.pop(guild_id, None)
+        room = self._rooms.pop(guild_id, None)
+        if room is not None:
+            await room.disconnect()
+
+    async def update(self, guild_id: str, *, self_mute: Optional[bool] = None, self_deaf: Optional[bool] = None,
+                     self_video: Optional[bool] = None) -> None:
+        link = self._own_link(guild_id)
+        if not link or not link.get("connection_id"):
+            raise MicupAPIError(0, "VOICE_NOT_CONNECTED", "Bu sunucuda bağlı bir ses bağlantın yok")
+        new = {
+            "self_mute": link.get("self_mute", False) if self_mute is None else self_mute,
+            "self_deaf": link.get("self_deaf", False) if self_deaf is None else self_deaf,
+            "self_video": link.get("self_video", False) if self_video is None else self_video,
+        }
+        await self._bot._send({
+            "op": 4,
+            "d": {
+                "guild_id": guild_id,
+                "channel_id": link["channel_id"],
+                "connection_id": link["connection_id"],
+                **new,
+                "self_stream": link.get("self_stream", False),
+            },
+        })
+        link.update(new)

micup-0.1.0/micup.egg-info/PKG-INFO

@@ -0,0 +1,55 @@
+Metadata-Version: 2.4
+Name: micup
+Version: 0.1.0
+Summary: Micup platformu için Python kütüphanesi.
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: aiohttp>=3.9
+Requires-Dist: livekit
+
+# micup
+
+Micup platformu için Python kütüphanesi. Bot yazmak için mesaj, komut, olay, yetki ve ses yönetimini tek yerden sağlar.
+
+## Kurulum
+
+```
+pip install micup
+```
+
+## Hızlı başlangıç
+
+```python
+from micup import Bot
+
+bot = Bot()  # token MICUP_TOKEN ortam değişkeninden okunur
+
+@bot.command("!ping")
+async def ping(msg):
+    return "pong"
+
+bot.run()
+```
+
+Token'ı kodun içine yazma. PowerShell'de:
+
+```powershell
+$env:MICUP_TOKEN = "uygulama_id.gizli_anahtar"
+python bot.py
+```
+
+## Özellikler
+
+- Gateway bağlantısı, kopunca otomatik yeniden bağlanma (resume destekli)
+- Komutlar ve olaylar: `@bot.command(...)`, `@bot.on(...)`
+- Mesaj işlemleri: gönder, düzenle, sil, toplu sil, listele
+- Ham REST erişimi: `bot.rest(...)`
+- Ses: kanala katılma, ayrılma, durum okuma (LiveKit medya bağlantısı dahil)
+- Durum: `bot.set_presence(...)`
+- Yetki bitleri ve snowflake yardımcıları
+
+Ayrıntılı kullanım için dokümantasyona bak.
+
+## Lisans
+
+Henüz belirlenmedi.

micup-0.1.0/micup.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+micup/__init__.py
+micup/client.py
+micup/constants.py
+micup/errors.py
+micup/models.py
+micup/permissions.py
+micup/utils.py
+micup/voice.py
+micup.egg-info/PKG-INFO
+micup.egg-info/SOURCES.txt
+micup.egg-info/dependency_links.txt
+micup.egg-info/requires.txt
+micup.egg-info/top_level.txt

{micup-0.0.1 → micup-0.1.0}/micup.egg-info/requires.txt

@@ -1 +1,2 @@
 aiohttp>=3.9
+livekit

micup-0.1.0/pyproject.toml

@@ -0,0 +1,17 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "micup"
+version = "0.1.0"
+description = "Micup platformu için Python kütüphanesi."
+readme = "README.md"
+requires-python = ">=3.9"
+dependencies = [
+    "aiohttp>=3.9",
+    "livekit",
+]
+
+[tool.setuptools]
+packages = ["micup"]

micup-0.0.1/PKG-INFO

@@ -1,28 +0,0 @@
-Metadata-Version: 2.4
-Name: micup
-Version: 0.0.1
-Summary: Python library for Micup bots (in development)
-Author-email: Renbow <egekoc28@gmail.com>
-License: MIT
-Classifier: Development Status :: 1 - Planning
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-Requires-Dist: aiohttp>=3.9
-
-# micup
-
-Micup platformu için Python bot kütüphanesi. Şu an geliştirme aşamasında, henüz kullanılabilir bir sürüm yayınlanmadı.
-
-Planlanan kullanım:
-
-    from micup import Bot
-
-    bot = Bot()
-
-    @bot.command("!ping")
-    async def ping(msg):
-        return "pong"
-
-    bot.run()

micup-0.0.1/README.md

@@ -1,15 +0,0 @@
-# micup
-
-Micup platformu için Python bot kütüphanesi. Şu an geliştirme aşamasında, henüz kullanılabilir bir sürüm yayınlanmadı.
-
-Planlanan kullanım:
-
-    from micup import Bot
-
-    bot = Bot()
-
-    @bot.command("!ping")
-    async def ping(msg):
-        return "pong"
-
-    bot.run()

micup-0.0.1/micup/init.py

@@ -1,3 +0,0 @@
-"""Micup bot kütüphanesi. Geliştirme aşamasında."""
-
-__version__ = "0.0.1"

micup-0.0.1/micup.egg-info/PKG-INFO

@@ -1,28 +0,0 @@
-Metadata-Version: 2.4
-Name: micup
-Version: 0.0.1
-Summary: Python library for Micup bots (in development)
-Author-email: Renbow <egekoc28@gmail.com>
-License: MIT
-Classifier: Development Status :: 1 - Planning
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-Requires-Dist: aiohttp>=3.9
-
-# micup
-
-Micup platformu için Python bot kütüphanesi. Şu an geliştirme aşamasında, henüz kullanılabilir bir sürüm yayınlanmadı.
-
-Planlanan kullanım:
-
-    from micup import Bot
-
-    bot = Bot()
-
-    @bot.command("!ping")
-    async def ping(msg):
-        return "pong"
-
-    bot.run()

micup-0.0.1/micup.egg-info/SOURCES.txt

@@ -1,8 +0,0 @@
-README.md
-pyproject.toml
-micup/init.py
-micup.egg-info/PKG-INFO
-micup.egg-info/SOURCES.txt
-micup.egg-info/dependency_links.txt
-micup.egg-info/requires.txt
-micup.egg-info/top_level.txt

micup-0.0.1/pyproject.toml

@@ -1,21 +0,0 @@
-[build-system]
-requires = ["setuptools>=68", "wheel"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "micup"
-version = "0.0.1"
-description = "Python library for Micup bots (in development)"
-readme = "README.md"
-requires-python = ">=3.9"
-license = {text = "MIT"}
-authors = [{name = "Renbow", email = "egekoc28@gmail.com"}]
-dependencies = ["aiohttp>=3.9"]
-classifiers = [
-    "Development Status :: 1 - Planning",
-    "Programming Language :: Python :: 3",
-    "License :: OSI Approved :: MIT License",
-]
-
-[tool.setuptools]
-packages = ["micup"]