mailsuite 2.2.2__tar.gz → 2.3.0__tar.gz

{mailsuite-2.2.2 → mailsuite-2.3.0}/PKG-INFO

@@ -1,9 +1,9 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: mailsuite
-Version: 2.2.2
+Version: 2.3.0
 Summary: A Python package for retrieving, parsing, and sending emails
 Project-URL: Homepage, https://github.com/seanthegeek/mailsuite/
-Project-URL: Documentation, https://seanthegeek.github.io/mailsuite/
+Project-URL: Documentation, https://seanthegeek.net/mailsuite/
 Project-URL: Issues, https://github.com/seanthegeek/mailsuite/issues
 Project-URL: Changelog, https://github.com/seanthegeek/mailsuite/blob/master/CHANGELOG.md
 Author-email: Sean Whalen <whalenster@gmail.com>
@@ -16,15 +16,20 @@ Classifier: Intended Audience :: Information Technology
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.10
 Requires-Dist: authres>=1.2.0
-Requires-Dist: cryptography>=41.0.0
+Requires-Dist: cryptography>=50.0.0
 Requires-Dist: dkimpy>=1.1.0
 Requires-Dist: dnspython>=2.0.0
 Requires-Dist: expiringdict==1.2.2
 Requires-Dist: html2text>=2020.1.16
 Requires-Dist: imapclient>=3.1.0
-Requires-Dist: mail-parser>=4.2.1
+Requires-Dist: mail-parser>=4.6.2
 Requires-Dist: publicsuffix2>=2.20190812
 Provides-Extra: all
 Requires-Dist: azure-identity>=1.15.0; extra == 'all'
@@ -50,6 +55,20 @@ A Python package for retrieving, parsing, and sending emails.
 
 ## Features
 
+- Simplified IMAP client (`mailsuite.imap.IMAPClient`) — usable on its own,
+  and the engine behind the mailbox abstraction's IMAP backend
+  - Automatic reconnection and retries after dropped connections and timeouts
+  - Watch a folder for new messages with `IDLE` callbacks, including periodic
+    session refresh
+  - Username/password or OAuth2 (XOAUTH2 / OAUTHBEARER) login
+  - Always uses `/` as the folder hierarchy separator, converting to the
+    server's separator and prepending its namespace automatically, and
+    stripping folder-name characters that collide with the separator
+  - Works around server quirks across Gmail, Microsoft 365, Exchange,
+    Dovecot, and DavMail, including:
+    - Gmail / Google Workspace returning an empty `IDLE` response
+    - Random Microsoft 365 / Exchange `BAD` / "unexpected response" errors
+    - Nonstandard hierarchy separators and namespaces
 - Provider-agnostic mailbox abstraction (`mailsuite.mailbox`)
   - Single `MailboxConnection` interface for IMAP, Microsoft Graph, Gmail,
     and on-disk Maildir
@@ -58,33 +77,32 @@ A Python package for retrieving, parsing, and sending emails.
   - Folder management across every backend — create, rename, move, merge,
     delete, and existence checks, with consistent `FolderExistsError` /
     `FolderNotFoundError` semantics
-  - Watch a folder for new messages — the IMAP `IDLE` command (with periodic
-    session refresh) on the IMAP backend, polling on the cloud backends
+  - Watch a folder for new messages — the IMAP `IDLE` command on the IMAP
+    backend, polling on the cloud backends
   - Unified `send_message()` on backends that support sending (Microsoft
     Graph, Gmail) — IMAP and Maildir users send through
     `mailsuite.smtp.send_email`
-  - Username/password or OAuth2 (XOAUTH2 / OAUTHBEARER) login for IMAP and SMTP
-  - Automatic IMAP reconnection after dropped connections and timeouts
-  - Always uses `/` as the folder hierarchy separator, converting to the
-    server's separator and prepending its namespace automatically, and
-    stripping folder-name characters that collide with the separator
-  - Works around backend quirks across Gmail, Microsoft 365, Exchange,
-    Dovecot, and DavMail, including:
-    - Gmail / Google Workspace returning an empty `IDLE` response
-    - Random Microsoft 365 / Exchange `BAD` / "unexpected response" errors
-    - Nonstandard hierarchy separators and namespaces
-- Consistent email parsing
+- Consistent email parsing (`mailsuite.utils`)
+  - Parse RFC 822 messages from a string, bytes, or file path into
+    consistent dictionaries, with HTML bodies also converted to Markdown
   - SHA256 hashes of attachments
   - Parsed `Authentication-Results` and `DKIM-Signature` headers
