marketmyna 0.2.0__py3-none-any.whl

marketmyna/notifiers/settings_schema.py

@@ -0,0 +1,119 @@
+"""Shared field schema for notification-channel settings.
+
+Single source of truth for which Config attributes exist per channel and
+what kind of value each one holds. The HTTP system-config endpoint
+(marketmyna/api/v1/endpoints/system_config.py) reads CHANNELS from here.
+"""
+
+from __future__ import annotations
+
+# (attr on Config, label, field kind) per channel.
+# kind: "text" | "password" | "int" | "bool" | "list" | "multiline"
+CHANNELS = [
+    ("Telegram", [
+        ("telegram_bot_token", "Bot token", "password"),
+        ("telegram_chat_id", "Chat ID (send /start to your bot to get it; comma-separate several)", "text"),
+        ("telegram_message_thread_id", "Topic ID (optional, for forum groups)", "text"),
+    ]),
+    ("WhatsApp", [
+        ("whatsapp_phone", "Your WhatsApp number with country code (e.g. +919876543210)", "text"),
+        ("whatsapp_callmebot_apikey", "CallMeBot API key (message +34 644 51 95 23 'I allow callmebot to send me messages')", "password"),
+    ]),
+    ("Twilio SMS/WhatsApp", [
+        ("twilio_account_sid", "Account SID", "text"),
+        ("twilio_auth_token", "Auth token", "password"),
+        ("twilio_from", "From number (e.g. +15551234567, or whatsapp:+14155238886)", "text"),
+        ("twilio_to", "To numbers (comma-separated; prefix whatsapp: for WhatsApp)", "list"),
+    ]),
+    ("Discord", [
+        ("discord_webhook_url", "Webhook URL", "text"),
+    ]),
+    ("Slack", [
+        ("slack_webhook_url", "Webhook URL", "text"),
+    ]),
+    ("Email", [
+        ("email_sender", "Sender address", "text"),
+        ("email_reports_sender", "Reports & alerts sender", "text"),
+        ("email_username", "SMTP username", "text"),
+        ("email_password", "Password / app password", "password"),
+        ("email_receivers", "Recipients (comma-separated)", "list"),
+        ("email_smtp_server", "SMTP server (blank = auto-detect)", "text"),
+        ("email_smtp_port", "SMTP port (blank = auto-detect)", "int"),
+        ("email_smtp_ssl", "Force SSL (unchecked = auto-detect)", "bool"),
+    ]),
+    ("DingTalk", [
+        ("dingtalk_webhook_url", "Webhook URL", "text"),
+        ("dingtalk_secret", "Secret (optional signing)", "password"),
+    ]),
+    ("Feishu", [
+        ("feishu_webhook_url", "Webhook URL", "text"),
+        ("feishu_webhook_secret", "Secret (optional signing)", "password"),
+    ]),
+    ("WeChat", [
+        ("wechat_webhook_url", "Group robot webhook URL", "text"),
+    ]),
+    ("Pushover", [
+        ("pushover_user_key", "User key", "text"),
+        ("pushover_api_token", "API token", "password"),
+    ]),
+    ("ntfy", [
+        ("ntfy_url", "Topic URL (e.g. https://ntfy.sh/mytopic)", "text"),
+        ("ntfy_token", "Access token (optional)", "password"),
+    ]),
+    ("Gotify", [
+        ("gotify_url", "Server URL", "text"),
+        ("gotify_token", "App token", "password"),
+    ]),
+    ("PushPlus", [
+        ("pushplus_token", "Token", "password"),
+        ("pushplus_topic", "Topic (optional, for group push)", "text"),
+    ]),
+    ("ServerChan3", [
+        ("serverchan3_sendkey", "SendKey", "password"),
+    ]),
+    ("AstrBot", [
+        ("astrbot_url", "Instance URL", "text"),
+        ("astrbot_token", "Token (optional)", "password"),
+    ]),
+    ("Microsoft Teams", [
+        ("teams_webhook_url", "Workflows webhook URL (Teams channel > Workflows > 'Post to a channel when a webhook request is received')", "text"),
+    ]),
+    ("Google Chat", [
+        ("google_chat_webhook_url", "Space webhook URL (Space > Apps & integrations > Webhooks)", "text"),
+    ]),
+    ("Matrix", [
+        ("matrix_homeserver", "Homeserver URL (e.g. https://matrix.org)", "text"),
+        ("matrix_access_token", "Access token", "password"),
+        ("matrix_room_id", "Room ID (e.g. !abc123:matrix.org)", "text"),
+    ]),
+    ("Signal", [
+        ("signal_api_url", "signal-cli REST API URL (e.g. http://localhost:8080)", "text"),
+        ("signal_number", "Sending number linked to signal-cli (e.g. +919876543210)", "text"),
+        ("signal_recipients", "Recipients (comma-separated numbers or group IDs)", "list"),
+    ]),
+    ("Bark (iOS)", [
+        ("bark_url", "Device URL from the Bark app (e.g. https://api.day.app/yourkey)", "password"),
+    ]),
+    ("Pushbullet", [
+        ("pushbullet_token", "Access token", "password"),
+    ]),
+    ("Apprise", [
+        ("apprise_urls", "Apprise URLs for 100+ other services (comma-separated; needs 'pip install apprise')", "list"),
+    ]),
+    ("Webhook", [
+        ("webhook_url", "URL", "text"),
+        ("webhook_headers", 'Extra headers (JSON, e.g. {"Authorization": "Bearer x"})', "multiline"),
+    ]),
+]
+
+
+def iter_fields():
+    """Yield (channel_name, attr, label, kind) for every field across all channels."""
+    for channel_name, fields in CHANNELS:
+        for attr, label, kind in fields:
+            yield channel_name, attr, label, kind
+
+
+def is_secret_kind(kind: str) -> bool:
+    """Whether a field's raw value should never be echoed back (e.g. over HTTP)."""
+    return kind in ("password", "secret_list")

