fix(rate-limiter): cargo fmt and pylint E0606 for CI

- Run cargo fmt on engine.rs and benches/rate_limiter.rs
- Add _RateLimiterEngine sentinel assignment to fix pylint
  possibly-used-before-assignment (E0606) when RATE_LIMITER_FORCE_PYTHON
  skips the import block

Signed-off-by: Pratik Gandhi <gandhipratik203@gmail.com>

Author: gandhipratik203

plugins/rate_limiter/rate_limiter.py

@@ -58,6 +58,7 @@
 # ---------------------------------------------------------------------------
 
 _RATE_LIMITER_FORCE_PYTHON = os.environ.get("RATE_LIMITER_FORCE_PYTHON", "").strip().lower() in ("1", "true", "yes")
+_RateLimiterEngine: Any = None  # Assigned below when the Rust extension is available.
 
 if _RATE_LIMITER_FORCE_PYTHON:
     _RUST_AVAILABLE = False

plugins_rust/rate_limiter/benches/rate_limiter.rs

@@ -12,11 +12,7 @@ use std::hint::black_box;
 use std::sync::Arc;
 
 use criterion::{Criterion, criterion_group, criterion_main};
-use rate_limiter_rust::{
-    clock::FakeClock,
-    config::Algorithm,
-    memory::MemoryStore,
-};
+use rate_limiter_rust::{clock::FakeClock, config::Algorithm, memory::MemoryStore};
 
 const T0_UNIX: i64 = 1_000_000;
 const LIMIT: u64 = 100;
@@ -90,9 +86,30 @@ fn bench_multi_dim(c: &mut Criterion) {
             handle.advance_secs(61);
             let now_mono = handle.monotonic_nanos();
             let now_unix = handle.unix_secs();
-            let _r1 = store.check_and_increment("user:alice", LIMIT, WINDOW, Algorithm::FixedWindow, now_mono, now_unix);
-            let _r2 = store.check_and_increment("tenant:acme", LIMIT * 100, WINDOW, Algorithm::FixedWindow, now_mono, now_unix);
-            let _r3 = store.check_and_increment("tool:search", LIMIT / 10, WINDOW, Algorithm::FixedWindow, now_mono, now_unix);
+            let _r1 = store.check_and_increment(
+                "user:alice",
+                LIMIT,
+                WINDOW,
+                Algorithm::FixedWindow,
+                now_mono,
+                now_unix,
+            );
+            let _r2 = store.check_and_increment(
+                "tenant:acme",
+                LIMIT * 100,
+                WINDOW,
+                Algorithm::FixedWindow,
+                now_mono,
+                now_unix,
+            );
+            let _r3 = store.check_and_increment(
+                "tool:search",
+                LIMIT / 10,
+                WINDOW,
+                Algorithm::FixedWindow,
+                now_mono,
+                now_unix,
+            );
         })
     });
 }
@@ -133,7 +150,14 @@ fn bench_fixed_window_blocked(c: &mut Criterion) {
     let now_mono = handle.monotonic_nanos();
     let now_unix = handle.unix_secs();
     for _ in 0..LIMIT {
-        store.check_and_increment("user:blocked", LIMIT, WINDOW, Algorithm::FixedWindow, now_mono, now_unix);
+        store.check_and_increment(
+            "user:blocked",
+            LIMIT,
+            WINDOW,
+            Algorithm::FixedWindow,
+            now_mono,
+            now_unix,
+        );
     }
     // Now every call hits the blocked path
     c.bench_function("fixed_window/blocked_path", |b| {

plugins_rust/rate_limiter/src/engine.rs

@@ -18,8 +18,8 @@ use std::sync::Arc;
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyList};
 
-use pyo3_stub_gen::derive::*;
 use pyo3_async_runtimes::tokio::future_into_py;
+use pyo3_stub_gen::derive::*;
 
 use crate::clock::{Clock, SystemClock};
 use crate::config::{ConfigError, EngineConfig};
@@ -312,7 +312,12 @@ impl RateLimiterEngine {
                     let meta = PyDict::new(py);
                     meta.set_item("limited", false)?;
                     let tup = pyo3::types::PyTuple::new(
-                        py, [true.into_pyobject(py)?.to_owned().into_any(), headers.into_any(), meta.into_any()],
+                        py,
+                        [
+                            true.into_pyobject(py)?.to_owned().into_any(),
+                            headers.into_any(),
+                            meta.into_any(),
+                        ],
                     )?;
                     Ok(tup.into())
                 })
@@ -334,7 +339,12 @@ impl RateLimiterEngine {
                         .into_iter()
                         .map(|(key, limit_count, window_nanos)| {
                             store.check_and_increment(
-                                &key, limit_count, window_nanos, algorithm, now_mono, now_unix,
+                                &key,
+                                limit_count,
+                                window_nanos,
+                                algorithm,
+                                now_mono,
+                                now_unix,
                             )
                         })
                         .collect()
@@ -350,7 +360,12 @@ impl RateLimiterEngine {
                 let headers = build_headers_dict(py, &eval, include_retry_after)?;
                 let meta = build_meta_dict(py, &eval, now_unix)?;
                 let tup = pyo3::types::PyTuple::new(
-                    py, [eval.allowed.into_pyobject(py)?.to_owned().into_any(), headers.into_any(), meta.into_any()],
+                    py,
+                    [
+                        eval.allowed.into_pyobject(py)?.to_owned().into_any(),
+                        headers.into_any(),
+                        meta.into_any(),
+                    ],
                 )?;
                 Ok(tup.into())
             })
@@ -365,7 +380,12 @@ impl RateLimiterEngine {
 impl RateLimiterEngine {
     /// Build dimension checks from engine config.
     /// Mirrors Python `_build_rust_checks()` but runs in Rust.
-    fn build_checks(&self, user: &str, tenant: Option<&str>, tool: &str) -> Vec<(String, u64, u64)> {
+    fn build_checks(
+        &self,
+        user: &str,
+        tenant: Option<&str>,
+        tool: &str,
+    ) -> Vec<(String, u64, u64)> {
         let mut checks = Vec::with_capacity(3);
         if let Some(ref rl) = self.config.by_user {
             checks.push((format!("user:{}", user), rl.count, rl.window_nanos));