marketmyna 0.2.0__py3-none-any.whl

marketmyna/notifiers/dispatcher.py

@@ -0,0 +1,153 @@
+"""Fan-out dispatcher that sends a message to every configured channel."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from .apprise_sender import AppriseSender
+from .astrbot import AstrbotSender
+from .bark import BarkSender
+from .base import logger
+from .dingtalk import DingtalkSender
+from .discord import DiscordSender
+from .email import EmailSender
+from .feishu import FeishuSender
+from .googlechat import GoogleChatSender
+from .gotify import GotifySender
+from .matrix import MatrixSender
+from .ntfy import NtfySender
+from .pushbullet import PushbulletSender
+from .pushover import PushoverSender
+from .pushplus import PushplusSender
+from .serverchan3 import Serverchan3Sender
+from .signal_messenger import SignalSender
+from .slack import SlackSender
+from .teams import TeamsSender
+from .telegram import TelegramSender
+from .twilio import TwilioSender
+from .webhook import WebhookSender
+from .webpush import WebPushSender
+from .wechat import WechatSender
+from .whatsapp import WhatsAppSender
+
+# Message purposes and the Config field that routes each one.
+PURPOSES = {
+    "report": "notification_report_channels",
+    "alert": "notification_alert_channels",
+    "system_error": "notification_system_error_channels",
+}
+
+
+class NotificationDispatcher:
+    """Owns one instance of every sender and fans a message out to all configured ones."""
+
+    def __init__(self, config):
+        self._config = config
+        self._senders = {
+            "telegram": TelegramSender(config),
+            "discord": DiscordSender(config),
+            "slack": SlackSender(config),
+            "email": EmailSender(config),
+            "dingtalk": DingtalkSender(config),
+            "feishu": FeishuSender(config),
+            "wechat": WechatSender(config),
+            "pushover": PushoverSender(config),
+            "ntfy": NtfySender(config),
+            "gotify": GotifySender(config),
+            "pushplus": PushplusSender(config),
+            "serverchan3": Serverchan3Sender(config),
+            "astrbot": AstrbotSender(config),
+            "webhook": WebhookSender(config),
+            "webpush": WebPushSender(config),
+            "whatsapp": WhatsAppSender(config),
+            "twilio": TwilioSender(config),
+            "teams": TeamsSender(config),
+            "googlechat": GoogleChatSender(config),
+            "matrix": MatrixSender(config),
+            "signal": SignalSender(config),
+            "bark": BarkSender(config),
+            "pushbullet": PushbulletSender(config),
+            "apprise": AppriseSender(config),
+        }
+
+    def channel_names(self) -> list[str]:
+        return list(self._senders)
+
+    def configured_channels(self, purpose: Optional[str] = None) -> list[str]:
+        """Configured channels, narrowed to the ones routed for `purpose`
+        ("report", "alert", "system_error") when a route is set."""
+        configured = [name for name, sender in self._senders.items() if sender.is_configured()]
+        route = getattr(self._config, PURPOSES[purpose], None) if purpose in PURPOSES else None
+        if route:
+            wanted = {str(name).strip().lower() for name in route}
+            configured = [name for name in configured if name in wanted]
+        return configured
+
+    # In accounts mode a normal user's messages may only reach their own
+    # devices: web push (subscriptions are user-scoped) and their linked
+    # Telegram chats. The owner's channels in config.json are the owner's.
+    USER_CHANNELS = ("webpush",)
+
+    def _owner_channels_allowed(self) -> bool:
+        from ..services.accounts import is_owner_scope
+
+        try:
+            return is_owner_scope(self._config)
+        except Exception:
+            logger.exception("Could not resolve the platform owner; using user channels only")
+            return False
+
+    def _sender_for(self, name: str, purpose: Optional[str]):
+        """The channel's sender; reports and alerts by email come from the reports address."""
+        from ..services.accounts import report_sender
+
+        from_address = report_sender(self._config, purpose) if name == "email" else None
+        return EmailSender(self._config, from_address=from_address) if from_address else self._senders.get(name)
+
+    def send_all(self, message: str, title: Optional[str] = None, purpose: Optional[str] = None) -> dict[str, bool]:
+        results: dict[str, bool] = {}
+        if purpose == "system_error" or self._owner_channels_allowed():  # system errors are for the owner
+            allowed = set(self.configured_channels(purpose))
+        else:
+            allowed = {n for n in self.USER_CHANNELS if self._senders[n].is_configured()}
+        for name, sender in self._senders.items():
+            if name not in allowed:
+                continue
+            sender = self._sender_for(name, purpose)
+            try:
+                results[name] = bool(sender.send(message, title=title))
+            except Exception as exc:  # a channel must never take the others down with it
+                logger.error("Notifier %s raised unexpectedly: %s", name, exc)
+                results[name] = False
+        return results
+
+    def send_each(self, messages: dict[str, tuple], purpose: Optional[str] = None,
+                  files: Optional[dict[str, list[tuple[str, bytes]]]] = None) -> dict[str, bool]:
+        """Send each channel its own (title, message[, html]) - e.g. the same
+        report in the language that channel's reader prefers. The optional
+        html body is only used by email. files: "email" / "telegram" ->
+        (filename, bytes) pairs, attached to the email and sent as Telegram
+        documents. Unknown or unconfigured channels are skipped."""
+        files = files or {}
+        results: dict[str, bool] = {}
+        owner = self._owner_channels_allowed()
+        for name, payload in messages.items():
+            title, message = payload[0], payload[1]
+            html = payload[2] if len(payload) > 2 else None
+            sender = self._sender_for(name, purpose)
+            if sender is None or not sender.is_configured():
+                continue
+            if not owner and name not in self.USER_CHANNELS:
+                continue
+            try:
+                if name == "email" and (html or files.get("email")):
+                    results[name] = bool(sender.send(message, title=title, html=html, attachments=files.get("email")))
+                else:
+                    results[name] = bool(sender.send(message, title=title))
+                if name == "telegram" and results[name]:
+                    for filename, data in files.get("telegram") or []:
+                        results[name] = sender.send_document(filename, data) and results[name]
+            except Exception as exc:
+                logger.error("Notifier %s raised unexpectedly: %s", name, exc)
+                results[name] = False
+        return results

