yapper-bot 0.1.0__py3-none-any.whl

yapperpy/_http/aio.py

@@ -0,0 +1,175 @@
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import ssl
+from urllib.parse import urlsplit
+
+from .base import Headers, RawRequest, RawResponse, TransportError, TransportTimeout
+
+
+class _AsyncConnection:
+    def __init__(self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter) -> None:
+        self.reader = reader
+        self.writer = writer
+
+    def close(self) -> None:
+        with contextlib.suppress(Exception):
+            self.writer.close()
+
+
+class HTTPAsyncTransport:
+    def __init__(
+        self,
+        *,
+        timeout: float = 40.0,
+        ssl_context: ssl.SSLContext | None = None,
+        max_idle: int = 4,
+    ) -> None:
+        self.timeout = timeout
+        self.ssl_context = ssl_context or ssl.create_default_context()
+        self.max_idle = max(1, max_idle)
+        self._pool: dict[tuple[str, int], list[_AsyncConnection]] = {}
+        self._lock = asyncio.Lock()
+
+    async def _checkout(self, host: str, port: int, secure: bool) -> _AsyncConnection:
+        async with self._lock:
+            idle = self._pool.get((host, port))
+            if idle:
+                return idle.pop()
+        if secure:
+            reader, writer = await asyncio.open_connection(
+                host, port, ssl=self.ssl_context, server_hostname=host
+            )
+        else:
+            reader, writer = await asyncio.open_connection(host, port)
+        return _AsyncConnection(reader, writer)
+
+    async def _checkin(self, host: str, port: int, connection: _AsyncConnection) -> None:
+        async with self._lock:
+            idle = self._pool.setdefault((host, port), [])
+            if len(idle) < self.max_idle:
+                idle.append(connection)
+                return
+        connection.close()
+
+    async def send(self, request: RawRequest) -> RawResponse:
+        try:
+            return await asyncio.wait_for(self._exchange(request), request.timeout or self.timeout)
+        except asyncio.TimeoutError as exc:
+            raise TransportTimeout("request timed out") from exc
+        except TransportError:
+            raise
+        except OSError as exc:
+            raise TransportError(str(exc) or type(exc).__name__) from exc
+
+    async def _exchange(self, request: RawRequest) -> RawResponse:
+        parts = urlsplit(request.url)
+        host = parts.hostname or ""
+        secure = parts.scheme != "http"
+        port = parts.port or (443 if secure else 80)
+        path = parts.path or "/"
+        if parts.query:
+            path = f"{path}?{parts.query}"
+        headers = dict(request.headers)
+        headers.setdefault("Accept", "application/json")
+        headers.setdefault("Connection", "keep-alive")
+        if request.body is not None:
+            headers.setdefault("Content-Length", str(len(request.body)))
+        connection = await self._checkout(host, port, secure)
+        try:
+            head = f"{request.method} {path} HTTP/1.1\r\n".encode("latin-1")
+            head += b"".join(
+                f"{name}: {value}\r\n".encode("latin-1") for name, value in headers.items()
+            )
+            head += b"\r\n"
+            connection.writer.write(head)
+            if request.body:
+                connection.writer.write(request.body)
+            await connection.writer.drain()
+            status, reason, response_headers, body = await self._read_response(
+                connection.reader, request.method
+            )
+        except (TransportError, OSError, asyncio.IncompleteReadError):
+            connection.close()
+            raise
+        if response_headers.get("connection", "").lower() == "close":
+            connection.close()
+        else:
+            await self._checkin(host, port, connection)
+        return RawResponse(status=status, reason=reason, headers=response_headers, body=body)
+
+    async def _read_response(
+        self, reader: asyncio.StreamReader, method: str = "GET"
+    ) -> tuple[int, str, Headers, bytes]:
+        status_line = await reader.readline()
+        if not status_line:
+            raise TransportError("the connection closed before a response arrived")
+        parts = status_line.decode("latin-1").rstrip("\r\n").split(" ", 2)
+        if len(parts) < 2:
+            raise TransportError("the server sent a malformed status line")
+        try:
+            status = int(parts[1])
+        except ValueError as exc:
+            raise TransportError("the server sent a malformed status line") from exc
+        reason = parts[2] if len(parts) > 2 else ""
+        headers: Headers = Headers()
+        while True:
+            line = await reader.readline()
+            if not line:
+                raise TransportError("the connection closed while reading headers")
+            if line in (b"\r\n", b"\n"):
+                break
+            name, _, value = line.decode("latin-1").partition(":")
+            headers[name.strip()] = value.strip()
+        body = await self._read_body(reader, headers, status, method)
+        return status, reason, headers, body
+
+    async def _read_body(
+        self,
+        reader: asyncio.StreamReader,
+        headers: Headers,
+        status: int = 200,
+        method: str = "GET",
+    ) -> bytes:
+        if status in (204, 304) or method.upper() == "HEAD":
+            return b""
+        if headers.get("transfer-encoding", "").lower() == "chunked":
+            return await self._read_chunked(reader)
+        raw_length = headers.get("content-length")
+        if raw_length is None:
+            return await reader.read()
+        try:
+            length = int(raw_length)
+        except ValueError as exc:
+            raise TransportError("the server sent a malformed content length") from exc
+        if length <= 0:
+            return b""
+        return await reader.readexactly(length)
+
+    async def _read_chunked(self, reader: asyncio.StreamReader) -> bytes:
+        chunks: list[bytes] = []
+        while True:
+            size_line = await reader.readline()
+            if not size_line:
+                raise TransportError("the connection closed while reading the body")
+            try:
+                size = int(size_line.split(b";")[0].strip(), 16)
+            except ValueError as exc:
+                raise TransportError("the server sent a malformed chunk size") from exc
+            if size == 0:
+                while True:
+                    trailer = await reader.readline()
+                    if trailer in (b"\r\n", b"\n", b""):
+                        break
+                break
+            chunks.append(await reader.readexactly(size))
+            await reader.readexactly(2)
+        return b"".join(chunks)
+
+    async def close(self) -> None:
+        async with self._lock:
+            for idle in self._pool.values():
+                for connection in idle:
+                    connection.close()
+            self._pool.clear()

