python-codex 0.3.2__py3-none-any.whl → 0.4.0__py3-none-any.whl

pycodex/feishu_link.py

@@ -1,440 +0,0 @@
-import asyncio
-import threading
-import time
-import typing
-
-from .events import SessionStateEvent
-from .feishu_card import PycodexCard
-from .runtime import AgentRuntime
-
-CARD_UPDATE_FLUSH_INTERVAL_SECONDS = 0.5
-_LISTENER = None
-_LISTENER_LOCK = threading.Lock()
-
-
-class PycodexRuntimeLink:
-    def __init__(
-        self,
-        runtime: "AgentRuntime",
-        target: str,
-        loop=None,
-        card: "typing.Union[PycodexCard, None]" = None,
-    ) -> None:
-        self.runtime = runtime
-        self.target = target
-        self.loop = loop
-        self.card = card or PycodexCard.from_env()
-        self.session_key = None
-        self.message_id = None
-        self._listener = None
-        self._frontend_id = None
-        self._detached = False
-        self._update_thread = None
-        self._update_stop = threading.Event()
-        self._update_lock = threading.Lock()
-        self._update_pending = False
-
-    async def start_async(self) -> "PycodexRuntimeLink":
-        self.loop = asyncio.get_event_loop()
-        self.card.apply_event(SessionStateEvent("attach", self.runtime.snapshot()))
-        try:
-            await self.loop.run_in_executor(None, self.start)
-        except Exception:
-            await self.loop.run_in_executor(None, self.stop)
-            raise
-        self._frontend_id = self.runtime.attach(self._handle_runtime_event)
-        return self
-
-    def start(self) -> "PycodexRuntimeLink":
-        if self.loop is None:
-            raise RuntimeError("PycodexRuntimeLink.start_async() is required")
-        self.card.send(self.target)
-        self.session_key = self.card.session_key
-        self.message_id = self.card.message_id
-        self._listener = _feishu_listener(self.card)
-        self._listener.register(self)
-        self._listener.start()
-        self._start_update_thread()
-        return self
-
-    def stop(self) -> None:
-        self._detach_frontend()
-        if self._listener is not None:
-            _release_feishu_listener(self._listener, self)
-            self._listener = None
-        self._stop_update_thread()
-
-    def detach(self) -> None:
-        self._detached = True
-        self._detach_frontend()
-        if self._listener is not None:
-            _release_feishu_listener(self._listener, self)
-            self._listener = None
-        self.card.detach()
-        self._safe_update_card()
-        self._stop_update_thread()
-
-    def _detach_frontend(self) -> None:
-        if self._frontend_id is not None:
-            self.runtime.detach(self._frontend_id)
-            self._frontend_id = None
-
-    def _handle_runtime_event(self, event) -> None:
-        if self._detached:
-            return
-        self.card.apply_event(event)
-        self._update_card()
-
-    async def _submit(
-        self, action: "typing.Dict[str, object]"
-    ) -> "typing.Dict[str, object]":
-        if self._detached:
-            return {"toast": {"type": "warning", "content": "pycodex is detached."}}
-        if action.get("action") == "history":
-            try:
-                self.card.show_history(action.get("history_index"))
-            except ValueError as exc:
-                return {"toast": {"type": "warning", "content": str(exc)}}
-            self._update_card()
-            return {}
-        if action.get("action") != "send":
-            return {
-                "toast": {
-                    "type": "info",
-                    "content": "Unsupported action: {0}".format(action.get("action")),
-                }
-            }
-        prompt = str(action.get("prompt") or "").strip()
-        future = asyncio.run_coroutine_threadsafe(
-            self.runtime.submit_input(
-                prompt, sender=str(action.get("sender") or "feishu")
-            ),
-            self.loop,
-        )
-        try:
-            await asyncio.wrap_future(future)
-        except (ValueError, RuntimeError) as exc:
-            return {"toast": {"type": "warning", "content": str(exc)}}
-        return {"toast": {"type": "info", "content": "Input submitted."}}
-
-    def _update_card(self) -> None:
-        with self._update_lock:
-            self._update_pending = True
-
-    def _safe_update_card(self) -> None:
-        try:
-            self.card.update()
-        except Exception as e:
-            print(e)
-
-    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",
-        )
-        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 not self._update_stop.wait(CARD_UPDATE_FLUSH_INTERVAL_SECONDS):
-            with self._update_lock:
-                if not self._update_pending:
-                    continue
-                self._update_pending = False
-            self._safe_update_card()
-
-
-def _feishu_listener(card: PycodexCard) -> "_FeishuCardActionListener":
-    global _LISTENER
-    with _LISTENER_LOCK:
-        if _LISTENER is None:
-            _LISTENER = _FeishuCardActionListener(card)
-        else:
-            _LISTENER.assert_compatible(card)
-        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
-        self.app_secret = card.app_secret
-        self.domain = card.domain
-        self.encrypt_key = card.encrypt_key
-        self.verification_token = card.verification_token
-        self._links = {}
-        self._links_lock = threading.Lock()
-        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:
-            raise RuntimeError("Feishu listener is already running for another app")
-
-    def start(self) -> None:
-        if not self.app_id or not self.app_secret:
-            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,
-            name="pycodex-feishu-link",
-        )
-        self._thread.daemon = True
-        self._thread.start()
-
-    def register(self, link: PycodexRuntimeLink) -> None:
-        message_id = str(getattr(link, "message_id", "") or "").strip()
-        if not message_id:
-            raise RuntimeError("Feishu linked card message_id is required")
-        with self._links_lock:
-            self._links[message_id] = link
-
-    def unregister(self, link: PycodexRuntimeLink) -> None:
-        message_id = str(getattr(link, "message_id", "") or "").strip()
-        with self._links_lock:
-            if message_id and self._links.get(message_id) is link:
-                del self._links[message_id]
-                return
-            stale_ids = [
-                registered_id
-                for registered_id, registered_link in self._links.items()
-                if registered_link is link
-            ]
-            for registered_id in stale_ids:
-                del self._links[registered_id]
-
-    def empty(self) -> bool:
-        with self._links_lock:
-            return not self._links
-
-    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
-            import lark_oapi.ws as lark_ws
-            from lark_oapi.event.callback.model.p2_card_action_trigger import (
-                P2CardActionTriggerResponse,
-            )
-        except ImportError as exc:
-            raise RuntimeError(
-                "lark-oapi is required for Feishu long-connection mode"
-            ) from exc
-
-        def on_card_action(event):
-            return P2CardActionTriggerResponse(self._handle_card_action(event))
-
-        handler = (
-            lark.EventDispatcherHandler.builder(
-                self.encrypt_key or "",
-                self.verification_token or "",
-                lark.LogLevel.INFO,
-            )
-            .register_p2_card_action_trigger(on_card_action)
-            .build()
-        )
-        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:
-            message_id = _event_message_id(event)
-            link = self._resolve_link(message_id)
-            if link is None or link._detached:
-                return {
-                    "toast": {
-                        "type": "warning",
-                        "content": "pycodex is detached.",
-                    }
-                }
-            action = link.card.parse_action(event)
-            return self._async_thread.run(link._submit(action))
-        except Exception as exc:
-            return {
-                "toast": {
-                    "type": "error",
-                    "content": "pycodex error: {0}".format(exc),
-                }
-            }
-
-    def _resolve_link(self, message_id):
-        message_id = str(message_id or "").strip()
-        with self._links_lock:
-            if message_id:
-                return self._links.get(message_id)
-            if len(self._links) == 1:
-                return next(iter(self._links.values()))
-            return None
-
-
-def _event_message_id(event) -> "typing.Union[str, None]":
-    event_data = getattr(event, "event", None)
-    context = getattr(event_data, "context", None)
-    for name in ("open_message_id", "message_id"):
-        value = str(getattr(context, name, None) or "").strip()
-        if value:
-            return value
-    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
-        self.thread = None
-        self._started = threading.Event()
-
-    def start(self) -> None:
-        if self.loop is not None and self.loop.is_running():
-            return
-        self.loop = asyncio.new_event_loop()
-        self._started.clear()
-        self.thread = threading.Thread(
-            target=self._run_loop,
-            name="pycodex-feishu-asyncio",
-        )
-        self.thread.daemon = True
-        self.thread.start()
-        self._started.wait()
-
-    def run(self, coro):
-        if self.loop is None or not self.loop.is_running():
-            raise RuntimeError("Feishu asyncio loop is not running")
-        return asyncio.run_coroutine_threadsafe(coro, self.loop).result()
-
-    def stop(self) -> None:
-        loop = self.loop
-        if loop is None:
-            return
-        if loop.is_running():
-            loop.call_soon_threadsafe(loop.stop)
-        if self.thread is not None:
-            self.thread.join()
-        loop.close()
-        self.loop = None
-        self.thread = None
-
-    def _run_loop(self) -> None:
-        asyncio.set_event_loop(self.loop)
-        self._started.set()
-        self.loop.run_forever()

