style(python): rustfmt the response module

Author: barjin

impit-python/src/response.rs

@@ -141,43 +141,44 @@ impl PyResponseAsyncBytesIterator {
 
         let parent_response = self.parent_response.as_ref().map(|p| p.clone_ref(py));
 
-        let future = pyo3_async_runtimes::tokio::future_into_py::<_, Py<PyBytes>>(py, async move {
-            let chunk_result = {
-                let mut stream_guard = stream_arc.lock().await;
-                if let Some(stream) = stream_guard.as_mut() {
-                    stream.next().await
-                } else {
-                    None
-                }
-            };
-            match chunk_result {
-                Some(Ok(chunk)) => Ok(Python::attach(|py| PyBytes::new(py, &chunk).unbind())),
-                Some(Err(e)) => {
-                    if let Some(parent) = parent_response {
-                        Python::attach(|py| {
-                            if let Ok(mut parent_ref) = parent.try_borrow_mut(py) {
-                                parent_ref.inner_state = InnerResponseState::StreamingClosed;
-                                parent_ref.is_stream_consumed = true;
-                                parent_ref.is_closed = true;
-                            }
-                        });
+        let future =
+            pyo3_async_runtimes::tokio::future_into_py::<_, Py<PyBytes>>(py, async move {
+                let chunk_result = {
+                    let mut stream_guard = stream_arc.lock().await;
+                    if let Some(stream) = stream_guard.as_mut() {
+                        stream.next().await
+                    } else {
+                        None
                     }
-                    Err(ImpitPyError(ImpitError::from(e, None)).into())
-                }
-                None => {
-                    if let Some(parent) = parent_response {
-                        Python::attach(|py| {
-                            if let Ok(mut parent_ref) = parent.try_borrow_mut(py) {
-                                parent_ref.inner_state = InnerResponseState::StreamingClosed;
-                                parent_ref.is_stream_consumed = true;
-                                parent_ref.is_closed = true;
-                            }
-                        });
+                };
+                match chunk_result {
+                    Some(Ok(chunk)) => Ok(Python::attach(|py| PyBytes::new(py, &chunk).unbind())),
+                    Some(Err(e)) => {
+                        if let Some(parent) = parent_response {
+                            Python::attach(|py| {
+                                if let Ok(mut parent_ref) = parent.try_borrow_mut(py) {
+                                    parent_ref.inner_state = InnerResponseState::StreamingClosed;
+                                    parent_ref.is_stream_consumed = true;
+                                    parent_ref.is_closed = true;
+                                }
+                            });
+                        }
+                        Err(ImpitPyError(ImpitError::from(e, None)).into())
+                    }
+                    None => {
+                        if let Some(parent) = parent_response {
+                            Python::attach(|py| {
+                                if let Ok(mut parent_ref) = parent.try_borrow_mut(py) {
+                                    parent_ref.inner_state = InnerResponseState::StreamingClosed;
+                                    parent_ref.is_stream_consumed = true;
+                                    parent_ref.is_closed = true;
+                                }
+                            });
+                        }
+                        Err(pyo3::exceptions::PyStopAsyncIteration::new_err(""))
                     }
-                    Err(pyo3::exceptions::PyStopAsyncIteration::new_err(""))
                 }
-            }
-        })?;
+            })?;
 
         Ok(future)
     }
@@ -407,9 +408,10 @@ impl ImpitPyResponse {
                 })),
                 InnerResponseState::Unread => {
                     if let Some(response) = response_option {
-                        let content = response.bytes().await.map_err(|_| {
-                            ImpitPyError(impit::errors::ImpitError::NetworkError)
-                        })?;
+                        let content = response
+                            .bytes()
+                            .await
+                            .map_err(|_| ImpitPyError(impit::errors::ImpitError::NetworkError))?;
 
                         Ok(Python::attach(|py| {
                             let mut slf_ref = slf.borrow_mut(py);