yapperpy/_http/base.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+import json
+from collections.abc import Iterable, Mapping
+from dataclasses import dataclass, field
+from typing import Any, Protocol
+from urllib.parse import parse_qsl, quote, urlencode, urlsplit
+
+from .._version import __version__
+
+DEFAULT_BASE_URL = "https://www.yapper.website/api/bot/v1"
+DEFAULT_TIMEOUT = 40.0
+USER_AGENT = f"yapperpy/{__version__} (+https://www.yapper.website/developers)"
+
+
+def segment(value: object) -> str:
+    return quote(str(value), safe="")
+
+
+def build_url(base: str, path: str, query: Mapping[str, Any] | None = None) -> str:
+    url = base.rstrip("/") + path
+    if query:
+        pairs = [(k, str(v)) for k, v in query.items() if v is not None]
+        if pairs:
+            url += "?" + urlencode(pairs)
+    return url
+
+
+class TransportError(Exception):
+    pass
+
+
+class TransportTimeout(TransportError):
+    pass
+
+
+class Headers(dict[str, str]):
+    def __init__(self, data: Mapping[str, str] | Iterable[tuple[str, str]] | None = None) -> None:
+        super().__init__()
+        if data is None:
+            return
+        pairs = data.items() if isinstance(data, Mapping) else data
+        for name, value in pairs:
+            self[name] = value
+
+    def __setitem__(self, name: str, value: str) -> None:
+        super().__setitem__(name.lower(), value)
+
+    def __getitem__(self, name: str) -> str:
+        return super().__getitem__(name.lower())
+
+    def __contains__(self, name: object) -> bool:
+        if isinstance(name, str):
+            return super().__contains__(name.lower())
+        return super().__contains__(name)
+
+
+@dataclass(slots=True)
+class RawRequest:
+    method: str
+    url: str
+    headers: dict[str, str] = field(default_factory=dict)
+    body: bytes | None = None
+    timeout: float = DEFAULT_TIMEOUT
+
+    @property
+    def path(self) -> str:
+        return urlsplit(self.url).path
+
+    @property
+    def query(self) -> dict[str, str]:
+        return dict(parse_qsl(urlsplit(self.url).query))
+
+
+@dataclass(slots=True)
+class RawResponse:
+    status: int
+    reason: str = ""
+    headers: Headers = field(default_factory=Headers)
+    body: bytes = b""
+
+    def json(self) -> Any:
+        if not self.body:
+            return None
+        return json.loads(self.body.decode("utf-8"))
+
+
+class SyncTransport(Protocol):
+    def send(self, request: RawRequest) -> RawResponse: ...
+
+    def close(self) -> None: ...
+
+
+class AsyncTransport(Protocol):
+    async def send(self, request: RawRequest) -> RawResponse: ...
+
+    async def close(self) -> None: ...

