lark-oapi 2.0.0.dev2__py3-none-any.whl → 2.0.0.dev4__py3-none-any.whl

lark_oapi/channel/channel.py

@@ -70,6 +70,7 @@ from .config import (
 from .driver import LarkClientDriver
 from .errors import FeishuChannelError, FeishuChannelErrorCode
 from .identity import IdentityResolver, NameCache
+from .normalize.comment import normalize_comment
 from .normalize.dedup import Deduper, InMemoryDedupStore
 from .normalize.pipeline import InboundPipeline, PipelineConfig, PipelineDeps
 from .outbound.routing import infer_receive_id_type
@@ -95,6 +96,22 @@ EventHandler = Callable[..., Any]
 Unsubscribe = Callable[[], None]
 
 
+def _card_action_identity(action: Any) -> str:
+    """Stable dedup fragment for a card action.
+
+    Node-SDK aligned: different buttons on the same card click to different
+    ``(tag, value)`` pairs, and those must dedup-distinctly; a genuine WS
+    redelivery of the *same* click hashes identically and is suppressed.
+    """
+    tag = getattr(action, "tag", "") or ""
+    value = getattr(action, "value", None)
+    try:
+        value_repr = json.dumps(value, sort_keys=True, ensure_ascii=False)
+    except (TypeError, ValueError):
+        value_repr = repr(value)
+    return f"{tag}:{value_repr}"
+
+
 # ---------------------------------------------------------------------------
 # FeishuChannel
 # ---------------------------------------------------------------------------
@@ -771,6 +788,18 @@ class FeishuChannel:
                 b = getattr(b, register)(handler)
             except Exception:  # pragma: no cover
                 pass
+        # drive.notice.comment_add_v1 has no typed processor in the
+        # generated SDK. The wire payload may arrive under either schema:
+        # the legacy callback channel uses p1 (event has ``uuid``), but
+        # the modern WS frontier wraps the same event in a p2 envelope
+        # (``schema=2.0``). Register the customized-event handler under
+        # both so neither path logs "processor not found".
+        b = b.register_p1_customized_event(
+            "drive.notice.comment_add_v1", self._on_p1_comment_add
+        )
+        b = b.register_p2_customized_event(
+            "drive.notice.comment_add_v1", self._on_p1_comment_add
+        )
         return b.build()
 
     # ------------------------------------------------------------------
@@ -804,6 +833,9 @@ class FeishuChannel:
     def _on_p2_message_read(self, data: Any) -> None:
         self.schedule(self._handle_message_read_event(data))
 
+    def _on_p1_comment_add(self, data: Any) -> None:
+        self.schedule(self._handle_comment_event(data))
+
     # ------------------------------------------------------------------
     # Async event handlers
     # ------------------------------------------------------------------
@@ -866,25 +898,80 @@ class FeishuChannel:
             operator_open_id = getattr(
                 getattr(event, "operator", None), "open_id", None
             )
-            await self._invoke(
-                "cardAction",
-                CardActionEvent(
-                    message_id=message_id or "",
-                    chat_id=chat_id or "",
-                    operator=EventOperator(open_id=operator_open_id or ""),
-                    action=CardActionPayload(
-                        tag=tag or "",
-                        value=raw_value,
-                        name=getattr(raw_value, "name", None)
-                        if hasattr(raw_value, "name")
-                        else None,
-                    ),
-                    raw=_coerce.obj_to_dict(data) or {},
+            payload = CardActionEvent(
+                message_id=message_id or "",
+                chat_id=chat_id or "",
+                operator=EventOperator(open_id=operator_open_id or ""),
+                action=CardActionPayload(
+                    tag=tag or "",
+                    value=raw_value,
+                    name=getattr(raw_value, "name", None)
+                    if hasattr(raw_value, "name")
+                    else None,
                 ),
+                raw=_coerce.obj_to_dict(data) or {},
+            )
+            # Route through safety.push_action (tier 2): dedup on a stable
+            # action identity (tag + value payload) so Feishu's at-least-once
+            # WS redelivery can't double-invoke the handler, and serialize by
+            # chat_id so two fast clicks in the same chat are processed in
+            # order. Node-SDK aligned.
+            await self._through_action_safety(
+                event_id=f"card:{payload.message_id}:{payload.operator.open_id}:"
+                         f"{_card_action_identity(payload.action)}",
+                queue_scope=payload.chat_id or payload.message_id or "",
+                handler=lambda: self._invoke("cardAction", payload),
             )
         except Exception as e:
             logger.exception("FeishuChannel cardAction dispatch failed: %s", e)
 
+    async def _through_action_safety(
+        self,
+        *,
+        event_id: str,
+        queue_scope: str,
+        handler: Callable[[], Any],
+    ) -> None:
+        """Run ``handler`` through the safety tier-2 gate (dedup + lock +
+        per-scope serial queue) when the pipeline exists; fall back to a
+        direct invocation when it hasn't been built yet (early events during
+        startup, unit tests that bypass ``connect``)."""
+        safety = self._safety
+        if safety is None:
+            result = handler()
+            if inspect.isawaitable(result):
+                await result
+            return
+
+        async def _run() -> None:
+            result = handler()
+            if inspect.isawaitable(result):
+                await result
+
+        await safety.push_action(event_id, queue_scope or event_id, _run)
+
+    async def _through_light_safety(
+        self,
+        *,
+        event_id: str,
+        handler: Callable[[], Any],
+    ) -> None:
+        """Tier-3 variant: dedup only (reaction add/remove). Same fallback
+        semantics as :meth:`_through_action_safety`."""
+        safety = self._safety
+        if safety is None:
+            result = handler()
+            if inspect.isawaitable(result):
+                await result
+            return
+
+        async def _run() -> None:
+            result = handler()
+            if inspect.isawaitable(result):
+                await result
+
+        await safety.push_light(event_id, _run)
+
     async def _handle_reaction_event(self, data: Any, *, action: str) -> None:
         cfg = self._config.inbound.reaction_notifications
         if cfg == "off":
@@ -905,16 +992,25 @@ class FeishuChannel:
                 if message_id and message_id not in self._sent_messages:
                     return
 
-            await self._invoke(
-                "reaction",
-                ReactionEvent(
-                    message_id=message_id,
-                    operator=EventOperator(open_id=operator_open_id or ""),
-                    emoji_type=emoji_type or "",
-                    action="added" if action == "create" else "removed",
-                    action_time=action_time,
-                    raw=_coerce.obj_to_dict(data) or {},
+            direction = "added" if action == "create" else "removed"
+            payload = ReactionEvent(
+                message_id=message_id,
+                operator=EventOperator(open_id=operator_open_id or ""),
+                emoji_type=emoji_type or "",
+                action=direction,
+                action_time=action_time,
+                raw=_coerce.obj_to_dict(data) or {},
+            )
+            # Tier 3: dedup only. Reactions are idempotent state changes so
+            # lock / serial queue would add latency for no benefit, but
+            # WS redelivery would double-invoke without this guard.
+            # Node-SDK aligned (pushLight).
+            await self._through_light_safety(
+                event_id=(
+                    f"reaction:{message_id}:{operator_open_id or ''}:"
+                    f"{emoji_type or ''}:{direction}"
                 ),
+                handler=lambda: self._invoke("reaction", payload),
             )
         except Exception as e:
             logger.exception("FeishuChannel reaction dispatch failed: %s", e)
@@ -961,6 +1057,36 @@ class FeishuChannel:
         except Exception as e:
             logger.exception("FeishuChannel messageRead dispatch failed: %s", e)
 
+    async def _handle_comment_event(self, data: Any) -> None:
+        try:
+            # ``CustomizedEvent.event`` is the raw inner event payload as a
+            # plain dict; the per-event timestamp lives on the envelope
+            # (``header.create_time`` for p2, ``ts`` for p1) — not in the
+            # inner dict — so pass it explicitly.
+            raw_event = getattr(data, "event", None)
+            header = getattr(data, "header", None)
+            envelope_ts = (
+                getattr(header, "create_time", None) if header is not None
+                else getattr(data, "ts", None)
+            )
+            normalized = normalize_comment(
+                raw_event if raw_event is not None else data,
+                bot_open_id=self._bot_open_id,
+                envelope_timestamp=envelope_ts,
+            )
+            if normalized is None:
+                return
+            # Tier 2: dedup + lock + per-file_token serial queue. Multiple
+            # comments on the same document are ordered; redeliveries of the
+            # same comment event are dropped. Node-SDK aligned.
+            await self._through_action_safety(
+                event_id=f"comment:{normalized.file_token}:{normalized.comment_id}",
+                queue_scope=normalized.file_token,
+                handler=lambda: self._invoke("comment", normalized),
+            )
+        except Exception as e:
+            logger.exception("FeishuChannel comment dispatch failed: %s", e)
+
     def _notify_reconnecting(self) -> None:
         for h in list(self._handlers.get("reconnecting", [])):
             try:

lark_oapi/channel/normalize/comment.py

@@ -1,7 +1,33 @@
-"""Normalize `drive.notice.comment_add_v1` events.
+"""Normalize ``drive.notice.comment_add_v1`` events.
 
-Produces a `CommentEvent` with `file_token` / `file_type` / `comment_id` /
-`operator` fields extracted from the raw event payload.
+Wire payload (node-aligned, observed end-to-end via channel-test-harness
+TC-317 against a real Feishu tenant 2026-04-27)::
+
+    {
+      "file_token": "...",
+      "file_type": "docx",
+      "comment_id": "...",
+      "reply_id": "...",
+      "is_mentioned": true,
+      "create_time": "1700000000000",   # ms, string
+      "notice_meta": {
+        "from_user_id":  { "open_id": "...", "user_id": "...", "union_id": "..." },
+        "to_user_id":    { ... },
+        "file_token": "...",
+        "file_type": "docx",
+        "timestamp": "1700000000000",
+        "is_mentioned": true,
+        "notice_type": "comment_add"
+      },
+      // Legacy fallbacks (older p1 callbacks):
+      "user_id":   { "open_id": "...", ... },
+      "is_mention": true,
+      "action_time": "1700000000000"
+    }
+
+The operator lives at ``notice_meta.from_user_id`` (top-level
+``user_id`` is the legacy fallback). Whether the bot was mentioned is a
+boolean flag (``is_mentioned``), not a probe of the mentions array.
 """
 
 from dataclasses import dataclass, field
@@ -31,10 +57,23 @@ def normalize_comment(
     data: Any,
     *,
     bot_open_id: Optional[str] = None,
+    envelope_timestamp: Optional[str] = None,
 ) -> Optional[CommentEvent]:
-    """Flatten the raw drive.notice.comment_add_v1 payload.
+    """Flatten the raw ``drive.notice.comment_add_v1`` payload.
+
+    Accepts either the whole envelope (with ``event`` key) or the inner
+    event dict. Returns ``None`` when the payload is malformed or missing
+    one of the required fields (``file_token`` / ``file_type`` /
+    ``comment_id`` / operator open_id).
 
-    Accepts either the whole envelope (with `event` key) or the inner event dict.
+    ``envelope_timestamp`` is the ``header.create_time`` (p2) or top-level
+    ``ts`` (p1) carried by the WS/HTTP envelope. The inner event payload
+    omits a per-event timestamp on the wire, so the envelope is the only
+    reliable source — pass it from the dispatcher callback.
+
+    ``bot_open_id`` is unused — the bot-mention signal is sourced from the
+    payload's ``is_mentioned`` flag instead. The parameter is kept for
+    backward compatibility with the previous (broken) implementation.
     """
     if not isinstance(data, dict):
         data = _try_dict(data)
@@ -46,30 +85,50 @@ def normalize_comment(
     notice_meta = event.get("notice_meta") if isinstance(event.get("notice_meta"), dict) else {}
 
     file_token = event.get("file_token") or notice_meta.get("file_token") or ""
-    if not file_token:
-        return None
     file_type = event.get("file_type") or notice_meta.get("file_type") or ""
     comment_id = event.get("comment_id") or notice_meta.get("comment_id") or ""
-    if not comment_id:
+
+    # Operator: prefer notice_meta.from_user_id (current p2 wire format),
+    # fall back to top-level user_id (legacy p1 callback shape). The old
+    # path looked at ``event.operator`` / ``event.operator_id`` — neither
+    # is in the actual payload, so operator came back null.
+    user_id_obj = notice_meta.get("from_user_id") or event.get("user_id") or {}
+    if not isinstance(user_id_obj, dict):
+        user_id_obj = {}
+    operator_open_id = user_id_obj.get("open_id")
+
+    # Required-field gate (node-aligned). Missing operator open_id is a
+    # malformed payload — drop rather than deliver a half-populated event.
+    if not (file_token and file_type and comment_id and operator_open_id):
         return None
+
     reply_id = event.get("reply_id") or notice_meta.get("reply_id") or None
 
-    operator_raw = event.get("operator") or event.get("operator_id") or notice_meta.get("operator") or {}
     op = CommentOperator(
-        open_id=(operator_raw or {}).get("open_id"),
-        user_id=(operator_raw or {}).get("user_id"),
-        union_id=(operator_raw or {}).get("union_id"),
+        open_id=operator_open_id,
+        user_id=user_id_obj.get("user_id"),
+        union_id=user_id_obj.get("union_id"),
     )
+
     mentioned_bot_flag = bool(
-        bot_open_id and any(
-            isinstance(m, dict) and m.get("user_id") == bot_open_id
-            for m in (event.get("mentions") or [])
-        )
+        event.get("is_mentioned")
+        if event.get("is_mentioned") is not None
+        else (notice_meta.get("is_mentioned") or event.get("is_mention"))
+    )
+
+    ts_str = (
+        event.get("create_time")
+        or notice_meta.get("timestamp")
+        or event.get("action_time")
+        or event.get("event_create_time")
+        or event.get("timestamp")
+        or envelope_timestamp
     )
     try:
-        ts = int(event.get("event_create_time") or event.get("timestamp") or 0)
+        ts = int(ts_str) if ts_str is not None else 0
     except (TypeError, ValueError):
         ts = 0
+
     return CommentEvent(
         file_token=file_token,
         file_type=file_type,

lark_oapi/channel/normalize/mentions.py

@@ -20,6 +20,10 @@ from typing import Any, Dict, Iterable, List, Optional, Tuple
 from ..types import Mention
 
 _PLACEHOLDER_RE = re.compile(r"@_user_\d+")
+# Matches the ``@_all`` mention-all placeholder Feishu embeds in text content
+# for "@所有人" messages. Needs a non-word-char (or end-of-string) boundary
+# after ``@_all`` so we don't misfire on, say, ``@_all_employees``.
+_AT_ALL_RE = re.compile(r"@_all(?![A-Za-z0-9_])")
 _AT_TAG_RE = re.compile(
     r"<at\s+([^>]*?)>(?P<name>.*?)</at>",
     re.IGNORECASE | re.DOTALL,
@@ -27,6 +31,20 @@ _AT_TAG_RE = re.compile(
 _ATTR_RE = re.compile(r'([\w_-]+)\s*=\s*"([^"]*)"')
 
 
+def text_has_mention_all(text: Optional[str]) -> bool:
+    """True if ``text`` contains the ``@_all`` placeholder.
+
+    Feishu does NOT populate ``event.message.mentions`` for ``@所有人``
+    messages in all cases — the only signal can be an ``@_all`` token
+    inside ``content.text``. Without detecting that, downstream policy
+    code sees ``mentioned_all=False`` and the ``mention_all_blocked``
+    gate never fires.
+    """
+    if not text:
+        return False
+    return _AT_ALL_RE.search(text) is not None
+
+
 # ---------------------------------------------------------------------------
 # Data shape
 # ---------------------------------------------------------------------------
@@ -155,6 +173,9 @@ def resolve_mentions(
         return f"@{m.name}"
 
     result = _PLACEHOLDER_RE.sub(_replace, content)
+    # Rewrite ``@_all`` placeholder to the human-visible form; without this
+    # user-visible content carries the raw token.
+    result = _AT_ALL_RE.sub("@所有人", result)
     if strip_bot_mentions:
         result = re.sub(r"\s{2,}", " ", result).strip()
     return result

lark_oapi/channel/normalize/pipeline.py

@@ -25,7 +25,12 @@ from ..types import (
 from .dedup import Deduper
 from .flatten import flatten
 from .interactive import fetch_interactive
-from .mentions import extract_mentions, parse_at_tags, resolve_mentions
+from .mentions import (
+    extract_mentions,
+    parse_at_tags,
+    resolve_mentions,
+    text_has_mention_all,
+)
 from .merge_forward import MergeForwardExpander
 from .registry import parse_message_content
 
@@ -155,8 +160,18 @@ class InboundPipeline:
         mentions: List[Mention] = list(ext.mention_list)
         mentioned_all = ext.mentioned_all
         if isinstance(content, TextContent):
+            # Feishu frequently ships ``@所有人`` messages with
+            # ``mentions = null`` — the only signal is an ``@_all``
+            # placeholder in ``content.text``. Without this probe the
+            # policy gate never sees ``mentioned_all=True`` so
+            # ``respond_to_mention_all`` / ``mention_all_blocked`` go
+            # silently skipped (TC-505).
+            if not mentioned_all and text_has_mention_all(content.text):
+                mentioned_all = True
             content.text = resolve_mentions(content.text, ext)
         elif isinstance(content, PostContent):
+            if not mentioned_all and text_has_mention_all(content.text):
+                mentioned_all = True
             content.text = resolve_mentions(content.text, ext)
             at_mentions, at_all, stripped = parse_at_tags(content.text)
             content.text = stripped

lark_oapi/core/const.py

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

{lark_oapi-2.0.0.dev2.dist-info → lark_oapi-2.0.0.dev4.dist-info}/METADATA

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

{lark_oapi-2.0.0.dev2.dist-info → lark_oapi-2.0.0.dev4.dist-info}/RECORD

@@ -10003,7 +10003,7 @@ lark_oapi/channel/__init__.py,sha256=yZeVV8Zeyv53YufjfX6lHrDblyeMmhMS2I40sHRv0kM
 lark_oapi/channel/_api_helpers.py,sha256=mv0pNmf1X2gG0gSCNfFXOFf_Y2Bl08FhOQCATc_vzqM,8874
 lark_oapi/channel/_coerce.py,sha256=nHdt-y6iHuo_Fp7ZdLFkydG1pTMM-_wQJGJbOzcUiEI,7490
 lark_oapi/channel/bot_identity.py,sha256=E2zMl1AYFCENi-HXtXH47WgZrWRpPMXiXyM38cvMdrw,5488
-lark_oapi/channel/channel.py,sha256=KNvvf6-y3eTUr1Hn08lNbPnG_8dMx_2UFP6ofi_BHnI,54225
+lark_oapi/channel/channel.py,sha256=uZJXERef6N9QYqUXzt2PmLBTNY3ZK_gwJZeczJHB8C8,59676
 lark_oapi/channel/config.py,sha256=PEYUDqG_r3sOqAF7acrA3pDgVPmk16ChWVB71l1xd_U,9877
 lark_oapi/channel/driver.py,sha256=5Ij0WaQP3kEhUqZqUoREgfwv052118lyj2A6bCiIg7Y,11863
 lark_oapi/channel/errors.py,sha256=MbQIH95dxt3m99ofaMp_3oM1RJVvAMxW1A3SKiavAfk,7179
@@ -10017,13 +10017,13 @@ lark_oapi/channel/auth/uat_runner.py,sha256=pt4c99AJnIJzmPwNxngI6PrsrBK5Xpt5WDh8
 lark_oapi/channel/card/__init__.py,sha256=NqmfsU_1sWIubZ-QtrhWTlEcHY5H_THNaVPSakJsjl0,277
 lark_oapi/channel/card/builder.py,sha256=KbxbIBQTd0ojN0wWplxz1DdM-BK9Twllf_tUEXqw94w,11932
 lark_oapi/channel/normalize/__init__.py,sha256=8VPAoSV7LHKLKQAS7LnqgDC0jHwldykhRxnvlng70cw,940
-lark_oapi/channel/normalize/comment.py,sha256=4DuUL1hfxsJhpvtAbQXydFL_ScJzssRljp06hvtdP7Q,2755
+lark_oapi/channel/normalize/comment.py,sha256=vmAKhCKXyzNSrB0WBvHDDDDtSKhO_zxyZSby1R-k1KQ,5054
 lark_oapi/channel/normalize/dedup.py,sha256=T8c2eUynJkOc83nEsxBxTSmaj0BFw8crjjVVGOuoY5I,3250
 lark_oapi/channel/normalize/flatten.py,sha256=vvvKhFFF_HXHC9fBZr_hhN6eV0DCq-vsfHXlHJrYku4,804
 lark_oapi/channel/normalize/interactive.py,sha256=EqwBy5EEW-wdfze4EQpBXQ7UIqzzxJNiBj8fSdWqSbM,2705
-lark_oapi/channel/normalize/mentions.py,sha256=aQy4dKAEYBND17Ra1tZiQFgQtcc-bpgd7n5eCjKQfsk,6744
+lark_oapi/channel/normalize/mentions.py,sha256=w-hoYYw8QoiFP6Gf30l1MLSMJVfm4lpRURmGbOXufYU,7716
 lark_oapi/channel/normalize/merge_forward.py,sha256=F88wE2dNywQOUpPeoEJNiM4l3U5we1EtP_Cnrpa8YCs,8513
-lark_oapi/channel/normalize/pipeline.py,sha256=VZ9h-F6RzkTP7I7uoS0lCz6s3Lbl80nVmlE3XUgJeUU,8979
+lark_oapi/channel/normalize/pipeline.py,sha256=s2UU3-BvBQaAPKHhK5nFbZzBHTVUbkdHqfWb9Td0Rpk,9623
 lark_oapi/channel/normalize/registry.py,sha256=xF-35gSSxwLjoHsWS3Cjz7n7K4rDMOIFvlXfLgqrEyg,11260
 lark_oapi/channel/normalize/converters/__init__.py,sha256=7hIl1hfFXkQ78EkY1WzVt4vmWThGJP2ll7ozp5jCCck,2202
 lark_oapi/channel/normalize/converters/_utils.py,sha256=VvDj6v6NwTSIY39Gsudsl4s6Hcq0inuAyfR87bYGrM8,1853
@@ -10073,7 +10073,7 @@ lark_oapi/channel/safety/processing_lock.py,sha256=G4Kcm8-aRCfrIKD_6aXu-inWG28tB
 lark_oapi/channel/safety/stale_detector.py,sha256=FKVBdYwRddpFynpRZxTyznxL3gkJVaoTXnn_iQ9uY04,691
 lark_oapi/channel/safety/types.py,sha256=WaWhUleLe21-57HTFH4cOwJpZb2OiwKuDxWxPAE0OYA,2124
 lark_oapi/core/__init__.py,sha256=z286YdAEQ4kRDGuKsZb0Osua5KMcg4yqBsLmKsdW1Hw,263
-lark_oapi/core/const.py,sha256=Nzn_gukWAtdLCrjRSojYlIlYsdALTOBHU102XRWqUuA,608
+lark_oapi/core/const.py,sha256=6t5WIv00UT_LdpXnzL0WEpzYp1vhpQP0p2TMAwgJmnI,608
 lark_oapi/core/construct.py,sha256=CKsC-5bza7R01PDE2pWbyThlXi1oLAtjR0YD3Lex_sM,1980
 lark_oapi/core/enum.py,sha256=ehxuylOjD3btFHTRtpA--QvEcvUlWimuqXIqglcg4Kw,471
 lark_oapi/core/env_var.py,sha256=6xonyZzC_6Jyaotazj-ip0_yzB4wpZ4xArXIdPdPTck,169
@@ -10174,8 +10174,8 @@ lark_oapi/ws/pb/google/protobuf/pyext/cpp_message.py,sha256=GCWPkLCXd0QxY3yzNN-G
 lark_oapi/ws/pb/google/protobuf/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lark_oapi/ws/pb/google/protobuf/util/json_format_pb2.py,sha256=4QRyr6gfGO_e2MNpt3z3MT1ZHfoR5SXRpmIs4aWrv6g,6375
 lark_oapi/ws/pb/google/protobuf/util/json_format_proto3_pb2.py,sha256=uA8FCLxKYYUrFOlpjSlyWQWbtpodzBMZrIxM25dyJhM,14610
-lark_oapi-2.0.0.dev2.dist-info/licenses/LICENSE,sha256=N2ZgITrKZ1yufqVdfmr4ixMPp4qJ_ly-1_YeCs3w-Uk,1083
-lark_oapi-2.0.0.dev2.dist-info/METADATA,sha256=Rslg-_LRvQwuubEyhu17sS60bTx-pSEfDiu_tlVslxo,4743
-lark_oapi-2.0.0.dev2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-lark_oapi-2.0.0.dev2.dist-info/top_level.txt,sha256=sDloiIa3R4quQp19_e1mf206wAxH0Wg1bvNnKzV8QJg,10
-lark_oapi-2.0.0.dev2.dist-info/RECORD,,
+lark_oapi-2.0.0.dev4.dist-info/licenses/LICENSE,sha256=N2ZgITrKZ1yufqVdfmr4ixMPp4qJ_ly-1_YeCs3w-Uk,1083
+lark_oapi-2.0.0.dev4.dist-info/METADATA,sha256=o25IQ1h_x-Q-Od785pKtEtIRmyxdvpIka9q5gqcN3SY,4743
+lark_oapi-2.0.0.dev4.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+lark_oapi-2.0.0.dev4.dist-info/top_level.txt,sha256=sDloiIa3R4quQp19_e1mf206wAxH0Wg1bvNnKzV8QJg,10
+lark_oapi-2.0.0.dev4.dist-info/RECORD,,