pycodex/tools/ipython_tool.py

@@ -1,142 +0,0 @@
-"""Optional tool that executes code in the current IPython kernel."""
-
-from ..events import ToolCompletedEvent
-from ..utils.event_helpers import colorize_tool_message
-from .base_tool import BaseTool, ToolContext
-
-
-class IPythonTool(BaseTool):
-    name = "ipython"
-    description = (
-        "Execute Python code in the current IPython kernel namespace. Use this "
-        "only when running inside IPython and live notebook/session variables "
-        "need to be inspected."
-    )
-    input_schema = {
-        "type": "object",
-        "properties": {
-            "code": {
-                "type": "string",
-                "description": "Python code to execute in the current IPython session.",
-            },
-        },
-        "required": ["code"],
-        "additionalProperties": False,
-    }
-    supports_parallel = False
-
-    def __init__(self, shell, name="ipython"):
-        self._shell = shell
-        self.name = name
-
-    async def run(self, context: "ToolContext", args):
-        del context
-        if not isinstance(args, dict):
-            return {"error": "arguments must be an object"}
-
-        code = args.get("code", "")
-        if not isinstance(code, str) or not code.strip():
-            return {"error": "`code` must be a non-empty string"}
-
-        from IPython.display import Code, display
-        from IPython.utils.capture import capture_output
-
-        display(Code(code, language="python"))
-        with capture_output() as captured:
-            result = self._shell.run_cell(code, store_history=False)
-        captured.show()
-
-        output = {
-            "stdout": captured.stdout,
-            "stderr": captured.stderr,
-        }
-
-        display_outputs = []
-        for item in captured.outputs:
-            data = getattr(item, "data", None)
-            if isinstance(data, dict):
-                display_outputs.append(
-                    data.get("text/plain") or data.get("text/html") or repr(data)
-                )
-            else:
-                display_outputs.append(repr(item))
-        if display_outputs:
-            output["display"] = display_outputs
-
-        if getattr(result, "result", None) is not None:
-            output["result"] = repr(result.result)
-
-        error = result.error_before_exec or result.error_in_exec
-        if error is not None:
-            output["error"] = f"{type(error).__name__}: {error}"
-
-        return output
-
-
-def _install_agent_shortcut(shell):
-    existing = shell.user_ns.get("_pycodex_agent_shortcut_transform")
-    if existing in shell.input_transformers_cleanup:
-        return existing
-
-    def transform(lines):
-        if len(lines) != 1:
-            return lines
-
-        line = lines[0]
-        stripped = line.lstrip()
-        indent = line[: len(line) - len(stripped)]
-        if not stripped.startswith("@"):
-            return lines
-
-        body = stripped[1:].rstrip("\n")
-        parts = body.split(None, 1)
-        if not parts:
-            return lines
-
-        agent_name = parts[0]
-        if not agent_name.isidentifier():
-            return lines
-
-        agent = shell.user_ns.get(agent_name)
-        if agent is None or not callable(getattr(agent, "run_turn", None)):
-            return lines
-
-        prompt = "" if len(parts) == 1 else parts[1]
-        if not prompt.strip():
-            return [f"{indent}print('Usage: @{agent_name} <prompt>')\n"]
-
-        return [f"{indent}print({agent_name}.ask({prompt!r}).output_text)\n"]
-
-    shell.input_transformers_cleanup.append(transform)
-    shell.user_ns["_pycodex_agent_shortcut_transform"] = transform
-    return transform
-
-
-def attach_ipython_event_printer(agent, color=True):
-    def handle_event(event):
-        if isinstance(event, ToolCompletedEvent):
-            tool_name = event.call.name
-            message = event.visualize()
-            for line in message.splitlines() or [""]:
-                print(colorize_tool_message(line, color, tool_name), flush=True)
-
-    agent.event_handler = handle_event
-    return handle_event
-
-
-def attach_ipython_tool(
-    agent, name="current_ipython", shortcut=True, print_tool_events=True, color=True
-):
-    from IPython import get_ipython
-
-    shell = get_ipython()
-    if shell is None:
-        raise RuntimeError("not running inside IPython")
-
-    tool = IPythonTool(shell, name=name)
-    agent.tool_registry.register(tool)
-    if shortcut:
-        _install_agent_shortcut(shell)
-    if print_tool_events:
-        attach_ipython_event_printer(agent, color=color)
-    return tool

