"""Read/write support for Maildir, mbox, MH, Babyl, and MMDF mailboxes."""

# Notes for authors of new mailbox subclasses:

#

# Remember to fsync() changes to disk before closing a modified file

# or returning from a flush() method. See functions _sync_flush() and

# _sync_close().

import os

import time

import calendar

import socket

import errno

import copy

import warnings

import email

import email.message

import email.generator

import io

import contextlib

from types import GenericAlias

try:

import fcntl

except ImportError:

fcntl = None

__all__ = ['Mailbox', 'Maildir', 'mbox', 'MH', 'Babyl', 'MMDF',

'Message', 'MaildirMessage', 'mboxMessage', 'MHMessage',

'BabylMessage', 'MMDFMessage', 'Error', 'NoSuchMailboxError',

'NotEmptyError', 'ExternalClashError', 'FormatError']

linesep = os.linesep.encode('ascii')

class Mailbox:

"""A group of messages in a particular place."""

def __init__(self, path, factory=None, create=True):

"""Initialize a Mailbox instance."""

self._path = os.path.abspath(os.path.expanduser(path))

self._factory = factory

def __enter__(self):

self.lock()

return self

def __exit__(self, type, value, traceback):

self.close()

def add(self, message):

"""Add message and return assigned key."""

raise NotImplementedError('Method must be implemented by subclass')

def remove(self, key):

"""Remove the keyed message; raise KeyError if it doesn't exist."""

raise NotImplementedError('Method must be implemented by subclass')

def __delitem__(self, key):

self.remove(key)

def discard(self, key):

"""If the keyed message exists, remove it."""

try:

self.remove(key)

except KeyError:

pass

def __setitem__(self, key, message):

"""Replace the keyed message; raise KeyError if it doesn't exist."""

raise NotImplementedError('Method must be implemented by subclass')

def get(self, key, default=None):

"""Return the keyed message, or default if it doesn't exist."""

try:

return self.__getitem__(key)

except KeyError:

return default

def __getitem__(self, key):

"""Return the keyed message; raise KeyError if it doesn't exist."""

if not self._factory:

return self.get_message(key)

else:

with contextlib.closing(self.get_file(key)) as file:

return self._factory(file)

def get_message(self, key):

"""Return a Message representation or raise a KeyError."""

raise NotImplementedError('Method must be implemented by subclass')

def get_string(self, key):

"""Return a string representation or raise a KeyError.

Uses email.message.Message to create a 7bit clean string

representation of the message."""

return email.message_from_bytes(self.get_bytes(key)).as_string()

def get_bytes(self, key):

"""Return a byte string representation or raise a KeyError."""

raise NotImplementedError('Method must be implemented by subclass')

def get_file(self, key):

"""Return a file-like representation or raise a KeyError."""

raise NotImplementedError('Method must be implemented by subclass')

def iterkeys(self):

"""Return an iterator over keys."""

raise NotImplementedError('Method must be implemented by subclass')

def keys(self):

"""Return a list of keys."""

return list(self.iterkeys())

def itervalues(self):

"""Return an iterator over all messages."""

for key in self.iterkeys():

try:

value = self[key]

except KeyError:

continue

yield value

def __iter__(self):

return self.itervalues()

def values(self):

"""Return a list of messages. Memory intensive."""

return list(self.itervalues())

def iteritems(self):

"""Return an iterator over (key, message) tuples."""

for key in self.iterkeys():

try:

value = self[key]

except KeyError:

continue

yield (key, value)

def items(self):

"""Return a list of (key, message) tuples. Memory intensive."""

return list(self.iteritems())

def __contains__(self, key):

"""Return True if the keyed message exists, False otherwise."""

raise NotImplementedError('Method must be implemented by subclass')

def __len__(self):

"""Return a count of messages in the mailbox."""

raise NotImplementedError('Method must be implemented by subclass')

def clear(self):

"""Delete all messages."""

for key in self.keys():

self.discard(key)

def pop(self, key, default=None):

"""Delete the keyed message and return it, or default."""

try:

result = self[key]

except KeyError:

return default

self.discard(key)

return result

def popitem(self):

"""Delete an arbitrary (key, message) pair and return it."""

for key in self.iterkeys():

