use pyo3::exceptions::PyValueError;
use pyo3::prelude::*;
use std::sync::Mutex;
use std::time::Instant;
use super::pylock::lock;
#[pyclass(frozen)]
pub struct RustTokenBucket {
capacity: f64,
refill_rate: f64,
state: Mutex<BucketState>,
}
struct BucketState {
tokens: f64,
last_refill: Instant,
}
impl BucketState {
fn refill(&mut self, capacity: f64, refill_rate: f64) {
let now = Instant::now();
let elapsed = now.duration_since(self.last_refill).as_secs_f64();
if elapsed > 0.0 {
self.tokens = (self.tokens + elapsed * refill_rate).min(capacity);
self.last_refill = now;
}
}
}
#[pymethods]
impl RustTokenBucket {
#[new]
#[pyo3(signature = (capacity, refill_rate, initial_tokens=None))]
fn new(capacity: f64, refill_rate: f64, initial_tokens: Option<f64>) -> PyResult<Self> {
let tokens = initial_tokens.unwrap_or(capacity);
if !(capacity.is_finite() && capacity > 0.0) {
return Err(PyValueError::new_err("capacity must be a positive number"));
}
if !(refill_rate.is_finite() && refill_rate >= 0.0) {
return Err(PyValueError::new_err(
"refill_rate must be a non-negative number",
));
}
if !(0.0..=capacity).contains(&tokens) {
return Err(PyValueError::new_err(
"initial_tokens must be between 0 and capacity",
));
}
Ok(Self {
capacity,
refill_rate,
state: Mutex::new(BucketState {
tokens,
last_refill: Instant::now(),
}),
})
}
#[pyo3(signature = (tokens=1.0))]
fn acquire(&self, py: Python<'_>, tokens: f64) -> PyResult<bool> {
if !(tokens.is_finite() && tokens >= 0.0) {
return Err(PyValueError::new_err(
"tokens must be a non-negative number",
));
}
let mut state = lock(py, &self.state);
state.refill(self.capacity, self.refill_rate);
if state.tokens >= tokens {
state.tokens -= tokens;
Ok(true)
} else {
Ok(false)
}
}
#[getter]
fn tokens(&self, py: Python<'_>) -> f64 {
let mut state = lock(py, &self.state);
state.refill(self.capacity, self.refill_rate);
state.tokens
}
fn reset(&self, py: Python<'_>) {
let mut state = lock(py, &self.state);
state.tokens = self.capacity;
state.last_refill = Instant::now();
}
}