Use Claude Code, Codex, VSCode, Pi, and OpenCode (and 6 other harnesses) for free (1.3B+ free tokens) from your terminal, app, IDE, or phone, and now from the browser with native browser sessions (multi-harness + multi-model) like OpenClaw (voice supported + ToS friendly)
Python
fixed replies
Alishahryar11cf32da002b3
diff --git a/messaging/limiter.py b/messaging/limiter.pyindex 37db3ce5..55e72c97 100644--- a/messaging/limiter.py+++ b/messaging/limiter.py@@ -8,7 +8,7 @@ using a leaky bucket algorithm (aiolimiter) and a task queue.import asyncioimport loggingimport os-from typing import Awaitable, Callable, Any, Optional+from typing import Awaitable, Callable, Any, Optional, List, Dictfrom aiolimiter import AsyncLimiterlogger = logging.getLogger(__name__)@@ -52,7 +52,7 @@ class GlobalRateLimiter:# Custom queue stateself._queue_list: List[str] = [] # List of dedup_keys in orderself._queue_map: Dict[- str, tuple[Callable[[], Awaitable[Any]], asyncio.Future]+ str, tuple[Callable[[], Awaitable[Any]], List[asyncio.Future]]] = {}self._condition = asyncio.Condition()@@ -74,7 +74,7 @@ class GlobalRateLimiter:await self._condition.wait()dedup_key = self._queue_list.pop(0)- func, future = self._queue_map.pop(dedup_key)+ func, futures = self._queue_map.pop(dedup_key)# Check for manual pause (FloodWait)now = asyncio.get_event_loop().time()@@ -89,8 +89,9 @@ class GlobalRateLimiter:async with self.limiter:try:result = await func()- if not future.done():- future.set_result(result)+ for f in futures:+ if not f.done():+ f.set_result(result)except Exception as e:# Handle Telegram FloodWaitError specificallyerror_msg = str(e).lower()@@ -107,14 +108,15 @@ class GlobalRateLimiter:asyncio.get_event_loop().time() + seconds)- # Re-queue the task at the front (as a high priority update)- await self._enqueue_internal(- func, future, dedup_key, front=True+ # Re-queue the tasks at the front (as a high priority update)+ await self._enqueue_internal_multi(+ func, futures, dedup_key, front=True)await asyncio.sleep(seconds)else:- if not future.done():- future.set_exception(e)+ for f in futures:+ if not f.done():+ f.set_exception(e)except asyncio.CancelledError:breakexcept Exception as e:@@ -122,18 +124,24 @@ class GlobalRateLimiter:await asyncio.sleep(1)async def _enqueue_internal(self, func, future, dedup_key, front=False):+ async def callback(f):+ # This is just a placeholder to use the same internal logic+ pass++ await self._enqueue_internal_multi(func, [future], dedup_key, front)++ async def _enqueue_internal_multi(self, func, futures, dedup_key, front=False):async with self._condition:if dedup_key in self._queue_map:- # Compaction: Update existing task with new func, keep old future- old_func, old_future = self._queue_map[dedup_key]- self._queue_map[dedup_key] = (func, old_future)- # Chain them so the new one resolves the old caller's future- # but we actually just use the same future object for simplicity- # The user just wants to know when "their" request is done,- # which is now the new request's completion.- logger.debug(f"Compacted task for key: {dedup_key}")+ # Compaction: Update existing task with new func, append new futures+ old_func, old_futures = self._queue_map[dedup_key]+ old_futures.extend(futures)+ self._queue_map[dedup_key] = (func, old_futures)+ logger.debug(+ f"Compacted task for key: {dedup_key} (now {len(old_futures)} futures)"+ )else:- self._queue_map[dedup_key] = (func, future)+ self._queue_map[dedup_key] = (func, futures)if front:self._queue_list.insert(0, dedup_key)else:diff --git a/tests/verify_limiter_v2.py b/tests/verify_limiter_v2.pynew file mode 100644index 00000000..736e6063--- /dev/null+++ b/tests/verify_limiter_v2.py@@ -0,0 +1,77 @@+import asyncio+import time+import os+from messaging.limiter import GlobalRateLimiter++import logging++logging.basicConfig(level=logging.INFO)+logger = logging.getLogger(__name__)+++async def test_compaction_and_hang():+ # Set small rate for testing+ os.environ["MESSAGING_RATE_LIMIT"] = "1"+ os.environ["MESSAGING_RATE_WINDOW"] = "0.5" # Fast for testing++ limiter = await GlobalRateLimiter.get_instance()++ call_counts = {}++ async def mock_edit(msg_id, content):+ call_counts[msg_id] = call_counts.get(msg_id, 0) + 1+ logger.info(f"Executing actual Telegram edit for {msg_id}: {content}")+ await asyncio.sleep(0.1) # Simulate network lag+ return f"result_{content}"++ print("\n--- Starting Hang/Multi-Future Test ---")++ msg_id = "test_msg_123"++ # We will enqueue 3 edits and await all of them.+ # Previously, the 2nd and 3rd would HANG.++ async def task(i):+ logger.info(f"Task {i} started, enqueuing edit...")+ res = await limiter.enqueue(+ lambda i=i: mock_edit(msg_id, f"v{i}"), dedup_key=f"edit:{msg_id}"+ )+ logger.info(f"Task {i} completed with: {res}")+ return res++ start_time = time.time()++ # Run tasks concurrently+ results = await asyncio.gather(task(1), task(2), task(3))++ end_time = time.time()+ duration = end_time - start_time++ print(f"\nAll tasks finished in {duration:.2f}s")+ print(f"Results: {results}")+ print(f"Call counts: {call_counts}")++ # Check that they all got the LAST result+ for res in results:+ assert res == "result_v3", f"Expected result_v3, got {res}"++ # Check that they didn't hang (should be < 1s given the compaction)+ assert duration < 2.0, "Tasks took too long, might have hung or not compacted"++ # Check call counts:+ # T1 might go through immediately or be compacted if T2/T3 arrive fast enough.+ # Given the loop speed, we expect 1-2 calls.+ assert call_counts[msg_id] <= 2, f"Too many calls: {call_counts[msg_id]}"++ print("\nPASSED: All futures resolved, no hang detected.")+++if __name__ == "__main__":+ # Fix encoding for windows terminal to avoid Unicode print crash+ import sys+ import io++ if sys.platform == "win32":+ sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding="utf-8")++ asyncio.run(test_compaction_and_hang())