return (key, self.pop(key)) # This is only run once.

else:

raise KeyError('No messages in mailbox')

def update(self, arg=None):

"""Change the messages that correspond to certain keys."""

if hasattr(arg, 'iteritems'):

source = arg.iteritems()

elif hasattr(arg, 'items'):

source = arg.items()

else:

source = arg

bad_key = False

for key, message in source:

try:

self[key] = message

except KeyError:

bad_key = True

if bad_key:

raise KeyError('No message with key(s)')

def flush(self):

"""Write any pending changes to the disk."""

raise NotImplementedError('Method must be implemented by subclass')

def lock(self):

"""Lock the mailbox."""

raise NotImplementedError('Method must be implemented by subclass')

def unlock(self):

"""Unlock the mailbox if it is locked."""

raise NotImplementedError('Method must be implemented by subclass')

def close(self):

"""Flush and close the mailbox."""

raise NotImplementedError('Method must be implemented by subclass')

def _string_to_bytes(self, message):

# If a message is not 7bit clean, we refuse to handle it since it

# likely came from reading invalid messages in text mode, and that way

# lies mojibake.

try:

return message.encode('ascii')

except UnicodeError:

raise ValueError("String input must be ASCII-only; "

"use bytes or a Message instead")

# Whether each message must end in a newline

_append_newline = False

def _dump_message(self, message, target, mangle_from_=False):

# This assumes the target file is open in binary mode.

"""Dump message contents to target file."""

if isinstance(message, email.message.Message):

buffer = io.BytesIO()

gen = email.generator.BytesGenerator(buffer, mangle_from_, 0)

gen.flatten(message)

buffer.seek(0)

data = buffer.read()

data = data.replace(b'\n', linesep)

target.write(data)

if self._append_newline and not data.endswith(linesep):

# Make sure the message ends with a newline

target.write(linesep)

elif isinstance(message, (str, bytes, io.StringIO)):

if isinstance(message, io.StringIO):

warnings.warn("Use of StringIO input is deprecated, "

"use BytesIO instead", DeprecationWarning, 3)

message = message.getvalue()

if isinstance(message, str):

message = self._string_to_bytes(message)

if mangle_from_:

message = message.replace(b'\nFrom ', b'\n>From ')

message = message.replace(b'\n', linesep)

target.write(message)

if self._append_newline and not message.endswith(linesep):

# Make sure the message ends with a newline

target.write(linesep)

elif hasattr(message, 'read'):

if hasattr(message, 'buffer'):

warnings.warn("Use of text mode files is deprecated, "

"use a binary mode file instead", DeprecationWarning, 3)

message = message.buffer

lastline = None

while True:

line = message.readline()

# Universal newline support.

if line.endswith(b'\r\n'):

line = line[:-2] + b'\n'

elif line.endswith(b'\r'):

line = line[:-1] + b'\n'

if not line:

break

if mangle_from_ and line.startswith(b'From '):

line = b'>From ' + line[5:]

line = line.replace(b'\n', linesep)

target.write(line)

lastline = line

if self._append_newline and lastline and not lastline.endswith(linesep):

# Make sure the message ends with a newline

target.write(linesep)

else:

raise TypeError('Invalid message type: %s' % type(message))

__class_getitem__ = classmethod(GenericAlias)

class Maildir(Mailbox):

"""A qmail-style Maildir mailbox."""

colon = ':'

def __init__(self, dirname, factory=None, create=True):

"""Initialize a Maildir instance."""

Mailbox.__init__(self, dirname, factory, create)

self._paths = {

'tmp': os.path.join(self._path, 'tmp'),

'new': os.path.join(self._path, 'new'),

'cur': os.path.join(self._path, 'cur'),

}

if not os.path.exists(self._path):

if create:

os.mkdir(self._path, 0o700)

for path in self._paths.values():

os.mkdir(path, 0o700)

else:

raise NoSuchMailboxError(self._path)

self._toc = {}

self._toc_mtimes = {'cur': 0, 'new': 0}

self._last_read = 0 # Records last time we read cur/new

self._skewfactor = 0.1 # Adjust if os/fs clocks are skewing

def add(self, message):

"""Add message and return assigned key."""

tmp_file = self._create_tmp()

