Qubx 1.1.3.dev11__tar.gz → 1.1.3.dev13__tar.gz

{qubx-1.1.3.dev11 → qubx-1.1.3.dev13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Qubx
-Version: 1.1.3.dev11
+Version: 1.1.3.dev13
 Summary: Qubx - Quantitative Trading Framework
 Project-URL: homepage, https://xlydian.com
 Project-URL: repository, https://github.com/xLydianSoftware/Qubx

{qubx-1.1.3.dev11 → qubx-1.1.3.dev13}/src/qubx/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.1.3.dev11'
-__version_tuple__ = version_tuple = (1, 1, 3, 'dev11')
+__version__ = version = '1.1.3.dev13'
+__version_tuple__ = version_tuple = (1, 1, 3, 'dev13')
 
 __commit_id__ = commit_id = None

{qubx-1.1.3.dev11 → qubx-1.1.3.dev13}/src/qubx/core/context.py

@@ -161,6 +161,7 @@ class StrategyContext(IStrategyContext):
         state_snapshot_interval: str | None = None,
         rate_limit_backend: Any | None = None,
         rate_limiting_config: Any | None = None,
+        event_loop: "asyncio.AbstractEventLoop | None" = None,
     ) -> None:
         self.account = account
         self.strategy = self.__instantiate_strategy(strategy, config)
@@ -194,6 +195,7 @@ class StrategyContext(IStrategyContext):
         self._state_snapshot_interval = state_snapshot_interval
         self._rate_limit_backend = rate_limit_backend
         self._rate_limiting_config = rate_limiting_config
+        self.event_loop = event_loop
 
         # Initialize shutdown handling
         self._stop_lock = Lock()

{qubx-1.1.3.dev11 → qubx-1.1.3.dev13}/src/qubx/core/mixins/processing.py

@@ -314,22 +314,18 @@ class ProcessingManager(IProcessingManager):
     def _emit_rate_limit_metrics(self, ctx) -> None:
         """Emit rate limit metrics for all registered rate limiters."""
         import asyncio
+        import concurrent.futures
 
-        if ctx.emitter is None:
+        if ctx.emitter is None or ctx.event_loop is None:
             return
 
         for exchange_name, rate_limiter in ctx.rate_limiters.items():
             try:
-                # collect_metrics is async but we're in sync context
-                loop = asyncio.get_event_loop()
-                if loop.is_running():
-                    future = asyncio.ensure_future(rate_limiter.collect_metrics())
-                    future.add_done_callback(
-                        lambda f, _ctx=ctx: self._do_emit_metrics(_ctx, f.result()) if not f.cancelled() else None
-                    )
-                else:
-                    metrics = loop.run_until_complete(rate_limiter.collect_metrics())
-                    self._do_emit_metrics(ctx, metrics)
+                future = asyncio.run_coroutine_threadsafe(rate_limiter.collect_metrics(), ctx.event_loop)
+                metrics = future.result(timeout=5)
+                self._do_emit_metrics(ctx, metrics)
+            except concurrent.futures.TimeoutError:
+                logger.warning(f"Rate limit metrics collection timed out for {exchange_name}")
             except Exception as e:
                 logger.error(f"Failed to collect rate limit metrics for {exchange_name}: {e}")
 

{qubx-1.1.3.dev11 → qubx-1.1.3.dev13}/src/qubx/rate_limiting/backend.py

@@ -33,11 +33,16 @@ class IRateLimitBackend(ABC):
         """
 
     @abstractmethod
-    async def get_remaining(self, key: str) -> float | None:
+    async def get_remaining(self, key: str, capacity: float = 0, refill_rate: float = 0) -> float | None:
         """Get remaining tokens for a key (non-blocking).
 
+        Args:
+            key: Bucket identifier
+            capacity: Pool capacity (for computing refill on read)
+            refill_rate: Tokens per second (for computing refill on read)
+
         Returns:
-            Token count, or None if key doesn't exist
+            Token count (with refill applied), or None if key doesn't exist
         """
 
     @abstractmethod
@@ -70,7 +75,7 @@ class InMemoryBackend(IRateLimitBackend):
         await limiter.acquire(weight)
         return time.monotonic() - start
 
-    async def get_remaining(self, key: str) -> float | None:
+    async def get_remaining(self, key: str, capacity: float = 0, refill_rate: float = 0) -> float | None:
         limiter = self._limiters.get(key)
         if limiter is None:
             return None

{qubx-1.1.3.dev11 → qubx-1.1.3.dev13}/src/qubx/rate_limiting/engine.py

@@ -333,7 +333,7 @@ class ExchangeRateLimiter:
             remaining = self._quota_remaining.get(pool_name, 0)
         else:
             key = self._key_for(pool)
-            remaining = await self._backend.get_remaining(key)
+            remaining = await self._backend.get_remaining(key, pool.capacity, pool.refill_rate)
             if remaining is None:
                 remaining = pool.capacity
 

{qubx-1.1.3.dev11 → qubx-1.1.3.dev13}/src/qubx/rate_limiting/redis_backend.py

@@ -35,7 +35,7 @@ tokens = math.min(capacity, tokens + tokens_to_add)
 if tokens >= weight then
     tokens = tokens - weight
     redis.call('HSET', key, 'tokens', tokens, 'last_refill', now)
-    redis.call('EXPIRE', key, 300)  -- 5 min TTL to auto-cleanup stale keys
+    redis.call('EXPIRE', key, 600)  -- 10 min TTL to auto-cleanup stale keys
     return 0  -- no wait needed
 else
     -- Calculate wait time
@@ -56,12 +56,18 @@ local refill_rate = tonumber(ARGV[2])
 local now = tonumber(ARGV[3])
 
 local tokens = tonumber(redis.call('HGET', key, 'tokens'))
-if tokens == nil then return capacity * 1000 end
+if tokens == nil then return -1 end
+
+-- Compute refilled value (same logic as acquire)
+if refill_rate > 0 then
+    local last_refill = tonumber(redis.call('HGET', key, 'last_refill') or now)
+    local elapsed = now - last_refill
+    local tokens_to_add = elapsed * refill_rate
+    tokens = math.min(capacity, tokens + tokens_to_add)
+end
 
-local last_refill = tonumber(redis.call('HGET', key, 'last_refill') or now)
-local elapsed = now - last_refill
-local tokens_to_add = elapsed * refill_rate
-tokens = math.min(capacity, tokens + tokens_to_add)
+-- Refresh TTL on read (keeps keys alive while bot is running)
+redis.call('EXPIRE', key, 600)
 
 return math.floor(tokens * 1000)  -- return as millitokens for precision
 """
@@ -72,7 +78,7 @@ local remaining = tonumber(ARGV[1])
 local now = tonumber(ARGV[2])
 
 redis.call('HSET', key, 'tokens', remaining, 'last_refill', now)
-redis.call('EXPIRE', key, 300)
+redis.call('EXPIRE', key, 600)
 return 1
 """
 
@@ -111,13 +117,16 @@ class RedisBackend(IRateLimitBackend):
             await __import__("asyncio").sleep(wait_s)
             now = time.time()
 
-    async def get_remaining(self, key: str) -> float | None:
-        # We need capacity and refill_rate to compute remaining after refill,
-        # but we don't have them here. Return raw stored tokens.
-        raw = await self._redis.hget(key, "tokens")
-        if raw is None:
+    async def get_remaining(self, key: str, capacity: float = 0, refill_rate: float = 0) -> float | None:
+        now = time.time()
+        result = await self._get_remaining_script(
+            keys=[key],
+            args=[capacity, refill_rate, now],
+        )
+        result = float(result)
+        if result < 0:
             return None
-        return float(raw)
+        return result / 1000.0  # convert millitokens back
 
     async def set_remaining(self, key: str, remaining: float) -> None:
         now = time.time()

{qubx-1.1.3.dev11 → qubx-1.1.3.dev13}/src/qubx/utils/runner/runner.py

@@ -657,12 +657,9 @@ def create_strategy_context(
         state_snapshot_interval=_state_snapshot_interval,
         rate_limit_backend=_rate_limit_backend,
         rate_limiting_config=_rate_limiting_config,
+        event_loop=loop,
     )
 
-    # Store the shared event loop reference for cleanup
-    if loop is not None:
-        ctx._shared_event_loop = loop  # type: ignore
-
     # Set context for metric emitters to enable is_live tag and time access
     if _metric_emitter is not None:
         _metric_emitter.set_context(ctx)