integration @r10s' additions

Co-authored-by: bjoern <r10s@b44t.com>

.github/workflows/ci.yml

@@ -144,7 +144,7 @@ jobs:
       env:
         DCC_NEW_TMP_EMAIL: ${{ secrets.DCC_NEW_TMP_EMAIL }}
       working-directory: deltachat-rpc-client
-      run: tox -e py3,lint
+      run: tox -e py3
 
     - name: install pypy
       if: ${{ matrix.python }}

CHANGELOG.md

@@ -2,24 +2,13 @@
 
 ## Unreleased
 
-### Changes
-- Pipeline SMTP commands #3924
-- Cache DNS results #3970
-
 ### Fixes
 - Securejoin: Fix adding and handling Autocrypt-Gossip headers #3914
-- fix verifier-by addr was empty string intead of None #3961
-- Emit DC_EVENT_MSGS_CHANGED for DC_CHAT_ID_ARCHIVED_LINK when the number of archived chats with
-  unread messages increases #3959
-- Fix Peerstate comparison #3962
-- Log SOCKS5 configuration for IMAP like already done for SMTP #3964
-- Fix SOCKS5 usage for IMAP #3965
-- Exit from recently seen loop on interrupt channel errors to avoid busy looping #3966
 
 ### API-Changes
 - jsonrpc: add verified-by information to `Contact`-Object
 - Remove `attach_selfavatar` config #3951
-
+- `DC_EVENT_WEBXDC_UPDATE_STATE_CHANGED` is emitted when webxdc update state changes #3320
 
 ## 1.106.0
 
@@ -57,13 +46,13 @@
 ### Fixes
 - Do not add an error if the message is encrypted but not signed #3860
 - Do not strip leading spaces from message lines #3867
-- Don't always rebuild group member lists #3872
 - Fix uncaught exception in JSON-RPC tests #3884
 - Fix STARTTLS connection and add a test for it #3907
 - Trigger reconnection when failing to fetch existing messages #3911
 - Do not retry fetching existing messages after failure, prevents infinite reconnection loop #3913
 - Ensure format=flowed formatting is always reversible on the receiver side #3880
 
+
 ## 1.104.0
 
 ### Changes

Cargo.lock

@@ -165,9 +165,9 @@ dependencies = [
 
 [[package]]
 name = "async-smtp"
-version = "0.6.0"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2ade89127f9e0d44f9e83cf574d499060005cd45b7dc76be89c0167487fe8edd"
+checksum = "6da21e1dd19fbad3e095ad519fb1558ab77fd82e5c4778dca8f9be0464589e1e"
 dependencies = [
  "async-native-tls",
  "async-trait",

Cargo.toml

@@ -25,7 +25,7 @@ ansi_term = { version = "0.12.1", optional = true }
 anyhow = "1"
 async-imap = { git = "https://github.com/async-email/async-imap", branch = "master", default-features = false, features = ["runtime-tokio"] }
 async-native-tls = { version = "0.4", default-features = false, features = ["runtime-tokio"] }
-async-smtp = { version = "0.6", default-features = false, features = ["smtp-transport", "socks5", "runtime-tokio"] }
+async-smtp = { version = "0.5", default-features = false, features = ["smtp-transport", "socks5", "runtime-tokio"] }
 trust-dns-resolver = "0.22"
 tokio = { version = "1", features = ["fs", "rt-multi-thread", "macros"] }
 tokio-tar = { version = "0.3" } # TODO: integrate tokio into async-tar

benches/create_account.rs

@@ -1,7 +1,6 @@
-use std::path::PathBuf;
-
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
 use deltachat::accounts::Accounts;
+use std::path::PathBuf;
 use tempfile::tempdir;
 
 async fn create_accounts(n: u32) {

benches/get_chat_msgs.rs

@@ -1,6 +1,7 @@
 use std::path::Path;
 
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
+
 use deltachat::chat::{self, ChatId};
 use deltachat::chatlist::Chatlist;
 use deltachat::context::Context;

benches/get_chatlist.rs

@@ -1,6 +1,7 @@
 use std::path::Path;
 
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
+
 use deltachat::chatlist::Chatlist;
 use deltachat::context::Context;
 use deltachat::stock_str::StockStrings;

benches/search_msgs.rs

@@ -1,9 +1,8 @@
-use std::path::Path;
-
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
 use deltachat::context::Context;
 use deltachat::stock_str::StockStrings;
 use deltachat::Events;
+use std::path::Path;
 
 async fn search_benchmark(dbfile: impl AsRef<Path>) {
     let id = 100;

deltachat-ffi/deltachat.h

@@ -1082,6 +1082,17 @@ int dc_send_webxdc_status_update (dc_context_t* context, uint32_t msg_id, const
  */
 char* dc_get_webxdc_status_updates (dc_context_t* context, uint32_t msg_id, uint32_t serial);
 
+
+/**
+ * Checks if a webxdc has pending updates to be sent out.
+ 
+ * @param context The context object.
+ * @param msg_id The ID of the message with the webxdc instance.
+ * @return 1 = webxdc is updating , 0 = webxdc is not updating
+ */
+int   dc_is_webxdc_updating        (dc_context_t* context, uint32_t msg_id);
+
+
 /**
  * Save a draft for a chat in the database.
  *
@@ -5872,10 +5883,17 @@ void dc_event_unref(dc_event_t* event);
  *
  * @param data1 (int) msg_id
  */
-
 #define DC_EVENT_WEBXDC_INSTANCE_DELETED          2121
 
 
+/**
+ * Webxdc changed it's update sending state
+ *
+ * @param data1 (int) msg_id
+ * @param data1 (int) is_sending
+ */
+#define DC_EVENT_WEBXDC_UPDATE_STATE_CHANGED      2122
+
 /**
  * @}
  */

deltachat-ffi/src/lib.rs

@@ -23,6 +23,13 @@ use std::sync::Arc;
 use std::time::{Duration, SystemTime};
 
 use anyhow::Context as _;
+use deltachat::qr_code_generator::get_securejoin_qr_svg;
+use num_traits::{FromPrimitive, ToPrimitive};
+use once_cell::sync::Lazy;
+use rand::Rng;
+use tokio::runtime::Runtime;
+use tokio::sync::RwLock;
+
 use deltachat::chat::{ChatId, ChatVisibility, MuteDuration, ProtectionStatus};
 use deltachat::constants::DC_MSG_ID_LAST_SPECIAL;
 use deltachat::contact::{Contact, ContactId, Origin};
@@ -30,27 +37,20 @@ use deltachat::context::Context;
 use deltachat::ephemeral::Timer as EphemeralTimer;
 use deltachat::key::DcKey;
 use deltachat::message::MsgId;
-use deltachat::qr_code_generator::get_securejoin_qr_svg;
 use deltachat::reaction::{get_msg_reactions, send_reaction, Reactions};
 use deltachat::stock_str::StockMessage;
 use deltachat::stock_str::StockStrings;
 use deltachat::webxdc::StatusUpdateSerial;
 use deltachat::*;
 use deltachat::{accounts::Accounts, log::LogExt};
-use num_traits::{FromPrimitive, ToPrimitive};
-use once_cell::sync::Lazy;
-use rand::Rng;
-use tokio::runtime::Runtime;
-use tokio::sync::RwLock;
 use tokio::task::JoinHandle;
 
 mod dc_array;
 mod lot;
 
 mod string;
-use deltachat::chatlist::Chatlist;
-
 use self::string::*;
+use deltachat::chatlist::Chatlist;
 
 // as C lacks a good and portable error handling,
 // in general, the C Interface is forgiving wrt to bad parameters.
@@ -521,6 +521,7 @@ pub unsafe extern "C" fn dc_event_get_id(event: *mut dc_event_t) -> libc::c_int
         EventType::SelfavatarChanged => 2110,
         EventType::WebxdcStatusUpdate { .. } => 2120,
         EventType::WebxdcInstanceDeleted { .. } => 2121,
+        EventType::WebxdcUpdateStateChanged { .. } => 2122,
     }
 }
 
@@ -570,6 +571,7 @@ pub unsafe extern "C" fn dc_event_get_data1_int(event: *mut dc_event_t) -> libc:
         }
         EventType::WebxdcStatusUpdate { msg_id, .. } => msg_id.to_u32() as libc::c_int,
         EventType::WebxdcInstanceDeleted { msg_id, .. } => msg_id.to_u32() as libc::c_int,
+        EventType::WebxdcUpdateStateChanged { msg_id, .. } => msg_id.to_u32() as libc::c_int,
     }
 }
 
@@ -618,6 +620,10 @@ pub unsafe extern "C" fn dc_event_get_data2_int(event: *mut dc_event_t) -> libc:
             status_update_serial,
             ..
         } => status_update_serial.to_u32() as libc::c_int,
+        EventType::WebxdcUpdateStateChanged {
+            has_pending_updates: is_send,
+            ..
+        } => *is_send as libc::c_int,
     }
 }
 
@@ -662,6 +668,7 @@ pub unsafe extern "C" fn dc_event_get_data2_str(event: *mut dc_event_t) -> *mut
         | EventType::SelfavatarChanged
         | EventType::WebxdcStatusUpdate { .. }
         | EventType::WebxdcInstanceDeleted { .. }
+        | EventType::WebxdcUpdateStateChanged { .. }
         | EventType::ChatEphemeralTimerModified { .. } => ptr::null_mut(),
         EventType::ConfigureProgress { comment, .. } => {
             if let Some(comment) = comment {
@@ -3285,6 +3292,24 @@ pub unsafe extern "C" fn dc_msg_get_webxdc_info(msg: *mut dc_msg_t) -> *mut libc
     })
 }
 