try:

self._dump_message(message, tmp_file)

except BaseException:

tmp_file.close()

os.remove(tmp_file.name)

raise

_sync_close(tmp_file)

if isinstance(message, MaildirMessage):

subdir = message.get_subdir()

suffix = self.colon + message.get_info()

if suffix == self.colon:

suffix = ''

else:

subdir = 'new'

suffix = ''

uniq = os.path.basename(tmp_file.name).split(self.colon)[0]

dest = os.path.join(self._path, subdir, uniq + suffix)

if isinstance(message, MaildirMessage):

os.utime(tmp_file.name,

(os.path.getatime(tmp_file.name), message.get_date()))

# No file modification should be done after the file is moved to its

# final position in order to prevent race conditions with changes

# from other programs

try:

try:

os.link(tmp_file.name, dest)

except (AttributeError, PermissionError):

os.rename(tmp_file.name, dest)

else:

os.remove(tmp_file.name)

except OSError as e:

os.remove(tmp_file.name)

if e.errno == errno.EEXIST:

raise ExternalClashError('Name clash with existing message: %s'

% dest)

else:

raise

return uniq

def remove(self, key):

"""Remove the keyed message; raise KeyError if it doesn't exist."""

os.remove(os.path.join(self._path, self._lookup(key)))

def discard(self, key):

"""If the keyed message exists, remove it."""

# This overrides an inapplicable implementation in the superclass.

try:

self.remove(key)

except (KeyError, FileNotFoundError):

pass

def __setitem__(self, key, message):

"""Replace the keyed message; raise KeyError if it doesn't exist."""

old_subpath = self._lookup(key)

temp_key = self.add(message)

temp_subpath = self._lookup(temp_key)

if isinstance(message, MaildirMessage):

# temp's subdir and suffix were specified by message.

dominant_subpath = temp_subpath

else:

# temp's subdir and suffix were defaults from add().

dominant_subpath = old_subpath

subdir = os.path.dirname(dominant_subpath)

if self.colon in dominant_subpath:

suffix = self.colon + dominant_subpath.split(self.colon)[-1]

else:

suffix = ''

self.discard(key)

tmp_path = os.path.join(self._path, temp_subpath)

new_path = os.path.join(self._path, subdir, key + suffix)

if isinstance(message, MaildirMessage):

os.utime(tmp_path,

(os.path.getatime(tmp_path), message.get_date()))

# No file modification should be done after the file is moved to its

# final position in order to prevent race conditions with changes

# from other programs

os.rename(tmp_path, new_path)

def get_message(self, key):

"""Return a Message representation or raise a KeyError."""

subpath = self._lookup(key)

with open(os.path.join(self._path, subpath), 'rb') as f:

if self._factory:

msg = self._factory(f)

else:

msg = MaildirMessage(f)

subdir, name = os.path.split(subpath)

msg.set_subdir(subdir)

if self.colon in name:

msg.set_info(name.split(self.colon)[-1])

msg.set_date(os.path.getmtime(os.path.join(self._path, subpath)))

return msg

def get_bytes(self, key):

"""Return a bytes representation or raise a KeyError."""

with open(os.path.join(self._path, self._lookup(key)), 'rb') as f:

return f.read().replace(linesep, b'\n')

def get_file(self, key):

"""Return a file-like representation or raise a KeyError."""

f = open(os.path.join(self._path, self._lookup(key)), 'rb')

return _ProxyFile(f)

def get_info(self, key):

"""Get the keyed message's "info" as a string."""

subpath = self._lookup(key)

if self.colon in subpath:

return subpath.split(self.colon)[-1]

return ''

def set_info(self, key, info: str):

"""Set the keyed message's "info" string."""

if not isinstance(info, str):

raise TypeError(f'info must be a string: {type(info)}')

old_subpath = self._lookup(key)

new_subpath = old_subpath.split(self.colon)[0]

if info:

new_subpath += self.colon + info

if new_subpath == old_subpath:

return

old_path = os.path.join(self._path, old_subpath)

new_path = os.path.join(self._path, new_subpath)

os.rename(old_path, new_path)

self._toc[key] = new_subpath

def get_flags(self, key):

"""Return as a string the standard flags that are set on the keyed message."""

