imbot-sdk-python 0.1.0__py3-none-any.whl

imbot_sdk/consts.py

@@ -0,0 +1,36 @@
+"""Connection states and client error codes."""
+
+from enum import IntEnum
+
+
+class ConnectState(IntEnum):
+    """Connection lifecycle state."""
+
+    DISCONNECT = 0
+    CONNECTING = 1
+    CONNECTED = 2
+
+
+class ClientErrorCode:
+    """Client error codes.
+
+    These are plain integer constants rather than an ``IntEnum`` because the
+    server may return arbitrary business codes that are surfaced verbatim.
+    """
+
+    SUCCESS = 0
+
+    UNKNOWN = 20000
+    SOCKET_FAILED = 20001
+    CONNECT_TIMEOUT = 20002
+    NEED_REDIRECT = 20003
+    CONNECT_EXISTED = 20004
+    PING_TIMEOUT = 20005
+    CONNECT_FAILED = 20006
+    CONNECT_CLOSED = 20007
+    INIT_ENCRYPTOR_FAILED = 20008
+    NEGOTIATE_FAILED = 20009
+
+    SEND_TIMEOUT = 21001
+
+    QUERY_TIMEOUT = 22001

imbot_sdk/data_accessor.py

@@ -0,0 +1,35 @@
+"""Synchronous request/response rendezvous with timeout.
+
+A one-shot slot that a producer thread fills via :meth:`put` while a consumer
+thread blocks in :meth:`get_with_timeout`. Used to wait for ACK frames keyed by
+request index.
+"""
+
+import threading
+from typing import Any, Optional
+
+
+class TimeoutError(Exception):
+    """Raised by :meth:`DataAccessor.get_with_timeout` when no data arrives."""
+
+
+class DataAccessor:
+    def __init__(self) -> None:
+        self._event = threading.Event()
+        self._data: Optional[Any] = None
+        self._lock = threading.Lock()
+
+    def put(self, data: Any) -> None:
+        with self._lock:
+            self._data = data
+            self._event.set()
+
+    def get_with_timeout(self, timeout: float) -> Any:
+        """Block up to ``timeout`` seconds for a value.
+
+        :raises TimeoutError: if nothing was put in time.
+        """
+        if not self._event.wait(timeout):
+            raise TimeoutError("time up")
+        with self._lock:
+            return self._data

imbot_sdk/listeners.py

@@ -0,0 +1,67 @@
+"""Listener base classes.
+
+Subclass and override the callbacks you care about; every method has a no-op
+default so you only implement what you need. Callbacks run on internal threads
+— avoid long blocking work inside them.
+"""
+
+from typing import List
+
+from .consts import ClientErrorCode, ConnectState
+from .models import (
+    Conversation,
+    ConversationInfo,
+    Message,
+    MessageReaction,
+)
+
+
+class ConnectionStatusChangeListener:
+    """Receives connection status changes."""
+
+    def on_status_change(self, status: ConnectState, code: int) -> None:
+        pass
+
+
+class MessageListener:
+    """Receives message events (receive / recall / update / reaction / top)."""
+
+    def on_message_receive(self, msg: Message) -> None:
+        pass
+
+    def on_message_recall(self, msg: Message) -> None:
+        pass
+
+    def on_message_update(self, msg: Message) -> None:
+        pass
+
+    def on_message_delete(self, conver: Conversation, msg_ids: List[str]) -> None:
+        pass
+
+    def on_message_clear(self, conver: Conversation, time: int, sender_id: str) -> None:
+        pass
+
+    def on_message_reaction_add(self, conver: Conversation, reaction: MessageReaction) -> None:
+        pass
+
+    def on_message_reaction_remove(self, conver: Conversation, reaction: MessageReaction) -> None:
+        pass
+
+    def on_message_set_top(self, message: Message, operator_id: str, is_top: bool) -> None:
+        pass
+
+
+class ConversationChangeListener:
+    """Receives conversation list and total-unread-count changes."""
+
+    def on_conversation_info_add(self, convers: List[ConversationInfo]) -> None:
+        pass
+
+    def on_conversation_info_update(self, convers: List[ConversationInfo]) -> None:
+        pass
+
+    def on_conversation_info_delete(self, convers: List[ConversationInfo]) -> None:
+        pass
+
+    def on_total_unread_message_count_update(self, count: int) -> None:
+        pass

imbot_sdk/messages/__init__.py