+#[no_mangle]
+pub unsafe extern "C" fn dc_is_webxdc_updating(
+    context: *mut dc_context_t,
+    msg_id: u32,
+) -> libc::c_int {
+    if context.is_null() {
+        eprintln!("ignoring careless call to dc_is_webxdc_updating()");
+        return 0;
+    }
+    let ctx = &*context;
+    block_on(async move {
+        webxdc::get_busy_webxdc_instances(ctx)
+            .await
+            .unwrap_or_default()
+            .contains(&MsgId::new(msg_id)) as libc::c_int
+    })
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn dc_msg_get_filemime(msg: *mut dc_msg_t) -> *mut libc::c_char {
     if msg.is_null() {
@@ -4577,12 +4602,11 @@ pub unsafe extern "C" fn dc_accounts_get_event_emitter(
 
 #[cfg(feature = "jsonrpc")]
 mod jsonrpc {
+    use super::*;
     use deltachat_jsonrpc::api::CommandApi;
     use deltachat_jsonrpc::events::event_to_json_rpc_notification;
     use deltachat_jsonrpc::yerpc::{OutReceiver, RpcClient, RpcSession};
 
-    use super::*;
-
     pub struct dc_jsonrpc_instance_t {
         receiver: OutReceiver,
         handle: RpcSession<CommandApi>,

deltachat-ffi/src/lot.rs

@@ -1,12 +1,10 @@
 //! # Legacy generic return values for C API.
 
-use std::borrow::Cow;
-
-use anyhow::Error;
-
 use crate::message::MessageState;
 use crate::qr::Qr;
 use crate::summary::{Summary, SummaryPrefix};
+use anyhow::Error;
+use std::borrow::Cow;
 
 /// An object containing a set of values.
 /// The meaning of the values is defined by the function returning the object.

deltachat-ffi/src/string.rs

@@ -287,9 +287,8 @@ fn as_path_unicode<'a>(s: *const libc::c_char) -> &'a std::path::Path {
 
 #[cfg(test)]
 mod tests {
-    use libc::{free, strcmp};
-
     use super::*;
+    use libc::{free, strcmp};
 
     #[test]
     fn test_os_str_to_c_string_cwd() {

deltachat-jsonrpc/src/api/events.rs

@@ -281,6 +281,7 @@ pub enum JSONRPCEventType {
     WebxdcInstanceDeleted {
         msg_id: u32,
     },
+    WebxdcUpdateStateChanged,
 }
 
 impl From<EventType> for JSONRPCEventType {
@@ -381,6 +382,7 @@ impl From<EventType> for JSONRPCEventType {
             EventType::WebxdcInstanceDeleted { msg_id } => WebxdcInstanceDeleted {
                 msg_id: msg_id.to_u32(),
             },
+            EventType::WebxdcUpdateStateChanged { .. } => WebxdcUpdateStateChanged,
         }
     }
 }

deltachat-jsonrpc/src/api/mod.rs

@@ -1,9 +1,4 @@
-use std::collections::BTreeMap;
-use std::sync::Arc;
-use std::{collections::HashMap, str::FromStr};
-
 use anyhow::{anyhow, bail, ensure, Context, Result};
-pub use deltachat::accounts::Accounts;
 use deltachat::{
     chat::{
         self, add_contact_to_chat, forward_msgs, get_chat_media, get_chat_msgs, marknoticed_chat,
@@ -28,14 +23,21 @@ use deltachat::{
     webxdc::StatusUpdateSerial,
 };
 use sanitize_filename::is_sanitized;
+use std::collections::BTreeMap;
+use std::sync::Arc;
+use std::{collections::HashMap, str::FromStr};
 use tokio::{fs, sync::RwLock};
 use walkdir::WalkDir;
 use yerpc::rpc;
 
+pub use deltachat::accounts::Accounts;
+
 pub mod events;
 pub mod types;
 
-use num_traits::FromPrimitive;
+use crate::api::types::chat_list::{get_chat_list_item_by_id, ChatListItemFetchResult};
+use crate::api::types::qr::QrObject;
+
 use types::account::Account;
 use types::chat::FullChat;
 use types::chat_list::ChatListEntry;
@@ -51,8 +53,8 @@ use self::types::{
         JSONRPCMessageListItem, MessageNotificationInfo, MessageSearchResult, MessageViewtype,
     },
 };
-use crate::api::types::chat_list::{get_chat_list_item_by_id, ChatListItemFetchResult};
-use crate::api::types::qr::QrObject;
+
+use num_traits::FromPrimitive;
 
 #[derive(Clone, Debug)]
 pub struct CommandApi {

deltachat-jsonrpc/src/lib.rs

@@ -4,13 +4,12 @@ pub use yerpc;
 
 #[cfg(test)]
 mod tests {
+    use super::api::{Accounts, CommandApi};
     use async_channel::unbounded;
     use futures::StreamExt;
     use tempfile::TempDir;
     use yerpc::{RpcClient, RpcSession};
 
-    use super::api::{Accounts, CommandApi};
-
     #[tokio::test(flavor = "multi_thread")]
     async fn basic_json_rpc_functionality() -> anyhow::Result<()> {
         let tmp_dir = TempDir::new().unwrap().path().into();

deltachat-jsonrpc/src/webserver.rs

@@ -1,7 +1,6 @@
+use axum::{extract::ws::WebSocketUpgrade, response::Response, routing::get, Extension, Router};
 use std::net::SocketAddr;
 use std::path::PathBuf;
-
-use axum::{extract::ws::WebSocketUpgrade, response::Response, routing::get, Extension, Router};
 use yerpc::axum::handle_ws_rpc;
 use yerpc::{RpcClient, RpcSession};
 

deltachat-jsonrpc/typescript/generated/events.ts

@@ -0,0 +1,3 @@
+// AUTO-GENERATED by typescript-type-def
+
+export type EventTypeName=("Info"|"SmtpConnected"|"ImapConnected"|"SmtpMessageSent"|"ImapMessageDeleted"|"ImapMessageMoved"|"NewBlobFile"|"DeletedBlobFile"|"Warning"|"Error"|"ErrorSelfNotInGroup"|"MsgsChanged"|"IncomingMsg"|"MsgsNoticed"|"MsgDelivered"|"MsgFailed"|"MsgRead"|"ChatModified"|"ChatEphemeralTimerModified"|"ContactsChanged"|"LocationChanged"|"ConfigureProgress"|"ImexProgress"|"ImexFileWritten"|"SecurejoinInviterProgress"|"SecurejoinJoinerProgress"|"ConnectivityChanged"|"SelfavatarChanged"|"WebxdcStatusUpdate"|"WebxdcInstanceDeleted"|"WebxdcUpdateStateChanged");

deltachat-rpc-client/examples/echobot_advanced.py

@@ -27,7 +27,9 @@ async def log_error(event):
 
 @hooks.on(events.MemberListChanged)
 async def on_memberlist_changed(event):
-    logging.info("member %s was %s", event.member, "added" if event.member_added else "removed")
+    logging.info(
+        "member %s was %s", event.member, "added" if event.member_added else "removed"
+    )
 
 
 @hooks.on(events.GroupImageChanged)

deltachat-rpc-client/pyproject.toml

@@ -27,13 +27,3 @@ deltachat_rpc_client = [
 
 [project.entry-points.pytest11]
 "deltachat_rpc_client.pytestplugin" = "deltachat_rpc_client.pytestplugin"
-
-[tool.black]
-line-length = 120
-
-[tool.ruff]
-select = ["E", "F", "W", "N", "YTT", "B", "C4", "ISC", "ICN", "PT", "RET", "SIM", "TID", "ARG", "DTZ", "ERA", "PLC", "PLE", "PLW", "PIE", "COM"]
-line-length = 120
-
-[tool.isort]
-profile = "black"

deltachat-rpc-client/src/deltachat_rpc_client/__init__.py

@@ -8,18 +8,3 @@ from .contact import Contact
 from .deltachat import DeltaChat
 from .message import Message
 from .rpc import Rpc
-
-__all__ = [
-    "Account",
-    "AttrDict",
-    "Bot",
-    "Chat",
-    "Client",
-    "Contact",
-    "DeltaChat",
-    "EventType",
-    "Message",
-    "Rpc",
-    "run_bot_cli",
-    "run_client_cli",
-]

deltachat-rpc-client/src/deltachat_rpc_client/_utils.py

@@ -30,7 +30,12 @@ class AttrDict(dict):
     """Dictionary that allows accessing values usin the "dot notation" as attributes."""
 
     def __init__(self, *args, **kwargs) -> None:
-        super().__init__({_camel_to_snake(key): _to_attrdict(value) for key, value in dict(*args, **kwargs).items()})
+        super().__init__(
+            {
+                _camel_to_snake(key): _to_attrdict(value)
+                for key, value in dict(*args, **kwargs).items()
+            }
+        )
 
     def __getattr__(self, attr):
         if attr in self:
@@ -46,7 +51,7 @@ class AttrDict(dict):
 async def run_client_cli(
     hooks: Optional[Iterable[Tuple[Callable, Union[type, "EventFilter"]]]] = None,
     argv: Optional[list] = None,
-    **kwargs,
+    **kwargs
 ) -> None:
     """Run a simple command line app, using the given hooks.
 
@@ -60,7 +65,7 @@ async def run_client_cli(
 async def run_bot_cli(
     hooks: Optional[Iterable[Tuple[Callable, Union[type, "EventFilter"]]]] = None,
     argv: Optional[list] = None,
-    **kwargs,
+    **kwargs
 ) -> None:
     """Run a simple bot command line using the given hooks.
 
@@ -75,7 +80,7 @@ async def _run_cli(
     client_type: Type["Client"],
     hooks: Optional[Iterable[Tuple[Callable, Union[type, "EventFilter"]]]] = None,
     argv: Optional[list] = None,
-    **kwargs,
+    **kwargs
 ) -> None:
     from .deltachat import DeltaChat
     from .rpc import Rpc
@@ -102,9 +107,12 @@ async def _run_cli(
         client = client_type(account, hooks)
         client.logger.debug("Running deltachat core %s", core_version)
         if not await client.is_configured():
-            assert args.email, "Account is not configured and email must be provided"
-            assert args.password, "Account is not configured and password must be provided"
-            asyncio.create_task(client.configure(email=args.email, password=args.password))
+            assert (
+                args.email and args.password
+            ), "Account is not configured and email and password must be provided"
+            asyncio.create_task(
+                client.configure(email=args.email, password=args.password)
+            )
         await client.run_forever()
 
 

deltachat-rpc-client/src/deltachat_rpc_client/account.py

@@ -89,7 +89,9 @@ class Account:
         """Configure an account."""
         await self._rpc.configure(self.id)
 
-    async def create_contact(self, obj: Union[int, str, Contact], name: Optional[str] = None) -> Contact:
+    async def create_contact(
+        self, obj: Union[int, str, Contact], name: Optional[str] = None
+    ) -> Contact:
         """Create a new Contact or return an existing one.
 
         Calling this method will always result in the same
@@ -118,7 +120,10 @@ class Account:
     async def get_blocked_contacts(self) -> List[AttrDict]:
         """Return a list with snapshots of all blocked contacts."""
         contacts = await self._rpc.get_blocked_contacts(self.id)
-        return [AttrDict(contact=Contact(self, contact["id"]), **contact) for contact in contacts]
+        return [
+            AttrDict(contact=Contact(self, contact["id"]), **contact)
+            for contact in contacts
+        ]
 
     async def get_contacts(
         self,
@@ -143,7 +148,10 @@ class Account:
 
         if snapshot:
             contacts = await self._rpc.get_contacts(self.id, flags, query)
-            return [AttrDict(contact=Contact(self, contact["id"]), **contact) for contact in contacts]
+            return [
+                AttrDict(contact=Contact(self, contact["id"]), **contact)
+                for contact in contacts
+            ]
         contacts = await self._rpc.get_contact_ids(self.id, flags, query)
         return [Contact(self, contact_id) for contact_id in contacts]
 
@@ -184,7 +192,9 @@ class Account:
         if alldone_hint:
             flags |= ChatlistFlag.ADD_ALLDONE_HINT
 
-        entries = await self._rpc.get_chatlist_entries(self.id, flags, query, contact and contact.id)
+        entries = await self._rpc.get_chatlist_entries(
+            self.id, flags, query, contact and contact.id
+        )
         if not snapshot:
             return [Chat(self, entry[0]) for entry in entries]
 

deltachat-rpc-client/src/deltachat_rpc_client/chat.py

@@ -63,7 +63,7 @@ class Chat:
         """
         if duration is not None:
             assert duration > 0, "Invalid duration"
-            dur: Union[str, dict] = {"Until": duration}
+            dur: Union[str, dict] = dict(Until=duration)
         else:
             dur = "Forever"
         await self._rpc.set_chat_mute_duration(self.account.id, self.id, dur)
@@ -74,19 +74,27 @@ class Chat:
 
     async def pin(self) -> None:
         """Pin this chat."""
-        await self._rpc.set_chat_visibility(self.account.id, self.id, ChatVisibility.PINNED)
+        await self._rpc.set_chat_visibility(
+            self.account.id, self.id, ChatVisibility.PINNED
+        )
 
     async def unpin(self) -> None:
         """Unpin this chat."""
-        await self._rpc.set_chat_visibility(self.account.id, self.id, ChatVisibility.NORMAL)
+        await self._rpc.set_chat_visibility(
+            self.account.id, self.id, ChatVisibility.NORMAL
+        )
 
     async def archive(self) -> None:
         """Archive this chat."""
-        await self._rpc.set_chat_visibility(self.account.id, self.id, ChatVisibility.ARCHIVED)
+        await self._rpc.set_chat_visibility(
+            self.account.id, self.id, ChatVisibility.ARCHIVED
+        )
 
     async def unarchive(self) -> None:
         """Unarchive this chat."""
-        await self._rpc.set_chat_visibility(self.account.id, self.id, ChatVisibility.NORMAL)
+        await self._rpc.set_chat_visibility(
+            self.account.id, self.id, ChatVisibility.NORMAL
+        )
 
     async def set_name(self, name: str) -> None:
         """Set name of this chat."""
@@ -125,7 +133,9 @@ class Chat:
         if isinstance(quoted_msg, Message):
             quoted_msg = quoted_msg.id
 
-        msg_id, _ = await self._rpc.misc_send_msg(self.account.id, self.id, text, file, location, quoted_msg)
+        msg_id, _ = await self._rpc.misc_send_msg(
+            self.account.id, self.id, text, file, location, quoted_msg
+        )
         return Message(self.account, msg_id)
 
     async def send_text(self, text: str) -> Message:
@@ -231,17 +241,23 @@ class Chat:
         timestamp_to: Optional[datetime] = None,
     ) -> List[AttrDict]:
         """Get list of location snapshots for the given contact in the given timespan."""
-        time_from = calendar.timegm(timestamp_from.utctimetuple()) if timestamp_from else 0
+        time_from = (
+            calendar.timegm(timestamp_from.utctimetuple()) if timestamp_from else 0
+        )
         time_to = calendar.timegm(timestamp_to.utctimetuple()) if timestamp_to else 0
         contact_id = contact.id if contact else 0
 
-        result = await self._rpc.get_locations(self.account.id, self.id, contact_id, time_from, time_to)
+        result = await self._rpc.get_locations(
+            self.account.id, self.id, contact_id, time_from, time_to
+        )
         locations = []
         contacts: Dict[int, Contact] = {}
         for loc in result:
             loc = AttrDict(loc)
             loc["chat"] = self
-            loc["contact"] = contacts.setdefault(loc.contact_id, Contact(self.account, loc.contact_id))
+            loc["contact"] = contacts.setdefault(
+                loc.contact_id, Contact(self.account, loc.contact_id)
+            )
             loc["message"] = Message(self.account, loc.msg_id)
             locations.append(loc)
         return locations

deltachat-rpc-client/src/deltachat_rpc_client/client.py

@@ -47,11 +47,15 @@ class Client:
         self._should_process_messages = 0
         self.add_hooks(hooks or [])
 
-    def add_hooks(self, hooks: Iterable[Tuple[Callable, Union[type, EventFilter]]]) -> None:
+    def add_hooks(
+        self, hooks: Iterable[Tuple[Callable, Union[type, EventFilter]]]
+    ) -> None:
         for hook, event in hooks:
             self.add_hook(hook, event)
 
-    def add_hook(self, hook: Callable, event: Union[type, EventFilter] = RawEvent) -> None:
+    def add_hook(
+        self, hook: Callable, event: Union[type, EventFilter] = RawEvent
+    ) -> None:
         """Register hook for the given event filter."""
         if isinstance(event, type):
             event = event()
@@ -60,7 +64,7 @@ class Client:
             isinstance(
                 event,
                 (NewMessage, MemberListChanged, GroupImageChanged, GroupNameChanged),
-            ),
+            )
         )
         self._hooks.setdefault(type(event), set()).add((hook, event))
 
@@ -72,7 +76,7 @@ class Client:
             isinstance(
                 event,
                 (NewMessage, MemberListChanged, GroupImageChanged, GroupNameChanged),
-            ),
+            )
         )
         self._hooks.get(type(event), set()).remove((hook, event))
 
@@ -91,7 +95,9 @@ class Client:
         """Process events forever."""
         await self.run_until(lambda _: False)
 
-    async def run_until(self, func: Callable[[AttrDict], Union[bool, Coroutine]]) -> AttrDict:
+    async def run_until(
+        self, func: Callable[[AttrDict], Union[bool, Coroutine]]
+    ) -> AttrDict:
         """Process events until the given callable evaluates to True.
 
         The callable should accept an AttrDict object representing the
@@ -116,7 +122,9 @@ class Client:
             if stop:
                 return event
 
-    async def _on_event(self, event: AttrDict, filter_type: Type[EventFilter] = RawEvent) -> None:
+    async def _on_event(
+        self, event: AttrDict, filter_type: Type[EventFilter] = RawEvent
+    ) -> None:
         for hook, evfilter in self._hooks.get(filter_type, []):
             if await evfilter.filter(event):
                 try:
@@ -125,7 +133,11 @@ class Client:
                     self.logger.exception(ex)
 
     async def _parse_command(self, event: AttrDict) -> None:
-        cmds = [hook[1].command for hook in self._hooks.get(NewMessage, []) if hook[1].command]
+        cmds = [
+            hook[1].command
+            for hook in self._hooks.get(NewMessage, [])
+            if hook[1].command
+        ]
         parts = event.message_snapshot.text.split(maxsplit=1)
         payload = parts[1] if len(parts) > 1 else ""
         cmd = parts.pop(0)
@@ -190,7 +202,11 @@ class Client:
             for message in await self.account.get_fresh_messages_in_arrival_order():
                 snapshot = await message.get_snapshot()
                 await self._on_new_msg(snapshot)
-                if snapshot.is_info and snapshot.system_message_type != SystemMessageType.WEBXDC_INFO_MESSAGE:
+                if (
+                    snapshot.is_info
+                    and snapshot.system_message_type
+                    != SystemMessageType.WEBXDC_INFO_MESSAGE
+                ):
                     await self._handle_info_msg(snapshot)
                 await snapshot.message.mark_seen()
 

deltachat-rpc-client/src/deltachat_rpc_client/events.py

@@ -10,7 +10,7 @@ from .const import EventType
 
 def _tuple_of(obj, type_: type) -> tuple:
     if not obj:
-        return ()
+        return tuple()
     if isinstance(obj, type_):
         obj = (obj,)
 
@@ -39,7 +39,7 @@ class EventFilter(ABC):
         """Return True if two event filters are equal."""
 
     def __ne__(self, other):
-        return not self == other
+        return not self.__eq__(other)
 
     async def _call_func(self, event) -> bool:
         if not self.func:
@@ -65,7 +65,9 @@ class RawEvent(EventFilter):
                  should be dispatched or not.
     """
 
-    def __init__(self, types: Union[None, EventType, Iterable[EventType]] = None, **kwargs):
+    def __init__(
+        self, types: Union[None, EventType, Iterable[EventType]] = None, **kwargs
+    ):
         super().__init__(**kwargs)
         try:
             self.types = _tuple_of(types, EventType)

deltachat-rpc-client/src/deltachat_rpc_client/message.py

@@ -49,14 +49,22 @@ class Message:
         """Mark the message as seen."""
         await self._rpc.markseen_msgs(self.account.id, [self.id])
 
-    async def send_webxdc_status_update(self, update: Union[dict, str], description: str) -> None:
+    async def send_webxdc_status_update(
+        self, update: Union[dict, str], description: str
+    ) -> None:
         """Send a webxdc status update. This message must be a webxdc."""
         if not isinstance(update, str):
             update = json.dumps(update)
-        await self._rpc.send_webxdc_status_update(self.account.id, self.id, update, description)
+        await self._rpc.send_webxdc_status_update(
+            self.account.id, self.id, update, description
+        )
 
     async def get_webxdc_status_updates(self, last_known_serial: int = 0) -> list:
-        return json.loads(await self._rpc.get_webxdc_status_updates(self.account.id, self.id, last_known_serial))
+        return json.loads(
+            await self._rpc.get_webxdc_status_updates(
+                self.account.id, self.id, last_known_serial
+            )
+        )
 
     async def get_webxdc_info(self) -> dict:
         return await self._rpc.get_webxdc_info(self.account.id, self.id)

deltachat-rpc-client/src/deltachat_rpc_client/pytestplugin.py

@@ -67,7 +67,9 @@ class ACFactory:
     ) -> Message:
         if not from_account:
             from_account = (await self.get_online_accounts(1))[0]
-        to_contact = await from_account.create_contact(await to_account.get_config("addr"))
+        to_contact = await from_account.create_contact(
+            await to_account.get_config("addr")
+        )
         if group:
             to_chat = await from_account.create_group(group)
             await to_chat.add_contact(to_contact)

deltachat-rpc-client/src/deltachat_rpc_client/rpc.py

@@ -30,7 +30,7 @@ class Rpc:
             "deltachat-rpc-server",
             stdin=asyncio.subprocess.PIPE,
             stdout=asyncio.subprocess.PIPE,
-            **self._kwargs,
+            **self._kwargs
         )
         self.id = 0
         self.event_queues = {}
@@ -46,7 +46,7 @@ class Rpc:
         await self.start()
         return self
 
-    async def __aexit__(self, _exc_type, _exc, _tb):
+    async def __aexit__(self, exc_type, exc, tb):
         await self.close()
 
     async def reader_loop(self) -> None:
@@ -97,6 +97,5 @@ class Rpc:
                 raise JsonRpcError(response["error"])
             if "result" in response:
                 return response["result"]
-            return None
 
         return method

deltachat-rpc-client/tests/test_something.py

@@ -6,14 +6,14 @@ from deltachat_rpc_client import EventType, events
 from deltachat_rpc_client.rpc import JsonRpcError
 
 
-@pytest.mark.asyncio()
+@pytest.mark.asyncio
 async def test_system_info(rpc) -> None:
     system_info = await rpc.get_system_info()
     assert "arch" in system_info
     assert "deltachat_core_version" in system_info
 
 
-@pytest.mark.asyncio()
+@pytest.mark.asyncio
 async def test_email_address_validity(rpc) -> None:
     valid_addresses = [
         "email@example.com",
@@ -27,7 +27,7 @@ async def test_email_address_validity(rpc) -> None:
         assert not await rpc.check_email_validity(addr)
 
 
-@pytest.mark.asyncio()
+@pytest.mark.asyncio
 async def test_acfactory(acfactory) -> None:
     account = await acfactory.new_configured_account()
     while True:
@@ -41,7 +41,7 @@ async def test_acfactory(acfactory) -> None:
     print("Successful configuration")
 
 
-@pytest.mark.asyncio()
+@pytest.mark.asyncio
 async def test_configure_starttls(acfactory) -> None:
     account = await acfactory.new_preconfigured_account()
 
@@ -51,7 +51,7 @@ async def test_configure_starttls(acfactory) -> None:
     assert await account.is_configured()
 
 
-@pytest.mark.asyncio()
+@pytest.mark.asyncio
 async def test_account(acfactory) -> None:
     alice, bob = await acfactory.get_online_accounts(2)
 
@@ -111,7 +111,7 @@ async def test_account(acfactory) -> None:
     await alice.stop_io()
 
 
-@pytest.mark.asyncio()
+@pytest.mark.asyncio
 async def test_chat(acfactory) -> None:
     alice, bob = await acfactory.get_online_accounts(2)
 
@@ -177,7 +177,7 @@ async def test_chat(acfactory) -> None:
     await group.get_locations()
 
 
-@pytest.mark.asyncio()
+@pytest.mark.asyncio
 async def test_contact(acfactory) -> None:
     alice, bob = await acfactory.get_online_accounts(2)
 
@@ -195,7 +195,7 @@ async def test_contact(acfactory) -> None:
     await alice_contact_bob.create_chat()
 
 
-@pytest.mark.asyncio()
+@pytest.mark.asyncio
 async def test_message(acfactory) -> None:
     alice, bob = await acfactory.get_online_accounts(2)
 
@@ -226,7 +226,7 @@ async def test_message(acfactory) -> None:
     await message.send_reaction("😎")
 
 
-@pytest.mark.asyncio()
+@pytest.mark.asyncio
 async def test_bot(acfactory) -> None:
     mock = MagicMock()
     user = (await acfactory.get_online_accounts(1))[0]
@@ -237,20 +237,25 @@ async def test_bot(acfactory) -> None:
 
     hook = lambda e: mock.hook(e.msg_id), events.RawEvent(EventType.INCOMING_MSG)
     bot.add_hook(*hook)
-    event = await acfactory.process_message(from_account=user, to_client=bot, text="Hello!")
+    event = await acfactory.process_message(
+        from_account=user, to_client=bot, text="Hello!"
+    )
     mock.hook.assert_called_once_with(event.msg_id)
     bot.remove_hook(*hook)
 
-    def track(e):
-        mock.hook(e.message_snapshot.id)
+    track = lambda e: mock.hook(e.message_snapshot.id)
 
     mock.hook.reset_mock()
     hook = track, events.NewMessage(r"hello")
     bot.add_hook(*hook)
     bot.add_hook(track, events.NewMessage(command="/help"))
-    event = await acfactory.process_message(from_account=user, to_client=bot, text="hello")
+    event = await acfactory.process_message(
+        from_account=user, to_client=bot, text="hello"
+    )
     mock.hook.assert_called_with(event.msg_id)
-    event = await acfactory.process_message(from_account=user, to_client=bot, text="hello!")
+    event = await acfactory.process_message(
+        from_account=user, to_client=bot, text="hello!"
+    )
     mock.hook.assert_called_with(event.msg_id)
     await acfactory.process_message(from_account=user, to_client=bot, text="hey!")
     assert len(mock.hook.mock_calls) == 2
@@ -258,5 +263,7 @@ async def test_bot(acfactory) -> None:
 
     mock.hook.reset_mock()
     await acfactory.process_message(from_account=user, to_client=bot, text="hello")
-    event = await acfactory.process_message(from_account=user, to_client=bot, text="/help")
+    event = await acfactory.process_message(
+        from_account=user, to_client=bot, text="/help"
+    )
     mock.hook.assert_called_once_with(event.msg_id)

deltachat-rpc-client/tests/test_webxdc.py

@@ -3,14 +3,16 @@ import pytest
 from deltachat_rpc_client import EventType
 
 
-@pytest.mark.asyncio()
+@pytest.mark.asyncio
 async def test_webxdc(acfactory) -> None:
     alice, bob = await acfactory.get_online_accounts(2)
 
     bob_addr = await bob.get_config("addr")
     alice_contact_bob = await alice.create_contact(bob_addr, "Bob")
     alice_chat_bob = await alice_contact_bob.create_chat()
-    await alice_chat_bob.send_message(text="Let's play chess!", file="../test-data/webxdc/chess.xdc")
+    await alice_chat_bob.send_message(
+        text="Let's play chess!", file="../test-data/webxdc/chess.xdc"
+    )
 
     while True:
         event = await bob.wait_for_event()

deltachat-rpc-client/tox.ini

@@ -2,7 +2,6 @@
 isolated_build = true
 envlist =
     py3
-    lint
 
 [testenv]
 commands =
@@ -17,13 +16,3 @@ deps =
     pytest-asyncio
     aiohttp
     aiodns
-
-[testenv:lint]
-skipsdist = True
-skip_install = True
-deps =
-    ruff
-    black
-commands =
-    black --check src/ examples/ tests/
-    ruff src/ examples/ tests/

deltachat_derive/src/lib.rs

@@ -1,9 +1,8 @@
 #![recursion_limit = "128"]
 extern crate proc_macro;
 
-use quote::quote;
-
 use crate::proc_macro::TokenStream;
+use quote::quote;
 
 // For now, assume (not check) that these macroses are applied to enum without
 // data.  If this assumption is violated, compiler error will point to

examples/simple.rs

@@ -1,3 +1,5 @@
+use tempfile::tempdir;
+
 use deltachat::chat::{self, ChatId};
 use deltachat::chatlist::*;
 use deltachat::config;
@@ -6,7 +8,6 @@ use deltachat::context::*;
 use deltachat::message::Message;
 use deltachat::stock_str::StockStrings;
 use deltachat::{EventType, Events};
-use tempfile::tempdir;
 
 fn cb(event: EventType) {
     match event {

python/doc/conf.py

@@ -11,8 +11,7 @@
 # All configuration values have a default; values that are commented out
 # serve to show the default.
 
-import sys
-import os
+import sys, os
 
 # The version info for the project you're documenting, acts as replacement for
 # |version| and |release|, also used in various other places throughout the

python/examples/group_tracking.py

@@ -34,10 +34,8 @@ class GroupTrackingPlugin:
     def ac_member_added(self, chat, contact, actor, message):
         print(
             "ac_member_added {} to chat {} from {}".format(
-                contact.addr,
-                chat.id,
-                actor or message.get_sender_contact().addr,
-            ),
+                contact.addr, chat.id, actor or message.get_sender_contact().addr
+            )
         )
         for member in chat.get_contacts():
             print("chat member: {}".format(member.addr))
@@ -46,10 +44,8 @@ class GroupTrackingPlugin:
     def ac_member_removed(self, chat, contact, actor, message):
         print(
             "ac_member_removed {} from chat {} by {}".format(
-                contact.addr,
-                chat.id,
-                actor or message.get_sender_contact().addr,
-            ),
+                contact.addr, chat.id, actor or message.get_sender_contact().addr
+            )
         )
 
 

python/examples/test_examples.py

@@ -13,8 +13,8 @@ def datadir():
         datadir = path.join("test-data")
         if datadir.isdir():
             return datadir
-    pytest.skip("test-data directory not found")
-    return None
+    else:
+        pytest.skip("test-data directory not found")
 
 
 def test_echo_quit_plugin(acfactory, lp):
@@ -47,7 +47,7 @@ def test_group_tracking_plugin(acfactory, lp):
     botproc.fnmatch_lines(
         """
         *ac_configure_completed*
-    """,
+    """
     )
     ac1.add_account_plugin(FFIEventLogger(ac1))
     ac2.add_account_plugin(FFIEventLogger(ac2))
@@ -61,7 +61,7 @@ def test_group_tracking_plugin(acfactory, lp):
     botproc.fnmatch_lines(
         """
         *ac_chat_modified*bot test group*
-    """,
+    """
     )
 
     lp.sec("adding third member {}".format(ac2.get_config("addr")))
@@ -76,9 +76,8 @@ def test_group_tracking_plugin(acfactory, lp):
         """
         *ac_member_added {}*from*{}*
     """.format(
-            contact3.addr,
-            ac1.get_config("addr"),
-        ),
+            contact3.addr, ac1.get_config("addr")
+        )
     )
 
     lp.sec("contact successfully added, now removing")
@@ -87,7 +86,6 @@ def test_group_tracking_plugin(acfactory, lp):
         """
         *ac_member_removed {}*from*{}*
     """.format(
-            contact3.addr,
-            ac1.get_config("addr"),
-        ),
+            contact3.addr, ac1.get_config("addr")
+        )
     )

python/pyproject.toml

@@ -44,9 +44,5 @@ git_describe_command = "git describe --dirty --tags --long --match py-*.*"
 [tool.black]
 line-length = 120
 
-[tool.ruff]
-select = ["E", "F", "W", "YTT", "C4", "ISC", "ICN", "TID", "DTZ", "PLC", "PLE", "PLW", "PIE", "COM"]
-line-length = 120
-
 [tool.isort]
-profile = "black"
+profile = "black"

python/src/deltachat/__init__.py

@@ -36,8 +36,7 @@ register_global_plugin(events)
 
 def run_cmdline(argv=None, account_plugins=None):
     """Run a simple default command line app, registering the specified
-    account plugins.
-    """
+    account plugins."""
     import argparse
 
     if argv is None:

python/src/deltachat/_build.py

@@ -102,8 +102,8 @@ def find_header(flags):
                     printf("%s", _dc_header_file_location());
                     return 0;
                 }
-            """,
-                ),
+            """
+                )
             )
         cwd = os.getcwd()
         try:
@@ -198,7 +198,7 @@ def ffibuilder():
         typedef int... time_t;
         void free(void *ptr);
         extern int dc_event_has_string_data(int);
-    """,
+    """
     )
     function_defs = extract_functions(flags)
     defines = extract_defines(flags)

python/src/deltachat/account.py

@@ -1,4 +1,4 @@
-"""Account class implementation."""
+""" Account class implementation. """
 
 from __future__ import print_function
 
@@ -39,7 +39,7 @@ def get_core_info():
             ffi.gc(
                 lib.dc_context_new(as_dc_charpointer(""), as_dc_charpointer(path.name), ffi.NULL),
                 lib.dc_context_unref,
-            ),
+            )
         )
 
 
@@ -172,7 +172,10 @@ class Account(object):
         namebytes = name.encode("utf8")
         if isinstance(value, (int, bool)):
             value = str(int(value))
-        valuebytes = value.encode("utf8") if value is not None else ffi.NULL
+        if value is not None:
+            valuebytes = value.encode("utf8")
+        else:
+            valuebytes = ffi.NULL
         lib.dc_set_config(self._dc_context, namebytes, valuebytes)
 
     def get_config(self, name: str) -> str:
@@ -222,10 +225,9 @@ class Account(object):
         return bool(lib.dc_is_configured(self._dc_context))
 
     def is_open(self) -> bool:
-        """Determine if account is open.
+        """Determine if account is open
 
-        :returns True if account is open.
-        """
+        :returns True if account is open."""
         return bool(lib.dc_context_is_open(self._dc_context))
 
     def set_avatar(self, img_path: Optional[str]) -> None:
@@ -541,7 +543,7 @@ class Account(object):
         return from_dc_charpointer(res)
 
     def check_qr(self, qr):
-        """check qr code and return :class:`ScannedQRCode` instance representing the result."""
+        """check qr code and return :class:`ScannedQRCode` instance representing the result"""
         res = ffi.gc(lib.dc_check_qr(self._dc_context, as_dc_charpointer(qr)), lib.dc_lot_unref)
         lot = DCLot(res)
         if lot.state() == const.DC_QR_ERROR:
@@ -660,7 +662,7 @@ class Account(object):
         return lib.dc_all_work_done(self._dc_context)
 
     def start_io(self):
-        """start this account's IO scheduling (Rust-core async scheduler).
+        """start this account's IO scheduling (Rust-core async scheduler)
 
         If this account is not configured an Exception is raised.
         You need to call account.configure() and account.wait_configure_finish()
@@ -703,10 +705,12 @@ class Account(object):
         """
         lib.dc_maybe_network(self._dc_context)
 
-    def configure(self) -> ConfigureTracker:
+    def configure(self, reconfigure: bool = False) -> ConfigureTracker:
         """Start configuration process and return a Configtracker instance
         on which you can block with wait_finish() to get a True/False success
         value for the configuration process.
+
+        :param reconfigure: deprecated, doesn't need to be checked anymore.
         """
         if not self.get_config("addr") or not self.get_config("mail_pw"):
             raise MissingCredentials("addr or mail_pwd not set in config")
@@ -729,8 +733,7 @@ class Account(object):
 
     def shutdown(self) -> None:
         """shutdown and destroy account (stop callback thread, close and remove
-        underlying dc_context).
-        """
+        underlying dc_context)."""
         if self._dc_context is None:
             return
 

python/src/deltachat/chat.py

@@ -1,4 +1,4 @@
-"""Chat and Location related API."""
+""" Chat and Location related API. """
 
 import calendar
 import json
@@ -37,7 +37,7 @@ class Chat(object):
         return self.id == getattr(other, "id", None) and self.account._dc_context == other.account._dc_context
 
     def __ne__(self, other) -> bool:
-        return not self == other
+        return not (self == other)
 
     def __repr__(self) -> str:
         return "<Chat id={} name={}>".format(self.id, self.get_name())
@@ -74,19 +74,19 @@ class Chat(object):
         return lib.dc_chat_get_type(self._dc_chat) == const.DC_CHAT_TYPE_GROUP
 
     def is_single(self) -> bool:
-        """Return True if this chat is a single/direct chat, False otherwise."""
+        """Return True if this chat is a single/direct chat, False otherwise"""
         return lib.dc_chat_get_type(self._dc_chat) == const.DC_CHAT_TYPE_SINGLE
 
     def is_mailinglist(self) -> bool:
-        """Return True if this chat is a mailing list, False otherwise."""
+        """Return True if this chat is a mailing list, False otherwise"""
         return lib.dc_chat_get_type(self._dc_chat) == const.DC_CHAT_TYPE_MAILINGLIST
 
     def is_broadcast(self) -> bool:
-        """Return True if this chat is a broadcast list, False otherwise."""
+        """Return True if this chat is a broadcast list, False otherwise"""
         return lib.dc_chat_get_type(self._dc_chat) == const.DC_CHAT_TYPE_BROADCAST
 
     def is_multiuser(self) -> bool:
-        """Return True if this chat is a multi-user chat (group, mailing list or broadcast), False otherwise."""
+        """Return True if this chat is a multi-user chat (group, mailing list or broadcast), False otherwise"""
         return lib.dc_chat_get_type(self._dc_chat) in (
             const.DC_CHAT_TYPE_GROUP,
             const.DC_CHAT_TYPE_MAILINGLIST,
@@ -94,11 +94,11 @@ class Chat(object):
         )
 
     def is_self_talk(self) -> bool:
-        """Return True if this chat is the self-chat (a.k.a. "Saved Messages"), False otherwise."""
+        """Return True if this chat is the self-chat (a.k.a. "Saved Messages"), False otherwise"""
         return bool(lib.dc_chat_is_self_talk(self._dc_chat))
 
     def is_device_talk(self) -> bool:
-        """Returns True if this chat is the "Device Messages" chat, False otherwise."""
+        """Returns True if this chat is the "Device Messages" chat, False otherwise"""
         return bool(lib.dc_chat_is_device_talk(self._dc_chat))
 
     def is_muted(self) -> bool:
@@ -109,12 +109,12 @@ class Chat(object):
         return bool(lib.dc_chat_is_muted(self._dc_chat))
 
     def is_pinned(self) -> bool:
-        """Return True if this chat is pinned, False otherwise."""
+        """Return True if this chat is pinned, False otherwise"""
         return lib.dc_chat_get_visibility(self._dc_chat) == const.DC_CHAT_VISIBILITY_PINNED
 
     def is_archived(self) -> bool:
         """Return True if this chat is archived, False otherwise.
-        :returns: True if archived, False otherwise.
+        :returns: True if archived, False otherwise
         """
         return lib.dc_chat_get_visibility(self._dc_chat) == const.DC_CHAT_VISIBILITY_ARCHIVED
 
@@ -136,7 +136,7 @@ class Chat(object):
 
     def can_send(self) -> bool:
         """Check if messages can be sent to a give chat.
-        This is not true eg. for the contact requests or for the device-talk.
+        This is not true eg. for the contact requests or for the device-talk
 
         :returns: True if the chat is writable, False otherwise
         """
@@ -167,7 +167,7 @@ class Chat(object):
 
     def get_color(self):
         """return the color of the chat.
-        :returns: color as 0x00rrggbb.
+        :returns: color as 0x00rrggbb
         """
         return lib.dc_chat_get_color(self._dc_chat)
 
@@ -178,18 +178,21 @@ class Chat(object):
         return json.loads(s)
 
     def mute(self, duration: Optional[int] = None) -> None:
-        """mutes the chat.
+        """mutes the chat
 
         :param duration: Number of seconds to mute the chat for. None to mute until unmuted again.
         :returns: None
         """
-        mute_duration = -1 if duration is None else duration
+        if duration is None:
+            mute_duration = -1
+        else:
+            mute_duration = duration
         ret = lib.dc_set_chat_mute_duration(self.account._dc_context, self.id, mute_duration)
         if not bool(ret):
             raise ValueError("Call to dc_set_chat_mute_duration failed")
 
     def unmute(self) -> None:
-        """unmutes the chat.
+        """unmutes the chat
 
         :returns: None
         """
@@ -249,8 +252,7 @@ class Chat(object):
     def get_encryption_info(self) -> Optional[str]:
         """Return encryption info for this chat.
 
-        :returns: a string with encryption preferences of all chat members
-        """
+        :returns: a string with encryption preferences of all chat members"""
         res = lib.dc_get_chat_encrinfo(self.account._dc_context, self.id)
         return from_dc_charpointer(res)
 
@@ -461,7 +463,7 @@ class Chat(object):
 
     def get_contacts(self):
         """get all contacts for this chat.
-        :returns: list of :class:`deltachat.contact.Contact` objects for this chat.
+        :returns: list of :class:`deltachat.contact.Contact` objects for this chat
         """
         from .contact import Contact
 
@@ -545,10 +547,19 @@ class Chat(object):
         :param timespan_to: a datetime object or None (indicating up till now)
         :returns: list of :class:`deltachat.chat.Location` objects.
         """
-        time_from = 0 if timestamp_from is None else calendar.timegm(timestamp_from.utctimetuple())
-        time_to = 0 if timestamp_to is None else calendar.timegm(timestamp_to.utctimetuple())
+        if timestamp_from is None:
+            time_from = 0
+        else:
+            time_from = calendar.timegm(timestamp_from.utctimetuple())
+        if timestamp_to is None:
+            time_to = 0
+        else:
+            time_to = calendar.timegm(timestamp_to.utctimetuple())
 
-        contact_id = 0 if contact is None else contact.id
+        if contact is None:
+            contact_id = 0
+        else:
+            contact_id = contact.id
 
         dc_array = lib.dc_get_locations(self.account._dc_context, self.id, contact_id, time_from, time_to)
         return [

python/src/deltachat/contact.py

@@ -1,4 +1,4 @@
-"""Contact object."""
+""" Contact object. """
 
 from datetime import date, datetime, timezone
 from typing import Optional
@@ -28,7 +28,7 @@ class Contact(object):
         return self.account._dc_context == other.account._dc_context and self.id == other.id
 
     def __ne__(self, other):
-        return not self == other
+        return not (self == other)
 
     def __repr__(self):
         return "<Contact id={} addr={} dc_context={}>".format(self.id, self.addr, self.account._dc_context)
@@ -76,7 +76,7 @@ class Contact(object):
         return lib.dc_contact_is_verified(self._dc_contact)
 
     def get_verifier(self, contact):
-        """Return the address of the contact that verified the contact."""
+        """Return the address of the contact that verified the contact"""
         return from_dc_charpointer(lib.dc_contact_get_verifier_addr(contact._dc_contact))
 
     def get_profile_image(self) -> Optional[str]:

python/src/deltachat/direct_imap.py

@@ -79,17 +79,15 @@ class DirectImap:
 
     def select_config_folder(self, config_name: str):
         """Return info about selected folder if it is
-        configured, otherwise None.
-        """
+        configured, otherwise None."""
         if "_" not in config_name:
             config_name = "configured_{}_folder".format(config_name)
         foldername = self.account.get_config(config_name)
         if foldername:
             return self.select_folder(foldername)
-        return None
 
     def list_folders(self) -> List[str]:
-        """return list of all existing folder names."""
+        """return list of all existing folder names"""
         assert not self._idling
         return [folder.name for folder in self.conn.folder.list()]
 
@@ -105,7 +103,7 @@ class DirectImap:
 
     def get_all_messages(self) -> List[MailMessage]:
         assert not self._idling
-        return list(self.conn.fetch())
+        return [mail for mail in self.conn.fetch()]
 
     def get_unread_messages(self) -> List[str]:
         assert not self._idling
@@ -223,4 +221,5 @@ class IdleManager:
 
     def done(self):
         """send idle-done to server if we are currently in idle mode."""
-        return self.direct_imap.conn.idle.stop()
+        res = self.direct_imap.conn.idle.stop()
+        return res

python/src/deltachat/events.py

@@ -32,11 +32,12 @@ class FFIEvent:
     def __str__(self):
         if self.name == "DC_EVENT_INFO":
             return "INFO {data2}".format(data2=self.data2)
-        if self.name == "DC_EVENT_WARNING":
+        elif self.name == "DC_EVENT_WARNING":
             return "WARNING {data2}".format(data2=self.data2)
-        if self.name == "DC_EVENT_ERROR":
+        elif self.name == "DC_EVENT_ERROR":
             return "ERROR {data2}".format(data2=self.data2)
-        return "{name} data1={data1} data2={data2}".format(**self.__dict__)
+        else:
+            return "{name} data1={data1} data2={data2}".format(**self.__dict__)
 
 
 class FFIEventLogger:
@@ -134,8 +135,7 @@ class FFIEventTracker:
     def wait_for_connectivity(self, connectivity):
         """Wait for the specified connectivity.
         This only works reliably if the connectivity doesn't change
-        again too quickly, otherwise we might miss it.
-        """
+        again too quickly, otherwise we might miss it."""
         while 1:
             if self.account.get_connectivity() == connectivity:
                 return
@@ -143,13 +143,12 @@ class FFIEventTracker:
 
     def wait_for_connectivity_change(self, previous, expected_next):
         """Wait until the connectivity changes to `expected_next`.
-        Fails the test if it changes to something else.
-        """
+        Fails the test if it changes to something else."""
         while 1:
             current = self.account.get_connectivity()
             if current == expected_next:
                 return
-            if current != previous:
+            elif current != previous:
                 raise Exception("Expected connectivity " + str(expected_next) + " but got " + str(current))
 
             self.get_matching("DC_EVENT_CONNECTIVITY_CHANGED")
@@ -184,8 +183,7 @@ class FFIEventTracker:
         - ac1 and ac2 are created
         - ac1 sends a message to ac2
         - ac2 is still running FetchExsistingMsgs job and thinks it's an existing, old message
-        - therefore no DC_EVENT_INCOMING_MSG is sent
-        """
+        - therefore no DC_EVENT_INCOMING_MSG is sent"""
         self.get_info_contains("INBOX: Idle entering")
 
     def wait_next_incoming_message(self):
@@ -195,15 +193,14 @@ class FFIEventTracker:
 
     def wait_next_messages_changed(self):
         """wait for and return next message-changed message or None
-        if the event contains no msgid
-        """
+        if the event contains no msgid"""
         ev = self.get_matching("DC_EVENT_MSGS_CHANGED")
         if ev.data2 > 0:
             return self.account.get_message_by_id(ev.data2)
         return None
 
     def wait_next_reactions_changed(self):
-        """wait for and return next reactions-changed message."""
+        """wait for and return next reactions-changed message"""
         ev = self.get_matching("DC_EVENT_REACTIONS_CHANGED")
         assert ev.data1 > 0
         return self.account.get_message_by_id(ev.data2)
@@ -295,10 +292,10 @@ class EventThread(threading.Thread):
             if data1 == 0 or data1 == 1000:
                 success = data1 == 1000
                 comment = ffi_event.data2
-                yield "ac_configure_completed", {"success": success, "comment": comment}
+                yield "ac_configure_completed", dict(success=success, comment=comment)
         elif name == "DC_EVENT_INCOMING_MSG":
             msg = account.get_message_by_id(ffi_event.data2)
-            yield map_system_message(msg) or ("ac_incoming_message", {"message": msg})
+            yield map_system_message(msg) or ("ac_incoming_message", dict(message=msg))
         elif name == "DC_EVENT_MSGS_CHANGED":
             if ffi_event.data2 != 0:
                 msg = account.get_message_by_id(ffi_event.data2)
@@ -306,19 +303,19 @@ class EventThread(threading.Thread):
                     res = map_system_message(msg)
                     if res and res[0].startswith("ac_member"):
                         yield res
-                    yield "ac_outgoing_message", {"message": msg}
+                    yield "ac_outgoing_message", dict(message=msg)
                 elif msg.is_in_fresh():
                     yield map_system_message(msg) or (
                         "ac_incoming_message",
-                        {"message": msg},
+                        dict(message=msg),
                     )
         elif name == "DC_EVENT_REACTIONS_CHANGED":
             assert ffi_event.data1 > 0
             msg = account.get_message_by_id(ffi_event.data2)
-            yield "ac_reactions_changed", {"message": msg}
+            yield "ac_reactions_changed", dict(message=msg)
         elif name == "DC_EVENT_MSG_DELIVERED":
             msg = account.get_message_by_id(ffi_event.data2)
-            yield "ac_message_delivered", {"message": msg}
+            yield "ac_message_delivered", dict(message=msg)
         elif name == "DC_EVENT_CHAT_MODIFIED":
             chat = account.get_chat_by_id(ffi_event.data1)
-            yield "ac_chat_modified", {"chat": chat}
+            yield "ac_chat_modified", dict(chat=chat)

python/src/deltachat/hookspec.py

@@ -1,4 +1,4 @@
-"""Hooks for Python bindings to Delta Chat Core Rust CFFI."""
+""" Hooks for Python bindings to Delta Chat Core Rust CFFI"""
 
 import pluggy
 

python/src/deltachat/message.py

@@ -1,4 +1,4 @@
-"""The Message object."""
+""" The Message object. """
 
 import json
 import os
@@ -59,7 +59,10 @@ class Message(object):
         :param view_type: the message type code or one of the strings:
            "text", "audio", "video", "file", "sticker", "videochat", "webxdc"
         """
-        view_type_code = view_type if isinstance(view_type, int) else get_viewtype_code_from_name(view_type)
+        if isinstance(view_type, int):
+            view_type_code = view_type
+        else:
+            view_type_code = get_viewtype_code_from_name(view_type)
         return Message(
             account,
             ffi.gc(lib.dc_msg_new(account._dc_context, view_type_code), lib.dc_msg_unref),
@@ -126,7 +129,7 @@ class Message(object):
 
     @props.with_doc
     def filemime(self) -> str:
-        """mime type of the file (if it exists)."""
+        """mime type of the file (if it exists)"""
         return from_dc_charpointer(lib.dc_msg_get_filemime(self._dc_msg))
 
     def get_status_updates(self, serial: int = 0) -> list:
@@ -138,7 +141,7 @@ class Message(object):
         :param serial: The last known serial. Pass 0 if there are no known serials to receive all updates.
         """
         return json.loads(
-            from_dc_charpointer(lib.dc_get_webxdc_status_updates(self.account._dc_context, self.id, serial)),
+            from_dc_charpointer(lib.dc_get_webxdc_status_updates(self.account._dc_context, self.id, serial))
         )
 
     def send_status_update(self, json_data: Union[str, dict], description: str) -> bool:
@@ -155,11 +158,8 @@ class Message(object):
             json_data = json.dumps(json_data, default=str)
         return bool(
             lib.dc_send_webxdc_status_update(
-                self.account._dc_context,
-                self.id,
-                as_dc_charpointer(json_data),
-                as_dc_charpointer(description),
-            ),
+                self.account._dc_context, self.id, as_dc_charpointer(json_data), as_dc_charpointer(description)
+            )
         )
 
     def send_reaction(self, reaction: str):
@@ -232,18 +232,16 @@ class Message(object):
         ts = lib.dc_msg_get_received_timestamp(self._dc_msg)
         if ts:
             return datetime.fromtimestamp(ts, timezone.utc)
-        return None
 
     @props.with_doc
     def ephemeral_timer(self):
-        """Ephemeral timer in seconds.
+        """Ephemeral timer in seconds
 
         :returns: timer in seconds or None if there is no timer
         """
         timer = lib.dc_msg_get_ephemeral_timer(self._dc_msg)
         if timer:
             return timer
-        return None
 
     @props.with_doc
     def ephemeral_timestamp(self):
@@ -257,25 +255,23 @@ class Message(object):
 
     @property
     def quoted_text(self) -> Optional[str]:
-        """Text inside the quote.
+        """Text inside the quote
 
-        :returns: Quoted text
-        """
+        :returns: Quoted text"""
         return from_optional_dc_charpointer(lib.dc_msg_get_quoted_text(self._dc_msg))
 
     @property
     def quote(self):
-        """Quote getter.
+        """Quote getter
 
-        :returns: Quoted message, if found in the database
-        """
+        :returns: Quoted message, if found in the database"""
         msg = lib.dc_msg_get_quoted_msg(self._dc_msg)
         if msg:
             return Message(self.account, ffi.gc(msg, lib.dc_msg_unref))
 
     @quote.setter
     def quote(self, quoted_message):
-        """Quote setter."""
+        """Quote setter"""
         lib.dc_msg_set_quote(self._dc_msg, quoted_message._dc_msg)
 
     def force_plaintext(self) -> None:
@@ -290,7 +286,7 @@ class Message(object):
 
         :returns: email-mime message object (with headers only, no body).
         """
-        import email
+        import email.parser
 
         mime_headers = lib.dc_get_mime_headers(self.account._dc_context, self.id)
         if mime_headers:
@@ -301,7 +297,7 @@ class Message(object):
 
     @property
     def error(self) -> Optional[str]:
-        """Error message."""
+        """Error message"""
         return from_optional_dc_charpointer(lib.dc_msg_get_error(self._dc_msg))
 
     @property
@@ -497,8 +493,7 @@ def get_viewtype_code_from_name(view_type_name):
     if code is not None:
         return code
     raise ValueError(
-        "message typecode not found for {!r}, "
-        "available {!r}".format(view_type_name, list(_view_type_mapping.keys())),
+        "message typecode not found for {!r}, " "available {!r}".format(view_type_name, list(_view_type_mapping.keys()))
     )
 
 
@@ -511,11 +506,14 @@ def map_system_message(msg):
     if msg.is_system_message():
         res = parse_system_add_remove(msg.text)
         if not res:
-            return None
+            return
         action, affected, actor = res
         affected = msg.account.get_contact_by_addr(affected)
-        actor = None if actor == "me" else msg.account.get_contact_by_addr(actor)
-        d = {"chat": msg.chat, "contact": affected, "actor": actor, "message": msg}
+        if actor == "me":
+            actor = None
+        else:
+            actor = msg.account.get_contact_by_addr(actor)
+        d = dict(chat=msg.chat, contact=affected, actor=actor, message=msg)
         return "ac_member_" + res[0], d
 
 
@@ -530,8 +528,8 @@ def extract_addr(text):
 def parse_system_add_remove(text):
     """return add/remove info from parsing the given system message text.
 
-    returns a (action, affected, actor) triple
-    """
+    returns a (action, affected, actor) triple"""
+
     # You removed member a@b.
     # You added member a@b.
     # Member Me (x@y) removed by a@b.

python/src/deltachat/props.py

@@ -8,7 +8,7 @@ def with_doc(f):
 # copied over unmodified from
 # https://github.com/devpi/devpi/blob/master/common/devpi_common/types.py
 def cached(f):
-    """returns a cached property that is calculated by function f."""
+    """returns a cached property that is calculated by function f"""
 
     def get(self):
         try:
@@ -17,9 +17,8 @@ def cached(f):
             self._property_cache = {}
         except KeyError:
             pass
-        res = f(self)
-        self._property_cache[f] = res
-        return res
+        x = self._property_cache[f] = f(self)
+        return x
 
     def set(self, val):
         propcache = self.__dict__.setdefault("_property_cache", {})

python/src/deltachat/provider.py

@@ -9,8 +9,7 @@ class ProviderNotFoundError(Exception):
 
 
 class Provider(object):
-    """
-    Provider information.
+    """Provider information.
 
     :param domain: The email to get the provider info for.
     """

python/src/deltachat/reactions.py

@@ -1,4 +1,4 @@
-"""The Reactions object."""
+""" The Reactions object. """
 
 from .capi import ffi, lib
 from .cutil import from_dc_charpointer, iter_array

python/src/deltachat/testplugin.py

@@ -29,7 +29,7 @@ def pytest_addoption(parser):
         "--liveconfig",
         action="store",
         default=None,
-        help="a file with >=2 lines where each line contains NAME=VALUE config settings for one account",
+        help="a file with >=2 lines where each line " "contains NAME=VALUE config settings for one account",
     )
     group.addoption(
         "--ignored",
@@ -124,7 +124,7 @@ def pytest_report_header(config, startdir):
             info["deltachat_core_version"],
             info["sqlite_version"],
             info["journal_mode"],
-        ),
+        )
     ]
 
     cfg = config.option.liveconfig
@@ -180,7 +180,7 @@ class TestProcess:
                     if res.status_code != 200:
                         pytest.fail("newtmpuser count={} code={}: '{}'".format(index, res.status_code, res.text))
                     d = res.json()
-                    config = {"addr": d["email"], "mail_pw": d["password"]}
+                    config = dict(addr=d["email"], mail_pw=d["password"])
                     print("newtmpuser {}: addr={}".format(index, config["addr"]))
                     self._configlist.append(config)
                     yield config
@@ -229,7 +229,7 @@ def write_dict_to_dir(dic, target_dir):
         path.write_bytes(content)
 
 
-@pytest.fixture()
+@pytest.fixture
 def data(request):
     class Data:
         def __init__(self) -> None:
@@ -253,7 +253,6 @@ def data(request):
                 if os.path.exists(fn):
                     return fn
             print("WARNING: path does not exist: {!r}".format(fn))
-            return None
 
         def read_path(self, bn, mode="r"):
             fn = self.get_path(bn)
@@ -265,11 +264,8 @@ def data(request):
 
 
 class ACSetup:
-    """
-    Accounts setup helper to deal with multiple configure-process
-    and io & imap initialization phases.
-
-    From tests, use the higher level
+    """accounts setup helper to deal with multiple configure-process
+    and io & imap initialization phases. From tests, use the higher level
     public ACFactory methods instead of its private helper class.
     """
 
@@ -293,7 +289,7 @@ class ACSetup:
         self._account2state[account] = self.CONFIGURED
         self.log("added already configured account", account, account.get_config("addr"))
 
-    def start_configure(self, account):
+    def start_configure(self, account, reconfigure=False):
         """add an account and start its configure process."""
 
         class PendingTracker:
@@ -303,7 +299,7 @@ class ACSetup:
 
         account.add_account_plugin(PendingTracker(), name="pending_tracker")
         self._account2state[account] = self.CONFIGURING
-        account.configure()
+        account.configure(reconfigure=reconfigure)
         self.log("started configure on", account)
 
     def wait_one_configured(self, account):
@@ -415,8 +411,7 @@ class ACFactory:
                 acc.disable_logging()
 
     def get_next_liveconfig(self):
-        """
-        Base function to get functional online configurations
+        """Base function to get functional online configurations
         where we can make valid SMTP and IMAP connections with.
         """
         configdict = next(self._liveconfig_producer).copy()
@@ -470,7 +465,8 @@ class ACFactory:
             if fname_pub and fname_sec:
                 account._preconfigure_keypair(addr, fname_pub, fname_sec)
                 return True
-            print("WARN: could not use preconfigured keys for {!r}".format(addr))
+            else:
+                print("WARN: could not use preconfigured keys for {!r}".format(addr))
 
     def get_pseudo_configured_account(self, passphrase: Optional[str] = None) -> Account:
         # do a pseudo-configured account
@@ -480,14 +476,14 @@ class ACFactory:
         acname = ac._logid
         addr = "{}@offline.org".format(acname)
         ac.update_config(
-            {
-                "addr": addr,
-                "displayname": acname,
-                "mail_pw": "123",
-                "configured_addr": addr,
-                "configured_mail_pw": "123",
-                "configured": "1",
-            },
+            dict(
+                addr=addr,
+                displayname=acname,
+                mail_pw="123",
+                configured_addr=addr,
+                configured_mail_pw="123",
+                configured="1",
+            )
         )
         self._preconfigure_key(ac, addr)
         self._acsetup.init_logging(ac)
@@ -498,12 +494,12 @@ class ACFactory:
             configdict = self.get_next_liveconfig()
         else:
             # XXX we might want to transfer the key to the new account
-            configdict = {
-                "addr": cloned_from.get_config("addr"),
-                "mail_pw": cloned_from.get_config("mail_pw"),
-                "imap_certificate_checks": cloned_from.get_config("imap_certificate_checks"),
-                "smtp_certificate_checks": cloned_from.get_config("smtp_certificate_checks"),
-            }
+            configdict = dict(
+                addr=cloned_from.get_config("addr"),
+                mail_pw=cloned_from.get_config("mail_pw"),
+                imap_certificate_checks=cloned_from.get_config("imap_certificate_checks"),
+                smtp_certificate_checks=cloned_from.get_config("smtp_certificate_checks"),
+            )
         configdict.update(kwargs)
         ac = self._get_cached_account(addr=configdict["addr"]) if cache else None
         if ac is not None:
@@ -604,7 +600,7 @@ class ACFactory:
             acc._evtracker.wait_next_incoming_message()
 
 
-@pytest.fixture()
+@pytest.fixture
 def acfactory(request, tmpdir, testprocess, data):
     am = ACFactory(request=request, tmpdir=tmpdir, testprocess=testprocess, data=data)
     yield am
@@ -669,12 +665,12 @@ class BotProcess:
                     ignored.append(line)
 
 
-@pytest.fixture()
+@pytest.fixture
 def tmp_db_path(tmpdir):
     return tmpdir.join("test.db").strpath
 
 
-@pytest.fixture()
+@pytest.fixture
 def lp():
     class Printer:
         def sec(self, msg: str) -> None:

python/src/deltachat/tracker.py

@@ -77,11 +77,11 @@ class ConfigureTracker:
         self.account.remove_account_plugin(self)
 
     def wait_smtp_connected(self):
-        """Wait until SMTP is configured."""
+        """wait until smtp is configured."""
         self._smtp_finished.wait()
 
     def wait_imap_connected(self):
-        """Wait until IMAP is configured."""
+        """wait until smtp is configured."""
         self._imap_finished.wait()
 
     def wait_progress(self, data1=None):
@@ -91,8 +91,7 @@ class ConfigureTracker:
                 break
 
     def wait_finish(self, timeout=None):
-        """
-        Wait until configure is completed.
+        """wait until configure is completed.
 
         Raise Exception if Configure failed
         """

python/tests/auditwheels.py

@@ -15,5 +15,5 @@ if __name__ == "__main__":
                     p,
                     "-w",
                     workspacedir,
-                ],
+                ]
             )