marketmyna/notifiers/signal_messenger.py

@@ -0,0 +1,25 @@
+"""Signal sender through a signal-cli REST API instance
+(https://github.com/bbernhard/signal-cli-rest-api) linked to your number."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from .base import DEFAULT_TIMEOUT, DEFAULT_TITLE, http_ok
+
+
+class SignalSender:
+    def __init__(self, config):
+        self._url = (getattr(config, "signal_api_url", None) or "").rstrip("/")
+        self._number = getattr(config, "signal_number", None)
+        self._recipients = getattr(config, "signal_recipients", None) or []
+
+    def is_configured(self) -> bool:
+        return bool(self._url and self._number and self._recipients)
+
+    def send(self, message: str, title: Optional[str] = None, *, timeout: float = DEFAULT_TIMEOUT) -> bool:
+        if not self.is_configured():
+            return False
+        body = {"message": f"{title or DEFAULT_TITLE}\n\n{message}", "number": self._number,
+                "recipients": list(self._recipients)}
+        return http_ok("Signal", "POST", f"{self._url}/v2/send", json=body, timeout=timeout)

marketmyna/notifiers/slack.py

@@ -0,0 +1,36 @@
+"""Slack Incoming Webhook notification sender."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import requests
+
+from .base import DEFAULT_TIMEOUT, DEFAULT_TITLE, logger, truncate
+
+SLACK_MAX_LENGTH = 39000
+
+
+class SlackSender:
+    def __init__(self, config):
+        self._webhook_url = getattr(config, "slack_webhook_url", None)
+
+    def is_configured(self) -> bool:
+        return bool(self._webhook_url)
+
+    def send(self, message: str, title: Optional[str] = None, *, timeout: float = DEFAULT_TIMEOUT) -> bool:
+        if not self.is_configured():
+            return False
+
+        text = f"*{title or DEFAULT_TITLE}*\n{message}"
+        text = truncate(text, SLACK_MAX_LENGTH)
+
+        try:
+            resp = requests.post(self._webhook_url, json={"text": text}, timeout=timeout)
+            if resp.status_code == 200 and resp.text == "ok":
+                return True
+            logger.error("Slack send failed: HTTP %s %s", resp.status_code, resp.text[:200])
+            return False
+        except requests.RequestException as exc:
+            logger.error("Slack send failed: %s", exc)
+            return False

