python-seatalk-bot 1.0.2__tar.gz → 1.1.0__tar.gz

{python_seatalk_bot-1.0.2 → python_seatalk_bot-1.1.0}/PKG-INFO

@@ -1,8 +1,9 @@
 Metadata-Version: 2.3
 Name: python-seatalk-bot
-Version: 1.0.2
+Version: 1.1.0
 Summary: Python wrapper for the SeaTalk API, inspired by python-telegram-bot.
 Requires-Dist: aiohttp
+Requires-Dist: websockets>=15.0.1
 Requires-Python: >=3.9
 Project-URL: Repository, https://github.com/heyzec/python-seatalk-bot
 Description-Content-Type: text/markdown

{python_seatalk_bot-1.0.2 → python_seatalk_bot-1.1.0}/pyproject.toml

@@ -1,10 +1,11 @@
 [project]
 name = "python-seatalk-bot"
-version = "1.0.2"
+version = "1.1.0"
 description = "Python wrapper for the SeaTalk API, inspired by python-telegram-bot."
 requires-python = ">=3.9"
 dependencies = [
     "aiohttp",
+    "websockets>=15.0.1",
 ]
 readme = "README.md"
 

{python_seatalk_bot-1.0.2 → python_seatalk_bot-1.1.0}/src/seatalk/core/__init__.py

@@ -208,8 +208,9 @@ class Update:
             date = (
                 data.event.message.message_sent_time.unwrap()
             )  # suddenly this API exposes this extra field
+            print("the data is ", data)
             group_id = data.event.group_id.unwrap()
-            thread_id = data.event.thread_id.unwrap()
+            thread_id = data.event.message.thread_id.unwrap()
             chat_id = Chat.join_group_and_thread_id(group_id, thread_id)
             chat = Chat(chat_id)
             employee_code = data.event.message.sender.employee_code.unwrap()
@@ -287,8 +288,8 @@ class Bot:
     )
 
     def __init__(self, app_id: str, app_secret: str):
-        self.app_id = app_id
-        self.app_secret = app_secret
+        self.app_id: str = app_id
+        self.app_secret: str = app_secret
 
     async def create_session_if_necessary(self):
         if self.session is None:  # pyright: ignore[reportUnnecessaryComparison]
@@ -315,8 +316,16 @@ class Bot:
             ) as r:
                 return (await r.json())["app_access_token"]
 
-    async def send_message(self, chat_id: str, text: str):
+    async def send(self, url: str, data: dict[str, Any]):
         await self.create_session_if_necessary()
+
+        r = await self.session.post(url, json=data)
+        if (await r.json())["code"] == 100:
+            await self.refresh_session()
+            r = await self.session.post(url, json=data)
+        return await r.json()
+
+    async def send_message(self, chat_id: str, text: str):
         data: dict[str, Any] = {
             "message": {
                 "tag": "text",
@@ -326,7 +335,6 @@ class Bot:
                 },
             },
         }
-        print(data)
         if Chat.is_employee_code(chat_id):
             print("Sending message to bot user with employee code:", chat_id)
             data["employee_code"] = chat_id
@@ -338,15 +346,16 @@ class Bot:
             data["message"]["thread_id"] = thread_id
             url = SEND_MESSAGE_TO_GROUP_CHAT_URL
 
-        r = await self.session.post(url, json=data)
-        if (await r.json())["code"] == 100:
-            await self.refresh_session()
-            r = await self.session.post(url, json=data)
-        print(await r.json())  # debug
+        res = await self.send(url, data)
+        if res["code"] != 0:
+            print("Failed to send message:", res)
+            return None
+        chat = Chat(chat_id)
+        return Message(
+            message_id=res["message_id"], chat=chat, date=0, from_user=User("")
+        )  # dummy message
 
     async def send_image(self, chat_id: str, image: str):
