Method iter_bytes

impit-python/src/response.rs:336–379

(slf: Py<Self>, py: Python)

    }

    fn iter_bytes(slf: Py<Self>, py: Python) -> PyResult<PyResponseBytesIterator> {
        let runtime = pyo3_async_runtimes::tokio::get_runtime().handle().clone();
        let mut slf_ref = slf.borrow_mut(py);

        match slf_ref.inner_state {
            InnerResponseState::Read => {
                let content = slf_ref.content.clone();
                drop(slf_ref);

                Ok(PyResponseBytesIterator {
                    ready_content: content,
                    stream: None,
                    runtime,
                    content_returned: false,
                    parent_response: Some(slf),
                })
            }
            InnerResponseState::Unread => {
                slf_ref.inner_state = InnerResponseState::Streaming;

                let response = slf_ref
                    .inner
                    .take()
                    .ok_or(ImpitPyError(impit::errors::ImpitError::StreamClosed))?;

                drop(slf_ref);

                let stream: Pin<Box<dyn Stream<Item = reqwest::Result<Bytes>> + Send + Sync>> =
                    Box::pin(response.bytes_stream());

                Ok(PyResponseBytesIterator {
                    ready_content: None,
                    stream: Some(stream),
                    runtime,
                    content_returned: false,
                    parent_response: Some(slf),
                })
            }
            InnerResponseState::Streaming | InnerResponseState::StreamingClosed => {
                drop(slf_ref);
                Err(ImpitPyError(impit::errors::ImpitError::StreamConsumed).into())
            }
        }
    }

    fn aread(slf: Py<Self>, py: Python<'_>) -> PyResult<Bound<'_, PyAny>> {
        pyo3_async_runtimes::tokio::future_into_py(py, async move {