marketmyna/notifiers/teams.py

@@ -0,0 +1,37 @@
+"""Microsoft Teams sender (Workflows / Power Automate "post to a channel
+when a webhook request is received" URL, which takes an Adaptive Card)."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from .base import DEFAULT_TIMEOUT, DEFAULT_TITLE, http_ok, truncate
+
+TEAMS_MAX_LENGTH = 20000
+
+
+class TeamsSender:
+    def __init__(self, config):
+        self._url = getattr(config, "teams_webhook_url", None)
+
+    def is_configured(self) -> bool:
+        return bool(self._url)
+
+    def send(self, message: str, title: Optional[str] = None, *, timeout: float = DEFAULT_TIMEOUT) -> bool:
+        if not self.is_configured():
+            return False
+        card = {
+            "$schema": "http://adaptivecards.io/schemas/adaptive-card.json",
+            "type": "AdaptiveCard",
+            "version": "1.4",
+            "body": [
+                {"type": "TextBlock", "text": title or DEFAULT_TITLE, "weight": "Bolder", "size": "Medium", "wrap": True},
+                # Adaptive Cards treat single newlines as spaces; double them.
+                {"type": "TextBlock", "text": truncate(message, TEAMS_MAX_LENGTH).replace("\n", "\n\n"), "wrap": True},
+            ],
+        }
+        payload = {
+            "type": "message",
+            "attachments": [{"contentType": "application/vnd.microsoft.card.adaptive", "content": card}],
+        }
+        return http_ok("Teams", "POST", self._url, json=payload, timeout=timeout)

marketmyna/notifiers/telegram.py

@@ -0,0 +1,81 @@
+"""Telegram Bot API notification sender."""
+
+from __future__ import annotations
+
+import html
+import re
+from typing import Optional
+
+import requests
+
+from .base import DEFAULT_TIMEOUT, DEFAULT_TITLE, logger, split_message  # noqa: F401 (re-exported)
+
+TELEGRAM_MAX_LENGTH = 4096
+
+
+class TelegramSender:
+    def __init__(self, config):
+        self._bot_token = getattr(config, "telegram_bot_token", None)
+        # One chat ID, or several comma-separated (e.g. you and a group).
+        raw = str(getattr(config, "telegram_chat_id", None) or "")
+        self._chat_ids = [c.strip() for c in raw.split(",") if c.strip()]
+        # Optional: post into one topic of a forum-style group.
+        self._thread_id = getattr(config, "telegram_message_thread_id", None)
+
+    def is_configured(self) -> bool:
+        return bool(self._bot_token and self._chat_ids)
+
+    def send(self, message: str, title: Optional[str] = None, *, timeout: float = DEFAULT_TIMEOUT) -> bool:
+        if not self.is_configured():
+            return False
+
+        # HTML mode with everything escaped: the title is bold and the body
+        # arrives verbatim (Markdown mode silently ate "_" and "*" in news / AI text).
+        text = f"<b>{html.escape(title or DEFAULT_TITLE)}</b>\n\n{html.escape(message, quote=False)}"
+        # Long reports go out as several messages instead of being cut off.
+        chunks = split_message(text, TELEGRAM_MAX_LENGTH)
+        results = [all(self._send_chunk(chat, chunk, timeout) for chunk in chunks) for chat in self._chat_ids]
+        return all(results)
+
+    def send_document(self, filename: str, data: bytes, caption: Optional[str] = None, *,
+                      timeout: float = 60) -> bool:
+        """A file (e.g. the Smart messaging report PDF) to every chat."""
+        if not self.is_configured():
+            return False
+        url = f"https://api.telegram.org/bot{self._bot_token}/sendDocument"
+        ok = True
+        for chat_id in self._chat_ids:
+            payload = {"chat_id": chat_id}
+            if caption:
+                payload["caption"] = caption[:1024]  # Telegram's caption limit
+            if self._thread_id:
+                payload["message_thread_id"] = int(self._thread_id)
+            try:
+                resp = requests.post(url, data=payload, files={"document": (filename, data)}, timeout=timeout)
+                if resp.status_code != 200:
+                    logger.error("Telegram file to %s failed: HTTP %s %s", chat_id, resp.status_code, resp.text[:200])
+                    ok = False
+            except requests.RequestException as exc:
+                logger.error("Telegram file send failed: %s", exc)
+                ok = False
+        return ok
+
+    def _send_chunk(self, chat_id: str, text: str, timeout: float) -> bool:
+        url = f"https://api.telegram.org/bot{self._bot_token}/sendMessage"
+        payload = {"chat_id": chat_id, "text": text, "parse_mode": "HTML"}
+        if self._thread_id:
+            payload["message_thread_id"] = int(self._thread_id)
+        try:
+            resp = requests.post(url, json=payload, timeout=timeout)
+            if resp.status_code == 400 and "parse" in resp.text.lower():
+                # A chunk boundary split the bold title tag: resend as plain text.
+                payload.pop("parse_mode")
+                payload["text"] = html.unescape(re.sub(r"</?b>", "", text))
+                resp = requests.post(url, json=payload, timeout=timeout)
+            if resp.status_code == 200:
+                return True
+            logger.error("Telegram send to %s failed: HTTP %s %s", chat_id, resp.status_code, resp.text[:200])
+            return False
+        except requests.RequestException as exc:
+            logger.error("Telegram send failed: %s", exc)
+            return False

marketmyna/notifiers/twilio.py

@@ -0,0 +1,33 @@
+"""Twilio sender: SMS, or WhatsApp when the numbers are "whatsapp:+..."."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from .base import DEFAULT_TIMEOUT, DEFAULT_TITLE, http_ok, truncate
+
+# One SMS/WhatsApp message body on Twilio is capped at 1600 characters.
+TWILIO_MAX_LENGTH = 1600
+
+
+class TwilioSender:
+    def __init__(self, config):
+        self._sid = getattr(config, "twilio_account_sid", None)
+        self._token = getattr(config, "twilio_auth_token", None)
+        self._from = getattr(config, "twilio_from", None)
+        self._to = getattr(config, "twilio_to", None) or []
+
+    def is_configured(self) -> bool:
+        return bool(self._sid and self._token and self._from and self._to)
+
+    def send(self, message: str, title: Optional[str] = None, *, timeout: float = DEFAULT_TIMEOUT) -> bool:
+        if not self.is_configured():
+            return False
+        body = truncate(f"{title or DEFAULT_TITLE}\n{message}", TWILIO_MAX_LENGTH)
+        url = f"https://api.twilio.com/2010-04-01/Accounts/{self._sid}/Messages.json"
+        results = [
+            http_ok("Twilio", "POST", url, data={"From": self._from, "To": to, "Body": body},
+                    auth=(self._sid, self._token), timeout=timeout)
+            for to in self._to
+        ]
+        return all(results)