python/tests/test_0_complex_or_slow.py

@@ -216,7 +216,7 @@ def test_fetch_existing(acfactory, lp, mvbox_move):
     # would also find the "Sent" folder, but it would be too late:
     # The sentbox thread, started by `start_io()`, would have seen that there is no
     # ConfiguredSentboxFolder and do nothing.
-    acfactory._acsetup.start_configure(ac1)
+    acfactory._acsetup.start_configure(ac1, reconfigure=True)
     acfactory.bring_accounts_online()
     assert_folders_configured(ac1)
 

python/tests/test_1_online.py

@@ -32,7 +32,7 @@ def test_basic_imap_api(acfactory, tmpdir):
     imap2.shutdown()
 
 
-@pytest.mark.ignored()
+@pytest.mark.ignored
 def test_configure_generate_key(acfactory, lp):
     # A slow test which will generate new keys.
     acfactory.remove_preconfigured_keys()
@@ -510,7 +510,7 @@ def test_send_and_receive_message_markseen(acfactory, lp):
             idle2.wait_for_seen()
 
         lp.step("1")
-        for _i in range(2):
+        for i in range(2):
             ev = ac1._evtracker.get_matching("DC_EVENT_MSG_READ")
             assert ev.data1 > const.DC_CHAT_ID_LAST_SPECIAL
             assert ev.data2 > const.DC_MSG_ID_LAST_SPECIAL
