Qubx 1.1.3.dev11__tar.gz → 1.1.3.dev12__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Qubx
-Version: 1.1.3.dev11
+Version: 1.1.3.dev12
 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.dev12}/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.dev12'
+__version_tuple__ = version_tuple = (1, 1, 3, 'dev12')
 
 __commit_id__ = commit_id = None

{qubx-1.1.3.dev11 → qubx-1.1.3.dev12}/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.dev12}/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.dev12}/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
@@ -51,17 +51,13 @@ end
 
 _LUA_GET_REMAINING = """
 local key = KEYS[1]
-local capacity = tonumber(ARGV[1])
-local refill_rate = tonumber(ARGV[2])
-local now = tonumber(ARGV[3])
+local now = tonumber(ARGV[1])
 
 local tokens = tonumber(redis.call('HGET', key, 'tokens'))
-if tokens == nil then return capacity * 1000 end
+if tokens == nil then return -1 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 +68,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
 """
 
@@ -112,12 +108,15 @@ class RedisBackend(IRateLimitBackend):
             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:
+        now = time.time()
+        result = await self._get_remaining_script(
+            keys=[key],
+            args=[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.dev12}/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)