python-codex 0.1.13__py3-none-any.whl → 0.2.0__py3-none-any.whl

pycodex/feishu_card.py

@@ -45,6 +45,8 @@ class PycodexCard:
         self.last_prompt = ""
         self.model_name = "pycodex"
         self.output_text = ""
+        self.working_output_text = ""
+        self._working_delta_active = False
         self.error = ""
         self.running = False
         self.detached = False
@@ -150,6 +152,7 @@ class PycodexCard:
         self.last_sender = sender or "cli"
         self.last_prompt = prompt
         self._mark_last_turn_output()
+        self._reset_working_output()
         self.error = ""
         self.running = True
 
@@ -179,6 +182,7 @@ class PycodexCard:
             self.status_detail = "Model request started."
             was_running = self.running
             self.running = True
+            self._reset_working_output()
             prompt = payload.get("user_text") or "\n".join(
                 str(item) for item in payload.get("user_texts", []) or []
             )
@@ -193,16 +197,18 @@ class PycodexCard:
         if kind == "assistant_delta":
             self.status = "Responding"
             self.status_detail = "Receiving assistant output."
-            # self.output_text += str(payload.get("delta", ""))
+            self._append_working_delta(str(payload.get("delta") or ""))
             return False
         if kind == "tool_started":
             self.status = "Tool"
             self.status_detail = str(payload.get("tool_name") or "tool")
+            self._finish_working_delta_segment()
             return False
         if kind == "tool_completed":
             self.status_detail = str(
                 payload.get("summary") or payload.get("tool_name") or "tool completed"
             )
+            self._finish_working_delta_segment()
             return False
         if kind == "stream_error":
             self.status = "Retrying"
@@ -217,17 +223,20 @@ class PycodexCard:
             self.status = "Idle"
             self.status_detail = "Turn completed."
             self.running = False
+            self._reset_working_output()
             return True
         if kind in {"turn_failed", "submission_failed"}:
             self.status = "Error"
             self.error = str(payload.get("error") or kind)
             self.status_detail = self.error
             self.running = False
+            self._finish_working_delta_segment()
             return True
         if kind in {"turn_interrupted", "submission_cancelled"}:
             self.status = "Idle"
             self.status_detail = kind.replace("_", " ")
             self.running = False
+            self._reset_working_output()
             return True
         return False
 
@@ -235,6 +244,22 @@ class PycodexCard:
         if self.output_text and not self.output_text.startswith(LAST_TURN_PREFIX):
             self.output_text = LAST_TURN_PREFIX + self.output_text
 
+    def _reset_working_output(self) -> None:
+        self.working_output_text = ""
+        self._working_delta_active = False
+
+    def _finish_working_delta_segment(self) -> None:
+        self._working_delta_active = False
+
+    def _append_working_delta(self, delta: str) -> None:
+        if not delta:
+            return
+        if self._working_delta_active:
+            self.working_output_text += delta
+        else:
+            self.working_output_text = delta
+            self._working_delta_active = True
+
     def render(
         self, output_mode: str = CARD_OUTPUT_MODE_MARKDOWN
     ) -> "typing.Dict[str, object]":
@@ -251,7 +276,25 @@ class PycodexCard:
             "Waiting for output..." if self.running else "Ready."
         )
         output_content = _render_output_content(output, output_mode)
+        working_output = _truncate(self.working_output_text, CARD_OUTPUT_LIMIT)
         color, title = _status_template(self.status)
+        body_elements = [
+            {
+                "tag": "markdown",
+                "element_id": "prompt_md",
+                "content": f"> {sender}: **{_escape_code_block(prompt)}**",
+            },
+            _output_box("answer_box", "answer_md", output_content, "grey-50"),
+        ]
+        if working_output:
+            body_elements.append(
+                _output_box(
+                    "working_output_box",
+                    "working_output_md",
+                    _render_output_content(working_output, output_mode),
+                    "green-50",
+                )
+            )
         card = {
             "schema": "2.0",
             "config": {"update_multi": True},
@@ -260,35 +303,7 @@ class PycodexCard:
                 "template": color,
             },
             "body": {
-                "elements": [
-                    {
-                        "tag": "markdown",
-                        "element_id": "prompt_md",
-                        "content": f"> {sender}: **{_escape_code_block(prompt)}**",
-                    },
-                    {
-                        "tag": "column_set",
-                        "background_style": "grey-50",
-                        "horizontal_spacing": "8px",
-                        "horizontal_align": "left",
-                        "columns": [
-                            {
-                                "tag": "column",
-                                "width": "auto",
-                                "elements": [
-                                    {
-                                        "tag": "markdown",
-                                        "element_id": "answer_md",
-                                        "content": output_content,
-                                    },
-                                ],
-                                "vertical_spacing": "8px",
-                                "horizontal_align": "left",
-                                "vertical_align": "top",
-                            }
-                        ],
-                    },
-                ]
+                "elements": body_elements,
             },
         }
         if not self.detached:
@@ -614,6 +629,37 @@ def _render_output_content(output: str, output_mode: str) -> str:
     return output
 
 
+def _output_box(
+    box_id: str,
+    markdown_id: str,
+    content: str,
+    background_style: str,
+) -> "typing.Dict[str, object]":
+    return {
+        "tag": "column_set",
+        "element_id": box_id,
+        "background_style": background_style,
+        "horizontal_spacing": "8px",
+        "horizontal_align": "left",
+        "columns": [
+            {
+                "tag": "column",
+                "width": "auto",
+                "elements": [
+                    {
+                        "tag": "markdown",
+                        "element_id": markdown_id,
+                        "content": content,
+                    },
+                ],
+                "vertical_spacing": "8px",
+                "horizontal_align": "left",
+                "vertical_align": "top",
+            }
+        ],
+    }
+
+
 def _is_card_content_error(exc: "BaseException") -> bool:
     return CARD_CONTENT_ERROR_MARKER in str(exc)
 

pycodex/feishu_link.py

@@ -31,6 +31,7 @@ class PycodexRuntimeLink:
         self._event_handler = None
         self._detached = False
         self._update_thread = None
+        self._update_stop = threading.Event()
         self._update_lock = threading.Lock()
         self._update_pending = False
 
@@ -60,17 +61,19 @@ class PycodexRuntimeLink:
     def stop(self) -> None:
         self._restore_event_handler()
         if self._listener is not None:
-            self._listener.unregister(self)
+            _release_feishu_listener(self._listener, self)
             self._listener = None
+        self._stop_update_thread()
 
     def detach(self) -> None:
         self._detached = True
         self._restore_event_handler()
         if self._listener is not None:
-            self._listener.unregister(self)
+            _release_feishu_listener(self._listener, self)
             self._listener = None
         self.card.detach()
         self._safe_update_card()
+        self._stop_update_thread()
 
     def _restore_event_handler(self) -> None:
         current = getattr(self.queue, "_event_handler", None)
@@ -152,6 +155,7 @@ class PycodexRuntimeLink:
     def _start_update_thread(self) -> None:
         if self._update_thread is not None and self._update_thread.is_alive():
             return
