open-swarm 0.1.1745275181__py3-none-any.whl → 0.1.1748636259__py3-none-any.whl

swarm/cli/async_input.py

@@ -1,65 +0,0 @@
-import asyncio
-import sys
-import threading
-from typing import Callable, Optional
-
-class AsyncInputHandler:
-    """
-    Async input handler supporting double-Enter interrupt and warning.
-    Usage:
-        handler = AsyncInputHandler(on_interrupt=callback)
-        await handler.get_input(prompt="You: ")
-    """
-    def __init__(self, on_interrupt: Optional[Callable[[str], None]] = None):
-        self.on_interrupt = on_interrupt
-        self._input_event = threading.Event()
-        self._interrupt_event = threading.Event()
-        self._input_result = None
-        self._warned = False
-        self._input_thread = None
-
-    def _input_loop(self, prompt):
-        buffer = ""
-        while True:
-            try:
-                line = input(prompt if not buffer else "")
-            except EOFError:
-                break
-            if line == "":
-                if self._warned:
-                    self._interrupt_event.set()
-                    break
-                else:
-                    print("[!] Press Enter again to interrupt and send a new message.")
-                    self._warned = True
-                    continue
-            else:
-                buffer = line
-                self._input_result = buffer
-                self._input_event.set()
-                break
-
-    async def get_input(self, prompt="You: "):
-        self._warned = False
-        self._input_event.clear()
-        self._interrupt_event.clear()
-        self._input_result = None
-        loop = asyncio.get_event_loop()
-        self._input_thread = threading.Thread(target=self._input_loop, args=(prompt,))
-        self._input_thread.start()
-        while not self._input_event.is_set() and not self._interrupt_event.is_set():
-            await asyncio.sleep(0.05)
-        if self._interrupt_event.is_set():
-            if self.on_interrupt:
-                self.on_interrupt("")
-            return None
-        return self._input_result
-
-    def interrupt(self):
-        self._interrupt_event.set()
-        if self._input_thread and self._input_thread.is_alive():
-            try:
-                import ctypes
-                ctypes.pythonapi.PyThreadState_SetAsyncExc(ctypes.c_long(self._input_thread.ident), ctypes.py_object(KeyboardInterrupt))
-            except Exception:
-                pass

swarm/cli/async_input_demo.py

@@ -1,32 +0,0 @@
-import asyncio
-import time
-from async_input import AsyncInputHandler
-
-def on_interrupt(_):
-    print("\n[!] Interrupted! Submitting new prompt...")
-
-async def fake_stream_response():
-    for i in range(1, 8):
-        print(f"Bot: streaming token {i}...", flush=True)
-        await asyncio.sleep(1)
-    print("Bot: done!\n")
-
-async def main():
-    handler = AsyncInputHandler(on_interrupt=on_interrupt)
-    while True:
-        user_prompt = await handler.get_input()
-        if user_prompt is None:
-            # Interrupted, start new loop
-            continue
-        print(f"[You submitted]: {user_prompt}")
-        # Simulate streaming response
-        stream_task = asyncio.create_task(fake_stream_response())
-        while not stream_task.done():
-            # Allow user to interrupt during streaming
-            if handler._interrupt_event.is_set():
-                stream_task.cancel()
-                break
-            await asyncio.sleep(0.1)
-
-if __name__ == "__main__":
-    asyncio.run(main())