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 telegram rate limiter
Alishahryar1db57d4d3d221
diff --git a/messaging/handler.py b/messaging/handler.pyindex 9815a43b..f4cbcf25 100644--- a/messaging/handler.py+++ b/messaging/handler.py@@ -96,7 +96,9 @@ class ClaudeMessageHandler:status_msg_id = await self.platform.send_message(incoming.chat_id,status_text,- reply_to=incoming.message_id if incoming.message_id != incoming.message_id else None,+ reply_to=incoming.message_id+ if incoming.message_id != incoming.message_id+ else None,)# Create or extend tree@@ -182,37 +184,26 @@ class ClaudeMessageHandler:nonlocal last_ui_updatenow = time.time()- # Small 1s debounce for UI sanity (not a hard rate limit)- if not force and now - last_ui_update < 1.0:+ # Match UI debounce with platform rate limits to prevent queue bloat+ # Default to 1.0s if rate_window is not available+ debounce = getattr(self.platform, "rate_window", 1.0)+ if not force and now - last_ui_update < debounce:return- # Retry logic for flood wait errors- max_retries = 3 if not force else 5- for attempt in range(max_retries):- try:- display = self._build_message(components, status)- if display:- await self.platform.edit_message(- chat_id, status_msg_id, display, parse_mode="markdown"- )- last_ui_update = now- return # Success, exit retry loop- except Exception as e:- error_msg = str(e).lower()- is_flood_error = "flood" in error_msg or "wait" in error_msg-- if is_flood_error and attempt < max_retries - 1:- # Wait before retry on flood error- wait_time = 2 ** attempt # Exponential backoff: 2s, 4s, 8s- logger.warning(f"Flood wait on edit (attempt {attempt + 1}/{max_retries}), retrying in {wait_time}s...")- await asyncio.sleep(wait_time)- continue- else:- # Log and give up after retries or if not a flood error- if is_flood_error:- last_ui_update = now + 10 # Skip for 10s on persistent flood error- logger.error(f"UI update failed after {attempt + 1} attempts: {e}")- return+ try:+ display = self._build_message(components, status)+ if display:+ # The platform is wrapped in RateLimitedPlatform, so it will wait+ # if globally rate limited or paused.+ await self.platform.edit_message(+ chat_id, status_msg_id, display, parse_mode="markdown"+ )+ last_ui_update = now+ except Exception as e:+ # Log error but don't crash the handler+ logger.error(f"UI update failed: {e}")+ # Don't immediate retry, wait for next scheduled update+ last_ui_update = nowtry:# Get or create CLI session@@ -244,7 +235,9 @@ class ClaudeMessageHandler:incoming.text, session_id=captured_session_id):if not isinstance(event_data, dict):- logger.warning(f"HANDLER: Non-dict event received: {type(event_data)}")+ logger.warning(+ f"HANDLER: Non-dict event received: {type(event_data)}"+ )continueevent_count += 1if event_count % 10 == 0:@@ -302,7 +295,9 @@ class ClaudeMessageHandler:elif parsed["type"] == "error":error_msg = parsed.get("message", "Unknown error")- logger.error(f"HANDLER: Error event received: {error_msg[:200]}")+ logger.error(+ f"HANDLER: Error event received: {error_msg[:200]}"+ )components["errors"].append(error_msg)logger.info(f"HANDLER: Updating UI with error status")# Always force error status to bypass flood wait@@ -346,7 +341,9 @@ class ClaudeMessageHandler:except Exception as e:logger.error(f"Failed to update child status: {e}")except Exception as e:- logger.error(f"HANDLER: Task failed with exception: {type(e).__name__}: {e}")+ logger.error(+ f"HANDLER: Task failed with exception: {type(e).__name__}: {e}"+ )error_msg = str(e)[:200]components["errors"].append(error_msg)# Always force error status to bypass flood wait@@ -368,7 +365,9 @@ class ClaudeMessageHandler:except Exception as e:logger.error(f"Failed to update child status: {e}")finally:- logger.info(f"HANDLER: _process_node completed for node {node_id}, errors={len(components['errors'])}")+ logger.info(+ f"HANDLER: _process_node completed for node {node_id}, errors={len(components['errors'])}"+ )def _build_message(self,diff --git a/messaging/rate_limited_platform.py b/messaging/rate_limited_platform.pyindex 48c70972..2c44fa59 100644--- a/messaging/rate_limited_platform.py+++ b/messaging/rate_limited_platform.py@@ -27,6 +27,11 @@ class RateLimitedPlatform(MessagingPlatform):f"RateLimitedPlatform initialized with {rate_limit} calls per {rate_window}s")+ @property+ def rate_window(self) -> float:+ """Return the rate limit window (period)."""+ return self._limiter.period+@propertydef name(self) -> str:return f"rate_limited_{self._platform.name}"diff --git a/messaging/rate_limiter.py b/messaging/rate_limiter.pyindex c6b4284b..450c9530 100644--- a/messaging/rate_limiter.py+++ b/messaging/rate_limiter.py@@ -1,6 +1,7 @@import asyncioimport loggingimport threading+import timefrom typing import Callable, Any, TypeVar, Coroutinefrom ratelimitqueue import RateLimitQueue@@ -19,12 +20,20 @@ class GlobalRateLimiter:"""def __init__(self, calls: int = 1, period: float = 1.0):+ self._period = periodself.queue = RateLimitQueue(calls=calls, per=period)self._stop_event = threading.Event()+ self._pause_until = 0.0+ self._lock = threading.Lock()self._worker_thread = threading.Thread(target=self._worker, daemon=True)self._worker_thread.start()logger.info(f"GlobalRateLimiter started with {calls} calls per {period}s")+ @property+ def period(self) -> float:+ """Return the rate limit period."""+ return self._period+async def execute(self, func: Callable[[], Coroutine[Any, Any, T]]) -> T:"""Schedule a function to be executed within the rate limit.@@ -37,23 +46,60 @@ class GlobalRateLimiter:def _worker(self):"""Worker thread that pulls from the RateLimitQueue and executes tasks."""+ import concurrent.futures+while not self._stop_event.is_set():try:+ # Check if paused+ with self._lock:+ pause_wait = self._pause_until - time.time()++ if pause_wait > 0:+ logger.warning(+ f"GlobalRateLimiter paused, waiting {pause_wait:.1f}s..."+ )+ # Sleep in small increments to remain responsive to stop event+ time.sleep(min(pause_wait, 1.0))+ continue+# get() blocks based on rate limit- # We don't use timeout here to avoid the skip issue- # instead we depend on the queue blockingitem = self.queue.get(block=True)task_fn, future, loop = item- # Execute the task- async def run_task(f=task_fn, fut=future, l=loop):- try:- result = await f()- l.call_soon_threadsafe(fut.set_result, result)- except Exception as e:- l.call_soon_threadsafe(fut.set_exception, e)+ if future.done():+ self.queue.task_done()+ continue++ # Execute the task and WAIT for it to complete+ # This ensures we don't pull the next item until this one is done,+ # which is critical for detecting and honoring flood waits.+ async def run_task(f=task_fn):+ return await f()++ task_future = asyncio.run_coroutine_threadsafe(run_task(), loop)+ try:+ result = task_future.result()+ if not future.done():+ loop.call_soon_threadsafe(future.set_result, result)+ except (concurrent.futures.CancelledError, asyncio.CancelledError):+ if not future.done():+ loop.call_soon_threadsafe(future.cancel)+ except Exception as e:+ # Detect flood wait (e.g. from Telethon)+ wait_seconds = getattr(e, "seconds", None)+ if wait_seconds:+ logger.error(+ f"GlobalRateLimiter detected flood wait: pausing for {wait_seconds}s"+ )+ with self._lock:+ # Set pause if it's further in the future than current pause+ self._pause_until = max(+ self._pause_until, time.time() + wait_seconds+ )++ if not future.done():+ loop.call_soon_threadsafe(future.set_exception, e)- asyncio.run_coroutine_threadsafe(run_task(), loop)self.queue.task_done()except Exception as e:logger.error(f"Error in GlobalRateLimiter worker: {e}")