info = self.get_info(key)

if info.startswith('2,'):

return info[2:]

return ''

def set_flags(self, key, flags: str):

"""Set the given flags and unset all others on the keyed message."""

if not isinstance(flags, str):

raise TypeError(f'flags must be a string: {type(flags)}')

# TODO: check if flags are valid standard flag characters?

self.set_info(key, '2,' + ''.join(sorted(set(flags))))

def add_flag(self, key, flag: str):

"""Set the given flag(s) without changing others on the keyed message."""

if not isinstance(flag, str):

raise TypeError(f'flag must be a string: {type(flag)}')

# TODO: check that flag is a valid standard flag character?

self.set_flags(key, ''.join(set(self.get_flags(key)) | set(flag)))

def remove_flag(self, key, flag: str):

"""Unset the given string flag(s) without changing others on the keyed message."""

if not isinstance(flag, str):

raise TypeError(f'flag must be a string: {type(flag)}')

if self.get_flags(key):

self.set_flags(key, ''.join(set(self.get_flags(key)) - set(flag)))

def iterkeys(self):

"""Return an iterator over keys."""

self._refresh()

for key in self._toc:

try:

self._lookup(key)

except KeyError:

continue

yield key

def __contains__(self, key):

"""Return True if the keyed message exists, False otherwise."""

self._refresh()

return key in self._toc

def __len__(self):

"""Return a count of messages in the mailbox."""

self._refresh()

return len(self._toc)

def flush(self):

"""Write any pending changes to disk."""

# Maildir changes are always written immediately, so there's nothing

# to do.

pass

def lock(self):

"""Lock the mailbox."""

return

def unlock(self):

"""Unlock the mailbox if it is locked."""

return

def close(self):

"""Flush and close the mailbox."""

return

def list_folders(self):

"""Return a list of folder names."""

result = []

for entry in os.listdir(self._path):

if len(entry) > 1 and entry[0] == '.' and \

os.path.isdir(os.path.join(self._path, entry)):

result.append(entry[1:])

return result

def get_folder(self, folder):

"""Return a Maildir instance for the named folder."""

return Maildir(os.path.join(self._path, '.' + folder),

factory=self._factory,

create=False)

def add_folder(self, folder):

"""Create a folder and return a Maildir instance representing it."""

path = os.path.join(self._path, '.' + folder)

result = Maildir(path, factory=self._factory)

maildirfolder_path = os.path.join(path, 'maildirfolder')

if not os.path.exists(maildirfolder_path):

os.close(os.open(maildirfolder_path, os.O_CREAT | os.O_WRONLY,

0o666))

return result

def remove_folder(self, folder):

"""Delete the named folder, which must be empty."""

path = os.path.join(self._path, '.' + folder)

for entry in os.listdir(os.path.join(path, 'new')) + \

os.listdir(os.path.join(path, 'cur')):

if len(entry) < 1 or entry[0] != '.':

raise NotEmptyError('Folder contains message(s): %s' % folder)

for entry in os.listdir(path):

if entry != 'new' and entry != 'cur' and entry != 'tmp' and \

os.path.isdir(os.path.join(path, entry)):

raise NotEmptyError("Folder contains subdirectory '%s': %s" %

(folder, entry))

for root, dirs, files in os.walk(path, topdown=False):

for entry in files:

os.remove(os.path.join(root, entry))

for entry in dirs:

os.rmdir(os.path.join(root, entry))

os.rmdir(path)

def clean(self):

"""Delete old files in "tmp"."""

now = time.time()

for entry in os.listdir(os.path.join(self._path, 'tmp')):

path = os.path.join(self._path, 'tmp', entry)

if now - os.path.getatime(path) > 129600: # 60 * 60 * 36

os.remove(path)

_count = 1 # This is used to generate unique file names.

def _create_tmp(self):

"""Create a file in the tmp subdirectory and open and return it."""

now = time.time()

hostname = socket.gethostname()

if '/' in hostname:

hostname = hostname.replace('/', r'\057')

if ':' in hostname:

hostname = hostname.replace(':', r'\072')

uniq = "%s.M%sP%sQ%s.%s" % (int(now), int(now % 1 * 1e6), os.getpid(),

Maildir._count, hostname)

