cargo fmt

apis/c++/node/src/lib.rs

@@ -1,16 +1,15 @@
 use std::{any::Any, vec};
 
 use dora_node_api::{
-    self,
+    self, Event, EventStream,
     arrow::array::{AsArray, UInt8Array},
     merged::{MergeExternal, MergedEvent},
-    Event, EventStream,
 };
 use eyre::bail;
 
 #[cfg(feature = "ros2-bridge")]
 use dora_ros2_bridge::{_core, ros2_client};
-use futures_lite::{stream, Stream, StreamExt};
+use futures_lite::{Stream, StreamExt, stream};
 
 #[cxx::bridge]
 #[allow(clippy::needless_lifetimes)]

apis/c++/operator/src/lib.rs

@@ -2,7 +2,7 @@
 #![warn(unsafe_op_in_unsafe_fn)]
 
 use dora_operator_api::{
-    self, register_operator, DoraOperator, DoraOutputSender, DoraStatus, Event, IntoArrow,
+    self, DoraOperator, DoraOutputSender, DoraStatus, Event, IntoArrow, register_operator,
 };
 use ffi::DoraSendOutputResult;
 

apis/python/node/src/lib.rs

@@ -11,7 +11,7 @@ use dora_node_api::dora_core::config::NodeId;
 use dora_node_api::dora_core::descriptor::source_is_url;
 use dora_node_api::merged::{MergeExternalSend, MergedEvent};
 use dora_node_api::{DataflowId, DoraNode, EventStream};
-use dora_operator_api_python::{pydict_to_metadata, DelayedCleanup, NodeCleanupHandle, PyEvent};
+use dora_operator_api_python::{DelayedCleanup, NodeCleanupHandle, PyEvent, pydict_to_metadata};
 use dora_ros2_bridge_python::Ros2Subscription;
 use eyre::Context;
 use futures::{Stream, StreamExt};

apis/python/operator/src/lib.rs