yapperpy/_http/sync.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+import http.client
+import ssl
+import threading
+from urllib.parse import urlsplit
+
+from .base import Headers, RawRequest, RawResponse, TransportError, TransportTimeout
+
+
+class HTTPSyncTransport:
+    def __init__(
+        self,
+        *,
+        timeout: float = 40.0,
+        ssl_context: ssl.SSLContext | None = None,
+        max_idle: int = 4,
+    ) -> None:
+        self.timeout = timeout
+        self.ssl_context = ssl_context or ssl.create_default_context()
+        self.max_idle = max(1, max_idle)
+        self._pool: dict[tuple[str, int], list[http.client.HTTPConnection]] = {}
+        self._lock = threading.Lock()
+
+    def _checkout(self, host: str, port: int, secure: bool) -> http.client.HTTPConnection:
+        with self._lock:
+            idle = self._pool.get((host, port))
+            if idle:
+                return idle.pop()
+        if secure:
+            return http.client.HTTPSConnection(
+                host, port, timeout=self.timeout, context=self.ssl_context
+            )
+        return http.client.HTTPConnection(host, port, timeout=self.timeout)
+
+    def _checkin(self, host: str, port: int, connection: http.client.HTTPConnection) -> None:
+        with self._lock:
+            idle = self._pool.setdefault((host, port), [])
+            if len(idle) < self.max_idle:
+                idle.append(connection)
+                return
+        connection.close()
+
+    def send(self, request: RawRequest) -> RawResponse:
+        parts = urlsplit(request.url)
+        host = parts.hostname or ""
+        secure = parts.scheme != "http"
+        port = parts.port or (443 if secure else 80)
+        path = parts.path or "/"
+        if parts.query:
+            path = f"{path}?{parts.query}"
+        headers = dict(request.headers)
+        headers.setdefault("Accept", "application/json")
+        headers.setdefault("Connection", "keep-alive")
+        connection = self._checkout(host, port, secure)
+        try:
+            connection.request(request.method, path, body=request.body, headers=headers)
+            response = connection.getresponse()
+            body = response.read()
+        except TimeoutError as exc:
+            connection.close()
+            raise TransportTimeout(str(exc) or "request timed out") from exc
+        except (http.client.HTTPException, OSError) as exc:
+            connection.close()
+            raise TransportError(str(exc) or type(exc).__name__) from exc
+        result = RawResponse(
+            status=response.status,
+            reason=response.reason,
+            headers=Headers(response.getheaders()),
+            body=body,
+        )
+        if response.will_close:
+            connection.close()
+        else:
+            self._checkin(host, port, connection)
+        return result
+
+    def close(self) -> None:
+        with self._lock:
+            for idle in self._pool.values():
+                for connection in idle:
+                    connection.close()
+            self._pool.clear()

yapperpy/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

yapperpy/aio_bot.py

