pyyapper 1.4.0__tar.gz → 1.6.0__tar.gz

{pyyapper-1.4.0/src/pyyapper.egg-info → pyyapper-1.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyyapper
-Version: 1.4.0
+Version: 1.6.0
 Summary: An intuitive, async Python library for the Yapper bot API.
 Author: PyYapper contributors
 License-Expression: MIT

{pyyapper-1.4.0 → pyyapper-1.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pyyapper"
-version = "1.4.0"
+version = "1.6.0"
 description = "An intuitive, async Python library for the Yapper bot API."
 readme = "README.md"
 license = "MIT"

{pyyapper-1.4.0 → pyyapper-1.6.0}/src/pyyapper/__init__.py

@@ -23,10 +23,18 @@ from .presence import Activity, Presence
 from .pagination import Paginator
 from .webhooks import Webhook
 from .wait_for import WaiterRegistry, wait_for
+from .oauth import OAuth2Client, OAuthError, generate_state, generate_pkce, YapperOAuth, LoginWithYapper
 from .config import load_config, load_env_file, get_token
 from .i18n import Translator, t as translate
 from .metrics import Metrics
 from .ext import commands, tasks
+from . import components_v2 as components_v2
+from .components_v2 import (
+    IS_COMPONENTS_V2, TextDisplay, Thumbnail, Section, MediaGallery, MediaGalleryItem,
+    Separator, FileComponent, Container, ActionRow,
+    text, thumbnail, section, gallery, separator, file_display, container, action_row,
+    row, normalize_components,
+)
 
 __version__ = _version.__version__
 
@@ -38,9 +46,15 @@ __all__ = [
     "User", "Server", "Channel", "Category", "Member", "Message", "Role", "VoiceChannel", "picture_url",
     "Activity", "Presence",
     "Paginator", "Webhook", "WaiterRegistry", "wait_for",
+    "OAuth2Client", "OAuthError", "generate_state", "generate_pkce",
+    "YapperOAuth", "LoginWithYapper",
     "load_config", "load_env_file", "get_token",
     "Translator", "translate", "Metrics",
-    "commands", "tasks",
+    "commands", "tasks", "components_v2",
+    "IS_COMPONENTS_V2", "TextDisplay", "Thumbnail", "Section", "MediaGallery",
+    "MediaGalleryItem", "Separator", "FileComponent", "Container", "ActionRow",
+    "text", "thumbnail", "section", "gallery", "separator", "file_display",
+    "container", "action_row", "row", "normalize_components",
     "Cog", "Command", "Group",
     "__version__",
 ]

pyyapper-1.6.0/src/pyyapper/_version.py

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

{pyyapper-1.4.0 → pyyapper-1.6.0}/src/pyyapper/bot.py

@@ -88,6 +88,9 @@ class Context:
     async def say(self, content: Any = "", **opts: Any) -> Any:
         return await self._bot.send(self.channel_id, content, **opts)
 
+    async def send_layout(self, components: Any, **opts: Any) -> Any:
+        return await self._bot.send_layout(self.channel_id, components, **opts)
+
     def __repr__(self) -> str:
         return f"Context(id={self.id!r}, author={self.author!r})"
 
@@ -137,6 +140,10 @@ class InteractionContext:
             kw = {**changes, **kw}
             changes = None
         body = {"type": "update"}
+        if "layout" in kw:
+            from .components_v2 import normalize_components
+            body["flags"] = 32768
+            body["components"] = normalize_components(kw.pop("layout"))
         if "content" in kw:
             c = kw.pop("content")
             body["content"] = None if c is None else str(c)
@@ -556,6 +563,23 @@ class Bot:
     def send_embed(self, channel_id: Any, embed: Any, content: str = "") -> Any:
         return self.send(channel_id, content, embeds=[embed])
 
+    async def send_layout(self, channel_id: Any, components: Any, *, reply_to: Any = None,
+                          flags: int = 32768) -> Any:
+        from .components_v2 import normalize_components
+        body: dict[str, Any] = {"flags": flags, "components": normalize_components(components)}
+        if reply_to is not None:
+            body["reply_to"] = reply_to
+        out = await self.api("POST", f"/channels/{channel_id}/messages", body)
+        msg = out.get("message") if isinstance(out, dict) else None
+        return msg if msg is not None else out
+
+    async def edit_layout(self, channel_id: Any, message_id: Any, components: Any,
+                          *, flags: int = 32768) -> Any:
+        from .components_v2 import normalize_components
+        body: dict[str, Any] = {"flags": flags, "components": normalize_components(components)}
+        out = await self.api("PATCH", f"/channels/{channel_id}/messages/{message_id}", body)
+        return out.get("message") if isinstance(out, dict) else out
+
     async def delete(self, channel_id: Any, message_id: Any) -> Any:
         return await self.api("DELETE", f"/channels/{channel_id}/messages/{message_id}")
 

pyyapper-1.6.0/src/pyyapper/components_v2.py

@@ -0,0 +1,319 @@
+"""Components V2 builders for PyYapper.
+
+Components V2 lets you build a whole message out of layout parts: containers
+(cards), sections with a button or thumbnail next to the text, media galleries,
+separators, files and text displays, with button rows anywhere.
+
+Send one with ``bot.send_layout(channel, [container(...)])`` (or
+``ctx.send_layout(...)``), which sets ``flags: 32768`` (``IS_COMPONENTS_V2``).
+"""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from .buttons import Button, Row
+from .embeds import Embed  # noqa: F401 (kept for parity)
+
+
+def _plain(x: Any) -> Any:
+    if hasattr(x, "to_dict"):
+        return x.to_dict()
+    if hasattr(x, "toJSON"):
+        return x.toJSON()
+    return x
+
+
+def _color(c: Any) -> Optional[int]:
+    if c is None:
+        return None
+    if isinstance(c, bool):
+        return None
+    if isinstance(c, int):
+        return c
+    s = str(c).strip()
+    named = {"red": 0xED4245, "green": 0x57F287, "blue": 0x5865F2,
+             "yellow": 0xFEE75C, "purple": 0x9B59B6, "orange": 0xE67E22,
+             "grey": 0x95A5A6, "gray": 0x95A5A6, "blurple": 0x5865F2}
+    if s.lower() in named:
+        return named[s.lower()]
+    hexed = s.lstrip("#").lstrip("0x").lstrip("x")
+    if s.lower().startswith("0x"):
+        hexed = s[2:]
+    try:
+        return int(hexed, 16)
+    except ValueError:
+        return None
+
+
+def _media(url: Any) -> dict[str, Any]:
+    if isinstance(url, dict):
+        return dict(url)
+    return {"url": str(url)}
+
+
+def _normalize_v2(obj: Any) -> Any:
+    """Coerce builders/dicts to plain dicts and normalize action-row types."""
+    if hasattr(obj, "to_dict"):
+        obj = obj.to_dict()
+    if isinstance(obj, dict):
+        # action row: "row" -> 1
+        t = obj.get("type")
+        if t in ("row", "action_row"):
+            obj["type"] = 1
+        if t == "button":
+            obj["type"] = 2
+        # recurse
+        for k in ("components", "items", "accessory"):
+            if k in obj and isinstance(obj[k], list):
+                obj[k] = [_normalize_v2(x) for x in obj[k]]
+            elif k in obj and obj[k] is not None and not isinstance(obj[k], (str, int, float, bool)):
+                obj[k] = _normalize_v2(obj[k])
+        if "media" in obj and isinstance(obj["media"], (dict,)):
+            obj["media"] = _normalize_v2(obj["media"])
+        if "file" in obj and isinstance(obj["file"], (dict,)):
+            obj["file"] = _normalize_v2(obj["file"])
+        return obj
+    if isinstance(obj, (list, tuple)):
+        return [_normalize_v2(x) for x in obj]
+    return obj
+
+
+# --------------------------------------------------------------------------- #
+# Builders
+# --------------------------------------------------------------------------- #
+class TextDisplay:
+    """Type 10 — a text display (markdown)."""
+
+    def __init__(self, content: Any, *, id: Optional[int] = None) -> None:
+        self.data: dict[str, Any] = {"type": 10, "content": str(content)}
+        if id is not None:
+            self.data["id"] = id
+
+    def to_dict(self) -> dict[str, Any]:
+        return dict(self.data)
+
+    def toJSON(self) -> dict[str, Any]:
+        return self.to_dict()
+
+
+class Thumbnail:
+    """Type 11 — a thumbnail (only valid as a section accessory)."""
+
+    def __init__(self, url: Any, *, description: Optional[str] = None,
+                 spoiler: bool = False, id: Optional[int] = None) -> None:
+        self.data: dict[str, Any] = {"type": 11, "media": {"url": str(url)}}
+        if description is not None:
+            self.data["description"] = str(description)
+        if spoiler:
+            self.data["spoiler"] = True
+        if id is not None:
+            self.data["id"] = id
+
+    def to_dict(self) -> dict[str, Any]:
+        return dict(self.data)
+
+    def toJSON(self) -> dict[str, Any]:
+        return self.to_dict()
+
+
+class Section:
+    """Type 9 — 1 to 3 text displays plus a button or thumbnail accessory."""
+
+    def __init__(self, *texts: Any, accessory: Any = None, id: Optional[int] = None) -> None:
+        comps = [_plain(t) if not hasattr(t, "to_dict") else t.to_dict() for t in texts]
+        # allow passing raw strings
+        norm = []
+        for t in texts:
+            if isinstance(t, str):
+                norm.append({"type": 10, "content": t})
+            else:
+                norm.append(_normalize_v2(_plain(t)))
+        self.data: dict[str, Any] = {"type": 9, "components": norm}
+        if accessory is not None:
+            self.data["accessory"] = _normalize_v2(_plain(accessory))
+        if id is not None:
+            self.data["id"] = id
+
+    def accessory(self, acc: Any) -> "Section":
+        self.data["accessory"] = _normalize_v2(_plain(acc))
+        return self
+
+    def to_dict(self) -> dict[str, Any]:
+        return _normalize_v2(dict(self.data))
+
+    def toJSON(self) -> dict[str, Any]:
+        return self.to_dict()
+
+
+class MediaGalleryItem:
+    def __init__(self, url: Any, *, description: Optional[str] = None, spoiler: bool = False) -> None:
+        self.data: dict[str, Any] = {"media": {"url": str(url)}}
+        if description is not None:
+            self.data["description"] = str(description)
+        if spoiler:
+            self.data["spoiler"] = True
+
+    def to_dict(self) -> dict[str, Any]:
+        return dict(self.data)
+
+
+class MediaGallery:
+    """Type 12 — a gallery of 1 to 10 media items."""
+
+    def __init__(self, *items: Any, id: Optional[int] = None) -> None:
+        norm = []
+        for it in items:
+            if isinstance(it, str):
+                norm.append({"media": {"url": it}})
+            elif isinstance(it, MediaGalleryItem):
+                norm.append(it.to_dict())
+            elif isinstance(it, dict):
+                if "media" in it:
+                    norm.append(dict(it))
+                else:
+                    norm.append({"media": {"url": str(it)}})
+            else:
+                norm.append(_normalize_v2(_plain(it)))
+        self.data: dict[str, Any] = {"type": 12, "items": norm}
+        if id is not None:
+            self.data["id"] = id
+
+    def to_dict(self) -> dict[str, Any]:
+        return _normalize_v2(dict(self.data))
+
+    def toJSON(self) -> dict[str, Any]:
+        return self.to_dict()
+
+
+class Separator:
+    """Type 14 — a divider or spacer."""
+
+    def __init__(self, *, divider: bool = True, spacing: int = 1, id: Optional[int] = None) -> None:
+        self.data: dict[str, Any] = {"type": 14, "divider": bool(divider), "spacing": int(spacing)}
+        if id is not None:
+            self.data["id"] = id
+
+    def to_dict(self) -> dict[str, Any]:
+        return dict(self.data)
+
+    def toJSON(self) -> dict[str, Any]:
+        return self.to_dict()
+
+
+class FileComponent:
+    """Type 13 — a file download card."""
+
+    def __init__(self, url: Any, *, spoiler: bool = False, id: Optional[int] = None) -> None:
+        self.data: dict[str, Any] = {"type": 13, "file": {"url": str(url)}}
+        if spoiler:
+            self.data["spoiler"] = True
+        if id is not None:
+            self.data["id"] = id
+
+    def to_dict(self) -> dict[str, Any]:
+        return dict(self.data)
+
+    def toJSON(self) -> dict[str, Any]:
+        return self.to_dict()
+
+
+class Container:
+    """Type 17 — a card. ``components``: action rows, text displays, sections, galleries, separators, files."""
+
+    def __init__(self, *components: Any, accent_color: Any = None, spoiler: bool = False,
+                 id: Optional[int] = None) -> None:
+        self.data: dict[str, Any] = {"type": 17, "components": [_normalize_v2(_plain(c)) for c in components]}
+        ac = _color(accent_color)
+        if ac is not None:
+            self.data["accent_color"] = ac
+        if spoiler:
+            self.data["spoiler"] = True
+        if id is not None:
+            self.data["id"] = id
+
+    def add(self, *components: Any) -> "Container":
+        self.data["components"].extend(_normalize_v2(_plain(c)) for c in components)
+        return self
+
+    def accent(self, color: Any) -> "Container":
+        ac = _color(color)
+        if ac is not None:
+            self.data["accent_color"] = ac
+        return self
+
+    def to_dict(self) -> dict[str, Any]:
+        return _normalize_v2(dict(self.data))
+
+    def toJSON(self) -> dict[str, Any]:
+        return self.to_dict()
+
+
+class ActionRow:
+    """Type 1 — an action row of up to 5 buttons (V2 canonical)."""
+
+    def __init__(self, *buttons: Any, id: Optional[int] = None) -> None:
+        btns = []
+        for b in buttons:
+            btns.extend(b if isinstance(b, list) else [b])
+        self.data: dict[str, Any] = {"type": 1, "components": [_plain(x) for x in btns]}
+        if id is not None:
+            self.data["id"] = id
+
+    def to_dict(self) -> dict[str, Any]:
+        return _normalize_v2(dict(self.data))
+
+    def toJSON(self) -> dict[str, Any]:
+        return self.to_dict()
+
+
+# --------------------------------------------------------------------------- #
+# Factory functions (discord.py / JS-style convenience)
+# --------------------------------------------------------------------------- #
+def text(content: Any, *, id: Optional[int] = None) -> TextDisplay:
+    return TextDisplay(content, id=id)
+
+
+def thumbnail(url: Any, *, description: Optional[str] = None, spoiler: bool = False,
+              id: Optional[int] = None) -> Thumbnail:
+    return Thumbnail(url, description=description, spoiler=spoiler, id=id)
+
+
+def section(*texts: Any, accessory: Any = None, id: Optional[int] = None) -> Section:
+    return Section(*texts, accessory=accessory, id=id)
+
+
+def gallery(*items: Any, id: Optional[int] = None) -> MediaGallery:
+    return MediaGallery(*items, id=id)
+
+
+def separator(*, divider: bool = True, spacing: int = 1, id: Optional[int] = None) -> Separator:
+    return Separator(divider=divider, spacing=spacing, id=id)
+
+
+def file_display(url: Any, *, spoiler: bool = False, id: Optional[int] = None) -> FileComponent:
+    return FileComponent(url, spoiler=spoiler, id=id)
+
+
+def container(*components: Any, accent_color: Any = None, spoiler: bool = False,
+              id: Optional[int] = None) -> Container:
+    return Container(*components, accent_color=accent_color, spoiler=spoiler, id=id)
+
+
+def action_row(*buttons: Any, id: Optional[int] = None) -> ActionRow:
+    return ActionRow(*buttons, id=id)
+
+
+# alias for Row-style usage in V2
+row = action_row
+
+
+IS_COMPONENTS_V2 = 32768
+
+
+def normalize_components(components: Any) -> list:
+    """Normalize a list of V2 components to plain dicts."""
+    out = []
+    for c in (components if isinstance(components, (list, tuple)) else [components]):
+        out.append(_normalize_v2(_plain(c)))
+    return out

pyyapper-1.6.0/src/pyyapper/oauth.py

@@ -0,0 +1,217 @@
+"""OAuth2 "Login with Yapper" client for PyYapper.
+
+Implements the authorization-code flow (with optional PKCE) described in the
+Yapper developer docs. This is intended for web apps that let users log in with
+their Yapper account; it is independent of the bot API.
+"""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import json
+import os
+import secrets
+import urllib.parse
+from typing import Any, Optional
+
+import aiohttp
+
+from .errors import YapperError
+
+
+class OAuthError(YapperError):
+    """An OAuth2 request failed.
+
+    Attributes:
+        error: OAuth2 error code (e.g. ``invalid_grant``).
+        description: Human readable description.
+        status: HTTP status code.
+    """
+
+    def __init__(self, error: str, description: str = "", *, status: int = 400) -> None:
+        self.error = error
+        self.description = description
+        self.status = status
+        super().__init__(f"{error}: {description}".strip(": "))
+
+
+DEFAULT_BASE = "https://www.yapper.website"
+AUTHORIZE_PATH = "/oauth/authorize"
+TOKEN_PATH = "/api/oauth/token"
+ME_PATH = "/api/oauth/me"
+
+
+def _b64url(data: bytes) -> str:
+    return base64.urlsafe_b64encode(data).rstrip(b"=").decode("ascii")
+
+
+def generate_state(n: int = 32) -> str:
+    """Generate a random, URL-safe ``state`` value."""
+    return secrets.token_urlsafe(n)
+
+
+def generate_pkce(verifier_length: int = 64) -> tuple[str, str]:
+    """Generate a (code_verifier, code_challenge) pair for PKCE (S256)."""
+    verifier = secrets.token_urlsafe(verifier_length)[:128]
+    if len(verifier) < 43:
+        verifier = verifier + secrets.token_urlsafe(43 - len(verifier))
+    challenge = _b64url(hashlib.sha256(verifier.encode("ascii")).digest())
+    return verifier, challenge
+
+
+class OAuth2Client:
+    """A client for one Yapper OAuth2 app.
+
+    Parameters
+    ----------
+    client_id:
+        The app's client id.
+    client_secret:
+        The app's client secret (omit for PKCE/public apps).
+    redirect_uri:
+        Default redirect URI (must match one registered for the app).
+    base_url:
+        Yapper base URL. Defaults to ``https://www.yapper.website``.
+    session:
+        Optional shared :class:`aiohttp.ClientSession`.
+    """
+
+    def __init__(
+        self,
+        client_id: str,
+        client_secret: Optional[str] = None,
+        redirect_uri: Optional[str] = None,
+        *,
+        base_url: str = DEFAULT_BASE,
+        session: Optional[aiohttp.ClientSession] = None,
+    ) -> None:
+        self.client_id = str(client_id)
+        self.client_secret = client_secret
+        self.redirect_uri = redirect_uri
+        self.base_url = base_url.rstrip("/")
+        self._session = session
+        self._owns_session = session is None
+
+    # ------------------------------------------------------------------ #
+    # Session management
+    # ------------------------------------------------------------------ #
+    async def _get_session(self) -> aiohttp.ClientSession:
+        if self._session is None or getattr(self._session, "closed", False):
+            self._session = aiohttp.ClientSession()
+            self._owns_session = True
+        return self._session
+
+    async def close(self) -> None:
+        if self._owns_session and self._session is not None and not getattr(self._session, "closed", True):
+            await self._session.close()
+        self._session = None
+
+    async def __aenter__(self) -> "OAuth2Client":
+        return self
+
+    async def __aexit__(self, *exc: Any) -> None:
+        await self.close()
+
+    # ------------------------------------------------------------------ #
+    # Authorization URL
+    # ------------------------------------------------------------------ #
+    def authorization_url(
+        self,
+        state: str,
+        *,
+        scope: str = "identify",
+        redirect_uri: Optional[str] = None,
+        code_challenge: Optional[str] = None,
+        code_challenge_method: str = "S256",
+    ) -> str:
+        params: dict[str, Any] = {
+            "client_id": self.client_id,
+            "redirect_uri": redirect_uri or self.redirect_uri,
+            "response_type": "code",
+            "scope": scope,
+            "state": state,
+        }
+        if code_challenge is not None:
+            params["code_challenge"] = code_challenge
+            params["code_challenge_method"] = code_challenge_method
+        return f"{self.base_url}{AUTHORIZE_PATH}?{urllib.parse.urlencode(params)}"
+
+    # ------------------------------------------------------------------ #
+    # Token exchange
+    # ------------------------------------------------------------------ #
+    async def exchange_code(
+        self,
+        code: str,
+        *,
+        redirect_uri: Optional[str] = None,
+        code_verifier: Optional[str] = None,
+        use_basic_auth: bool = False,
+    ) -> dict[str, Any]:
+        url = f"{self.base_url}{TOKEN_PATH}"
+        body: dict[str, Any] = {
+            "grant_type": "authorization_code",
+            "code": code,
+            "redirect_uri": redirect_uri or self.redirect_uri,
+            "client_id": self.client_id,
+        }
+        if self.client_secret is not None and not use_basic_auth:
+            body["client_secret"] = self.client_secret
+        if code_verifier is not None:
+            body["code_verifier"] = code_verifier
+
+        headers: dict[str, str] = {"Content-Type": "application/x-www-form-urlencoded"}
+        if use_basic_auth and self.client_secret is not None:
+            import base64 as _b64
+
+            creds = _b64.b64encode(f"{self.client_id}:{self.client_secret}".encode()).decode()
+            headers["Authorization"] = f"Basic {creds}"
+            body.pop("client_secret", None)
+
+        session = await self._get_session()
+        async with session.post(url, data=body, headers=headers) as res:
+            raw = await res.read()
+            text = raw.decode("utf-8", errors="replace") if raw else ""
+            try:
+                payload = json.loads(text) if text else {}
+            except Exception:
+                payload = {}
+            if res.status >= 400:
+                err = payload.get("error", "invalid_request") if isinstance(payload, dict) else "invalid_request"
+                desc = payload.get("error_description", "") if isinstance(payload, dict) else ""
+                raise OAuthError(err, desc, status=res.status)
+            return payload if isinstance(payload, dict) else {}
+
+    # ------------------------------------------------------------------ #
+    # User info
+    # ------------------------------------------------------------------ #
+    async def fetch_user(self, access_token: str) -> dict[str, Any]:
+        url = f"{self.base_url}{ME_PATH}"
+        session = await self._get_session()
+        async with session.get(url, headers={"Authorization": f"Bearer {access_token}"}) as res:
+            raw = await res.read()
+            text = raw.decode("utf-8", errors="replace") if raw else ""
+            try:
+                payload = json.loads(text) if text else {}
+            except Exception:
+                payload = {}
+            if res.status >= 400:
+                err = payload.get("error", "invalid_token") if isinstance(payload, dict) else "invalid_token"
+                desc = payload.get("error_description", "") if isinstance(payload, dict) else ""
+                raise OAuthError(err, desc, status=res.status)
+            return payload if isinstance(payload, dict) else {}
+
+    # ------------------------------------------------------------------ #
+    # Convenience
+    # ------------------------------------------------------------------ #
+    async def login(self, code: str, **kw: Any) -> dict[str, Any]:
+        """Exchange ``code`` and immediately fetch the user. Returns ``{token, user}``."""
+        token = await self.exchange_code(code, **kw)
+        access_token = token.get("access_token")
+        user = await self.fetch_user(access_token) if access_token else None
+        return {"token": token, "user": user}
+
+
+# Aliases
+YapperOAuth = OAuth2Client
+LoginWithYapper = OAuth2Client

{pyyapper-1.4.0 → pyyapper-1.6.0/src/pyyapper.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyyapper
-Version: 1.4.0
+Version: 1.6.0
 Summary: An intuitive, async Python library for the Yapper bot API.
 Author: PyYapper contributors
 License-Expression: MIT

{pyyapper-1.4.0 → pyyapper-1.6.0}/src/pyyapper.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ src/pyyapper/bot.py
 src/pyyapper/buttons.py
 src/pyyapper/cache.py
 src/pyyapper/commands.py
+src/pyyapper/components_v2.py
 src/pyyapper/config.py
 src/pyyapper/embeds.py
 src/pyyapper/errors.py
@@ -14,6 +15,7 @@ src/pyyapper/http.py
 src/pyyapper/i18n.py
 src/pyyapper/metrics.py
 src/pyyapper/models.py
+src/pyyapper/oauth.py
 src/pyyapper/pagination.py
 src/pyyapper/presence.py
 src/pyyapper/py.typed
@@ -32,6 +34,7 @@ src/pyyapper/ext/commands/converters.py
 src/pyyapper/ext/commands/core.py
 src/pyyapper/ext/commands/errors.py
 tests/test_ext_commands.py
+tests/test_oauth.py
 tests/test_smoke.py
 tests/test_tasks.py
 tests/test_webhooks.py

pyyapper-1.6.0/tests/test_oauth.py

@@ -0,0 +1,35 @@
+import asyncio
+
+from pyyapper import OAuth2Client, generate_state, generate_pkce, OAuthError
+
+
+def test_auth_url():
+    c = OAuth2Client("cid", "secret", "https://example.com/cb")
+    url = c.authorization_url("st")
+    assert "client_id=cid" in url
+    assert "state=st" in url
+    assert "response_type=code" in url
+
+
+def test_pkce():
+    v, ch = generate_pkce()
+    assert len(v) >= 43
+    assert len(ch) >= 43
+
+
+def test_generate_state():
+    s = generate_state()
+    assert len(s) >= 32
+
+
+def test_oauth_error():
+    e = OAuthError("invalid_grant", "bad code", status=400)
+    assert e.error == "invalid_grant"
+    assert e.status == 400
+
+
+def test_async_context_manager():
+    async def main():
+        async with OAuth2Client("cid", redirect_uri="https://example.com/cb") as c:
+            assert c.client_id == "cid"
+    asyncio.run(main())

pyyapper-1.4.0/src/pyyapper/_version.py

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