lark-oapi 2.0.0.dev0__tar.gz → 2.0.0.dev1__tar.gz

{lark_oapi-2.0.0.dev0/lark_oapi.egg-info → lark_oapi-2.0.0.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lark-oapi
-Version: 2.0.0.dev0
+Version: 2.0.0.dev1
 Summary: Lark OpenAPI SDK for Python
 Home-page: https://github.com/larksuite/oapi-sdk-python
 Author: Wenbo Mao

{lark_oapi-2.0.0.dev0 → lark_oapi-2.0.0.dev1}/lark_oapi/channel/__init__.py

@@ -127,6 +127,9 @@ from .types import (
     OutboundMessage,
     OutboundPost,
     OutboundText,
+    OutboundShareChat,
+    OutboundShareUser,
+    OutboundSticker,
     OutboundVideo,
     PostContent,
     ReactionEvent,
@@ -265,6 +268,9 @@ __all__ = [
     "OutboundMessage",
     "OutboundPost",
     "OutboundText",
+    "OutboundShareChat",
+    "OutboundShareUser",
+    "OutboundSticker",
     "OutboundVideo",
     "PostContent",
     "ReactionEvent",

{lark_oapi-2.0.0.dev0 → lark_oapi-2.0.0.dev1}/lark_oapi/channel/_coerce.py

@@ -27,6 +27,9 @@ from .types import (
     OutboundImage,
     OutboundMessage,
     OutboundPost,
+    OutboundShareChat,
+    OutboundShareUser,
+    OutboundSticker,
     OutboundText,
     OutboundVideo,
     SendOpts,
@@ -84,6 +87,7 @@ def coerce_outbound(
         (
             OutboundText, OutboundPost, OutboundCard, OutboundImage,
             OutboundFile, OutboundAudio, OutboundVideo,
+            OutboundShareChat, OutboundShareUser, OutboundSticker,
         ),
     ):
         return input_
@@ -109,6 +113,30 @@ def coerce_outbound(
         return OutboundAudio(source=coerce_media_source(input_["audio"], kind="audio"))
     if "video" in input_:
         return OutboundVideo(source=coerce_media_source(input_["video"], kind="video"))
+    if "share_chat" in input_ or "shareChat" in input_:
+        spec = input_.get("share_chat") or input_.get("shareChat") or {}
+        chat_id = spec if isinstance(spec, str) else _dict_get_any(
+            spec, ("chat_id", "chatId")
+        )
+        if not chat_id:
+            raise TypeError("share_chat requires a chat_id (str or {chat_id: ...})")
+        return OutboundShareChat(chat_id=chat_id)
+    if "share_user" in input_ or "shareUser" in input_:
+        spec = input_.get("share_user") or input_.get("shareUser") or {}
+        user_id = spec if isinstance(spec, str) else _dict_get_any(
+            spec, ("user_id", "userId", "open_id", "openId")
+        )
+        if not user_id:
+            raise TypeError("share_user requires a user_id (str or {user_id: ...})")
+        return OutboundShareUser(user_id=user_id)
+    if "sticker" in input_:
+        spec = input_["sticker"]
+        file_key = spec if isinstance(spec, str) else _dict_get_any(
+            spec, ("file_key", "fileKey")
+        )
+        if not file_key:
+            raise TypeError("sticker requires a file_key (str or {file_key: ...})")
+        return OutboundSticker(file_key=file_key)
     raise TypeError(f"send: unrecognized input keys {list(input_.keys())}")
 
 

{lark_oapi-2.0.0.dev0 → lark_oapi-2.0.0.dev1}/lark_oapi/channel/channel.py

@@ -431,7 +431,16 @@ class FeishuChannel:
         self.stop()
 
     def start(self) -> None:
-        """Start WS (blocking) or return after initializing Webhook dispatcher."""
+        """Start WS (blocking) or return after initializing Webhook dispatcher.
+
+        Transport-level failures (bad credentials, network unreachable, TLS
+        handshake failure, ...) are wrapped into
+        :class:`FeishuChannelError(NOT_CONNECTED)` with the original
+        exception chained via ``__cause__``. This gives callers a stable,
+        ``code``-bearing exception to match on instead of whatever raw
+        exception the underlying transport happens to raise (e.g.
+        ``lark_oapi.ws.client.ClientException`` whose ``.code`` is an int).
+        """
         if self._started:
             return
         self._started = True
@@ -451,7 +460,27 @@ class FeishuChannel:
             domain=self._config.domain,
             auto_reconnect=self._config.transport.auto_reconnect,
         )
-        self._ws_client.start()
+        # Wire transport-level reconnect events to the public ``on()`` bus so
+        # callers registering ``on("reconnecting", ...) / on("reconnected", ...)``
+        # actually observe them. Before this, those event names were advertised
+        # but never fired (TC-007).
+        self._ws_client.on_reconnecting = self._notify_reconnecting
+        self._ws_client.on_reconnected = self._notify_reconnected
+        try:
+            self._ws_client.start()
+        except FeishuChannelError:
+            # Already the right shape; just reset started so caller can retry.
+            self._started = False
+            raise
+        except Exception as e:
+            # Anything else (ws client's ClientException, timeouts, DNS, ...)
+            # → typed NOT_CONNECTED so callers can ``except FeishuChannelError
+            # as err: if err.code == FeishuChannelErrorCode.NOT_CONNECTED``.
+            self._started = False
+            raise FeishuChannelError(
+                FeishuChannelErrorCode.NOT_CONNECTED,
+                f"WebSocket connect failed: {e}",
+            ) from e
 
     def stop(self, *, join_timeout: float = 5.0) -> None:
         """Tear down everything the channel owns.
@@ -521,6 +550,16 @@ class FeishuChannel:
         self._bg_thread = None
         self._ws_client = None
 
+        # Allow a subsequent connect()/start() to actually run. Without
+        # clearing these two flags, a channel that was stopped would be
+        # permanently inert — any future connect() would short-circuit on
+        # ``self._started`` and ``_ensure_bg_loop`` would refuse on the
+        # persisted ``_shutdown``.
+        self._shutdown.clear()
+        self._started = False
+        with self._bg_tasks_lock:
+            self._bg_tasks.clear()
+
     def schedule(self, coro) -> "concurrent.futures.Future":
         """Submit a coroutine to the background loop; safe from any thread.
 
@@ -946,29 +985,64 @@ class FeishuChannel:
         ``{"image": {...}}``, …), a typed :class:`OutboundMessage` dataclass,
         or a bare string (shorthand for markdown). See :mod:`._coerce` for the
         full accepted shape.
+
+        Errors: both raised exceptions (coercion errors, transport failures)
+        AND ``SendResult.fail(...)`` outcomes are also forwarded to any
+        handler registered via ``channel.on("error", ...)``, so apps can
+        centralise failure observation. The error is still returned /
+        raised to the immediate caller as well — forwarding does not swallow.
         """
-        outbound = _coerce.coerce_outbound(message)
-        send_opts = _coerce.coerce_send_opts(opts)
-        rit = send_opts.receive_id_type or infer_receive_id_type(to)
-        return await self._sender.send(
-            outbound,
-            receive_id=to,
-            receive_id_type=rit,
-            reply_to=send_opts.reply_to,
-            reply_in_thread=send_opts.reply_in_thread,
-            uuid_=send_opts.uuid,
-        )
+        try:
+            outbound = _coerce.coerce_outbound(message)
+            send_opts = _coerce.coerce_send_opts(opts)
+            rit = send_opts.receive_id_type or infer_receive_id_type(to)
+            result = await self._sender.send(
+                outbound,
+                receive_id=to,
+                receive_id_type=rit,
+                reply_to=send_opts.reply_to,
+                reply_in_thread=send_opts.reply_in_thread,
+                uuid_=send_opts.uuid,
+            )
+        except Exception as e:
+            await self._forward_outbound_error(e)
+            raise
+        if not result.success and result.error is not None:
+            await self._forward_outbound_error(result.error)
+        return result
+
+    async def _forward_outbound_error(self, err: Any) -> None:
+        """Fan-out a send/stream failure to any ``on("error", ...)`` handlers.
+
+        Never swallows — the error still propagates to the direct caller.
+        Handler exceptions are logged but otherwise ignored.
+        """
+        for h in list(self._handlers.get("error", [])):
+            try:
+                result = h(err)
+                if inspect.isawaitable(result):
+                    await result
+            except Exception as inner:  # pragma: no cover - defensive
+                logger.warning("on('error') handler raised: %s", inner)
 
     async def stream(self, to, spec: Dict[str, Any], opts=None) -> SendResult:
         """Stream a message progressively.
 
         ``spec`` is either ``{"markdown": producer}`` or
         ``{"card": {"initial": ..., "producer": ...}}``.
+
+        Errors (coercion + stream controller raises) are also forwarded to
+        any ``on("error", ...)`` handlers before being re-raised to the
+        caller, same contract as :meth:`send`.
         """
-        if not isinstance(spec, dict):
-            raise TypeError("stream spec must be a dict")
-        send_opts = _coerce.coerce_send_opts(opts)
-        rit = send_opts.receive_id_type or infer_receive_id_type(to)
+        try:
+            if not isinstance(spec, dict):
+                raise TypeError("stream spec must be a dict")
+            send_opts = _coerce.coerce_send_opts(opts)
+            rit = send_opts.receive_id_type or infer_receive_id_type(to)
+        except Exception as e:
+            await self._forward_outbound_error(e)
+            raise
 
         if "markdown" in spec:
             # Markdown streaming uses the CardKit preallocation flow — every
@@ -986,7 +1060,11 @@ class FeishuChannel:
                 update_card_element_content=self.update_card_element_content,
                 finish_streaming_card=self.finish_streaming_card,
             )
-            mid = await ctl.run(spec["markdown"])
+            try:
+                mid = await ctl.run(spec["markdown"])
+            except Exception as e:
+                await self._forward_outbound_error(e)
+                raise
             return SendResult.ok(message_id=mid)
 
         if "card" in spec:
@@ -994,7 +1072,9 @@ class FeishuChannel:
             initial = card_def.get("initial") if isinstance(card_def, dict) else None
             producer = card_def.get("producer") if isinstance(card_def, dict) else None
             if initial is None or not callable(producer):
-                raise TypeError("card stream requires {initial, producer}")
+                err = TypeError("card stream requires {initial, producer}")
+                await self._forward_outbound_error(err)
+                raise err
             ctl = CardStreamController(
                 initial=initial,
                 ensure_created=lambda snap: self._ensure_card_snapshot(
@@ -1004,10 +1084,16 @@ class FeishuChannel:
                 ),
                 patch_card=self._patch_card,
             )
-            mid = await ctl.run(producer)
+            try:
+                mid = await ctl.run(producer)
+            except Exception as e:
+                await self._forward_outbound_error(e)
+                raise
             return SendResult.ok(message_id=mid)
 
-        raise TypeError("stream spec must contain 'markdown' or 'card'")
+        err = TypeError("stream spec must contain 'markdown' or 'card'")
+        await self._forward_outbound_error(err)
+        raise err
 
     async def update_card(self, message_id: str, card: Dict[str, Any]) -> SendResult:
         """Update a card message (node-aligned). Returns a :class:`SendResult`."""

{lark_oapi-2.0.0.dev0 → lark_oapi-2.0.0.dev1}/lark_oapi/channel/outbound/media/uploader.py

@@ -131,22 +131,25 @@ async def gather_buffer(
                 source.url,
             )
         elif not allowlist:
-            logger.warning(
-                "outbound: refusing URL download for %s — no SSRF allowlist "
-                "configured; set MediaSource._ssrf_allowlist to a list of "
-                "trusted hostnames (see docs) or use kind='buffer'/'file' "
-                "instead",
-                source.url,
+            # No allowlist configured → hard stop. Raise a typed error so
+            # the caller sees ``code=SSRF_BLOCKED`` and can surface that to
+            # the user; silently returning ``(None, name)`` was ambiguous
+            # with a transient network failure (TC-605).
+            raise FeishuChannelError(
+                FeishuChannelErrorCode.SSRF_BLOCKED,
+                (
+                    f"refusing URL download for {source.url} — no SSRF "
+                    "allowlist configured; set "
+                    "MediaSource._ssrf_allowlist to a list of trusted "
+                    "hostnames or use kind='buffer'/'file' instead"
+                ),
+                context={"url": source.url},
             )
-            return None, default_name
         else:
-            try:
-                await assert_public_url(source.url, allowlist=allowlist)
-            except FeishuChannelError as e:
-                logger.warning(
-                    "outbound: SSRF guard blocked %s: %s", source.url, e
-                )
-                return None, default_name
+            # Let assert_public_url's FeishuChannelError propagate up as
+            # the typed SSRF_BLOCKED error. The earlier swallow-to-None
+            # made the block indistinguishable from a download failure.
+            await assert_public_url(source.url, allowlist=allowlist)
 
         cap = int(getattr(source, "_url_download_cap", _URL_DOWNLOAD_DEFAULT_CAP))
         try:

{lark_oapi-2.0.0.dev0 → lark_oapi-2.0.0.dev1}/lark_oapi/channel/outbound/sender.py

@@ -18,6 +18,7 @@ from lark_oapi.core.log import logger
 
 from ..config import OutboundConfig
 from ..errors import (
+    FeishuChannelError,
     FeishuChannelErrorCode,
     SendError,
     classify_error,
@@ -36,12 +37,15 @@ from ..types import (
     OutboundImage,
     OutboundMessage,
     OutboundPost,
+    OutboundShareChat,
+    OutboundShareUser,
+    OutboundSticker,
     OutboundText,
     OutboundVideo,
     SendOpts,
     SendResult,
 )
-from .markdown import markdown_to_post_ast
+from .markdown import markdown_to_post_ast, split_with_code_fences
 from .routing import infer_receive_id_type
 
 # ----------------------------------------------------------------------------
@@ -216,6 +220,27 @@ def _build_video(file_key: str) -> Dict[str, str]:
     return {"msg_type": "media", "content": json.dumps({"file_key": file_key}, ensure_ascii=False)}
 
 
+def _build_share_chat(chat_id: str) -> Dict[str, str]:
+    return {
+        "msg_type": "share_chat",
+        "content": json.dumps({"chat_id": chat_id}, ensure_ascii=False),
+    }
+
+
+def _build_share_user(user_id: str) -> Dict[str, str]:
+    return {
+        "msg_type": "share_user",
+        "content": json.dumps({"user_id": user_id}, ensure_ascii=False),
+    }
+
+
+def _build_sticker(file_key: str) -> Dict[str, str]:
+    return {
+        "msg_type": "sticker",
+        "content": json.dumps({"file_key": file_key}, ensure_ascii=False),
+    }
+
+
 # ----------------------------------------------------------------------------
 # Sender
 # ----------------------------------------------------------------------------
@@ -256,6 +281,14 @@ class OutboundSender:
         """
         try:
             body_list = await self._materialize(message)
+        except FeishuChannelError as e:
+            # Preserve the typed error code (SSRF_BLOCKED, UPLOAD_FAILED, …)
+            # from the uploader / ssrf guard; wrapping into UNKNOWN loses
+            # the signal callers want to match on.
+            logger.warning("outbound: materialize blocked: %s", e)
+            return SendResult.fail(SendError(
+                code=e.code, retryable=False, hint=str(e),
+            ))
         except Exception as e:
             logger.exception("outbound: materialize failed: %s", e)
             return SendResult.fail(SendError(code=FeishuChannelErrorCode.UNKNOWN, retryable=False, hint=str(e)))
@@ -263,6 +296,12 @@ class OutboundSender:
         if not body_list:
             return SendResult.fail(SendError(code=FeishuChannelErrorCode.UNKNOWN, retryable=False, hint="empty body"))
 
+        # Collect every successful chunk's message_id. For single-chunk
+        # messages we return the familiar ``SendResult.ok(message_id=...)``.
+        # For multi-chunk (long markdown / post → multiple POST /messages
+        # requests), we also populate ``chunk_ids`` so callers can observe
+        # that the logical message was split. Node-sdk aligned.
+        chunk_message_ids: List[str] = []
         last_result: SendResult = SendResult.fail(SendError(code=FeishuChannelErrorCode.UNKNOWN, retryable=False))
         for idx, body in enumerate(body_list):
             req_uuid = uuid_ if (idx == 0 and uuid_) else str(uuid.uuid4())
@@ -280,6 +319,15 @@ class OutboundSender:
             last_result = result
             if not result.success:
                 return result
+            if result.message_id:
+                chunk_message_ids.append(result.message_id)
+        # Augment the final success result with chunk_ids when >1 chunk.
+        if len(chunk_message_ids) > 1:
+            return SendResult.ok(
+                message_id=chunk_message_ids[0],
+                raw=last_result.raw,
+                chunk_ids=list(chunk_message_ids),
+            )
         return last_result
 
     async def _send_one_with_fallback(
@@ -359,6 +407,24 @@ class OutboundSender:
         if isinstance(msg, OutboundPost):
             conv = self._config.markdown_converter
             table_mode = conv.table_mode if getattr(conv, "enabled", True) else "off"
+            # Markdown-sourced posts get split (code-fence aware) when the raw
+            # markdown exceeds the configured chunk limit; each chunk becomes
+            # its own post body. Pre-built ``msg.post`` ASTs are sent as-is —
+            # they're opaque to us. Mentions go only on the first chunk so
+            # ``@user`` doesn't fire again on every fragment.
+            if msg.markdown is not None and len(msg.markdown) > self._config.text_chunk_limit:
+                md_chunks = split_with_code_fences(
+                    msg.markdown, self._config.text_chunk_limit,
+                )
+                out: List[Dict[str, str]] = []
+                for i, chunk in enumerate(md_chunks):
+                    part = OutboundPost(
+                        markdown=chunk,
+                        title=msg.title if i == 0 else "",
+                        mentions=msg.mentions if i == 0 else [],
+                    )
+                    out.append(_build_post(part, table_mode=table_mode))
+                return out
             return [_build_post(msg, table_mode=table_mode)]
         if isinstance(msg, OutboundCard):
             return [_build_card(msg)]
@@ -386,6 +452,12 @@ class OutboundSender:
                 file_type="mp4", ssrf_allowlist=allowlist,
             )
             return [_build_video(key)] if key else []
+        if isinstance(msg, OutboundShareChat):
+            return [_build_share_chat(msg.chat_id)] if msg.chat_id else []
+        if isinstance(msg, OutboundShareUser):
+            return [_build_share_user(msg.user_id)] if msg.user_id else []
+        if isinstance(msg, OutboundSticker):
+            return [_build_sticker(msg.file_key)] if msg.file_key else []
         return []
 
     async def _create(

{lark_oapi-2.0.0.dev0 → lark_oapi-2.0.0.dev1}/lark_oapi/channel/safety/pipeline.py

@@ -25,7 +25,7 @@ from .policy_gate import PolicyGate
 from .processing_lock import ProcessingLock
 from .dedup_cache import SeenCache
 from .stale_detector import DEFAULT_STALE_MS, is_stale
-from .types import ChatQueueConfig, DedupConfig, RejectEvent, TextBatchConfig
+from .types import ChatQueueConfig, DedupConfig, RejectEvent, RejectReason, TextBatchConfig
 
 MessageDispatch = Callable[[InboundMessage], Awaitable[None]]
 OnReject = Callable[[RejectEvent], None]
@@ -82,35 +82,50 @@ class SafetyPipeline:
     def get_policy(self) -> PolicyConfig:
         return self._policy.get_policy()
 
+    def _emit_reject(self, msg: InboundMessage, reason: "RejectReason") -> None:
+        """Emit a :class:`RejectEvent` to the caller-supplied hook, if any.
+
+        Kept internal because the event taxonomy is deliberately narrow; only
+        :meth:`push_message` calls this. Swallows handler exceptions so a
+        buggy reject callback can't break message processing.
+        """
+        if self._on_reject is None:
+            return
+        try:
+            self._on_reject(RejectEvent(
+                message_id=msg.id,
+                chat_id=msg.conversation.chat_id,
+                sender_id=msg.sender.open_id,
+                reason=reason,
+            ))
+        except Exception as e:  # pragma: no cover
+            logger.warning("safety: on_reject handler raised: %s", e)
+
     # ---- tier 1: full message pipeline ---------------------------------------
     async def push_message(self, msg: InboundMessage) -> None:
         """Run a message through the complete safety gauntlet."""
-        # 1. Stale detector
+        # 1. Stale detector — emits RejectEvent(reason="stale") so subscribers
+        #    can observe the drop; previously silently returned.
         if is_stale(msg.create_time * 1000 if msg.create_time < 10**12 else msg.create_time,
                     self._stale_window_ms):
             logger.debug("safety: stale drop message_id=%s", msg.id)
+            self._emit_reject(msg, "stale")
             return
 
-        # 2. Dedup (seen cache)
+        # 2. Dedup (seen cache) — emits RejectEvent(reason="duplicate"); same
+        #    rationale as the stale branch above.
         if await self._seen.has(msg.id):
             logger.debug("safety: dedup drop message_id=%s", msg.id)
+            self._emit_reject(msg, "duplicate")
             return
 
-        # 3. Policy gate — only this tier emits a `reject` event
+        # 3. Policy gate
         decision = self._policy.evaluate(msg)
         if not decision.allowed:
-            if self._on_reject is not None and decision.reason is not None:
-                try:
-                    self._on_reject(RejectEvent(
-                        message_id=msg.id,
-                        chat_id=msg.conversation.chat_id,
-                        sender_id=msg.sender.open_id,
-                        reason=decision.reason,
-                    ))
-                except Exception as e:  # pragma: no cover
-                    logger.warning("safety: on_reject handler raised: %s", e)
+            if decision.reason is not None:
+                self._emit_reject(msg, decision.reason)
             else:
-                logger.debug("safety: policy drop message_id=%s reason=%s", msg.id, decision.reason)
+                logger.debug("safety: policy drop message_id=%s reason=None", msg.id)
             return
 
         # 4. Processing lock

{lark_oapi-2.0.0.dev0 → lark_oapi-2.0.0.dev1}/lark_oapi/channel/types.py

@@ -483,6 +483,39 @@ class OutboundVideo(_OutBase):
     source: Optional[MediaSource] = None
 
 
+@dataclass
+class OutboundShareChat(_OutBase):
+    """Send a group chat "business card" referencing ``chat_id``.
+
+    Feishu wire form: ``msg_type="share_chat"`` / ``content={"chat_id": "..."}``.
+    """
+
+    kind: Literal["share_chat"] = "share_chat"
+    chat_id: str = ""
+
+
+@dataclass
+class OutboundShareUser(_OutBase):
+    """Send a personal card referencing a user's ``open_id`` (or union_id).
+
+    Feishu wire form: ``msg_type="share_user"`` / ``content={"user_id": "..."}``.
+    """
+
+    kind: Literal["share_user"] = "share_user"
+    user_id: str = ""
+
+
+@dataclass
+class OutboundSticker(_OutBase):
+    """Send a sticker by its ``file_key``.
+
+    Feishu wire form: ``msg_type="sticker"`` / ``content={"file_key": "..."}``.
+    """
+
+    kind: Literal["sticker"] = "sticker"
+    file_key: str = ""
+
+
 OutboundMessage = Union[
     OutboundText,
     OutboundPost,
@@ -491,6 +524,9 @@ OutboundMessage = Union[
     OutboundFile,
     OutboundAudio,
     OutboundVideo,
+    OutboundShareChat,
+    OutboundShareUser,
+    OutboundSticker,
 ]
 
 
@@ -501,14 +537,33 @@ OutboundMessage = Union[
 
 @dataclass
 class SendResult:
+    """The outcome of a single :meth:`FeishuChannel.send` or ``stream`` call.
+
+    For messages that fit in one wire payload, only ``message_id`` is set.
+    For messages that get split across multiple wire payloads (long
+    markdown, long post — see :mod:`.outbound.sender._materialize`),
+    ``chunk_ids`` lists **every** chunk's message_id in order, and
+    ``message_id`` holds the first chunk for convenience / back-compat.
+    ``chunk_ids`` is ``None`` when there was only one chunk. Aligned with
+    node-sdk's ``SendResult.chunkIds?``.
+    """
+
     success: bool
     message_id: Optional[str] = None
     error: Optional[SendError] = None
     raw: Optional[Dict[str, Any]] = None
+    chunk_ids: Optional[List[str]] = None
 
     @classmethod
-    def ok(cls, message_id: Optional[str] = None, raw: Optional[Dict[str, Any]] = None) -> "SendResult":
-        return cls(success=True, message_id=message_id, raw=raw)
+    def ok(
+        cls,
+        message_id: Optional[str] = None,
+        raw: Optional[Dict[str, Any]] = None,
+        chunk_ids: Optional[List[str]] = None,
+    ) -> "SendResult":
+        return cls(
+            success=True, message_id=message_id, raw=raw, chunk_ids=chunk_ids,
+        )
 
     @classmethod
     def fail(cls, error: SendError, raw: Optional[Dict[str, Any]] = None) -> "SendResult":

{lark_oapi-2.0.0.dev0 → lark_oapi-2.0.0.dev1}/lark_oapi/core/const.py

@@ -1,6 +1,6 @@
 # Info
 PROJECT = "oapi-sdk-python"
-VERSION = "2.0.0.dev0"
+VERSION = "2.0.0.dev1"
 
 # Domain
 FEISHU_DOMAIN = "https://open.feishu.cn"

{lark_oapi-2.0.0.dev0 → lark_oapi-2.0.0.dev1}/lark_oapi/core/json.py

@@ -1,3 +1,4 @@
+import base64
 import copy
 import datetime
 import io
@@ -31,7 +32,17 @@ class Encoder(JSONEncoder):
         if isinstance(o, datetime.datetime):
             return o.strftime("%Y-%m-%d %H:%M:%S")
         if isinstance(o, bytes):
-            return str(o, encoding=UTF_8)
+            # Try UTF-8 first (the common case for wire payloads that
+            # happen to be stringly-typed), but fall back to base64 for
+            # genuine binary data (JPEG/PNG/PDF bytes pulled out of a
+            # download response that is later JSON-serialized by caller
+            # code). Without this fallback, any non-UTF-8 byte sequence
+            # raises ``UnicodeDecodeError`` mid-marshal and the whole
+            # response is lost.
+            try:
+                return str(o, encoding=UTF_8)
+            except UnicodeDecodeError:
+                return base64.b64encode(o).decode("ascii")
         if isinstance(o, int):
             return int(o)
         if isinstance(o, float):