@@ -0,0 +1,170 @@
+from __future__ import annotations
+
+import asyncio
+import inspect
+import traceback
+from collections.abc import Callable
+from typing import Any
+
+from .aio_client import AsyncYapper
+from .context import MessageContext
+from .event_models import InteractionPayload, MessagePayload
+from .framework import BotBase
+from .models import Command, Event
+from .registry import Command as CommandSpec
+
+WAIT_SECONDS = 25
+MAX_BACKOFF = 30.0
+
+
+class AsyncBot(BotBase):
+    def __init__(
+        self,
+        token: str | None = None,
+        *,
+        client: AsyncYapper | None = None,
+        prefixes: tuple[str, ...] = ("/", "!"),
+        ignore_bots: bool = True,
+        log: bool = True,
+        command_limit: int = 100,
+        **client_kwargs: Any,
+    ) -> None:
+        resolved = client if client is not None else AsyncYapper(token, **client_kwargs)
+        super().__init__(
+            resolved,
+            prefixes=prefixes,
+            ignore_bots=ignore_bots,
+            log=log,
+            command_limit=command_limit,
+        )
+
+    def _log(self, message: str) -> None:
+        if self.log:
+            print(f"[yapperpy] {message}")
+
+    async def sync_commands(self) -> list[Command]:
+        payload = self.command_payload()
+        await self.client.bot.set_commands(payload)
+        self.registry.dirty = False
+        return [Command(name=item["name"], description=item["description"]) for item in payload]
+
+    async def invoke(self, handler: Callable[..., Any], *args: Any) -> Any:
+        result = handler(*args)
+        if inspect.isawaitable(result):
+            return await result
+        return result
+
+    async def emit(self, event: str, payload: Any) -> None:
+        for handler in self.listeners(event):
+            try:
+                await self.invoke(handler, payload)
+            except Exception as exc:
+                await self.handle_error(exc, None, event)
+
+    async def handle_error(
+        self, exc: Exception, owner: str | None = None, where: str | None = None
+    ) -> None:
+        if owner is not None and getattr(exc, "cog", None) is None:
+            setattr(exc, "cog", owner)
+            setattr(exc, "where", where)
+        handlers = self.listeners("error")
+        if handlers:
+            for handler in handlers:
+                try:
+                    await self.invoke(handler, exc)
+                except Exception as inner:
+                    self._log(f"error listener failed: {inner}")
+            return
+        if self.log:
+            tag = f"[{owner}]" if owner else "[yapperpy]"
+            if where:
+                tag = f"{tag} {where}"
+            print(f"{tag} {type(exc).__name__}: {exc}")
+            traceback.print_exception(type(exc), exc, exc.__traceback__, limit=-3)
+
+    async def handle(self, event: Event) -> None:
+        kind, payload = self.prepare(event)
+        if kind == "message" and isinstance(payload, MessagePayload):
+            await self.handle_message(payload)
+        elif kind == "interaction" and isinstance(payload, InteractionPayload):
+            await self.handle_interaction(payload)
+        else:
+            await self.emit(kind, self.build_context(payload))
+
+    async def handle_message(self, payload: MessagePayload) -> None:
+        if self.ignore_bots and payload.author_bot:
+            return
+        context = self.build_context(payload)
+        match = self.resolve_command(payload)
+        if match is not None:
+            command, args = match
+            context.command = command.name
+            context.args = args
+            if await self.run_check(command, context):
+                try:
+                    await self.invoke(command.handler, context)
+                except Exception as exc:
+                    await self.handle_error(exc, command.owner, f"/{command.name}")
+            await self.emit("command", context)
+        await self.emit("message", context)
+
+    async def run_check(self, command: CommandSpec, context: MessageContext) -> bool:
+        if command.check is None:
+            return True
+        try:
+            result = command.check(context)
+            if inspect.isawaitable(result):
+                result = await result
+            return result is not False
+        except Exception as exc:
+            await self.handle_error(exc, command.owner, "check")
+            return False
+
+    async def handle_interaction(self, payload: InteractionPayload) -> None:
+        context = self.build_context(payload)
+        for entry in self.interaction_handlers(payload.custom_id):
+            try:
+                await self.invoke(entry.handler, context)
+            except Exception as exc:
+                await self.handle_error(exc, entry.owner, f"button {entry.matcher}")
+        await self.emit("interaction", context)
+
+    async def run(self) -> None:
+        try:
+            await self._run()
+        except KeyboardInterrupt:
+            self._log("stopped")
+        finally:
+            self.running = False
+
+    start = run
+
+    async def _run(self) -> None:
+        self.running = True
+        self.me = await self.client.bot.get()
+        await self.sync_commands()
+        await self.emit("ready", self.me)
+        if self.me is not None:
+            self._log(f"online as {self.me.username}")
+        failures = 0
+        while self.running:
+            try:
+                page = await self.client.events.fetch(after=self.last_event_id, wait=WAIT_SECONDS)
+            except Exception as exc:
+                failures += 1
+                await self.handle_error(exc, None, "events")
+                await asyncio.sleep(min(MAX_BACKOFF, 2.0**failures))
+                continue
+            failures = 0
+            for event in page.events:
+                if event.id <= self.last_event_id:
+                    continue
+                self.last_event_id = event.id
+                await self.handle(event)
+                if self.registry.dirty:
+                    await self.sync_commands()
+            if page.last > self.last_event_id:
+                self.last_event_id = page.last
+
+    def stop(self) -> None:
+        self.running = False