use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex};
use pyo3::prelude::*;
use crate::cookies::PyCookies;
use crate::errors::map_err;
use crate::response::PyResponse;
use crate::streaming::PyStreamingResponse;
use crate::trace_bridge::take_callback_error;
pub(crate) struct RuntimeState {
runtime: Mutex<Option<tokio::runtime::Runtime>>,
shutdown_requested: AtomicBool,
}
impl RuntimeState {
fn new(runtime: tokio::runtime::Runtime) -> Self {
Self {
runtime: Mutex::new(Some(runtime)),
shutdown_requested: AtomicBool::new(false),
}
}
fn handle(&self) -> Option<tokio::runtime::Handle> {
self.runtime
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.as_ref()
.map(tokio::runtime::Runtime::handle)
.cloned()
}
fn request_shutdown(self: &Arc<Self>) {
self.shutdown_requested.store(true, Ordering::Release);
self.try_shutdown();
}
fn try_shutdown(self: &Arc<Self>) {
if !self.shutdown_requested.load(Ordering::Acquire) {
return;
}
if Arc::strong_count(self) != 1 {
return;
}
let mut guard = self
.runtime
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
if !self.shutdown_requested.load(Ordering::Acquire) {
return;
}
if Arc::strong_count(self) != 1 {
return;
}
if let Some(runtime) = guard.take() {
runtime.shutdown_background();
}
}
}
#[derive(Clone)]
pub(crate) struct RuntimeGuard(Arc<RuntimeState>);
impl Drop for RuntimeGuard {
fn drop(&mut self) {
self.0.try_shutdown();
}
}
#[pyclass(name = "Client")]
pub struct PyClient {
runtime: std::sync::Mutex<Option<Arc<RuntimeState>>>,
client: Mutex<Option<eggfetch_core::Client>>,
decompress: Option<bool>,
verify_disabled: bool,
redirect_policy: eggfetch_core::redirect::RedirectPolicy,
}
#[pymethods]
impl PyClient {
#[allow(clippy::too_many_arguments)]
#[new]
#[pyo3(signature = (*, headers=None, timeout=None, follow_redirects=None, max_redirects=None, cookies=None, auth=None, decompress=None, proxy=None, verify=None, cert=None, retries=None, http1=None, http2=None, http3=None, limits=None, trust_env=None, local_address=None, socket_options=None, uds=None))]
fn new(
py: Python<'_>,
headers: Option<&Bound<'_, PyAny>>,
timeout: Option<&Bound<'_, PyAny>>,
follow_redirects: Option<bool>,
max_redirects: Option<usize>,
cookies: Option<&Bound<'_, PyAny>>,
auth: Option<&Bound<'_, PyAny>>,
decompress: Option<bool>,
proxy: Option<&Bound<'_, PyAny>>,
verify: Option<&Bound<'_, PyAny>>,
cert: Option<&Bound<'_, PyAny>>,
retries: Option<&Bound<'_, PyAny>>,
http1: Option<bool>,
http2: Option<bool>,
http3: Option<bool>,
limits: Option<&Bound<'_, PyAny>>,
trust_env: Option<bool>,
local_address: Option<&str>,
socket_options: Option<&Bound<'_, PyAny>>,
uds: Option<&str>,
) -> PyResult<Self> {
let prepared = crate::request_preparation::prepare_client_config(
py,
headers,
timeout,
follow_redirects,
max_redirects,
cookies,
auth,
decompress,
proxy,
verify,
cert,
retries,
http1,
http2,
http3,
limits,
trust_env,
local_address,
socket_options,
uds,
)?;
let runtime = Arc::new(RuntimeState::new(
py.detach(tokio::runtime::Runtime::new)
.map_err(|e| PyErr::new::<pyo3::exceptions::PyRuntimeError, _>(e.to_string()))?,
));
let verify_disabled = prepared.verify_disabled;
let decompress = prepared.decompress;
let redirect_policy = prepared.redirect_policy.clone();
let client = crate::request_preparation::apply_client_config(prepared)?;
Ok(Self {
runtime: std::sync::Mutex::new(Some(runtime)),
client: Mutex::new(Some(client)),
decompress,
verify_disabled,
redirect_policy,
})
}
#[pyo3(signature = (method, url, *, headers=None, params=None, content=None, data=None, json=None, files=None, timeout=None, cookies=None, auth=None, follow_redirects=None, max_redirects=None, decompress=None, proxy=None, verify=None, cert=None, retries=None, extensions=None))]
#[allow(clippy::too_many_arguments)]
#[allow(clippy::too_many_lines)]
fn request<'py>(
&self,
py: Python<'py>,
method: &str,
url: &str,
headers: Option<&Bound<'py, PyAny>>,
params: Option<&Bound<'py, PyAny>>,
content: Option<&Bound<'py, PyAny>>,
data: Option<&Bound<'py, PyAny>>,
json: Option<&Bound<'py, PyAny>>,
files: Option<&Bound<'py, PyAny>>,
timeout: Option<&Bound<'py, PyAny>>,
cookies: Option<&Bound<'py, PyAny>>,
auth: Option<&Bound<'py, PyAny>>,
follow_redirects: Option<bool>,
max_redirects: Option<usize>,
decompress: Option<bool>,
proxy: Option<&Bound<'py, PyAny>>,
verify: Option<&Bound<'py, PyAny>>,
cert: Option<&Bound<'py, PyAny>>,
retries: Option<&Bound<'py, PyAny>>,
extensions: Option<&Bound<'py, PyAny>>,
) -> PyResult<Bound<'py, PyAny>> {
self.ensure_not_closed()?;
if verify.is_some() || cert.is_some() {
return Err(PyErr::new::<crate::errors::UnsupportedKwarg, _>(
"verify and cert are client-level only; set them on the Client() constructor",
));
}
let prepared = crate::request_preparation::prepare_request(
py,
method,
url,
headers,
params,
content,
data,
json,
files,
timeout,
cookies,
auth,
follow_redirects,
max_redirects,
proxy,
retries,
extensions,
false,
)?;
let client = self.clone_client()?;
let dispatch = crate::request_preparation::prepare_core_dispatch(
&client,
prepared,
crate::request_preparation::RequestDispatchDefaults {
redirect_policy: self.redirect_policy.clone(),
decompress: decompress.or(self.decompress),
},
)?;
let trace_slot = dispatch.trace_error_slot.clone();
let builder = dispatch.builder;
let (runtime_guard, runtime_handle) = self.runtime_for_dispatch()?;
let result = py.detach(|| {
runtime_handle.block_on(async {
let mut response = Box::pin(builder.send()).await.map_err(map_err)?;
let content = response.bytes().await.map_err(map_err)?;
Ok::<_, PyErr>((response, content))
})
});
if let Some(slot) = trace_slot {
if let Some(err) = take_callback_error(&slot) {
return Err(err);
}
}
let (mut response, content) = result?;
let runtime_lease = crate::streaming::RuntimeLease::new(runtime_guard);
let py_response = PyResponse::from_core_response_with_body(
&mut response,
content,
Some(&runtime_handle),
Some(&runtime_lease),
false,
)?;
Ok(Py::new(py, py_response)?.into_bound(py).into_any())
}
#[pyo3(signature = (url, *, headers=None, params=None, timeout=None, cookies=None, auth=None, follow_redirects=None, max_redirects=None, decompress=None, proxy=None, verify=None, cert=None, retries=None, extensions=None))]
#[allow(clippy::too_many_arguments)]
fn get<'py>(
&self,
py: Python<'py>,
url: &str,
headers: Option<&Bound<'py, PyAny>>,
params: Option<&Bound<'py, PyAny>>,
timeout: Option<&Bound<'py, PyAny>>,
cookies: Option<&Bound<'py, PyAny>>,
auth: Option<&Bound<'py, PyAny>>,
follow_redirects: Option<bool>,
max_redirects: Option<usize>,
decompress: Option<bool>,
proxy: Option<&Bound<'py, PyAny>>,
verify: Option<&Bound<'py, PyAny>>,
cert: Option<&Bound<'py, PyAny>>,
retries: Option<&Bound<'py, PyAny>>,
extensions: Option<&Bound<'py, PyAny>>,
) -> PyResult<Bound<'py, PyAny>> {
self.request(
py,
"GET",
url,
headers,
params,
None,
None,
None,
None,
timeout,
cookies,
auth,
follow_redirects,
max_redirects,
decompress,
proxy,
verify,
cert,
retries,
extensions,
)
}
#[pyo3(signature = (url, *, headers=None, params=None, content=None, data=None, json=None, files=None, timeout=None, cookies=None, auth=None, follow_redirects=None, max_redirects=None, decompress=None, proxy=None, verify=None, cert=None, retries=None, extensions=None))]
#[allow(clippy::too_many_arguments)]
fn post<'py>(
&self,
py: Python<'py>,
url: &str,
headers: Option<&Bound<'py, PyAny>>,
params: Option<&Bound<'py, PyAny>>,
content: Option<&Bound<'py, PyAny>>,
data: Option<&Bound<'py, PyAny>>,
json: Option<&Bound<'py, PyAny>>,
files: Option<&Bound<'py, PyAny>>,
timeout: Option<&Bound<'py, PyAny>>,
cookies: Option<&Bound<'py, PyAny>>,
auth: Option<&Bound<'py, PyAny>>,
follow_redirects: Option<bool>,
max_redirects: Option<usize>,
decompress: Option<bool>,
proxy: Option<&Bound<'py, PyAny>>,
verify: Option<&Bound<'py, PyAny>>,
cert: Option<&Bound<'py, PyAny>>,
retries: Option<&Bound<'py, PyAny>>,
extensions: Option<&Bound<'py, PyAny>>,
) -> PyResult<Bound<'py, PyAny>> {
self.request(
py,
"POST",
url,
headers,
params,
content,
data,
json,
files,
timeout,
cookies,
auth,
follow_redirects,
max_redirects,
decompress,
proxy,
verify,
cert,
retries,
extensions,
)
}
#[pyo3(signature = (url, *, headers=None, params=None, content=None, data=None, json=None, files=None, timeout=None, cookies=None, auth=None, follow_redirects=None, max_redirects=None, decompress=None, proxy=None, verify=None, cert=None, retries=None, extensions=None))]
#[allow(clippy::too_many_arguments)]
fn put<'py>(
&self,
py: Python<'py>,
url: &str,
headers: Option<&Bound<'py, PyAny>>,
params: Option<&Bound<'py, PyAny>>,
content: Option<&Bound<'py, PyAny>>,
data: Option<&Bound<'py, PyAny>>,
json: Option<&Bound<'py, PyAny>>,
files: Option<&Bound<'py, PyAny>>,
timeout: Option<&Bound<'py, PyAny>>,
cookies: Option<&Bound<'py, PyAny>>,
auth: Option<&Bound<'py, PyAny>>,
follow_redirects: Option<bool>,
max_redirects: Option<usize>,
decompress: Option<bool>,
proxy: Option<&Bound<'py, PyAny>>,
verify: Option<&Bound<'py, PyAny>>,
cert: Option<&Bound<'py, PyAny>>,
retries: Option<&Bound<'py, PyAny>>,
extensions: Option<&Bound<'py, PyAny>>,
) -> PyResult<Bound<'py, PyAny>> {
self.request(
py,
"PUT",
url,
headers,
params,
content,
data,
json,
files,
timeout,
cookies,
auth,
follow_redirects,
max_redirects,
decompress,
proxy,
verify,
cert,
retries,
extensions,
)
}
#[pyo3(signature = (url, *, headers=None, params=None, content=None, data=None, json=None, files=None, timeout=None, cookies=None, auth=None, follow_redirects=None, max_redirects=None, decompress=None, proxy=None, verify=None, cert=None, retries=None, extensions=None))]
#[allow(clippy::too_many_arguments)]
fn patch<'py>(
&self,
py: Python<'py>,
url: &str,
headers: Option<&Bound<'py, PyAny>>,
params: Option<&Bound<'py, PyAny>>,
content: Option<&Bound<'py, PyAny>>,
data: Option<&Bound<'py, PyAny>>,
json: Option<&Bound<'py, PyAny>>,
files: Option<&Bound<'py, PyAny>>,
timeout: Option<&Bound<'py, PyAny>>,
cookies: Option<&Bound<'py, PyAny>>,
auth: Option<&Bound<'py, PyAny>>,
follow_redirects: Option<bool>,
max_redirects: Option<usize>,
decompress: Option<bool>,
proxy: Option<&Bound<'py, PyAny>>,
verify: Option<&Bound<'py, PyAny>>,
cert: Option<&Bound<'py, PyAny>>,
retries: Option<&Bound<'py, PyAny>>,
extensions: Option<&Bound<'py, PyAny>>,
) -> PyResult<Bound<'py, PyAny>> {
self.request(
py,
"PATCH",
url,
headers,
params,
content,
data,
json,
files,
timeout,
cookies,
auth,
follow_redirects,
max_redirects,
decompress,
proxy,
verify,
cert,
retries,
extensions,
)
}
#[pyo3(signature = (url, *, headers=None, params=None, timeout=None, cookies=None, auth=None, follow_redirects=None, max_redirects=None, decompress=None, proxy=None, verify=None, cert=None, retries=None, extensions=None))]
#[allow(clippy::too_many_arguments)]
fn delete<'py>(
&self,
py: Python<'py>,
url: &str,
headers: Option<&Bound<'py, PyAny>>,
params: Option<&Bound<'py, PyAny>>,
timeout: Option<&Bound<'py, PyAny>>,
cookies: Option<&Bound<'py, PyAny>>,
auth: Option<&Bound<'py, PyAny>>,
follow_redirects: Option<bool>,
max_redirects: Option<usize>,
decompress: Option<bool>,
proxy: Option<&Bound<'py, PyAny>>,
verify: Option<&Bound<'py, PyAny>>,
cert: Option<&Bound<'py, PyAny>>,
retries: Option<&Bound<'py, PyAny>>,
extensions: Option<&Bound<'py, PyAny>>,
) -> PyResult<Bound<'py, PyAny>> {
self.request(
py,
"DELETE",
url,
headers,
params,
None,
None,
None,
None,
timeout,
cookies,
auth,
follow_redirects,
max_redirects,
decompress,
proxy,
verify,
cert,
retries,
extensions,
)
}
#[pyo3(signature = (url, *, headers=None, params=None, timeout=None, cookies=None, auth=None, follow_redirects=None, max_redirects=None, decompress=None, proxy=None, verify=None, cert=None, retries=None, extensions=None))]
#[allow(clippy::too_many_arguments)]
fn head<'py>(
&self,
py: Python<'py>,
url: &str,
headers: Option<&Bound<'py, PyAny>>,
params: Option<&Bound<'py, PyAny>>,
timeout: Option<&Bound<'py, PyAny>>,
cookies: Option<&Bound<'py, PyAny>>,
auth: Option<&Bound<'py, PyAny>>,
follow_redirects: Option<bool>,
max_redirects: Option<usize>,
decompress: Option<bool>,
proxy: Option<&Bound<'py, PyAny>>,
verify: Option<&Bound<'py, PyAny>>,
cert: Option<&Bound<'py, PyAny>>,
retries: Option<&Bound<'py, PyAny>>,
extensions: Option<&Bound<'py, PyAny>>,
) -> PyResult<Bound<'py, PyAny>> {
self.request(
py,
"HEAD",
url,
headers,
params,
None,
None,
None,
None,
timeout,
cookies,
auth,
follow_redirects,
max_redirects,
decompress,
proxy,
verify,
cert,
retries,
extensions,
)
}
#[pyo3(signature = (url, *, headers=None, params=None, timeout=None, cookies=None, auth=None, follow_redirects=None, max_redirects=None, decompress=None, proxy=None, verify=None, cert=None, retries=None, extensions=None))]
#[allow(clippy::too_many_arguments)]
fn options<'py>(
&self,
py: Python<'py>,
url: &str,
headers: Option<&Bound<'py, PyAny>>,
params: Option<&Bound<'py, PyAny>>,
timeout: Option<&Bound<'py, PyAny>>,
cookies: Option<&Bound<'py, PyAny>>,
auth: Option<&Bound<'py, PyAny>>,
follow_redirects: Option<bool>,
max_redirects: Option<usize>,
decompress: Option<bool>,
proxy: Option<&Bound<'py, PyAny>>,
verify: Option<&Bound<'py, PyAny>>,
cert: Option<&Bound<'py, PyAny>>,
retries: Option<&Bound<'py, PyAny>>,
extensions: Option<&Bound<'py, PyAny>>,
) -> PyResult<Bound<'py, PyAny>> {
self.request(
py,
"OPTIONS",
url,
headers,
params,
None,
None,
None,
None,
timeout,
cookies,
auth,
follow_redirects,
max_redirects,
decompress,
proxy,
verify,
cert,
retries,
extensions,
)
}
#[pyo3(signature = (method, url, *, headers=None, params=None, content=None, data=None, json=None, files=None, timeout=None, cookies=None, auth=None, follow_redirects=None, max_redirects=None, decompress=None, proxy=None, verify=None, cert=None, retries=None, extensions=None))]
#[allow(clippy::too_many_arguments)]
#[allow(clippy::too_many_lines)]
fn stream<'py>(
&self,
py: Python<'py>,
method: &str,
url: &str,
headers: Option<&Bound<'py, PyAny>>,
params: Option<&Bound<'py, PyAny>>,
content: Option<&Bound<'py, PyAny>>,
data: Option<&Bound<'py, PyAny>>,
json: Option<&Bound<'py, PyAny>>,
files: Option<&Bound<'py, PyAny>>,
timeout: Option<&Bound<'py, PyAny>>,
cookies: Option<&Bound<'py, PyAny>>,
auth: Option<&Bound<'py, PyAny>>,
follow_redirects: Option<bool>,
max_redirects: Option<usize>,
decompress: Option<bool>,
proxy: Option<&Bound<'py, PyAny>>,
verify: Option<&Bound<'py, PyAny>>,
cert: Option<&Bound<'py, PyAny>>,
retries: Option<&Bound<'py, PyAny>>,
extensions: Option<&Bound<'py, PyAny>>,
) -> PyResult<Bound<'py, PyStreamingResponse>> {
self.ensure_not_closed()?;
if verify.is_some() || cert.is_some() {
return Err(PyErr::new::<crate::errors::UnsupportedKwarg, _>(
"verify and cert are client-level only; set them on the Client() constructor",
));
}
let prepared = crate::request_preparation::prepare_request(
py,
method,
url,
headers,
params,
content,
data,
json,
files,
timeout,
cookies,
auth,
follow_redirects,
max_redirects,
proxy,
retries,
extensions,
false,
)?;
let client = self.clone_client()?;
let dispatch = crate::request_preparation::prepare_core_dispatch(
&client,
prepared,
crate::request_preparation::RequestDispatchDefaults {
redirect_policy: self.redirect_policy.clone(),
decompress: decompress.or(self.decompress),
},
)?;
let trace_slot = dispatch.trace_error_slot.clone();
let builder = dispatch.builder;
let (runtime_guard, runtime_handle) = self.runtime_for_dispatch()?;
let result = py.detach(|| {
runtime_handle.block_on(async {
let response = Box::pin(builder.send()).await.map_err(map_err)?;
Ok::<_, PyErr>(response)
})
});
if let Some(slot) = trace_slot {
if let Some(err) = take_callback_error(&slot) {
return Err(err);
}
}
let response = result?;
PyStreamingResponse::from_core_response(
py,
response,
runtime_handle,
Some(crate::streaming::RuntimeLease::new(runtime_guard)),
false,
)
}
fn close(&self) {
let mut guard = self
.client
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
if guard.is_some() {
*guard = None;
drop(guard);
if let Some(runtime) = self
.runtime
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.take()
{
runtime.request_shutdown();
}
}
}
#[getter]
fn is_closed(&self) -> bool {
self.client.lock().map_or(true, |g| g.is_none())
}
#[getter]
fn cookies(&self) -> PyResult<PyCookies> {
let client = self.clone_client()?;
Ok(PyCookies::from_jar(client.cookies().clone()))
}
fn __enter__(slf: Py<Self>) -> Py<Self> {
slf
}
#[pyo3(signature = (_exc_type=None, _exc_value=None, _traceback=None))]
fn __exit__(
&self,
_exc_type: Option<&Bound<'_, PyAny>>,
_exc_value: Option<&Bound<'_, PyAny>>,
_traceback: Option<&Bound<'_, PyAny>>,
) -> bool {
self.close();
false
}
fn __repr__(&self) -> String {
if self.client.lock().map_or(true, |g| g.is_none()) {
"Client(closed=true)".to_string()
} else if self.verify_disabled {
"Client(verify=False) [UNSAFE: TLS verification disabled]".to_string()
} else {
"Client()".to_string()
}
}
}
impl PyClient {
fn ensure_not_closed(&self) -> PyResult<()> {
let guard = self
.client
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
if guard.is_none() {
return Err(PyErr::new::<pyo3::exceptions::PyValueError, _>(
"client is closed",
));
}
Ok(())
}
fn clone_client(&self) -> PyResult<eggfetch_core::Client> {
let guard = self
.client
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
guard
.as_ref()
.cloned()
.ok_or_else(|| PyErr::new::<pyo3::exceptions::PyValueError, _>("client is closed"))
}
fn runtime_for_dispatch(&self) -> PyResult<(RuntimeGuard, tokio::runtime::Handle)> {
let guard = self.runtime.lock().map_err(|_| {
PyErr::new::<pyo3::exceptions::PyRuntimeError, _>("client runtime lock poisoned")
})?;
let state = guard
.as_ref()
.ok_or_else(|| PyErr::new::<pyo3::exceptions::PyValueError, _>("client is closed"))?;
let state = state.clone();
let handle = state.handle().ok_or_else(|| {
PyErr::new::<pyo3::exceptions::PyRuntimeError, _>("client runtime is shut down")
})?;
Ok((RuntimeGuard(state), handle))
}
}