use std::time::Duration;
use pyo3::prelude::*;
#[pyclass(name = "Timeout", from_py_object)]
#[derive(Debug, Clone)]
pub struct PyTimeout {
pub inner: eggfetch_core::Timeout,
}
fn secs_to_duration(value: f64, name: &str) -> PyResult<Duration> {
Duration::try_from_secs_f64(value).map_err(|_| {
PyErr::new::<pyo3::exceptions::PyValueError, _>(format!("{name} timeout is too large"))
})
}
#[pymethods]
impl PyTimeout {
#[new]
#[pyo3(signature = (seconds=None, *, pool=None, connect=None, write=None, read=None, total=None))]
fn new(
seconds: Option<&Bound<'_, PyAny>>,
pool: Option<&Bound<'_, PyAny>>,
connect: Option<&Bound<'_, PyAny>>,
write: Option<&Bound<'_, PyAny>>,
read: Option<&Bound<'_, PyAny>>,
total: Option<&Bound<'_, PyAny>>,
) -> PyResult<Self> {
let seconds = crate::conversion::extract_optional_secs(seconds, "timeout")?;
let pool = crate::conversion::extract_optional_secs(pool, "pool")?;
let connect = crate::conversion::extract_optional_secs(connect, "connect")?;
let write = crate::conversion::extract_optional_secs(write, "write")?;
let read = crate::conversion::extract_optional_secs(read, "read")?;
let total = crate::conversion::extract_optional_secs(total, "total")?;
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 = secs_to_duration(s, "timeout")?;
Ok(Self {
inner: eggfetch_core::Timeout {
pool: pool
.map(|v| secs_to_duration(v, "pool"))
.transpose()?
.or(Some(duration)),
connect: connect
.map(|v| secs_to_duration(v, "connect"))
.transpose()?
.or(Some(duration)),
write: write
.map(|v| secs_to_duration(v, "write"))
.transpose()?
.or(Some(duration)),
read: read
.map(|v| secs_to_duration(v, "read"))
.transpose()?
.or(Some(duration)),
total: total.map(|v| secs_to_duration(v, "total")).transpose()?,
},
})
} else {
Ok(Self {
inner: eggfetch_core::Timeout {
pool: pool.map(|v| secs_to_duration(v, "pool")).transpose()?,
connect: connect
.map(|v| secs_to_duration(v, "connect"))
.transpose()?,
write: write.map(|v| secs_to_duration(v, "write")).transpose()?,
read: read.map(|v| secs_to_duration(v, "read")).transpose()?,
total: total.map(|v| secs_to_duration(v, "total")).transpose()?,
},
})
}
}
#[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)
)
}
}