pyyapper 1.2.0a1__tar.gz → 1.3.2__tar.gz

{pyyapper-1.2.0a1/src/pyyapper.egg-info → pyyapper-1.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyyapper
-Version: 1.2.0a1
+Version: 1.3.2
 Summary: An intuitive, async Python library for the Yapper bot API.
 Author: PyYapper contributors
 License-Expression: MIT
@@ -31,6 +31,8 @@ Requires-Dist: twine; extra == "dev"
 Provides-Extra: docs
 Requires-Dist: mkdocs; extra == "docs"
 Requires-Dist: mkdocs-material; extra == "docs"
+Provides-Extra: speed
+Requires-Dist: orjson; extra == "speed"
 Dynamic: license-file
 
 # PyYapper

{pyyapper-1.2.0a1 → pyyapper-1.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pyyapper"
-version = "1.2.0a1"
+version = "1.3.2"
 description = "An intuitive, async Python library for the Yapper bot API."
 readme = "README.md"
 license = "MIT"
@@ -33,6 +33,7 @@ dependencies = [
 [project.optional-dependencies]
 dev = ["pytest", "pytest-asyncio", "build", "twine"]
 docs = ["mkdocs", "mkdocs-material"]
+speed = ["orjson"]
 
 [project.urls]
 Homepage = "https://github.com/pyyapper/pyyapper"

{pyyapper-1.2.0a1 → pyyapper-1.3.2}/src/pyyapper/__init__.py

@@ -14,10 +14,12 @@ from .errors import (
     NotFound,
     RateLimited,
     ServerError,
+    ServiceUnavailable,
 )
 from .models import (
-    User, Server, Channel, Category, Member, Message, Role,
+    User, Server, Channel, Category, Member, Message, Role, VoiceChannel, picture_url,
 )
+from .presence import Activity, Presence
 from .pagination import Paginator
 from .webhooks import Webhook
 from .wait_for import WaiterRegistry, wait_for
@@ -29,8 +31,9 @@ __all__ = [
     "Bot", "Context", "InteractionContext",
     "Embed", "Button", "Row",
     "YapperError", "ConfigurationError", "HTTPException",
-    "BadRequest", "Unauthorized", "Forbidden", "NotFound", "RateLimited", "ServerError",
-    "User", "Server", "Channel", "Category", "Member", "Message", "Role",
+    "BadRequest", "Unauthorized", "Forbidden", "NotFound", "RateLimited", "ServerError", "ServiceUnavailable",
+    "User", "Server", "Channel", "Category", "Member", "Message", "Role", "VoiceChannel", "picture_url",
+    "Activity", "Presence",
     "Paginator", "Webhook", "WaiterRegistry", "wait_for",
     "commands", "tasks",
     "Cog", "Command", "Group",

pyyapper-1.3.2/src/pyyapper/_version.py

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

{pyyapper-1.2.0a1 → pyyapper-1.3.2}/src/pyyapper/bot.py

@@ -17,15 +17,18 @@ from .models import (
     Role,
     Server,
     User,
+    VoiceChannel,
 )
+from .cache import TTLCache, MISSING as _CACHE_MISSING
+from .presence import Activity, Presence
 from .embeds import Embed
 from .buttons import Button, Row
 
 # Event names that are valid.
 EVENTS = {
     "message", "command", "command_error", "member_join", "member_leave",
-    "reaction_add", "reaction_remove", "interaction", "test",
-    "ready", "error",
+    "reaction_add", "reaction_remove", "voice_join", "voice_leave",
+    "interaction", "test", "ready", "error",
 }
 
 # Helper to coerce embeds/buttons to dicts.
@@ -170,14 +173,25 @@ class Bot:
 
     def __init__(
         self,
-        token: str,
+        token: Optional[str] = None,
         *,
         base_url: str = "https://www.yapper.website/api/bot/v1",
         prefixes: Optional[list[str]] = None,
         log: bool = True,
+        ignore_bots: bool = True,
+        max_age: Optional[int] = None,
+        cache_ttl: float = 0.0,
     ) -> None:
+        if token is None:
+            import os
+            token = os.environ.get("YAPPER_BOT_TOKEN")
         self.token = str(token).strip() if token else ""
         self.base_url = base_url
+        self.ignore_bots = bool(ignore_bots)
+        self.max_age = max_age
+        self._presence = None
+        self._cache = TTLCache(default_ttl=cache_ttl)
+        self.cache_ttl = cache_ttl
         self.prefixes = prefixes if prefixes is not None else ["/", "!"]
         self.log = log
 
@@ -430,27 +444,71 @@ class Bot:
     # ------------------------------------------------------------------ #
     # Servers / channels / members
     # ------------------------------------------------------------------ #
-    async def servers(self) -> list[Server]:
+    async def servers(self, *, cache_ttl: Optional[float] = None, force: bool = False) -> list[Server]:
+        key = ("servers",)
+        _eff_ttl = self._cache.default_ttl if cache_ttl is None else cache_ttl
+        if not force and _eff_ttl and _eff_ttl > 0:
+            ttl = self._cache.default_ttl if cache_ttl is None else cache_ttl
+            cached = self._cache.get(key)
+            if cached is not _CACHE_MISSING:
+                return cached
         out = await self.api("GET", "/servers")
-        return [Server.from_dict(s) for s in (out.get("servers") or [])]
-
-    async def channels(self, server_id: Any = None, *, type: Optional[str] = None) -> list[Channel]:
+        res = [Server.from_dict(s) for s in (out.get("servers") or [])]
+        if cache_ttl != 0:
+            ttl = self._cache.default_ttl if cache_ttl is None else cache_ttl
+            self._cache.set(key, res, ttl)
+        return res
+
+    async def channels(self, server_id: Any = None, *, type: Optional[str] = None, cache_ttl: Optional[float] = None, force: bool = False) -> list[Channel]:
+        key = ("channels", server_id, type)
+        _eff_ttl = self._cache.default_ttl if cache_ttl is None else cache_ttl
+        if not force and _eff_ttl and _eff_ttl > 0:
+            ttl = self._cache.default_ttl if cache_ttl is None else cache_ttl
+            cached = self._cache.get(key)
+            if cached is not _CACHE_MISSING:
+                return cached
         q = f"?type={type}" if type else ""
         path = f"/servers/{server_id}/channels{q}" if server_id else f"/channels{q}"
         out = await self.api("GET", path)
-        return [Channel.from_dict(c) for c in (out.get("channels") or [])]
-
-    async def categories(self, server_id: Any) -> list[Category]:
+        res = [Channel.from_dict(c) for c in (out.get("channels") or [])]
+        if cache_ttl != 0:
+            ttl = self._cache.default_ttl if cache_ttl is None else cache_ttl
+            self._cache.set(key, res, ttl)
+        return res
+
+    async def categories(self, server_id: Any, *, cache_ttl: Optional[float] = None, force: bool = False) -> list[Category]:
+        key = ("categories", server_id)
+        _eff_ttl = self._cache.default_ttl if cache_ttl is None else cache_ttl
+        if not force and _eff_ttl and _eff_ttl > 0:
+            ttl = self._cache.default_ttl if cache_ttl is None else cache_ttl
+            cached = self._cache.get(key)
+            if cached is not _CACHE_MISSING:
+                return cached
         out = await self.api("GET", f"/servers/{server_id}/channels")
-        return [Category.from_dict(c) for c in (out.get("categories") or [])]
-
-    async def channel(self, channel_id: Any) -> Optional[Channel]:
+        res = [Category.from_dict(c) for c in (out.get("categories") or [])]
+        if cache_ttl != 0:
+            ttl = self._cache.default_ttl if cache_ttl is None else cache_ttl
+            self._cache.set(key, res, ttl)
+        return res
+
+    async def channel(self, channel_id: Any, *, cache_ttl: Optional[float] = None, force: bool = False) -> Optional[Channel]:
+        key = ("channel", channel_id)
+        _eff_ttl = self._cache.default_ttl if cache_ttl is None else cache_ttl
+        if not force and _eff_ttl and _eff_ttl > 0:
+            ttl = self._cache.default_ttl if cache_ttl is None else cache_ttl
+            cached = self._cache.get(key)
+            if cached is not _CACHE_MISSING:
+                return cached
         try:
             out = await self.api("GET", f"/channels/{channel_id}")
         except Exception:
             return None
         c = out.get("channel") if isinstance(out, dict) else None
-        return Channel.from_dict(c) if c else None
+        res = Channel.from_dict(c) if c else None
+        if cache_ttl != 0:
+            ttl = self._cache.default_ttl if cache_ttl is None else cache_ttl
+            self._cache.set(key, res, ttl)
+        return res
 
     async def members(self, server_id: Any, after: Any = None) -> list[Member]:
         path = f"/servers/{server_id}/members?limit=200"
@@ -463,10 +521,21 @@ class Bot:
         out = await self.api("GET", f"/channels/{channel_id}/messages?limit={limit}")
         return [Message.from_dict(m) for m in (out.get("messages") or [])]
 
-    async def user(self, user_id: Any) -> User:
+    async def user(self, user_id: Any, *, cache_ttl: Optional[float] = None, force: bool = False) -> User:
+        key = ("user", user_id)
+        _eff_ttl = self._cache.default_ttl if cache_ttl is None else cache_ttl
+        if not force and _eff_ttl and _eff_ttl > 0:
+            ttl = self._cache.default_ttl if cache_ttl is None else cache_ttl
+            cached = self._cache.get(key)
+            if cached is not _CACHE_MISSING:
+                return cached
         out = await self.api("GET", f"/users/{user_id}")
         u = out.get("user") if isinstance(out, dict) else out
-        return User.from_dict(u)
+        res = User.from_dict(u)
+        if cache_ttl != 0:
+            ttl = self._cache.default_ttl if cache_ttl is None else cache_ttl
+            self._cache.set(key, res, ttl)
+        return res
 
     # ------------------------------------------------------------------ #
     # Profile
@@ -485,9 +554,18 @@ class Bot:
     async def set_banner(self, image: Any, type: Optional[str] = None) -> Any:
         return await self.http.upload("PUT", "/me/banner", image, type)
 
-    async def set_status(self, status: str = "online", activity: Optional[str] = None) -> Any:
+    async def set_status(self, status: str = "online", activity: Any = None) -> Any:
+        if isinstance(activity, Activity):
+            activity = activity.to_text()
+        elif isinstance(activity, Presence):
+            status = activity.to_status()
+            activity = activity.to_activity()
         return await self.api("PUT", "/me/status", {"status": status, "activity": activity})
 
+    async def set_presence(self, *, status: str = "online", activity: Any = None) -> Any:
+        self._presence = Presence(status=status, activity=activity)
+        return await self.set_status(status=status, activity=activity)
+
     # ------------------------------------------------------------------ #
     # Messages advanced
     # ------------------------------------------------------------------ #
@@ -548,13 +626,35 @@ class Bot:
     # ------------------------------------------------------------------ #
     # Moderation
     # ------------------------------------------------------------------ #
-    async def server(self, server_id: Any) -> Any:
+    async def server(self, server_id: Any, *, cache_ttl: Optional[float] = None, force: bool = False) -> Any:
+        key = ("server", server_id)
+        _eff_ttl = self._cache.default_ttl if cache_ttl is None else cache_ttl
+        if not force and _eff_ttl and _eff_ttl > 0:
+            ttl = self._cache.default_ttl if cache_ttl is None else cache_ttl
+            cached = self._cache.get(key)
+            if cached is not _CACHE_MISSING:
+                return cached
         out = await self.api("GET", f"/servers/{server_id}")
-        return out.get("server") if isinstance(out, dict) else out
-
-    async def roles(self, server_id: Any) -> list[Role]:
+        res = out.get("server") if isinstance(out, dict) else out
+        if cache_ttl != 0:
+            ttl = self._cache.default_ttl if cache_ttl is None else cache_ttl
+            self._cache.set(key, res, ttl)
+        return res
+
+    async def roles(self, server_id: Any, *, cache_ttl: Optional[float] = None, force: bool = False) -> list[Role]:
+        key = ("roles", server_id)
+        _eff_ttl = self._cache.default_ttl if cache_ttl is None else cache_ttl
+        if not force and _eff_ttl and _eff_ttl > 0:
+            ttl = self._cache.default_ttl if cache_ttl is None else cache_ttl
+            cached = self._cache.get(key)
+            if cached is not _CACHE_MISSING:
+                return cached
         out = await self.api("GET", f"/servers/{server_id}/roles")
-        return [Role.from_dict(r) for r in (out.get("roles") or [])]
+        res = [Role.from_dict(r) for r in (out.get("roles") or [])]
+        if cache_ttl != 0:
+            ttl = self._cache.default_ttl if cache_ttl is None else cache_ttl
+            self._cache.set(key, res, ttl)
+        return res
 
     async def member(self, server_id: Any, user_id: Any) -> Member:
         out = await self.api("GET", f"/servers/{server_id}/members/{user_id}")
@@ -588,6 +688,24 @@ class Bot:
             "user_id": user_id, "minutes": minutes, "reason": reason,
         })
 
+    # ------------------------------------------------------------------ #
+    # Voice
+    # ------------------------------------------------------------------ #
+    async def voice(self, server_id: Any) -> list:
+        out = await self.api("GET", f"/servers/{server_id}/voice")
+        voice = out.get("voice", []) if isinstance(out, dict) else []
+        return [VoiceChannel.from_dict(v) for v in (voice or [])]
+
+    async def move_member(self, server_id: Any, user_id: Any, channel_id: Any) -> Any:
+        return await self.api("POST", f"/servers/{server_id}/voice/move", {
+            "user_id": user_id, "channel_id": channel_id,
+        })
+
+    async def disconnect_member(self, server_id: Any, user_id: Any) -> Any:
+        return await self.api("POST", f"/servers/{server_id}/voice/disconnect", {
+            "user_id": user_id,
+        })
+
     # ------------------------------------------------------------------ #
     # Channels management
     # ------------------------------------------------------------------ #
@@ -664,7 +782,10 @@ class Bot:
             try:
                 self.me = User.from_dict(await self.api("GET", "/me"))
                 await self.api("PUT", "/commands", {"commands": cmd_list})
-                first = await self.api("GET", "/events?after=0&wait=0")
+                q = "/events?after=0&wait=0"
+                if self.max_age is not None:
+                    q += f"&max_age={int(self.max_age)}"
+                first = await self.api("GET", q)
                 break
             except Exception as e:
                 status = getattr(e, "status", None)
@@ -684,6 +805,12 @@ class Bot:
             print(f"[pyyapper] {self.me.username} is online"
                   + (f" with {len(cmd_list)} command{'s' if len(cmd_list) != 1 else ''}" if cmd_list else ""))
         await self._emit("ready", self.me)
+        # re-apply saved presence
+        if getattr(self, "_presence", None) is not None:
+            try:
+                await self.set_presence(status=self._presence.status, activity=self._presence.activity)
+            except Exception:
+                pass
         # start registered tasks
         try:
             from .ext.tasks import register_task, cancel_all_tasks
@@ -700,7 +827,10 @@ class Bot:
         failures = 0
         while self.running:
             try:
-                out = await self.api("GET", f"/events?after={self.last}&wait=25", timeout=45.0)
+                q = f"/events?after={self.last}&wait=25"
+                if self.max_age is not None:
+                    q += f"&max_age={int(self.max_age)}"
+                out = await self.api("GET", q, timeout=45.0)
                 failures = 0
             except Exception as e:
                 failures += 1
@@ -748,6 +878,19 @@ class Bot:
     def stop(self) -> None:
         self.running = False
 
+    def invalidate_cache(self, key: Any = None) -> None:
+        """Drop cached read results. ``key=None`` clears everything."""
+        self._cache.invalidate(key)
+
+    async def send_many(self, channel_id: Any, contents: Any, *, concurrency: int = 5, **opts: Any) -> list:
+        sem = asyncio.Semaphore(max(1, int(concurrency)))
+
+        async def _one(c: Any) -> Any:
+            async with sem:
+                return await self.send(channel_id, c, **opts)
+
+        return list(await asyncio.gather(*(_one(c) for c in (contents or [])), return_exceptions=True))
+
     # ------------------------------------------------------------------ #
     # Internals
     # ------------------------------------------------------------------ #
@@ -768,6 +911,9 @@ class Bot:
                 except Exception:
                     pass
 
+        if len(fns) == 1:
+            await _run(fns[0])
+            return
         # Dispatch handlers concurrently to reduce latency when several
         # listeners are registered for the same event. Order is not guaranteed.
         await asyncio.gather(*(_run(fn) for fn in fns), return_exceptions=True)
@@ -782,6 +928,15 @@ class Bot:
         etype = ev.get("type")
         data = ev.get("data") or {}
         if etype == "message":
+            if self.ignore_bots and data.get("author_bot"):
+                # skip messages from other bots/webhooks
+                if self._waiters is not None:
+                    try:
+                        ctx = Context(self, data)
+                        self._waiters.dispatch("message", ctx)
+                    except Exception:
+                        pass
+                return
             ctx = Context(self, data)
             # resolve command
             name = data.get("command")

pyyapper-1.3.2/src/pyyapper/cache.py

@@ -0,0 +1,52 @@
+"""Tiny TTL cache used by PyYapper for read-heavy API calls."""
+
+from __future__ import annotations
+
+import time
+from typing import Any, Optional
+
+_MISSING = object()
+
+
+class TTLCache:
+    """A simple in-memory TTL cache.
+
+    Keys may be any hashable value. ``get`` returns the sentinel
+    :data:`MISSING` when a key is absent or expired.
+    """
+
+    def __init__(self, default_ttl: float = 15.0) -> None:
+        self._store: dict[Any, tuple[Any, float]] = {}
+        self.default_ttl = float(default_ttl)
+
+    def get(self, key: Any) -> Any:
+        entry = self._store.get(key)
+        if entry is None:
+            return _MISSING
+        value, expiry = entry
+        if time.monotonic() >= expiry:
+            self._store.pop(key, None)
+            return _MISSING
+        return value
+
+    def set(self, key: Any, value: Any, ttl: Optional[float] = None) -> None:
+        if ttl is None:
+            ttl = self.default_ttl
+        if ttl and ttl > 0:
+            self._store[key] = (value, time.monotonic() + float(ttl))
+
+    def invalidate(self, key: Any = None) -> None:
+        if key is None:
+            self._store.clear()
+        else:
+            self._store.pop(key, None)
+
+    def invalidate_prefix(self, prefix: Any) -> None:
+        for k in [k for k in list(self._store.keys()) if isinstance(k, tuple) and k and k[0] == prefix]:
+            self._store.pop(k, None)
+
+    def size(self) -> int:
+        return len(self._store)
+
+
+MISSING = _MISSING

{pyyapper-1.2.0a1 → pyyapper-1.3.2}/src/pyyapper/errors.py

@@ -72,6 +72,10 @@ class ServerError(HTTPException):
     """5xx - something went wrong on Yapper's side."""
 
 
+class ServiceUnavailable(ServerError):
+    """503 - Yapper is busy; retry after Retry-After."""
+
+
 # Status code -> exception class mapping used by the HTTP layer.
 STATUS_TO_EXC: dict[int, type[HTTPException]] = {
     400: BadRequest,
@@ -79,6 +83,7 @@ STATUS_TO_EXC: dict[int, type[HTTPException]] = {
     403: Forbidden,
     404: NotFound,
     429: RateLimited,
+    503: ServiceUnavailable,
 }
 
 

{pyyapper-1.2.0a1 → pyyapper-1.3.2}/src/pyyapper/ext/commands/core.py

@@ -376,10 +376,13 @@ def remove_cog(bot, name):
             import asyncio
             # best-effort: if event loop running, schedule; else run
             try:
-                loop = asyncio.get_event_loop()
-                if loop.is_running():
-                    loop.create_task(res)
-                else:
+                try:
+                    loop = asyncio.get_running_loop()
+                    if loop.is_running():
+                        loop.create_task(res)
+                except RuntimeError:
+                    loop = asyncio.new_event_loop()
+                    asyncio.set_event_loop(loop)
                     loop.run_until_complete(res)
             except Exception:
                 pass

{pyyapper-1.2.0a1 → pyyapper-1.3.2}/src/pyyapper/ext/tasks.py

@@ -132,9 +132,10 @@ class Loop:
         try:
             loop = asyncio.get_running_loop()
         except RuntimeError:
-            # Fallback: try to get/create an event loop.
+            # Fallback: create a new event loop (cross-platform).
             try:
-                loop = asyncio.get_event_loop()
+                loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(loop)
             except RuntimeError:
                 return None
         try:

{pyyapper-1.2.0a1 → pyyapper-1.3.2}/src/pyyapper/http.py

@@ -15,6 +15,25 @@ from __future__ import annotations
 import asyncio
 import json
 import random
+
+try:
+    import orjson as _orjson
+
+    def _json_loads(data):
+        return _orjson.loads(data)
+
+    def _json_dumps(obj):
+        return _orjson.dumps(obj)
+
+    _HAS_ORJSON = True
+except ImportError:  # pragma: no cover
+    _HAS_ORJSON = False
+
+    def _json_loads(data):
+        return json.loads(data)
+
+    def _json_dumps(obj):
+        return json.dumps(obj).encode()
 from typing import Any, Optional
 
 import aiohttp
@@ -93,7 +112,8 @@ class HTTPClient:
             # JSON body unless caller already provided bytes
             if content_type is None:
                 content_type = "application/json"
-            data = json.dumps(body)
+            dumped = _json_dumps(body)
+            data = dumped if isinstance(dumped, (bytes, bytearray)) else dumped.encode()
         elif body is not None:
             data = body
         if content_type:
@@ -111,8 +131,8 @@ class HTTPClient:
                     raw = await res.read()
                     text = raw.decode("utf-8", errors="replace") if raw else ""
                     try:
-                        payload = json.loads(text) if text else {}
-                    except json.JSONDecodeError:
+                        payload = _json_loads(text) if text else {}
+                    except Exception:
                         payload = {}
                     if res.status < 400:
                         return payload
@@ -127,12 +147,14 @@ class HTTPClient:
                             retry_after = float(ra)
                         except ValueError:
                             retry_after = None
-                    # retry on 429 with Retry-After
-                    if res.status == 429 and retry_after and retry_after > 0 and retry_after <= 60 and attempt < retries:
-                        if self.log:
-                            print(f"[pyyapper] rate limited, retrying {method} {path} in {retry_after}s")
-                        await asyncio.sleep(retry_after)
-                        continue
+                    # retry on 429 / 503 with Retry-After
+                    if res.status in (429, 503) and retry_after and retry_after > 0 and attempt < retries:
+                        cap = 60 if res.status == 429 else 30
+                        if retry_after <= cap:
+                            if self.log:
+                                print(f"[pyyapper] {res.status} retrying {method} {path} in {retry_after}s")
+                            await asyncio.sleep(retry_after)
+                            continue
                     exc_cls = exception_for_status(res.status)
                     raise exc_cls(
                         res.status,

{pyyapper-1.2.0a1 → pyyapper-1.3.2}/src/pyyapper/models.py

@@ -43,6 +43,16 @@ class _Model:
         return out
 
 
+def picture_url(bucket: str, path: Any) -> Optional[str]:
+    """Build a full picture URL from a path returned by the API."""
+    if not path:
+        return None
+    p = str(path)
+    if p.startswith("/"):
+        return "https://www.yapper.website" + p
+    return f"https://files.yapper.website/{bucket}/{p}"
+
+
 @dataclass
 class User(_Model):
     id: str = ""
@@ -51,10 +61,21 @@ class User(_Model):
     bio: str = ""
     avatar_url: Optional[str] = None
     banner_url: Optional[str] = None
+    avatar_path: Optional[str] = None
+    banner_path: Optional[str] = None
+    badges: list[Any] = field(default_factory=list)
     created_at: Optional[str] = None
     bot: Optional[dict[str, Any]] = None
     raw: dict[str, Any] = field(default_factory=dict, repr=False)
 
+    @property
+    def avatar(self) -> Optional[str]:
+        return self.avatar_url or picture_url("avatars", self.avatar_path)
+
+    @property
+    def banner(self) -> Optional[str]:
+        return self.banner_url or picture_url("banners", self.banner_path)
+
     @classmethod
     def from_dict(cls, data: dict[str, Any] | None) -> "User":
         data = data or {}
@@ -65,6 +86,9 @@ class User(_Model):
             bio=data.get("bio", "") or "",
             avatar_url=data.get("avatar_url"),
             banner_url=data.get("banner_url"),
+            avatar_path=data.get("avatar_path"),
+            banner_path=data.get("banner_path"),
+            badges=list(data.get("badges") or []),
             created_at=data.get("created_at"),
             bot=data.get("bot"),
             raw=dict(data),
@@ -75,12 +99,26 @@ class User(_Model):
 class Server(_Model):
     id: str = ""
     name: str = ""
+    icon_path: Optional[str] = None
+    owner_id: Optional[str] = None
+    member_count: Optional[int] = None
     raw: dict[str, Any] = field(default_factory=dict, repr=False)
 
+    @property
+    def icon(self) -> Optional[str]:
+        return picture_url("icons", self.icon_path)
+
     @classmethod
     def from_dict(cls, data: dict[str, Any] | None) -> "Server":
         data = data or {}
-        return cls(id=data.get("id", "") or "", name=data.get("name", "") or "", raw=dict(data))
+        return cls(
+            id=data.get("id", "") or "",
+            name=data.get("name", "") or "",
+            icon_path=data.get("icon_path"),
+            owner_id=data.get("owner_id"),
+            member_count=data.get("member_count"),
+            raw=dict(data),
+        )
 
 
 @dataclass
@@ -166,13 +204,25 @@ class Message(_Model):
     author: Optional[str] = None
     content: str = ""
     attachment: Optional[str] = None
+    attachment_path: Optional[str] = None
     reply_to_id: Optional[str] = None
     created_at: Optional[str] = None
+    edited_at: Optional[str] = None
+    pinned_at: Optional[str] = None
     mentioned: bool = False
+    author_bot: bool = False
+    embeds: list[Any] = field(default_factory=list)
+    components: list[Any] = field(default_factory=list)
     command: Optional[str] = None
     args: Optional[str] = None
     raw: dict[str, Any] = field(default_factory=dict, repr=False)
 
+    @property
+    def attachment_url(self) -> Optional[str]:
+        if self.attachment:
+            return self.attachment
+        return picture_url("attachments", self.attachment_path)
+
     @classmethod
     def from_dict(cls, data: dict[str, Any] | None) -> "Message":
         data = data or {}
@@ -185,9 +235,15 @@ class Message(_Model):
             author=data.get("author"),
             content=data.get("content", "") or "",
             attachment=data.get("attachment"),
+            attachment_path=data.get("attachment_path"),
             reply_to_id=data.get("reply_to_id"),
             created_at=data.get("created_at"),
+            edited_at=data.get("edited_at"),
+            pinned_at=data.get("pinned_at"),
             mentioned=bool(data.get("mentioned", False)),
+            author_bot=bool(data.get("author_bot", False)),
+            embeds=list(data.get("embeds") or []),
+            components=list(data.get("components") or []),
             command=data.get("command"),
             args=data.get("args"),
             raw=dict(data),
@@ -203,4 +259,20 @@ class Role(_Model):
     @classmethod
     def from_dict(cls, data: dict[str, Any] | None) -> "Role":
         data = data or {}
-        return cls(id=data.get("id", "") or "", name=data.get("name", "") or "", raw=dict(data))
+        return cls(id=data.get("id", "") or "", name=data.get("name", "") or "", raw=dict(data))
+
+
+@dataclass
+class VoiceChannel(_Model):
+    channel_id: str = ""
+    user_ids: list[str] = field(default_factory=list)
+    raw: dict[str, Any] = field(default_factory=dict, repr=False)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any] | None) -> "VoiceChannel":
+        data = data or {}
+        return cls(
+            channel_id=data.get("channel_id", "") or "",
+            user_ids=list(data.get("user_ids") or []),
+            raw=dict(data),
+        )

{pyyapper-1.2.0a1 → pyyapper-1.3.2}/src/pyyapper/pagination.py

@@ -62,7 +62,11 @@ class Paginator:
         return [Row(*btns)]
 
     async def _wait(self) -> Any:
-        loop = asyncio.get_event_loop()
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
         self._future = loop.create_future()
         try:
             return await asyncio.wait_for(self._future, timeout=self.timeout)

pyyapper-1.3.2/src/pyyapper/presence.py

@@ -0,0 +1,139 @@
+"""Presence / activity helpers for PyYapper bots.
+
+Yapper's API accepts a status (``online``/``idle``/``dnd``) and a single
+activity line (up to 60 characters). This module adds a small, discord.py-style
+``Activity`` builder on top of that, including an activity *type* (playing,
+listening, watching, ...) that is rendered into the activity line. Extra
+"rich" fields (details, state, timestamps, assets) are stored locally so they
+are available when Yapper supports them, and are serialized into the activity
+string in the meantime.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from typing import Any, Optional
+
+ACTIVITY_TYPES = ("playing", "streaming", "listening", "watching", "competing", "custom")
+
+_PREFIX = {
+    "playing": "Playing",
+    "streaming": "Streaming",
+    "listening": "Listening to",
+    "watching": "Watching",
+    "competing": "Competing in",
+    "custom": "",
+}
+
+
+@dataclass
+class Activity:
+    """A rich activity descriptor.
+
+    Example::
+
+        act = Activity.playing("chess")
+        act = Activity.listening("lofi beats")
+        act = Activity.custom("Moderating")
+    """
+
+    name: str = ""
+    type: str = "playing"
+    state: Optional[str] = None
+    details: Optional[str] = None
+    url: Optional[str] = None
+    start: Optional[datetime] = None
+    end: Optional[datetime] = None
+    large_image: Optional[str] = None
+    small_image: Optional[str] = None
+    large_text: Optional[str] = None
+    small_text: Optional[str] = None
+    extra: dict[str, Any] = field(default_factory=dict)
+
+    # -- factories --------------------------------------------------------
+    @classmethod
+    def playing(cls, name: str, **kw: Any) -> "Activity":
+        return cls(name=name, type="playing", **kw)
+
+    @classmethod
+    def streaming(cls, name: str, url: Optional[str] = None, **kw: Any) -> "Activity":
+        return cls(name=name, type="streaming", url=url, **kw)
+
+    @classmethod
+    def listening(cls, name: str, **kw: Any) -> "Activity":
+        return cls(name=name, type="listening", **kw)
+
+    @classmethod
+    def watching(cls, name: str, **kw: Any) -> "Activity":
+        return cls(name=name, type="watching", **kw)
+
+    @classmethod
+    def competing(cls, name: str, **kw: Any) -> "Activity":
+        return cls(name=name, type="competing", **kw)
+
+    @classmethod
+    def custom(cls, text: str, **kw: Any) -> "Activity":
+        return cls(name=text, type="custom", **kw)
+
+    # -- serialization ----------------------------------------------------
+    def to_text(self) -> str:
+        """Render to the 60-char activity line Yapper accepts."""
+        prefix = _PREFIX.get(self.type, "")
+        base = self.name.strip() if self.name else ""
+        if self.type == "custom":
+            text = base
+        elif prefix and base:
+            text = f"{prefix} {base}"
+        else:
+            text = base
+        # Append state/details if room (Yapper caps at 60).
+        if self.state and len(text) + len(self.state) + 3 <= 60:
+            text = f"{text} — {self.state}"
+        return text[:60]
+
+    def to_dict(self) -> dict[str, Any]:
+        out: dict[str, Any] = {"type": self.type, "name": self.name}
+        if self.state is not None:
+            out["state"] = self.state
+        if self.details is not None:
+            out["details"] = self.details
+        if self.url is not None:
+            out["url"] = self.url
+        if self.start is not None:
+            out["start"] = self.start.isoformat()
+        if self.end is not None:
+            out["end"] = self.end.isoformat()
+        if self.large_image is not None:
+            out["large_image"] = self.large_image
+        if self.small_image is not None:
+            out["small_image"] = self.small_image
+        if self.large_text is not None:
+            out["large_text"] = self.large_text
+        if self.small_text is not None:
+            out["small_text"] = self.small_text
+        out.update(self.extra)
+        return out
+
+    def to_api(self) -> str:
+        return self.to_text()
+
+    def __str__(self) -> str:
+        return self.to_text()
+
+
+@dataclass
+class Presence:
+    """Status + activity pair."""
+    status: str = "online"
+    activity: Optional[Any] = None
+
+    def to_status(self) -> str:
+        return self.status
+
+    def to_activity(self) -> Optional[str]:
+        if self.activity is None:
+            return None
+        if isinstance(self.activity, Activity):
+            return self.activity.to_text()
+        return str(self.activity)[:60] if self.activity is not None else None

{pyyapper-1.2.0a1 → pyyapper-1.3.2}/src/pyyapper/wait_for.py

@@ -104,7 +104,8 @@ class WaiterRegistry:
         try:
             loop = asyncio.get_running_loop()
         except RuntimeError:
-            loop = asyncio.get_event_loop()
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
         future = loop.create_future()
         waiter = self.add(event, check, future)
         try:

{pyyapper-1.2.0a1 → pyyapper-1.3.2}/src/pyyapper/webhooks.py

@@ -10,6 +10,25 @@ from __future__ import annotations
 import asyncio
 import json
 from typing import Any, Optional
+
+try:
+    import orjson as _orjson
+
+    def _json_loads(data):
+        return _orjson.loads(data)
+
+    def _json_dumps(obj):
+        return _orjson.dumps(obj)
+
+    _HAS_ORJSON = True
+except ImportError:  # pragma: no cover
+    _HAS_ORJSON = False
+
+    def _json_loads(data):
+        return json.loads(data)
+
+    def _json_dumps(obj):
+        return json.dumps(obj).encode()
 from urllib.parse import urlparse
 
 import aiohttp
@@ -134,11 +153,16 @@ class Webhook:
         session = await self._get_session()
         for attempt in range(retries + 1):
             try:
+                if json_body is None:
+                    data_body = None
+                else:
+                    dumped = _json_dumps(json_body)
+                    data_body = dumped if isinstance(dumped, (bytes, bytearray)) else dumped.encode()
                 kwargs = dict(
                     params=params,
-                    json=json_body,
+                    data=data_body,
                     timeout=aiohttp.ClientTimeout(total=timeout),
-                    headers={"User-Agent": USER_AGENT},
+                    headers={"User-Agent": USER_AGENT, "Content-Type": "application/json"} if data_body is not None else {"User-Agent": USER_AGENT},
                 )
                 if hasattr(session, "request"):
                     cm = session.request(method, url, **kwargs)
@@ -151,8 +175,8 @@ class Webhook:
                     raw = await res.read()
                     text = raw.decode("utf-8", errors="replace") if raw else ""
                     try:
-                        payload = json.loads(text) if text else None
-                    except json.JSONDecodeError:
+                        payload = _json_loads(text) if text else None
+                    except Exception:
                         payload = None
                     if res.status < 400:
                         return payload
@@ -167,12 +191,13 @@ class Webhook:
                         except (TypeError, ValueError):
                             retry_after = None
                     if (
-                        res.status == 429
+                        res.status in (429, 503)
                         and retry_after is not None
                         and retry_after > 0
                         and attempt < retries
                     ):
-                        await asyncio.sleep(min(retry_after, 60.0))
+                        cap = 60.0 if res.status == 429 else 30.0
+                        await asyncio.sleep(min(retry_after, cap))
                         continue
                     exc_cls = exception_for_status(res.status)
                     # RateLimited subclass expected for 429

{pyyapper-1.2.0a1 → pyyapper-1.3.2/src/pyyapper.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyyapper
-Version: 1.2.0a1
+Version: 1.3.2
 Summary: An intuitive, async Python library for the Yapper bot API.
 Author: PyYapper contributors
 License-Expression: MIT
@@ -31,6 +31,8 @@ Requires-Dist: twine; extra == "dev"
 Provides-Extra: docs
 Requires-Dist: mkdocs; extra == "docs"
 Requires-Dist: mkdocs-material; extra == "docs"
+Provides-Extra: speed
+Requires-Dist: orjson; extra == "speed"
 Dynamic: license-file
 
 # PyYapper

{pyyapper-1.2.0a1 → pyyapper-1.3.2}/src/pyyapper.egg-info/SOURCES.txt

@@ -5,12 +5,14 @@ src/pyyapper/__init__.py
 src/pyyapper/_version.py
 src/pyyapper/bot.py
 src/pyyapper/buttons.py
+src/pyyapper/cache.py
 src/pyyapper/commands.py
 src/pyyapper/embeds.py
 src/pyyapper/errors.py
 src/pyyapper/http.py
 src/pyyapper/models.py
 src/pyyapper/pagination.py
+src/pyyapper/presence.py
 src/pyyapper/py.typed
 src/pyyapper/wait_for.py
 src/pyyapper/webhooks.py

{pyyapper-1.2.0a1 → pyyapper-1.3.2}/src/pyyapper.egg-info/requires.txt

@@ -9,3 +9,6 @@ twine
 [docs]
 mkdocs
 mkdocs-material
+
+[speed]
+orjson

pyyapper-1.2.0a1/src/pyyapper/_version.py

@@ -1 +0,0 @@
-__version__ = "1.2.0a1"