+        self._update_stop.clear()
         self._update_thread = threading.Thread(
             target=self._run_update_loop,
             name="pycodex-feishu-card",
@@ -159,9 +163,15 @@ class PycodexRuntimeLink:
         self._update_thread.daemon = True
         self._update_thread.start()
 
+    def _stop_update_thread(self) -> None:
+        self._update_stop.set()
+        thread = self._update_thread
+        if thread is not None and thread.is_alive():
+            thread.join(timeout=2.0)
+        self._update_thread = None
+
     def _run_update_loop(self) -> None:
-        while True:
-            time.sleep(CARD_UPDATE_FLUSH_INTERVAL_SECONDS)
+        while not self._update_stop.wait(CARD_UPDATE_FLUSH_INTERVAL_SECONDS):
             with self._update_lock:
                 if not self._update_pending:
                     continue
@@ -194,6 +204,19 @@ def _feishu_listener(card: PycodexCard) -> '_FeishuCardActionListener':
         return _LISTENER
 
 
+def _release_feishu_listener(
+    listener: '_FeishuCardActionListener',
+    link: PycodexRuntimeLink,
+) -> None:
+    global _LISTENER
+    with _LISTENER_LOCK:
+        listener.unregister(link)
+        if listener.empty():
+            listener.stop()
+            if _LISTENER is listener:
+                _LISTENER = None
+
+
 class _FeishuCardActionListener:
     def __init__(self, card: PycodexCard) -> None:
         self.app_id = card.app_id
@@ -204,6 +227,9 @@ class _FeishuCardActionListener:
         self.link = None
         self._async_thread = _AsyncLoopThread()
         self._thread = None
+        self._client = None
+        self._client_loop = None
+        self._stop_requested = threading.Event()
 
     def assert_compatible(self, card: PycodexCard) -> None:
         if self.app_id != card.app_id or self.domain != card.domain:
@@ -214,6 +240,7 @@ class _FeishuCardActionListener:
             raise RuntimeError("FEISHU_APP_ID and FEISHU_APP_SECRET are required")
         if self._thread is not None and self._thread.is_alive():
             return
+        self._stop_requested.clear()
         self._async_thread.start()
         self._thread = threading.Thread(
             target=self._listen,
@@ -229,6 +256,21 @@ class _FeishuCardActionListener:
         if self.link is link:
             self.link = None
 
+    def empty(self) -> bool:
+        return self.link is None
+
+    def stop(self) -> None:
+        self._stop_requested.set()
+        client = self._client
+        loop = self._client_loop
+        if loop is not None:
+            _stop_lark_client(client, loop)
+        thread = self._thread
+        if thread is not None and thread.is_alive():
+            thread.join(timeout=2.0)
+        self._thread = None
+        self._async_thread.stop()
+
     def _listen(self) -> None:
         try:
             import lark_oapi as lark
@@ -253,13 +295,37 @@ class _FeishuCardActionListener:
             .register_p2_card_action_trigger(on_card_action)
             .build()
         )
-        client = lark_ws.Client(
-            self.app_id,
-            self.app_secret,
-            event_handler=handler,
-            domain=self.domain,
-        )
-        client.start()
+        import lark_oapi.ws.client as lark_ws_client
+
+        client = None
+        loop = asyncio.new_event_loop()
+        self._client_loop = loop
+        asyncio.set_event_loop(loop)
+        lark_ws_client.loop = loop
+        try:
+            if self._stop_requested.is_set():
+                return
+            client = lark_ws.Client(
+                self.app_id,
+                self.app_secret,
+                event_handler=handler,
+                domain=self.domain,
+            )
+            self._client = client
+            if self._stop_requested.is_set():
+                return
+            client.start()
+        except RuntimeError as exc:
+            stopped = "Event loop stopped before Future completed" in str(exc)
+            if not self._stop_requested.is_set() or not stopped:
+                raise
+        finally:
+            if self._client is client:
+                self._client = None
+            if self._client_loop is loop:
+                self._client_loop = None
+            _close_loop(loop)
+            asyncio.set_event_loop(None)
 
     def _handle_card_action(self, event) -> 'typing.Dict[str, object]':
         try:
@@ -300,6 +366,60 @@ def _event_message_id(event) -> "typing.Union[str, None]":
     return None
 
 
+def _stop_lark_client(client, loop) -> None:
+    if loop.is_closed():
+        return
+    disconnect = getattr(client, "_disconnect", None) if client is not None else None
+    if loop.is_running():
+        future = asyncio.run_coroutine_threadsafe(
+            _disconnect_then_stop(disconnect, loop),
+            loop,
+        )
+        try:
+            future.result(timeout=2.0)
+        except Exception as exc:
+            future.cancel()
+            print(exc)
+            loop.call_soon_threadsafe(loop.stop)
+        return
+    if callable(disconnect):
+        try:
+            loop.run_until_complete(disconnect())
+        except Exception as exc:
+            print(exc)
+
+
+async def _disconnect_then_stop(disconnect, loop) -> None:
+    try:
+        if callable(disconnect):
+            await disconnect()
+    except Exception as exc:
+        print(exc)
+    finally:
+        loop.stop()
+
+
+def _close_loop(loop) -> None:
+    if loop.is_closed():
+        return
+    tasks = list(_all_loop_tasks(loop))
+    for task in tasks:
+        task.cancel()
+    if tasks:
+        loop.run_until_complete(asyncio.gather(*tasks, return_exceptions=True))
+    shutdown_asyncgens = getattr(loop, "shutdown_asyncgens", None)
+    if callable(shutdown_asyncgens):
+        loop.run_until_complete(shutdown_asyncgens())
+    loop.close()
+
+
+def _all_loop_tasks(loop):
+    all_tasks = getattr(asyncio, "all_tasks", None)
+    if callable(all_tasks):
+        return all_tasks(loop)
+    return asyncio.Task.all_tasks(loop)
+
+
 class _AsyncLoopThread:
     def __init__(self) -> None:
         self.loop = None