path = os.path.join(self._path, 'tmp', uniq)

try:

os.stat(path)

except FileNotFoundError:

Maildir._count += 1

try:

return _create_carefully(path)

except FileExistsError:

pass

# Fall through to here if stat succeeded or open raised EEXIST.

raise ExternalClashError('Name clash prevented file creation: %s' %

path)

def _refresh(self):

"""Update table of contents mapping."""

# If it has been less than two seconds since the last _refresh() call,

# we have to unconditionally re-read the mailbox just in case it has

# been modified, because os.path.mtime() has a 2 sec resolution in the

# most common worst case (FAT) and a 1 sec resolution typically. This

# results in a few unnecessary re-reads when _refresh() is called

# multiple times in that interval, but once the clock ticks over, we

# will only re-read as needed. Because the filesystem might be being

# served by an independent system with its own clock, we record and

# compare with the mtimes from the filesystem. Because the other

# system's clock might be skewing relative to our clock, we add an

# extra delta to our wait. The default is one tenth second, but is an

# instance variable and so can be adjusted if dealing with a

# particularly skewed or irregular system.

if time.time() - self._last_read > 2 + self._skewfactor:

refresh = False

for subdir in self._toc_mtimes:

mtime = os.path.getmtime(self._paths[subdir])

if mtime > self._toc_mtimes[subdir]:

refresh = True

self._toc_mtimes[subdir] = mtime

if not refresh:

return

# Refresh toc

self._toc = {}

for subdir in self._toc_mtimes:

path = self._paths[subdir]

for entry in os.listdir(path):

if entry.startswith('.'):

continue

p = os.path.join(path, entry)

if os.path.isdir(p):

continue

uniq = entry.split(self.colon)[0]

self._toc[uniq] = os.path.join(subdir, entry)

self._last_read = time.time()

def _lookup(self, key):

"""Use TOC to return subpath for given key, or raise a KeyError."""

try:

if os.path.exists(os.path.join(self._path, self._toc[key])):

return self._toc[key]

except KeyError:

pass

self._refresh()

try:

return self._toc[key]

except KeyError:

raise KeyError('No message with key: %s' % key) from None

# This method is for backward compatibility only.

def next(self):

"""Return the next message in a one-time iteration."""

if not hasattr(self, '_onetime_keys'):

self._onetime_keys = self.iterkeys()

while True:

try:

return self[next(self._onetime_keys)]

except StopIteration:

return None

except KeyError:

continue

class _singlefileMailbox(Mailbox):

"""A single-file mailbox."""

def __init__(self, path, factory=None, create=True):

"""Initialize a single-file mailbox."""

Mailbox.__init__(self, path, factory, create)

try:

f = open(self._path, 'rb+')

except OSError as e:

if e.errno == errno.ENOENT:

if create:

f = open(self._path, 'wb+')

else:

raise NoSuchMailboxError(self._path)

elif e.errno in (errno.EACCES, errno.EROFS):

f = open(self._path, 'rb')

else:

raise

self._file = f

self._toc = None

self._next_key = 0

self._pending = False # No changes require rewriting the file.

self._pending_sync = False # No need to sync the file

self._locked = False

self._file_length = None # Used to record mailbox size

def add(self, message):

"""Add message and return assigned key."""

self._lookup()

self._toc[self._next_key] = self._append_message(message)

self._next_key += 1

# _append_message appends the message to the mailbox file. We

# don't need a full rewrite + rename, sync is enough.

self._pending_sync = True

return self._next_key - 1

def remove(self, key):

"""Remove the keyed message; raise KeyError if it doesn't exist."""

self._lookup(key)

del self._toc[key]

self._pending = True

def __setitem__(self, key, message):

"""Replace the keyed message; raise KeyError if it doesn't exist."""

self._lookup(key)

self._toc[key] = self._append_message(message)

self._pending = True

def iterkeys(self):

"""Return an iterator over keys."""

self._lookup()

yield from self._toc.keys()

def __contains__(self, key):

"""Return True if the keyed message exists, False otherwise."""

self._lookup()

return key in self._toc

def __len__(self):

"""Return a count of messages in the mailbox."""

self._lookup()

return len(self._toc)

