zynko 0.1.0__py3-none-any.whl

zynko/rest.py

@@ -0,0 +1,309 @@
+"""The HTTP API with a bot's token (docs.zynko.org/api/rotas).
+
+Every route is reachable through :meth:`Rest.request`; the common ones have their own method.
+Methods return the API's JSON as it came (dicts and lists); :class:`zynko.Client` wraps
+messages in :class:`zynko.Message`.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+from collections.abc import Callable
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Union
+from urllib.parse import quote, urlencode
+
+import aiohttp
+
+from .models import Card, Command, Components
+
+__all__ = ["Rest", "ZynkoError", "File", "FileInput", "DEFAULT_API"]
+
+DEFAULT_API = "https://zynko.org/api"
+JSON = Any
+
+
+class ZynkoError(Exception):
+    """An answer the API refused (docs.zynko.org/api/#erros)."""
+
+    def __init__(self, status: int, code: str, message: str) -> None:
+        super().__init__(message)
+        #: HTTP status.
+        self.status = status
+        #: ``bad_request``, ``forbidden``, ``not_found``, ``rate_limited``...
+        self.code = code
+        self.message = message
+
+    def __repr__(self) -> str:
+        return f"ZynkoError(status={self.status}, code={self.code!r}, message={self.message!r})"
+
+
+@dataclass(slots=True)
+class File:
+    """A file to send with a message."""
+
+    name: str
+    data: bytes
+    content_type: str | None = None
+
+    @classmethod
+    def from_path(cls, path: str | os.PathLike[str], name: str | None = None) -> File:
+        p = Path(path)
+        return cls(name=name or p.name, data=p.read_bytes())
+
+
+#: A :class:`File`, or a path to read.
+FileInput = Union[File, str, "os.PathLike[str]"]
+
+
+def _as_file(f: FileInput) -> File:
+    return f if isinstance(f, File) else File.from_path(f)
+
+
+def _drop_none(d: dict[str, Any]) -> dict[str, Any]:
+    return {k: v for k, v in d.items() if v is not None}
+
+
+class Rest:
+    """The HTTP API with a bot's token."""
+
+    def __init__(self, token: str, *, api: str | None = None, retries: int = 3) -> None:
+        self.token = token
+        #: Where the API is: https://zynko.org/api unless you run your own server.
+        self.api = (api or DEFAULT_API).rstrip("/")
+        #: Waits out a 429 and tries again, up to this many times (0: never).
+        self.retries = retries
+        self._session: aiohttp.ClientSession | None = None
+
+    @property
+    def base(self) -> str:
+        """The server's address without /api, to turn ``/api/media/...`` paths into links."""
+        return self.api[: -len("/api")] if self.api.endswith("/api") else self.api
+
+    @property
+    def session(self) -> aiohttp.ClientSession:
+        """The HTTP session, made on first use (it needs a running event loop)."""
+        if self._session is None or self._session.closed:
+            self._session = aiohttp.ClientSession()
+        return self._session
+
+    async def close(self) -> None:
+        if self._session is not None and not self._session.closed:
+            await self._session.close()
+        self._session = None
+
+    async def request(
+        self,
+        method: str,
+        path: str,
+        body: Any = None,
+        *,
+        form: aiohttp.FormData | Callable[[], aiohttp.FormData] | None = None,
+    ) -> JSON:
+        """Calls a route. ``body`` goes as JSON; ``form`` as multipart (uploads).
+
+        A form can be sent once only: pass a function that builds it to have uploads retried
+        after a 429 too.
+        """
+        for attempt in range(self.retries + 1):
+            headers = {"Authorization": f"Bot {self.token}"}
+            data: Any = None
+            if form is not None:
+                data = form() if callable(form) else form
+            elif body is not None:
+                headers["Content-Type"] = "application/json"
+                data = json.dumps(body)
+            async with self.session.request(method, self.api + path, data=data, headers=headers) as res:
+                text = await res.text()
+                if res.ok:
+                    return json.loads(text) if text else None
+                err: dict[str, Any] = {}
+                try:
+                    parsed = json.loads(text)
+                    if isinstance(parsed, dict):
+                        err = parsed
+                except ValueError:
+                    pass
+                if res.status == 429 and attempt < self.retries and err.get("code") == "rate_limited":
+                    wait_ms = err.get("retry_after_ms")
+                    if wait_ms is None:
+                        wait_ms = float(res.headers.get("Retry-After", "1")) * 1000
+                    if not isinstance(form, aiohttp.FormData):
+                        await asyncio.sleep((float(wait_ms) + 50) / 1000)
+                        continue
+                raise ZynkoError(res.status, err.get("code") or f"http_{res.status}", err.get("message") or res.reason or "")
+        raise AssertionError("unreachable")
+
+    async def get(self, path: str) -> JSON:
+        return await self.request("GET", path)
+
+    async def post(self, path: str, body: Any = None) -> JSON:
+        return await self.request("POST", path, {} if body is None else body)
+
+    async def patch(self, path: str, body: Any) -> JSON:
+        return await self.request("PATCH", path, body)
+
+    async def put(self, path: str, body: Any = None) -> JSON:
+        return await self.request("PUT", path, body)
+
+    async def delete(self, path: str) -> JSON:
+        return await self.request("DELETE", path)
+
+    # ---------- messages ----------
+
+    async def send(
+        self,
+        channel_id: str,
+        content: str | None = None,
+        *,
+        reply_to: str | None = None,
+        files: list[FileInput] | None = None,
+        nonce: str | None = None,
+        cards: list[Card] | None = None,
+        components: Components | None = None,
+    ) -> JSON:
+        """Sends a message; files are uploaded first (up to 10)."""
+        attachment_ids = [(await self.upload(channel_id, f))["id"] for f in files or []]
+        body: dict[str, Any] = {"content": content or ""}
+        if reply_to:
+            body["reply_to"] = reply_to
+        if nonce:
+            body["nonce"] = nonce
+        if attachment_ids:
+            body["attachment_ids"] = attachment_ids
+        if cards:
+            body["cards"] = cards
+        if components:
+            body["components"] = components
+        return await self.post(f"/channels/{channel_id}/messages", body)
+
+    async def upload(self, channel_id: str, file: FileInput) -> JSON:
+        """Uploads a file to a channel, to be sent in a message (see :meth:`send`)."""
+        f = _as_file(file)
+
+        def form() -> aiohttp.FormData:
+            fd = aiohttp.FormData()
+            fd.add_field("file", f.data, filename=f.name, content_type=f.content_type or "application/octet-stream")
+            return fd
+
+        return await self.request("POST", f"/channels/{channel_id}/attachments", form=form)
+
+    async def edit_message(
+        self,
+        channel_id: str,
+        message_id: str,
+        content: str | None = None,
+        *,
+        cards: list[Card] | None = None,
+        components: Components | None = None,
+    ) -> JSON:
+        """Changes the bot's own message: whatever is given (text, cards, buttons)."""
+        body = _drop_none({"content": content, "cards": cards, "components": components})
+        return await self.patch(f"/channels/{channel_id}/messages/{message_id}", body)
+
+    async def delete_message(self, channel_id: str, message_id: str) -> JSON:
+        return await self.delete(f"/channels/{channel_id}/messages/{message_id}")
+
+    async def messages(
+        self, channel_id: str, *, before: str | None = None, after: str | None = None, limit: int | None = None
+    ) -> list[JSON]:
+        """Messages, newest first; ``before``/``after`` an id, up to ``limit`` (100)."""
+        q = urlencode(_drop_none({"before": before, "after": after, "limit": limit}))
+        return await self.get(f"/channels/{channel_id}/messages" + (f"?{q}" if q else ""))  # type: ignore[no-any-return]
+
+    async def react(self, channel_id: str, message_id: str, emoji: str) -> JSON:
+        return await self.put(f"/channels/{channel_id}/messages/{message_id}/reactions/{quote(emoji, safe='')}")
+
+    async def unreact(self, channel_id: str, message_id: str, emoji: str) -> JSON:
+        return await self.delete(f"/channels/{channel_id}/messages/{message_id}/reactions/{quote(emoji, safe='')}")
+
+    async def typing(self, channel_id: str) -> JSON:
+        """"Digitando..." for a few seconds."""
+        return await self.post(f"/channels/{channel_id}/typing")
+
+    # ---------- people, guilds, channels ----------
+
+    async def me(self) -> JSON:
+        return await self.get("/users/@me")
+
+    async def profile(self, user_id: str) -> JSON:
+        return await self.get(f"/users/{user_id}/profile")
+
+    async def dm(self, user_id: str) -> JSON:
+        """The DM channel with someone (opened if needed)."""
+        return await self.post("/users/@me/channels", {"recipient_id": user_id})
+
+    async def members(self, guild_id: str) -> list[JSON]:
+        return await self.get(f"/guilds/{guild_id}/members")  # type: ignore[no-any-return]
+
+    async def kick(self, guild_id: str, user_id: str) -> JSON:
+        return await self.delete(f"/guilds/{guild_id}/members/{user_id}")
+
+    async def ban(self, guild_id: str, user_id: str) -> JSON:
+        return await self.put(f"/guilds/{guild_id}/bans/{user_id}")
+
+    async def unban(self, guild_id: str, user_id: str) -> JSON:
+        return await self.delete(f"/guilds/{guild_id}/bans/{user_id}")
+
+    async def add_role(self, guild_id: str, user_id: str, role_id: str) -> JSON:
+        return await self.put(f"/guilds/{guild_id}/members/{user_id}/roles/{role_id}")
+
+    async def remove_role(self, guild_id: str, user_id: str, role_id: str) -> JSON:
+        return await self.delete(f"/guilds/{guild_id}/members/{user_id}/roles/{role_id}")
+
+    async def create_role(
+        self,
+        guild_id: str,
+        name: str,
+        *,
+        color: int | None = None,
+        permissions: int | None = None,
+        hoist: bool | None = None,
+    ) -> JSON:
+        body = _drop_none({"name": name, "color": color, "permissions": permissions, "hoist": hoist})
+        return await self.post(f"/guilds/{guild_id}/roles", body)
+
+    async def create_channel(
+        self,
+        guild_id: str,
+        name: str,
+        *,
+        type: int | None = None,
+        parent_id: str | None = None,
+        topic: str | None = None,
+    ) -> JSON:
+        body = _drop_none({"name": name, "type": type, "parent_id": parent_id, "topic": topic})
+        return await self.post(f"/guilds/{guild_id}/channels", body)
+
+    async def edit_channel(self, channel_id: str, **changes: Any) -> JSON:
+        """Changes ``name``, ``topic``, ``position``, ``parent_id`` or ``rate_limit_per_user``."""
+        return await self.patch(f"/channels/{channel_id}", changes)
+
+    async def delete_channel(self, channel_id: str) -> JSON:
+        return await self.delete(f"/channels/{channel_id}")
+
+    async def create_invite(self, guild_id: str, *, max_age_secs: int | None = None, max_uses: int | None = None) -> JSON:
+        body = _drop_none({"max_age_secs": max_age_secs, "max_uses": max_uses})
+        return await self.post(f"/guilds/{guild_id}/invites", body)
+
+    # ---------- commands ----------
+
+    async def set_commands(self, commands: list[Command]) -> list[JSON]:
+        """Replaces all of the bot's "/" commands."""
+        return await self.put("/users/@me/commands", commands)  # type: ignore[no-any-return]
+
+    async def commands(self) -> list[JSON]:
+        return await self.get("/users/@me/commands")  # type: ignore[no-any-return]
+
+    async def interaction_callback(self, id: str, token: str, body: dict[str, Any]) -> JSON:
+        """Answers an interaction (see :class:`zynko.Interaction`)."""
+        return await self.post(f"/interactions/{id}/{token}/callback", body)
+
+    # ---------- voice ----------
+
+    async def voice_token(self, channel_id: str) -> JSON:
+        """A media token for a voice room (the voice connection uses it; see ``Client.join_voice``)."""
+        return await self.post(f"/channels/{channel_id}/voice")

zynko/voice.py

@@ -0,0 +1,298 @@
+"""A bot in a voice room.
+
+The Zynko server hands out a media token (``POST /channels/{id}/voice``) and the guild learns
+where the bot is from gateway op 4; the audio itself travels through LiveKit, the same media
+server the apps use, through the ``livekit`` package (``pip install "zynko[voice]"``)::
+
+    voice = await client.join_voice(channel_id)
+    voice.player.enqueue("https://exemplo.com/musica.mp3")
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from array import array
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, Literal, TypeVar, overload
+
+from ._events import Emitter
+from .models import Channel, VoiceState
+from .player import CHANNELS, FRAME_SAMPLES, SAMPLE_RATE, AudioPlayer
+
+if TYPE_CHECKING:
+    from livekit import rtc
+
+    from .client import Client
+
+__all__ = ["VoiceConnection", "load_rtc"]
+
+log = logging.getLogger("zynko.voice")
+
+F = TypeVar("F", bound=Callable[..., Any])
+
+_rtc: Any = None
+
+
+def load_rtc() -> Any:
+    """The ``livekit.rtc`` module, or a clear error when it is not installed."""
+    global _rtc
+    if _rtc is None:
+        try:
+            from livekit import rtc
+        except ImportError:
+            raise ImportError('A voz precisa do pacote livekit: pip install "zynko[voice]"') from None
+        _rtc = rtc
+    return _rtc
+
+
+Status = Literal["connecting", "connected", "reconnecting", "closed"]
+
+
+class VoiceConnection:
+    """The bot in one voice room.
+
+    Events: ``ready()`` (connected, again after a server move), ``speaking(user_ids)``,
+    ``audio(user_id, samples, channels)`` with ``receive=True``, ``disconnect(reason)`` (out
+    of the room for good) and ``error(error)``.
+    """
+
+    def __init__(
+        self,
+        client: Client,
+        channel_id: str,
+        *,
+        receive: bool = False,
+        relay: bool = False,
+        deaf: bool = False,
+        ffmpeg: str | None = None,
+        ytdlp: bool | str = False,
+    ) -> None:
+        self.client = client
+        self.channel_id = channel_id
+        self.receive = receive
+        self.relay = relay
+        self.deaf = deaf
+        self.status: Status = "connecting"
+        #: The voice server the room is on (Brasil 1, Brasil 2...).
+        self.server: str | None = None
+        #: Can speak here: a room's roles may let the bot only listen.
+        self.can_speak = True
+        self.player: AudioPlayer[Any] = AudioPlayer(self, ffmpeg=ffmpeg, ytdlp=ytdlp)
+        self._room: rtc.Room | None = None
+        self._source: rtc.AudioSource | None = None
+        self._events = Emitter("zynko.voice")
+        self._leaving = False
+        self._in_room = False
+        self._moving: asyncio.Task[None] | None = None
+        self._tasks: set[asyncio.Task[Any]] = set()
+
+    def __repr__(self) -> str:
+        return f"<VoiceConnection channel_id={self.channel_id} status={self.status} server={self.server!r}>"
+
+    # ---------- events ----------
+
+    @overload
+    def on(self, event: str) -> Callable[[F], F]: ...
+    @overload
+    def on(self, event: str, handler: F) -> F: ...
+    def on(self, event: str, handler: F | None = None) -> Any:
+        return self._events.on(event, handler) if handler is not None else self._events.on(event)
+
+    def off(self, event: str, handler: Callable[..., Any]) -> None:
+        self._events.off(event, handler)
+
+    async def wait_for(self, event: str, check: Callable[..., bool] | None = None, timeout: float | None = 30.0) -> Any:
+        return await self._events.wait_for(event, check, timeout)
+
+    @property
+    def channel(self) -> Channel | None:
+        """The room's channel."""
+        return self.client.channels.get(self.channel_id)
+
+    # ---------- connecting ----------
+
+    async def connect(self) -> None:
+        """Connects to the room's media and tells the guild the bot is there."""
+        lk = load_rtc()
+        join = await self.client.rest.voice_token(self.channel_id)
+        self.server = join.get("server")
+        self.can_speak = join.get("can_speak") is not False
+        room = lk.Room()
+        self._room = room
+
+        def _disconnected(reason: Any) -> None:
+            if self._room is not room or self._leaving:
+                return
+            # The room closed under us: a server move is followed through CHANNEL_UPDATE;
+            # anything else (removed, room deleted) ends the connection.
+            if self._moving is not None:
+                return
+            try:
+                name = lk.DisconnectReason.Name(reason)
+            except (ValueError, TypeError):
+                name = str(reason)
+            self._spawn(self._end(f"desconectado ({name})"))
+
+        def _speakers(speakers: list[Any]) -> None:
+            self._events.emit("speaking", [p.identity for p in speakers])
+
+        def _subscribed(track: Any, _pub: Any, participant: Any) -> None:
+            if track.kind != lk.TrackKind.KIND_AUDIO or not self.receive:
+                return
+            self._spawn(self._hear(lk, track, participant.identity))
+
+        room.on("disconnected", _disconnected)
+        room.on("active_speakers_changed", _speakers)
+        room.on("track_subscribed", _subscribed)
+
+        rtc_config = None
+        if self.relay:
+            rtc_config = lk.RtcConfiguration(
+                ice_transport_type=lk.IceTransportType.TRANSPORT_RELAY,
+                continual_gathering_policy=lk.ContinualGatheringPolicy.GATHER_CONTINUALLY,
+                ice_servers=[],
+            )
+        options = lk.RoomOptions(auto_subscribe=self.receive, dynacast=False, rtc_config=rtc_config)
+        await room.connect(join["url"], join["token"], options)
+        if self._room is not room:
+            await room.disconnect()
+            return
+        if self.can_speak:
+            source = lk.AudioSource(SAMPLE_RATE, CHANNELS, queue_size_ms=200)
+            track = lk.LocalAudioTrack.create_audio_track("zynko", source)
+            opts = lk.TrackPublishOptions(source=lk.TrackSource.SOURCE_MICROPHONE, dtx=False, red=False)
+            opts.audio_encoding.max_bitrate = 128_000
+            await room.local_participant.publish_track(track, opts)
+            self._source = source
+        await self._announce()
+        self.status = "connected"
+        self._events.emit("ready")
+
+    async def leave(self) -> None:
+        """Leaves the room."""
+        if self.status == "closed":
+            return
+        self._leaving = True
+        self.player.stop()
+        await self.client.send_op(4, {"channel_id": None, "self_mute": False, "self_deaf": False})
+        await self._end("saiu")
+
+    # ---------- FrameSink, for the player ----------
+
+    async def capture(self, frame: bytes) -> None:
+        lk = _rtc
+        if lk is None:
+            return
+        # Moving to another server: wait for the new connection, then go on where it was.
+        moving = self._moving
+        if moving is not None:
+            try:
+                await asyncio.shield(moving)
+            except Exception:  # noqa: BLE001
+                pass
+        source = self._source
+        if source is None or self.status == "closed":
+            return
+        await source.capture_frame(lk.AudioFrame(frame, SAMPLE_RATE, CHANNELS, FRAME_SAMPLES))
+
+    def flush(self) -> None:
+        if self._source is not None:
+            self._source.clear_queue()
+
+    # ---------- from the client ----------
+
+    def _on_channel_update(self, c: Channel) -> None:
+        """The room moved to another voice server (someone picked Brasil 1 or 2): follow it."""
+        if c.id != self.channel_id or self.status != "connected" or not c.voice_server or c.voice_server == self.server:
+            return
+
+        async def move() -> None:
+            self.status = "reconnecting"
+            old, old_source = self._room, self._source
+            self._room = None
+            self._source = None
+            try:
+                if old is not None:
+                    await old.disconnect()
+                if old_source is not None:
+                    await old_source.aclose()
+            except Exception:  # noqa: BLE001
+                log.debug("closing the old room failed", exc_info=True)
+            try:
+                await self.connect()
+            except Exception as e:  # noqa: BLE001
+                await self._end("não conseguiu entrar no servidor novo")
+                self._events.emit("error", e)
+            finally:
+                self._moving = None
+
+        self._moving = asyncio.ensure_future(move())
+
+    def _on_own_state(self, v: VoiceState) -> None:
+        """The server says where the bot is in voice: elsewhere, or nowhere, ends this connection."""
+        if self.status == "closed" or self._leaving:
+            return
+        if v.channel_id == self.channel_id:
+            self._in_room = True
+            return
+        # Moving from another room, its "left" state can arrive after this one began: only a
+        # state that comes once the server has the bot here means it was moved or removed.
+        if not self._in_room:
+            return
+        self._spawn(self._end("entrou em outra sala" if v.channel_id else "removido da sala"))
+
+    def _resync(self) -> None:
+        """After the gateway reconnects: say again where the bot is."""
+        if self.status in ("connected", "reconnecting"):
+            self._spawn(self._announce())
+
+    async def _announce(self) -> None:
+        await self.client.send_op(
+            4, {"channel_id": self.channel_id, "self_mute": not self.can_speak, "self_deaf": self.deaf}
+        )
+
+    def _spawn(self, coro: Any) -> None:
+        task = asyncio.ensure_future(coro)
+        self._tasks.add(task)
+        task.add_done_callback(self._tasks.discard)
+
+    async def _hear(self, lk: Any, track: Any, user_id: str) -> None:
+        stream = lk.AudioStream(track, sample_rate=SAMPLE_RATE, num_channels=1)
+        try:
+            async for event in stream:
+                if self.status == "closed":
+                    break
+                frame = event.frame
+                samples = array("h")
+                samples.frombytes(bytes(frame.data.cast("B")))
+                self._events.emit("audio", user_id, samples, frame.num_channels)
+        except Exception:  # noqa: BLE001 - the track went away
+            pass
+        finally:
+            try:
+                await stream.aclose()
+            except Exception:  # noqa: BLE001
+                pass
+
+    async def _end(self, reason: str) -> None:
+        if self.status == "closed":
+            return
+        self.status = "closed"
+        self.player.stop()
+        room, source = self._room, self._source
+        self._room = None
+        self._source = None
+        try:
+            if room is not None:
+                await room.disconnect()
+        except Exception:  # noqa: BLE001
+            pass
+        try:
+            if source is not None:
+                await source.aclose()
+        except Exception:  # noqa: BLE001
+            pass
+        if self.client.voice is self:
+            self.client.voice = None
+        self._events.emit("disconnect", reason)

zynko-0.1.0.dist-info/METADATA

@@ -0,0 +1,67 @@
+Metadata-Version: 2.4
+Name: zynko
+Version: 0.1.0
+Summary: Biblioteca oficial para bots do Zynko: API, gateway e voz.
+Project-URL: Documentation, https://docs.zynko.org/bots/python
+Project-URL: Homepage, https://zynko.org
+License-Expression: MIT
+Keywords: asyncio,bot,chat,voice,zynko
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: aiohttp<4,>=3.11
+Provides-Extra: dev
+Requires-Dist: mypy>=1.13; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.24; extra == 'dev'
+Requires-Dist: pytest>=8.3; extra == 'dev'
+Provides-Extra: voice
+Requires-Dist: livekit==1.2.1; extra == 'voice'
+Description-Content-Type: text/markdown
+
+# zynko
+
+A biblioteca oficial para bots do [Zynko](https://zynko.org) em Python: gateway com
+reconexão, cache de servidores, canais e membros, a API inteira, comandos com "/", cartões e
+botões, e voz (tocar e ouvir áudio nas salas). Feita com asyncio.
+
+```sh
+pip install zynko
+pip install "zynko[voice]"   # com voz
+```
+
+```python
+import os
+import zynko
+
+client = zynko.Client(intents=zynko.Intents.GUILDS | zynko.Intents.MESSAGES)
+
+@client.on("message_create")
+async def ping(msg: zynko.Message):
+    if not msg.mine and msg.content == "!ping":
+        await msg.reply("pong")
+
+client.run(os.environ["ZYNKO_TOKEN"])
+```
+
+Voz:
+
+```python
+voice = await client.join_voice(channel_id)
+voice.player.enqueue("https://exemplo.com/musica.mp3")
+```
+
+Python 3.10 ou mais novo. Para tocar arquivos e links, o ffmpeg precisa estar instalado.
+Exemplos em [`examples/`](examples): `ping.py`, `dado.py` (comandos, cartão e botões) e
+`musica.py`.
+
+Documentação: https://docs.zynko.org/bots/python · Crie seu bot: https://dev.zynko.org
+
+Licença MIT.

zynko-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+zynko/__init__.py,sha256=u1eqWLAiodi9-Z4fDM14HmCnR_tzo5hwOi6vahtxw4g,1474
+zynko/_events.py,sha256=jt3iF3UjmXcYsaZIK03XCzlq4ITtwJj2rlIu48nRQAI,4394
+zynko/bits.py,sha256=f40UjC1Mr822XEbYFprDkXzetQavxtcTj5hjrqbpNuA,1697
+zynko/client.py,sha256=yTYMS_4PuBHCRO5-O8tjekL4Vk_W1EGgW4030Xb4i9w,18812
+zynko/gateway.py,sha256=gHR6Cb183QE8LJa_PlKpLoPgwV51J4wyPHebnuy5Dz0,6023
+zynko/interaction.py,sha256=EWTAtURFAZGWDVJimuPnsXqkJTMDeem14w1xgJtSvts,4226
+zynko/message.py,sha256=PaP1ljTfXWj1doe-lK7Q6idTCPGeGCWrG_n11PmbeX0,4664
+zynko/models.py,sha256=irLu527L9Sl645Fw2TB5Cx3Y3TYVwJigqRlV99pDtwE,9957
+zynko/permissions.py,sha256=ZnKFbL8T_e3N38DdR5MCRbqoDOJT-g57bnCzNxuaWZg,1861
+zynko/player.py,sha256=SeJac7maXeoqVELtNln1xbYsh8ospSETTM3crBgeolw,14133
+zynko/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+zynko/rest.py,sha256=q1f4myUCGABRLF6uBHI6743YhWuqO5tf8uZ1kXbHbyw,12246
+zynko/voice.py,sha256=oMUqxUwhJQpnDKCEPJfnh2Kap5IPaxtbbbDhG2lsf5s,11090
+zynko-0.1.0.dist-info/METADATA,sha256=ehNAxuYlxkHsqiKpusf_bIlnZWd5lslO2Z56tHIY0pU,2103
+zynko-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+zynko-0.1.0.dist-info/RECORD,,