@@ -529,7 +529,7 @@ def test_send_and_receive_message_markseen(acfactory, lp):
         pass  # mark_seen_messages() has generated events before it returns
 
 
-def test_moved_markseen(acfactory):
+def test_moved_markseen(acfactory, lp):
     """Test that message already moved to DeltaChat folder is marked as seen."""
     ac1 = acfactory.new_online_configuring_account()
     ac2 = acfactory.new_online_configuring_account(mvbox_move=True)
@@ -553,7 +553,7 @@ def test_moved_markseen(acfactory):
         ac2.mark_seen_messages([msg])
         uid = idle2.wait_for_seen()
 
-    assert len(list(ac2.direct_imap.conn.fetch(AND(seen=True, uid=U(uid, "*"))))) == 1
+    assert len([a for a in ac2.direct_imap.conn.fetch(AND(seen=True, uid=U(uid, "*")))]) == 1
 
 
 def test_message_override_sender_name(acfactory, lp):
@@ -832,7 +832,7 @@ def test_send_first_message_as_long_unicode_with_cr(acfactory, lp):
     lp.sec("sending multi-line non-unicode message from ac1 to ac2")
     text1 = (
         "hello\nworld\nthis is a very long message that should be"
-        " wrapped using format=flowed and unwrapped on the receiver"
+        + " wrapped using format=flowed and unwrapped on the receiver"
     )
     msg_out = chat.send_text(text1)
     assert not msg_out.is_encrypted()