def lock(self):

"""Lock the mailbox."""

if not self._locked:

_lock_file(self._file)

self._locked = True

def unlock(self):

"""Unlock the mailbox if it is locked."""

if self._locked:

_unlock_file(self._file)

self._locked = False

def flush(self):

"""Write any pending changes to disk."""

if not self._pending:

if self._pending_sync:

# Messages have only been added, so syncing the file

# is enough.

_sync_flush(self._file)

self._pending_sync = False

return

# In order to be writing anything out at all, self._toc must

# already have been generated (and presumably has been modified

# by adding or deleting an item).

assert self._toc is not None

# Check length of self._file; if it's changed, some other process

# has modified the mailbox since we scanned it.

self._file.seek(0, 2)

cur_len = self._file.tell()

if cur_len != self._file_length:

raise ExternalClashError('Size of mailbox file changed '

'(expected %i, found %i)' %

(self._file_length, cur_len))

new_file = _create_temporary(self._path)

try:

new_toc = {}

self._pre_mailbox_hook(new_file)

for key in sorted(self._toc.keys()):

start, stop = self._toc[key]

self._file.seek(start)

self._pre_message_hook(new_file)

new_start = new_file.tell()

while True:

buffer = self._file.read(min(4096,

stop - self._file.tell()))

if not buffer:

break

new_file.write(buffer)

new_toc[key] = (new_start, new_file.tell())

self._post_message_hook(new_file)

self._file_length = new_file.tell()

except:

new_file.close()

os.remove(new_file.name)

raise

_sync_close(new_file)

# self._file is about to get replaced, so no need to sync.

self._file.close()

# Make sure the new file's mode and owner are the same as the old file's

info = os.stat(self._path)

os.chmod(new_file.name, info.st_mode)

try:

os.chown(new_file.name, info.st_uid, info.st_gid)

except (AttributeError, OSError):

pass

try:

os.rename(new_file.name, self._path)

except FileExistsError:

os.remove(self._path)

os.rename(new_file.name, self._path)

self._file = open(self._path, 'rb+')

self._toc = new_toc

self._pending = False

self._pending_sync = False

if self._locked:

_lock_file(self._file, dotlock=False)

def _pre_mailbox_hook(self, f):

"""Called before writing the mailbox to file f."""

return

def _pre_message_hook(self, f):

"""Called before writing each message to file f."""

return

def _post_message_hook(self, f):

"""Called after writing each message to file f."""

return

def close(self):

"""Flush and close the mailbox."""

try:

self.flush()

finally:

try:

if self._locked:

self.unlock()

finally:

self._file.close() # Sync has been done by self.flush() above.

def _lookup(self, key=None):

"""Return (start, stop) or raise KeyError."""

if self._toc is None:

self._generate_toc()

if key is not None:

try:

return self._toc[key]

except KeyError:

raise KeyError('No message with key: %s' % key) from None

def _append_message(self, message):

"""Append message to mailbox and return (start, stop) offsets."""

self._file.seek(0, 2)

before = self._file.tell()

if len(self._toc) == 0 and not self._pending:

# This is the first message, and the _pre_mailbox_hook

# hasn't yet been called. If self._pending is True,

# messages have been removed, so _pre_mailbox_hook must

# have been called already.

self._pre_mailbox_hook(self._file)

try:

self._pre_message_hook(self._file)

offsets = self._install_message(message)

self._post_message_hook(self._file)

except BaseException:

self._file.truncate(before)

raise

self._file.flush()

self._file_length = self._file.tell() # Record current length of mailbox

return offsets

class _mboxMMDF(_singlefileMailbox):

"""An mbox or MMDF mailbox."""

_mangle_from_ = True

def get_message(self, key):

"""Return a Message representation or raise a KeyError."""

start, stop = self._lookup(key)

self._file.seek(start)

from_line = self._file.readline().replace(linesep, b'').decode('ascii')

string = self._file.read(stop - self._file.tell())

msg = self._message_factory(string.replace(linesep, b'\n'))

msg.set_unixfrom(from_line)

msg.set_from(from_line[5:])

return msg

def get_string(self, key, from_=False):

"""Return a string representation or raise a KeyError."""

