use std::time::Duration;
use pyo3::prelude::*;
#[pyclass(name = "Timeout", from_py_object)]
#[derive(Debug, Clone)]
pub struct PyTimeout {
pub inner: eggfetch_core::Timeout,
}
#[pymethods]
impl PyTimeout {
#[new]
#[pyo3(signature = (seconds=None, *, pool=None, connect=None, write=None, read=None, total=None))]
fn new(
seconds: Option<f64>,
pool: Option<f64>,
connect: Option<f64>,
write: Option<f64>,
read: Option<f64>,
total: Option<f64>,
) -> PyResult<Self> {
for (name, val) in [
("pool", pool),
("connect", connect),
("write", write),
("read", read),
("total", total),
] {
if let Some(v) = val {
if !v.is_finite() || v < 0.0 {
return Err(PyErr::new::<pyo3::exceptions::PyValueError, _>(format!(
"{name} timeout must be a finite, non-negative number"
)));
}
}
}
if let Some(s) = seconds {
if !s.is_finite() || s < 0.0 {
return Err(PyErr::new::<pyo3::exceptions::PyValueError, _>(
"timeout must be a finite, non-negative number",
));
}
let duration = Duration::from_secs_f64(s);
Ok(Self {
inner: eggfetch_core::Timeout {
pool: pool.map(Duration::from_secs_f64).or(Some(duration)),
connect: connect.map(Duration::from_secs_f64).or(Some(duration)),
write: write.map(Duration::from_secs_f64).or(Some(duration)),
read: read.map(Duration::from_secs_f64).or(Some(duration)),
total: total.map(Duration::from_secs_f64),
},
})
} else {
Ok(Self {
inner: eggfetch_core::Timeout {
pool: pool.map(Duration::from_secs_f64),
connect: connect.map(Duration::from_secs_f64),
write: write.map(Duration::from_secs_f64),
read: read.map(Duration::from_secs_f64),
total: total.map(Duration::from_secs_f64),
},
})
}
}
#[getter]
fn pool(&self) -> Option<f64> {
self.inner.pool.map(|d| d.as_secs_f64())
}
#[getter]
fn connect(&self) -> Option<f64> {
self.inner.connect.map(|d| d.as_secs_f64())
}
#[getter]
fn write(&self) -> Option<f64> {
self.inner.write.map(|d| d.as_secs_f64())
}
#[getter]
fn read(&self) -> Option<f64> {
self.inner.read.map(|d| d.as_secs_f64())
}
#[getter]
fn total(&self) -> Option<f64> {
self.inner.total.map(|d| d.as_secs_f64())
}
fn has_any(&self) -> bool {
self.inner.has_any()
}
fn __repr__(&self) -> String {
fn secs(value: Option<std::time::Duration>) -> String {
match value {
Some(d) => format!("{:?}", d.as_secs_f64()),
None => "None".to_owned(),
}
}
format!(
"Timeout(pool={}, connect={}, write={}, read={}, total={})",
secs(self.inner.pool),
secs(self.inner.connect),
secs(self.inner.write),
secs(self.inner.read),
secs(self.inner.total)
)
}
}