pushraker 0.1.0.dev0__py3-none-any.whl

pushraker/discord.py

@@ -0,0 +1,240 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+# SPDX-PackageHomePage: https://github.com/noon92/pushraker
+# SPDX-FileCopyrightText: Copyright (c) 2026 @noon92
+
+# Discord senders for push_notifications, registered as Apprise plugins so
+# they get the same queues, retries and fallbacks as the other services:
+#
+#   discordhook://<webhook id>/<webhook token>?name=U1&ping=<mention>
+#       A server channel, through a channel webhook.
+#   discorddm://<bot token>@<user id>
+#
+# silent=yes sends without a phone notification sound (Discord's @silent).
+#       A direct message from the user's own bot. Discord only lets a bot
+#       message someone it shares a server with.
+#
+# Each notification is one embed: the title, the text (Markdown), a colour
+# from the notification type, and the image inside the embed.
+#
+# This file may be distributed under the terms of the GNU GPLv3 license.
+
+from __future__ import annotations
+import json
+import logging
+import os
+from typing import Any, Dict, Optional, Tuple
+
+import requests
+from apprise.decorators import notify
+
+API = "https://discord.com/api/v10"
+USER_AGENT = ("DiscordBot (https://github.com/paxx12-snapmaker-u1/"
+              "SnapmakerU1-Extended-Firmware, 1)")
+TIMEOUT = (10., 60.)      # connect, read: same as push_notifications
+# Embed bar colours, matching the spool pictures
+COLOURS = {"info": 0x5F6269, "success": 0x24743A, "warning": 0xC46800,
+           "failure": 0xB02626}
+TITLE_MAX = 256
+TEXT_MAX = 4096
+# Error codes: https://discord.com/developers/docs/topics/opcodes-and-status-codes
+CANNOT_DM = 50007
+UNKNOWN_WEBHOOK = 10015
+SUPPRESS_NOTIFICATIONS = 1 << 12
+
+_dm_channels: Dict[Tuple[str, str], str] = {}
+log = logging.getLogger("apprise")
+
+
+def escape(text: str) -> str:
+    """Markdown special characters shown as typed (file names, spool
+    names)."""
+    for c in "\\*_~`|>[]#":
+        text = text.replace(c, "\\" + c)
+    return text
+
+
+def link(name: str, url: str) -> str:
+    return f"[{escape(name)}]({url.replace(')', '%29').replace(' ', '%20')})"
+
+
+def _why(e: Exception) -> str:
+    """A failed request, without its URL: requests puts the URL (which
+    holds the webhook token) in the exception's text, so only the kind of
+    failure is logged."""
+    if isinstance(e, requests.Timeout):
+        return "timed out"
+    if isinstance(e, requests.ConnectionError):
+        return "connection failed"
+    return type(e).__name__
+
+
+def _error(r: requests.Response) -> Tuple[int, str]:
+    try:
+        data = r.json()
+        return int(data.get("code") or 0), str(data.get("message") or "")
+    except (ValueError, AttributeError, TypeError):
+        return 0, (r.text or "")[:200]
+
+
+def _post(url: str, headers: Dict[str, str], payload: Dict[str, Any],
+          attach: Any) -> requests.Response:
+    """Post a message, with the first attachment shown inside the embed."""
+    path = None
+    for a in attach or []:
+        path = a.path if hasattr(a, "path") else str(a)
+        if path and os.path.exists(path):
+            break
+        path = None
+    headers = dict(headers, **{"User-Agent": USER_AGENT})
+    if not path:
+        return requests.post(url, headers=headers, json=payload,
+                             timeout=TIMEOUT)
+    name = "image" + (os.path.splitext(path)[1].lower() or ".jpg")
+    payload["embeds"][0]["image"] = {"url": f"attachment://{name}"}
+    payload["attachments"] = [{"id": 0, "filename": name}]
+    with open(path, "rb") as f:
+        return requests.post(
+            url, headers=headers, timeout=TIMEOUT,
+            data={"payload_json": json.dumps(payload)},
+            files={"files[0]": (name, f, "image/jpeg")})
+
+
+def _payload(body: str, title: str, notify_type: Any, qsd: Dict[str, str],
+             content: str = "") -> Dict[str, Any]:
+    embed = {"title": title[:TITLE_MAX], "description": body[:TEXT_MAX],
+             "color": COLOURS.get(str(notify_type), COLOURS["info"])}
+    payload: Dict[str, Any] = {"embeds": [embed]}
+    if qsd.get("silent") == "yes":
+        payload["flags"] = SUPPRESS_NOTIFICATIONS
+    if content:
+        payload["content"] = content
+        # Only the mention in the settings may ping
+        payload["allowed_mentions"] = {"parse": ["everyone", "roles",
+                                                 "users"]}
+    else:
+        payload["allowed_mentions"] = {"parse": []}
+    return payload
+
+
+def mention(value: str) -> str:
+    """Settings value to a Discord mention: a user ID, role:ID,
+    everyone or here."""
+    v = (value or "").strip()
+    if v in ("everyone", "here"):
+        return "@" + v
+    if v.startswith("role:"):
+        return f"<@&{v[5:]}>"
+    return f"<@{v}>" if v else ""
+
+
+@notify(on="discordhook", name="Discord channel")
+def send_webhook(body: str, title: str, notify_type: Any, attach: Any,
+                 meta: Dict[str, Any], *args: Any, **kwargs: Any) -> bool:
+    hook_id = meta.get("host") or ""
+    token = (meta.get("fullpath") or meta.get("path") or "").strip("/")
+    qsd = meta.get("qsd") or {}
+    payload = _payload(body, title, notify_type, qsd,
+                       mention(qsd.get("ping", "")))
+    if qsd.get("name"):
+        payload["username"] = qsd["name"][:80]
+    try:
+        r = _post(f"{API}/webhooks/{hook_id}/{token}?wait=true", {},
+                  payload, attach)
+    except requests.RequestException as e:
+        log.warning("Discord: could not connect (%s)", _why(e))
+        return False
+    if r.status_code in (200, 204):
+        return True
+    code, msg = _error(r)
+    if code == UNKNOWN_WEBHOOK or r.status_code == 401:
+        log.warning("Discord: the webhook no longer exists or the URL is "
+                    "wrong; copy it again from the channel's Integrations "
+                    "settings")
+    else:
+        log.warning("Discord: HTTP %d, %s", r.status_code, msg or "error")
+    return False
+
+
+def bot_info(token: str) -> Tuple[Optional[Dict[str, Any]], str]:
+    """The bot's application (id, owner), or (None, reason)."""
+    try:
+        r = requests.get(f"{API}/applications/@me", timeout=TIMEOUT,
+                         headers={"Authorization": f"Bot {token}",
+                                  "User-Agent": USER_AGENT})
+    except requests.RequestException as e:
+        return None, f"could not connect to Discord ({_why(e)})"
+    if r.status_code == 401:
+        return None, "Discord doesn't accept this bot token"
+    if r.status_code != 200:
+        return None, "Discord: HTTP %d, %s" % (r.status_code, _error(r)[1])
+    return r.json(), ""
+
+
+def owner_id(app: Dict[str, Any]) -> str:
+    """The user who made the bot (a team's owner, for a team's bot)."""
+    team = app.get("team") or {}
+    if team.get("owner_user_id"):
+        return str(team["owner_user_id"])
+    return str((app.get("owner") or {}).get("id") or "")
+
+
+def bot_servers(token: str) -> Optional[int]:
+    """How many servers the bot is in (None if unknown)."""
+    try:
+        r = requests.get(f"{API}/users/@me/guilds", timeout=TIMEOUT,
+                         headers={"Authorization": f"Bot {token}",
+                                  "User-Agent": USER_AGENT})
+        return len(r.json()) if r.status_code == 200 else None
+    except (requests.RequestException, ValueError, TypeError):
+        return None
+
+
+def invite_url(app_id: str) -> str:
+    return (f"https://discord.com/oauth2/authorize?client_id={app_id}"
+            "&scope=bot&permissions=0")
+
+
+@notify(on="discorddm", name="Discord DM")
+def send_dm(body: str, title: str, notify_type: Any, attach: Any,
+            meta: Dict[str, Any], *args: Any, **kwargs: Any) -> bool:
+    token = meta.get("user") or ""
+    user_id = meta.get("host") or ""
+    auth = {"Authorization": f"Bot {token}"}
+    try:
+        channel = _dm_channels.get((token, user_id))
+        if channel is None:
+            r = requests.post(f"{API}/users/@me/channels", timeout=TIMEOUT,
+                              headers=dict(auth, **{"User-Agent": USER_AGENT}),
+                              json={"recipient_id": user_id})
+            if r.status_code != 200:
+                code, msg = _error(r)
+                if r.status_code == 401:
+                    log.warning("Discord: the bot token is wrong or was "
+                                "reset; copy a new one from the Developer "
+                                "Portal (Bot > Reset Token)")
+                else:
+                    log.warning("Discord: could not open the DM: HTTP %d, %s",
+                                r.status_code, msg or "error")
+                return False
+            channel = str(r.json()["id"])
+            _dm_channels[(token, user_id)] = channel
+        r = _post(f"{API}/channels/{channel}/messages", auth,
+                  _payload(body, title, notify_type, meta.get("qsd") or {}),
+                  attach)
+    except (requests.RequestException, KeyError, ValueError) as e:
+        log.warning("Discord: could not send (%s)", _why(e))
+        return False
+    if r.status_code == 200:
+        return True
+    code, msg = _error(r)
+    if code == CANNOT_DM:
+        app, _ = bot_info(token)
+        how = (f" Add the bot to a server you are in: "
+               f"{invite_url(app['id'])}" if app else "")
+        log.warning("Discord: the bot can't message you. Discord only "
+                    "allows it when you and the bot share a server, and "
+                    "your Privacy settings allow DMs from members of that "
+                    "server.%s", how)
+    else:
+        log.warning("Discord: HTTP %d, %s", r.status_code, msg or "error")
+    return False