return email.message_from_bytes(

self.get_bytes(key, from_)).as_string(unixfrom=from_)

def get_bytes(self, key, from_=False):

"""Return a string representation or raise a KeyError."""

start, stop = self._lookup(key)

self._file.seek(start)

if not from_:

self._file.readline()

string = self._file.read(stop - self._file.tell())

return string.replace(linesep, b'\n')

def get_file(self, key, from_=False):

"""Return a file-like representation or raise a KeyError."""

start, stop = self._lookup(key)

self._file.seek(start)

if not from_:

self._file.readline()

return _PartialFile(self._file, self._file.tell(), stop)

def _install_message(self, message):

"""Format a message and blindly write to self._file."""

from_line = None

if isinstance(message, str):

message = self._string_to_bytes(message)

if isinstance(message, bytes) and message.startswith(b'From '):

newline = message.find(b'\n')

if newline != -1:

from_line = message[:newline]

message = message[newline + 1:]

else:

from_line = message

message = b''

elif isinstance(message, _mboxMMDFMessage):

author = message.get_from().encode('ascii')

from_line = b'From ' + author

elif isinstance(message, email.message.Message):

from_line = message.get_unixfrom() # May be None.

if from_line is not None:

from_line = from_line.encode('ascii')

if from_line is None:

from_line = b'From MAILER-DAEMON ' + time.asctime(time.gmtime()).encode()

start = self._file.tell()

self._file.write(from_line + linesep)

self._dump_message(message, self._file, self._mangle_from_)

stop = self._file.tell()

return (start, stop)

class mbox(_mboxMMDF):

"""A classic mbox mailbox."""

_mangle_from_ = True

# All messages must end in a newline character, and

# _post_message_hooks outputs an empty line between messages.

_append_newline = True

def __init__(self, path, factory=None, create=True):

"""Initialize an mbox mailbox."""

self._message_factory = mboxMessage

_mboxMMDF.__init__(self, path, factory, create)

def _post_message_hook(self, f):

"""Called after writing each message to file f."""

f.write(linesep)

def _generate_toc(self):

"""Generate key-to-(start, stop) table of contents."""

starts, stops = [], []

last_was_empty = False

self._file.seek(0)

while True:

line_pos = self._file.tell()

line = self._file.readline()

if line.startswith(b'From '):

if len(stops) < len(starts):

if last_was_empty:

stops.append(line_pos - len(linesep))

else:

# The last line before the "From " line wasn't

# blank, but we consider it a start of a

# message anyway.

stops.append(line_pos)

starts.append(line_pos)

last_was_empty = False

elif not line:

if last_was_empty:

stops.append(line_pos - len(linesep))

else:

stops.append(line_pos)

break

elif line == linesep:

last_was_empty = True

else:

last_was_empty = False

self._toc = dict(enumerate(zip(starts, stops)))

self._next_key = len(self._toc)

self._file_length = self._file.tell()

class MMDF(_mboxMMDF):

"""An MMDF mailbox."""

def __init__(self, path, factory=None, create=True):

"""Initialize an MMDF mailbox."""

self._message_factory = MMDFMessage

_mboxMMDF.__init__(self, path, factory, create)

def _pre_message_hook(self, f):

"""Called before writing each message to file f."""

f.write(b'\001\001\001\001' + linesep)

def _post_message_hook(self, f):

"""Called after writing each message to file f."""

f.write(linesep + b'\001\001\001\001' + linesep)

def _generate_toc(self):

"""Generate key-to-(start, stop) table of contents."""

starts, stops = [], []

self._file.seek(0)

next_pos = 0

while True:

line_pos = next_pos

line = self._file.readline()

next_pos = self._file.tell()

if line.startswith(b'\001\001\001\001' + linesep):

starts.append(next_pos)

while True:

line_pos = next_pos

line = self._file.readline()

next_pos = self._file.tell()

if line == b'\001\001\001\001' + linesep:

stops.append(line_pos - len(linesep))

break

elif not line:

stops.append(line_pos)

break

elif not line:

break

self._toc = dict(enumerate(zip(starts, stops)))

self._next_key = len(self._toc)

self._file.seek(0, 2)

self._file_length = self._file.tell()

class MH(Mailbox):

"""An MH mailbox."""