marketmyna/notifiers/webhook.py

@@ -0,0 +1,44 @@
+"""Generic JSON webhook notification sender (fallback for any POST-JSON endpoint)."""
+
+from __future__ import annotations
+
+import json
+from typing import Optional
+
+import requests
+
+from .base import DEFAULT_TIMEOUT, DEFAULT_TITLE, logger
+
+
+class WebhookSender:
+    def __init__(self, config):
+        self._url = getattr(config, "webhook_url", None)
+        self._headers_json = getattr(config, "webhook_headers", None)
+
+    def is_configured(self) -> bool:
+        return bool(self._url)
+
+    def _headers(self) -> dict:
+        if not self._headers_json:
+            return {}
+        try:
+            return json.loads(self._headers_json)
+        except ValueError:
+            logger.error("Webhook headers config is not valid JSON, ignoring")
+            return {}
+
+    def send(self, message: str, title: Optional[str] = None, *, timeout: float = DEFAULT_TIMEOUT) -> bool:
+        if not self.is_configured():
+            return False
+
+        payload = {"title": title or DEFAULT_TITLE, "message": message}
+
+        try:
+            resp = requests.post(self._url, json=payload, headers=self._headers(), timeout=timeout)
+            if 200 <= resp.status_code < 300:
+                return True
+            logger.error("Webhook send failed: HTTP %s %s", resp.status_code, resp.text[:200])
+            return False
+        except requests.RequestException as exc:
+            logger.error("Webhook send failed: %s", exc)
+            return False