+  - Email address parsing into display name, local part, domain, and
+    second-level domain, tolerating noncompliant addresses
+  - Check whether a message passed DKIM or DMARC as a trusted domain
+    (`from_trusted_domain`)
+  - Forward and reverse DNS lookup helpers
   - Parse Microsoft Outlook `.msg` files using `msgconvert`
-- Simplified email creation and sending
+- Simplified email creation and sending (`mailsuite.smtp`)
   - Easily add attachments, plain text, and HTML
+  - Optional DKIM signing of outgoing mail
   - Uses opportunistic encryption (`STARTTLS`) with SMTP by default
-- DKIM signing and verification
+  - Username/password or OAuth2 (XOAUTH2 / OAUTHBEARER) login
+- DKIM signing and verification (`mailsuite.dkim`)
   - Generate RSA keypairs and the matching DNS TXT record
   - Sign outbound mail with a sensible default header set
   - Verify one or many `DKIM-Signature` headers on a received message
-- ARC (Authenticated Received Chain) sealing and verification
+- ARC (Authenticated Received Chain) sealing and verification (`mailsuite.arc`)
   - Seal forwarded mail with an ARC set, extending an existing chain
   - Verify the ARC chain on a received message and read its `cv` result
 

{mailsuite-2.2.2 → mailsuite-2.3.0}/README.md

@@ -7,6 +7,20 @@ A Python package for retrieving, parsing, and sending emails.
 
 ## Features
 
+- Simplified IMAP client (`mailsuite.imap.IMAPClient`) — usable on its own,
+  and the engine behind the mailbox abstraction's IMAP backend
+  - Automatic reconnection and retries after dropped connections and timeouts
+  - Watch a folder for new messages with `IDLE` callbacks, including periodic
+    session refresh
+  - Username/password or OAuth2 (XOAUTH2 / OAUTHBEARER) login
+  - Always uses `/` as the folder hierarchy separator, converting to the
+    server's separator and prepending its namespace automatically, and
+    stripping folder-name characters that collide with the separator
+  - Works around server quirks across Gmail, Microsoft 365, Exchange,
+    Dovecot, and DavMail, including:
+    - Gmail / Google Workspace returning an empty `IDLE` response
+    - Random Microsoft 365 / Exchange `BAD` / "unexpected response" errors
+    - Nonstandard hierarchy separators and namespaces
 - Provider-agnostic mailbox abstraction (`mailsuite.mailbox`)
   - Single `MailboxConnection` interface for IMAP, Microsoft Graph, Gmail,
     and on-disk Maildir
@@ -15,33 +29,32 @@ A Python package for retrieving, parsing, and sending emails.
   - Folder management across every backend — create, rename, move, merge,
     delete, and existence checks, with consistent `FolderExistsError` /
     `FolderNotFoundError` semantics
-  - Watch a folder for new messages — the IMAP `IDLE` command (with periodic
-    session refresh) on the IMAP backend, polling on the cloud backends
+  - Watch a folder for new messages — the IMAP `IDLE` command on the IMAP
+    backend, polling on the cloud backends
   - Unified `send_message()` on backends that support sending (Microsoft
     Graph, Gmail) — IMAP and Maildir users send through
     `mailsuite.smtp.send_email`
-  - Username/password or OAuth2 (XOAUTH2 / OAUTHBEARER) login for IMAP and SMTP
-  - Automatic IMAP reconnection after dropped connections and timeouts
-  - Always uses `/` as the folder hierarchy separator, converting to the
-    server's separator and prepending its namespace automatically, and
-    stripping folder-name characters that collide with the separator
-  - Works around backend quirks across Gmail, Microsoft 365, Exchange,
-    Dovecot, and DavMail, including:
-    - Gmail / Google Workspace returning an empty `IDLE` response
-    - Random Microsoft 365 / Exchange `BAD` / "unexpected response" errors
-    - Nonstandard hierarchy separators and namespaces
-- Consistent email parsing
+- Consistent email parsing (`mailsuite.utils`)
+  - Parse RFC 822 messages from a string, bytes, or file path into
+    consistent dictionaries, with HTML bodies also converted to Markdown
   - SHA256 hashes of attachments
   - Parsed `Authentication-Results` and `DKIM-Signature` headers