@@ -894,7 +894,7 @@ def test_dont_show_emails(acfactory, lp):
 
         message in Drafts that is moved to Sent later
     """.format(
-            ac1.get_config("configured_addr"),
+            ac1.get_config("configured_addr")
         ),
     )
     ac1.direct_imap.append(
@@ -908,7 +908,7 @@ def test_dont_show_emails(acfactory, lp):
 
         message in Sent
     """.format(
-            ac1.get_config("configured_addr"),
+            ac1.get_config("configured_addr")
         ),
     )
     ac1.direct_imap.append(
@@ -922,7 +922,7 @@ def test_dont_show_emails(acfactory, lp):
 
         Unknown message in Spam
     """.format(
-            ac1.get_config("configured_addr"),
+            ac1.get_config("configured_addr")
         ),
     )
     ac1.direct_imap.append(
@@ -936,7 +936,7 @@ def test_dont_show_emails(acfactory, lp):
 
         Unknown & malformed message in Spam
     """.format(
-            ac1.get_config("configured_addr"),
+            ac1.get_config("configured_addr")
         ),
     )
     ac1.direct_imap.append(
@@ -950,7 +950,7 @@ def test_dont_show_emails(acfactory, lp):
 
         Unknown & malformed message in Spam
     """.format(
-            ac1.get_config("configured_addr"),
+            ac1.get_config("configured_addr")
         ),
     )
     ac1.direct_imap.append(
@@ -964,7 +964,7 @@ def test_dont_show_emails(acfactory, lp):
 
         Actually interesting message in Spam
     """.format(
-            ac1.get_config("configured_addr"),
+            ac1.get_config("configured_addr")
         ),
     )
     ac1.direct_imap.append(
@@ -978,7 +978,7 @@ def test_dont_show_emails(acfactory, lp):
 
         Unknown message in Junk
     """.format(
-            ac1.get_config("configured_addr"),
+            ac1.get_config("configured_addr")
         ),
     )
 
@@ -1710,7 +1710,7 @@ def test_system_group_msg_from_blocked_user(acfactory, lp):
     assert contact.is_blocked()
     chat_on_ac2.remove_contact(ac1)
     ac1._evtracker.get_matching("DC_EVENT_CHAT_MODIFIED")
-    assert ac1.get_self_contact() not in chat_on_ac1.get_contacts()
+    assert not ac1.get_self_contact() in chat_on_ac1.get_contacts()
 
 
 def test_set_get_group_image(acfactory, data, lp):
@@ -1784,7 +1784,7 @@ def test_connectivity(acfactory, lp):
 
     lp.sec(
         "Test that after calling start_io(), maybe_network() and waiting for `all_work_done()`, "
-        "all messages are fetched",
+        + "all messages are fetched"
     )
 
     ac1.direct_imap.select_config_folder("inbox")
@@ -2146,7 +2146,7 @@ def test_group_quote(acfactory, lp):
 
 
 @pytest.mark.parametrize(
-    ("folder", "move", "expected_destination"),
+    "folder,move,expected_destination,",
     [
         (
             "xyz",
@@ -2261,44 +2261,11 @@ def test_aeap_flow_verified(acfactory, lp):
     assert ac1new.get_config("addr") in [contact.addr for contact in msg_in_2.chat.get_contacts()]
 
 
-def test_archived_muted_chat(acfactory, lp):
-    """If an archived and muted chat receives a new message, DC_EVENT_MSGS_CHANGED for
-    DC_CHAT_ID_ARCHIVED_LINK must be generated if the chat had only seen messages previously.
-    """
-    ac1, ac2 = acfactory.get_online_accounts(2)
-    chat = acfactory.get_accepted_chat(ac1, ac2)
-
-    lp.sec("ac1: send message to ac2")
-    chat.send_text("message0")
-
-    lp.sec("wait for ac2 to receive message")
-    msg2 = ac2._evtracker.wait_next_incoming_message()
-    assert msg2.text == "message0"
-    msg2.mark_seen()
-
-    chat2 = msg2.chat
-    chat2.archive()
-    chat2.mute()
-
-    lp.sec("ac1: send another message to ac2")
-    chat.send_text("message1")
-
-    lp.sec("wait for ac2 to receive DC_EVENT_MSGS_CHANGED for DC_CHAT_ID_ARCHIVED_LINK")
-    while 1:
-        ev = ac2._evtracker.get_matching("DC_EVENT_MSGS_CHANGED")
-        if ev.data1 == const.DC_CHAT_ID_ARCHIVED_LINK:
-            assert ev.data2 == 0
-            archive = ac2.get_chat_by_id(const.DC_CHAT_ID_ARCHIVED_LINK)
-            assert archive.count_fresh_messages() == 1
-            assert chat2.count_fresh_messages() == 1
-            break
-
-
 class TestOnlineConfigureFails:
     def test_invalid_password(self, acfactory):
         configdict = acfactory.get_next_liveconfig()
         ac1 = acfactory.get_unconfigured_account()
-        ac1.update_config({"addr": configdict["addr"], "mail_pw": "123"})
+        ac1.update_config(dict(addr=configdict["addr"], mail_pw="123"))
         configtracker = ac1.configure()
         configtracker.wait_progress(500)
         configtracker.wait_progress(0)

python/tests/test_3_offline.py

@@ -15,7 +15,7 @@ from deltachat.tracker import ImexFailed
 
 
 @pytest.mark.parametrize(
-    ("msgtext", "res"),
+    "msgtext,res",
     [
         (
             "Member Me (tmp1@x.org) removed by tmp2@x.org.",
@@ -108,7 +108,7 @@ class TestOfflineAccountBasic:
 
     def test_update_config(self, acfactory):
         ac1 = acfactory.get_unconfigured_account()
-        ac1.update_config({"mvbox_move": False})
+        ac1.update_config(dict(mvbox_move=False))
         assert ac1.get_config("mvbox_move") == "0"
 
     def test_has_savemime(self, acfactory):
@@ -229,11 +229,11 @@ class TestOfflineContact:
 
 
 class TestOfflineChat:
-    @pytest.fixture()
+    @pytest.fixture
     def ac1(self, acfactory):
         return acfactory.get_pseudo_configured_account()
 
-    @pytest.fixture()
+    @pytest.fixture
     def chat1(self, ac1):
         return ac1.create_contact("some1@example.org", name="some1").create_chat()
 
@@ -257,7 +257,7 @@ class TestOfflineChat:
         assert chat2.id == chat1.id
         assert chat2.get_name() == chat1.get_name()
         assert chat1 == chat2
-        assert not chat1.__ne__(chat2)
+        assert not (chat1 != chat2)
         assert chat1 != chat3
 
         for ichat in ac1.get_chats():
@@ -450,7 +450,7 @@ class TestOfflineChat:
         assert msg.filemime == "image/png"
 
     @pytest.mark.parametrize(
-        ("fn", "typein", "typeout"),
+        "fn,typein,typeout",
         [
             ("r", None, "application/octet-stream"),
             ("r.txt", None, "text/plain"),
@@ -458,7 +458,7 @@ class TestOfflineChat:
             ("r.txt", "image/png", "image/png"),
         ],
     )
-    def test_message_file(self, chat1, data, lp, fn, typein, typeout):
+    def test_message_file(self, ac1, chat1, data, lp, fn, typein, typeout):
         lp.sec("sending file")
         fp = data.get_path(fn)
         msg = chat1.send_file(fp, typein)
@@ -694,7 +694,7 @@ class TestOfflineChat:
         chat1.set_draft(None)
         assert chat1.get_draft() is None
 
-    def test_qr_setup_contact(self, acfactory):
+    def test_qr_setup_contact(self, acfactory, lp):
         ac1 = acfactory.get_pseudo_configured_account()
         ac2 = acfactory.get_pseudo_configured_account()
         qr = ac1.get_setup_contact_qr()

python/tests/test_4_lowlevel.py

@@ -93,7 +93,7 @@ def test_empty_context():
     capi.lib.dc_context_unref(ctx)
 
 
-def test_dc_close_events(acfactory):
+def test_dc_close_events(tmpdir, acfactory):
     ac1 = acfactory.get_unconfigured_account()
 
     # register after_shutdown function

python/tox.ini

@@ -50,14 +50,18 @@ commands =
 skipsdist = True
 skip_install = True
 deps =
-    ruff
+    flake8
+# isort 5.11.0 is broken: https://github.com/PyCQA/isort/issues/2031
+    isort<5.11.0
     black
     # pygments required by rst-lint
     pygments
     restructuredtext_lint 
 commands =
+    isort --check setup.py install_python_bindings.py src/deltachat examples/ tests/
     black --check setup.py install_python_bindings.py src/deltachat examples/ tests/
-    ruff src/deltachat tests/ examples/
+    flake8 src/deltachat
+    flake8 tests/ examples/
     rst-lint --encoding 'utf-8' README.rst
 
 [testenv:mypy]
@@ -98,3 +102,7 @@ timeout = 150
 timeout_func_only = True
 markers = 
     ignored: ignore this test in default test runs, use --ignored to run.
+
+[flake8]
+max-line-length = 120
+ignore = E203, E266, E501, W503

scripts/cleanup_devpi_indices.py

@@ -2,13 +2,12 @@
 Remove old "dc" indices except for master which always stays.
 
 """
-import datetime
-import subprocess
-import sys
-
 from requests import Session
+import datetime
+import sys
+import subprocess
 
-MAXDAYS = 7
+MAXDAYS=7
 
 session = Session()
 session.headers["Accept"] = "application/json"
@@ -55,8 +54,7 @@ def run():
             if not dates:
                 print(
                     "%s has no releases" % (baseurl + username + "/" + indexname),
-                    file=sys.stderr,
-                )
+                    file=sys.stderr)
                 date = datetime.datetime.now()
             else:
                 date = datetime.datetime(*max(dates))
@@ -69,5 +67,6 @@ def run():
             subprocess.check_call(["devpi", "index", "-y", "--delete", url])
 
 
-if __name__ == "__main__":
+
+if __name__ == '__main__':
     run()

scripts/set_core_version.py

@@ -1,9 +1,9 @@
 #!/usr/bin/env python3
 
-import json
 import os
-import pathlib
+import json
 import re
+import pathlib
 import subprocess
 from argparse import ArgumentParser
 
@@ -23,7 +23,7 @@ def read_toml_version(relpath):
     res = regex_matches(relpath, rex)
     if res is not None:
         return res.group(1)
-    raise ValueError(f"no version found in {relpath}")
+    raise ValueError("no version found in {}".format(relpath))
 
 
 def replace_toml_version(relpath, newversion):
@@ -34,8 +34,8 @@ def replace_toml_version(relpath, newversion):
         for line in open(str(p)):
             m = rex.match(line)
             if m is not None:
-                print(f"{relpath}: set version={newversion}")
-                f.write(f'version = "{newversion}"\n')
+                print("{}: set version={}".format(relpath, newversion))
+                f.write('version = "{}"\n'.format(newversion))
             else:
                 f.write(line)
     os.rename(tmp_path, str(p))
@@ -44,7 +44,7 @@ def replace_toml_version(relpath, newversion):
 def read_json_version(relpath):
     p = pathlib.Path(relpath)
     assert p.exists()
-    with open(p) as f:
+    with open(p, "r") as f:
         json_data = json.loads(f.read())
     return json_data["version"]
 
@@ -52,7 +52,7 @@ def read_json_version(relpath):
 def update_package_json(relpath, newversion):
     p = pathlib.Path(relpath)
     assert p.exists()
-    with open(p) as f:
+    with open(p, "r") as f:
         json_data = json.loads(f.read())
     json_data["version"] = newversion
     with open(p, "w") as f:
@@ -63,7 +63,7 @@ def main():
     parser = ArgumentParser(prog="set_core_version")
     parser.add_argument("newversion")
 
