rename conduit to conduwuit finally

Signed-off-by: strawberry <strawberry@puppygock.gay>

src/service/Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "conduit_service"
+name = "conduwuit_service"
 categories.workspace = true
 description.workspace = true
 edition.workspace = true
@@ -44,8 +44,8 @@ arrayvec.workspace = true
 async-trait.workspace = true
 base64.workspace = true
 bytes.workspace = true
-conduit-core.workspace = true
-conduit-database.workspace = true
+conduwuit-core.workspace = true
+conduwuit-database.workspace = true
 const-str.workspace = true
 either.workspace = true
 futures.workspace = true

src/service/account_data/mod.rs

@@ -1,6 +1,6 @@
 use std::sync::Arc;
 
-use conduit::{
+use conduwuit::{
 	err, implement,
 	utils::{result::LogErr, stream::TryIgnore, ReadyExt},
 	Err, Result,

src/service/admin/console.rs

@@ -4,7 +4,7 @@ use std::{
 	sync::{Arc, Mutex},
 };
 
-use conduit::{debug, defer, error, log, Server};
+use conduwuit::{debug, defer, error, log, Server};
 use futures::future::{AbortHandle, Abortable};
 use ruma::events::room::message::RoomMessageEventContent;
 use rustyline_async::{Readline, ReadlineError, ReadlineEvent};

src/service/admin/create.rs

@@ -1,6 +1,6 @@
 use std::collections::BTreeMap;
 
-use conduit::{pdu::PduBuilder, Result};
+use conduwuit::{pdu::PduBuilder, Result};
 use ruma::{
 	events::room::{
 		canonical_alias::RoomCanonicalAliasEventContent,
@@ -67,7 +67,7 @@ pub async fn create_admin_room(services: &Services) -> Result<()> {
 		)
 		.await?;
 
-	// 2. Make conduit bot join
+	// 2. Make server user/bot join
 	services
 		.rooms
 		.timeline

src/service/admin/grant.rs

@@ -1,6 +1,6 @@
 use std::collections::BTreeMap;
 
-use conduit::{error, implement, Result};
+use conduwuit::{error, implement, Result};
 use ruma::{
 	events::{
 		room::{
@@ -16,9 +16,9 @@ use ruma::{
 
 use crate::pdu::PduBuilder;
 
-/// Invite the user to the conduit admin room.
+/// Invite the user to the conduwuit admin room.
 ///
-/// In conduit, this is equivalent to granting admin privileges.
+/// This is equivalent to granting server admin privileges.
 #[implement(super::Service)]
 pub async fn make_user_admin(&self, user_id: &UserId) -> Result<()> {
 	let Ok(room_id) = self.get_admin_room().await else {

src/service/admin/mod.rs

@@ -10,7 +10,7 @@ use std::{
 };
 
 use async_trait::async_trait;
-use conduit::{debug, err, error, error::default_log, pdu::PduBuilder, Error, PduEvent, Result, Server};
+use conduwuit::{debug, err, error, error::default_log, pdu::PduBuilder, Error, PduEvent, Result, Server};
 pub use create::create_admin_room;
 use futures::{FutureExt, TryFutureExt};
 use loole::{Receiver, Sender};

src/service/admin/startup.rs

@@ -1,4 +1,4 @@
-use conduit::{debug, debug_info, error, implement, info, Err, Result};
+use conduwuit::{debug, debug_info, error, implement, info, Err, Result};
 use ruma::events::room::message::RoomMessageEventContent;
 use tokio::time::{sleep, Duration};
 

src/service/appservice/mod.rs

@@ -4,7 +4,7 @@ mod registration_info;
 use std::{collections::BTreeMap, sync::Arc};
 
 use async_trait::async_trait;
-use conduit::{err, utils::stream::TryIgnore, Result};
+use conduwuit::{err, utils::stream::TryIgnore, Result};
 use database::Map;
 use futures::{Future, StreamExt, TryStreamExt};
 use ruma::{api::appservice::Registration, RoomAliasId, RoomId, UserId};

src/service/appservice/namespace_regex.rs

@@ -1,4 +1,4 @@
-use conduit::Result;
+use conduwuit::Result;
 use regex::RegexSet;
 use ruma::api::appservice::Namespace;
 

src/service/appservice/registration_info.rs

@@ -1,4 +1,4 @@
-use conduit::Result;
+use conduwuit::Result;
 use ruma::{api::appservice::Registration, UserId};
 
 use super::NamespaceRegex;

src/service/client/mod.rs

@@ -1,6 +1,6 @@
 use std::{sync::Arc, time::Duration};
 
-use conduit::{err, implement, trace, Config, Result};
+use conduwuit::{err, implement, trace, Config, Result};
 use either::Either;
 use ipaddress::IPAddress;
 use reqwest::redirect;
@@ -124,7 +124,7 @@ fn base(config: &Config) -> Result<reqwest::ClientBuilder> {
 		.timeout(Duration::from_secs(config.request_total_timeout))
 		.pool_idle_timeout(Duration::from_secs(config.request_idle_timeout))
 		.pool_max_idle_per_host(config.request_idle_per_host.into())
-		.user_agent(conduit::version::user_agent())
+		.user_agent(conduwuit::version::user_agent())
 		.redirect(redirect::Policy::limited(6))
 		.connection_verbose(true);
 
@@ -188,7 +188,7 @@ fn builder_interface(builder: reqwest::ClientBuilder, config: Option<&str>) -> R
 
 #[cfg(not(any(target_os = "android", target_os = "fuchsia", target_os = "linux")))]
 fn builder_interface(builder: reqwest::ClientBuilder, config: Option<&str>) -> Result<reqwest::ClientBuilder> {
-	use conduit::Err;
+	use conduwuit::Err;
 
 	if let Some(iface) = config {
 		Err!("Binding to network-interface {iface:?} by name is not supported on this platform.")

src/service/emergency/mod.rs

@@ -1,7 +1,7 @@
 use std::sync::Arc;
 
 use async_trait::async_trait;
-use conduit::{error, warn, Result};
+use conduwuit::{error, warn, Result};
 use ruma::{
 	events::{push_rules::PushRulesEventContent, GlobalAccountDataEvent, GlobalAccountDataEventType},
 	push::Ruleset,
@@ -38,7 +38,7 @@ impl crate::Service for Service {
 
 		self.set_emergency_access()
 			.await
-			.inspect_err(|e| error!("Could not set the configured emergency password for the conduit user: {e}"))?;
+			.inspect_err(|e| error!("Could not set the configured emergency password for the server user: {e}"))?;
 
 		Ok(())
 	}
@@ -47,17 +47,17 @@ impl crate::Service for Service {
 }
 
 impl Service {
-	/// Sets the emergency password and push rules for the @conduit account in
-	/// case emergency password is set
+	/// Sets the emergency password and push rules for the server user account
+	/// in case emergency password is set
 	async fn set_emergency_access(&self) -> Result<bool> {
-		let conduit_user = &self.services.globals.server_user;
+		let server_user = &self.services.globals.server_user;
 
 		self.services
 			.users
-			.set_password(conduit_user, self.services.globals.emergency_password().as_deref())?;
+			.set_password(server_user, self.services.globals.emergency_password().as_deref())?;
 
 		let (ruleset, pwd_set) = match self.services.globals.emergency_password() {
-			Some(_) => (Ruleset::server_default(conduit_user), true),
+			Some(_) => (Ruleset::server_default(server_user), true),
 			None => (Ruleset::new(), false),
 		};
 
@@ -65,7 +65,7 @@ impl Service {
 			.account_data
 			.update(
 				None,
-				conduit_user,
+				server_user,
 				GlobalAccountDataEventType::PushRules.to_string().into(),
 				&serde_json::to_value(&GlobalAccountDataEvent {
 					content: PushRulesEventContent {
@@ -83,7 +83,7 @@ impl Service {
 			);
 		} else {
 			// logs out any users still in the server service account and removes sessions
-			self.services.users.deactivate_account(conduit_user).await?;
+			self.services.users.deactivate_account(server_user).await?;
 		}
 
 		Ok(pwd_set)

src/service/globals/data.rs

@@ -1,6 +1,6 @@
 use std::sync::{Arc, RwLock};
 
-use conduit::{utils, Result};
+use conduwuit::{utils, Result};
 use database::{Database, Deserialized, Map};
 
 pub struct Data {

src/service/globals/mod.rs

@@ -7,7 +7,7 @@ use std::{
 	time::Instant,
 };
 
-use conduit::{error, Config, Result};
+use conduwuit::{error, Config, Result};
 use data::Data;
 use regex::RegexSet;
 use ruma::{OwnedEventId, OwnedRoomAliasId, OwnedServerName, OwnedUserId, RoomAliasId, ServerName, UserId};
@@ -83,8 +83,8 @@ impl crate::Service for Service {
 			.server
 			.supported_room_version(&config.default_room_version)
 		{
-			error!(config=?s.config.default_room_version, fallback=?conduit::config::default_default_room_version(), "Room version in config isn't supported, falling back to default version");
-			s.config.default_room_version = conduit::config::default_default_room_version();
+			error!(config=?s.config.default_room_version, fallback=?conduwuit::config::default_default_room_version(), "Room version in config isn't supported, falling back to default version");
+			s.config.default_room_version = conduwuit::config::default_default_room_version();
 		};
 
 		Ok(Arc::new(s))

src/service/key_backups/mod.rs

@@ -1,6 +1,6 @@
 use std::{collections::BTreeMap, sync::Arc};
 
-use conduit::{
+use conduwuit::{
 	err, implement,
 	utils::stream::{ReadyExt, TryIgnore},
 	Err, Result,

src/service/manager.rs

@@ -1,6 +1,6 @@
 use std::{panic::AssertUnwindSafe, sync::Arc, time::Duration};
 
-use conduit::{debug, debug_warn, error, trace, utils::time, warn, Err, Error, Result, Server};
+use conduwuit::{debug, debug_warn, error, trace, utils::time, warn, Err, Error, Result, Server};
 use futures::FutureExt;
 use tokio::{
 	sync::{Mutex, MutexGuard},

src/service/media/data.rs

@@ -1,6 +1,6 @@
 use std::{sync::Arc, time::Duration};
 
-use conduit::{
+use conduwuit::{
 	debug, debug_info, err,
 	utils::{str_from_bytes, stream::TryIgnore, string_from_bytes, ReadyExt},
 	Err, Error, Result,

src/service/media/migrations.rs

@@ -7,7 +7,7 @@ use std::{
 	time::Instant,
 };
 
-use conduit::{
+use conduwuit::{
 	debug, debug_info, debug_warn, error, info,
 	utils::{stream::TryIgnore, ReadyExt},
 	warn, Config, Result,

src/service/media/mod.rs

@@ -9,7 +9,7 @@ use std::{path::PathBuf, sync::Arc, time::SystemTime};
 
 use async_trait::async_trait;
 use base64::{engine::general_purpose, Engine as _};
-use conduit::{
+use conduwuit::{
 	debug, debug_error, debug_info, debug_warn, err, error, trace,
 	utils::{self, MutexMap},
 	warn, Err, Result, Server,

src/service/media/preview.rs

@@ -1,7 +1,7 @@
 use std::{io::Cursor, time::SystemTime};
 
-use conduit::{debug, utils, Err, Result};
-use conduit_core::implement;
+use conduwuit::{debug, utils, Err, Result};
+use conduwuit_core::implement;
 use image::ImageReader as ImgReader;
 use ipaddress::IPAddress;
 use ruma::Mxc;

src/service/media/remote.rs

@@ -1,6 +1,6 @@
 use std::{fmt::Debug, time::Duration};
 
-use conduit::{debug_warn, err, implement, utils::content_disposition::make_content_disposition, Err, Error, Result};
+use conduwuit::{debug_warn, err, implement, utils::content_disposition::make_content_disposition, Err, Error, Result};
 use http::header::{HeaderValue, CONTENT_DISPOSITION, CONTENT_TYPE};
 use ruma::{
 	api::{

src/service/media/thumbnail.rs

@@ -1,6 +1,6 @@
 use std::{cmp, io::Cursor, num::Saturating as Sat};
 
-use conduit::{checked, err, Result};
+use conduwuit::{checked, err, Result};
 use image::{imageops::FilterType, DynamicImage};
 use ruma::{http_headers::ContentDisposition, media::Method, Mxc, UInt, UserId};
 use tokio::{

src/service/migrations.rs

@@ -1,6 +1,6 @@
 use std::cmp;
 
-use conduit::{
+use conduwuit::{
 	debug, debug_info, debug_warn, error, info,
 	result::NotFound,
 	utils::{
@@ -41,9 +41,9 @@ pub(crate) async fn migrations(services: &Services) -> Result<()> {
 	// Matrix resource ownership is based on the server name; changing it
 	// requires recreating the database from scratch.
 	if users_count > 0 {
-		let conduit_user = &services.globals.server_user;
-		if !services.users.exists(conduit_user).await {
-			error!("The {conduit_user} server user does not exist, and the database is not new.");
+		let server_user = &services.globals.server_user;
+		if !services.users.exists(server_user).await {
+			error!("The {server_user} server user does not exist, and the database is not new.");
 			return Err!(Database(
 				"Cannot reuse an existing database after changing the server name, please delete the old one first.",
 			));

src/service/mod.rs

@@ -25,14 +25,14 @@ pub mod uiaa;
 pub mod updates;
 pub mod users;
 
-extern crate conduit_core as conduit;
-extern crate conduit_database as database;
+extern crate conduwuit_core as conduwuit;
+extern crate conduwuit_database as database;
 
-pub use conduit::{pdu, PduBuilder, PduCount, PduEvent};
+pub use conduwuit::{pdu, PduBuilder, PduCount, PduEvent};
 pub(crate) use service::{Args, Dep, Service};
 
 pub use crate::services::Services;
 
-conduit::mod_ctor! {}
-conduit::mod_dtor! {}
-conduit::rustc_flags_capture! {}
+conduwuit::mod_ctor! {}
+conduwuit::mod_dtor! {}
+conduwuit::rustc_flags_capture! {}

src/service/presence/data.rs

@@ -1,6 +1,6 @@
 use std::sync::Arc;
 
-use conduit::{
+use conduwuit::{
 	debug_warn, utils,
 	utils::{stream::TryIgnore, ReadyExt},
 	Result,

src/service/presence/mod.rs

@@ -4,7 +4,7 @@ mod presence;
 use std::{sync::Arc, time::Duration};
 
 use async_trait::async_trait;
-use conduit::{checked, debug, error, result::LogErr, Error, Result, Server};
+use conduwuit::{checked, debug, error, result::LogErr, Error, Result, Server};
 use futures::{stream::FuturesUnordered, Stream, StreamExt, TryFutureExt};
 use ruma::{events::presence::PresenceEvent, presence::PresenceState, OwnedUserId, UInt, UserId};
 use tokio::{sync::Mutex, time::sleep};

src/service/presence/presence.rs

@@ -1,4 +1,4 @@
-use conduit::{utils, Error, Result};
+use conduwuit::{utils, Error, Result};
 use ruma::{
 	events::presence::{PresenceEvent, PresenceEventContent},
 	presence::PresenceState,

src/service/pusher/mod.rs

@@ -1,7 +1,7 @@
 use std::{fmt::Debug, mem, sync::Arc};
 
 use bytes::BytesMut;
-use conduit::{
+use conduwuit::{
 	debug_warn, err, trace,
 	utils::{stream::TryIgnore, string_from_bytes},
 	warn, Err, PduEvent, Result,

src/service/resolver/actual.rs

@@ -3,7 +3,7 @@ use std::{
 	net::{IpAddr, SocketAddr},
 };
 
-use conduit::{debug, debug_error, debug_info, debug_warn, err, error, trace, Err, Result};
+use conduwuit::{debug, debug_error, debug_info, debug_warn, err, error, trace, Err, Result};
 use hickory_resolver::error::ResolveError;
 use ipaddress::IPAddress;
 use ruma::ServerName;

src/service/resolver/cache.rs

@@ -6,7 +6,7 @@ use std::{
 };
 
 use arrayvec::ArrayVec;
-use conduit::{trace, utils::rand};
+use conduwuit::{trace, utils::rand};
 use ruma::{OwnedServerName, ServerName};
 
 use super::fed::FedDest;

src/service/resolver/dns.rs

@@ -1,6 +1,6 @@
 use std::{net::SocketAddr, sync::Arc, time::Duration};
 
-use conduit::{err, Result, Server};
+use conduwuit::{err, Result, Server};
 use futures::FutureExt;
 use hickory_resolver::TokioAsyncResolver;
 use reqwest::dns::{Addrs, Name, Resolve, Resolving};

src/service/resolver/mod.rs

@@ -6,7 +6,7 @@ mod tests;
 
 use std::{fmt::Write, sync::Arc};
 
-use conduit::{Result, Server};
+use conduwuit::{Result, Server};
 
 use self::{cache::Cache, dns::Resolver};
 use crate::{client, Dep};

src/service/rooms/alias/mod.rs

@@ -2,7 +2,7 @@ mod remote;
 
 use std::sync::Arc;
 
-use conduit::{
+use conduwuit::{
 	err,
 	utils::{stream::TryIgnore, ReadyExt},
 	Err, Error, Result,

src/service/rooms/alias/remote.rs

@@ -1,6 +1,6 @@
 use std::iter::once;
 
-use conduit::{debug, debug_error, err, implement, Result};
+use conduwuit::{debug, debug_error, err, implement, Result};
 use federation::query::get_room_information::v1::Response;
 use ruma::{api::federation, OwnedRoomId, OwnedServerName, RoomAliasId, ServerName};
 

src/service/rooms/auth_chain/data.rs

@@ -3,7 +3,7 @@ use std::{
 	sync::{Arc, Mutex},
 };
 
-use conduit::{err, utils, utils::math::usize_from_f64, Err, Result};
+use conduwuit::{err, utils, utils::math::usize_from_f64, Err, Result};
 use database::Map;
 use lru_cache::LruCache;
 

src/service/rooms/auth_chain/mod.rs

@@ -6,7 +6,7 @@ use std::{
 	sync::Arc,
 };
 
-use conduit::{
+use conduwuit::{
 	debug, debug_error, trace,
 	utils::{stream::ReadyExt, IterStream},
 	validated, warn, Err, Result,

src/service/rooms/directory/mod.rs

@@ -1,6 +1,6 @@
 use std::sync::Arc;
 
-use conduit::{implement, utils::stream::TryIgnore, Result};
+use conduwuit::{implement, utils::stream::TryIgnore, Result};
 use database::Map;
 use futures::Stream;
 use ruma::{api::client::room::Visibility, RoomId};

src/service/rooms/event_handler/acl_check.rs

@@ -1,4 +1,4 @@
-use conduit::{debug, implement, trace, warn, Err, Result};
+use conduwuit::{debug, implement, trace, warn, Err, Result};
 use ruma::{
 	events::{room::server_acl::RoomServerAclEventContent, StateEventType},
 	RoomId, ServerName,

src/service/rooms/event_handler/fetch_and_handle_outliers.rs

@@ -4,7 +4,7 @@ use std::{
 	time::Instant,
 };
 
-use conduit::{
+use conduwuit::{
 	debug, debug_error, implement, info, pdu, trace, utils::math::continue_exponential_backoff_secs, warn, PduEvent,
 };
 use futures::TryFutureExt;

src/service/rooms/event_handler/fetch_prev.rs

@@ -3,7 +3,7 @@ use std::{
 	sync::Arc,
 };
 
-use conduit::{debug_warn, err, implement, PduEvent, Result};
+use conduwuit::{debug_warn, err, implement, PduEvent, Result};
 use futures::{future, FutureExt};
 use ruma::{
 	int,

src/service/rooms/event_handler/fetch_state.rs

@@ -3,7 +3,7 @@ use std::{
 	sync::Arc,
 };
 
-use conduit::{debug, implement, warn, Err, Error, PduEvent, Result};
+use conduwuit::{debug, implement, warn, Err, Error, PduEvent, Result};
 use futures::FutureExt;
 use ruma::{
 	api::federation::event::get_room_state_ids, events::StateEventType, EventId, RoomId, RoomVersionId, ServerName,

src/service/rooms/event_handler/handle_incoming_pdu.rs

@@ -4,7 +4,7 @@ use std::{
 	time::Instant,
 };
 
-use conduit::{debug, err, implement, warn, Error, Result};
+use conduwuit::{debug, err, implement, warn, Error, Result};
 use futures::{FutureExt, TryFutureExt};
 use ruma::{
 	api::client::error::ErrorKind, events::StateEventType, CanonicalJsonValue, EventId, RoomId, ServerName, UserId,

src/service/rooms/event_handler/handle_outlier_pdu.rs

@@ -3,7 +3,7 @@ use std::{
 	sync::Arc,
 };
 
-use conduit::{debug, debug_info, err, implement, trace, warn, Err, Error, PduEvent, Result};
+use conduwuit::{debug, debug_info, err, implement, trace, warn, Err, Error, PduEvent, Result};
 use futures::{future::ready, TryFutureExt};
 use ruma::{
 	api::client::error::ErrorKind,

src/service/rooms/event_handler/handle_prev_pdu.rs

@@ -4,7 +4,7 @@ use std::{
 	time::Instant,
 };
 
-use conduit::{debug, implement, utils::math::continue_exponential_backoff_secs, Error, PduEvent, Result};
+use conduwuit::{debug, implement, utils::math::continue_exponential_backoff_secs, Error, PduEvent, Result};
 use ruma::{api::client::error::ErrorKind, CanonicalJsonValue, EventId, RoomId, ServerName};
 
 #[implement(super::Service)]

src/service/rooms/event_handler/mod.rs

@@ -17,7 +17,7 @@ use std::{
 	time::Instant,
 };
 
-use conduit::{
+use conduwuit::{
 	utils::{MutexMap, TryFutureExtExt},
 	Err, PduEvent, Result, Server,
 };

src/service/rooms/event_handler/parse_incoming_pdu.rs

@@ -1,4 +1,4 @@
-use conduit::{err, implement, pdu::gen_event_id_canonical_json, result::FlatOk, Result};
+use conduwuit::{err, implement, pdu::gen_event_id_canonical_json, result::FlatOk, Result};
 use ruma::{CanonicalJsonObject, CanonicalJsonValue, OwnedEventId, OwnedRoomId, RoomId};
 use serde_json::value::RawValue as RawJsonValue;
 

src/service/rooms/event_handler/resolve_state.rs

@@ -4,7 +4,7 @@ use std::{
 	sync::Arc,
 };
 
-use conduit::{
+use conduwuit::{
 	debug, err, implement,
 	utils::stream::{IterStream, WidebandExt},
 	Result,

src/service/rooms/event_handler/state_at_incoming.rs

@@ -4,7 +4,7 @@ use std::{
 	sync::Arc,
 };
 
-use conduit::{
+use conduwuit::{
 	debug, err, implement,
 	result::LogErr,
 	utils::stream::{BroadbandExt, IterStream},

src/service/rooms/event_handler/upgrade_outlier_pdu.rs

@@ -5,7 +5,7 @@ use std::{
 	time::Instant,
 };
 
-use conduit::{debug, debug_info, err, implement, trace, warn, Err, Error, PduEvent, Result};
+use conduwuit::{debug, debug_info, err, implement, trace, warn, Err, Error, PduEvent, Result};
 use futures::{future::ready, StreamExt};
 use ruma::{
 	api::client::error::ErrorKind,

src/service/rooms/lazy_loading/mod.rs

@@ -4,7 +4,7 @@ use std::{
 	sync::{Arc, Mutex},
 };
 
-use conduit::{
+use conduwuit::{
 	implement,
 	utils::{stream::TryIgnore, ReadyExt},
 	PduCount, Result,

src/service/rooms/metadata/mod.rs

@@ -1,6 +1,6 @@
 use std::sync::Arc;
 
-use conduit::{implement, utils::stream::TryIgnore, Result};
+use conduwuit::{implement, utils::stream::TryIgnore, Result};
 use database::Map;
 use futures::{Stream, StreamExt};
 use ruma::RoomId;

src/service/rooms/outlier/mod.rs

@@ -1,6 +1,6 @@
 use std::sync::Arc;
 
-use conduit::{implement, Result};
+use conduwuit::{implement, Result};
 use database::{Deserialized, Json, Map};
 use ruma::{CanonicalJsonObject, EventId};
 

src/service/rooms/pdu_metadata/data.rs

@@ -1,7 +1,7 @@
 use std::{mem::size_of, sync::Arc};
 
 use arrayvec::ArrayVec;
-use conduit::{
+use conduwuit::{
 	result::LogErr,
 	utils::{
 		stream::{TryIgnore, WidebandExt},

src/service/rooms/pdu_metadata/mod.rs

@@ -1,7 +1,7 @@
 mod data;
 use std::sync::Arc;
 
-use conduit::{PduCount, Result};
+use conduwuit::{PduCount, Result};
 use futures::StreamExt;
 use ruma::{api::Direction, EventId, RoomId, UserId};
 

src/service/rooms/read_receipt/data.rs

@@ -1,6 +1,6 @@
 use std::sync::Arc;
 
-use conduit::{
+use conduwuit::{
 	utils::{stream::TryIgnore, ReadyExt},
 	Result,
 };

src/service/rooms/read_receipt/mod.rs

@@ -2,7 +2,7 @@ mod data;
 
 use std::{collections::BTreeMap, sync::Arc};
 
-use conduit::{debug, err, warn, PduCount, PduId, RawPduId, Result};
+use conduwuit::{debug, err, warn, PduCount, PduId, RawPduId, Result};
 use futures::{try_join, Stream, TryFutureExt};
 use ruma::{
 	events::{

src/service/rooms/search/mod.rs

@@ -1,7 +1,7 @@
 use std::sync::Arc;
 
 use arrayvec::ArrayVec;
-use conduit::{
+use conduwuit::{
 	implement,
 	utils::{
 		set,

src/service/rooms/short/mod.rs

@@ -1,7 +1,7 @@
 use std::{borrow::Borrow, fmt::Debug, mem::size_of_val, sync::Arc};
 
-pub use conduit::pdu::{ShortEventId, ShortId, ShortRoomId};
-use conduit::{err, implement, utils, utils::stream::ReadyExt, Result};
+pub use conduwuit::pdu::{ShortEventId, ShortId, ShortRoomId};
+use conduwuit::{err, implement, utils, utils::stream::ReadyExt, Result};
 use database::{Deserialized, Map};
 use futures::{Stream, StreamExt};
 use ruma::{events::StateEventType, EventId, RoomId};

src/service/rooms/spaces/mod.rs

@@ -7,7 +7,7 @@ use std::{
 	sync::Arc,
 };
 
-use conduit::{
+use conduwuit::{
 	checked, debug_info, err,
 	utils::{math::usize_from_f64, IterStream},
 	Error, Result,

src/service/rooms/state/mod.rs

@@ -5,7 +5,7 @@ use std::{
 	sync::Arc,
 };
 
-use conduit::{
+use conduwuit::{
 	err,
 	result::FlatOk,
 	utils::{

src/service/rooms/state_accessor/data.rs

@@ -1,6 +1,6 @@
 use std::{borrow::Borrow, collections::HashMap, sync::Arc};
 
-use conduit::{
+use conduwuit::{
 	at, err, ref_at,
 	utils::stream::{BroadbandExt, IterStream, ReadyExt},
 	PduEvent, Result,

src/service/rooms/state_accessor/mod.rs

@@ -7,7 +7,7 @@ use std::{
 	sync::{Arc, Mutex as StdMutex, Mutex},
 };
 
-use conduit::{
+use conduwuit::{
 	err, error,
 	pdu::PduBuilder,
 	utils::{math::usize_from_f64, ReadyExt},

src/service/rooms/state_cache/mod.rs

@@ -3,7 +3,7 @@ use std::{
 	sync::{Arc, RwLock},
 };
 
-use conduit::{
+use conduwuit::{
 	is_not_empty,
 	result::LogErr,
 	utils::{stream::TryIgnore, ReadyExt, StreamTools},
@@ -395,7 +395,7 @@ impl Service {
 	pub fn get_shared_rooms<'a>(
 		&'a self, user_a: &'a UserId, user_b: &'a UserId,
 	) -> impl Stream<Item = &RoomId> + Send + 'a {
-		use conduit::utils::set;
+		use conduwuit::utils::set;
 
 		let a = self.rooms_joined(user_a);
 		let b = self.rooms_joined(user_b);

src/service/rooms/state_compressor/mod.rs

@@ -6,7 +6,7 @@ use std::{
 };
 
 use arrayvec::ArrayVec;
-use conduit::{
+use conduwuit::{
 	at, checked, debug, err, expected, utils,
 	utils::{bytes, math::usize_from_f64, stream::IterStream},
 	Result,

src/service/rooms/threads/mod.rs

@@ -1,6 +1,6 @@
 use std::{collections::BTreeMap, sync::Arc};
 
-use conduit::{
+use conduwuit::{
 	err,
 	utils::{
 		stream::{TryIgnore, WidebandExt},

src/service/rooms/timeline/data.rs

@@ -4,7 +4,7 @@ use std::{
 	sync::Arc,
 };
 
-use conduit::{
+use conduwuit::{
 	at, err,
 	result::{LogErr, NotFound},
 	utils,

src/service/rooms/timeline/mod.rs

@@ -8,13 +8,13 @@ use std::{
 	sync::Arc,
 };
 
-use conduit::{
+use conduwuit::{
 	debug, debug_warn, err, error, implement, info,
 	pdu::{EventHash, PduBuilder, PduCount, PduEvent},
 	utils::{self, stream::TryIgnore, IterStream, MutexMap, MutexMapGuard, ReadyExt},
 	validated, warn, Err, Error, Result, Server,
 };
-pub use conduit::{PduId, RawPduId};
+pub use conduwuit::{PduId, RawPduId};
 use futures::{future, future::ready, Future, FutureExt, Stream, StreamExt, TryFutureExt, TryStreamExt};
 use ruma::{
 	api::federation,

src/service/rooms/typing/mod.rs

@@ -1,6 +1,6 @@
 use std::{collections::BTreeMap, sync::Arc};
 
-use conduit::{
+use conduwuit::{
 	debug_info, trace,
 	utils::{self, IterStream},
 	Result, Server,

src/service/rooms/user/mod.rs

@@ -1,6 +1,6 @@
 use std::sync::Arc;
 
-use conduit::{implement, Result};
+use conduwuit::{implement, Result};
 use database::{Database, Deserialized, Map};
 use ruma::{RoomId, UserId};
 

src/service/sending/appservice.rs

@@ -1,7 +1,7 @@
 use std::{fmt::Debug, mem};
 
 use bytes::BytesMut;
-use conduit::{debug_error, err, trace, utils, warn, Err, Result};
+use conduwuit::{debug_error, err, trace, utils, warn, Err, Result};
 use reqwest::Client;
 use ruma::api::{appservice::Registration, IncomingResponse, MatrixVersion, OutgoingRequest, SendAccessToken};
 

src/service/sending/data.rs

@@ -1,6 +1,6 @@
 use std::{fmt::Debug, sync::Arc};
 
-use conduit::{
+use conduwuit::{
 	at, utils,
 	utils::{stream::TryIgnore, ReadyExt},
 	Error, Result,

src/service/sending/dest.rs

@@ -1,6 +1,6 @@
 use std::fmt::Debug;
 
-use conduit::implement;
+use conduwuit::implement;
 use ruma::{OwnedServerName, OwnedUserId};
 
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]

src/service/sending/mod.rs

@@ -7,7 +7,7 @@ mod sender;
 use std::{fmt::Debug, iter::once, sync::Arc};
 
 use async_trait::async_trait;
-use conduit::{
+use conduwuit::{
 	debug_warn, err,
 	utils::{ReadyExt, TryReadyExt},
 	warn, Result, Server,

src/service/sending/send.rs

@@ -1,7 +1,7 @@
 use std::mem;
 
 use bytes::Bytes;
-use conduit::{
+use conduwuit::{
 	debug, debug_error, debug_warn, err, error::inspect_debug_log, implement, trace, utils::string::EMPTY, Err, Error,
 	Result,
 };

src/service/sending/sender.rs

@@ -6,7 +6,7 @@ use std::{
 };
 
 use base64::{engine::general_purpose, Engine as _};
-use conduit::{
+use conduwuit::{
 	debug, err, error,
 	result::LogErr,
 	trace,

src/service/server_keys/acquire.rs

@@ -4,7 +4,7 @@ use std::{
 	time::Duration,
 };
 
-use conduit::{debug, debug_error, debug_warn, error, implement, info, result::FlatOk, trace, warn};
+use conduwuit::{debug, debug_error, debug_warn, error, implement, info, result::FlatOk, trace, warn};
 use futures::{stream::FuturesUnordered, StreamExt};
 use ruma::{
 	api::federation::discovery::ServerSigningKeys, serde::Raw, CanonicalJsonObject, OwnedServerName,

src/service/server_keys/get.rs

@@ -1,6 +1,6 @@
 use std::borrow::Borrow;
 
-use conduit::{implement, Err, Result};
+use conduwuit::{implement, Err, Result};
 use ruma::{api::federation::discovery::VerifyKey, CanonicalJsonObject, RoomVersionId, ServerName, ServerSigningKeyId};
 
 use super::{extract_key, PubKeyMap, PubKeys};

src/service/server_keys/keypair.rs

@@ -1,6 +1,6 @@
 use std::sync::Arc;
 
-use conduit::{debug, debug_info, err, error, utils, utils::string_from_bytes, Result};
+use conduwuit::{debug, debug_info, err, error, utils, utils::string_from_bytes, Result};
 use database::Database;
 use ruma::{api::federation::discovery::VerifyKey, serde::Base64, signatures::Ed25519KeyPair};
 

src/service/server_keys/mod.rs

@@ -7,7 +7,7 @@ mod verify;
 
 use std::{collections::BTreeMap, sync::Arc, time::Duration};
 
-use conduit::{
+use conduwuit::{
 	implement,
 	utils::{timepoint_from_now, IterStream},
 	Result, Server,

src/service/server_keys/request.rs

@@ -1,6 +1,6 @@
 use std::{collections::BTreeMap, fmt::Debug};
 
-use conduit::{debug, implement, Err, Result};
+use conduwuit::{debug, implement, Err, Result};
 use ruma::{
 	api::federation::discovery::{
 		get_remote_server_keys,

src/service/server_keys/sign.rs

@@ -1,4 +1,4 @@
-use conduit::{implement, Result};
+use conduwuit::{implement, Result};
 use ruma::{CanonicalJsonObject, RoomVersionId};
 
 #[implement(super::Service)]

src/service/server_keys/verify.rs

@@ -1,4 +1,4 @@
-use conduit::{implement, pdu::gen_event_id_canonical_json, Err, Result};
+use conduwuit::{implement, pdu::gen_event_id_canonical_json, Err, Result};
 use ruma::{signatures::Verified, CanonicalJsonObject, CanonicalJsonValue, OwnedEventId, RoomVersionId};
 use serde_json::value::RawValue as RawJsonValue;
 

src/service/service.rs

@@ -7,7 +7,7 @@ use std::{
 };
 
 use async_trait::async_trait;
-use conduit::{err, error::inspect_log, utils::string::SplitInfallible, Err, Result, Server};
+use conduwuit::{err, error::inspect_log, utils::string::SplitInfallible, Err, Result, Server};
 use database::Database;
 
 /// Abstract interface for a Service

src/service/services.rs

@@ -5,7 +5,7 @@ use std::{
 	sync::{Arc, RwLock},
 };
 
-use conduit::{debug, debug_info, info, trace, Result, Server};
+use conduwuit::{debug, debug_info, info, trace, Result, Server};
 use database::Database;
 use tokio::sync::Mutex;
 

src/service/sync/mod.rs

@@ -5,7 +5,7 @@ use std::{
 	sync::{Arc, Mutex, Mutex as StdMutex},
 };
 
-use conduit::{Result, Server};
+use conduwuit::{Result, Server};
 use database::Map;
 use ruma::{
 	api::client::sync::sync_events::{

src/service/sync/watch.rs

@@ -1,4 +1,4 @@
-use conduit::{implement, trace, Result};
+use conduwuit::{implement, trace, Result};
 use futures::{pin_mut, stream::FuturesUnordered, FutureExt, StreamExt};
 use ruma::{DeviceId, UserId};
 

src/service/transaction_ids/mod.rs

@@ -1,6 +1,6 @@
 use std::sync::Arc;
 
-use conduit::{implement, Result};
+use conduwuit::{implement, Result};
 use database::{Handle, Map};
 use ruma::{DeviceId, TransactionId, UserId};
 

src/service/uiaa/mod.rs

@@ -3,7 +3,7 @@ use std::{
 	sync::{Arc, RwLock},
 };
 
-use conduit::{
+use conduwuit::{
 	err, error, implement, utils,
 	utils::{hash, string::EMPTY},
 	Error, Result,

src/service/updates/mod.rs

@@ -1,7 +1,7 @@
 use std::{sync::Arc, time::Duration};
 
 use async_trait::async_trait;
-use conduit::{debug, info, warn, Result, Server};
+use conduwuit::{debug, info, warn, Result, Server};
 use database::{Deserialized, Map};
 use ruma::events::room::message::RoomMessageEventContent;
 use serde::Deserialize;

src/service/users/mod.rs

@@ -1,6 +1,6 @@
 use std::{collections::BTreeMap, mem, mem::size_of, sync::Arc};
 
-use conduit::{
+use conduwuit::{
 	debug_warn, err, utils,
 	utils::{stream::TryIgnore, string::Unquoted, ReadyExt},
 	Err, Error, Result, Server,