marketmyna/notifiers/email.py

@@ -0,0 +1,99 @@
+"""SMTP email notification sender."""
+
+from __future__ import annotations
+
+import smtplib
+from email.mime.application import MIMEApplication
+from email.mime.multipart import MIMEMultipart
+from email.mime.text import MIMEText
+from email.utils import formataddr
+from typing import Optional
+
+from .base import DEFAULT_TIMEOUT, DEFAULT_TITLE, logger
+
+SMTP_PRESETS = {
+    "qq.com": ("smtp.qq.com", 465, True),
+    "foxmail.com": ("smtp.qq.com", 465, True),
+    "163.com": ("smtp.163.com", 465, True),
+    "126.com": ("smtp.126.com", 465, True),
+    "gmail.com": ("smtp.gmail.com", 587, False),
+    "outlook.com": ("smtp-mail.outlook.com", 587, False),
+    "hotmail.com": ("smtp-mail.outlook.com", 587, False),
+}
+
+
+
+# Attachment file extension -> MIME subtype (application/...).
+ATTACHMENT_TYPES = {"pdf": "pdf", "xlsx": "vnd.openxmlformats-officedocument.spreadsheetml.sheet"}
+
+class EmailSender:
+    def __init__(self, config, from_address: Optional[str] = None, from_name: Optional[str] = None):
+        self._sender = getattr(config, "email_sender", None)
+        # Logs in as email_username (or the sender); sends as from_address if given.
+        self._login = getattr(config, "email_username", None) or self._sender
+        self._from = from_address or self._sender
+        self._from_name = from_name or DEFAULT_TITLE
+        self._password = getattr(config, "email_password", None)
+        self._receivers = getattr(config, "email_receivers", None) or (
+            [self._sender] if self._sender else []
+        )
+        self._smtp_server = getattr(config, "email_smtp_server", None)
+        self._smtp_port = getattr(config, "email_smtp_port", None)
+        self._smtp_ssl = getattr(config, "email_smtp_ssl", None)
+
+    def is_configured(self) -> bool:
+        return bool(self._sender and self._login and self._password and self._receivers)
+
+    def send(self, message: str, title: Optional[str] = None, *, timeout: float = DEFAULT_TIMEOUT,
+             html: Optional[str] = None, attachments: Optional[list[tuple[str, bytes]]] = None) -> bool:
+        """attachments: (filename, bytes) pairs; the type comes from the extension (PDF, Excel)."""
+        if not self.is_configured():
+            return False
+
+        subject = title or DEFAULT_TITLE
+        domain = self._login.split("@")[-1].lower()
+        server_host, port, use_ssl = SMTP_PRESETS.get(domain, (None, None, None))
+        server_host = self._smtp_server or server_host or f"smtp.{domain}"
+        port = self._smtp_port or port or 465
+        use_ssl = self._smtp_ssl if self._smtp_ssl is not None else (use_ssl if use_ssl is not None else True)
+
+        body = MIMEMultipart("alternative")
+        body.attach(MIMEText(message, "plain", "utf-8"))
+        if html:
+            # multipart/alternative: mail apps show the HTML table, others the text.
+            body.attach(MIMEText(html, "html", "utf-8"))
+        if attachments:
+            msg = MIMEMultipart("mixed")
+            msg.attach(body)
+            for name, data in attachments:
+                part = MIMEApplication(data, _subtype=ATTACHMENT_TYPES.get(name.rsplit(".", 1)[-1].lower(), "octet-stream"))
+                part.add_header("Content-Disposition", "attachment", filename=name)
+                msg.attach(part)
+        else:
+            msg = body
+        msg["Subject"] = subject
+        msg["From"] = formataddr((self._from_name, self._from))
+        msg["To"] = ", ".join(self._receivers)
+
+        server = None
+        try:
+            if use_ssl:
+                server = smtplib.SMTP_SSL(server_host, port, timeout=timeout)
+            else:
+                server = smtplib.SMTP(server_host, port, timeout=timeout)
+                server.starttls()
+            server.login(self._login, self._password)
+            server.send_message(msg)
+            return True
+        except smtplib.SMTPException as exc:
+            logger.error("Email send failed: %s", exc)
+            return False
+        except OSError as exc:
+            logger.error("Email send failed: %s", exc)
+            return False
+        finally:
+            if server is not None:
+                try:
+                    server.quit()
+                except Exception:
+                    pass

