Method request

impit-python/src/client.rs:369–443

(
        &self,
        py: Python<'_>,
        method: &str,
        url: String,
        content: Option<Vec<u8>>,
        mut data: Option<RequestBody>,
        headers: Option<HashMap<String, Str

    #[pyo3(signature = (method, url, content=None, data=None, headers=None, timeout=Some(Right(USE_CLIENT_DEFAULT_SENTINEL)), force_http3=false, stream=false))]
    pub fn request(
        &self,
        py: Python<'_>,
        method: &str,
        url: String,
        content: Option<Vec<u8>>,
        mut data: Option<RequestBody>,
        headers: Option<HashMap<String, String>>,
        timeout: Option<Either<f64, &str>>,
        force_http3: Option<bool>,
        stream: Option<bool>,
    ) -> Result<ImpitPyResponse, ImpitPyError> {
        let mut headers = headers.clone();

        if let Some(content) = content {
            data = Some(RequestBody::Bytes(content));
        }

        let body: Vec<u8> = match data {
            Some(data) => match data {
                RequestBody::Bytes(bytes) => Ok(bytes),
                RequestBody::Form(form) => {
                    headers.get_or_insert_with(HashMap::new).insert(
                        "Content-Type".to_string(),
                        "application/x-www-form-urlencoded".to_string(),
                    );
                    Ok(form_to_bytes(form))
                }
                RequestBody::CatchAll(e) => Err(ImpitPyError(ImpitError::BindingPassthroughError(
                    format!("Unsupported data type: {e:?}").to_string(),
                ))),
            },
            None => Ok(Vec::new()),
        }?;

        let timeout = parse_timeout(timeout)
            .map_err(|e| ImpitPyError(ImpitError::BindingPassthroughError(e.to_string())))?;

        let options = RequestOptions {
            headers: headers
                .unwrap_or_default()
                .iter()
                .map(|(k, v)| (k.clone(), v.clone()))
                .collect(),
            timeout,
            http3_prior_knowledge: force_http3.unwrap_or(false),
        };

        py.detach(|| {
            pyo3_async_runtimes::tokio::get_runtime().block_on(async {
                let response = match method.to_lowercase().as_str() {
                    "get" => self.impit.get(url, Some(body), Some(options)).await,
                    "post" => self.impit.post(url, Some(body), Some(options)).await,
                    "patch" => self.impit.patch(url, Some(body), Some(options)).await,
                    "put" => self.impit.put(url, Some(body), Some(options)).await,
                    "options" => self.impit.options(url, Some(body), Some(options)).await,
                    "trace" => self.impit.trace(url, Some(body), Some(options)).await,
                    "head" => self.impit.head(url, Some(body), Some(options)).await,