make clippy happy (#274)

mhils · web-flow · commit 813e3ca4a51d · 2025-07-15T19:57:31.000Z
diff --git a/mitmproxy-contentviews/src/protobuf/existing_proto_definitions.rs b/mitmproxy-contentviews/src/protobuf/existing_proto_definitions.rs
@@ -169,13 +169,12 @@ fn walk_proto_directory(definitions_path: &Path, parser: &mut Parser) -> anyhow:
     for entry in definitions_path
         .read_dir()
         .context("failed to read protobuf directory")?
+        .flatten()
     {
-        if let Ok(entry) = entry {
-            if entry.metadata()?.is_dir() {
-                walk_proto_directory(entry.path().as_path(), parser)?;
-            } else if entry.file_name().to_string_lossy().ends_with(".proto") {
-                parser.input(entry.path());
-            }
+        if entry.metadata()?.is_dir() {
+            walk_proto_directory(entry.path().as_path(), parser)?;
+        } else if entry.file_name().to_string_lossy().ends_with(".proto") {
+            parser.input(entry.path());
         }
     }
     Ok(())
diff --git a/mitmproxy-contentviews/src/protobuf/raw_to_proto.rs b/mitmproxy-contentviews/src/protobuf/raw_to_proto.rs
@@ -111,7 +111,7 @@ fn create_descriptor_proto(
     }
 
     for (field_index, field_values) in field_groups.into_iter() {
-        let name = Some(format!("unknown_field_{}", field_index));
+        let name = Some(format!("unknown_field_{field_index}"));
         let mut add_int = |name: Option<String>, typ: Type| {
             descriptor.field.push(FieldDescriptorProto {
                 number: Some(field_index as i32),
diff --git a/mitmproxy-contentviews/src/protobuf/yaml_to_pretty.rs b/mitmproxy-contentviews/src/protobuf/yaml_to_pretty.rs
@@ -29,12 +29,12 @@ impl Display for NumReprs {
             .unwrap();
         let mut i = self.0.iter().filter(|(t, _)| t != min_typ);
 
-        write!(f, "{}", min_val)?;
+        write!(f, "{min_val}")?;
         if let Some((t, v)) = i.next() {
-            write!(f, "  # {}: {}", t, v)?;
+            write!(f, "  # {t}: {v}")?;
         }
         for (t, v) in i {
-            write!(f, ", {}: {}", t, v)?;
+            write!(f, ", {t}: {v}")?;
         }
         Ok(())
     }
@@ -95,7 +95,7 @@ pub(super) fn apply_replacements(yaml_str: &str) -> anyhow::Result<String> {
 
 /// Ensure that floating point numbers have a ".0" component so that we roundtrip.
 fn format_float<T: Display>(val: T) -> String {
-    let mut ret = format!("{:.}", val);
+    let mut ret = format!("{val:.}");
     if !ret.contains(".") {
         ret.push_str(".0");
     }
diff --git a/mitmproxy-rs/src/contentviews.rs b/mitmproxy-rs/src/contentviews.rs
@@ -107,7 +107,7 @@ impl Contentview {
     pub fn prettify(&self, data: Vec<u8>, metadata: PythonMetadata) -> PyResult<String> {
         self.0
             .prettify(&data, &metadata)
-            .map_err(|e| PyValueError::new_err(format!("{:?}", e)))
+            .map_err(|e| PyValueError::new_err(format!("{e:?}")))
     }
 
     /// Return the priority of this view for rendering data.
@@ -153,7 +153,7 @@ impl InteractiveContentview {
     pub fn reencode(&self, data: &str, metadata: PythonMetadata) -> PyResult<Vec<u8>> {
         self.0
             .reencode(data, &metadata)
-            .map_err(|e| PyValueError::new_err(format!("{:?}", e)))
+            .map_err(|e| PyValueError::new_err(format!("{e:?}")))
     }
 
     fn __repr__(self_: PyRef<'_, Self>) -> PyResult<String> {
diff --git a/mitmproxy-rs/src/dns_resolver.rs b/mitmproxy-rs/src/dns_resolver.rs
@@ -26,8 +26,7 @@ impl DnsResolver {
         let resolver =
             mitmproxy::dns::DnsResolver::new(name_servers, use_hosts_file).map_err(|e| {
                 pyo3::exceptions::PyRuntimeError::new_err(format!(
-                    "failed to create dns resolver: {}",
-                    e
+                    "failed to create dns resolver: {e}"
                 ))
             })?;
         Ok(Self(Arc::new(resolver)))
@@ -74,7 +73,7 @@ impl DnsResolver {
 #[pyfunction]
 pub fn get_system_dns_servers() -> PyResult<Vec<String>> {
     DNS_SERVERS.clone().map_err(|e| {
-        pyo3::exceptions::PyRuntimeError::new_err(format!("failed to get dns servers: {}", e))
+        pyo3::exceptions::PyRuntimeError::new_err(format!("failed to get dns servers: {e}"))
     })
 }
 
diff --git a/mitmproxy-rs/src/process_info.rs b/mitmproxy-rs/src/process_info.rs
@@ -57,7 +57,7 @@ pub fn active_executables() -> PyResult<Vec<Process>> {
     {
         processes::active_executables()
             .map(|p| p.into_iter().map(Process).collect())
-            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{}", e)))
+            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))
     }
     #[cfg(not(any(windows, target_os = "macos", target_os = "linux")))]
     Err(pyo3::exceptions::PyNotImplementedError::new_err(
diff --git a/mitmproxy-rs/src/server/base.rs b/mitmproxy-rs/src/server/base.rs
@@ -45,7 +45,7 @@ impl Server {
         T: PacketSourceConf,
     {
         let typ = packet_source_conf.name();
-        log::debug!("Initializing {} ...", typ);
+        log::debug!("Initializing {typ} ...");
 
         // Channel used to notify Python land of incoming connections.
         let (transport_events_tx, transport_events_rx) = mpsc::channel(256);
@@ -80,7 +80,7 @@ impl Server {
         let (shutdown_done_tx, shutdown_done_rx) = shutdown::channel();
         tokio::spawn(shutdown_task(tasks, shutdown_done_tx));
 
-        log::debug!("{} successfully initialized.", typ);
+        log::debug!("{typ} successfully initialized.");
 
         Ok((
             Server {
diff --git a/mitmproxy-rs/src/server/local_redirector.rs b/mitmproxy-rs/src/server/local_redirector.rs
@@ -39,7 +39,7 @@ impl LocalRedirector {
     fn describe_spec(spec: &str) -> PyResult<String> {
         InterceptConf::try_from(spec)
             .map(|conf| conf.description())
-            .map_err(|e| PyValueError::new_err(format!("{:?}", e)))
+            .map_err(|e| PyValueError::new_err(format!("{e:?}")))
     }
 
     /// Set a new intercept spec.
diff --git a/mitmproxy-rs/src/syntax_highlight.rs b/mitmproxy-rs/src/syntax_highlight.rs
@@ -25,7 +25,7 @@ pub fn highlight(text: String, language: &str) -> PyResult<Vec<(&'static str, St
                 .map(|(tag, text)| (tag.as_str(), text))
                 .collect()
         })
-        .map_err(|e| PyValueError::new_err(format!("{:?}", e)))
+        .map_err(|e| PyValueError::new_err(format!("{e:?}")))
 }
 
 /// Return the list of all possible syntax highlight tags.
diff --git a/mitmproxy-rs/src/task.rs b/mitmproxy-rs/src/task.rs
@@ -101,7 +101,7 @@ impl PyInteropTask {
                                         if let Err(err) = future.await {
                                             let is_cancelled = Python::with_gil(|py| err.is_instance_of::<CancelledError>(py));
                                             if !is_cancelled {
-                                                log::error!("TCP connection handler coroutine raised an exception:\n{}", err);
+                                                log::error!("TCP connection handler coroutine raised an exception:\n{err}");
                                             }
                                         }
                                         active_streams.lock().await.remove(&connection_id);
@@ -112,7 +112,7 @@ impl PyInteropTask {
 
                                 Ok(())
                             }) {
-                                log::error!("Failed to spawn connection handler:\n{}", err);
+                                log::error!("Failed to spawn connection handler:\n{err}");
                             };
                         },
                     }
@@ -127,10 +127,7 @@ impl PyInteropTask {
                 // Future is already finished: just await;
                 // Python exceptions are already logged by the wrapper coroutine
                 if let Err(err) = handle.await {
-                    log::warn!(
-                        "TCP connection handler coroutine could not be joined: {}",
-                        err
-                    );
+                    log::warn!("TCP connection handler coroutine could not be joined: {err}");
                 }
             } else {
                 // Future is not finished: abort tokio task
@@ -139,7 +136,7 @@ impl PyInteropTask {
                 if let Err(err) = handle.await {
                     if !err.is_cancelled() {
                         // JoinError was not caused by cancellation: coroutine panicked, log error
-                        log::error!("TCP connection handler coroutine panicked: {}", err);
+                        log::error!("TCP connection handler coroutine panicked: {err}");
                     }
                 }
             }
diff --git a/mitmproxy-rs/src/udp_client.rs b/mitmproxy-rs/src/udp_client.rs
@@ -72,7 +72,7 @@ async fn udp_connect(
     let socket = if let Some((host, port)) = local_addr {
         UdpSocket::bind((host.as_str(), port))
             .await
-            .with_context(|| format!("unable to bind to ({}, {})", host, port))?
+            .with_context(|| format!("unable to bind to ({host}, {port})"))?
     } else if addrs.iter().any(|x| x.is_ipv4()) {
         // we initially tried to bind to IPv6 by default if that doesn't fail,
         // but binding mysteriously works if there are only IPv4 addresses in addrs,
diff --git a/mitmproxy-rs/src/util.rs b/mitmproxy-rs/src/util.rs
@@ -70,8 +70,7 @@ pub fn add_cert(py: Python<'_>, pem: String) -> PyResult<()> {
         match certificates::add_cert(der, executable_path.to_str().unwrap()) {
             Ok(_) => Ok(()),
             Err(e) => Err(PyErr::new::<PyOSError, _>(format!(
-                "Failed to add certificate: {:?}",
-                e
+                "Failed to add certificate: {e:?}"
             ))),
         }
     }
@@ -89,8 +88,7 @@ pub fn remove_cert() -> PyResult<()> {
         match certificates::remove_cert() {
             Ok(_) => Ok(()),
             Err(e) => Err(PyErr::new::<PyOSError, _>(format!(
-                "Failed to remove certificate: {:?}",
-                e
+                "Failed to remove certificate: {e:?}"
             ))),
         }
     }
diff --git a/src/intercept_conf.rs b/src/intercept_conf.rs
@@ -92,17 +92,17 @@ impl TryFrom<&str> for Pattern {
 impl std::fmt::Display for Action {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            Action::Include(pat) => write!(f, "{}", pat),
-            Action::Exclude(pat) => write!(f, "!{}", pat),
+            Action::Include(pat) => write!(f, "{pat}"),
+            Action::Exclude(pat) => write!(f, "!{pat}"),
         }
     }
 }
 
 impl std::fmt::Display for Pattern {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            Pattern::Pid(pid) => write!(f, "{}", pid),
-            Pattern::Process(name) => write!(f, "{}", name),
+            Pattern::Pid(pid) => write!(f, "{pid}"),
+            Pattern::Process(name) => write!(f, "{name}"),
         }
     }
 }
@@ -148,13 +148,13 @@ impl InterceptConf {
             .actions
             .iter()
             .map(|a| match a {
-                Action::Include(Pattern::Pid(pid)) => format!("Include PID {}.", pid),
+                Action::Include(Pattern::Pid(pid)) => format!("Include PID {pid}."),
                 Action::Include(Pattern::Process(name)) => {
-                    format!("Include processes matching \"{}\".", name)
+                    format!("Include processes matching \"{name}\".")
                 }
-                Action::Exclude(Pattern::Pid(pid)) => format!("Exclude PID {}.", pid),
+                Action::Exclude(Pattern::Pid(pid)) => format!("Exclude PID {pid}."),
                 Action::Exclude(Pattern::Process(name)) => {
-                    format!("Exclude processes matching \"{}\".", name)
+                    format!("Exclude processes matching \"{name}\".")
                 }
             })
             .collect();
diff --git a/src/messages.rs b/src/messages.rs
@@ -205,7 +205,7 @@ impl SmolPacket {
                 IpProtocol::Icmp => IpProtocol::Icmp,
                 IpProtocol::Icmpv6 => IpProtocol::Icmpv6,
                 other => {
-                    log::debug!("TODO: Implement IPv6 next_header logic: {}", other);
+                    log::debug!("TODO: Implement IPv6 next_header logic: {other}");
                     other
                 }
             },
diff --git a/src/network/core.rs b/src/network/core.rs
@@ -53,7 +53,7 @@ impl NetworkStack<'_> {
             IpProtocol::Udp => {
                 match UdpPacket::try_from(packet) {
                     Ok(packet) => self.udp.receive_data(packet, tunnel_info, permit),
-                    Err(e) => log::debug!("Received invalid UDP packet: {}", e),
+                    Err(e) => log::debug!("Received invalid UDP packet: {e}"),
                 };
                 Ok(())
             }
diff --git a/src/network/icmp.rs b/src/network/icmp.rs
@@ -15,7 +15,7 @@ pub(super) fn handle_icmpv4_echo_request(
     let mut input_icmpv4_packet = match Icmpv4Packet::new_checked(input_packet.payload_mut()) {
         Ok(p) => p,
         Err(e) => {
-            log::debug!("Received invalid ICMPv4 packet: {}", e);
+            log::debug!("Received invalid ICMPv4 packet: {e}");
             return None;
         }
     };
@@ -64,7 +64,7 @@ pub(super) fn handle_icmpv6_echo_request(
     let mut input_icmpv6_packet = match Icmpv6Packet::new_checked(input_packet.payload_mut()) {
         Ok(p) => p,
         Err(e) => {
-            log::debug!("Received invalid ICMPv6 packet: {}", e);
+            log::debug!("Received invalid ICMPv6 packet: {e}");
             return None;
         }
     };
diff --git a/src/network/task.rs b/src/network/task.rs
@@ -79,7 +79,7 @@ impl NetworkTask<'_> {
 
             #[cfg(debug_assertions)]
             if let Some(d) = delay {
-                log::debug!("Waiting for device timeout: {:?} ...", d);
+                log::debug!("Waiting for device timeout: {d:?} ...");
             }
 
             #[cfg(debug_assertions)]
diff --git a/src/network/tcp.rs b/src/network/tcp.rs
@@ -111,7 +111,7 @@ impl TcpHandler<'_> {
             }
             // packet with incorrect length
             Err(e) => {
-                log::debug!("Received invalid TCP packet ({}) with payload:", e);
+                log::debug!("Received invalid TCP packet ({e}) with payload:");
                 log::debug!("{}", pretty_hex(&packet.payload_mut()));
                 return Ok(());
             }
diff --git a/src/network/virtual_device.rs b/src/network/virtual_device.rs
@@ -86,7 +86,7 @@ impl TxToken for VirtualTxToken<'_> {
                 self.permit.send(NetworkCommand::SendPacket(packet));
             }
             Err(err) => {
-                log::error!("Failed to parse packet from smol: {:?}", err)
+                log::error!("Failed to parse packet from smol: {err:?}")
             }
         }
 
diff --git a/src/packet_sources/macos.rs b/src/packet_sources/macos.rs
@@ -147,7 +147,7 @@ impl PacketSourceTask for MacOsTask {
                             );
                             self.connections.spawn(task.run());
                         },
-                        Err(e) => log::error!("Error accepting connection from macos-redirector: {}", e)
+                        Err(e) => log::error!("Error accepting connection from macos-redirector: {e}")
                     }
                 },
                 // pipe through changes to the intercept list
@@ -234,7 +234,7 @@ impl ConnectionTask {
                 bail!("no local address")
             };
             SocketAddr::try_from(addr)
-                .with_context(|| format!("invalid local_address: {:?}", addr))?
+                .with_context(|| format!("invalid local_address: {addr:?}"))?
         };
         let mut remote_address = SocketAddr::new(IpAddr::V4(Ipv4Addr::UNSPECIFIED), 0);
         let (command_tx, mut command_rx) = unbounded_channel();
@@ -252,7 +252,7 @@ impl ConnectionTask {
                     ).context("invalid IPC message")?;
                     let dst_addr = {
                         let Some(dst_addr) = &packet.remote_address else { bail!("no remote addr") };
-                        SocketAddr::try_from(dst_addr).with_context(|| format!("invalid remote_address: {:?}", dst_addr))?
+                        SocketAddr::try_from(dst_addr).with_context(|| format!("invalid remote_address: {dst_addr:?}"))?
                     };
 
                     // We can only send ConnectionEstablished once we know the destination address.
diff --git a/src/packet_sources/udp.rs b/src/packet_sources/udp.rs
@@ -42,7 +42,7 @@ pub(crate) fn create_and_bind_udp_socket(addr: SocketAddr) -> Result<UdpSocket>
 
     sock2
         .bind(&addr.into())
-        .context(format!("Failed to bind UDP socket to {}", addr))?;
+        .context(format!("Failed to bind UDP socket to {addr}"))?;
 
     let std_sock: std::net::UdpSocket = sock2.into();
     std_sock
@@ -74,7 +74,7 @@ impl PacketSourceConf for UdpConf {
         let socket = create_and_bind_udp_socket(self.listen_addr)?;
         let local_addr: SocketAddr = socket.local_addr()?;
 
-        log::debug!("UDP server listening on {} ...", local_addr);
+        log::debug!("UDP server listening on {local_addr} ...");
 
         Ok((
             UdpTask {
diff --git a/src/packet_sources/wireguard.rs b/src/packet_sources/wireguard.rs
diff --git a/src/shutdown.rs b/src/shutdown.rs

Original file line number	Diff line number	Diff line change
`@@ -169,13 +169,12 @@ fn walk_proto_directory(definitions_path: &Path, parser: &mut Parser) -> anyhow:`
`169`	`169`	`for entry in definitions_path`
`170`	`170`	`.read_dir()`
`171`	`171`	`.context("failed to read protobuf directory")?`
	`172`	`+ .flatten()`
`172`	`173`	`{`
`173`		`- if let Ok(entry) = entry {`
`174`		`- if entry.metadata()?.is_dir() {`
`175`		`- walk_proto_directory(entry.path().as_path(), parser)?;`
`176`		`- } else if entry.file_name().to_string_lossy().ends_with(".proto") {`
`177`		`- parser.input(entry.path());`
`178`		`- }`
	`174`	`+ if entry.metadata()?.is_dir() {`
	`175`	`+ walk_proto_directory(entry.path().as_path(), parser)?;`
	`176`	`+ } else if entry.file_name().to_string_lossy().ends_with(".proto") {`
	`177`	`+ parser.input(entry.path());`
`179`	`178`	`}`
`180`	`179`	`}`
`181`	`180`	`Ok(())`
Original file line number	Diff line number	Diff line change
`@@ -111,7 +111,7 @@ fn create_descriptor_proto(`
`111`	`111`	`}`
`112`	`112`
`113`	`113`	`for (field_index, field_values) in field_groups.into_iter() {`
`114`		`- let name = Some(format!("unknown_field_{}", field_index));`
	`114`	`+ let name = Some(format!("unknown_field_{field_index}"));`
`115`	`115`	`let mut add_int = \|name: Option<String>, typ: Type\| {`
`116`	`116`	`descriptor.field.push(FieldDescriptorProto {`
`117`	`117`	`number: Some(field_index as i32),`
Original file line number	Diff line number	Diff line change
`@@ -29,12 +29,12 @@ impl Display for NumReprs {`
`29`	`29`	`.unwrap();`
`30`	`30`	`let mut i = self.0.iter().filter(\|(t, _)\| t != min_typ);`
`31`	`31`
`32`		`- write!(f, "{}", min_val)?;`
	`32`	`+ write!(f, "{min_val}")?;`
`33`	`33`	`if let Some((t, v)) = i.next() {`
`34`		`- write!(f, " # {}: {}", t, v)?;`
	`34`	`+ write!(f, " # {t}: {v}")?;`
`35`	`35`	`}`
`36`	`36`	`for (t, v) in i {`
`37`		`- write!(f, ", {}: {}", t, v)?;`
	`37`	`+ write!(f, ", {t}: {v}")?;`
`38`	`38`	`}`
`39`	`39`	`Ok(())`
`40`	`40`	`}`
`@@ -95,7 +95,7 @@ pub(super) fn apply_replacements(yaml_str: &str) -> anyhow::Result<String> {`
`95`	`95`
`96`	`96`	`/// Ensure that floating point numbers have a ".0" component so that we roundtrip.`
`97`	`97`	`fn format_float<T: Display>(val: T) -> String {`
`98`		`- let mut ret = format!("{:.}", val);`
	`98`	`+ let mut ret = format!("{val:.}");`
`99`	`99`	`if !ret.contains(".") {`
`100`	`100`	`ret.push_str(".0");`
`101`	`101`	`}`
Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,7 @@ pub fn active_executables() -> PyResult<Vec<Process>> {`
`57`	`57`	`{`
`58`	`58`	`processes::active_executables()`
`59`	`59`	`.map(\|p\| p.into_iter().map(Process).collect())`
`60`		`- .map_err(\|e\| pyo3::exceptions::PyRuntimeError::new_err(format!("{}", e)))`
	`60`	`+ .map_err(\|e\| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))`
`61`	`61`	`}`
`62`	`62`	`#[cfg(not(any(windows, target_os = "macos", target_os = "linux")))]`
`63`	`63`	`Err(pyo3::exceptions::PyNotImplementedError::new_err(`
Original file line number	Diff line number	Diff line change
`@@ -39,7 +39,7 @@ impl LocalRedirector {`
`39`	`39`	`fn describe_spec(spec: &str) -> PyResult<String> {`
`40`	`40`	`InterceptConf::try_from(spec)`
`41`	`41`	`.map(\|conf\| conf.description())`
`42`		`- .map_err(\|e\| PyValueError::new_err(format!("{:?}", e)))`
	`42`	`+ .map_err(\|e\| PyValueError::new_err(format!("{e:?}")))`
`43`	`43`	`}`
`44`	`44`
`45`	`45`	`/// Set a new intercept spec.`
Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ pub fn highlight(text: String, language: &str) -> PyResult<Vec<(&'static str, St`
`25`	`25`	`.map(\|(tag, text)\| (tag.as_str(), text))`
`26`	`26`	`.collect()`
`27`	`27`	`})`
`28`		`- .map_err(\|e\| PyValueError::new_err(format!("{:?}", e)))`
	`28`	`+ .map_err(\|e\| PyValueError::new_err(format!("{e:?}")))`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`/// Return the list of all possible syntax highlight tags.`
Original file line number	Diff line number	Diff line change
`@@ -101,7 +101,7 @@ impl PyInteropTask {`
`101`	`101`	`if let Err(err) = future.await {`
`102`	`102`	`let is_cancelled = Python::with_gil(\|py\| err.is_instance_of::<CancelledError>(py));`
`103`	`103`	`if !is_cancelled {`
`104`		`- log::error!("TCP connection handler coroutine raised an exception:\n{}", err);`
	`104`	`+ log::error!("TCP connection handler coroutine raised an exception:\n{err}");`
`105`	`105`	`}`
`106`	`106`	`}`
`107`	`107`	`active_streams.lock().await.remove(&connection_id);`
`@@ -112,7 +112,7 @@ impl PyInteropTask {`
`112`	`112`
`113`	`113`	`Ok(())`
`114`	`114`	`}) {`
`115`		`- log::error!("Failed to spawn connection handler:\n{}", err);`
	`115`	`+ log::error!("Failed to spawn connection handler:\n{err}");`
`116`	`116`	`};`
`117`	`117`	`},`
`118`	`118`	`}`
`@@ -127,10 +127,7 @@ impl PyInteropTask {`
`127`	`127`	`// Future is already finished: just await;`
`128`	`128`	`// Python exceptions are already logged by the wrapper coroutine`
`129`	`129`	`if let Err(err) = handle.await {`
`130`		`- log::warn!(`
`131`		`- "TCP connection handler coroutine could not be joined: {}",`
`132`		`- err`
`133`		`- );`
	`130`	`+ log::warn!("TCP connection handler coroutine could not be joined: {err}");`
`134`	`131`	`}`
`135`	`132`	`} else {`
`136`	`133`	`// Future is not finished: abort tokio task`
`@@ -139,7 +136,7 @@ impl PyInteropTask {`
`139`	`136`	`if let Err(err) = handle.await {`
`140`	`137`	`if !err.is_cancelled() {`
`141`	`138`	`// JoinError was not caused by cancellation: coroutine panicked, log error`
`142`		`- log::error!("TCP connection handler coroutine panicked: {}", err);`
	`139`	`+ log::error!("TCP connection handler coroutine panicked: {err}");`
`143`	`140`	`}`
`144`	`141`	`}`
`145`	`142`	`}`