@@ -5,8 +5,8 @@ use std::{
 
 use arrow::pyarrow::ToPyArrow;
 use dora_node_api::{
-    merged::{MergeExternalSend, MergedEvent},
     DoraNode, Event, EventStream, Metadata, MetadataParameters, Parameter, StopCause,
+    merged::{MergeExternalSend, MergedEvent},
 };
 use eyre::{Context, Result};
 use futures::{Stream, StreamExt};
@@ -282,7 +282,7 @@ mod tests {
     use aligned_vec::{AVec, ConstAlign};
     use arrow::{
         array::{
-            ArrayData, ArrayRef, BooleanArray, Float64Array, Int32Array, Int64Array, Int8Array,
+            ArrayData, ArrayRef, BooleanArray, Float64Array, Int8Array, Int32Array, Int64Array,
             ListArray, StructArray,
         },
         buffer::Buffer,

apis/rust/node/src/daemon_connection/mod.rs

@@ -1,10 +1,10 @@
 use dora_core::{config::NodeId, uhlc::Timestamp};
 use dora_message::{
+    DataflowId,
     daemon_to_node::DaemonReply,
     node_to_daemon::{DaemonRequest, NodeRegisterRequest, Timestamped},
-    DataflowId,
 };
-use eyre::{bail, eyre, Context};
+use eyre::{Context, bail, eyre};
 use shared_memory_server::{ShmemClient, ShmemConf};
 #[cfg(unix)]
 use std::os::unix::net::UnixStream;

apis/rust/node/src/daemon_connection/tcp.rs

@@ -2,7 +2,7 @@ use dora_message::{
     daemon_to_node::DaemonReply,
     node_to_daemon::{DaemonRequest, Timestamped},
 };
-use eyre::{eyre, Context};
+use eyre::{Context, eyre};
 use std::{
     io::{Read, Write},
     net::TcpStream,
@@ -42,21 +42,20 @@ fn receive_reply(
     connection: &mut TcpStream,
     serializer: Serializer,
 ) -> eyre::Result<Option<DaemonReply>> {
-    let raw = match tcp_receive(connection) {
-        Ok(raw) => raw,
-        Err(err) => match err.kind() {
-            std::io::ErrorKind::UnexpectedEof | std::io::ErrorKind::ConnectionAborted => {
-                return Ok(None)
-            }
-            other => {
-                return Err(err).with_context(|| {
+    let raw =
+        match tcp_receive(connection) {
+            Ok(raw) => raw,
+            Err(err) => match err.kind() {
+                std::io::ErrorKind::UnexpectedEof | std::io::ErrorKind::ConnectionAborted => {
+                    return Ok(None);
+                }
+                other => return Err(err).with_context(|| {
                     format!(
                         "unexpected I/O error (kind {other:?}) while trying to receive DaemonReply"
                     )
-                })
-            }
-        },
-    };
+                }),
+            },
+        };
     match serializer {
         Serializer::Bincode => bincode::deserialize(&raw)
             .wrap_err("failed to deserialize DaemonReply")

apis/rust/node/src/daemon_connection/unix_domain.rs

@@ -2,7 +2,7 @@ use dora_message::{
     daemon_to_node::DaemonReply,
     node_to_daemon::{DaemonRequest, Timestamped},
 };
-use eyre::{eyre, Context};
+use eyre::{Context, eyre};
 use std::{
     io::{Read, Write},
     os::unix::net::UnixStream,
@@ -42,21 +42,20 @@ fn receive_reply(
     connection: &mut UnixStream,
     serializer: Serializer,
 ) -> eyre::Result<Option<DaemonReply>> {
-    let raw = match stream_receive(connection) {
-        Ok(raw) => raw,
-        Err(err) => match err.kind() {
-            std::io::ErrorKind::UnexpectedEof | std::io::ErrorKind::ConnectionAborted => {
-                return Ok(None)
-            }
-            other => {
-                return Err(err).with_context(|| {
+    let raw =
+        match stream_receive(connection) {
+            Ok(raw) => raw,
+            Err(err) => match err.kind() {
+                std::io::ErrorKind::UnexpectedEof | std::io::ErrorKind::ConnectionAborted => {
+                    return Ok(None);
+                }
+                other => return Err(err).with_context(|| {
                     format!(
                         "unexpected I/O error (kind {other:?}) while trying to receive DaemonReply"
                     )
-                })
-            }
-        },
-    };
+                }),
+            },
+        };
     match serializer {
         Serializer::Bincode => bincode::deserialize(&raw)
             .wrap_err("failed to deserialize DaemonReply")

apis/rust/node/src/event_stream/mod.rs

@@ -6,18 +6,18 @@ use std::{
 };
 
 use dora_message::{
+    DataflowId,
     daemon_to_node::{DaemonCommunication, DaemonReply, DataMessage, NodeEvent},
     id::DataId,
     node_to_daemon::{DaemonRequest, Timestamped},
-    DataflowId,
 };
 pub use event::{Event, StopCause};
 use futures::{
-    future::{select, Either},
     Stream, StreamExt,
+    future::{Either, select},
 };
 use futures_timer::Delay;
-use scheduler::{Scheduler, NON_INPUT_EVENT};
+use scheduler::{NON_INPUT_EVENT, Scheduler};
 
 use self::thread::{EventItem, EventStreamThreadHandle};
 use crate::{
@@ -28,7 +28,7 @@ use dora_core::{
     config::{Input, NodeId},
     uhlc,
 };
-use eyre::{eyre, Context};
+use eyre::{Context, eyre};
 
 pub use scheduler::Scheduler as EventScheduler;
 

apis/rust/node/src/event_stream/thread.rs

@@ -6,7 +6,7 @@ use dora_message::{
     daemon_to_node::{DaemonReply, NodeEvent},
     node_to_daemon::{DaemonRequest, DropToken, Timestamped},
 };
-use eyre::{eyre, Context};
+use eyre::{Context, eyre};
 use flume::RecvTimeoutError;
 use std::{
     sync::Arc,

apis/rust/node/src/lib.rs

@@ -84,13 +84,13 @@ pub use arrow;
 pub use dora_arrow_convert::*;
 pub use dora_core::{self, uhlc};
 pub use dora_message::{
-    metadata::{Metadata, MetadataParameters, Parameter},
     DataflowId,
+    metadata::{Metadata, MetadataParameters, Parameter},
 };
-pub use event_stream::{merged, Event, EventScheduler, EventStream, StopCause};
+pub use event_stream::{Event, EventScheduler, EventStream, StopCause, merged};
 pub use flume::Receiver;
 pub use futures;
-pub use node::{arrow_utils, DataSample, DoraNode, ZERO_COPY_THRESHOLD};
+pub use node::{DataSample, DoraNode, ZERO_COPY_THRESHOLD, arrow_utils};
 
 mod daemon_connection;
 mod event_stream;

apis/rust/node/src/node/control_channel.rs

@@ -6,12 +6,12 @@ use dora_core::{
     uhlc::HLC,
 };
 use dora_message::{
+    DataflowId,
     daemon_to_node::{DaemonCommunication, DaemonReply},
     metadata::Metadata,
     node_to_daemon::{DaemonRequest, DataMessage, Timestamped},
-    DataflowId,
 };
-use eyre::{bail, eyre, Context};
+use eyre::{Context, bail, eyre};
 
 pub(crate) struct ControlChannel {
     channel: DaemonChannel,

apis/rust/node/src/node/drop_stream.rs

@@ -3,11 +3,11 @@ use std::{sync::Arc, time::Duration};
 use crate::daemon_connection::DaemonChannel;
 use dora_core::{config::NodeId, uhlc};
 use dora_message::{
+    DataflowId,
     daemon_to_node::{DaemonCommunication, DaemonReply, NodeDropEvent},
     node_to_daemon::{DaemonRequest, DropToken, Timestamped},
-    DataflowId,
 };
-use eyre::{eyre, Context};
+use eyre::{Context, eyre};
 use flume::RecvTimeoutError;
 
 pub struct DropStream {

apis/rust/node/src/node/mod.rs

@@ -1,4 +1,4 @@
-use crate::{daemon_connection::DaemonChannel, EventStream};
+use crate::{EventStream, daemon_connection::DaemonChannel};
 
 use self::{
     arrow_utils::{copy_array_into_sample, required_data_size},
@@ -16,12 +16,12 @@ use dora_core::{
 };
 
 use dora_message::{
+    DataflowId,
     daemon_to_node::{DaemonReply, NodeConfig},
     metadata::{ArrowTypeInfo, Metadata, MetadataParameters},
     node_to_daemon::{DaemonRequest, DataMessage, DropToken, Timestamped},
-    DataflowId,
 };
-use eyre::{bail, WrapErr};
+use eyre::{WrapErr, bail};
 use shared_memory_extended::{Shmem, ShmemConf};
 use std::{
     collections::{BTreeSet, HashMap, VecDeque},
@@ -157,7 +157,9 @@ impl DoraNode {
     /// [`init_from_node_id`][Self::init_from_node_id].
     pub fn init_flexible(node_id: NodeId) -> eyre::Result<(Self, EventStream)> {
         if std::env::var("DORA_NODE_CONFIG").is_ok() {
-            info!("Skipping {node_id} specified within the node initialization in favor of `DORA_NODE_CONFIG` specified by `dora start`");
+            info!(
+                "Skipping {node_id} specified within the node initialization in favor of `DORA_NODE_CONFIG` specified by `dora start`"
+            );
             Self::init_from_env()
         } else {
             Self::init_from_node_id(node_id)

apis/rust/operator/src/lib.rs

@@ -23,8 +23,8 @@ pub use dora_operator_api_macros::register_operator;
 pub use dora_operator_api_types as types;
 pub use types::DoraStatus;
 use types::{
-    arrow::{self, array::Array},
     Metadata, Output, SendOutput,
+    arrow::{self, array::Array},
 };
 
 pub mod raw;

apis/rust/operator/src/raw.rs

@@ -1,6 +1,6 @@
 use crate::{DoraOperator, DoraOutputSender, DoraStatus, Event};
 use dora_operator_api_types::{
-    arrow, DoraInitResult, DoraResult, OnEventResult, RawEvent, SendOutput,
+    DoraInitResult, DoraResult, OnEventResult, RawEvent, SendOutput, arrow,
 };
 use std::ffi::c_void;
 

binaries/cli/src/command/build/distributed.rs

@@ -1,13 +1,13 @@
 use communication_layer_request_reply::{TcpConnection, TcpRequestReplyConnection};
 use dora_core::descriptor::Descriptor;
 use dora_message::{
+    BuildId,
     cli_to_coordinator::ControlRequest,
     common::{GitSource, LogMessage},
     coordinator_to_cli::ControlRequestReply,
     id::NodeId,
-    BuildId,
 };
-use eyre::{bail, Context};
+use eyre::{Context, bail};
 use std::{
     collections::BTreeMap,
     net::{SocketAddr, TcpStream},

binaries/cli/src/command/build/mod.rs

@@ -52,11 +52,11 @@ use dora_core::{
     descriptor::{CoreNodeKind, CustomNode, Descriptor, DescriptorExt},
     topics::{DORA_COORDINATOR_PORT_CONTROL_DEFAULT, LOCALHOST},
 };
-use dora_message::{descriptor::NodeSource, BuildId};
+use dora_message::{BuildId, descriptor::NodeSource};
 use eyre::Context;
 use std::{collections::BTreeMap, net::IpAddr};
 
-use super::{default_tracing, Executable};
+use super::{Executable, default_tracing};
 use crate::{
     common::{connect_to_coordinator, local_working_dir, resolve_dataflow},
     session::DataflowSession,

binaries/cli/src/command/check.rs

@@ -1,10 +1,10 @@
-use super::{default_tracing, Executable};
-use crate::{common::connect_to_coordinator, LOCALHOST};
+use super::{Executable, default_tracing};
+use crate::{LOCALHOST, common::connect_to_coordinator};
 use communication_layer_request_reply::TcpRequestReplyConnection;
 use dora_core::descriptor::DescriptorExt;
 use dora_core::{descriptor::Descriptor, topics::DORA_COORDINATOR_PORT_CONTROL_DEFAULT};
 use dora_message::{cli_to_coordinator::ControlRequest, coordinator_to_cli::ControlRequestReply};
-use eyre::{bail, Context};
+use eyre::{Context, bail};
 use std::{
     io::{IsTerminal, Write},
     net::SocketAddr,

binaries/cli/src/command/destroy.rs

@@ -1,4 +1,4 @@
-use super::{default_tracing, up, Executable};
+use super::{Executable, default_tracing, up};
 use dora_core::topics::{DORA_COORDINATOR_PORT_CONTROL_DEFAULT, LOCALHOST};
 use std::net::IpAddr;
 use std::path::PathBuf;

binaries/cli/src/command/list.rs

@@ -1,9 +1,9 @@
 use std::io::Write;
 
-use super::{default_tracing, Executable};
+use super::{Executable, default_tracing};
 use crate::{
-    common::{connect_to_coordinator, query_running_dataflows},
     LOCALHOST,
+    common::{connect_to_coordinator, query_running_dataflows},
 };
 use clap::Args;
 use communication_layer_request_reply::TcpRequestReplyConnection;

binaries/cli/src/command/logs.rs

@@ -1,11 +1,11 @@
-use super::{default_tracing, Executable};
+use super::{Executable, default_tracing};
 use crate::common::{connect_to_coordinator, query_running_dataflows};
 use bat::{Input, PrettyPrinter};
 use clap::Args;
 use communication_layer_request_reply::TcpRequestReplyConnection;
 use dora_core::topics::{DORA_COORDINATOR_PORT_CONTROL_DEFAULT, LOCALHOST};
 use dora_message::{cli_to_coordinator::ControlRequest, coordinator_to_cli::ControlRequestReply};
-use eyre::{bail, Context, Result};
+use eyre::{Context, Result, bail};
 use uuid::Uuid;
 
 #[derive(Debug, Args)]
@@ -80,9 +80,11 @@ pub fn logs(
         .grid(false)
         .line_numbers(false)
         .paging_mode(bat::PagingMode::QuitIfOneScreen)
-        .inputs(vec![Input::from_bytes(&logs)
-            .name("Logs")
-            .title(format!("Logs from {node}.").as_str())])
+        .inputs(vec![
+            Input::from_bytes(&logs)
+                .name("Logs")
+                .title(format!("Logs from {node}.").as_str()),
+        ])
         .print()
         .wrap_err("Something went wrong with viewing log file")?;
 

binaries/cli/src/command/new.rs

@@ -1,6 +1,6 @@
 use clap::Args;
 
-use super::{default_tracing, Executable};
+use super::{Executable, default_tracing};
 
 #[derive(Debug, Args)]
 /// Generate a new project or node. Choose the language between Rust, Python, C or C++.

binaries/cli/src/command/run.rs

@@ -11,7 +11,7 @@ use crate::{
     output::print_log_message,
     session::DataflowSession,
 };
-use dora_daemon::{flume, Daemon, LogDestination};
+use dora_daemon::{Daemon, LogDestination, flume};
 use dora_tracing::TracingBuilder;
 use eyre::Context;
 use tokio::runtime::Builder;

binaries/cli/src/command/self_.rs

@@ -1,6 +1,6 @@
-use super::{default_tracing, Executable};
+use super::{Executable, default_tracing};
 use clap::Subcommand;
-use eyre::{bail, Context};
+use eyre::{Context, bail};
 
 #[derive(Debug, Subcommand)]
 /// Dora CLI self-management commands

binaries/cli/src/command/start/attach.rs

@@ -1,5 +1,5 @@
 use communication_layer_request_reply::{TcpConnection, TcpRequestReplyConnection};
-use dora_core::descriptor::{resolve_path, CoreNodeKind, Descriptor, DescriptorExt};
+use dora_core::descriptor::{CoreNodeKind, Descriptor, DescriptorExt, resolve_path};
 use dora_message::cli_to_coordinator::ControlRequest;
 use dora_message::common::LogMessage;
 use dora_message::coordinator_to_cli::ControlRequestReply;

binaries/cli/src/command/start/mod.rs

@@ -2,7 +2,7 @@
 //!
 //! The `dora start` command does not run any build commands, nor update git dependencies or similar. Use `dora build` for that.
 
-use super::{default_tracing, Executable};
+use super::{Executable, default_tracing};
 use crate::{
     command::start::attach::attach_dataflow,
     common::{connect_to_coordinator, local_working_dir, resolve_dataflow},
@@ -17,7 +17,7 @@ use dora_core::{
 use dora_message::{
     cli_to_coordinator::ControlRequest, common::LogMessage, coordinator_to_cli::ControlRequestReply,
 };
-use eyre::{bail, Context};
+use eyre::{Context, bail};
 use std::{
     net::{IpAddr, SocketAddr, TcpStream},
     path::PathBuf,

binaries/cli/src/command/stop.rs

@@ -1,11 +1,11 @@
-use super::{default_tracing, Executable};
+use super::{Executable, default_tracing};
 use crate::common::{connect_to_coordinator, handle_dataflow_result, query_running_dataflows};
 use communication_layer_request_reply::TcpRequestReplyConnection;
 use dora_core::topics::{DORA_COORDINATOR_PORT_CONTROL_DEFAULT, LOCALHOST};
 use dora_message::cli_to_coordinator::ControlRequest;
 use dora_message::coordinator_to_cli::ControlRequestReply;
 use duration_str::parse;
-use eyre::{bail, Context};
+use eyre::{Context, bail};
 use std::net::IpAddr;
 use std::time::Duration;
 use uuid::Uuid;

binaries/cli/src/command/up.rs

@@ -1,9 +1,9 @@
 use super::check::daemon_running;
-use super::{default_tracing, Executable};
-use crate::{common::connect_to_coordinator, LOCALHOST};
+use super::{Executable, default_tracing};
+use crate::{LOCALHOST, common::connect_to_coordinator};
 use dora_core::topics::DORA_COORDINATOR_PORT_CONTROL_DEFAULT;
 use dora_message::{cli_to_coordinator::ControlRequest, coordinator_to_cli::ControlRequestReply};
-use eyre::{bail, Context, ContextCompat};
+use eyre::{Context, ContextCompat, bail};
 use std::path::PathBuf;
 use std::{fs, net::SocketAddr, path::Path, process::Command, time::Duration};
 

binaries/cli/src/common.rs

@@ -1,12 +1,12 @@
 use crate::formatting::FormatDataflowError;
 use communication_layer_request_reply::{RequestReplyLayer, TcpLayer, TcpRequestReplyConnection};
-use dora_core::descriptor::{source_is_url, Descriptor};
+use dora_core::descriptor::{Descriptor, source_is_url};
 use dora_download::download_file;
 use dora_message::{
     cli_to_coordinator::ControlRequest,
     coordinator_to_cli::{ControlRequestReply, DataflowList, DataflowResult},
 };
-use eyre::{bail, Context, ContextCompat};
+use eyre::{Context, ContextCompat, bail};
 use std::{
     env::current_dir,
     net::SocketAddr,

binaries/cli/src/lib.rs

@@ -65,9 +65,9 @@ pub fn lib_main(args: Args) {
 use clap::Parser;
 #[cfg(feature = "python")]
 use pyo3::{
-    pyfunction, pymodule,
+    Bound, PyResult, Python, pyfunction, pymodule,
     types::{PyModule, PyModuleMethods},
-    wrap_pyfunction, Bound, PyResult, Python,
+    wrap_pyfunction,
 };
 
 #[cfg(feature = "python")]

binaries/cli/src/session.rs

@@ -4,7 +4,7 @@ use std::{
 };
 
 use dora_core::build::BuildInfo;
-use dora_message::{common::GitSource, id::NodeId, BuildId, SessionId};
+use dora_message::{BuildId, SessionId, common::GitSource, id::NodeId};
 use eyre::{Context, ContextCompat};
 
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
@@ -33,7 +33,9 @@ impl DataflowSession {
             if let Ok(parsed) = deserialize(&session_file) {
                 return Ok(parsed);
             } else {
-                tracing::warn!("failed to read dataflow session file, regenerating (you might need to run `dora build` again)");
+                tracing::warn!(
+                    "failed to read dataflow session file, regenerating (you might need to run `dora build` again)"
+                );
             }
         }
 

binaries/cli/src/template/c/mod.rs

@@ -1,5 +1,5 @@
 use dora_node_api_c::HEADER_NODE_API;
-use eyre::{bail, Context, ContextCompat};
+use eyre::{Context, ContextCompat, bail};
 use std::{
     fs,
     path::{Path, PathBuf},

binaries/cli/src/template/cxx/mod.rs

@@ -1,4 +1,4 @@
-use eyre::{bail, Context, ContextCompat};
+use eyre::{Context, ContextCompat, bail};
 use std::{
     fs,
     path::{Path, PathBuf},

binaries/cli/src/template/python/mod.rs

@@ -1,4 +1,4 @@
-use eyre::{bail, Context};
+use eyre::{Context, bail};
 use std::{
     fs,
     path::{Path, PathBuf},

binaries/cli/src/template/rust/mod.rs

@@ -1,4 +1,4 @@
-use eyre::{bail, Context};
+use eyre::{Context, bail};
 use std::{
     fs,
     path::{Path, PathBuf},

binaries/coordinator/src/control.rs

@@ -1,15 +1,15 @@
 use crate::{
-    tcp_utils::{tcp_receive, tcp_send},
     Event,
+    tcp_utils::{tcp_receive, tcp_send},
 };
 use dora_message::{
-    cli_to_coordinator::ControlRequest, coordinator_to_cli::ControlRequestReply, BuildId,
+    BuildId, cli_to_coordinator::ControlRequest, coordinator_to_cli::ControlRequestReply,
 };
-use eyre::{eyre, Context};
+use eyre::{Context, eyre};
 use futures::{
+    FutureExt, Stream, StreamExt,
     future::{self, Either},
     stream::FuturesUnordered,
-    FutureExt, Stream, StreamExt,
 };
 use futures_concurrency::future::Race;
 use std::{io::ErrorKind, net::SocketAddr};

binaries/coordinator/src/lib.rs

@@ -9,6 +9,7 @@ use dora_core::{
     uhlc::{self, HLC},
 };
 use dora_message::{
+    BuildId, DataflowId, SessionId,
     cli_to_coordinator::ControlRequest,
     common::{DaemonId, GitSource},
     coordinator_to_cli::{
@@ -20,10 +21,9 @@ use dora_message::{
     },
     daemon_to_coordinator::{DaemonCoordinatorReply, DataflowDaemonResult},
     descriptor::{Descriptor, ResolvedNode},
-    BuildId, DataflowId, SessionId,
 };
-use eyre::{bail, eyre, ContextCompat, Result, WrapErr};
-use futures::{future::join_all, stream::FuturesUnordered, Future, Stream, StreamExt};
+use eyre::{ContextCompat, Result, WrapErr, bail, eyre};
+use futures::{Future, Stream, StreamExt, future::join_all, stream::FuturesUnordered};
 use futures_concurrency::stream::Merge;
 use itertools::Itertools;
 use log_subscriber::LogSubscriber;
@@ -122,7 +122,9 @@ fn resolve_name(
             Ok(*uuid)
         } else {
             // TODO: Index the archived dataflows in order to return logs based on the index.
-            bail!("multiple archived dataflows found with name `{name}`, Please provide the UUID instead.");
+            bail!(
+                "multiple archived dataflows found with name `{name}`, Please provide the UUID instead."
+            );
         }
     } else if let [uuid] = uuids.as_slice() {
         Ok(*uuid)
@@ -285,7 +287,9 @@ async fn start_inner(
                             );
                         }
                         Err(err) => {
-                            tracing::warn!("failed to register daemon connection for daemon `{daemon_id}`: {err}");
+                            tracing::warn!(
+                                "failed to register daemon connection for daemon `{daemon_id}`: {err}"
+                            );
                         }
                     }
                 }
@@ -341,7 +345,9 @@ async fn start_inner(
                     }
                 }
                 DataflowEvent::DataflowFinishedOnDaemon { daemon_id, result } => {
-                    tracing::debug!("coordinator received DataflowFinishedOnDaemon ({daemon_id:?}, result: {result:?})");
+                    tracing::debug!(
+                        "coordinator received DataflowFinishedOnDaemon ({daemon_id:?}, result: {result:?})"
+                    );
                     match running_dataflows.entry(uuid) {
                         std::collections::hash_map::Entry::Occupied(mut entry) => {
                             let dataflow = entry.get_mut();
@@ -474,7 +480,9 @@ async fn start_inner(
                                         .values()
                                         .any(|d: &RunningDataflow| d.name.as_deref() == Some(name))
                                     {
-                                        bail!("there is already a running dataflow with name `{name}`");
+                                        bail!(
+                                            "there is already a running dataflow with name `{name}`"
+                                        );
                                     }
                                 }
                                 let dataflow = start_dataflow(
@@ -875,7 +883,9 @@ async fn start_inner(
                     }
                 }
                 None => {
-                    tracing::warn!("received DataflowSpawnResult, but no matching dataflow in `running_dataflows` map");
+                    tracing::warn!(
+                        "received DataflowSpawnResult, but no matching dataflow in `running_dataflows` map"
+                    );
                 }
             },
             Event::DataflowSpawnResult {
@@ -901,7 +911,9 @@ async fn start_inner(
                     };
                 }
                 None => {
-                    tracing::warn!("received DataflowSpawnResult, but no matching dataflow in `running_dataflows` map");
+                    tracing::warn!(
+                        "received DataflowSpawnResult, but no matching dataflow in `running_dataflows` map"
+                    );
                 }
             },
         }

binaries/coordinator/src/listener.rs

@@ -1,4 +1,4 @@
-use crate::{tcp_utils::tcp_receive, DaemonRequest, DataflowEvent, Event};
+use crate::{DaemonRequest, DataflowEvent, Event, tcp_utils::tcp_receive};
 use dora_core::uhlc::HLC;
 use dora_message::daemon_to_coordinator::{CoordinatorRequest, DaemonEvent, Timestamped};
 use eyre::Context;
@@ -12,7 +12,7 @@ pub async fn create_listener(bind: SocketAddr) -> eyre::Result<TcpListener> {
     let socket = match TcpListener::bind(bind).await {
         Ok(socket) => socket,
         Err(err) => {
-            return Err(eyre::Report::new(err).wrap_err("failed to create local TCP listener"))
+            return Err(eyre::Report::new(err).wrap_err("failed to create local TCP listener"));
         }
     };
     Ok(socket)

binaries/coordinator/src/run/mod.rs

@@ -1,18 +1,18 @@
 use crate::{
-    tcp_utils::{tcp_receive, tcp_send},
     DaemonConnections,
+    tcp_utils::{tcp_receive, tcp_send},
 };
 
 use dora_core::{descriptor::DescriptorExt, uhlc::HLC};
 use dora_message::{
+    BuildId, SessionId,
     common::DaemonId,
     coordinator_to_daemon::{DaemonCoordinatorEvent, SpawnDataflowNodes, Timestamped},
     daemon_to_coordinator::DaemonCoordinatorReply,
     descriptor::{Descriptor, ResolvedNode},
     id::NodeId,
-    BuildId, SessionId,
 };
-use eyre::{bail, eyre, ContextCompat, WrapErr};
+use eyre::{ContextCompat, WrapErr, bail, eyre};
 use itertools::Itertools;
 use std::{
     collections::{BTreeMap, BTreeSet},

binaries/daemon/src/coordinator.rs

@@ -1,6 +1,6 @@
 use crate::{
-    socket_stream_utils::{socket_stream_receive, socket_stream_send},
     DaemonCoordinatorEvent,
+    socket_stream_utils::{socket_stream_receive, socket_stream_send},
 };
 use dora_core::uhlc::HLC;
 use dora_message::{
@@ -8,14 +8,14 @@ use dora_message::{
     coordinator_to_daemon::RegisterResult,
     daemon_to_coordinator::{CoordinatorRequest, DaemonCoordinatorReply, DaemonRegisterRequest},
 };
-use eyre::{eyre, Context};
+use eyre::{Context, eyre};
 use std::{io::ErrorKind, net::SocketAddr, time::Duration};
 use tokio::{
     net::TcpStream,
     sync::{mpsc, oneshot},
     time::sleep,
 };
-use tokio_stream::{wrappers::ReceiverStream, Stream};
+use tokio_stream::{Stream, wrappers::ReceiverStream};
 use tracing::warn;
 
 const DAEMON_COORDINATOR_RETRY_INTERVAL: std::time::Duration = Duration::from_secs(1);
@@ -37,7 +37,9 @@ pub async fn register(
             .wrap_err("failed to connect to dora-coordinator")
         {
             Err(err) => {
-                warn!("Could not connect to: {addr}, with error: {err}. Retring in {DAEMON_COORDINATOR_RETRY_INTERVAL:#?}..");
+                warn!(
+                    "Could not connect to: {addr}, with error: {err}. Retring in {DAEMON_COORDINATOR_RETRY_INTERVAL:#?}.."
+                );
                 sleep(DAEMON_COORDINATOR_RETRY_INTERVAL).await;
             }
             Ok(stream) => {

binaries/daemon/src/local_listener.rs

@@ -137,7 +137,7 @@ async fn receive_message(
             | ErrorKind::ConnectionReset => return Ok(None),
             _other => {
                 return Err(err)
-                    .context("unexpected I/O error while trying to receive DaemonRequest")
+                    .context("unexpected I/O error while trying to receive DaemonRequest");
             }
         },
     };

binaries/daemon/src/log.rs

@@ -10,9 +10,9 @@ use dora_core::{
     uhlc,
 };
 use dora_message::{
+    BuildId,
     common::{DaemonId, LogLevel, LogMessage, Timestamped},
     daemon_to_coordinator::{CoordinatorRequest, DaemonEvent},
-    BuildId,
 };
 use eyre::Context;
 use flume::Sender;

binaries/daemon/src/node_communication/mod.rs

@@ -5,13 +5,13 @@ use dora_core::{
     uhlc,
 };
 use dora_message::{
+    DataflowId,
     common::{DropToken, Timestamped},
     daemon_to_node::{DaemonCommunication, DaemonReply, NodeDropEvent, NodeEvent},
     node_to_daemon::DaemonRequest,
-    DataflowId,
 };
-use eyre::{eyre, Context};
-use futures::{future, task, Future};
+use eyre::{Context, eyre};
+use futures::{Future, future, task};
 use shared_memory_server::{ShmemConf, ShmemServer};
 use std::{
     collections::{BTreeMap, VecDeque},
@@ -50,7 +50,7 @@ pub async fn spawn_listener_loop(
                 Err(err) => {
                     return Err(
                         eyre::Report::new(err).wrap_err("failed to create local TCP listener")
-                    )
+                    );
                 }
             };
             let socket_addr = socket
@@ -157,7 +157,7 @@ pub async fn spawn_listener_loop(
                 Ok(socket) => socket,
                 Err(err) => {
                     return Err(eyre::Report::new(err)
-                        .wrap_err("failed to create local Unix domain socket"))
+                        .wrap_err("failed to create local Unix domain socket"));
                 }
             };
 

binaries/daemon/src/node_communication/tcp.rs

@@ -2,8 +2,8 @@ use std::{collections::BTreeMap, io::ErrorKind, sync::Arc};
 
 use super::{Connection, Listener};
 use crate::{
-    socket_stream_utils::{socket_stream_receive, socket_stream_send},
     Event,
+    socket_stream_utils::{socket_stream_receive, socket_stream_send},
 };
 use dora_core::{config::DataId, uhlc::HLC};
 use dora_message::{
@@ -70,7 +70,7 @@ impl Connection for TcpConnection {
                 | ErrorKind::ConnectionReset => return Ok(None),
                 _other => {
                     return Err(err)
-                        .context("unexpected I/O error while trying to receive DaemonRequest")
+                        .context("unexpected I/O error while trying to receive DaemonRequest");
                 }
             },
         };

binaries/daemon/src/node_communication/unix_domain.rs

@@ -11,8 +11,8 @@ use tokio::{
 };
 
 use crate::{
-    socket_stream_utils::{socket_stream_receive, socket_stream_send},
     Event,
+    socket_stream_utils::{socket_stream_receive, socket_stream_send},
 };
 
 use super::{Connection, Listener};
@@ -68,7 +68,7 @@ impl Connection for UnixConnection {
                 | ErrorKind::ConnectionReset => return Ok(None),
                 _other => {
                     return Err(err)
-                        .context("unexpected I/O error while trying to receive DaemonRequest")
+                        .context("unexpected I/O error while trying to receive DaemonRequest");
                 }
             },
         };

binaries/daemon/src/pending.rs

@@ -2,18 +2,18 @@ use std::collections::{BTreeSet, HashMap, HashSet};
 
 use dora_core::{
     config::NodeId,
-    uhlc::{Timestamp, HLC},
+    uhlc::{HLC, Timestamp},
 };
 use dora_message::{
+    DataflowId,
     common::DaemonId,
     daemon_to_coordinator::{CoordinatorRequest, DaemonEvent, LogLevel, LogMessage, Timestamped},
     daemon_to_node::DaemonReply,
-    DataflowId,
 };
-use eyre::{bail, Context};
+use eyre::{Context, bail};
 use tokio::{net::TcpStream, sync::oneshot};
 
-use crate::{log::DataflowLogger, socket_stream_utils::socket_stream_send, CascadingErrorCauses};
+use crate::{CascadingErrorCauses, log::DataflowLogger, socket_stream_utils::socket_stream_send};
 
 pub struct PendingNodes {
     dataflow_id: DataflowId,

binaries/runtime/src/lib.rs

@@ -8,10 +8,10 @@ use dora_message::daemon_to_node::{NodeConfig, RuntimeConfig};
 use dora_metrics::run_metrics_monitor;
 use dora_node_api::{DoraNode, Event};
 use dora_tracing::TracingBuilder;
-use eyre::{bail, Context, Result};
+use eyre::{Context, Result, bail};
 use futures::{Stream, StreamExt};
 use futures_concurrency::stream::Merge;
-use operator::{run_operator, OperatorEvent, StopReason};
+use operator::{OperatorEvent, StopReason, run_operator};
 
 use std::{
     collections::{BTreeMap, BTreeSet, HashMap},
@@ -211,7 +211,9 @@ async fn run(
                     OperatorEvent::AllocateOutputSample { len, sample: tx } => {
                         let sample = node.allocate_data_sample(len);
                         if tx.send(sample).is_err() {
-                            tracing::warn!("output sample requested, but operator {operator_id} exited already");
+                            tracing::warn!(
+                                "output sample requested, but operator {operator_id} exited already"
+                            );
                         }
                     }
                     OperatorEvent::Output {
@@ -309,7 +311,10 @@ async fn run(
                     open_inputs.remove(&input_id);
                     if open_inputs.is_empty() {
                         // all inputs of the node were closed -> close its event channel
-                        tracing::trace!("all inputs of operator {}/{operator_id} were closed -> closing event channel", node.id());
+                        tracing::trace!(
+                            "all inputs of operator {}/{operator_id} were closed -> closing event channel",
+                            node.id()
+                        );
                         open_operator_inputs.remove(&operator_id);
                         operator_channels.remove(&operator_id);
                     }

binaries/runtime/src/operator/channel.rs

@@ -1,8 +1,8 @@
 use dora_core::config::DataId;
 use dora_node_api::Event;
 use futures::{
-    future::{self, FusedFuture},
     FutureExt,
+    future::{self, FusedFuture},
 };
 use std::collections::{BTreeMap, VecDeque};
 

binaries/runtime/src/operator/python.rs

@@ -3,21 +3,20 @@
 use super::{OperatorEvent, StopReason};
 use dora_core::{
     config::{NodeId, OperatorId},
-    descriptor::{source_is_url, Descriptor, PythonSource},
+    descriptor::{Descriptor, PythonSource, source_is_url},
 };
 use dora_download::download_file;
-use dora_node_api::{merged::MergedEvent, Event, Parameter};
+use dora_node_api::{Event, Parameter, merged::MergedEvent};
 use dora_operator_api_python::PyEvent;
 use dora_operator_api_types::DoraStatus;
-use eyre::{bail, eyre, Context, Result};
+use eyre::{Context, Result, bail, eyre};
 use pyo3::ffi::c_str;
 use pyo3::{
-    pyclass,
+    Py, PyAny, Python, pyclass,
     types::{IntoPyDict, PyAnyMethods, PyDict, PyDictMethods, PyTracebackMethods},
-    Py, PyAny, Python,
 };
 use std::{
-    panic::{catch_unwind, AssertUnwindSafe},
+    panic::{AssertUnwindSafe, catch_unwind},
     path::Path,
 };
 use tokio::sync::{mpsc::Sender, oneshot};
@@ -295,16 +294,15 @@ mod callback_impl {
     use dora_core::metadata::ArrowTypeInfoExt;
     use dora_message::metadata::ArrowTypeInfo;
     use dora_node_api::{
-        arrow_utils::{copy_array_into_sample, required_data_size},
         ZERO_COPY_THRESHOLD,
+        arrow_utils::{copy_array_into_sample, required_data_size},
     };
     use dora_operator_api_python::pydict_to_metadata;
     use dora_tracing::telemetry::deserialize_context;
-    use eyre::{eyre, Context, Result};
+    use eyre::{Context, Result, eyre};
     use pyo3::{
-        pymethods,
+        Bound, PyObject, Python, pymethods,
         types::{PyBytes, PyBytesMethods, PyDict},
-        Bound, PyObject, Python,
     };
     use tokio::sync::oneshot;
     use tracing::{field, span};

binaries/runtime/src/operator/shared_lib.rs

@@ -7,19 +7,19 @@ use dora_core::{
 };
 use dora_download::download_file;
 use dora_node_api::{
-    arrow_utils::{copy_array_into_sample, required_data_size},
     Event, Parameter,
+    arrow_utils::{copy_array_into_sample, required_data_size},
 };
 use dora_operator_api_types::{
-    safer_ffi::closure::ArcDynFn1, DoraDropOperator, DoraInitOperator, DoraInitResult, DoraOnEvent,
-    DoraResult, DoraStatus, Metadata, OnEventResult, Output, SendOutput,
+    DoraDropOperator, DoraInitOperator, DoraInitResult, DoraOnEvent, DoraResult, DoraStatus,
+    Metadata, OnEventResult, Output, SendOutput, safer_ffi::closure::ArcDynFn1,
 };
-use eyre::{bail, eyre, Context, Result};
+use eyre::{Context, Result, bail, eyre};
 use libloading::Symbol;
 use std::{
     collections::BTreeMap,
     ffi::c_void,
-    panic::{catch_unwind, AssertUnwindSafe},
+    panic::{AssertUnwindSafe, catch_unwind},
     path::Path,
     sync::Arc,
 };

examples/benchmark/node/src/main.rs

@@ -1,4 +1,4 @@
-use dora_node_api::{self, dora_core::config::DataId, DoraNode};
+use dora_node_api::{self, DoraNode, dora_core::config::DataId};
 use eyre::Context;
 use rand::RngCore;
 use std::time::Duration;

examples/benchmark/run.rs

@@ -1,5 +1,5 @@
 use dora_tracing::set_up_tracing;
-use eyre::{bail, Context};
+use eyre::{Context, bail};
 use std::path::Path;
 
 #[tokio::main]

examples/c++-arrow-dataflow/run.rs

@@ -1,5 +1,5 @@
 use dora_tracing::set_up_tracing;
-use eyre::{bail, Context};
+use eyre::{Context, bail};
 use std::{env::consts::EXE_SUFFIX, path::Path, process::Command};
 
 struct ArrowConfig {
@@ -77,7 +77,9 @@ fn find_arrow_config() -> eyre::Result<ArrowConfig> {
         .wrap_err("Failed to run pkg-config. Make sure Arrow C++ is installed")?;
 
     if !output.status.success() {
-        bail!("Arrow C++ not found via pkg-config. Make sure it's installed and in your PKG_CONFIG_PATH");
+        bail!(
+            "Arrow C++ not found via pkg-config. Make sure it's installed and in your PKG_CONFIG_PATH"
+        );
     }
 
     let cflags = String::from_utf8(output.stdout)?.trim().to_string();

examples/c++-dataflow/run.rs

@@ -1,5 +1,5 @@
 use dora_tracing::set_up_tracing;
-use eyre::{bail, Context};
+use eyre::{Context, bail};
 use std::{
     env::consts::{DLL_PREFIX, DLL_SUFFIX, EXE_SUFFIX},
     path::Path,

examples/c++-ros2-dataflow/run.rs

@@ -1,5 +1,5 @@
 use dora_tracing::set_up_tracing;
-use eyre::{bail, Context};
+use eyre::{Context, bail};
 use std::{env::consts::EXE_SUFFIX, path::Path};
 
 #[tokio::main]

examples/c-dataflow/run.rs

@@ -1,5 +1,5 @@
 use dora_tracing::set_up_tracing;
-use eyre::{bail, Context};
+use eyre::{Context, bail};
 use std::{
     env::consts::{DLL_PREFIX, DLL_SUFFIX, EXE_SUFFIX},
     path::Path,

examples/camera/run.rs

@@ -1,6 +1,6 @@
 use dora_core::{get_uv_path, run};
 use dora_tracing::set_up_tracing;
-use eyre::{bail, WrapErr};
+use eyre::{WrapErr, bail};
 use std::path::Path;
 
 #[tokio::main]

examples/cmake-dataflow/run.rs

@@ -1,5 +1,5 @@
 use dora_tracing::set_up_tracing;
-use eyre::{bail, Context};
+use eyre::{Context, bail};
 use std::path::Path;
 
 #[tokio::main]

examples/multiple-daemons/node/src/main.rs

@@ -1,4 +1,4 @@
-use dora_node_api::{self, dora_core::config::DataId, DoraNode, Event, IntoArrow};
+use dora_node_api::{self, DoraNode, Event, IntoArrow, dora_core::config::DataId};
 
 fn main() -> eyre::Result<()> {
     println!("hello");

examples/multiple-daemons/operator/src/lib.rs

@@ -1,7 +1,7 @@
 #![warn(unsafe_op_in_unsafe_fn)]
 
 use dora_operator_api::{
-    register_operator, DoraOperator, DoraOutputSender, DoraStatus, Event, IntoArrow,
+    DoraOperator, DoraOutputSender, DoraStatus, Event, IntoArrow, register_operator,
 };
 
 register_operator!(ExampleOperator);

examples/multiple-daemons/run.rs

@@ -1,7 +1,7 @@
 use dora_cli::session::DataflowSession;
 use dora_coordinator::{ControlEvent, Event};
 use dora_core::{
-    descriptor::{read_as_descriptor, DescriptorExt},
+    descriptor::{DescriptorExt, read_as_descriptor},
     topics::{DORA_COORDINATOR_PORT_CONTROL_DEFAULT, DORA_COORDINATOR_PORT_DEFAULT},
 };
 use dora_message::{
@@ -10,7 +10,7 @@ use dora_message::{
     coordinator_to_cli::{ControlRequestReply, DataflowIdAndName},
 };
 use dora_tracing::TracingBuilder;
-use eyre::{bail, Context};
+use eyre::{Context, bail};
 
 use std::{
     collections::BTreeSet,

examples/multiple-daemons/sink/src/main.rs

@@ -1,5 +1,5 @@
 use dora_node_api::{self, DoraNode, Event};
-use eyre::{bail, Context};
+use eyre::{Context, bail};
 
 fn main() -> eyre::Result<()> {
     let (_node, mut events) = DoraNode::init_from_env()?;
@@ -16,7 +16,9 @@ fn main() -> eyre::Result<()> {
                         TryFrom::try_from(&data).context("expected string message")?;
                     println!("sink received message: {received_string}");
                     if !received_string.starts_with("operator received random value ") {
-                        bail!("unexpected message format (should start with 'operator received random value')")
+                        bail!(
+                            "unexpected message format (should start with 'operator received random value')"
+                        )
                     }
                     if !received_string.ends_with(" ticks") {
                         bail!("unexpected message format (should end with 'ticks')")

examples/python-dataflow/run.rs

@@ -1,6 +1,6 @@
 use dora_core::{get_uv_path, run};
 use dora_tracing::set_up_tracing;
-use eyre::{bail, WrapErr};
+use eyre::{WrapErr, bail};
 use std::path::Path;
 
 #[tokio::main]

examples/python-operator-dataflow/run.rs

@@ -1,6 +1,6 @@
 use dora_core::{get_uv_path, run};
 use dora_tracing::set_up_tracing;
-use eyre::{bail, WrapErr};
+use eyre::{WrapErr, bail};
 use std::path::Path;
 
 #[tokio::main]

examples/python-ros2-dataflow/run.rs

@@ -1,6 +1,6 @@
 use dora_core::{get_uv_path, run};
 use dora_tracing::set_up_tracing;
-use eyre::{bail, WrapErr};
+use eyre::{WrapErr, bail};
 use std::path::Path;
 
 #[tokio::main]

examples/rerun-viewer/run.rs

@@ -1,6 +1,6 @@
 use dora_core::{get_uv_path, run};
 use dora_tracing::set_up_tracing;
-use eyre::{bail, WrapErr};
+use eyre::{WrapErr, bail};
 use std::path::Path;
 
 #[tokio::main]

examples/rust-dataflow-git/run.rs

@@ -1,5 +1,5 @@
 use dora_tracing::set_up_tracing;
-use eyre::{bail, Context};
+use eyre::{Context, bail};
 use std::path::Path;
 
 #[tokio::main]

examples/rust-dataflow-url/run.rs

@@ -1,5 +1,5 @@
 use dora_tracing::set_up_tracing;
-use eyre::{bail, Context};
+use eyre::{Context, bail};
 use std::path::Path;
 
 #[tokio::main]

examples/rust-dataflow/node/src/main.rs

@@ -1,4 +1,4 @@
-use dora_node_api::{self, dora_core::config::DataId, DoraNode, Event, IntoArrow};
+use dora_node_api::{self, DoraNode, Event, IntoArrow, dora_core::config::DataId};
 
 fn main() -> eyre::Result<()> {
     println!("hello");

examples/rust-dataflow/run.rs

@@ -1,5 +1,5 @@
 use dora_tracing::set_up_tracing;
-use eyre::{bail, Context};
+use eyre::{Context, bail};
 use std::path::Path;
 
 #[tokio::main]

examples/rust-dataflow/sink-dynamic/src/main.rs

@@ -1,5 +1,5 @@
-use dora_node_api::{self, dora_core::config::NodeId, DoraNode, Event};
-use eyre::{bail, Context};
+use dora_node_api::{self, DoraNode, Event, dora_core::config::NodeId};
+use eyre::{Context, bail};
 
 fn main() -> eyre::Result<()> {
     let (_node, mut events) =
@@ -17,7 +17,9 @@ fn main() -> eyre::Result<()> {
                         TryFrom::try_from(&data).context("expected string message")?;
                     println!("sink received message: {received_string}");
                     if !received_string.starts_with("operator received random value ") {
-                        bail!("unexpected message format (should start with 'operator received random value')")
+                        bail!(
+                            "unexpected message format (should start with 'operator received random value')"
+                        )
                     }
                     if !received_string.ends_with(" ticks") {
                         bail!("unexpected message format (should end with 'ticks')")

examples/rust-dataflow/sink/src/main.rs

@@ -1,5 +1,5 @@
 use dora_node_api::{self, DoraNode, Event};
-use eyre::{bail, Context};
+use eyre::{Context, bail};
 
 fn main() -> eyre::Result<()> {
     let (_node, mut events) = DoraNode::init_from_env()?;
@@ -16,7 +16,9 @@ fn main() -> eyre::Result<()> {
                         TryFrom::try_from(&data).context("expected string message")?;
                     println!("sink received message: {received_string}");
                     if !received_string.starts_with("operator received random value ") {
-                        bail!("unexpected message format (should start with 'operator received random value')")
+                        bail!(
+                            "unexpected message format (should start with 'operator received random value')"
+                        )
                     }
                     if !received_string.ends_with(" ticks") {
                         bail!("unexpected message format (should end with 'ticks')")

examples/rust-dataflow/status-node/src/main.rs

@@ -1,4 +1,4 @@
-use dora_node_api::{self, dora_core::config::DataId, DoraNode, Event, IntoArrow};
+use dora_node_api::{self, DoraNode, Event, IntoArrow, dora_core::config::DataId};
 use eyre::Context;
 
 fn main() -> eyre::Result<()> {

examples/rust-ros2-dataflow/node/src/main.rs

@@ -1,10 +1,9 @@
 use std::time::Duration;
 
 use dora_node_api::{
-    self,
+    self, DoraNode, Event,
     dora_core::config::DataId,
     merged::{MergeExternal, MergedEvent},
-    DoraNode, Event,
 };
 use dora_ros2_bridge::{
     messages::{
@@ -12,10 +11,10 @@ use dora_ros2_bridge::{
         geometry_msgs::msg::{Twist, Vector3},
         turtlesim::msg::Pose,
     },
-    ros2_client::{self, ros2, NodeOptions},
+    ros2_client::{self, NodeOptions, ros2},
     rustdds::{self, policy},
 };
-use eyre::{eyre, Context};
+use eyre::{Context, eyre};
 use futures::task::SpawnExt;
 
 fn main() -> eyre::Result<()> {

examples/rust-ros2-dataflow/run.rs

@@ -1,5 +1,5 @@
 use dora_tracing::set_up_tracing;
-use eyre::{bail, Context};
+use eyre::{Context, bail};
 use std::path::Path;
 
 #[tokio::main]

examples/vlm/run.rs

@@ -1,6 +1,6 @@
 use dora_core::{get_uv_path, run};
 use dora_tracing::set_up_tracing;
-use eyre::{bail, WrapErr};
+use eyre::{WrapErr, bail};
 use std::path::Path;
 
 #[tokio::main]

libraries/arrow-convert/src/from_impls.rs

@@ -274,7 +274,7 @@ where
 
 #[cfg(test)]
 mod tests {
-    use arrow::array::{make_array, PrimitiveArray};
+    use arrow::array::{PrimitiveArray, make_array};
 
     use crate::ArrowData;
 

libraries/arrow-convert/src/into_impls.rs

@@ -1,8 +1,8 @@
 use crate::IntoArrow;
 use arrow::array::{PrimitiveArray, StringArray, TimestampNanosecondArray};
 use arrow::datatypes::{
-    ArrowPrimitiveType, ArrowTimestampType, Float16Type, Float32Type, Float64Type, Int16Type,
-    Int32Type, Int64Type, Int8Type, UInt16Type, UInt32Type, UInt64Type, UInt8Type,
+    ArrowPrimitiveType, ArrowTimestampType, Float16Type, Float32Type, Float64Type, Int8Type,
+    Int16Type, Int32Type, Int64Type, UInt8Type, UInt16Type, UInt32Type, UInt64Type,
 };
 use chrono::{NaiveDate, NaiveDateTime, NaiveTime};
 use half::f16;

libraries/arrow-convert/src/lib.rs

@@ -3,11 +3,11 @@
 #![warn(missing_docs)]
 
 use arrow::array::{
-    Array, Float32Array, Float64Array, Int16Array, Int32Array, Int64Array, Int8Array, UInt16Array,
-    UInt32Array, UInt8Array,
+    Array, Float32Array, Float64Array, Int8Array, Int16Array, Int32Array, Int64Array, UInt8Array,
+    UInt16Array, UInt32Array,
 };
 use arrow::datatypes::DataType;
-use eyre::{eyre, ContextCompat, Result};
+use eyre::{ContextCompat, Result, eyre};
 use num::NumCast;
 use std::ops::{Deref, DerefMut};
 

libraries/communication-layer/pub-sub/src/zenoh.rs

@@ -4,7 +4,7 @@ use super::{CommunicationLayer, Publisher, Subscriber};
 use crate::{BoxError, ReceivedSample};
 use std::{borrow::Cow, sync::Arc, time::Duration};
 use zenoh::{
-    prelude::{sync::SyncResolve, Config, Priority, SessionDeclarations, SplitBuffer},
+    prelude::{Config, Priority, SessionDeclarations, SplitBuffer, sync::SyncResolve},
     publication::CongestionControl,
 };
 

libraries/communication-layer/request-reply/src/lib.rs

@@ -28,10 +28,10 @@ pub trait RequestReplyLayer: Send + Sync {
                 Item = Result<
                     Box<
                         dyn ListenConnection<
-                            RequestData = Self::RequestData,
-                            ReplyData = Self::ReplyData,
-                            Error = Self::Error,
-                        >,
+                                RequestData = Self::RequestData,
+                                ReplyData = Self::ReplyData,
+                                Error = Self::Error,
+                            >,
                     >,
                     Self::Error,
                 >,
@@ -47,10 +47,10 @@ pub trait RequestReplyLayer: Send + Sync {
     ) -> Result<
         Box<
             dyn RequestReplyConnection<
-                RequestData = Self::RequestData,
-                ReplyData = Self::ReplyData,
-                Error = Self::Error,
-            >,
+                    RequestData = Self::RequestData,
+                    ReplyData = Self::ReplyData,
+                    Error = Self::Error,
+                >,
         >,
         Self::Error,
     >;

libraries/communication-layer/request-reply/src/tcp.rs

@@ -37,10 +37,10 @@ impl RequestReplyLayer for TcpLayer {
                 Item = Result<
                     Box<
                         dyn crate::ListenConnection<
-                            RequestData = Self::RequestData,
-                            ReplyData = Self::ReplyData,
-                            Error = Self::Error,
-                        >,
+                                RequestData = Self::RequestData,
+                                ReplyData = Self::ReplyData,
+                                Error = Self::Error,
+                            >,
                     >,
                     Self::Error,
                 >,
@@ -56,10 +56,10 @@ impl RequestReplyLayer for TcpLayer {
                 r.map(|stream| {
                     let connection: Box<
                         dyn ListenConnection<
-                            RequestData = Self::RequestData,
-                            ReplyData = Self::ReplyData,
-                            Error = Self::Error,
-                        >,
+                                RequestData = Self::RequestData,
+                                ReplyData = Self::ReplyData,
+                                Error = Self::Error,
+                            >,
                     > = Box::new(TcpConnection { stream });
                     connection
                 })
@@ -74,20 +74,20 @@ impl RequestReplyLayer for TcpLayer {
     ) -> Result<
         Box<
             dyn crate::RequestReplyConnection<
-                RequestData = Self::RequestData,
-                ReplyData = Self::ReplyData,
-                Error = Self::Error,
-            >,
+                    RequestData = Self::RequestData,
+                    ReplyData = Self::ReplyData,
+                    Error = Self::Error,
+                >,
         >,
         Self::Error,
     > {
         TcpStream::connect(addr).map(|s| {
             let connection: Box<
                 dyn RequestReplyConnection<
-                    RequestData = Self::RequestData,
-                    ReplyData = Self::ReplyData,
-                    Error = Self::Error,
-                >,
+                        RequestData = Self::RequestData,
+                        ReplyData = Self::ReplyData,
+                        Error = Self::Error,
+                    >,
             > = Box::new(TcpConnection { stream: s });
             connection
         })

libraries/core/src/build/build_command.rs

@@ -6,7 +6,7 @@ use std::{
 };
 
 use dora_message::descriptor::EnvValue;
-use eyre::{eyre, Context};
+use eyre::{Context, eyre};
 
 pub fn run_build_command(
     build: &str,

libraries/core/src/build/git.rs

@@ -1,6 +1,6 @@
 use crate::build::{BuildLogger, PrevGitSource};
-use dora_message::{common::LogLevel, DataflowId, SessionId};
-use eyre::{bail, ContextCompat, WrapErr};
+use dora_message::{DataflowId, SessionId, common::LogLevel};
+use eyre::{ContextCompat, WrapErr, bail};
 use git2::FetchOptions;
 use itertools::Itertools;
 use std::{

libraries/core/src/descriptor/mod.rs

@@ -3,7 +3,7 @@ use dora_message::{
     descriptor::{GitRepoRev, NodeSource},
     id::{DataId, NodeId, OperatorId},
 };
-use eyre::{bail, Context, OptionExt, Result};
+use eyre::{Context, OptionExt, Result, bail};
 use std::{
     collections::{BTreeMap, HashMap},
     env::consts::EXE_EXTENSION,
@@ -14,9 +14,9 @@ use tokio::process::Command;
 
 // reexport for compatibility
 pub use dora_message::descriptor::{
-    CoreNodeKind, CustomNode, Descriptor, Node, OperatorConfig, OperatorDefinition, OperatorSource,
-    PythonSource, ResolvedNode, RuntimeNode, SingleOperatorDefinition, DYNAMIC_SOURCE,
-    SHELL_SOURCE,
+    CoreNodeKind, CustomNode, DYNAMIC_SOURCE, Descriptor, Node, OperatorConfig, OperatorDefinition,
+    OperatorSource, PythonSource, ResolvedNode, RuntimeNode, SHELL_SOURCE,
+    SingleOperatorDefinition,
 };
 pub use validate::ResolvedNodeExt;
 pub use visualize::collect_dora_timers;
@@ -165,7 +165,9 @@ fn node_kind_mut(node: &mut Node) -> eyre::Result<NodeKindMut> {
                         (None, Some(tag), None) => Some(GitRepoRev::Tag(tag.clone())),
                         (None, None, Some(rev)) => Some(GitRepoRev::Rev(rev.clone())),
                         other @ (_, _, _) => {
-                            eyre::bail!("only one of `branch`, `tag`, and `rev` are allowed (got {other:?})")
+                            eyre::bail!(
+                                "only one of `branch`, `tag`, and `rev` are allowed (got {other:?})"
+                            )
                         }
                     };
                     NodeSource::GitBranch {

libraries/core/src/descriptor/visualize.rs

@@ -1,5 +1,5 @@
 use dora_message::{
-    config::{format_duration, Input, InputMapping, UserInputMapping},
+    config::{Input, InputMapping, UserInputMapping, format_duration},
     descriptor::{CoreNodeKind, OperatorDefinition},
     id::{DataId, NodeId},
 };

libraries/core/src/lib.rs

@@ -1,4 +1,4 @@
-use eyre::{bail, eyre, Context};
+use eyre::{Context, bail, eyre};
 use std::{
     env::consts::{DLL_PREFIX, DLL_SUFFIX},
     ffi::OsStr,

libraries/extensions/ros2-bridge/msg-gen/src/parser/action.rs

@@ -61,7 +61,7 @@ mod test {
     use std::path::PathBuf;
 
     use super::*;
-    use crate::types::{primitives::*, sequences::*, MemberType};
+    use crate::types::{MemberType, primitives::*, sequences::*};
 
     fn parse_action_def(srv_name: &str) -> Result<Action> {
         let path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))

libraries/extensions/ros2-bridge/msg-gen/src/parser/constant.rs

@@ -1,4 +1,4 @@
-use anyhow::{ensure, Result};
+use anyhow::{Result, ensure};
 use nom::{
     bytes::complete::is_not,
     character::complete::{char, space0, space1},
@@ -8,7 +8,7 @@ use nom::{
 };
 
 use super::{error::RclMsgError, ident, literal, types};
-use crate::types::{primitives::PrimitiveType, Constant, ConstantType};
+use crate::types::{Constant, ConstantType, primitives::PrimitiveType};
 
 fn validate_value(r#type: ConstantType, value: &str) -> Result<Vec<String>> {
     match r#type {

libraries/extensions/ros2-bridge/msg-gen/src/parser/ident.rs

@@ -1,10 +1,10 @@
 use nom::{
+    IResult,
     branch::alt,
     character::complete::{alphanumeric0, char, one_of},
     combinator::{opt, recognize},
     multi::{many1, separated_list0, separated_list1},
     sequence::{pair, tuple},
-    IResult,
 };
 
 fn upperalpha(s: &str) -> IResult<&str, char> {

libraries/extensions/ros2-bridge/msg-gen/src/parser/literal.rs

@@ -1,6 +1,7 @@
 use std::convert::TryFrom;
 
 use nom::{
+    IResult,
     branch::alt,
     bytes::complete::{is_not, tag, tag_no_case, take_while},
     character::complete::{anychar, char, digit1, hex_digit1, none_of, oct_digit1, one_of, space0},
@@ -8,7 +9,6 @@ use nom::{
     multi::{many0, separated_list1},
     number::complete::recognize_float,
     sequence::{delimited, pair, tuple},
-    IResult,
 };
 
 use crate::types::primitives::{BasicType, GenericString};

libraries/extensions/ros2-bridge/msg-gen/src/parser/member.rs

@@ -1,4 +1,4 @@
-use anyhow::{ensure, Result};
+use anyhow::{Result, ensure};
 use nom::{
     bytes::complete::is_not,
     character::complete::{space0, space1},
@@ -8,7 +8,7 @@ use nom::{
 };
 
 use super::{error::RclMsgError, ident, literal, types};
-use crate::types::{primitives::NestableType, Member, MemberType};
+use crate::types::{Member, MemberType, primitives::NestableType};
 
 fn nestable_type_default(nestable_type: NestableType, default: &str) -> Result<Vec<String>> {
     match nestable_type {

libraries/extensions/ros2-bridge/msg-gen/src/parser/package.rs

@@ -51,9 +51,9 @@ fn get_ros_msgs_each_package<P: AsRef<Path>>(root_dir: P) -> Result<Vec<Package>
                 continue;
             } else if visited_files.contains(&(package.clone(), file_name.clone())) {
                 warn!(
-                        "found two versions of package: {:?}, message: {:?}. will skip the one in: {:#?}",
-                        package, file_name, path
-                    );
+                    "found two versions of package: {:?}, message: {:?}. will skip the one in: {:#?}",
+                    package, file_name, path
+                );
                 continue;
             } else {
                 visited_files.push((package.clone(), file_name.clone()));

libraries/extensions/ros2-bridge/msg-gen/src/parser/types.rs

@@ -1,11 +1,11 @@
 use anyhow::anyhow;
 use nom::{
+    IResult,
     branch::alt,
     bytes::complete::tag,
     character::complete::{char, space1},
     combinator::{eof, map, map_res, opt, peek},
     sequence::{delimited, pair, preceded, tuple},
-    IResult,
 };
 
 use super::{
@@ -13,9 +13,9 @@ use super::{
     literal::usize_literal,
 };
 use crate::types::{
+    ConstantType, MemberType,
     primitives::*,
     sequences::{Array, BoundedSequence, PrimitiveArray, Sequence},
-    ConstantType, MemberType,
 };
 
 pub fn parse_member_type(s: &str) -> IResult<&str, MemberType> {

libraries/extensions/ros2-bridge/msg-gen/src/types/action.rs

@@ -1,8 +1,8 @@
 use heck::SnakeCase;
-use quote::{format_ident, quote, ToTokens};
+use quote::{ToTokens, format_ident, quote};
 use syn::Ident;
 
-use super::{primitives::*, Member, Message, Service};
+use super::{Member, Message, Service, primitives::*};
 
 /// An action definition
 #[derive(Debug, Clone)]

libraries/extensions/ros2-bridge/msg-gen/src/types/constant.rs

@@ -1,4 +1,4 @@
-use quote::{quote, ToTokens};
+use quote::{ToTokens, quote};
 
 use super::{
     primitives::{BasicType, GenericUnboundedString, PrimitiveType},

libraries/extensions/ros2-bridge/msg-gen/src/types/member.rs

@@ -1,4 +1,4 @@
-use quote::{quote, ToTokens};
+use quote::{ToTokens, quote};
 
 use super::{primitives::*, sequences::*};
 

libraries/extensions/ros2-bridge/msg-gen/src/types/message.rs

@@ -1,7 +1,7 @@
-use quote::{format_ident, quote, ToTokens};
+use quote::{ToTokens, format_ident, quote};
 use syn::Ident;
 
-use super::{primitives::*, sequences::Array, ConstantType, MemberType};
+use super::{ConstantType, MemberType, primitives::*, sequences::Array};
 
 /// A member of a structure
 #[derive(Debug, Clone)]

libraries/extensions/ros2-bridge/msg-gen/src/types/package.rs

@@ -1,5 +1,5 @@
 use proc_macro2::Span;
-use quote::{quote, ToTokens};
+use quote::{ToTokens, quote};
 use syn::Ident;
 
 use crate::types::{Action, Message, Service};

libraries/extensions/ros2-bridge/msg-gen/src/types/primitives.rs

@@ -1,7 +1,7 @@
 use std::fmt;
 
 use proc_macro2::{Ident, Literal, Span};
-use quote::{format_ident, quote, ToTokens};
+use quote::{ToTokens, format_ident, quote};
 
 macro_rules! define_enum_from {
     ($into_t:ty, $from_t:ty, $path:path) => {