myappnotify 0.1.0__tar.gz

myappnotify-0.1.0/PKG-INFO

@@ -0,0 +1,38 @@
+Metadata-Version: 2.4
+Name: myappnotify
+Version: 0.1.0
+Summary: DingTalk + Gotify markdown notification helpers
+License-Expression: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# myappnotify
+
+DingTalk robot + Gotify push helpers (stdlib only).
+
+## Install
+
+```bash
+pip install myappnotify
+```
+
+## Env
+
+| Variable | Channel |
+|----------|---------|
+| `DINGDING_WEB_HOOK_TOKEN` / `DINGDING_BOT_SIGN` | DingTalk |
+| `GOTIFY_URL` / `GOTIFY_TOKEN` | Gotify |
+
+Missing config skips that channel and logs; never raises.
+
+## Usage
+
+```python
+from myappnotify import send_dingtalk, send_gotify, notify
+
+send_dingtalk("Title", "## body")
+send_gotify("Title", "## body")  # markdown via client::display
+
+# Fan-out; optional Gotify-specific body (e.g. GFM tables)
+notify("选股结果", dingtalk_md, gotify_text=gotify_table_md)
+```

myappnotify-0.1.0/README.md

@@ -0,0 +1,30 @@
+# myappnotify
+
+DingTalk robot + Gotify push helpers (stdlib only).
+
+## Install
+
+```bash
+pip install myappnotify
+```
+
+## Env
+
+| Variable | Channel |
+|----------|---------|
+| `DINGDING_WEB_HOOK_TOKEN` / `DINGDING_BOT_SIGN` | DingTalk |
+| `GOTIFY_URL` / `GOTIFY_TOKEN` | Gotify |
+
+Missing config skips that channel and logs; never raises.
+
+## Usage
+
+```python
+from myappnotify import send_dingtalk, send_gotify, notify
+
+send_dingtalk("Title", "## body")
+send_gotify("Title", "## body")  # markdown via client::display
+
+# Fan-out; optional Gotify-specific body (e.g. GFM tables)
+notify("选股结果", dingtalk_md, gotify_text=gotify_table_md)
+```

myappnotify-0.1.0/myappnotify/__init__.py

@@ -0,0 +1,37 @@
+"""myappnotify — DingTalk + Gotify markdown notifications."""
+
+from __future__ import annotations
+
+import logging
+from typing import Iterable, Optional
+
+from myappnotify.dingtalk import send_dingtalk
+from myappnotify.gotify import send_gotify
+
+__all__ = ["send_dingtalk", "send_gotify", "notify"]
+__version__ = "0.1.0"
+
+log = logging.getLogger("myappnotify")
+
+
+def notify(
+    title: str,
+    text: str,
+    *,
+    gotify_text: Optional[str] = None,
+    channels: Iterable[str] = ("dingtalk", "gotify"),
+) -> dict:
+    """Send to configured channels. Missing credentials skip that channel.
+
+    If ``gotify_text`` is set, Gotify uses it while DingTalk still uses ``text``.
+    """
+    results = {}
+    for ch in channels:
+        if ch == "dingtalk":
+            results["dingtalk"] = send_dingtalk(title, text)
+        elif ch == "gotify":
+            results["gotify"] = send_gotify(title, gotify_text if gotify_text is not None else text)
+        else:
+            log.error("unknown notify channel: %s", ch)
+            results[ch] = False
+    return results

myappnotify-0.1.0/myappnotify/dingtalk.py

@@ -0,0 +1,61 @@
+"""DingTalk group robot markdown push."""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import hmac
+import json
+import logging
+import os
+import time
+import urllib.parse
+import urllib.request
+from typing import Optional
+
+log = logging.getLogger("myappnotify.dingtalk")
+
+DINGDING_WEBHOOK = "https://oapi.dingtalk.com/robot/send"
+
+
+def send_dingtalk(
+    title: str,
+    text: str,
+    *,
+    token: Optional[str] = None,
+    secret: Optional[str] = None,
+) -> bool:
+    """Push markdown to DingTalk. Missing config or failure returns False, never raises."""
+    token = (token if token is not None else os.environ.get("DINGDING_WEB_HOOK_TOKEN", "")).strip()
+    secret = (secret if secret is not None else os.environ.get("DINGDING_BOT_SIGN", "")).strip()
+    if not token or not secret:
+        log.error("DingTalk not configured (DINGDING_WEB_HOOK_TOKEN/DINGDING_BOT_SIGN), skip")
+        return False
+
+    ts = str(round(time.time() * 1000))
+    string_to_sign = "{}\n{}".format(ts, secret)
+    hmac_code = hmac.new(
+        secret.encode("utf-8"), string_to_sign.encode("utf-8"), digestmod=hashlib.sha256
+    ).digest()
+    sign = urllib.parse.quote_plus(base64.b64encode(hmac_code))
+    url = "{}?access_token={}&timestamp={}&sign={}".format(
+        DINGDING_WEBHOOK, token, ts, sign
+    )
+    payload = json.dumps(
+        {"msgtype": "markdown", "markdown": {"title": title, "text": text}}
+    ).encode("utf-8")
+    try:
+        req = urllib.request.Request(
+            url,
+            data=payload,
+            headers={"Content-Type": "application/json", "User-Agent": "Mozilla/5.0"},
+        )
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            result = json.loads(resp.read().decode("utf-8", "ignore"))
+        if result.get("errcode") == 0:
+            log.info("DingTalk push ok")
+            return True
+        log.error("DingTalk push failed: %s", result)
+    except Exception as e:
+        log.error("DingTalk push failed: %s", e)
+    return False