@@ -0,0 +1,93 @@
+"""Message content models and a decoder registry."""
+
+from ..models import MESSAGE_CONTENT_TYPE_UNKNOWN
+from .base import (
+    MessageContent,
+    MESSAGE_CONTENT_TYPE_TEXT,
+    MESSAGE_CONTENT_TYPE_IMAGE,
+    MESSAGE_CONTENT_TYPE_FILE,
+    MESSAGE_CONTENT_TYPE_VIDEO,
+    MESSAGE_CONTENT_TYPE_VOICE,
+    MESSAGE_CONTENT_TYPE_STREAM_TEXT,
+    MESSAGE_CONTENT_TYPE_RECALL_INFO,
+    MESSAGE_CONTENT_TYPE_MERGE,
+    MESSAGE_CONTENT_TYPE_THUMBNAIL_PACKED_IMAGE,
+    MESSAGE_CONTENT_TYPE_SNAPSHOT_PACKED_VIDEO,
+)
+from .contents import (
+    TextMessage,
+    ImageMessage,
+    FileMessage,
+    VideoMessage,
+    VoiceMessage,
+    StreamTextMessage,
+    RecallInfoMessage,
+    MergeMessage,
+    MergeMessagePreviewUnit,
+    ThumbnailPackedImageMessage,
+    SnapshotPackedVideoMessage,
+    UnknownMessage,
+)
+
+# Factory map: content type -> zero-arg constructor.
+_CONTENT_FACTORIES = {
+    MESSAGE_CONTENT_TYPE_TEXT: TextMessage,
+    MESSAGE_CONTENT_TYPE_IMAGE: ImageMessage,
+    MESSAGE_CONTENT_TYPE_FILE: FileMessage,
+    MESSAGE_CONTENT_TYPE_VIDEO: VideoMessage,
+    MESSAGE_CONTENT_TYPE_VOICE: VoiceMessage,
+    MESSAGE_CONTENT_TYPE_STREAM_TEXT: StreamTextMessage,
+    MESSAGE_CONTENT_TYPE_RECALL_INFO: RecallInfoMessage,
+    MESSAGE_CONTENT_TYPE_MERGE: MergeMessage,
+    MESSAGE_CONTENT_TYPE_THUMBNAIL_PACKED_IMAGE: ThumbnailPackedImageMessage,
+    MESSAGE_CONTENT_TYPE_SNAPSHOT_PACKED_VIDEO: SnapshotPackedVideoMessage,
+}
+
+
+def decode_message_content(msg_type: str, data: bytes) -> MessageContent:
+    """Decode raw content bytes into a typed model.
+
+    Unknown types or decode failures fall back to :class:`UnknownMessage`.
+    """
+    factory = _CONTENT_FACTORIES.get(msg_type)
+    if factory is None:
+        unknown = UnknownMessage(msg_type)
+        unknown.decode(data)
+        return unknown
+    content = factory()
+    try:
+        content.decode(data)
+    except Exception:
+        unknown = UnknownMessage(msg_type)
+        unknown.decode(data)
+        return unknown
+    return content
+
+
+__all__ = [
+    "MessageContent",
+    "TextMessage",
+    "ImageMessage",
+    "FileMessage",
+    "VideoMessage",
+    "VoiceMessage",
+    "StreamTextMessage",
+    "RecallInfoMessage",
+    "MergeMessage",
+    "MergeMessagePreviewUnit",
+    "ThumbnailPackedImageMessage",
+    "SnapshotPackedVideoMessage",
+    "UnknownMessage",
+    "decode_message_content",
+    "MESSAGE_CONTENT_TYPE_TEXT",
+    "MESSAGE_CONTENT_TYPE_IMAGE",
+    "MESSAGE_CONTENT_TYPE_FILE",
+    "MESSAGE_CONTENT_TYPE_VIDEO",
+    "MESSAGE_CONTENT_TYPE_VOICE",
+    "MESSAGE_CONTENT_TYPE_STREAM_TEXT",
+    "MESSAGE_CONTENT_TYPE_RECALL_INFO",
+    "MESSAGE_CONTENT_TYPE_MERGE",
+    "MESSAGE_CONTENT_TYPE_THUMBNAIL_PACKED_IMAGE",
+    "MESSAGE_CONTENT_TYPE_SNAPSHOT_PACKED_VIDEO",
+    "MESSAGE_CONTENT_TYPE_UNKNOWN",
+]

imbot_sdk/messages/base.py

@@ -0,0 +1,54 @@
+"""Base class and type constants for message content models.
+
+Concrete content types serialize to/from compact JSON, so messages are
+interchangeable with the other JuggleIM client SDKs.
+"""
+
+import json
+
+from ..models import DEFAULT_MESSAGE_FLAGS, MESSAGE_CONTENT_TYPE_UNKNOWN
+
+# Built-in content type identifiers.
+MESSAGE_CONTENT_TYPE_TEXT = "jg:text"
+MESSAGE_CONTENT_TYPE_IMAGE = "jg:img"
+MESSAGE_CONTENT_TYPE_FILE = "jg:file"
+MESSAGE_CONTENT_TYPE_VIDEO = "jg:video"
+MESSAGE_CONTENT_TYPE_VOICE = "jg:voice"
+MESSAGE_CONTENT_TYPE_STREAM_TEXT = "jg:streamtext"
+MESSAGE_CONTENT_TYPE_RECALL_INFO = "jg:recallinfo"
+MESSAGE_CONTENT_TYPE_MERGE = "jg:merge"
+MESSAGE_CONTENT_TYPE_THUMBNAIL_PACKED_IMAGE = "jg:tpimg"
+MESSAGE_CONTENT_TYPE_SNAPSHOT_PACKED_VIDEO = "jg:spvideo"
+
+
+def _json_bytes(obj: dict) -> bytes:
+    """Serialize to compact JSON bytes (no whitespace between tokens)."""
+    return json.dumps(obj, separators=(",", ":"), ensure_ascii=False).encode("utf-8")
+
+
+class MessageContent:
+    """Base for all message content types."""
+
+    #: content type identifier, e.g. ``jg:text``.
+    CONTENT_TYPE = MESSAGE_CONTENT_TYPE_UNKNOWN
+
+    def get_content_type(self) -> str:
+        return self.CONTENT_TYPE or MESSAGE_CONTENT_TYPE_UNKNOWN
+
+    def encode(self) -> bytes:
+        return _json_bytes({})
+
+    def decode(self, data: bytes) -> None:
+        return None
+
+    def conversation_digest(self) -> str:
+        return ""
+
+    def get_flags(self) -> int:
+        return DEFAULT_MESSAGE_FLAGS
+
+    def get_search_content(self) -> str:
+        return ""
+
+    def __repr__(self) -> str:  # pragma: no cover - debug aid
+        return f"<{type(self).__name__} type={self.get_content_type()}>"