marketmyna/notifiers/feishu.py

@@ -0,0 +1,57 @@
+"""Feishu/Lark custom bot webhook notification sender."""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import hmac
+import time
+from typing import Optional
+
+import requests
+
+from .base import DEFAULT_TIMEOUT, DEFAULT_TITLE, logger, truncate
+
+FEISHU_MAX_LENGTH = 19000
+
+
+class FeishuSender:
+    def __init__(self, config):
+        self._webhook_url = getattr(config, "feishu_webhook_url", None)
+        self._secret = getattr(config, "feishu_webhook_secret", None)
+
+    def is_configured(self) -> bool:
+        return bool(self._webhook_url)
+
+    def _security_fields(self) -> dict:
+        if not self._secret:
+            return {}
+        timestamp = str(int(time.time()))
+        string_to_sign = f"{timestamp}\n{self._secret}"
+        sign = base64.b64encode(
+            hmac.new(string_to_sign.encode("utf-8"), digestmod=hashlib.sha256).digest()
+        ).decode("utf-8")
+        return {"timestamp": timestamp, "sign": sign}
+
+    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\n{message}", FEISHU_MAX_LENGTH)
+        payload = {"msg_type": "text", "content": {"text": text}}
+        payload.update(self._security_fields())
+
+        try:
+            resp = requests.post(self._webhook_url, json=payload, timeout=timeout)
+            if resp.status_code != 200:
+                logger.error("Feishu send failed: HTTP %s", resp.status_code)
+                return False
+            result = resp.json()
+            code = result.get("code", result.get("StatusCode"))
+            if code == 0:
+                return True
+            logger.error("Feishu send failed: %s", result)
+            return False
+        except (requests.RequestException, ValueError) as exc:
+            logger.error("Feishu send failed: %s", exc)
+            return False

marketmyna/notifiers/googlechat.py