-        await self.create_session_if_necessary()
-        # b = base64.b64encode(image.read()).decode()
         data: dict[str, Any] = {
             "message": {
                 "tag": "image",
@@ -364,14 +373,9 @@ class Bot:
             data["message"]["thread_id"] = thread_id
             url = SEND_MESSAGE_TO_GROUP_CHAT_URL
 
-        r = await self.session.post(url, json=data)
-        if (await r.json())["code"] == 100:
-            await self.refresh_session()
-            r = await self.session.post(url, json=data)
-        print(await r.json())  # debug
+        await self.send(url, data)
 
     async def send_card(self, chat_id: str, card: Card):
-        await self.create_session_if_necessary()
         data: dict[str, Any] = {"message": card.encode()}
         if Chat.is_employee_code(chat_id):
             data["employee_code"] = chat_id
@@ -381,28 +385,21 @@ class Bot:
             data["group_id"] = group_id
             data["message"]["thread_id"] = thread_id
             url = SEND_MESSAGE_TO_GROUP_CHAT_URL
-        r = await self.session.post(url, json=data)
-        if (await r.json())["code"] == 100:
-            await self.refresh_session()
-            r = await self.session.post(url, json=data)
-        print(await r.json())  # debug
+
+        await self.send(url, data)
 
     async def get_user_by_emails(self, emails: list[str]) -> list[User]:
-        await self.create_session_if_necessary()
         data = {"emails": emails}
-        r = await self.session.post(GET_EMPLOYEE_CODE_WITH_EMAIL, json=data)
-        print(await r.json())  # debug
-        employees: list[Any] = (await r.json())["employees"]
-        print(employees)  # debug
+        url = GET_EMPLOYEE_CODE_WITH_EMAIL
+        result = await self.send(url, data)
+        employees: list[Any] = (result)["employees"]
 
         if employees[0]["code"] == 3000:
             return []
 
         users: list[User] = []
         for employee in employees:
-            seatalk_id = (
-                0,
-            )  # employee['seatalk_id'] this api doesn't provide seatalk_id...
+            seatalk_id = "Unknown"  # employee['seatalk_id'] this api doesn't provide seatalk_id...
             employee_code = employee["employee_code"]
             email = employee["email"]
             user = User(seatalk_id, employee_code, email)

{python_seatalk_bot-1.0.2 → python_seatalk_bot-1.1.0}/src/seatalk/ext/__init__.py

@@ -5,19 +5,16 @@ from typing import Any, Callable, override
 import asyncio
 from collections.abc import Coroutine
 import abc
-import hashlib
-import json
 import re
 
-import aiohttp
-import aiohttp.web
+from seatalk.ext.updater import Updater, WebhookUpdater, WebsocketUpdater
+
 
 from .context import CallbackContext
 from .jobs import JobQueue
 from ..core import (
     Bot,
     Update,
-    EVENT_VERIFICATION,
 )
 
 # Re-export symbols
@@ -113,8 +110,6 @@ class Persistence:
 
 class Application:
     handlers: dict[int, list[BaseHandler]] = {}
-    persistence: Persistence | None
-    signing_secret: bytes | None = None
 
     def __init__(
         self,
@@ -123,14 +118,15 @@ class Application:
         app_name: str,
         persistence: Persistence | None = None,
     ):
+        self.app_id: str = app_id
+        self.app_secret: str = app_secret
         self.bot: Bot = Bot(app_id, app_secret)
         self.persistence: Persistence | None = persistence
         self.app_name: str = app_name
 
         self.job_queue: JobQueue = JobQueue(self.bot)
 
-        self.server: aiohttp.web.Application = aiohttp.web.Application()
-        self._setup()
+        self.token: str | None = None
 
     def add_handler(self, handler: BaseHandler, group: int = 0):
         handler.app_name = self.app_name  # inject app name
@@ -140,69 +136,48 @@ class Application:
         handler.app_name = self.app_name  # inject app name
         self.handlers[group].remove(handler)
 
-    def _setup(self):
-        async def handle(request: aiohttp.web.Request) -> aiohttp.web.Response:
-            assert self.signing_secret is not None
-
-            def is_valid_signature(
-                signing_secret: bytes, body: bytes, signature: str
-            ) -> bool:
-                # ref: https://open.seatalk.io/docs/server-apis-event-callback
-                return hashlib.sha256(body + signing_secret).hexdigest() == signature
-
-            body: bytes = await request.read()
-            signature: str = request.headers.get("signature", "")
-            # 1. validate the signature
-            if not is_valid_signature(self.signing_secret, body, signature):
-                return aiohttp.web.Response()
-            # 2. handle events
-            data: dict[str, Any] = json.loads(body)
-
-            if data["event_type"] == EVENT_VERIFICATION:
-                data = {"seatalk_challenge": data["event"]["seatalk_challenge"]}
-                return aiohttp.web.json_response(data)
-
-            update = Update.from_data(data)
-            if not update:
-                print("Failed to parse update from data:", data)
-                return aiohttp.web.Response()
-
-            callback = None
-            context = CallbackContext(self.bot)
-            if self.persistence:
-                context.bot_data = self.persistence.bot_data
-                assert update.effective_chat is not None
-                assert update.effective_user is not None
-                context.chat_data = self.persistence.chat_data.setdefault(
-                    update.effective_chat.chat_id, {}
-                )
-                context.user_data = self.persistence.user_data.setdefault(
-                    update.effective_user.user_id, {}
-                )
-
-            for group, handlers in sorted(self.handlers.items()):
-                for handler in handlers:
-                    if handler.check_update(update):
-                        print("Handler", handler, "matched for update", update)
-                        callback = handler.callback
-                        break
-                else:
-                    print("No handler matched for update", update)
-
-                if callback:
-                    # create task instead of awaiting, we need to respond in time, otherwise seatalk will retry
-                    _ = asyncio.create_task(callback(update, context))
-
-            return aiohttp.web.Response()
-
-        _ = self.server.add_routes([aiohttp.web.post("/", handle)])
+    def handle_update(self, update: Update):
+        callback = None
+        context = CallbackContext(self.bot)
+        if self.persistence:
+            context.bot_data = self.persistence.bot_data
+            assert update.effective_chat is not None
+            assert update.effective_user is not None
+            context.chat_data = self.persistence.chat_data.setdefault(
+                update.effective_chat.chat_id, {}
+            )
+            context.user_data = self.persistence.user_data.setdefault(
+                update.effective_user.user_id, {}
+            )
+
+        for group, handlers in sorted(self.handlers.items()):
+            for handler in handlers:
+                if handler.check_update(update):
+                    print("Handler", handler, "matched for update", update)
+                    callback = handler.callback
+                    break
+            else:
+                print("No handler matched for update", update)
+
+            if callback:
+                # create task instead of awaiting, we need to respond in time, otherwise seatalk will retry
+                _ = asyncio.create_task(callback(update, context))
+
+    async def run(self, updater: Updater):
+        await updater.setup()
+        _ = self.job_queue.start() # don't await
+        async for update in updater.get_updates():
+            self.handle_update(update)
 
     def run_webhook(
         self, signing_secret: bytes, listen: str = "127.0.0.1", port: int = 80
     ):
-        loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(loop)
-        loop.create_task(self.job_queue.start())
-
-        self.signing_secret = signing_secret
-        aiohttp.web.run_app(self.server, host=listen, port=port, loop=loop)
+        updater = WebhookUpdater(signing_secret, listen, port)
+        asyncio.run(self.run(updater))
+
+    def run_websocket(self):
+        updater = WebsocketUpdater(app_id=self.app_id, app_secret=self.app_secret)
+        # loop = asyncio.new_event_loop()
+        # asyncio.set_event_loop(loop)
+        # loop.run_until_complete(self.run(updater))
+        asyncio.run(self.run(updater))

python_seatalk_bot-1.1.0/src/seatalk/ext/updater.py

@@ -0,0 +1,254 @@
+# pyright: reportAny=false
+from __future__ import annotations
+
+import abc
+import asyncio
+from dataclasses import MISSING, dataclass, field, fields, is_dataclass
+import hashlib
+import json
+from typing import Any, AsyncGenerator, Self, get_type_hints
+import uuid
+
+import aiohttp
+import aiohttp.web
+import websockets
+from websockets.asyncio.client import ClientConnection
+
+from seatalk.core import EVENT_VERIFICATION, Update
+
+
+class Updater:
+    @abc.abstractmethod
+    async def setup(self): ...
+
+    @abc.abstractmethod
+    async def get_updates(self) -> AsyncGenerator[Update, None]:
+        raise NotImplementedError("get_updates must be implemented by subclasses")
+        yield  # pyright: ignore
+
+
+class WebhookUpdater(Updater):
+    def __init__(
+        self,
+        signing_secret: bytes,
+        listen: str = "127.0.0.1",
+        port: int = 80,
+    ):
+        self.signing_secret = signing_secret
+        self.listen = listen
+        self.port = port
+
+        self.queue: asyncio.Queue[Update] = asyncio.Queue()
+
+    async def setup(self):
+        server = aiohttp.web.Application()
+
+        async def handle(request: aiohttp.web.Request) -> aiohttp.web.Response:
+            assert self.signing_secret is not None
+
+            def is_valid_signature(
+                signing_secret: bytes, body: bytes, signature: str
+            ) -> bool:
+                # ref: https://open.seatalk.io/docs/server-apis-event-callback
+                return hashlib.sha256(body + signing_secret).hexdigest() == signature
+
+            body: bytes = await request.read()
+            signature: str = request.headers.get("signature", "")
+            # 1. validate the signature
+            if not is_valid_signature(self.signing_secret, body, signature):
+                return aiohttp.web.Response()
+            # 2. handle events
+            data: dict[str, Any] = json.loads(body)
+
+            if data["event_type"] == EVENT_VERIFICATION:
+                data = {"seatalk_challenge": data["event"]["seatalk_challenge"]}
+                return aiohttp.web.json_response(data)
+
+            update = Update.from_data(data)
+            if not update:
+                print("Failed to parse update from data:", data)
+                return aiohttp.web.Response()
+
+            self.queue.put_nowait(update)
+
+            return aiohttp.web.Response()
+
+        server.add_routes([aiohttp.web.post("/", handle)])
+
+        # aiohttp.web.run_app(server, host=listen, port=port, loop=loop)
+        runner = aiohttp.web.AppRunner(server)
+        await runner.setup()
+        site = aiohttp.web.TCPSite(
+            runner,
+            host=self.listen,
+            port=self.port,
+        )
+        await site.start()
+
+    async def get_updates(self) -> AsyncGenerator[Update, None]:
+        while True:
+            update = await self.queue.get()
+            yield update
+
+
+CODE_OK = 0
+COMMAND_REGISTER = "register"
+DEFAULT_WEB_SOCKET_URL = "wss://ws-openapi.haiserve.com/ws/bot"
+
+
+class Serializable:
+    @classmethod
+    def from_dict(cls, data: Any) -> Self:
+        assert is_dataclass(cls), f"{cls.__name__} must be a dataclass"
+
+        data = data if isinstance(data, dict) else {}
+        hints = get_type_hints(cls)
+
+        kwargs: dict[str, Any] = {}
+        for field in fields(cls):
+            value = data.get(field.name)
+
+            # resolved version of what field.type is trying to represent
+            annotation = hints[field.name]
+
+            if isinstance(value, dict) and issubclass(annotation, Serializable):
+                value = annotation.from_dict(value)
+            elif value is None:
+                assert field.default is not MISSING
+                value = field.default
+
+            if annotation is not Any:
+                assert isinstance(value, annotation)
+            kwargs[field.name] = value
+
+        return cls(**kwargs)
+
+    def to_dict(self) -> dict[str, Any]:
+        if not is_dataclass(self):
+            raise TypeError(f"{type(self).__name__} must be a dataclass")
+
+        result: dict[str, Any] = {}
+        for field in fields(self):
+            value = getattr(self, field.name)
+            if isinstance(value, Serializable):
+                value = value.to_dict()
+            if value:
+                result[field.name] = value
+        return result
+
+
+@dataclass
+class Header(Serializable):
+    app_id: str = ""
+    app_secret: str = ""
+    token: str = ""
+    sid: str = ""
+    callback_id: str = ""
+    rid: str = ""
+
+
+@dataclass
+class Envelope(Serializable):
+    cmd: str
+    header: Header = field(default_factory=Header)
+    data: Any = None
+    code: int = 0
+    message: str = ""
+
+
+class WebsocketUpdater(Updater):
+    def __init__(self, app_id: str, app_secret: str):
+        self.app_id: str = app_id
+        self.app_secret: str = app_secret
+        self._ws: ClientConnection | None = None
+
+    @property
+    def ws(self) -> ClientConnection:
+        if self._ws is None:
+            raise ValueError("WebSocket is not connected")
+        return self._ws
+
+    async def ws_send(self, envelope: Envelope):
+        if not envelope.header.rid:
+            envelope.header.rid = uuid.uuid4().hex
+        payload = json.dumps(
+            envelope.to_dict(), ensure_ascii=False, separators=(",", ":")
+        )
+        assert self.ws is not None
+        await self.ws.send(payload)
+
+    async def ws_connect(self):
+        self._ws = await websockets.connect(
+            DEFAULT_WEB_SOCKET_URL,
+            # additional_headers=self.request_headers,
+            open_timeout=15.0,
+        )
+        print("[ws] connected")
+        await self.ws_send(
+            Envelope(
+                cmd=COMMAND_REGISTER,
+                header=Header(app_id=self.app_id, app_secret=self.app_secret),
+            )
+        )
+
+        assert self.ws is not None
+        message = await self.ws.recv()
+        try:
+            env = Envelope.from_dict(json.loads(message))
+        except Exception as exc:
+            raise ValueError("invalid json in register phase: %s" % exc)
+        if env.cmd != COMMAND_REGISTER:
+            raise ValueError(
+                'expected cmd "%s" first, got "%s" (%s)'
+                % (COMMAND_REGISTER, env.cmd, env.message)
+            )
+        if env.code != CODE_OK:
+            raise ValueError(
+                "register rejected: code=%d msg=%s" % (env.code, env.message)
+            )
+        if not env.header.token:
+            raise ValueError("register ok but empty token")
+        self.token = env.header.token
+        # self.ping_interval = (
+        #     float(data.get("heartbeat_interval") or 0) or self.ping_interval
+        # )
+        # print(
+        #     f"[ws] registered token={self._token} heartbeat_interval={self.ping_interval}"
+        # )
+
+    async def ping_loop(self):
+        assert self.token is not None
+        while True:
+            await self.ws_send(Envelope(cmd="ping", header=Header(token=self.token)))
+            # await asyncio.sleep(self.ping_interval)
+            await asyncio.sleep(10)
+
+    async def setup(self):
+        await self.ws_connect()
+        ping_task = asyncio.create_task(self.ping_loop())
+
+    async def get_updates(self) -> AsyncGenerator[Update, None]:
+        await self.setup()
+        print("[ws] waiting for updates...")
+        assert self.token is not None
+        async for message in self.ws:
+            print("[ws] received message:", message)
+            try:
+                env = Envelope.from_dict(json.loads(message))
+            except Exception as exc:
+                print(f"[ws] invalid frame: {exc}")
+                continue
+            if env.cmd == "event" and env.header.callback_id:
+                await self.ws_send(
+                    Envelope(
+                        cmd="ack",
+                        header=Header(
+                            token=self.token, callback_id=env.header.callback_id
+                        ),
+                    )
+                )
+                update = Update.from_data(env.data)
+                if not update:
+                    print(f"[ws] failed to parse update from data: {env.data}")
+                    continue
+                yield update