+  - Email address parsing into display name, local part, domain, and
+    second-level domain, tolerating noncompliant addresses
+  - Check whether a message passed DKIM or DMARC as a trusted domain
+    (`from_trusted_domain`)
+  - Forward and reverse DNS lookup helpers
   - Parse Microsoft Outlook `.msg` files using `msgconvert`
-- Simplified email creation and sending
+- Simplified email creation and sending (`mailsuite.smtp`)
   - Easily add attachments, plain text, and HTML
+  - Optional DKIM signing of outgoing mail
   - Uses opportunistic encryption (`STARTTLS`) with SMTP by default
-- DKIM signing and verification
+  - Username/password or OAuth2 (XOAUTH2 / OAUTHBEARER) login
+- DKIM signing and verification (`mailsuite.dkim`)
   - Generate RSA keypairs and the matching DNS TXT record
   - Sign outbound mail with a sensible default header set
   - Verify one or many `DKIM-Signature` headers on a received message
-- ARC (Authenticated Received Chain) sealing and verification
+- ARC (Authenticated Received Chain) sealing and verification (`mailsuite.arc`)
   - Seal forwarded mail with an ARC set, extending an existing chain
   - Verify the ARC chain on a received message and read its `cv` result
 

{mailsuite-2.2.2 → mailsuite-2.3.0}/mailsuite/__init__.py

@@ -1,3 +1,3 @@
 """A Python package to simplify receiving, parsing, and sending email"""
 
-__version__ = "2.2.2"
+__version__ = "2.3.0"

{mailsuite-2.2.2 → mailsuite-2.3.0}/mailsuite/arc.py

@@ -18,7 +18,8 @@ like :mod:`mailsuite.dkim`.
 """
 
 import logging
-from typing import Any, Callable, List, Optional, Union
+from collections.abc import Callable
+from typing import Any
 
 import dkim as _dkim
 
@@ -31,14 +32,14 @@ class ARCError(RuntimeError):
 
 
 def seal_email(
-    message: Union[str, bytes],
+    message: str | bytes,
     selector: str,
     domain: str,
-    private_key: Union[str, bytes],
+    private_key: str | bytes,
     authserv_id: str,
-    signed_headers: Optional[List[str]] = None,
-    timestamp: Optional[int] = None,
-) -> Union[str, bytes]:
+    signed_headers: list[str] | None = None,
+    timestamp: int | None = None,
+) -> str | bytes:
     """
     Adds an ARC set (seal) to an email and returns the sealed RFC 822 message
 