@@ -0,0 +1,24 @@
+"""Google Chat space incoming-webhook sender."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from .base import DEFAULT_TIMEOUT, DEFAULT_TITLE, http_ok, split_message
+
+GOOGLE_CHAT_MAX_LENGTH = 4000
+
+
+class GoogleChatSender:
+    def __init__(self, config):
+        self._url = getattr(config, "google_chat_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
+        # Long reports go out as several messages instead of being cut off.
+        chunks = split_message(f"*{title or DEFAULT_TITLE}*\n{message}", GOOGLE_CHAT_MAX_LENGTH)
+        return all(http_ok("Google Chat", "POST", self._url, json={"text": c}, timeout=timeout) for c in chunks)

marketmyna/notifiers/gotify.py

@@ -0,0 +1,36 @@
+"""Gotify self-hosted push notification sender."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import requests
+
+from .base import DEFAULT_TIMEOUT, DEFAULT_TITLE, logger
+
+
+class GotifySender:
+    def __init__(self, config):
+        self._url = getattr(config, "gotify_url", None)
+        self._token = getattr(config, "gotify_token", None)
+
+    def is_configured(self) -> bool:
+        return bool(self._url and self._token)
+
+    def send(self, message: str, title: Optional[str] = None, *, timeout: float = DEFAULT_TIMEOUT) -> bool:
+        if not self.is_configured():
+            return False
+
+        endpoint = f"{self._url.rstrip('/')}/message"
+        headers = {"X-Gotify-Key": self._token}
+        payload = {"title": title or DEFAULT_TITLE, "message": message}
+
+        try:
+            resp = requests.post(endpoint, json=payload, headers=headers, timeout=timeout)
+            if 200 <= resp.status_code < 300:
+                return True
+            logger.error("Gotify send failed: HTTP %s %s", resp.status_code, resp.text[:200])
+            return False
+        except requests.RequestException as exc:
+            logger.error("Gotify send failed: %s", exc)
+            return False

marketmyna/notifiers/matrix.py

@@ -0,0 +1,28 @@
+"""Matrix room sender (any homeserver, e.g. matrix.org or Element)."""
+
+from __future__ import annotations
+
+import time
+import uuid
+from typing import Optional
+from urllib.parse import quote
+
+from .base import DEFAULT_TIMEOUT, DEFAULT_TITLE, http_ok
+
+
+class MatrixSender:
+    def __init__(self, config):
+        self._homeserver = (getattr(config, "matrix_homeserver", None) or "").rstrip("/")
+        self._token = getattr(config, "matrix_access_token", None)
+        self._room = getattr(config, "matrix_room_id", None)
+
+    def is_configured(self) -> bool:
+        return bool(self._homeserver and self._token and self._room)
+
+    def send(self, message: str, title: Optional[str] = None, *, timeout: float = DEFAULT_TIMEOUT) -> bool:
+        if not self.is_configured():
+            return False
+        txn = f"marketmyna-{int(time.time())}-{uuid.uuid4().hex[:8]}"
+        url = f"{self._homeserver}/_matrix/client/v3/rooms/{quote(self._room, safe='')}/send/m.room.message/{txn}"
+        body = {"msgtype": "m.text", "body": f"{title or DEFAULT_TITLE}\n\n{message}"}
+        return http_ok("Matrix", "PUT", url, json=body, headers={"Authorization": f"Bearer {self._token}"}, timeout=timeout)

marketmyna/notifiers/ntfy.py

@@ -0,0 +1,36 @@
+"""ntfy.sh (or self-hosted) topic notification sender."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import requests
+
+from .base import DEFAULT_TIMEOUT, DEFAULT_TITLE, logger
+
+
+class NtfySender:
+    def __init__(self, config):
+        self._url = getattr(config, "ntfy_url", None)
+        self._token = getattr(config, "ntfy_token", 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
+
+        headers = {"X-Title": title or DEFAULT_TITLE}
+        if self._token:
+            headers["Authorization"] = f"Bearer {self._token}"
+
+        try:
+            resp = requests.post(self._url, data=message.encode("utf-8"), headers=headers, timeout=timeout)
+            if 200 <= resp.status_code < 300:
+                return True
+            logger.error("ntfy send failed: HTTP %s %s", resp.status_code, resp.text[:200])
+            return False
+        except requests.RequestException as exc:
+            logger.error("ntfy send failed: %s", exc)
+            return False

marketmyna/notifiers/pushbullet.py

@@ -0,0 +1,24 @@
+"""Pushbullet sender: push to your phones and browsers."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from .base import DEFAULT_TIMEOUT, DEFAULT_TITLE, http_ok
+
+
+class PushbulletSender:
+    def __init__(self, config):
+        self._token = getattr(config, "pushbullet_token", None)
+
+    def is_configured(self) -> bool:
+        return bool(self._token)
+
+    def send(self, message: str, title: Optional[str] = None, *, timeout: float = DEFAULT_TIMEOUT) -> bool:
+        if not self.is_configured():
+            return False
+        return http_ok(
+            "Pushbullet", "POST", "https://api.pushbullet.com/v2/pushes",
+            json={"type": "note", "title": title or DEFAULT_TITLE, "body": message},
+            headers={"Access-Token": self._token}, timeout=timeout,
+        )