-    json_list = ["package.json", "deltachat-jsonrpc/typescript/package.json"]
+    json_list = ["package.json",  "deltachat-jsonrpc/typescript/package.json"]
     toml_list = [
         "Cargo.toml",
         "deltachat-ffi/Cargo.toml",
@@ -75,9 +75,9 @@ def main():
     except SystemExit:
         print()
         for x in toml_list:
-            print(f"{x}: {read_toml_version(x)}")
+            print("{}: {}".format(x, read_toml_version(x)))
         for x in json_list:
-            print(f"{x}: {read_json_version(x)}")
+            print("{}: {}".format(x, read_json_version(x)))
         print()
         raise SystemExit("need argument: new version, example: 1.25.0")
 
@@ -92,19 +92,19 @@ def main():
     if "alpha" not in newversion:
         for line in open("CHANGELOG.md"):
             ## 1.25.0
-            if line.startswith("## ") and line[2:].strip().startswith(newversion):
-                break
+            if line.startswith("## "):
+                if line[2:].strip().startswith(newversion):
+                    break
         else:
-            raise SystemExit(
-                f"CHANGELOG.md contains no entry for version: {newversion}"
-            )
+            raise SystemExit("CHANGELOG.md contains no entry for version: {}".format(newversion))
 
     for toml_filename in toml_list:
         replace_toml_version(toml_filename, newversion)
-
+    
     for json_filename in json_list:
         update_package_json(json_filename, newversion)
 
+
     print("running cargo check")
     subprocess.call(["cargo", "check"])
 
@@ -114,12 +114,13 @@ def main():
 
     print("after commit, on master make sure to: ")
     print("")
-    print(f"   git tag -a {newversion}")
-    print(f"   git push origin {newversion}")
-    print(f"   git tag -a py-{newversion}")
-    print(f"   git push origin py-{newversion}")
+    print("   git tag -a {}".format(newversion))
+    print("   git push origin {}".format(newversion))
+    print("   git tag -a py-{}".format(newversion))
+    print("   git push origin py-{}".format(newversion))
     print("")
 
 
 if __name__ == "__main__":
     main()
+

src/accounts.rs

@@ -509,6 +509,7 @@ impl AccountConfig {
 #[cfg(test)]
 mod tests {
     use super::*;
+
     use crate::stock_str::{self, StockMessage};
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]

src/aheader.rs

@@ -2,12 +2,11 @@
 //!
 //! Parse and create [Autocrypt-headers](https://autocrypt.org/en/latest/level1.html#the-autocrypt-header).
 
+use anyhow::{bail, Context as _, Error, Result};
 use std::collections::BTreeMap;
 use std::fmt;
 use std::str::FromStr;
 
-use anyhow::{bail, Context as _, Error, Result};
-
 use crate::key::{DcKey, SignedPublicKey};
 
 /// Possible values for encryption preference

src/authres.rs

@@ -355,6 +355,7 @@ mod tests {
     use tokio::io::AsyncReadExt;
 
     use super::*;
+
     use crate::aheader::EncryptPreference;
     use crate::e2ee;
     use crate::message;

src/blob.rs

@@ -499,15 +499,17 @@ fn encoded_img_exceeds_bytes(
 
 #[cfg(test)]
 mod tests {
-    use anyhow::Result;
     use fs::File;
+
+    use anyhow::Result;
     use image::{GenericImageView, Pixel};
 
-    use super::*;
     use crate::chat::{self, create_group_chat, ProtectionStatus};
     use crate::message::Message;
     use crate::test_utils::{self, TestContext};
 
+    use super::*;
+
     fn check_image_size(path: impl AsRef<Path>, width: u32, height: u32) -> image::DynamicImage {
         tokio::task::block_in_place(move || {
             let img = image::open(path).expect("failed to open image");

src/chat.rs

@@ -531,68 +531,20 @@ impl ChatId {
         Ok(())
     }
 
-    /// Unarchives a chat that is archived and not muted.
-    /// Needed after a message is added to a chat so that the chat gets a normal visibility again.
-    /// `msg_state` is the state of the message. Matters only for incoming messages currently. For
-    /// multiple outgoing messages the function may be called once with MessageState::Undefined.
-    /// Sending an appropriate event is up to the caller.
-    /// Also emits DC_EVENT_MSGS_CHANGED for DC_CHAT_ID_ARCHIVED_LINK when the number of archived
-    /// chats with unread messages increases (which is possible if the chat is muted).
-    pub async fn unarchive_if_not_muted(
-        self,
-        context: &Context,
-        msg_state: MessageState,
-    ) -> Result<()> {
-        if msg_state != MessageState::InFresh {
-            context
-                .sql
-                .execute(
-                    "UPDATE chats SET archived=0 WHERE id=? AND archived=1 \
-                AND NOT(muted_until=-1 OR muted_until>?)",
-                    paramsv![self, time()],
-                )
-                .await?;
-            return Ok(());
-        }
-        let chat = Chat::load_from_db(context, self).await?;
-        if chat.visibility != ChatVisibility::Archived {
-            return Ok(());
-        }
-        if chat.is_muted() {
-            let unread_cnt = context
-                .sql
-                .count(
-                    "SELECT COUNT(*)
-                FROM msgs
-                WHERE state=?
-                AND hidden=0
-                AND chat_id=?",
-                    paramsv![MessageState::InFresh, self],
-                )
-                .await?;
-            if unread_cnt == 1 {
-                // Added the first unread message in the chat.
-                context.emit_msgs_changed(DC_CHAT_ID_ARCHIVED_LINK, MsgId::new(0));
-            }
-            return Ok(());
-        }
+    // Unarchives a chat that is archived and not muted.
+    // Needed when a message is added to a chat so that the chat gets a normal visibility again.
+    // Sending an appropriate event is up to the caller.
+    pub async fn unarchive_if_not_muted(self, context: &Context) -> Result<()> {
         context
             .sql
-            .execute("UPDATE chats SET archived=0 WHERE id=?", paramsv![self])
+            .execute(
+                "UPDATE chats SET archived=0 WHERE id=? AND archived=1 AND NOT(muted_until=-1 OR muted_until>?)",
+                paramsv![self, time()],
+            )
             .await?;
         Ok(())
     }
 
-    /// Emits an appropriate event for a message. `important` is whether a notification should be
-    /// shown.
-    pub(crate) fn emit_msg_event(self, context: &Context, msg_id: MsgId, important: bool) {
-        if important {
-            context.emit_incoming_msg(self, msg_id);
-        } else {
-            context.emit_msgs_changed(self, msg_id);
-        }
-    }
-
     /// Deletes a chat.
     pub async fn delete(self, context: &Context) -> Result<()> {
         ensure!(
@@ -1363,8 +1315,6 @@ impl Chat {
         self.param.get_bool(Param::Unpromoted).unwrap_or_default()
     }
 
-    /// Returns whether the chat is promoted which means that a message has been
-    /// send to it and it not only exists on the users device.
     pub fn is_promoted(&self) -> bool {
         !self.is_unpromoted()
     }
@@ -2059,9 +2009,7 @@ async fn prepare_msg_common(
     msg.state = change_state_to;
 
     prepare_msg_blob(context, msg).await?;
-    if !msg.hidden {
-        chat_id.unarchive_if_not_muted(context, msg.state).await?;
-    }
+    chat_id.unarchive_if_not_muted(context).await?;
     msg.id = chat
         .prepare_msg_raw(
             context,
@@ -2857,7 +2805,6 @@ pub(crate) async fn remove_from_chat_contacts_table(
 }
 
 /// Adds a contact to the chat.
-/// If the group is promoted, also sends out a system message to all group members
 pub async fn add_contact_to_chat(
     context: &Context,
     chat_id: ChatId,
@@ -2879,7 +2826,7 @@ pub(crate) async fn add_contact_to_chat_ex(
 
     chat_id.reset_gossiped_timestamp(context).await?;
 
-    // this also makes sure, no contacts are added to special or normal chats
+    /*this also makes sure, not contacts are added to special or normal chats*/
     let mut chat = Chat::load_from_db(context, chat_id).await?;
     ensure!(
         chat.typ == Chattype::Group || chat.typ == Chattype::Broadcast,
@@ -2901,7 +2848,7 @@ pub(crate) async fn add_contact_to_chat_ex(
         context.emit_event(EventType::ErrorSelfNotInGroup(
             "Cannot add contact to group; self not in group.".into(),
         ));
-        bail!("can not add contact because the account is not part of the group/broadcast");
+        bail!("can not add contact because our account is not part of it");
     }
 
     if from_handshake && chat.param.get_int(Param::Unpromoted).unwrap_or_default() == 1 {
@@ -3254,9 +3201,7 @@ pub async fn forward_msgs(context: &Context, msg_ids: &[MsgId], chat_id: ChatId)
     let mut created_msgs: Vec<MsgId> = Vec::new();
     let mut curr_timestamp: i64;
 
-    chat_id
-        .unarchive_if_not_muted(context, MessageState::Undefined)
-        .await?;
+    chat_id.unarchive_if_not_muted(context).await?;
     if let Ok(mut chat) = Chat::load_from_db(context, chat_id).await {
         if let Some(reason) = chat.why_cant_send(context).await? {
             bail!("cannot send to {}: {}", chat_id, reason);
@@ -3459,6 +3404,7 @@ pub async fn add_device_msg_with_importance(
         let rfc724_mid = create_outgoing_rfc724_mid(None, "@device");
         msg.try_calc_and_set_dimensions(context).await.ok();
         prepare_msg_blob(context, msg).await?;
+        chat_id.unarchive_if_not_muted(context).await?;
 
         let timestamp_sent = create_smeared_timestamp(context).await;
 
@@ -3478,7 +3424,6 @@ pub async fn add_device_msg_with_importance(
             }
         }
 
-        let state = MessageState::InFresh;
         let row_id = context
             .sql
             .insert(
@@ -3502,7 +3447,7 @@ pub async fn add_device_msg_with_importance(
                     timestamp_sent,
                     timestamp_sent, // timestamp_sent equals timestamp_rcvd
                     msg.viewtype,
-                    state,
+                    MessageState::InFresh,
                     msg.text.as_ref().cloned().unwrap_or_default(),
                     msg.param.to_string(),
                     rfc724_mid,
@@ -3511,9 +3456,6 @@ pub async fn add_device_msg_with_importance(
             .await?;
 
         msg_id = MsgId::new(u32::try_from(row_id)?);
-        if !msg.hidden {
-            chat_id.unarchive_if_not_muted(context, state).await?;
-        }
     }
 
     if let Some(label) = label {
@@ -3527,7 +3469,11 @@ pub async fn add_device_msg_with_importance(
     }
 
     if !msg_id.is_unset() {
-        chat_id.emit_msg_event(context, msg_id, important);
+        if important {
+            context.emit_incoming_msg(chat_id, msg_id);
+        } else {
+            context.emit_msgs_changed(chat_id, msg_id);
+        }
     }
 
     Ok(msg_id)
@@ -3678,11 +3624,13 @@ pub(crate) async fn update_msg_text_and_timestamp(
 #[cfg(test)]
 mod tests {
     use super::*;
+
     use crate::chatlist::{get_archived_cnt, Chatlist};
     use crate::constants::{DC_GCL_ARCHIVED_ONLY, DC_GCL_NO_SPECIALS};
     use crate::contact::{Contact, ContactAddress};
     use crate::receive_imf::receive_imf;
-    use crate::test_utils::{TestContext, TestContextManager};
+
+    use crate::test_utils::TestContext;
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_chat_info() {
@@ -4077,45 +4025,6 @@ mod tests {
         Ok(())
     }
 
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_sync_member_list_on_rejoin() -> Result<()> {
-        let mut tcm = TestContextManager::new();
-        let alice = tcm.alice().await;
-
-        let bob_id = Contact::create(&alice, "", "bob@example.net").await?;
-        let claire_id = Contact::create(&alice, "", "claire@example.de").await?;
-
-        let alice_chat_id =
-            create_group_chat(&alice, ProtectionStatus::Unprotected, "foos").await?;
-        add_contact_to_chat(&alice, alice_chat_id, bob_id).await?;
-        add_contact_to_chat(&alice, alice_chat_id, claire_id).await?;
-
-        send_text_msg(&alice, alice_chat_id, "populate".to_string()).await?;
-        let add = alice.pop_sent_msg().await;
-        let bob = tcm.bob().await;
-        bob.recv_msg(&add).await;
-        let bob_chat_id = bob.get_last_msg().await.chat_id;
-        assert_eq!(get_chat_contacts(&bob, bob_chat_id).await?.len(), 3);
-
-        // remove bob from chat
-        remove_contact_from_chat(&alice, alice_chat_id, bob_id).await?;
-        let remove_bob = alice.pop_sent_msg().await;
-        bob.recv_msg(&remove_bob).await;
-
-        // remove any other member
-        remove_contact_from_chat(&alice, alice_chat_id, claire_id).await?;
-        alice.pop_sent_msg().await;
-
-        // readd bob
-        add_contact_to_chat(&alice, alice_chat_id, bob_id).await?;
-        let add2 = alice.pop_sent_msg().await;
-        bob.recv_msg(&add2).await;
-
-        // number of members in chat should have updated
-        assert_eq!(get_chat_contacts(&bob, bob_chat_id).await?.len(), 2);
-        Ok(())
-    }
-
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_leave_group() -> Result<()> {
         let alice = TestContext::new_alice().await;
@@ -4734,46 +4643,6 @@ mod tests {
         assert_eq!(chatlist, vec![chat_id3, chat_id2, chat_id1]);
     }
 
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_pinned_after_new_msgs() -> Result<()> {
-        let alice = TestContext::new_alice().await;
-        let bob = TestContext::new_bob().await;
-        let alice_chat_id = alice.create_chat(&bob).await.id;
-        let bob_chat_id = bob.create_chat(&alice).await.id;
-
-        assert!(alice_chat_id
-            .set_visibility(&alice, ChatVisibility::Pinned)
-            .await
-            .is_ok());
-        assert_eq!(
-            Chat::load_from_db(&alice, alice_chat_id)
-                .await?
-                .get_visibility(),
-            ChatVisibility::Pinned,
-        );
-
-        send_text_msg(&alice, alice_chat_id, "hi!".into()).await?;
-        assert_eq!(
-            Chat::load_from_db(&alice, alice_chat_id)
-                .await?
-                .get_visibility(),
-            ChatVisibility::Pinned,
-        );
-
-        let mut msg = Message::new(Viewtype::Text);
-        msg.set_text(Some("hi!".into()));
-        let sent_msg = bob.send_msg(bob_chat_id, &mut msg).await;
-        let msg = alice.recv_msg(&sent_msg).await;
-        assert_eq!(msg.chat_id, alice_chat_id);
-        assert_eq!(
-            Chat::load_from_db(&alice, alice_chat_id)
-                .await?
-                .get_visibility(),
-            ChatVisibility::Pinned,
-        );
-        Ok(())
-    }
-
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_set_chat_name() {
         let t = TestContext::new().await;

src/chatlist.rs

@@ -365,6 +365,7 @@ pub async fn get_archived_cnt(context: &Context) -> Result<usize> {
 #[cfg(test)]
 mod tests {
     use super::*;
+
     use crate::chat::{create_group_chat, get_chat_contacts, ProtectionStatus};
     use crate::message::Viewtype;
     use crate::receive_imf::receive_imf;

src/config.rs

@@ -440,15 +440,16 @@ fn get_config_keys_string() -> String {
 
 #[cfg(test)]
 mod tests {
+    use super::*;
+
     use std::str::FromStr;
     use std::string::ToString;
 
-    use num_traits::FromPrimitive;
-
-    use super::*;
     use crate::constants;
     use crate::test_utils::TestContext;
 
+    use num_traits::FromPrimitive;
+
     #[test]
     fn test_to_string() {
         assert_eq!(Config::MailServer.to_string(), "mail_server");

src/configure.rs

@@ -6,12 +6,9 @@ mod read_url;
 mod server_params;
 
 use anyhow::{bail, ensure, Context as _, Result};
-use auto_mozilla::moz_autoconfigure;
-use auto_outlook::outlk_autodiscover;
 use futures::FutureExt;
 use futures_lite::FutureExt as _;
 use percent_encoding::{utf8_percent_encode, NON_ALPHANUMERIC};
-use server_params::{expand_param_vector, ServerParams};
 use tokio::task;
 
 use crate::config::Config;
@@ -31,6 +28,10 @@ use crate::stock_str;
 use crate::tools::{time, EmailAddress};
 use crate::{chat, e2ee, provider};
 
+use auto_mozilla::moz_autoconfigure;
+use auto_outlook::outlk_autodiscover;
+use server_params::{expand_param_vector, ServerParams};
+
 macro_rules! progress {
     ($context:tt, $progress:expr, $comment:expr) => {
         assert!(
@@ -564,18 +565,13 @@ async fn try_imap_one_param(
     provider_strict_tls: bool,
 ) -> Result<Imap, ConfigurationError> {
     let inf = format!(
-        "imap: {}@{}:{} security={} certificate_checks={} oauth2={} socks5_config={}",
+        "imap: {}@{}:{} security={} certificate_checks={} oauth2={}",
         param.user,
         param.server,
         param.port,
         param.security,
         param.certificate_checks,
-        param.oauth2,
-        if let Some(socks5_config) = socks5_config {
-            socks5_config.to_string()
-        } else {
-            "None".to_string()
-        }
+        param.oauth2
     );
     info!(context, "Trying: {}", inf);
 
@@ -665,7 +661,6 @@ async fn nicer_configuration_error(context: &Context, errors: Vec<ConfigurationE
 
     if errors.iter().all(|e| {
         e.msg.to_lowercase().contains("could not resolve")
-            || e.msg.to_lowercase().contains("no dns resolution results")
             || e.msg
                 .to_lowercase()
                 .contains("temporary failure in name resolution")

src/configure/auto_mozilla.rs

@@ -1,17 +1,18 @@
 //! # Thunderbird's Autoconfiguration implementation
 //!
 //! Documentation: <https://developer.mozilla.org/en-US/docs/Mozilla/Thunderbird/Autoconfiguration>
+use quick_xml::events::{BytesStart, Event};
+
 use std::io::BufRead;
 use std::str::FromStr;
 
-use quick_xml::events::{BytesStart, Event};
-
-use super::read_url::read_url;
-use super::{Error, ServerParams};
 use crate::context::Context;
 use crate::login_param::LoginParam;
 use crate::provider::{Protocol, Socket};
 
+use super::read_url::read_url;
+use super::{Error, ServerParams};
+
 #[derive(Debug)]
 struct Server {
     pub typ: String,

src/configure/auto_outlook.rs

@@ -3,14 +3,15 @@
 //! This module implements autoconfiguration via POX (Plain Old XML) interface to Autodiscover
 //! Service. Newer SOAP interface, introduced in Exchange 2010, is not used.
 
+use quick_xml::events::Event;
+
 use std::io::BufRead;
 
-use quick_xml::events::Event;
+use crate::context::Context;
+use crate::provider::{Protocol, Socket};
 
 use super::read_url::read_url;
 use super::{Error, ServerParams};
-use crate::context::Context;
-use crate::provider::{Protocol, Socket};
 
 /// Result of parsing a single `Protocol` tag.
 ///

src/contact.rs

@@ -1612,9 +1612,6 @@ impl RecentlySeenLoop {
                             context,
                             "Error receiving an interruption in recently seen loop: {}", err
                         );
-                        // Maybe the sender side is closed.
-                        // Terminate the loop to avoid looping indefinitely.
-                        return;
                     }
                     Ok(Ok(RecentlySeenInterrupt {
                         contact_id,
@@ -1656,6 +1653,7 @@ impl RecentlySeenLoop {
 #[cfg(test)]
 mod tests {
     use super::*;
+
     use crate::chat::{get_chat_contacts, send_text_msg, Chat};
     use crate::chatlist::Chatlist;
     use crate::receive_imf::receive_imf;
@@ -2630,27 +2628,4 @@ Hi."#;
 
         Ok(())
     }
-
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_verified_by_none() -> Result<()> {
-        let mut tcm = TestContextManager::new();
-        let alice = tcm.alice().await;
-        let bob = tcm.bob().await;
-
-        let contact_id = Contact::create(&alice, "Bob", "bob@example.net").await?;
-        let contact = Contact::get_by_id(&alice, contact_id).await?;
-        assert!(contact.get_verifier_addr(&alice).await?.is_none());
-        assert!(contact.get_verifier_id(&alice).await?.is_none());
-
-        // Receive a message from Bob to create a peerstate.
-        let chat = bob.create_chat(&alice).await;
-        let sent_msg = bob.send_text(chat.id, "moin").await;
-        alice.recv_msg(&sent_msg).await;
-
-        let contact = Contact::get_by_id(&alice, contact_id).await?;
-        assert!(contact.get_verifier_addr(&alice).await?.is_none());
-        assert!(contact.get_verifier_id(&alice).await?.is_none());
-
-        Ok(())
-    }
 }

src/context.rs

@@ -861,13 +861,8 @@ pub fn get_version_str() -> &'static str {
 
 #[cfg(test)]
 mod tests {
-    use std::time::Duration;
-
-    use anyhow::Context as _;
-    use strum::IntoEnumIterator;
-    use tempfile::tempdir;
-
     use super::*;
+
     use crate::chat::{
         get_chat_contacts, get_chat_msgs, send_msg, set_muted, Chat, ChatId, MuteDuration,
     };
@@ -878,6 +873,10 @@ mod tests {
     use crate::receive_imf::receive_imf;
     use crate::test_utils::TestContext;
     use crate::tools::create_outgoing_rfc724_mid;
+    use anyhow::Context as _;
+    use std::time::Duration;
+    use strum::IntoEnumIterator;
+    use tempfile::tempdir;
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_wrong_db() -> Result<()> {

src/decrypt.rs

@@ -344,10 +344,11 @@ pub(crate) async fn get_autocrypt_peerstate(
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use crate::receive_imf::receive_imf;
     use crate::test_utils::TestContext;
 
+    use super::*;
+
     #[test]
     fn test_has_decrypted_pgp_armor() {
         let data = b" -----BEGIN PGP MESSAGE-----";

src/download.rs

@@ -1,11 +1,9 @@
 //! # Download large messages manually.
 
-use std::cmp::max;
-use std::collections::BTreeMap;
-
 use anyhow::{anyhow, Result};
 use deltachat_derive::{FromSql, ToSql};
 use serde::{Deserialize, Serialize};
+use std::collections::BTreeMap;
 
 use crate::config::Config;
 use crate::context::Context;
@@ -16,6 +14,7 @@ use crate::mimeparser::{MimeMessage, Part};
 use crate::param::Params;
 use crate::tools::time;
 use crate::{job_try, stock_str, EventType};
+use std::cmp::max;
 
 /// Download limits should not be used below `MIN_DOWNLOAD_LIMIT`.
 ///
@@ -265,13 +264,14 @@ impl MimeMessage {
 mod tests {
     use num_traits::FromPrimitive;
 
-    use super::*;
     use crate::chat::{get_chat_msgs, send_msg};
     use crate::ephemeral::Timer;
     use crate::message::Viewtype;
     use crate::receive_imf::receive_imf_inner;
     use crate::test_utils::TestContext;
 
+    use super::*;
+
     #[test]
     fn test_downloadstate_values() {
         // values may be written to disk and must not change

src/e2ee.rs

@@ -144,12 +144,13 @@ pub async fn ensure_secret_key_exists(context: &Context) -> Result<String> {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use crate::chat;
     use crate::message::{Message, Viewtype};
     use crate::param::Param;
     use crate::test_utils::{bob_keypair, TestContext};
 
+    use super::*;
+
     mod ensure_secret_key_exists {
         use super::*;
 

src/ephemeral.rs

@@ -64,7 +64,6 @@
 
 #![allow(missing_docs)]
 
-use std::cmp::max;
 use std::convert::{TryFrom, TryInto};
 use std::num::ParseIntError;
 use std::str::FromStr;
@@ -87,6 +86,7 @@ use crate::mimeparser::SystemMessage;
 use crate::sql::{self, params_iter};
 use crate::stock_str;
 use crate::tools::{duration_to_str, time};
+use std::cmp::max;
 
 #[derive(Debug, PartialEq, Eq, Copy, Clone, Serialize, Deserialize)]
 pub enum Timer {

src/events.rs

@@ -316,8 +316,14 @@ pub enum EventType {
         status_update_serial: StatusUpdateSerial,
     },
 
-    /// Inform that a message containing a webxdc instance has been deleted
+    /// Informs that a message containing a webxdc instance has been deleted
     WebxdcInstanceDeleted {
         msg_id: MsgId,
     },
+
+    /// Informs that the webxdc changed its update sending state
+    WebxdcUpdateStateChanged {
+        msg_id: MsgId,
+        has_pending_updates: bool,
+    },
 }

src/html.rs

@@ -7,14 +7,12 @@
 //! `MsgId.get_html()` will return HTML -
 //! this allows nice quoting, handling linebreaks properly etc.
 
+use futures::future::FutureExt;
 use std::future::Future;
 use std::pin::Pin;
 
 use anyhow::{Context as _, Result};
-use futures::future::FutureExt;
 use lettre_email::mime::{self, Mime};
-use lettre_email::PartBuilder;
-use mailparse::ParsedContentType;
 
 use crate::headerdef::{HeaderDef, HeaderDefMap};
 use crate::message::{Message, MsgId};
@@ -22,6 +20,8 @@ use crate::mimeparser::parse_message_id;
 use crate::param::Param::SendHtml;
 use crate::plaintext::PlainText;
 use crate::{context::Context, message};
+use lettre_email::PartBuilder;
+use mailparse::ParsedContentType;
 
 impl Message {
     /// Check if the message can be retrieved as HTML.

src/http.rs

@@ -1,8 +1,7 @@
 //! # HTTP module.
 
-use std::time::Duration;
-
 use anyhow::Result;
+use std::time::Duration;
 
 const HTTP_TIMEOUT: Duration = Duration::from_secs(30);
 

src/imap.rs

@@ -308,7 +308,6 @@ impl Imap {
             if let Some(socks5_config) = &config.socks5_config {
                 if config.lp.security == Socket::Starttls {
                     Client::connect_starttls_socks5(
-                        context,
                         imap_server,
                         imap_port,
                         socks5_config.clone(),
@@ -316,18 +315,13 @@ impl Imap {
                     )
                     .await
                 } else {
-                    Client::connect_insecure_socks5(
-                        context,
-                        imap_server,
-                        imap_port,
-                        socks5_config.clone(),
-                    )
-                    .await
+                    Client::connect_insecure_socks5((imap_server, imap_port), socks5_config.clone())
+                        .await
                 }
             } else if config.lp.security == Socket::Starttls {
-                Client::connect_starttls(context, imap_server, imap_port, config.strict_tls).await
+                Client::connect_starttls(imap_server, imap_port, config.strict_tls).await
             } else {
-                Client::connect_insecure(context, imap_server, imap_port).await
+                Client::connect_insecure((imap_server, imap_port)).await
             }
         } else {
             let config = &self.config;
@@ -336,7 +330,6 @@ impl Imap {
 
             if let Some(socks5_config) = &config.socks5_config {
                 Client::connect_secure_socks5(
-                    context,
                     imap_server,
                     imap_port,
                     config.strict_tls,
@@ -344,7 +337,7 @@ impl Imap {
                 )
                 .await
             } else {
-                Client::connect_secure(context, imap_server, imap_port, config.strict_tls).await
+                Client::connect_secure(imap_server, imap_port, config.strict_tls).await
             }
         };
 

src/imap/client.rs

@@ -4,18 +4,21 @@ use std::{
 };
 
 use anyhow::{Context as _, Result};
+
 use async_imap::Client as ImapClient;
 use async_imap::Session as ImapSession;
+
 use tokio::io::BufWriter;
+use tokio::net::ToSocketAddrs;
 
 use super::capabilities::Capabilities;
 use super::session::Session;
-use super::session::SessionStream;
-use crate::context::Context;
 use crate::login_param::build_tls;
 use crate::net::connect_tcp;
 use crate::socks::Socks5Config;
 
+use super::session::SessionStream;
+
 /// IMAP write and read timeout in seconds.
 pub(crate) const IMAP_TIMEOUT: Duration = Duration::from_secs(30);
 
@@ -88,13 +91,8 @@ impl Client {
         Ok(Session::new(session, capabilities))
     }
 
-    pub async fn connect_secure(
-        context: &Context,
-        hostname: &str,
-        port: u16,
-        strict_tls: bool,
-    ) -> Result<Self> {
-        let tcp_stream = connect_tcp(context, hostname, port, IMAP_TIMEOUT, strict_tls).await?;
+    pub async fn connect_secure(hostname: &str, port: u16, strict_tls: bool) -> Result<Self> {
+        let tcp_stream = connect_tcp((hostname, port), IMAP_TIMEOUT).await?;
         let tls = build_tls(strict_tls);
         let tls_stream = tls.connect(hostname, tcp_stream).await?;
         let buffered_stream = BufWriter::new(tls_stream);
@@ -109,8 +107,8 @@ impl Client {
         Ok(Client { inner: client })
     }
 
-    pub async fn connect_insecure(context: &Context, hostname: &str, port: u16) -> Result<Self> {
-        let tcp_stream = connect_tcp(context, hostname, port, IMAP_TIMEOUT, false).await?;
+    pub async fn connect_insecure(addr: impl ToSocketAddrs) -> Result<Self> {
+        let tcp_stream = connect_tcp(addr, IMAP_TIMEOUT).await?;
         let buffered_stream = BufWriter::new(tcp_stream);
         let session_stream: Box<dyn SessionStream> = Box::new(buffered_stream);
         let mut client = ImapClient::new(session_stream);
@@ -122,16 +120,12 @@ impl Client {
         Ok(Client { inner: client })
     }
 
-    pub async fn connect_starttls(
-        context: &Context,
-        hostname: &str,
-        port: u16,
-        strict_tls: bool,
-    ) -> Result<Self> {
-        let tcp_stream = connect_tcp(context, hostname, port, IMAP_TIMEOUT, strict_tls).await?;
+    pub async fn connect_starttls(hostname: &str, port: u16, strict_tls: bool) -> Result<Self> {
+        let tcp_stream = connect_tcp((hostname, port), IMAP_TIMEOUT).await?;
 
         // Run STARTTLS command and convert the client back into a stream.
-        let mut client = ImapClient::new(tcp_stream);
+        let session_stream: Box<dyn SessionStream> = Box::new(tcp_stream);
+        let mut client = ImapClient::new(session_stream);
         let _greeting = client
             .read_response()
             .await
@@ -156,15 +150,12 @@ impl Client {
     }
 
     pub async fn connect_secure_socks5(
-        context: &Context,
         domain: &str,
         port: u16,
         strict_tls: bool,
         socks5_config: Socks5Config,
     ) -> Result<Self> {
-        let socks5_stream = socks5_config
-            .connect(context, domain, port, IMAP_TIMEOUT, strict_tls)
-            .await?;
+        let socks5_stream = socks5_config.connect((domain, port), IMAP_TIMEOUT).await?;
         let tls = build_tls(strict_tls);
         let tls_stream = tls.connect(domain, socks5_stream).await?;
         let buffered_stream = BufWriter::new(tls_stream);
@@ -179,14 +170,10 @@ impl Client {
     }
 
     pub async fn connect_insecure_socks5(
-        context: &Context,
-        domain: &str,
-        port: u16,
+        target_addr: impl ToSocketAddrs,
         socks5_config: Socks5Config,
     ) -> Result<Self> {
-        let socks5_stream = socks5_config
-            .connect(context, domain, port, IMAP_TIMEOUT, false)
-            .await?;
+        let socks5_stream = socks5_config.connect(target_addr, IMAP_TIMEOUT).await?;
         let buffered_stream = BufWriter::new(socks5_stream);
         let session_stream: Box<dyn SessionStream> = Box::new(buffered_stream);
         let mut client = ImapClient::new(session_stream);
@@ -199,18 +186,18 @@ impl Client {
     }
 
     pub async fn connect_starttls_socks5(
-        context: &Context,
         hostname: &str,
         port: u16,
         socks5_config: Socks5Config,
         strict_tls: bool,
     ) -> Result<Self> {
         let socks5_stream = socks5_config
-            .connect(context, hostname, port, IMAP_TIMEOUT, strict_tls)
+            .connect((hostname, port), IMAP_TIMEOUT)
             .await?;
 
         // Run STARTTLS command and convert the client back into a stream.
-        let mut client = ImapClient::new(socks5_stream);
+        let session_stream: Box<dyn SessionStream> = Box::new(socks5_stream);
+        let mut client = ImapClient::new(session_stream);
         let _greeting = client
             .read_response()
             .await

src/imap/idle.rs

@@ -1,12 +1,12 @@
-use std::time::{Duration, SystemTime};
+use super::Imap;
 
 use anyhow::{bail, Context as _, Result};
 use async_channel::Receiver;
 use async_imap::extensions::idle::IdleResponse;
 use futures_lite::FutureExt;
+use std::time::{Duration, SystemTime};
 
 use super::session::Session;
-use super::Imap;
 use crate::imap::client::IMAP_TIMEOUT;
 use crate::{context::Context, scheduler::InterruptInfo};
 

src/imap/scan_folders.rs

@@ -3,12 +3,13 @@ use std::{collections::BTreeMap, time::Instant};
 use anyhow::{Context as _, Result};
 use futures::stream::StreamExt;
 
-use super::{get_folder_meaning, get_folder_meaning_by_name};
 use crate::config::Config;
 use crate::imap::Imap;
 use crate::log::LogExt;
 use crate::{context::Context, imap::FolderMeaning};
 
+use super::{get_folder_meaning, get_folder_meaning_by_name};
+
 impl Imap {
     /// Returns true if folders were scanned, false if scanning was postponed.
     pub(crate) async fn scan_folders(&mut self, context: &Context) -> Result<bool> {

src/imap/select_folder.rs

@@ -1,7 +1,7 @@
-use anyhow::Context as _;
-
 use super::session::Session as ImapSession;
+
 use crate::context::Context;
+use anyhow::Context as _;
 
 type Result<T> = std::result::Result<T, Error>;
 

src/imex.rs

@@ -769,13 +769,14 @@ where
 
 #[cfg(test)]
 mod tests {
-    use ::pgp::armor::BlockType;
-
     use super::*;
+
     use crate::pgp::{split_armored_data, HEADER_AUTOCRYPT, HEADER_SETUPCODE};
     use crate::stock_str::StockMessage;
     use crate::test_utils::{alice_keypair, TestContext};
 
+    use ::pgp::armor::BlockType;
+
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_render_setup_file() {
         let t = TestContext::new_alice().await;

src/job.rs

@@ -424,6 +424,7 @@ LIMIT 1;
 #[cfg(test)]
 mod tests {
     use super::*;
+
     use crate::test_utils::TestContext;
 
     async fn insert_job(context: &Context, foreign_id: i64, valid: bool) {

src/key.rs

@@ -11,7 +11,6 @@ use anyhow::{ensure, Context as _, Result};
 use futures::Future;
 use num_traits::FromPrimitive;
 use pgp::composed::Deserializable;
-pub use pgp::composed::{SignedPublicKey, SignedSecretKey};
 use pgp::ser::Serialize;
 use pgp::types::{KeyTrait, SecretKeyTrait};
 use tokio::runtime::Handle;
@@ -19,9 +18,11 @@ use tokio::runtime::Handle;
 use crate::config::Config;
 use crate::constants::KeyGenType;
 use crate::context::Context;
+use crate::tools::{time, EmailAddress};
+
 // Re-export key types
 pub use crate::pgp::KeyPair;
-use crate::tools::{time, EmailAddress};
+pub use pgp::composed::{SignedPublicKey, SignedSecretKey};
 
 /// Convenience trait for working with keys.
 ///
@@ -389,13 +390,12 @@ impl std::str::FromStr for Fingerprint {
 
 #[cfg(test)]
 mod tests {
-    use std::sync::Arc;
-
-    use once_cell::sync::Lazy;
-
     use super::*;
     use crate::test_utils::{alice_keypair, TestContext};
 
+    use once_cell::sync::Lazy;
+    use std::sync::Arc;
+
     static KEYPAIR: Lazy<KeyPair> = Lazy::new(alice_keypair);
 
     #[test]

src/log.rs

@@ -155,9 +155,8 @@ impl<T, E: std::fmt::Display> LogExt<T, E> for Result<T, E> {
 
 #[cfg(test)]
 mod tests {
-    use anyhow::Result;
-
     use crate::test_utils::TestContext;
+    use anyhow::Result;
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_get_last_error() -> Result<()> {

src/login_param.rs

@@ -332,6 +332,7 @@ pub fn build_tls(strict_tls: bool) -> async_native_tls::TlsConnector {
 #[cfg(test)]
 mod tests {
     use super::*;
+
     use crate::test_utils::TestContext;
 
     #[test]

src/message.rs

@@ -1982,13 +1982,14 @@ impl Viewtype {
 mod tests {
     use num_traits::FromPrimitive;
 
-    use super::*;
     use crate::chat::{marknoticed_chat, ChatItem};
     use crate::chatlist::Chatlist;
     use crate::receive_imf::receive_imf;
     use crate::test_utils as test;
     use crate::test_utils::{TestContext, TestContextManager};
 
+    use super::*;
+
     #[test]
     fn test_guess_msgtype_from_suffix() {
         assert_eq!(

src/mimefactory.rs

@@ -1508,7 +1508,6 @@ fn maybe_encode_words(words: &str) -> String {
 mod tests {
     use mailparse::{addrparse_header, MailHeaderMap};
 
-    use super::*;
     use crate::chat::ChatId;
     use crate::chat::{
         self, add_contact_to_chat, create_group_chat, remove_contact_from_chat, send_text_msg,
@@ -1519,6 +1518,8 @@ mod tests {
     use crate::mimeparser::MimeMessage;
     use crate::receive_imf::receive_imf;
     use crate::test_utils::{get_chat_msg, TestContext};
+
+    use super::*;
     #[test]
     fn test_render_email_address() {
         let display_name = "ä space";

src/mimeparser.rs

@@ -57,8 +57,6 @@ pub struct MimeMessage {
     /// Whether the From address was repeated in the signed part
     /// (and we know that the signer intended to send from this address)
     pub from_is_signed: bool,
-    /// The List-Post address is only set for mailing lists. Users can send
-    /// messages to this address to post them to the list.
     pub list_post: Option<String>,
     pub chat_disposition_notification_to: Option<SingleInfo>,
     pub decryption_info: DecryptionInfo,
@@ -723,8 +721,6 @@ impl MimeMessage {
         !self.signatures.is_empty()
     }
 
-    /// Returns whether the email contains a `chat-version` header.
-    /// This indicates that the email is a DC-email.
     pub(crate) fn has_chat_version(&self) -> bool {
         self.header.contains_key("chat-version")
     }
@@ -1957,8 +1953,6 @@ where
 mod tests {
     #![allow(clippy::indexing_slicing)]
 
-    use mailparse::ParsedMail;
-
     use super::*;
     use crate::{
         chatlist::Chatlist,
@@ -1968,6 +1962,7 @@ mod tests {
         receive_imf::receive_imf,
         test_utils::TestContext,
     };
+    use mailparse::ParsedMail;
 
     impl AvatarAction {
         pub fn is_change(&self) -> bool {

src/net.rs

@@ -1,180 +1,25 @@
 ///! # Common network utilities.
-use std::net::{IpAddr, SocketAddr};
 use std::pin::Pin;
-use std::str::FromStr;
 use std::time::Duration;
 
-use anyhow::{Context as _, Error, Result};
-use tokio::net::{lookup_host, TcpStream};
+use anyhow::{Context as _, Result};
+use tokio::net::{TcpStream, ToSocketAddrs};
 use tokio::time::timeout;
 use tokio_io_timeout::TimeoutStream;
 
-use crate::context::Context;
-use crate::tools::time;
-
-async fn connect_tcp_inner(addr: SocketAddr, timeout_val: Duration) -> Result<TcpStream> {
-    let tcp_stream = timeout(timeout_val, TcpStream::connect(addr))
-        .await
-        .context("connection timeout")?
-        .context("connection failure")?;
-    Ok(tcp_stream)
-}
-
-async fn lookup_host_with_timeout(
-    hostname: &str,
-    port: u16,
-    timeout_val: Duration,
-) -> Result<Vec<SocketAddr>> {
-    let res = timeout(timeout_val, lookup_host((hostname, port)))
-        .await
-        .context("DNS lookup timeout")?
-        .context("DNS lookup failure")?;
-    Ok(res.collect())
-}
-
-/// Looks up hostname and port using DNS and updates the address resolution cache.
-///
-/// If `load_cache` is true, appends cached results not older than 30 days to the end.
-async fn lookup_host_with_cache(
-    context: &Context,
-    hostname: &str,
-    port: u16,
-    timeout_val: Duration,
-    load_cache: bool,
-) -> Result<Vec<SocketAddr>> {
-    let now = time();
-    let mut resolved_addrs = match lookup_host_with_timeout(hostname, port, timeout_val).await {
-        Ok(res) => res,
-        Err(err) => {
-            warn!(
-                context,
-                "DNS resolution for {}:{} failed: {:#}.", hostname, port, err
-            );
-            Vec::new()
-        }
-    };
-
-    for addr in resolved_addrs.iter() {
-        let ip_string = addr.ip().to_string();
-        if ip_string == hostname {
-            // IP address resolved into itself, not interesting to cache.
-            continue;
-        }
-
-        info!(context, "Resolved {}:{} into {}.", hostname, port, &addr);
-
-        // Update the cache.
-        context
-            .sql
-            .execute(
-                "INSERT INTO dns_cache
-                 (hostname, address, timestamp)
-                 VALUES (?, ?, ?)
-                 ON CONFLICT (hostname, address)
-                 DO UPDATE SET timestamp=excluded.timestamp",
-                paramsv![hostname, ip_string, now],
-            )
-            .await?;
-    }
-
-    if load_cache {
-        for cached_address in context
-            .sql
-            .query_map(
-                "SELECT address
-                 FROM dns_cache
-                 WHERE hostname = ?
-                 AND ? < timestamp + 30 * 24 * 3600
-                 ORDER BY timestamp DESC",
-                paramsv![hostname, now],
-                |row| {
-                    let address: String = row.get(0)?;
-                    Ok(address)
-                },
-                |rows| {
-                    rows.collect::<std::result::Result<Vec<_>, _>>()
-                        .map_err(Into::into)
-                },
-            )
-            .await?
-        {
-            match IpAddr::from_str(&cached_address) {
-                Ok(ip_addr) => {
-                    let addr = SocketAddr::new(ip_addr, port);
-                    if !resolved_addrs.contains(&addr) {
-                        resolved_addrs.push(addr);
-                    }
-                }
-                Err(err) => {
-                    warn!(
-                        context,
-                        "Failed to parse cached address {:?}: {:#}.", cached_address, err
-                    );
-                }
-            }
-        }
-    }
-
-    Ok(resolved_addrs)
-}
-
 /// Returns a TCP connection stream with read/write timeouts set
 /// and Nagle's algorithm disabled with `TCP_NODELAY`.
 ///
 /// `TCP_NODELAY` ensures writing to the stream always results in immediate sending of the packet
 /// to the network, which is important to reduce the latency of interactive protocols such as IMAP.
-///
-/// If `load_cache` is true, may use cached DNS results.
-/// Because the cache may be poisoned with incorrect results by networks hijacking DNS requests,
-/// this option should only be used when connection is authenticated,
-/// for example using TLS.
-/// If TLS is not used or invalid TLS certificates are allowed,
-/// this option should be disabled.
 pub(crate) async fn connect_tcp(
-    context: &Context,
-    host: &str,
-    port: u16,
+    addr: impl ToSocketAddrs,
     timeout_val: Duration,
-    load_cache: bool,
 ) -> Result<Pin<Box<TimeoutStream<TcpStream>>>> {
-    let mut tcp_stream = None;
-    let mut last_error = None;
-
-    for resolved_addr in
-        lookup_host_with_cache(context, host, port, timeout_val, load_cache).await?
-    {
-        match connect_tcp_inner(resolved_addr, timeout_val).await {
-            Ok(stream) => {
-                tcp_stream = Some(stream);
-
-                // Maximize priority of this cached entry.
-                context
-                    .sql
-                    .execute(
-                        "UPDATE dns_cache
-                         SET timestamp = ?
-                         WHERE address = ?",
-                        paramsv![time(), resolved_addr.ip().to_string()],
-                    )
-                    .await?;
-                break;
-            }
-            Err(err) => {
-                warn!(
-                    context,
-                    "Failed to connect to {}: {:#}.", resolved_addr, err
-                );
-                last_error = Some(err);
-            }
-        }
-    }
-
-    let tcp_stream = match tcp_stream {
-        Some(tcp_stream) => tcp_stream,
-        None => {
-            return Err(last_error.unwrap_or_else(|| Error::msg("no DNS resolution results")));
-        }
-    };
+    let tcp_stream = timeout(timeout_val, TcpStream::connect(addr))
+        .await
+        .context("connection timeout")?
+        .context("connection failure")?;
 
     // Disable Nagle's algorithm.
     tcp_stream.set_nodelay(true)?;

src/oauth2.rs

@@ -352,6 +352,7 @@ fn normalize_addr(addr: &str) -> &str {
 #[cfg(test)]
 mod tests {
     use super::*;
+
     use crate::test_utils::TestContext;
 
     #[test]

src/param.rs

@@ -435,13 +435,14 @@ impl<'a> ParamsFile<'a> {
 
 #[cfg(test)]
 mod tests {
+    use super::*;
+
     use std::path::Path;
     use std::str::FromStr;
 
     use anyhow::Result;
     use tokio::fs;
 
-    use super::*;
     use crate::test_utils::TestContext;
 
     #[test]

src/peerstate.rs

@@ -3,9 +3,7 @@
 #![allow(missing_docs)]
 
 use std::collections::HashSet;
-
-use anyhow::{Context as _, Error, Result};
-use num_traits::FromPrimitive;
+use std::fmt;
 
 use crate::aheader::{Aheader, EncryptPreference};
 use crate::chat::{self, Chat};
@@ -19,6 +17,8 @@ use crate::message::Message;
 use crate::mimeparser::SystemMessage;
 use crate::sql::Sql;
 use crate::stock_str;
+use anyhow::{Context as _, Error, Result};
+use num_traits::FromPrimitive;
 
 #[derive(Debug)]
 pub enum PeerstateKeyType {
@@ -35,7 +35,6 @@ pub enum PeerstateVerifiedStatus {
 }
 
 /// Peerstate represents the state of an Autocrypt peer.
-#[derive(Debug, PartialEq, Eq)]
 pub struct Peerstate {
     pub addr: String,
     pub last_seen: i64,
@@ -53,6 +52,44 @@ pub struct Peerstate {
     pub verifier: Option<String>,
 }
 
+impl PartialEq for Peerstate {
+    fn eq(&self, other: &Peerstate) -> bool {
+        self.addr == other.addr
+            && self.last_seen == other.last_seen
+            && self.last_seen_autocrypt == other.last_seen_autocrypt
+            && self.prefer_encrypt == other.prefer_encrypt
+            && self.public_key == other.public_key
+            && self.public_key_fingerprint == other.public_key_fingerprint
+            && self.gossip_key == other.gossip_key
+            && self.gossip_timestamp == other.gossip_timestamp
+            && self.gossip_key_fingerprint == other.gossip_key_fingerprint
+            && self.verified_key == other.verified_key
+            && self.verified_key_fingerprint == other.verified_key_fingerprint
+            && self.fingerprint_changed == other.fingerprint_changed
+    }
+}
+
+impl Eq for Peerstate {}
+
+impl fmt::Debug for Peerstate {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_struct("Peerstate")
+            .field("addr", &self.addr)
+            .field("last_seen", &self.last_seen)
+            .field("last_seen_autocrypt", &self.last_seen_autocrypt)
+            .field("prefer_encrypt", &self.prefer_encrypt)
+            .field("public_key", &self.public_key)
+            .field("public_key_fingerprint", &self.public_key_fingerprint)
+            .field("gossip_key", &self.gossip_key)
+            .field("gossip_timestamp", &self.gossip_timestamp)
+            .field("gossip_key_fingerprint", &self.gossip_key_fingerprint)
+            .field("verified_key", &self.verified_key)
+            .field("verified_key_fingerprint", &self.verified_key_fingerprint)
+            .field("fingerprint_changed", &self.fingerprint_changed)
+            .finish()
+    }
+}
+
 impl Peerstate {
     pub fn from_header(header: &Aheader, message_time: i64) -> Self {
         Peerstate {
@@ -186,10 +223,7 @@ impl Peerstate {
                         .transpose()
                         .unwrap_or_default(),
                     fingerprint_changed: false,
-                    verifier: {
-                        let verifier: Option<String> = row.get("verifier")?;
-                        verifier.filter(|verifier| !verifier.is_empty())
-                    },
+                    verifier: row.get("verifier")?,
                 };
 
                 Ok(res)
@@ -421,7 +455,7 @@ impl Peerstate {
                 self.verified_key.as_ref().map(|k| k.to_bytes()),
                 self.verified_key_fingerprint.as_ref().map(|fp| fp.hex()),
                 self.addr,
-                self.verifier.as_deref().unwrap_or(""),
+                self.verifier,
             ],
         )
         .await?;

src/pgp.rs

@@ -382,11 +382,10 @@ pub async fn symm_decrypt<T: std::io::Read + std::io::Seek>(
 
 #[cfg(test)]
 mod tests {
-    use once_cell::sync::Lazy;
-    use tokio::sync::OnceCell;
-
     use super::*;
     use crate::test_utils::{alice_keypair, bob_keypair};
+    use once_cell::sync::Lazy;
+    use tokio::sync::OnceCell;
 
     #[test]
     fn test_split_armored_data_1() {

src/plaintext.rs

@@ -2,9 +2,8 @@
 
 #![allow(missing_docs)]
 
-use once_cell::sync::Lazy;
-
 use crate::simplify::split_lines;
+use once_cell::sync::Lazy;
 
 #[derive(Debug)]
 pub struct PlainText {

src/provider.rs

@@ -4,13 +4,12 @@
 
 mod data;
 
-use anyhow::Result;
-use chrono::{NaiveDateTime, NaiveTime};
-use trust_dns_resolver::{config, AsyncResolver, TokioAsyncResolver};
-
 use crate::config::Config;
 use crate::context::Context;
 use crate::provider::data::{PROVIDER_DATA, PROVIDER_IDS, PROVIDER_UPDATED};
+use anyhow::Result;
+use chrono::{NaiveDateTime, NaiveTime};
+use trust_dns_resolver::{config, AsyncResolver, TokioAsyncResolver};
 
 #[derive(Debug, Display, Copy, Clone, PartialEq, Eq, FromPrimitive, ToPrimitive)]
 #[repr(u8)]
@@ -196,11 +195,10 @@ pub fn get_provider_update_timestamp() -> i64 {
 mod tests {
     #![allow(clippy::indexing_slicing)]
 
-    use chrono::NaiveDate;
-
     use super::*;
     use crate::test_utils::TestContext;
     use crate::tools::time;
+    use chrono::NaiveDate;
 
     #[test]
     fn test_get_provider_by_domain_unexistant() {

src/provider/data.rs

@@ -1,13 +1,12 @@
 // file generated by src/provider/update.py
 
-use std::collections::HashMap;
-
-use once_cell::sync::Lazy;
-
 use crate::provider::Protocol::*;
 use crate::provider::Socket::*;
 use crate::provider::UsernamePattern::*;
 use crate::provider::{Config, ConfigDefault, Oauth2Authorizer, Provider, Server, Status};
+use std::collections::HashMap;
+
+use once_cell::sync::Lazy;
 
 // 163.md: 163.com
 static P_163: Lazy<Provider> = Lazy::new(|| Provider {

src/qr.rs

@@ -3,15 +3,14 @@
 #![allow(missing_docs)]
 
 mod dclogin_scheme;
-use std::collections::BTreeMap;
+pub use dclogin_scheme::LoginOptions;
 
 use anyhow::{anyhow, bail, ensure, Context as _, Error, Result};
-pub use dclogin_scheme::LoginOptions;
 use once_cell::sync::Lazy;
 use percent_encoding::percent_decode_str;
 use serde::Deserialize;
+use std::collections::BTreeMap;
 
-use self::dclogin_scheme::configure_from_login_qr;
 use crate::chat::{self, get_chat_id_by_grpid, ChatIdBlocked};
 use crate::config::Config;
 use crate::constants::Blocked;
@@ -25,6 +24,8 @@ use crate::peerstate::Peerstate;
 use crate::tools::time;
 use crate::{token, EventType};
 
+use self::dclogin_scheme::configure_from_login_qr;
+
 const OPENPGP4FPR_SCHEME: &str = "OPENPGP4FPR:"; // yes: uppercase
 const DCACCOUNT_SCHEME: &str = "DCACCOUNT:";
 pub(super) const DCLOGIN_SCHEME: &str = "DCLOGIN:";
@@ -641,14 +642,14 @@ fn normalize_address(addr: &str) -> Result<String, Error> {
 
 #[cfg(test)]
 mod tests {
-    use anyhow::Result;
-
     use super::*;
+
     use crate::aheader::EncryptPreference;
     use crate::chat::{create_group_chat, ProtectionStatus};
     use crate::key::DcKey;
     use crate::securejoin::get_securejoin_qr;
     use crate::test_utils::{alice_keypair, TestContext};
+    use anyhow::Result;
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_decode_http() -> Result<()> {