@@ -123,9 +124,9 @@ def seal_email(
 
 
 def verify_arc_chain(
-    message: Union[str, bytes],
+    message: str | bytes,
     minkey: int = 1024,
-    dns_func: Optional[Callable[[str], bytes]] = None,
+    dns_func: Callable[[str], bytes] | None = None,
 ) -> dict:
     """
     Verifies the ARC chain on an RFC 822 message

{mailsuite-2.2.2 → mailsuite-2.3.0}/mailsuite/dkim.py

@@ -3,7 +3,7 @@
 import base64
 import email
 import logging
-from typing import Callable, Optional, Tuple, Union
+from collections.abc import Callable
 
 import dkim as _dkim
 from cryptography.hazmat.primitives import serialization
@@ -58,7 +58,7 @@ def generate_dkim_private_key(key_size: int = 2048) -> str:
     return pem.decode("ascii")
 
 
-def get_dkim_public_key(private_key: Union[str, bytes]) -> str:
+def get_dkim_public_key(private_key: str | bytes) -> str:
     """
     Derives the DKIM public key from a private key
 
@@ -74,7 +74,7 @@ def get_dkim_public_key(private_key: Union[str, bytes]) -> str:
         key_bytes = bytes(private_key)
     try:
         key = serialization.load_pem_private_key(key_bytes, password=None)
-    except Exception as e:
+    except Exception as e:  # noqa: BLE001
         raise DKIMError(f"Failed to load private key: {e}")
     der = key.public_key().public_bytes(
         encoding=serialization.Encoding.DER,
@@ -83,7 +83,7 @@ def get_dkim_public_key(private_key: Union[str, bytes]) -> str:
     return base64.b64encode(der).decode("ascii")
 
 
-def generate_dkim_keypair(key_size: int = 2048) -> Tuple[str, str]:
+def generate_dkim_keypair(key_size: int = 2048) -> tuple[str, str]:
     """
     Generates a DKIM RSA keypair
 
@@ -98,11 +98,11 @@ def generate_dkim_keypair(key_size: int = 2048) -> Tuple[str, str]:
 
 
 def generate_dkim_txt_record(
-    public_key: Union[str, bytes],
+    public_key: str | bytes,
     selector: str = "default",
-    domain: Optional[str] = None,
-    flags: Optional[str] = None,
-    note: Optional[str] = None,
+    domain: str | None = None,
+    flags: str | None = None,
+    note: str | None = None,
 ) -> str:
     """
     Generates a DKIM TXT record
@@ -134,7 +134,7 @@ def generate_dkim_txt_record(
     elif "BEGIN" in key_str and "PUBLIC KEY" in key_str:
         try:
             pub = serialization.load_pem_public_key(key_str.encode("ascii"))
-        except Exception as e:
+        except Exception as e:  # noqa: BLE001
             raise DKIMError(f"Failed to load public key: {e}")
         der = pub.public_bytes(
             encoding=serialization.Encoding.DER,
@@ -159,14 +159,14 @@ def generate_dkim_txt_record(
 
 
 def sign_email(
-    message: Union[str, bytes],
+    message: str | bytes,
     selector: str,
     domain: str,
-    private_key: Union[str, bytes],
-    additional_headers: Optional[list[str]] = None,
-    canonicalize: Tuple[bytes, bytes] = (b"relaxed", b"relaxed"),
-    identity: Optional[str] = None,
-) -> Union[str, bytes]:
+    private_key: str | bytes,
+    additional_headers: list[str] | None = None,
+    canonicalize: tuple[bytes, bytes] = (b"relaxed", b"relaxed"),
+    identity: str | None = None,
+) -> str | bytes:
     """
     DKIM-signs an email and returns the signed RFC 822 message
 
@@ -210,7 +210,7 @@ def sign_email(
         headers_to_sign.extend(additional_headers)
 
     parsed = email.message_from_bytes(message_bytes)
-    present = {key.lower() for key in parsed.keys()}
+    present = {key.lower() for key in parsed}
 
     include = [
         header.encode("ascii")
@@ -243,10 +243,10 @@ def sign_email(
 
 
 def verify_email(
-    message: Union[str, bytes],
+    message: str | bytes,
     timeout: float = 5.0,
     minkey: int = 1024,
-    dns_func: Optional[Callable[[str], bytes]] = None,
+    dns_func: Callable[[str], bytes] | None = None,
 ) -> dict:
     """
     Verifies the DKIM signature(s) on an RFC 822 message
@@ -318,7 +318,7 @@ def verify_email(
                 sig_info["error"] = "Signature did not verify"
         except _dkim.DKIMException as e:
             sig_info["error"] = str(e)
-        except Exception as e:
+        except Exception as e:  # noqa: BLE001
             sig_info["error"] = f"Verification error: {e}"
 
         if sig_info["valid"]:

{mailsuite-2.2.2 → mailsuite-2.3.0}/mailsuite/imap.py

@@ -1,16 +1,16 @@
+import imaplib
 import logging
-from typing import Callable, Union, List, Dict, Optional, cast
 import time
-import socket
+from collections.abc import Callable
 from ssl import (
     CERT_NONE,
     SSLContext,
     create_default_context,
 )
+from typing import cast
 
 import imapclient
 import imapclient.exceptions
-import imaplib
 
 import mailsuite.utils
 
@@ -31,7 +31,7 @@ class IMAPClient(imapclient.IMAPClient):
     """A simplified IMAP client"""
 
     def _normalise_folder(
-        self, folder_name: Union[str, bytes, bytearray, memoryview]
+        self, folder_name: str | bytes | bytearray | memoryview
     ) -> str:
         """
         Translate a caller's ``/``-delimited folder path to the server's form.
@@ -82,14 +82,14 @@ class IMAPClient(imapclient.IMAPClient):
         # of the correct "INBOX/Projects/INBOX/old".
         if self._path_prefix and folder_name.startswith(self._path_prefix):
             folder_name = folder_name[len(self._path_prefix):]
-        if not self._hierarchy_separator == "/":
+        if self._hierarchy_separator != "/":
             # Map the caller's "/" delimiter onto the server's native separator
             # so "/" works regardless of what the server uses. (Any literal
             # native-separator characters are dropped first, since "/" is the
             # delimiter callers are expected to use.)
             folder_name = folder_name.replace(self._hierarchy_separator, "")
             folder_name = folder_name.replace("/", self._hierarchy_separator)
-        folder_name = "{0}{1}".format(self._path_prefix, folder_name)
+        folder_name = f"{self._path_prefix}{folder_name}"
 
         result = imapclient.IMAPClient._normalise_folder(self, folder_name)
         if isinstance(result, bytes):
@@ -149,7 +149,7 @@ class IMAPClient(imapclient.IMAPClient):
                                 idle_start_time = time.monotonic()
                                 self.idle()
                                 break
-            except (KeyError, socket.error, BrokenPipeError, ConnectionResetError):
+            except (OSError, KeyError, BrokenPipeError, ConnectionResetError):
                 logger.debug("IMAP error: Connection reset")
                 self.reset_connection()
                 idle_callback(self)
@@ -174,22 +174,22 @@ class IMAPClient(imapclient.IMAPClient):
     def __init__(
         self,
         host: str,
-        username: Optional[str] = None,
-        password: Optional[str] = None,
+        username: str | None = None,
+        password: str | None = None,
         port: int = 993,
         ssl: bool = True,
-        ssl_context: Optional[SSLContext] = None,
+        ssl_context: SSLContext | None = None,
         verify: bool = True,
         timeout: int = 30,
         max_retries: int = 4,
         initial_folder: str = "INBOX",
         idle_callback=None,
         idle_timeout: int = 30,
-        oauth2_token: Optional[str] = None,
-        oauth2_token_provider: Optional[Callable[[], str]] = None,
+        oauth2_token: str | None = None,
+        oauth2_token_provider: Callable[[], str] | None = None,
         oauth2_mechanism: str = "XOAUTH2",
-        oauth2_vendor: Optional[str] = None,
-        config_reloading: Optional[Callable[[], bool]] = None,
+        oauth2_vendor: str | None = None,
+        config_reloading: Callable[[], bool] | None = None,
     ):
         """
         Connects to an IMAP server
@@ -245,29 +245,29 @@ class IMAPClient(imapclient.IMAPClient):
                 "either password or an OAuth2 token / token_provider must be "
                 "provided"
             )
-        self._init_args = dict(
-            host=host,
-            username=username,
-            password=password,
-            port=port,
-            ssl=ssl,
-            ssl_context=ssl_context,
-            verify=verify,
-            timeout=timeout,
-            max_retries=max_retries,
-            initial_folder=initial_folder,
-            idle_callback=idle_callback,
-            idle_timeout=idle_timeout,
-            oauth2_token=oauth2_token,
-            oauth2_token_provider=oauth2_token_provider,
-            oauth2_mechanism=oauth2_mechanism,
-            oauth2_vendor=oauth2_vendor,
-        )
+        self._init_args = {
+            "host": host,
+            "username": username,
+            "password": password,
+            "port": port,
+            "ssl": ssl,
+            "ssl_context": ssl_context,
+            "verify": verify,
+            "timeout": timeout,
+            "max_retries": max_retries,
+            "initial_folder": initial_folder,
+            "idle_callback": idle_callback,
+            "idle_timeout": idle_timeout,
+            "oauth2_token": oauth2_token,
+            "oauth2_token_provider": oauth2_token_provider,
+            "oauth2_mechanism": oauth2_mechanism,
+            "oauth2_vendor": oauth2_vendor,
+        }
         self.max_retries = max_retries
         self.idle_callback = idle_callback
         self.idle_timeout = idle_timeout
         self._path_prefix = ""
-        self._other_namespace_prefixes: List[str] = []
+        self._other_namespace_prefixes: list[str] = []
         self._hierarchy_separator = ""
         if not ssl:
             logger.info("Connecting to IMAP over plain text")
@@ -317,7 +317,7 @@ class IMAPClient(imapclient.IMAPClient):
                 personal_namespace = self._namespace.personal
                 if len(personal_namespace) > 0:
                     self._hierarchy_separator = personal_namespace[0][1]
-                    if not personal_namespace[0][0] == "":
+                    if personal_namespace[0][0] != "":
                         self._path_prefix = personal_namespace[0][0]
                         if type(self._path_prefix) is bytes:
                             self._path_prefix = self._path_prefix.decode("utf-8")
@@ -335,8 +335,8 @@ class IMAPClient(imapclient.IMAPClient):
                 self._namespace = None
             self.select_folder(initial_folder)
         except (
+            OSError,
             ConnectionResetError,
-            socket.error,
             TimeoutError,
             imapclient.exceptions.IMAPClientError,
         ) as error:
@@ -357,8 +357,8 @@ class IMAPClient(imapclient.IMAPClient):
         logger.info("Reconnecting to IMAP")
         try:
             self.shutdown()
-        except Exception as e:
-            logger.info("Failed to log out: {0}".format(e.__str__()))
+        except Exception as e:  # noqa: BLE001
+            logger.info(f"Failed to log out: {e.__str__()}")
         self.__init__(
             self._init_args["host"],  # pyright: ignore[reportArgumentType]
             self._init_args["username"],  # pyright: ignore[reportArgumentType]
@@ -380,7 +380,7 @@ class IMAPClient(imapclient.IMAPClient):
 
     def fetch_message(
         self, msg_uid: int, parse: bool = False, _attempt: int = 1
-    ) -> Union[str, Dict]:
+    ) -> str | dict:
         """
         Fetch a message by UID, and optionally parse it
 
@@ -406,14 +406,12 @@ class IMAPClient(imapclient.IMAPClient):
         for fetch_cmd, expected_keys in fetch_attempts:
             try:
                 raw_msg = self.fetch(msg_uid, fetch_cmd)[msg_uid]
-            except (socket.timeout, imaplib.IMAP4.abort):
+            except (TimeoutError, imaplib.IMAP4.abort):
                 _attempt = _attempt + 1
                 if _attempt > self.max_retries:
                     raise MaxRetriesExceeded("Maximum retries exceeded")
                 logger.info(
-                    "Attempt {0} of {1} timed out. Retrying...".format(
-                        _attempt, self.max_retries
-                    )
+                    f"Attempt {_attempt} of {self.max_retries} timed out. Retrying..."
                 )
                 self.reset_connection()
                 return self.fetch_message(msg_uid, parse=parse, _attempt=_attempt)
@@ -425,7 +423,7 @@ class IMAPClient(imapclient.IMAPClient):
 
             # Check if any expected key is in the response
             for key in expected_keys:
-                if key in raw_msg.keys():
+                if key in raw_msg:
                     msg_key = key
                     break
 
@@ -459,7 +457,7 @@ class IMAPClient(imapclient.IMAPClient):
 
     def delete_messages(
         self,
-        messages: Union[List[int], List[str], str, int],
+        messages: list[int] | list[str] | str | int,
         silent: bool = True,
         _attempt: int = 1,
     ):
@@ -474,7 +472,7 @@ class IMAPClient(imapclient.IMAPClient):
         if type(messages) is str or type(messages) is int:
             messages = [int(messages)]
         logger.info(
-            "Deleting message UID(s) {0}".format(
+            "Deleting message UID(s) {}".format(
                 ",".join(str(uid) for uid in messages)  # pyright: ignore[reportGeneralTypeIssues]
             )
         )
@@ -487,14 +485,12 @@ class IMAPClient(imapclient.IMAPClient):
                 imapclient.IMAPClient.expunge(self, messages)
             else:
                 imapclient.IMAPClient.expunge(self)
-        except (socket.timeout, imaplib.IMAP4.abort):
+        except (TimeoutError, imaplib.IMAP4.abort):
             _attempt = _attempt + 1
             if _attempt > self.max_retries:
                 raise MaxRetriesExceeded("Maximum retries exceeded")
             logger.info(
-                "Attempt {0} of {1} timed out. Retrying...".format(
-                    _attempt, self.max_retries
-                )
+                f"Attempt {_attempt} of {self.max_retries} timed out. Retrying..."
             )
             self.reset_connection()
             self.delete_messages(messages, silent=silent, _attempt=_attempt)
@@ -508,22 +504,20 @@ class IMAPClient(imapclient.IMAPClient):
             _attempt: The attempt number
         """
         if not self.folder_exists(folder):
-            logger.info("Creating folder: {0}".format(folder))
+            logger.info(f"Creating folder: {folder}")
             try:
                 imapclient.IMAPClient.create_folder(self, folder)
-            except (socket.timeout, imaplib.IMAP4.abort):
+            except (TimeoutError, imaplib.IMAP4.abort):
                 _attempt = _attempt + 1
                 if _attempt > self.max_retries:
                     raise MaxRetriesExceeded("Maximum retries exceeded")
                 logger.info(
-                    "Attempt {0} of {1} timed out. Retrying...".format(
-                        _attempt, self.max_retries
-                    )
+                    f"Attempt {_attempt} of {self.max_retries} timed out. Retrying..."
                 )
                 self.reset_connection()
                 self.create_folder(folder, _attempt=_attempt)
 
-    def _move_messages(self, msg_uids: Union[int, List[int]], folder_path: str):
+    def _move_messages(self, msg_uids: int | list[int], folder_path: str):
         """
         Move the emails with the given UIDs to the given folder
 
@@ -537,7 +531,7 @@ class IMAPClient(imapclient.IMAPClient):
         for chunk in _chunks(msg_uids, 100):
             if self._move_supported:
                 logger.info(
-                    "Moving message UID(s) {0} to {1}".format(
+                    "Moving message UID(s) {} to {}".format(
                         ",".join(str(uid) for uid in chunk), folder_path
                     )
                 )
@@ -546,10 +540,10 @@ class IMAPClient(imapclient.IMAPClient):
                 except imapclient.exceptions.IMAPClientError as e:
                     e = e.__str__().lstrip("b'").rstrip("'").rstrip(".")
                     message = "Error moving message UIDs"
-                    e = "{0} {1}: {2}".format(message, msg_uids, e)
-                    logger.info("IMAP error: {0}".format(e))
+                    e = f"{message} {msg_uids}: {e}"
+                    logger.info(f"IMAP error: {e}")
                     logger.info(
-                        "Copying message UID(s) {0} to {1} by copy".format(
+                        "Copying message UID(s) {} to {} by copy".format(
                             ",".join(str(uid) for uid in chunk), folder_path
                         )
                     )
@@ -557,7 +551,7 @@ class IMAPClient(imapclient.IMAPClient):
                     self.delete_messages(chunk)
             else:
                 logger.info(
-                    "Moving message UID(s) {0} to {1} by copy".format(
+                    "Moving message UID(s) {} to {} by copy".format(
                         ",".join(str(uid) for uid in chunk), folder_path
                     )
                 )
@@ -565,7 +559,7 @@ class IMAPClient(imapclient.IMAPClient):
                 self.delete_messages(chunk)
 
     def move_messages(
-        self, msg_uids: Union[int, List[int]], folder_path: str, _attempt: int = 1
+        self, msg_uids: int | list[int], folder_path: str, _attempt: int = 1
     ):
         """
         Move the emails with the given UIDs to the given folder
@@ -577,14 +571,12 @@ class IMAPClient(imapclient.IMAPClient):
         """
         try:
             self._move_messages(msg_uids, folder_path)
-        except (socket.timeout, imaplib.IMAP4.abort):
+        except (TimeoutError, imaplib.IMAP4.abort):
             _attempt = _attempt + 1
             if _attempt > self.max_retries:
                 raise MaxRetriesExceeded("Maximum retries exceeded")
             logger.info(
-                "Attempt {0} of {1} timed out. Retrying...".format(
-                    _attempt, self.max_retries
-                )
+                f"Attempt {_attempt} of {self.max_retries} timed out. Retrying..."
             )
             self.reset_connection()
             self._move_messages(msg_uids, folder_path)