pushraker/email_html.py

@@ -0,0 +1,121 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+# SPDX-PackageHomePage: https://github.com/noon92/pushraker
+# SPDX-FileCopyrightText: Copyright (c) 2026 @noon92
+
+# HTML emails for push_notifications (and the Firmware Config test): a card
+# with a colour bar for the kind of notification, the title, the text, the
+# image inline, and the links as buttons. Inline styles and tables only, so
+# it looks the same in Gmail, Outlook and phone mail apps. Apprise adds a
+# plain-text version for mail apps that don't show HTML.
+#
+# This file may be distributed under the terms of the GNU GPLv3 license.
+
+from __future__ import annotations
+import datetime
+import html
+from typing import List, Optional, Sequence, Tuple
+
+# Bar colour per Apprise notification type (as in the Discord embeds)
+COLOURS = {"info": "#3D7BD9", "success": "#24743A", "warning": "#C46800",
+           "failure": "#B02626"}
+FONT = ("-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,Helvetica,"
+        "Arial,sans-serif")
+IMAGE_MARK = ("<!--image-->", "<!--/image-->")
+NO_IMAGE = ('<p style="margin:0;color:#8a8f98;font-size:13px">'
+            '(image could not be attached)</p>')
+
+
+def _esc(text: str) -> str:
+    return html.escape(text, quote=True)
+
+
+def _paragraphs(body: str) -> str:
+    """Blank lines separate paragraphs; the first line of each is bold
+    (the file name, or the toolhead in filament notifications)."""
+    out = []
+    for block in (b for b in body.strip().split("\n\n") if b.strip()):
+        lines = [_esc(x) for x in block.strip().split("\n")]
+        if len(lines) > 1:
+            lines[0] = f'<b style="color:#202226">{lines[0]}</b>'
+        out.append('<p style="margin:0 0 12px 0">' + "<br>".join(lines)
+                   + "</p>")
+    return "".join(out)
+
+
+def _button(title: str, url: str, primary: bool) -> str:
+    bg, fg = ("#202226", "#ffffff") if primary else ("#eceef1", "#202226")
+    return (f'<a href="{_esc(url)}" style="display:inline-block;'
+            f'background:{bg};color:{fg};text-decoration:none;'
+            f'font-weight:600;font-size:14px;padding:9px 16px;'
+            f'border-radius:8px;margin:0 8px 8px 0">{_esc(title)}</a>')
+
+
+def render(title: str, body: str, links: Sequence[Tuple[str, str]],
+           kind: str = "info", image: Optional[str] = None,
+           when: Optional[datetime.datetime] = None,
+           sender: str = "") -> str:
+    """The email's HTML. `image` is the attachment's file name (shown
+    inline through Apprise's cid: support), `when` the time shown at the
+    top and bottom (it also keeps Gmail from hiding repeated emails in a
+    thread)."""
+    when = when or datetime.datetime.now()
+    colour = COLOURS.get(str(kind), COLOURS["info"])
+    img = ""
+    if image:
+        img = (IMAGE_MARK[0] +
+               f'<tr><td style="padding:4px 24px 8px 24px">'
+               f'<img src="cid:{_esc(image)}" alt="" width="552" '
+               f'style="display:block;width:100%;max-width:552px;height:auto;'
+               f'border-radius:8px;border:1px solid #e3e5e8"></td></tr>'
+               + IMAGE_MARK[1])
+    buttons = " ".join(_button(t, u, n == 0) for n, (t, u) in enumerate(links))
+    if buttons:
+        buttons = (f'<tr><td style="padding:12px 24px 8px 24px">{buttons}'
+                   '</td></tr>')
+    footer = f"Sent {when:%Y-%m-%d %H:%M:%S}"
+    if sender:
+        footer += f" by {_esc(sender)}"
+    return (
+        '<!doctype html><html><head><meta charset="utf-8">'
+        '<meta name="viewport" content="width=device-width">'
+        '<meta name="color-scheme" content="light"></head>'
+        f'<body style="margin:0;padding:0;background:#f2f3f5">'
+        f'<table role="presentation" width="100%" cellpadding="0" '
+        f'cellspacing="0" style="background:#f2f3f5"><tr><td align="center" '
+        f'style="padding:24px 12px">'
+        f'<table role="presentation" width="100%" cellpadding="0" '
+        f'cellspacing="0" style="max-width:600px;background:#ffffff;'
+        f'border:1px solid #e3e5e8;border-radius:12px;font-family:{FONT};'
+        f'border-collapse:separate;overflow:hidden">'
+        f'<tr><td style="height:6px;line-height:6px;font-size:0;'
+        f'background:{colour};border-radius:12px 12px 0 0">&nbsp;</td></tr>'
+        f'<tr><td style="padding:18px 24px 0 24px;font-size:12px;'
+        f'color:#8a8f98;letter-spacing:.02em">'
+        f'{when:%a %d %b %Y · %H:%M}</td></tr>'
+        f'<tr><td style="padding:4px 24px 12px 24px;font-size:21px;'
+        f'line-height:1.3;font-weight:700;color:#202226">{_esc(title)}'
+        f'</td></tr>'
+        f'<tr><td style="padding:0 24px 4px 24px;font-size:15px;'
+        f'line-height:1.5;color:#3a3d42">{_paragraphs(body)}</td></tr>'
+        f'{img}{buttons}'
+        f'<tr><td style="padding:14px 24px 18px 24px;font-size:12px;'
+        f'color:#8a8f98;border-top:1px solid #eceef1">{footer}</td></tr>'
+        '</table></td></tr></table></body></html>')
+
+
+def without_image(page: str) -> str:
+    """The page with the image replaced by a note (the last retry is sent
+    without the image)."""
+    start, end = IMAGE_MARK
+    a, b = page.find(start), page.find(end)
+    if a < 0 or b < 0:
+        return page
+    note = f'<tr><td style="padding:4px 24px 8px 24px">{NO_IMAGE}</td></tr>'
+    return page[:a] + note + page[b + len(end):]
+
+
+def is_page(text: str) -> bool:
+    return text.startswith("<!doctype html>")
+
+
+__all__: List[str] = ["render", "without_image", "is_page", "COLOURS"]