marketmyna/notifiers/pushover.py

@@ -0,0 +1,41 @@
+"""Pushover notification sender."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import requests
+
+from .base import DEFAULT_TIMEOUT, DEFAULT_TITLE, logger, truncate
+
+PUSHOVER_MAX_LENGTH = 1024
+
+
+class PushoverSender:
+    def __init__(self, config):
+        self._user_key = getattr(config, "pushover_user_key", None)
+        self._api_token = getattr(config, "pushover_api_token", None)
+
+    def is_configured(self) -> bool:
+        return bool(self._user_key and self._api_token)
+
+    def send(self, message: str, title: Optional[str] = None, *, timeout: float = DEFAULT_TIMEOUT) -> bool:
+        if not self.is_configured():
+            return False
+
+        payload = {
+            "token": self._api_token,
+            "user": self._user_key,
+            "message": truncate(message, PUSHOVER_MAX_LENGTH),
+            "title": title or DEFAULT_TITLE,
+        }
+
+        try:
+            resp = requests.post("https://api.pushover.net/1/messages.json", data=payload, timeout=timeout)
+            if resp.status_code == 200 and resp.json().get("status") == 1:
+                return True
+            logger.error("Pushover send failed: HTTP %s %s", resp.status_code, resp.text[:200])
+            return False
+        except (requests.RequestException, ValueError) as exc:
+            logger.error("Pushover send failed: %s", exc)
+            return False

marketmyna/notifiers/pushplus.py

@@ -0,0 +1,41 @@
+"""PushPlus (pushplus.plus) notification sender."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import requests
+
+from .base import DEFAULT_TIMEOUT, DEFAULT_TITLE, logger
+
+
+class PushplusSender:
+    def __init__(self, config):
+        self._token = getattr(config, "pushplus_token", None)
+        self._topic = getattr(config, "pushplus_topic", None)
+
+    def is_configured(self) -> bool:
+        return bool(self._token)
+
+    def send(self, message: str, title: Optional[str] = None, *, timeout: float = DEFAULT_TIMEOUT) -> bool:
+        if not self.is_configured():
+            return False
+
+        payload = {
+            "token": self._token,
+            "title": title or DEFAULT_TITLE,
+            "content": message,
+            "template": "markdown",
+        }
+        if self._topic:
+            payload["topic"] = self._topic
+
+        try:
+            resp = requests.post("http://www.pushplus.plus/send", json=payload, timeout=timeout)
+            if resp.status_code == 200 and resp.json().get("code") == 200:
+                return True
+            logger.error("PushPlus send failed: HTTP %s %s", resp.status_code, resp.text[:200])
+            return False
+        except (requests.RequestException, ValueError) as exc:
+            logger.error("PushPlus send failed: %s", exc)
+            return False

marketmyna/notifiers/serverchan3.py

@@ -0,0 +1,40 @@
+"""Server酱³ (ServerChan3, sctapi.ftqq.com) notification sender."""
+
+from __future__ import annotations
+
+import re
+from typing import Optional
+
+import requests
+
+from .base import DEFAULT_TIMEOUT, DEFAULT_TITLE, logger
+
+
+class Serverchan3Sender:
+    def __init__(self, config):
+        self._sendkey = getattr(config, "serverchan3_sendkey", None)
+
+    def is_configured(self) -> bool:
+        return bool(self._sendkey)
+
+    def _endpoint(self) -> str:
+        match = re.match(r"sctp(\d+)t", self._sendkey)
+        if match:
+            return f"https://{match.group(1)}.push.ft07.com/send/{self._sendkey}.send"
+        return f"https://sctapi.ftqq.com/{self._sendkey}.send"
+
+    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, "desp": message}
+
+        try:
+            resp = requests.post(self._endpoint(), json=payload, timeout=timeout)
+            if resp.status_code == 200:
+                return True
+            logger.error("ServerChan3 send failed: HTTP %s %s", resp.status_code, resp.text[:200])
+            return False
+        except requests.RequestException as exc:
+            logger.error("ServerChan3 send failed: %s", exc)
+            return False