myappnotify-0.1.0/myappnotify/gotify.py

@@ -0,0 +1,57 @@
+"""Gotify application message push (markdown)."""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import urllib.request
+from typing import Optional
+
+log = logging.getLogger("myappnotify.gotify")
+
+
+def send_gotify(
+    title: str,
+    text: str,
+    *,
+    url: Optional[str] = None,
+    token: Optional[str] = None,
+    priority: int = 5,
+) -> bool:
+    """Push markdown to Gotify. Missing config or failure returns False, never raises."""
+    base = (url if url is not None else os.environ.get("GOTIFY_URL", "")).strip().rstrip("/")
+    token = (token if token is not None else os.environ.get("GOTIFY_TOKEN", "")).strip()
+    if not base or not token:
+        log.error("Gotify not configured (GOTIFY_URL/GOTIFY_TOKEN), skip")
+        return False
+
+    endpoint = base + "/message"
+    payload = json.dumps(
+        {
+            "title": title,
+            "message": text,
+            "priority": priority,
+            "extras": {"client::display": {"contentType": "text/markdown"}},
+        }
+    ).encode("utf-8")
+    try:
+        req = urllib.request.Request(
+            endpoint,
+            data=payload,
+            headers={
+                "Content-Type": "application/json",
+                "X-Gotify-Key": token,
+                "User-Agent": "Mozilla/5.0",
+            },
+        )
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            body = resp.read().decode("utf-8", "ignore")
+            status = getattr(resp, "status", None) or resp.getcode()
+        if 200 <= int(status) < 300:
+            log.info("Gotify push ok")
+            return True
+        log.error("Gotify push failed: status=%s body=%s", status, body)
+    except Exception as e:
+        log.error("Gotify push failed: %s", e)
+    return False

myappnotify-0.1.0/myappnotify.egg-info/PKG-INFO

@@ -0,0 +1,38 @@
+Metadata-Version: 2.4
+Name: myappnotify
+Version: 0.1.0
+Summary: DingTalk + Gotify markdown notification helpers
+License-Expression: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# myappnotify
+
+DingTalk robot + Gotify push helpers (stdlib only).
+
+## Install
+
+```bash
+pip install myappnotify
+```
+
+## Env
+
+| Variable | Channel |
+|----------|---------|
+| `DINGDING_WEB_HOOK_TOKEN` / `DINGDING_BOT_SIGN` | DingTalk |
+| `GOTIFY_URL` / `GOTIFY_TOKEN` | Gotify |
+
+Missing config skips that channel and logs; never raises.
+
+## Usage
+
+```python
+from myappnotify import send_dingtalk, send_gotify, notify
+
+send_dingtalk("Title", "## body")
+send_gotify("Title", "## body")  # markdown via client::display
+
+# Fan-out; optional Gotify-specific body (e.g. GFM tables)
+notify("选股结果", dingtalk_md, gotify_text=gotify_table_md)
+```

myappnotify-0.1.0/myappnotify.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+myappnotify/__init__.py
+myappnotify/dingtalk.py
+myappnotify/gotify.py
+myappnotify.egg-info/PKG-INFO
+myappnotify.egg-info/SOURCES.txt
+myappnotify.egg-info/dependency_links.txt
+myappnotify.egg-info/top_level.txt
+tests/test_notify.py

myappnotify-0.1.0/myappnotify.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

myappnotify-0.1.0/myappnotify.egg-info/top_level.txt

@@ -0,0 +1 @@
+myappnotify

myappnotify-0.1.0/pyproject.toml

@@ -0,0 +1,15 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "myappnotify"
+version = "0.1.0"
+description = "DingTalk + Gotify markdown notification helpers"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+dependencies = []
+
+[tool.setuptools.packages.find]
+include = ["myappnotify*"]

myappnotify-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

myappnotify-0.1.0/tests/test_notify.py

