Method request

impit-python/src/async_client.rs:372–446

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

    #[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<'python>(
        &self,
        py: Python<'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<pyo3::Bound<'python, PyAny>, PyErr> {
        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(PyErr::new::<PyTypeError, _>(format!(
                    "Unsupported data type in request body: {e:#?}"
                ))),
            },
            None => Ok(Vec::new()),
        }?;

        let timeout = parse_timeout(timeout)?;

        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),
        };

        let method_str = method.to_string();
        let default_encoding = self.default_encoding.clone();
        let stream_value = stream.unwrap_or(false);
        let impit = Arc::clone(&self.impit);

        pyo3_async_runtimes::tokio::future_into_py::<_, ImpitPyResponse>(py, async move {
            let response = match method_str.to_lowercase().as_str() {
                "get" => impit.get(url, Some(body), Some(options)).await,
                "post" => impit.post(url, Some(body), Some(options)).await,
                "patch" => impit.patch(url, Some(body), Some(options)).await,
                "put" => impit.put(url, Some(body), Some(options)).await,