marketmyna/notifiers/webpush.py

@@ -0,0 +1,222 @@
+"""Browser push notifications (Web Push) for the MarketMyna web app.
+
+Any browser that opens the app and allows notifications (Chrome, Edge,
+Firefox, Android; Safari/iOS 16.4+ when the app is added to the home
+screen) registers a push subscription; reports and alerts then arrive as
+system notifications even when the tab is closed.
+
+Implemented directly on `cryptography` (already a dependency) instead of
+pywebpush:
+- RFC 8291 message encryption ("aes128gcm" content coding),
+- RFC 8292 VAPID: an ES256-signed JWT that identifies this server to the
+  browser vendor's push service.
+
+The VAPID key pair is generated on first use and kept in the config
+(web_push_vapid_private_key); browsers subscribe against its public key.
+"""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import hmac
+import json
+import os
+import struct
+import time
+from datetime import datetime
+from typing import Optional
+from urllib.parse import urlsplit
+
+from cryptography.hazmat.primitives import hashes, serialization
+from cryptography.hazmat.primitives.asymmetric import ec
+from cryptography.hazmat.primitives.asymmetric.utils import decode_dss_signature
+from cryptography.hazmat.primitives.ciphers.aead import AESGCM
+
+from .base import DEFAULT_TIMEOUT, DEFAULT_TITLE, logger, truncate
+
+# Push services accept ~4 KB payloads; leave room for encryption overhead.
+BODY_MAX_LENGTH = 2800
+RECORD_SIZE = 4096
+DEFAULT_CONTACT = "mailto:marketmyna@localhost"
+
+
+def b64url(data: bytes) -> str:
+    return base64.urlsafe_b64encode(data).rstrip(b"=").decode()
+
+
+def b64url_decode(text: str) -> bytes:
+    return base64.urlsafe_b64decode(text + "=" * (-len(text) % 4))
+
+
+def _public_bytes(key) -> bytes:
+    return key.public_key().public_bytes(serialization.Encoding.X962, serialization.PublicFormat.UncompressedPoint)
+
+
+def _hkdf(salt: bytes, ikm: bytes, info: bytes, length: int) -> bytes:
+    prk = hmac.new(salt, ikm, hashlib.sha256).digest()
+    return hmac.new(prk, info + b"\x01", hashlib.sha256).digest()[:length]
+
+
+# ------------------------------------------------------------------ VAPID
+
+
+def generate_vapid_private_key() -> str:
+    """New P-256 key as base64url of the 32-byte private scalar."""
+    key = ec.generate_private_key(ec.SECP256R1())
+    return b64url(key.private_numbers().private_value.to_bytes(32, "big"))
+
+
+def load_vapid_key(private_b64: str):
+    value = int.from_bytes(b64url_decode(private_b64), "big")
+    return ec.derive_private_key(value, ec.SECP256R1())
+
+
+def vapid_public_key(private_b64: str) -> str:
+    """The applicationServerKey browsers subscribe with."""
+    return b64url(_public_bytes(load_vapid_key(private_b64)))
+
+
+def vapid_authorization(endpoint: str, private_b64: str, contact: str, now: Optional[float] = None) -> str:
+    key = load_vapid_key(private_b64)
+    parts = urlsplit(endpoint)
+    claims = {
+        "aud": f"{parts.scheme}://{parts.netloc}",
+        "exp": int((now or time.time()) + 12 * 3600),
+        "sub": contact if contact.startswith(("mailto:", "https://")) else f"mailto:{contact}",
+    }
+    signing_input = (
+        b64url(json.dumps({"typ": "JWT", "alg": "ES256"}, separators=(",", ":")).encode())
+        + "."
+        + b64url(json.dumps(claims, separators=(",", ":")).encode())
+    )
+    r, s = decode_dss_signature(key.sign(signing_input.encode(), ec.ECDSA(hashes.SHA256())))
+    token = f"{signing_input}.{b64url(r.to_bytes(32, 'big') + s.to_bytes(32, 'big'))}"
+    return f"vapid t={token}, k={b64url(_public_bytes(key))}"
+
+
+# ------------------------------------------------------------- encryption
+
+
+def encrypt(payload: bytes, p256dh: str, auth: str, *, salt: Optional[bytes] = None,
+            server_key=None) -> bytes:
+    """RFC 8291 aes128gcm body for one subscription (salt/server_key are
+    injectable only so tests can reproduce the RFC's example vector)."""
+    ua_public = b64url_decode(p256dh)
+    auth_secret = b64url_decode(auth)
+    server_key = server_key or ec.generate_private_key(ec.SECP256R1())
+    as_public = _public_bytes(server_key)
+    ua_key = ec.EllipticCurvePublicKey.from_encoded_point(ec.SECP256R1(), ua_public)
+    shared = server_key.exchange(ec.ECDH(), ua_key)
+
+    ikm = _hkdf(auth_secret, shared, b"WebPush: info\x00" + ua_public + as_public, 32)
+    salt = salt or os.urandom(16)
+    cek = _hkdf(salt, ikm, b"Content-Encoding: aes128gcm\x00", 16)
+    nonce = _hkdf(salt, ikm, b"Content-Encoding: nonce\x00", 12)
+
+    # Single record: payload + 0x02 end-of-record delimiter.
+    ciphertext = AESGCM(cek).encrypt(nonce, payload + b"\x02", None)
+    header = salt + struct.pack("!IB", RECORD_SIZE, len(as_public)) + as_public
+    return header + ciphertext
+
+
+# ----------------------------------------------------------------- sender
+
+
+def ensure_vapid_key(config) -> str:
+    """The server's VAPID private key, generating and saving one if needed."""
+    key = getattr(config, "web_push_vapid_private_key", None)
+    if not key:
+        key = generate_vapid_private_key()
+        config.web_push_vapid_private_key = key
+        try:
+            config.save()
+        except Exception as exc:  # the key still works for this process
+            logger.warning("Could not persist VAPID key: %s", exc)
+    return key
+
+
+def _db(config):
+    from ..storage import DatabaseManager, get_db_url
+
+    return DatabaseManager.instance(get_db_url(config=config))
+
+
+class WebPushSender:
+    def __init__(self, config):
+        self._config = config
+
+    def _subscriptions(self) -> list:
+        from ..storage import WebPushSubscriptionRecord, has_app_db
+
+        if not getattr(self._config, "web_push_vapid_private_key", None):
+            return []
+        try:
+            if not has_app_db(self._config):
+                return []
+            with _db(self._config).get_session() as session:
+                return [
+                    (r.id, r.endpoint, r.p256dh, r.auth)
+                    for r in session.query(WebPushSubscriptionRecord).all()
+                ]
+        except Exception as exc:
+            logger.warning("Web push subscriptions unreadable: %s", exc)
+            return []
+
+    def is_configured(self) -> bool:
+        return bool(self._subscriptions())
+
+    def send(self, message: str, title: Optional[str] = None, *, timeout: float = DEFAULT_TIMEOUT,
+             url: str = "/scheduler") -> bool:
+        import requests
+
+        from ..storage import WebPushSubscriptionRecord
+
+        subs = self._subscriptions()
+        if not subs:
+            return False
+        key = self._config.web_push_vapid_private_key
+        contact = getattr(self._config, "web_push_contact", None) or DEFAULT_CONTACT
+        payload = json.dumps({
+            "title": title or DEFAULT_TITLE,
+            "body": truncate(message, BODY_MAX_LENGTH),
+            "url": url,
+            "tag": f"marketmyna-{int(time.time())}",
+        }).encode()
+
+        delivered, gone = [], []
+        for sub_id, endpoint, p256dh, auth in subs:
+            try:
+                resp = requests.post(
+                    endpoint,
+                    data=encrypt(payload, p256dh, auth),
+                    headers={
+                        "Authorization": vapid_authorization(endpoint, key, contact),
+                        "Content-Encoding": "aes128gcm",
+                        "Content-Type": "application/octet-stream",
+                        "TTL": "86400",
+                        "Urgency": "normal",
+                    },
+                    timeout=timeout,
+                )
+            except Exception as exc:
+                logger.error("Web push to %s failed: %s", urlsplit(endpoint).netloc, exc)
+                continue
+            if resp.status_code in (404, 410):
+                gone.append(sub_id)  # browser unsubscribed or expired
+            elif 200 <= resp.status_code < 300:
+                delivered.append(sub_id)
+            else:
+                logger.error("Web push to %s failed: HTTP %s %s", urlsplit(endpoint).netloc,
+                             resp.status_code, resp.text[:200])
+
+        if delivered or gone:
+            with _db(self._config).get_session() as session:
+                if gone:
+                    session.query(WebPushSubscriptionRecord).filter(WebPushSubscriptionRecord.id.in_(gone)).delete(
+                        synchronize_session=False)
+                if delivered:
+                    session.query(WebPushSubscriptionRecord).filter(
+                        WebPushSubscriptionRecord.id.in_(delivered)).update(
+                        {"last_success_at": datetime.now()}, synchronize_session=False)
+        return bool(delivered)

