openim-sdk-core 0.1.3__py3-none-any.whl

openim_sdk/__init__.py

@@ -0,0 +1,57 @@
+__version__ = "0.1.3"
+
+from .client import OpenIMSDK, SDKConfig, SDKError, SDKHTTPError
+from .models import (
+    CONTENT_TYPE_NAMES,
+    AdvancedTextElem,
+    AtTextElem,
+    CardElem,
+    ContentType,
+    CustomElem,
+    FaceElem,
+    FileElem,
+    LocationElem,
+    MarkdownTextElem,
+    MergeElem,
+    NotificationElem,
+    PictureElem,
+    QuoteElem,
+    SelfUserInfo,
+    SoundElem,
+    TextElem,
+    TypingElem,
+    VideoElem,
+    WSMessage,
+)
+from .ws_client import OpenIMWSSDK, WSConfig, SDKError as WSSDKError
+
+__all__ = [
+    "__version__",
+    "OpenIMSDK",
+    "SDKConfig",
+    "SDKError",
+    "SDKHTTPError",
+    "WSSDKError",
+    "WSMessage",
+    "SelfUserInfo",
+    "ContentType",
+    "CONTENT_TYPE_NAMES",
+    "TextElem",
+    "PictureElem",
+    "SoundElem",
+    "VideoElem",
+    "FileElem",
+    "AtTextElem",
+    "MergeElem",
+    "CardElem",
+    "LocationElem",
+    "CustomElem",
+    "QuoteElem",
+    "FaceElem",
+    "AdvancedTextElem",
+    "TypingElem",
+    "MarkdownTextElem",
+    "NotificationElem",
+    "OpenIMWSSDK",
+    "WSConfig",
+]

openim_sdk/client.py