workspace_server/__init__.py

@@ -1,39 +0,0 @@
-from .app import (
-    ThreadedWorkspaceInteractiveSession,
-    WebSessionView,
-    WorkspaceInteractiveSession,
-    build_parser,
-    create_app,
-    create_multi_workspace_app,
-    main,
-    parse_listen,
-    run_serve_cli,
-)
-from .workspaces import (
-    WorkspaceDefinition,
-    WorkspaceEntry,
-    WorkspaceRegistry,
-    WorkspaceSessionManager,
-    WorkspaceStateStore,
-    default_board_path,
-    load_workspace_definitions,
-)
-
-__all__ = [
-    "ThreadedWorkspaceInteractiveSession",
-    "WebSessionView",
-    "WorkspaceInteractiveSession",
-    "WorkspaceDefinition",
-    "WorkspaceEntry",
-    "WorkspaceRegistry",
-    "WorkspaceSessionManager",
-    "WorkspaceStateStore",
-    "build_parser",
-    "create_app",
-    "create_multi_workspace_app",
-    "default_board_path",
-    "load_workspace_definitions",
-    "main",
-    "parse_listen",
-    "run_serve_cli",
-]

workspace_server/__main__.py

@@ -1,4 +0,0 @@
-from .app import main
-
-if __name__ == "__main__":
-    main()