marketmyna/notifiers/wechat.py

@@ -0,0 +1,40 @@
+"""WeChat Work (WeCom) group robot webhook notification sender."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import requests
+
+from .base import DEFAULT_TIMEOUT, DEFAULT_TITLE, logger, split_message, utf8_len
+
+WECHAT_MAX_LENGTH = 4000  # WeCom counts UTF-8 bytes (limit 4096)
+
+
+class WechatSender:
+    def __init__(self, config):
+        self._webhook_url = getattr(config, "wechat_webhook_url", None)
+
+    def is_configured(self) -> bool:
+        return bool(self._webhook_url)
+
+    def send(self, message: str, title: Optional[str] = None, *, timeout: float = DEFAULT_TIMEOUT) -> bool:
+        if not self.is_configured():
+            return False
+
+        # The limit is in bytes; emoji and Chinese take 3-4 each, so split by bytes.
+        chunks = split_message(f"**{title or DEFAULT_TITLE}**\n{message}", WECHAT_MAX_LENGTH, measure=utf8_len)
+        return all(self._post(chunk, timeout) for chunk in chunks)
+
+    def _post(self, text: str, timeout: float) -> bool:
+        payload = {"msgtype": "markdown", "markdown": {"content": text}}
+        try:
+            resp = requests.post(self._webhook_url, json=payload, timeout=timeout)
+            result = resp.json()
+            if result.get("errcode") == 0:
+                return True
+            logger.error("WeChat Work send failed: %s", result)
+            return False
+        except (requests.RequestException, ValueError) as exc:
+            logger.error("WeChat Work send failed: %s", exc)
+            return False

marketmyna/notifiers/whatsapp.py

@@ -0,0 +1,27 @@
+"""WhatsApp via CallMeBot - free for personal use: message +34 644 51 95 23
+"I allow callmebot to send me messages" on WhatsApp to get an API key."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from .base import DEFAULT_TIMEOUT, DEFAULT_TITLE, http_ok, truncate
+
+# CallMeBot passes the text in the URL; keep it well under URL limits.
+CALLMEBOT_MAX_LENGTH = 1500
+
+
+class WhatsAppSender:
+    def __init__(self, config):
+        self._phone = getattr(config, "whatsapp_phone", None)
+        self._api_key = getattr(config, "whatsapp_callmebot_apikey", None)
+
+    def is_configured(self) -> bool:
+        return bool(self._phone and self._api_key)
+
+    def send(self, message: str, title: Optional[str] = None, *, timeout: float = DEFAULT_TIMEOUT) -> bool:
+        if not self.is_configured():
+            return False
+        text = truncate(f"*{title or DEFAULT_TITLE}*\n{message}", CALLMEBOT_MAX_LENGTH)
+        params = {"phone": self._phone.replace(" ", ""), "text": text, "apikey": self._api_key}
+        return http_ok("WhatsApp", "GET", "https://api.callmebot.com/whatsapp.php", params=params, timeout=timeout)