@@ -0,0 +1,381 @@
+import base64
+import hashlib
+import json
+import os
+import random
+import threading
+import time
+import uuid
+from dataclasses import dataclass, field
+from typing import Any, Callable, Dict, Iterable, List, Optional, Sequence
+
+from .http_api import post_json_data
+from .models import SelfUserInfo
+from .self_user_info_api import fetch_self_user_info
+from .storage import SQLiteStorage, conversation_id_from_msg
+
+
+CONTENT_TEXT = 101
+MSG_FROM_USER = 100
+SESSION_SINGLE_CHAT = 1
+SESSION_GROUP_CHAT = 2
+
+
+class SDKError(Exception):
+    def __init__(self, err_code: int, err_msg: str, err_dlt: str = "") -> None:
+        super().__init__(f"[{err_code}] {err_msg} {err_dlt}".strip())
+        self.err_code = int(err_code)
+        self.err_msg = err_msg
+        self.err_dlt = err_dlt
+
+
+class SDKHTTPError(Exception):
+    def __init__(self, status_code: int, body: str) -> None:
+        super().__init__(f"http status={status_code}, body={body}")
+        self.status_code = status_code
+        self.body = body
+
+
+@dataclass
+class SDKConfig:
+    api_addr: str
+    data_dir: str = "./data"
+    poll_interval_seconds: float = 2.0
+    pull_batch_size: int = 100
+    connect_timeout_seconds: float = 10.0
+    verify_token_on_login: bool = False
+    pull_message_routes: Sequence[str] = field(
+        default_factory=lambda: (
+            "/msg/pull_message_by_seqs",
+            "/msg/pull_msg_by_seqs",
+            "/msg/pull_msg_by_range",
+        )
+    )
+
+
+class OpenIMSDK:
+    def __init__(
+        self,
+        config: SDKConfig,
+        *,
+        on_recv_new_message: Optional[Callable[[Dict[str, Any]], None]] = None,
+        on_recv_offline_new_message: Optional[Callable[[Dict[str, Any]], None]] = None,
+        on_connecting: Optional[Callable[[], None]] = None,
+        on_connect_success: Optional[Callable[[], None]] = None,
+        on_connect_failed: Optional[Callable[[Exception], None]] = None,
+        on_error: Optional[Callable[[Exception], None]] = None,
+        logger: Optional[Callable[[str], None]] = None,
+    ) -> None:
+        self._config = config
+        self._api_addr = config.api_addr.rstrip("/")
+        self._user_id = ""
+        self._token = ""
+        self._storage: Optional[SQLiteStorage] = None
+        self._poll_thread: Optional[threading.Thread] = None
+        self._stop_event = threading.Event()
+        self._route_lock = threading.Lock()
+        self._selected_pull_route: Optional[str] = None
+        self._logger = logger
+
+        self.on_recv_new_message = on_recv_new_message
+        self.on_recv_offline_new_message = on_recv_offline_new_message
+        self.on_connecting = on_connecting
+        self.on_connect_success = on_connect_success
+        self.on_connect_failed = on_connect_failed
+        self.on_error = on_error
+
+    @property
+    def user_id(self) -> str:
+        return self._user_id
+
+    def login(self, user_id: str, token: str) -> None:
+        if not user_id or not token:
+            raise ValueError("user_id and token are required")
+
+        self._user_id = user_id
+        self._token = token
+        self._selected_pull_route = None
+
+        if self._config.verify_token_on_login:
+            self._post("/auth/parse_token", {"token": token})
+
+        db_file = os.path.join(self._config.data_dir, f"OpenIM_py_{user_id}.db")
+        self._storage = SQLiteStorage(db_file)
+        self._storage.open()
+        self._log(f"login success, db={db_file}")
+
+    def logout(self) -> None:
+        self.stop_receiving()
+        if self._storage is not None:
+            self._storage.close()
+            self._storage = None
+        self._user_id = ""
+        self._token = ""
+
+    def start_receiving(self) -> None:
+        self._assert_logged_in()
+        if self._poll_thread is not None and self._poll_thread.is_alive():
+            return
+        self._stop_event.clear()
+        if self.on_connecting:
+            self.on_connecting()
+        self._poll_thread = threading.Thread(target=self._poll_loop, name="openim-poller", daemon=True)
+        self._poll_thread.start()
+
+    def stop_receiving(self) -> None:
+        self._stop_event.set()
+        if self._poll_thread is not None and self._poll_thread.is_alive():
+            self._poll_thread.join(timeout=2.0)
+        self._poll_thread = None
+
+    def sync_once(self) -> None:
+        self._assert_logged_in()
+        self._sync_messages_once()
+
+    def get_self_user_info(self) -> SelfUserInfo:
+        self._assert_logged_in()
+        return fetch_self_user_info(
+            api_addr=self._api_addr,
+            user_id=self._user_id,
+            token=self._token,
+            operation_id=self._operation_id(),
+            timeout_seconds=self._config.connect_timeout_seconds,
+            make_http_error=lambda status, body: SDKHTTPError(status, body),
+            make_sdk_error=lambda code, msg, dlt: SDKError(code, msg, dlt),
+            make_not_found_error=lambda uid: SDKError(-1, "self user info not found", f"userID={uid}"),
+        )
+
+    def send_text(
+        self,
+        text: str,
+        *,
+        recv_id: str = "",
+        group_id: str = "",
+        sender_platform_id: int = 0,
+        sender_nickname: str = "",
+        sender_face_url: str = "",
+        session_type: Optional[int] = None,
+        options: Optional[Dict[str, bool]] = None,
+        offline_push_info: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        self._assert_logged_in()
+        if not text:
+            raise ValueError("text is required")
+        if not recv_id and not group_id:
+            raise ValueError("either recv_id or group_id is required")
+
+        now = int(time.time() * 1000)
+        client_msg_id = self._generate_client_msg_id(self._user_id)
+        if session_type is None:
+            session_type = SESSION_SINGLE_CHAT if recv_id else SESSION_GROUP_CHAT
+
+        content = json.dumps({"content": text}, ensure_ascii=False, separators=(",", ":")).encode("utf-8")
+        msg_data: Dict[str, Any] = {
+            "sendID": self._user_id,
+            "recvID": recv_id,
+            "groupID": group_id,
+            "clientMsgID": client_msg_id,
+            "senderPlatformID": int(sender_platform_id),
+            "senderNickname": sender_nickname,
+            "senderFaceURL": sender_face_url,
+            "sessionType": int(session_type),
+            "msgFrom": MSG_FROM_USER,
+            "contentType": CONTENT_TEXT,
+            "content": base64.b64encode(content).decode("ascii"),
+            "seq": 0,
+            "sendTime": now,
+            "createTime": now,
+            "status": 1,
+            "isRead": False,
+            "options": options or self._default_send_options(),
+            "offlinePushInfo": offline_push_info,
+            "attachedInfo": "",
+            "ex": "",
+        }
+
+        resp = self._post("/msg/send_msg", {"msgData": self._drop_none(msg_data)})
+        msg_data["serverMsgID"] = resp.get("serverMsgID", "")
+        msg_data["sendTime"] = int(resp.get("sendTime", now) or now)
+        msg_data["status"] = 2
+
+        if self._storage is not None:
+            cid = conversation_id_from_msg(msg_data, self._user_id)
+            self._storage.upsert_message(cid, msg_data, content.decode("utf-8"))
+        return resp
+
+    def _poll_loop(self) -> None:
+        if self.on_connect_success:
+            self.on_connect_success()
+
+        while not self._stop_event.is_set():
+            try:
+                self._sync_messages_once()
+            except Exception as exc:  # pragma: no cover
+                if self.on_error:
+                    self.on_error(exc)
+                self._log(f"sync error: {exc}")
+            self._stop_event.wait(self._config.poll_interval_seconds)
+
+    def _sync_messages_once(self) -> None:
+        assert self._storage is not None
+
+        conversations_resp = self._post("/conversation/get_all_conversations", {"ownerUserID": self._user_id})
+        conversations = conversations_resp.get("conversations", []) if isinstance(conversations_resp, dict) else []
+        conversation_ids = [str(v.get("conversationID", "")) for v in conversations if v.get("conversationID")]
+        if not conversation_ids:
+            return
+
+        seq_resp = self._post(
+            "/msg/get_conversations_has_read_and_max_seq",
+            {
+                "userID": self._user_id,
+                "conversationIDs": conversation_ids,
+                "returnPinned": False,
+            },
+        )
+        seq_map = seq_resp.get("seqs", {}) if isinstance(seq_resp, dict) else {}
+
+        for cid in conversation_ids:
+            seqs_info = seq_map.get(cid, {}) if isinstance(seq_map, dict) else {}
+            max_seq = int(seqs_info.get("maxSeq", 0) or 0)
+            if max_seq <= 0:
+                continue
+
+            local_seq = self._storage.get_last_seq(cid)
+            if local_seq >= max_seq:
+                continue
+
+            begin = local_seq + 1
+            while begin <= max_seq:
+                end = min(max_seq, begin + self._config.pull_batch_size - 1)
+                pull_resp = self._pull_message_by_seq_ranges(
+                    [
+                        {
+                            "conversationID": cid,
+                            "begin": begin,
+                            "end": end,
+                            "num": self._config.pull_batch_size,
+                        }
+                    ]
+                )
+                msgs = self._extract_pull_messages(pull_resp, cid)
+                newest_seq = local_seq
+                for msg in msgs:
+                    inserted = self._persist_incoming_message(cid, msg)
+                    seq = int(msg.get("seq", 0) or 0)
+                    if seq > newest_seq:
+                        newest_seq = seq
+                    if inserted:
+                        self._dispatch_incoming_message(msg)
+
+                if newest_seq > local_seq:
+                    self._storage.set_last_seq(cid, newest_seq)
+                    local_seq = newest_seq
+                begin = end + 1
+
+    def _pull_message_by_seq_ranges(self, seq_ranges: List[Dict[str, Any]]) -> Dict[str, Any]:
+        with self._route_lock:
+            selected = self._selected_pull_route
+
+        if selected is not None:
+            return self._post(selected, {"userID": self._user_id, "seqRanges": seq_ranges, "order": 0})
+
+        last_exc: Optional[Exception] = None
+        for route in self._config.pull_message_routes:
+            try:
+                resp = self._post(route, {"userID": self._user_id, "seqRanges": seq_ranges, "order": 0})
+                with self._route_lock:
+                    self._selected_pull_route = route
+                self._log(f"selected pull route: {route}")
+                return resp
+            except SDKHTTPError as exc:
+                last_exc = exc
+                if exc.status_code != 404:
+                    break
+            except SDKError as exc:
+                last_exc = exc
+        if last_exc is None:
+            last_exc = RuntimeError("no pull route available")
+        raise last_exc
+
+    def _extract_pull_messages(self, pull_resp: Dict[str, Any], conversation_id: str) -> List[Dict[str, Any]]:
+        msgs_map = pull_resp.get("msgs", {}) if isinstance(pull_resp, dict) else {}
+        one = msgs_map.get(conversation_id, {}) if isinstance(msgs_map, dict) else {}
+        msgs = one.get("Msgs")
+        if msgs is None:
+            msgs = one.get("msgs", [])
+        return msgs if isinstance(msgs, list) else []
+
+    def _persist_incoming_message(self, conversation_id: str, msg: Dict[str, Any]) -> bool:
+        assert self._storage is not None
+        content_json = self._decode_content_to_json(msg.get("content"))
+        return self._storage.upsert_message(conversation_id, msg, content_json)
+
+    def _dispatch_incoming_message(self, msg: Dict[str, Any]) -> None:
+        # Polling mode receives synced messages, so they are treated as offline/new pull messages.
+        if self.on_recv_offline_new_message:
+            self.on_recv_offline_new_message(msg)
+            return
+        if self.on_recv_new_message:
+            self.on_recv_new_message(msg)
+
+    def _post(self, route: str, payload: Dict[str, Any]) -> Dict[str, Any]:
+        self._assert_logged_in()
+        return post_json_data(
+            api_addr=self._api_addr,
+            route=route,
+            payload=payload,
+            token=self._token,
+            operation_id=self._operation_id(),
+            timeout_seconds=self._config.connect_timeout_seconds,
+            make_http_error=lambda status, body: SDKHTTPError(status, body),
+            make_sdk_error=lambda code, msg, dlt: SDKError(code, msg, dlt),
+        )
+
+    def _build_url(self, route: str) -> str:
+        if not route.startswith("/"):
+            route = "/" + route
+        return self._api_addr + route
+
+    def _assert_logged_in(self) -> None:
+        if not self._user_id or not self._token:
+            raise RuntimeError("not logged in")
+
+    def _operation_id(self) -> str:
+        return f"{int(time.time() * 1e9)}{random.randint(1000, 9999)}"
+
+    @staticmethod
+    def _generate_client_msg_id(send_id: str) -> str:
+        raw = f"{time.time_ns()}{send_id}{uuid.uuid4().hex}".encode("utf-8")
+        return hashlib.md5(raw).hexdigest()
+
+    @staticmethod
+    def _default_send_options() -> Dict[str, bool]:
+        return {
+            "history": True,
+            "persistent": True,
+            "senderSync": True,
+            "conversationUpdate": True,
+            "senderConversationUpdate": True,
+            "unreadCount": True,
+            "offlinePush": True,
+            "notPrivate": True,
+        }
+
+    @staticmethod
+    def _drop_none(values: Dict[str, Any]) -> Dict[str, Any]:
+        return {k: v for k, v in values.items() if v is not None}
+
+    @staticmethod
+    def _decode_content_to_json(content_value: Any) -> str:
+        if isinstance(content_value, str):
+            try:
+                b = base64.b64decode(content_value, validate=True)
+                return b.decode("utf-8", errors="replace")
+            except Exception:
+                return content_value
+        return ""
+
+    def _log(self, msg: str) -> None:
+        if self._logger:
+            self._logger(msg)

openim_sdk/example.py

@@ -0,0 +1,35 @@
+from openim_sdk import OpenIMSDK, SDKConfig
+
+
+def on_new_message(msg):
+    print("recv:", msg.get("clientMsgID"), msg.get("sendID"), msg.get("contentType"))
+
+
+def main():
+    sdk = OpenIMSDK(
+        SDKConfig(
+            api_addr="https://im-api-test.kiwilightyear.com",
+            data_dir="./openim_py_data",
+            poll_interval_seconds=2.0,
+        ),
+        on_recv_new_message=on_new_message,
+    )
+
+    sdk.login(user_id="10628900", token="eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJVc2VySUQiOiIxMDYyODkwMCIsIlBsYXRmb3JtSUQiOjEsImV4cCI6MTc4MDQ1MDAxMiwibmJmIjoxNzcyNjczNzEyLCJpYXQiOjE3NzI2NzQwMTJ9.p9_k73F7B2Hz2Iv_MhwLAmrlar641ryg2l2_JbVscZw")
+    sdk.start_receiving()
+
+    # Single chat text
+    resp = sdk.send_text("hello from python sdk", recv_id="10630400")
+    print("send resp:", resp)
+
+    # Keep process alive for demo.
+    try:
+        import time
+
+        time.sleep(20)
+    finally:
+        sdk.logout()
+
+
+if __name__ == "__main__":
+    main()

openim_sdk/example_ws.py

@@ -0,0 +1,53 @@
+from time import sleep
+
+from openim_sdk import OpenIMWSSDK, PictureElem, SoundElem, TextElem, WSConfig, WSMessage
+
+
+def on_new_message(msg: WSMessage):
+    if isinstance(msg.content_obj, TextElem):
+        print("recv text:", msg.client_msg_id, msg.send_id, msg.content_obj.content)
+        return
+    if isinstance(msg.content_obj, PictureElem):
+        print("recv picture:", msg.client_msg_id, msg.send_id, msg.content_obj.source_picture)
+        return
+    if isinstance(msg.content_obj, SoundElem):
+        print("recv sound:", msg.client_msg_id, msg.send_id, msg.content_obj.duration)
+        return
+    print("recv other:", msg.client_msg_id, msg.send_id, msg.content_type, msg.content_obj)
+
+
+def on_error(err):
+    print("error:", err)
+
+
+def main():
+    sdk = OpenIMWSSDK(
+        WSConfig(
+            ws_addr="wss://im-gateway-test.kiwilightyear.com",
+            api_addr="https://im-api-test.kiwilightyear.com",
+            data_dir="./openim_py_data",
+        ),
+        on_recv_new_message=on_new_message,
+        on_error=on_error,
+    )
+    sdk.login(user_id="10628900", token="eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJVc2VySUQiOiIxMDYyODkwMCIsIlBsYXRmb3JtSUQiOjEsImV4cCI6MTc4MDQ1MDAxMiwibmJmIjoxNzcyNjczNzEyLCJpYXQiOjE3NzI2NzQwMTJ9.p9_k73F7B2Hz2Iv_MhwLAmrlar641ryg2l2_JbVscZw")
+    sdk.start()
+
+    resp = sdk.send_text(
+        "hello from python ws sdk",
+        recv_id="10630400",
+        ex='{"biz":"order","id":"123"}',
+    )
+    print("send resp:", resp)
+    resp = sdk.send_text("hello from python ws sdk 2", recv_id="10630400")
+    print("send resp:", resp)
+    try:
+        import time
+
+        time.sleep(2000)
+    finally:
+        sdk.logout()
+
+
+if __name__ == "__main__":
+    main()