fix: resolve all CI failures (clippy, E0282, dead code, Windows poetry)

Made-with: Cursor

Author: alihaskar

.github/workflows/ci.yml

@@ -48,9 +48,11 @@ jobs:
           key: venv-${{ matrix.os }}-${{ matrix.python-version }}-${{ hashFiles('poetry.lock') }}
 
       - name: Install Python dependencies
+        shell: bash
         run: poetry install --with dev
 
       - name: Build Rust extension (release)
+        shell: bash
         working-directory: rust_engine
         run: poetry run maturin develop --release
 
@@ -71,10 +73,13 @@ jobs:
       # ── Python checks ─────────────────────────────────────────────────────
 
       - name: Ruff lint
+        shell: bash
         run: poetry run ruff check src/ tests/
 
       - name: Ruff format check
+        shell: bash
         run: poetry run ruff format --check src/ tests/
 
       - name: pytest (unit + integration)
+        shell: bash
         run: poetry run pytest tests/ -v --tb=short

rust_engine/src/bybit.rs

@@ -52,9 +52,9 @@ pub struct MarketUpdate {
     /// where score_X = liquidity_beyond_gap_X / (gap_distance_X + ε).
     ///
     /// Interpretation (contrarian):
-    ///   > 0.5 → more resistance on ask side → price likely goes down
-    ///   < 0.5 → more support on bid side   → price likely goes up
-    ///   ≈ 0.5 → balanced
+    /// - above 0.5: more resistance on ask side → price likely goes down
+    /// - below 0.5: more support on bid side → price likely goes up
+    /// - near 0.5: balanced
     pub gap_prob_resistance_up: f64,
     pub gap_distance_up: u64,
     pub gap_distance_dn: u64,
@@ -91,8 +91,6 @@ struct LevelKey {
 pub struct OrderBookState {
     book: OrderBook<()>,
     levels: HashMap<LevelKey, OrderId>,
-    prev_best_bid: Option<u128>,
-    prev_best_ask: Option<u128>,
     /// Tick size in scaled integer units (price_f64 * PRICE_SCALE).
     tick_size_scaled: u128,
 }
@@ -103,8 +101,6 @@ impl OrderBookState {
         Self {
             book: OrderBook::<()>::new(symbol),
             levels: HashMap::new(),
-            prev_best_bid: None,
-            prev_best_ask: None,
             tick_size_scaled,
         }
     }
@@ -114,8 +110,6 @@ impl OrderBookState {
         *self = Self {
             book: OrderBook::<()>::new(symbol),
             levels: HashMap::new(),
-            prev_best_bid: None,
-            prev_best_ask: None,
             tick_size_scaled,
         };
     }
@@ -162,15 +156,6 @@ impl OrderBookState {
         }
     }
 
-    pub fn get_best_bid_ask(&self) -> Option<(f64, f64)> {
-        let best_bid = self.book.best_bid()?;
-        let best_ask = self.book.best_ask()?;
-        Some((
-            (best_bid as f64) / PRICE_SCALE,
-            (best_ask as f64) / PRICE_SCALE,
-        ))
-    }
-
     pub fn get_enriched_update(
         &self,
         symbol: &str,
@@ -308,15 +293,6 @@ impl OrderBookState {
             liquidity_dn,
         )
     }
-
-    pub fn update_and_check_change(&mut self) -> bool {
-        let best_bid = self.book.best_bid();
-        let best_ask = self.book.best_ask();
-        let changed = self.prev_best_bid != best_bid || self.prev_best_ask != best_ask;
-        self.prev_best_bid = best_bid;
-        self.prev_best_ask = best_ask;
-        changed
-    }
 }
 
 pub async fn start_bybit_streams(symbol: &str) -> Result<mpsc::Receiver<BybitMessage>> {
@@ -577,16 +553,16 @@ mod tests {
         add_bid(&mut state, 100.00, 1.0);
         add_ask(&mut state, 100.10, 1.0);
 
-        // Symmetrical gaps: 5 empty ticks then same liquidity on both sides
-        add_ask(&mut state, 100.60, 500.0); // 5 ticks gap up
-        add_bid(&mut state, 99.50, 500.0); // 5 ticks gap down
+        // 4 empty ticks between best ask (100.10) and next ask (100.60)
+        add_ask(&mut state, 100.60, 500.0); // 4 empty ticks above best ask
+        add_bid(&mut state, 99.50, 500.0); // 4 empty ticks below best bid
 
         let bid = state.book.best_bid().unwrap();
         let ask = state.book.best_ask().unwrap();
         let (score, gap_up, gap_dn, liq_up, liq_dn) = state.calculate_gap_probability(bid, ask);
 
-        assert_eq!(gap_up, 5, "should detect 5-tick gap up");
-        assert_eq!(gap_dn, 5, "should detect 5-tick gap down");
+        assert_eq!(gap_up, 4, "should detect 4 empty ticks above best ask");
+        assert_eq!(gap_dn, 4, "should detect 4 empty ticks below best bid");
         assert!(liq_up > 0);
         assert!(liq_dn > 0);
         // Balanced → score ≈ 0.5
@@ -651,16 +627,20 @@ mod tests {
         add_bid(&mut state, 3000.00, 1.0);
         add_ask(&mut state, 3000.01, 1.0);
 
-        // 10 tick gap up, 0 tick gap down (next level immediately)
+        // 9 empty ticks between best ask (3000.01) and next ask (3000.11)
+        // 0 empty ticks below best bid (2999.99 is immediately adjacent)
         add_ask(&mut state, 3000.11, 500.0);
         add_bid(&mut state, 2999.99, 500.0);
 
         let bid = state.book.best_bid().unwrap();
         let ask = state.book.best_ask().unwrap();
         let (_, gap_up, gap_dn, _, _) = state.calculate_gap_probability(bid, ask);
 
-        assert_eq!(gap_up, 10, "should detect 10-tick gap with 0.01 tick size");
-        assert_eq!(gap_dn, 0, "should detect 0-tick gap (immediate liquidity)");
+        assert_eq!(gap_up, 9, "should detect 9 empty ticks with 0.01 tick size");
+        assert_eq!(
+            gap_dn, 0,
+            "should detect 0 empty ticks (immediate liquidity)"
+        );
     }
 
     #[test]

rust_engine/src/execution.rs

@@ -154,6 +154,7 @@ impl PositionState {
         self.positions.get(symbol).map(|r| r.value().clone())
     }
 
+    #[allow(dead_code)]
     pub fn update_position(&self, position: Position) {
         self.positions.insert(position.symbol.clone(), position);
     }
@@ -504,6 +505,7 @@ struct BybitResponse<T> {
 }
 
 #[derive(Debug, Deserialize)]
+#[allow(dead_code)]
 pub struct SubmitOrderResponse {
     #[serde(rename = "orderId")]
     pub order_id: String,
@@ -512,6 +514,7 @@ pub struct SubmitOrderResponse {
 }
 
 #[derive(Debug, Deserialize)]
+#[allow(dead_code)]
 pub struct AmendOrderResponse {
     #[serde(rename = "orderId")]
     pub order_id: String,
@@ -520,6 +523,7 @@ pub struct AmendOrderResponse {
 }
 
 #[derive(Debug, Deserialize)]
+#[allow(dead_code)]
 pub struct CancelOrderResponse {
     #[serde(rename = "orderId")]
     pub order_id: String,
@@ -567,6 +571,7 @@ pub struct ExecutionEngine {
 }
 
 impl ExecutionEngine {
+    #[allow(clippy::too_many_arguments)]
     pub fn new(
         api_key: String,
         api_secret: String,

rust_engine/src/lib.rs

@@ -168,11 +168,11 @@ impl TradingNode {
     }
 
     fn __repr__(&self) -> String {
-        format!("TradingNode()")
+        "TradingNode()".to_string()
     }
 
     fn __str__(&self) -> String {
-        format!("TradingNode for Bybit orderbook streaming")
+        "TradingNode for Bybit orderbook streaming".to_string()
     }
 }
 
@@ -192,6 +192,7 @@ struct ExecutionNode {
 #[pymethods]
 impl ExecutionNode {
     #[new]
+    #[allow(clippy::too_many_arguments)]
     fn new(
         api_key: String,
         api_secret: String,
@@ -430,11 +431,11 @@ impl ExecutionNode {
     }
 
     fn __repr__(&self) -> String {
-        format!("ExecutionNode()")
+        "ExecutionNode()".to_string()
     }
 
     fn __str__(&self) -> String {
-        format!("ExecutionNode for Bybit order execution")
+        "ExecutionNode for Bybit order execution".to_string()
     }
 }
 

rust_engine/src/main.rs

@@ -1,7 +1,7 @@
 mod bybit;
 
 use anyhow::Result;
-use bybit::{process_orderbook_updates, start_bybit_streams};
+use bybit::{process_orderbook_updates, start_bybit_streams, MarketUpdate};
 use rustls::crypto::ring;
 
 #[tokio::main]
@@ -11,7 +11,7 @@ async fn main() -> Result<()> {
 
     let rx = start_bybit_streams("BTCUSDT").await?;
 
-    process_orderbook_updates(rx, |update| {
+    process_orderbook_updates(rx, 0.1, |update: MarketUpdate| {
         println!(
             "[{}] {} | Best Bid: {:.2} | Best Ask: {:.2} | Spread: {:.2}",
             update.source, update.symbol, update.bid, update.ask, update.spread

rust_engine/src/private_ws.rs

@@ -39,6 +39,7 @@ pub struct ExecutionReport {
 }
 
 #[derive(Debug, Clone)]
+#[allow(dead_code)]
 pub struct FillEvent {
     pub symbol: String,
     pub order_id: String,
@@ -53,6 +54,7 @@ pub struct FillEvent {
 }
 
 #[derive(Debug, Deserialize)]
+#[allow(dead_code)]
 struct PrivateMessage {
     topic: String,
     #[serde(rename = "creationTime")]
@@ -142,14 +144,12 @@ async fn connect_and_stream(
     eprintln!("Sent authentication request...");
 
     // Wait for auth response
-    if let Some(Ok(msg)) = read.next().await {
-        if let Message::Text(text) = msg {
-            eprintln!("Auth response: {}", text);
-            if text.contains("\"success\":true") {
-                eprintln!("✓ Authentication successful");
-            } else {
-                return Err(anyhow::anyhow!("Authentication failed: {}", text));
-            }
+    if let Some(Ok(Message::Text(text))) = read.next().await {
+        eprintln!("Auth response: {}", text);
+        if text.contains("\"success\":true") {
+            eprintln!("✓ Authentication successful");
+        } else {
+            return Err(anyhow::anyhow!("Authentication failed: {}", text));
         }
     }