@@ -0,0 +1,133 @@
+"""Unit tests for myappnotify (mocked HTTP)."""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import hmac
+import json
+import os
+import unittest
+import urllib.parse
+from unittest import mock
+
+from myappnotify import notify, send_dingtalk, send_gotify
+
+
+class _FakeUrlResp:
+    def __init__(self, body: str, status: int = 200):
+        self._body = body.encode("utf-8")
+        self.status = status
+
+    def read(self):
+        return self._body
+
+    def getcode(self):
+        return self.status
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *exc):
+        return False
+
+
+class TestDingTalk(unittest.TestCase):
+    def _sign(self, ts, secret):
+        raw = hmac.new(
+            secret.encode("utf-8"),
+            "{}\n{}".format(ts, secret).encode("utf-8"),
+            digestmod=hashlib.sha256,
+        ).digest()
+        return urllib.parse.quote_plus(base64.b64encode(raw))
+
+    def test_skip_when_unconfigured(self):
+        with mock.patch.dict(os.environ, {
+            "DINGDING_WEB_HOOK_TOKEN": "",
+            "DINGDING_BOT_SIGN": "",
+        }, clear=False):
+            with mock.patch("myappnotify.dingtalk.urllib.request.urlopen") as urlopen:
+                self.assertFalse(send_dingtalk("t", "body"))
+                urlopen.assert_not_called()
+
+    def test_success_signs_and_posts_markdown(self):
+        token, secret = "tok_abc", "SEC_xyz"
+        frozen = 1_700_000_000.0
+        ts = str(round(frozen * 1000))
+        expected_sign = self._sign(ts, secret)
+        with mock.patch.dict(os.environ, {
+            "DINGDING_WEB_HOOK_TOKEN": token,
+            "DINGDING_BOT_SIGN": secret,
+        }, clear=False):
+            with mock.patch("myappnotify.dingtalk.time.time", return_value=frozen):
+                with mock.patch(
+                    "myappnotify.dingtalk.urllib.request.urlopen",
+                    return_value=_FakeUrlResp('{"errcode":0,"errmsg":"ok"}'),
+                ) as urlopen:
+                    ok = send_dingtalk("持仓监控", "## 正文\n- 一条")
+        self.assertTrue(ok)
+        req = urlopen.call_args[0][0]
+        self.assertIn("access_token=" + token, req.full_url)
+        self.assertIn("timestamp=" + ts, req.full_url)
+        self.assertIn("sign=" + expected_sign, req.full_url)
+        body = json.loads(req.data.decode("utf-8"))
+        self.assertEqual(body["msgtype"], "markdown")
+        self.assertEqual(body["markdown"]["title"], "持仓监控")
+
+
+class TestGotify(unittest.TestCase):
+    def test_skip_when_unconfigured(self):
+        with mock.patch.dict(os.environ, {
+            "GOTIFY_URL": "",
+            "GOTIFY_TOKEN": "",
+        }, clear=False):
+            with mock.patch("myappnotify.gotify.urllib.request.urlopen") as urlopen:
+                self.assertFalse(send_gotify("t", "body"))
+                urlopen.assert_not_called()
+
+    def test_success_posts_markdown_extras(self):
+        with mock.patch.dict(os.environ, {
+            "GOTIFY_URL": "https://gotify.example.com/",
+            "GOTIFY_TOKEN": "app-tok",
+        }, clear=False):
+            with mock.patch(
+                "myappnotify.gotify.urllib.request.urlopen",
+                return_value=_FakeUrlResp('{"id":1}', status=200),
+            ) as urlopen:
+                ok = send_gotify("选股结果", "## hello")
+        self.assertTrue(ok)
+        req = urlopen.call_args[0][0]
+        self.assertEqual(req.full_url, "https://gotify.example.com/message")
+        self.assertEqual(req.get_header("X-gotify-key"), "app-tok")
+        body = json.loads(req.data.decode("utf-8"))
+        self.assertEqual(body["title"], "选股结果")
+        self.assertEqual(body["message"], "## hello")
+        self.assertEqual(
+            body["extras"]["client::display"]["contentType"],
+            "text/markdown",
+        )
+
+    def test_network_error_returns_false(self):
+        with mock.patch.dict(os.environ, {
+            "GOTIFY_URL": "https://gotify.example.com",
+            "GOTIFY_TOKEN": "tok",
+        }, clear=False):
+            with mock.patch(
+                "myappnotify.gotify.urllib.request.urlopen",
+                side_effect=OSError("timed out"),
+            ):
+                self.assertFalse(send_gotify("t", "x"))
+
+
+class TestNotify(unittest.TestCase):
+    def test_gotify_text_override(self):
+        with mock.patch("myappnotify.send_dingtalk", return_value=True) as dt:
+            with mock.patch("myappnotify.send_gotify", return_value=True) as gf:
+                out = notify("T", "ding-body", gotify_text="gotify-table")
+        self.assertEqual(out, {"dingtalk": True, "gotify": True})
+        dt.assert_called_once_with("T", "ding-body")
+        gf.assert_called_once_with("T", "gotify-table")
+
+
+if __name__ == "__main__":
+    unittest.main()