986 lines
26 KiB
Python
986 lines
26 KiB
Python
# MH interface -- purely object-oriented (well, almost)
|
|
#
|
|
# Executive summary:
|
|
#
|
|
# import mhlib
|
|
#
|
|
# mh = mhlib.MH() # use default mailbox directory and profile
|
|
# mh = mhlib.MH(mailbox) # override mailbox location (default from profile)
|
|
# mh = mhlib.MH(mailbox, profile) # override mailbox and profile
|
|
#
|
|
# mh.error(format, ...) # print error message -- can be overridden
|
|
# s = mh.getprofile(key) # profile entry (None if not set)
|
|
# path = mh.getpath() # mailbox pathname
|
|
# name = mh.getcontext() # name of current folder
|
|
# mh.setcontext(name) # set name of current folder
|
|
#
|
|
# list = mh.listfolders() # names of top-level folders
|
|
# list = mh.listallfolders() # names of all folders, including subfolders
|
|
# list = mh.listsubfolders(name) # direct subfolders of given folder
|
|
# list = mh.listallsubfolders(name) # all subfolders of given folder
|
|
#
|
|
# mh.makefolder(name) # create new folder
|
|
# mh.deletefolder(name) # delete folder -- must have no subfolders
|
|
#
|
|
# f = mh.openfolder(name) # new open folder object
|
|
#
|
|
# f.error(format, ...) # same as mh.error(format, ...)
|
|
# path = f.getfullname() # folder's full pathname
|
|
# path = f.getsequencesfilename() # full pathname of folder's sequences file
|
|
# path = f.getmessagefilename(n) # full pathname of message n in folder
|
|
#
|
|
# list = f.listmessages() # list of messages in folder (as numbers)
|
|
# n = f.getcurrent() # get current message
|
|
# f.setcurrent(n) # set current message
|
|
# list = f.parsesequence(seq) # parse msgs syntax into list of messages
|
|
# n = f.getlast() # get last message (0 if no messagse)
|
|
# f.setlast(n) # set last message (internal use only)
|
|
#
|
|
# dict = f.getsequences() # dictionary of sequences in folder {name: list}
|
|
# f.putsequences(dict) # write sequences back to folder
|
|
#
|
|
# f.removemessages(list) # remove messages in list from folder
|
|
# f.refilemessages(list, tofolder) # move messages in list to other folder
|
|
# f.movemessage(n, tofolder, ton) # move one message to a given destination
|
|
# f.copymessage(n, tofolder, ton) # copy one message to a given destination
|
|
#
|
|
# m = f.openmessage(n) # new open message object (costs a file descriptor)
|
|
# m is a derived class of mimetools.Message(rfc822.Message), with:
|
|
# s = m.getheadertext() # text of message's headers
|
|
# s = m.getheadertext(pred) # text of message's headers, filtered by pred
|
|
# s = m.getbodytext() # text of message's body, decoded
|
|
# s = m.getbodytext(0) # text of message's body, not decoded
|
|
#
|
|
# XXX To do, functionality:
|
|
# - annotate messages
|
|
# - create, send messages
|
|
#
|
|
# XXX To do, organization:
|
|
# - move IntSet to separate file
|
|
# - move most Message functionality to module mimetools
|
|
|
|
|
|
# Customizable defaults
|
|
|
|
MH_PROFILE = '~/.mh_profile'
|
|
PATH = '~/Mail'
|
|
MH_SEQUENCES = '.mh_sequences'
|
|
FOLDER_PROTECT = 0700
|
|
|
|
|
|
# Imported modules
|
|
|
|
import os
|
|
import sys
|
|
from stat import ST_NLINK
|
|
import regex
|
|
import string
|
|
import mimetools
|
|
import multifile
|
|
import shutil
|
|
from bisect import bisect
|
|
|
|
|
|
# Exported constants
|
|
|
|
Error = 'mhlib.Error'
|
|
|
|
|
|
# Class representing a particular collection of folders.
|
|
# Optional constructor arguments are the pathname for the directory
|
|
# containing the collection, and the MH profile to use.
|
|
# If either is omitted or empty a default is used; the default
|
|
# directory is taken from the MH profile if it is specified there.
|
|
|
|
class MH:
|
|
|
|
# Constructor
|
|
def __init__(self, path = None, profile = None):
|
|
if not profile: profile = MH_PROFILE
|
|
self.profile = os.path.expanduser(profile)
|
|
if not path: path = self.getprofile('Path')
|
|
if not path: path = PATH
|
|
if not os.path.isabs(path) and path[0] != '~':
|
|
path = os.path.join('~', path)
|
|
path = os.path.expanduser(path)
|
|
if not os.path.isdir(path): raise Error, 'MH() path not found'
|
|
self.path = path
|
|
|
|
# String representation
|
|
def __repr__(self):
|
|
return 'MH(%s, %s)' % (`self.path`, `self.profile`)
|
|
|
|
# Routine to print an error. May be overridden by a derived class
|
|
def error(self, msg, *args):
|
|
sys.stderr.write('MH error: %s\n' % (msg % args))
|
|
|
|
# Return a profile entry, None if not found
|
|
def getprofile(self, key):
|
|
return pickline(self.profile, key)
|
|
|
|
# Return the path (the name of the collection's directory)
|
|
def getpath(self):
|
|
return self.path
|
|
|
|
# Return the name of the current folder
|
|
def getcontext(self):
|
|
context = pickline(os.path.join(self.getpath(), 'context'),
|
|
'Current-Folder')
|
|
if not context: context = 'inbox'
|
|
return context
|
|
|
|
# Set the name of the current folder
|
|
def setcontext(self, context):
|
|
fn = os.path.join(self.getpath(), 'context')
|
|
f = open(fn, "w")
|
|
f.write("Current-Folder: %s\n" % context)
|
|
f.close()
|
|
|
|
# Return the names of the top-level folders
|
|
def listfolders(self):
|
|
folders = []
|
|
path = self.getpath()
|
|
for name in os.listdir(path):
|
|
fullname = os.path.join(path, name)
|
|
if os.path.isdir(fullname):
|
|
folders.append(name)
|
|
folders.sort()
|
|
return folders
|
|
|
|
# Return the names of the subfolders in a given folder
|
|
# (prefixed with the given folder name)
|
|
def listsubfolders(self, name):
|
|
fullname = os.path.join(self.path, name)
|
|
# Get the link count so we can avoid listing folders
|
|
# that have no subfolders.
|
|
st = os.stat(fullname)
|
|
nlinks = st[ST_NLINK]
|
|
if nlinks <= 2:
|
|
return []
|
|
subfolders = []
|
|
subnames = os.listdir(fullname)
|
|
for subname in subnames:
|
|
fullsubname = os.path.join(fullname, subname)
|
|
if os.path.isdir(fullsubname):
|
|
name_subname = os.path.join(name, subname)
|
|
subfolders.append(name_subname)
|
|
# Stop looking for subfolders when
|
|
# we've seen them all
|
|
nlinks = nlinks - 1
|
|
if nlinks <= 2:
|
|
break
|
|
subfolders.sort()
|
|
return subfolders
|
|
|
|
# Return the names of all folders, including subfolders, recursively
|
|
def listallfolders(self):
|
|
return self.listallsubfolders('')
|
|
|
|
# Return the names of subfolders in a given folder, recursively
|
|
def listallsubfolders(self, name):
|
|
fullname = os.path.join(self.path, name)
|
|
# Get the link count so we can avoid listing folders
|
|
# that have no subfolders.
|
|
st = os.stat(fullname)
|
|
nlinks = st[ST_NLINK]
|
|
if nlinks <= 2:
|
|
return []
|
|
subfolders = []
|
|
subnames = os.listdir(fullname)
|
|
for subname in subnames:
|
|
if subname[0] == ',' or isnumeric(subname): continue
|
|
fullsubname = os.path.join(fullname, subname)
|
|
if os.path.isdir(fullsubname):
|
|
name_subname = os.path.join(name, subname)
|
|
subfolders.append(name_subname)
|
|
if not os.path.islink(fullsubname):
|
|
subsubfolders = self.listallsubfolders(
|
|
name_subname)
|
|
subfolders = subfolders + subsubfolders
|
|
# Stop looking for subfolders when
|
|
# we've seen them all
|
|
nlinks = nlinks - 1
|
|
if nlinks <= 2:
|
|
break
|
|
subfolders.sort()
|
|
return subfolders
|
|
|
|
# Return a new Folder object for the named folder
|
|
def openfolder(self, name):
|
|
return Folder(self, name)
|
|
|
|
# Create a new folder. This raises os.error if the folder
|
|
# cannot be created
|
|
def makefolder(self, name):
|
|
protect = pickline(self.profile, 'Folder-Protect')
|
|
if protect and isnumeric(protect):
|
|
mode = string.atoi(protect, 8)
|
|
else:
|
|
mode = FOLDER_PROTECT
|
|
os.mkdir(os.path.join(self.getpath(), name), mode)
|
|
|
|
# Delete a folder. This removes files in the folder but not
|
|
# subdirectories. If deleting the folder itself fails it
|
|
# raises os.error
|
|
def deletefolder(self, name):
|
|
fullname = os.path.join(self.getpath(), name)
|
|
for subname in os.listdir(fullname):
|
|
fullsubname = os.path.join(fullname, subname)
|
|
try:
|
|
os.unlink(fullsubname)
|
|
except os.error:
|
|
self.error('%s not deleted, continuing...' %
|
|
fullsubname)
|
|
os.rmdir(fullname)
|
|
|
|
|
|
# Class representing a particular folder
|
|
|
|
numericprog = regex.compile('^[1-9][0-9]*$')
|
|
def isnumeric(str):
|
|
return numericprog.match(str) >= 0
|
|
|
|
class Folder:
|
|
|
|
# Constructor
|
|
def __init__(self, mh, name):
|
|
self.mh = mh
|
|
self.name = name
|
|
if not os.path.isdir(self.getfullname()):
|
|
raise Error, 'no folder %s' % name
|
|
|
|
# String representation
|
|
def __repr__(self):
|
|
return 'Folder(%s, %s)' % (`self.mh`, `self.name`)
|
|
|
|
# Error message handler
|
|
def error(self, *args):
|
|
apply(self.mh.error, args)
|
|
|
|
# Return the full pathname of the folder
|
|
def getfullname(self):
|
|
return os.path.join(self.mh.path, self.name)
|
|
|
|
# Return the full pathname of the folder's sequences file
|
|
def getsequencesfilename(self):
|
|
return os.path.join(self.getfullname(), MH_SEQUENCES)
|
|
|
|
# Return the full pathname of a message in the folder
|
|
def getmessagefilename(self, n):
|
|
return os.path.join(self.getfullname(), str(n))
|
|
|
|
# Return list of direct subfolders
|
|
def listsubfolders(self):
|
|
return self.mh.listsubfolders(self.name)
|
|
|
|
# Return list of all subfolders
|
|
def listallsubfolders(self):
|
|
return self.mh.listallsubfolders(self.name)
|
|
|
|
# Return the list of messages currently present in the folder.
|
|
# As a side effect, set self.last to the last message (or 0)
|
|
def listmessages(self):
|
|
messages = []
|
|
match = numericprog.match
|
|
append = messages.append
|
|
for name in os.listdir(self.getfullname()):
|
|
if match(name) >= 0:
|
|
append(name)
|
|
messages = map(string.atoi, messages)
|
|
messages.sort()
|
|
if messages:
|
|
self.last = messages[-1]
|
|
else:
|
|
self.last = 0
|
|
return messages
|
|
|
|
# Return the set of sequences for the folder
|
|
def getsequences(self):
|
|
sequences = {}
|
|
fullname = self.getsequencesfilename()
|
|
try:
|
|
f = open(fullname, 'r')
|
|
except IOError:
|
|
return sequences
|
|
while 1:
|
|
line = f.readline()
|
|
if not line: break
|
|
fields = string.splitfields(line, ':')
|
|
if len(fields) <> 2:
|
|
self.error('bad sequence in %s: %s' %
|
|
(fullname, string.strip(line)))
|
|
key = string.strip(fields[0])
|
|
value = IntSet(string.strip(fields[1]), ' ').tolist()
|
|
sequences[key] = value
|
|
return sequences
|
|
|
|
# Write the set of sequences back to the folder
|
|
def putsequences(self, sequences):
|
|
fullname = self.getsequencesfilename()
|
|
f = None
|
|
for key in sequences.keys():
|
|
s = IntSet('', ' ')
|
|
s.fromlist(sequences[key])
|
|
if not f: f = open(fullname, 'w')
|
|
f.write('%s: %s\n' % (key, s.tostring()))
|
|
if not f:
|
|
try:
|
|
os.unlink(fullname)
|
|
except os.error:
|
|
pass
|
|
else:
|
|
f.close()
|
|
|
|
# Return the current message. Raise KeyError when there is none
|
|
def getcurrent(self):
|
|
seqs = self.getsequences()
|
|
try:
|
|
return max(seqs['cur'])
|
|
except (ValueError, KeyError):
|
|
raise Error, "no cur message"
|
|
|
|
# Set the current message
|
|
def setcurrent(self, n):
|
|
updateline(self.getsequencesfilename(), 'cur', str(n), 0)
|
|
|
|
# Parse an MH sequence specification into a message list.
|
|
# Attempt to mimic mh-sequence(5) as close as possible.
|
|
# Also attempt to mimic observed behavior regarding which
|
|
# conditions cause which error messages
|
|
def parsesequence(self, seq):
|
|
# XXX Still not complete (see mh-format(5)).
|
|
# Missing are:
|
|
# - 'prev', 'next' as count
|
|
# - Sequence-Negation option
|
|
all = self.listmessages()
|
|
# Observed behavior: test for empty folder is done first
|
|
if not all:
|
|
raise Error, "no messages in %s" % self.name
|
|
# Common case first: all is frequently the default
|
|
if seq == 'all':
|
|
return all
|
|
# Test for X:Y before X-Y because 'seq:-n' matches both
|
|
i = string.find(seq, ':')
|
|
if i >= 0:
|
|
head, dir, tail = seq[:i], '', seq[i+1:]
|
|
if tail[:1] in '-+':
|
|
dir, tail = tail[:1], tail[1:]
|
|
if not isnumeric(tail):
|
|
raise Error, "bad message list %s" % seq
|
|
try:
|
|
count = string.atoi(tail)
|
|
except (ValueError, OverflowError):
|
|
# Can't use sys.maxint because of i+count below
|
|
count = len(all)
|
|
try:
|
|
anchor = self._parseindex(head, all)
|
|
except Error, msg:
|
|
seqs = self.getsequences()
|
|
if not seqs.has_key(head):
|
|
if not msg:
|
|
msg = "bad message list %s" % seq
|
|
raise Error, msg, sys.exc_traceback
|
|
msgs = seqs[head]
|
|
if not msgs:
|
|
raise Error, "sequence %s empty" % head
|
|
if dir == '-':
|
|
return msgs[-count:]
|
|
else:
|
|
return msgs[:count]
|
|
else:
|
|
if not dir:
|
|
if head in ('prev', 'last'):
|
|
dir = '-'
|
|
if dir == '-':
|
|
i = bisect(all, anchor)
|
|
return all[max(0, i-count):i]
|
|
else:
|
|
i = bisect(all, anchor-1)
|
|
return all[i:i+count]
|
|
# Test for X-Y next
|
|
i = string.find(seq, '-')
|
|
if i >= 0:
|
|
begin = self._parseindex(seq[:i], all)
|
|
end = self._parseindex(seq[i+1:], all)
|
|
i = bisect(all, begin-1)
|
|
j = bisect(all, end)
|
|
r = all[i:j]
|
|
if not r:
|
|
raise Error, "bad message list %s" % seq
|
|
return r
|
|
# Neither X:Y nor X-Y; must be a number or a (pseudo-)sequence
|
|
try:
|
|
n = self._parseindex(seq, all)
|
|
except Error, msg:
|
|
seqs = self.getsequences()
|
|
if not seqs.has_key(seq):
|
|
if not msg:
|
|
msg = "bad message list %s" % seq
|
|
raise Error, msg
|
|
return seqs[seq]
|
|
else:
|
|
if n not in all:
|
|
if isnumeric(seq):
|
|
raise Error, \
|
|
"message %d doesn't exist" % n
|
|
else:
|
|
raise Error, "no %s message" % seq
|
|
else:
|
|
return [n]
|
|
|
|
# Internal: parse a message number (or cur, first, etc.)
|
|
def _parseindex(self, seq, all):
|
|
if isnumeric(seq):
|
|
try:
|
|
return string.atoi(seq)
|
|
except (OverflowError, ValueError):
|
|
return sys.maxint
|
|
if seq in ('cur', '.'):
|
|
return self.getcurrent()
|
|
if seq == 'first':
|
|
return all[0]
|
|
if seq == 'last':
|
|
return all[-1]
|
|
if seq == 'next':
|
|
n = self.getcurrent()
|
|
i = bisect(all, n)
|
|
try:
|
|
return all[i]
|
|
except IndexError:
|
|
raise Error, "no next message"
|
|
if seq == 'prev':
|
|
n = self.getcurrent()
|
|
i = bisect(all, n-1)
|
|
if i == 0:
|
|
raise Error, "no prev message"
|
|
try:
|
|
return all[i-1]
|
|
except IndexError:
|
|
raise Error, "no prev message"
|
|
raise Error, None
|
|
|
|
# Open a message -- returns a Message object
|
|
def openmessage(self, n):
|
|
return Message(self, n)
|
|
|
|
# Remove one or more messages -- may raise os.error
|
|
def removemessages(self, list):
|
|
errors = []
|
|
deleted = []
|
|
for n in list:
|
|
path = self.getmessagefilename(n)
|
|
commapath = self.getmessagefilename(',' + str(n))
|
|
try:
|
|
os.unlink(commapath)
|
|
except os.error:
|
|
pass
|
|
try:
|
|
os.rename(path, commapath)
|
|
except os.error, msg:
|
|
errors.append(msg)
|
|
else:
|
|
deleted.append(n)
|
|
if deleted:
|
|
self.removefromallsequences(deleted)
|
|
if errors:
|
|
if len(errors) == 1:
|
|
raise os.error, errors[0]
|
|
else:
|
|
raise os.error, ('multiple errors:', errors)
|
|
|
|
# Refile one or more messages -- may raise os.error.
|
|
# 'tofolder' is an open folder object
|
|
def refilemessages(self, list, tofolder, keepsequences=0):
|
|
errors = []
|
|
refiled = {}
|
|
for n in list:
|
|
ton = tofolder.getlast() + 1
|
|
path = self.getmessagefilename(n)
|
|
topath = tofolder.getmessagefilename(ton)
|
|
try:
|
|
os.rename(path, topath)
|
|
except os.error:
|
|
# Try copying
|
|
try:
|
|
shutil.copy2(path, topath)
|
|
os.unlink(path)
|
|
except (IOError, os.error), msg:
|
|
errors.append(msg)
|
|
try:
|
|
os.unlink(topath)
|
|
except os.error:
|
|
pass
|
|
continue
|
|
tofolder.setlast(ton)
|
|
refiled[n] = ton
|
|
if refiled:
|
|
if keepsequences:
|
|
tofolder._copysequences(self, refiled.items())
|
|
self.removefromallsequences(refiled.keys())
|
|
if errors:
|
|
if len(errors) == 1:
|
|
raise os.error, errors[0]
|
|
else:
|
|
raise os.error, ('multiple errors:', errors)
|
|
|
|
# Helper for refilemessages() to copy sequences
|
|
def _copysequences(self, fromfolder, refileditems):
|
|
fromsequences = fromfolder.getsequences()
|
|
tosequences = self.getsequences()
|
|
changed = 0
|
|
for name, seq in fromsequences.items():
|
|
try:
|
|
toseq = tosequences[name]
|
|
new = 0
|
|
except:
|
|
toseq = []
|
|
new = 1
|
|
for fromn, ton in refileditems:
|
|
if fromn in seq:
|
|
toseq.append(ton)
|
|
changed = 1
|
|
if new and toseq:
|
|
tosequences[name] = toseq
|
|
if changed:
|
|
self.putsequences(tosequences)
|
|
|
|
# Move one message over a specific destination message,
|
|
# which may or may not already exist.
|
|
def movemessage(self, n, tofolder, ton):
|
|
path = self.getmessagefilename(n)
|
|
# Open it to check that it exists
|
|
f = open(path)
|
|
f.close()
|
|
del f
|
|
topath = tofolder.getmessagefilename(ton)
|
|
backuptopath = tofolder.getmessagefilename(',%d' % ton)
|
|
try:
|
|
os.rename(topath, backuptopath)
|
|
except os.error:
|
|
pass
|
|
try:
|
|
os.rename(path, topath)
|
|
except os.error:
|
|
# Try copying
|
|
ok = 0
|
|
try:
|
|
tofolder.setlast(None)
|
|
shutil.copy2(path, topath)
|
|
ok = 1
|
|
finally:
|
|
if not ok:
|
|
try:
|
|
os.unlink(topath)
|
|
except os.error:
|
|
pass
|
|
os.unlink(path)
|
|
self.removefromallsequences([n])
|
|
|
|
# Copy one message over a specific destination message,
|
|
# which may or may not already exist.
|
|
def copymessage(self, n, tofolder, ton):
|
|
path = self.getmessagefilename(n)
|
|
# Open it to check that it exists
|
|
f = open(path)
|
|
f.close()
|
|
del f
|
|
topath = tofolder.getmessagefilename(ton)
|
|
backuptopath = tofolder.getmessagefilename(',%d' % ton)
|
|
try:
|
|
os.rename(topath, backuptopath)
|
|
except os.error:
|
|
pass
|
|
ok = 0
|
|
try:
|
|
tofolder.setlast(None)
|
|
shutil.copy2(path, topath)
|
|
ok = 1
|
|
finally:
|
|
if not ok:
|
|
try:
|
|
os.unlink(topath)
|
|
except os.error:
|
|
pass
|
|
|
|
# Remove one or more messages from all sequeuces (including last)
|
|
# -- but not from 'cur'!!!
|
|
def removefromallsequences(self, list):
|
|
if hasattr(self, 'last') and self.last in list:
|
|
del self.last
|
|
sequences = self.getsequences()
|
|
changed = 0
|
|
for name, seq in sequences.items():
|
|
if name == 'cur':
|
|
continue
|
|
for n in list:
|
|
if n in seq:
|
|
seq.remove(n)
|
|
changed = 1
|
|
if not seq:
|
|
del sequences[name]
|
|
if changed:
|
|
self.putsequences(sequences)
|
|
|
|
# Return the last message number
|
|
def getlast(self):
|
|
if not hasattr(self, 'last'):
|
|
messages = self.listmessages()
|
|
return self.last
|
|
|
|
# Set the last message number
|
|
def setlast(self, last):
|
|
if last is None:
|
|
if hasattr(self, 'last'):
|
|
del self.last
|
|
else:
|
|
self.last = last
|
|
|
|
class Message(mimetools.Message):
|
|
|
|
# Constructor
|
|
def __init__(self, f, n, fp = None):
|
|
self.folder = f
|
|
self.number = n
|
|
if not fp:
|
|
path = f.getmessagefilename(n)
|
|
fp = open(path, 'r')
|
|
mimetools.Message.__init__(self, fp)
|
|
|
|
# String representation
|
|
def __repr__(self):
|
|
return 'Message(%s, %s)' % (repr(self.folder), self.number)
|
|
|
|
# Return the message's header text as a string. If an
|
|
# argument is specified, it is used as a filter predicate to
|
|
# decide which headers to return (its argument is the header
|
|
# name converted to lower case).
|
|
def getheadertext(self, pred = None):
|
|
if not pred:
|
|
return string.joinfields(self.headers, '')
|
|
headers = []
|
|
hit = 0
|
|
for line in self.headers:
|
|
if line[0] not in string.whitespace:
|
|
i = string.find(line, ':')
|
|
if i > 0:
|
|
hit = pred(string.lower(line[:i]))
|
|
if hit: headers.append(line)
|
|
return string.joinfields(headers, '')
|
|
|
|
# Return the message's body text as string. This undoes a
|
|
# Content-Transfer-Encoding, but does not interpret other MIME
|
|
# features (e.g. multipart messages). To suppress to
|
|
# decoding, pass a 0 as argument
|
|
def getbodytext(self, decode = 1):
|
|
self.fp.seek(self.startofbody)
|
|
encoding = self.getencoding()
|
|
if not decode or encoding in ('7bit', '8bit', 'binary'):
|
|
return self.fp.read()
|
|
from StringIO import StringIO
|
|
output = StringIO()
|
|
mimetools.decode(self.fp, output, encoding)
|
|
return output.getvalue()
|
|
|
|
# Only for multipart messages: return the message's body as a
|
|
# list of SubMessage objects. Each submessage object behaves
|
|
# (almost) as a Message object.
|
|
def getbodyparts(self):
|
|
if self.getmaintype() != 'multipart':
|
|
raise Error, \
|
|
'Content-Type is not multipart/*'
|
|
bdry = self.getparam('boundary')
|
|
if not bdry:
|
|
raise Error, 'multipart/* without boundary param'
|
|
self.fp.seek(self.startofbody)
|
|
mf = multifile.MultiFile(self.fp)
|
|
mf.push(bdry)
|
|
parts = []
|
|
while mf.next():
|
|
n = str(self.number) + '.' + `1 + len(parts)`
|
|
part = SubMessage(self.folder, n, mf)
|
|
parts.append(part)
|
|
mf.pop()
|
|
return parts
|
|
|
|
# Return body, either a string or a list of messages
|
|
def getbody(self):
|
|
if self.getmaintype() == 'multipart':
|
|
return self.getbodyparts()
|
|
else:
|
|
return self.getbodytext()
|
|
|
|
|
|
class SubMessage(Message):
|
|
|
|
# Constructor
|
|
def __init__(self, f, n, fp):
|
|
Message.__init__(self, f, n, fp)
|
|
if self.getmaintype() == 'multipart':
|
|
self.body = Message.getbodyparts(self)
|
|
else:
|
|
self.body = Message.getbodytext(self)
|
|
# XXX If this is big, should remember file pointers
|
|
|
|
# String representation
|
|
def __repr__(self):
|
|
f, n, fp = self.folder, self.number, self.fp
|
|
return 'SubMessage(%s, %s, %s)' % (f, n, fp)
|
|
|
|
def getbodytext(self):
|
|
if type(self.body) == type(''):
|
|
return self.body
|
|
|
|
def getbodyparts(self):
|
|
if type(self.body) == type([]):
|
|
return self.body
|
|
|
|
def getbody(self):
|
|
return self.body
|
|
|
|
|
|
# Class implementing sets of integers.
|
|
#
|
|
# This is an efficient representation for sets consisting of several
|
|
# continuous ranges, e.g. 1-100,200-400,402-1000 is represented
|
|
# internally as a list of three pairs: [(1,100), (200,400),
|
|
# (402,1000)]. The internal representation is always kept normalized.
|
|
#
|
|
# The constructor has up to three arguments:
|
|
# - the string used to initialize the set (default ''),
|
|
# - the separator between ranges (default ',')
|
|
# - the separator between begin and end of a range (default '-')
|
|
# The separators may be regular expressions and should be different.
|
|
#
|
|
# The tostring() function yields a string that can be passed to another
|
|
# IntSet constructor; __repr__() is a valid IntSet constructor itself.
|
|
#
|
|
# XXX The default begin/end separator means that negative numbers are
|
|
# not supported very well.
|
|
#
|
|
# XXX There are currently no operations to remove set elements.
|
|
|
|
class IntSet:
|
|
|
|
def __init__(self, data = None, sep = ',', rng = '-'):
|
|
self.pairs = []
|
|
self.sep = sep
|
|
self.rng = rng
|
|
if data: self.fromstring(data)
|
|
|
|
def reset(self):
|
|
self.pairs = []
|
|
|
|
def __cmp__(self, other):
|
|
return cmp(self.pairs, other.pairs)
|
|
|
|
def __hash__(self):
|
|
return hash(self.pairs)
|
|
|
|
def __repr__(self):
|
|
return 'IntSet(%s, %s, %s)' % (`self.tostring()`,
|
|
`self.sep`, `self.rng`)
|
|
|
|
def normalize(self):
|
|
self.pairs.sort()
|
|
i = 1
|
|
while i < len(self.pairs):
|
|
alo, ahi = self.pairs[i-1]
|
|
blo, bhi = self.pairs[i]
|
|
if ahi >= blo-1:
|
|
self.pairs[i-1:i+1] = [(alo, max(ahi, bhi))]
|
|
else:
|
|
i = i+1
|
|
|
|
def tostring(self):
|
|
s = ''
|
|
for lo, hi in self.pairs:
|
|
if lo == hi: t = `lo`
|
|
else: t = `lo` + self.rng + `hi`
|
|
if s: s = s + (self.sep + t)
|
|
else: s = t
|
|
return s
|
|
|
|
def tolist(self):
|
|
l = []
|
|
for lo, hi in self.pairs:
|
|
m = range(lo, hi+1)
|
|
l = l + m
|
|
return l
|
|
|
|
def fromlist(self, list):
|
|
for i in list:
|
|
self.append(i)
|
|
|
|
def clone(self):
|
|
new = IntSet()
|
|
new.pairs = self.pairs[:]
|
|
return new
|
|
|
|
def min(self):
|
|
return self.pairs[0][0]
|
|
|
|
def max(self):
|
|
return self.pairs[-1][-1]
|
|
|
|
def contains(self, x):
|
|
for lo, hi in self.pairs:
|
|
if lo <= x <= hi: return 1
|
|
return 0
|
|
|
|
def append(self, x):
|
|
for i in range(len(self.pairs)):
|
|
lo, hi = self.pairs[i]
|
|
if x < lo: # Need to insert before
|
|
if x+1 == lo:
|
|
self.pairs[i] = (x, hi)
|
|
else:
|
|
self.pairs.insert(i, (x, x))
|
|
if i > 0 and x-1 == self.pairs[i-1][1]:
|
|
# Merge with previous
|
|
self.pairs[i-1:i+1] = [
|
|
(self.pairs[i-1][0],
|
|
self.pairs[i][1])
|
|
]
|
|
return
|
|
if x <= hi: # Already in set
|
|
return
|
|
i = len(self.pairs) - 1
|
|
if i >= 0:
|
|
lo, hi = self.pairs[i]
|
|
if x-1 == hi:
|
|
self.pairs[i] = lo, x
|
|
return
|
|
self.pairs.append((x, x))
|
|
|
|
def addpair(self, xlo, xhi):
|
|
if xlo > xhi: return
|
|
self.pairs.append((xlo, xhi))
|
|
self.normalize()
|
|
|
|
def fromstring(self, data):
|
|
import string, regsub
|
|
new = []
|
|
for part in regsub.split(data, self.sep):
|
|
list = []
|
|
for subp in regsub.split(part, self.rng):
|
|
s = string.strip(subp)
|
|
list.append(string.atoi(s))
|
|
if len(list) == 1:
|
|
new.append((list[0], list[0]))
|
|
elif len(list) == 2 and list[0] <= list[1]:
|
|
new.append((list[0], list[1]))
|
|
else:
|
|
raise ValueError, 'bad data passed to IntSet'
|
|
self.pairs = self.pairs + new
|
|
self.normalize()
|
|
|
|
|
|
# Subroutines to read/write entries in .mh_profile and .mh_sequences
|
|
|
|
def pickline(file, key, casefold = 1):
|
|
try:
|
|
f = open(file, 'r')
|
|
except IOError:
|
|
return None
|
|
pat = key + ':'
|
|
if casefold:
|
|
prog = regex.compile(pat, regex.casefold)
|
|
else:
|
|
prog = regex.compile(pat)
|
|
while 1:
|
|
line = f.readline()
|
|
if not line: break
|
|
if prog.match(line) >= 0:
|
|
text = line[len(key)+1:]
|
|
while 1:
|
|
line = f.readline()
|
|
if not line or \
|
|
line[0] not in string.whitespace:
|
|
break
|
|
text = text + line
|
|
return string.strip(text)
|
|
return None
|
|
|
|
def updateline(file, key, value, casefold = 1):
|
|
try:
|
|
f = open(file, 'r')
|
|
lines = f.readlines()
|
|
f.close()
|
|
except IOError:
|
|
lines = []
|
|
pat = key + ':\(.*\)\n'
|
|
if casefold:
|
|
prog = regex.compile(pat, regex.casefold)
|
|
else:
|
|
prog = regex.compile(pat)
|
|
if value is None:
|
|
newline = None
|
|
else:
|
|
newline = '%s: %s\n' % (key, value)
|
|
for i in range(len(lines)):
|
|
line = lines[i]
|
|
if prog.match(line) == len(line):
|
|
if newline is None:
|
|
del lines[i]
|
|
else:
|
|
lines[i] = newline
|
|
break
|
|
else:
|
|
if newline is not None:
|
|
lines.append(newline)
|
|
tempfile = file + "~"
|
|
f = open(tempfile, 'w')
|
|
for line in lines:
|
|
f.write(line)
|
|
f.close()
|
|
os.rename(tempfile, file)
|
|
|
|
|
|
# Test program
|
|
|
|
def test():
|
|
global mh, f
|
|
os.system('rm -rf $HOME/Mail/@test')
|
|
mh = MH()
|
|
def do(s): print s; print eval(s)
|
|
do('mh.listfolders()')
|
|
do('mh.listallfolders()')
|
|
testfolders = ['@test', '@test/test1', '@test/test2',
|
|
'@test/test1/test11', '@test/test1/test12',
|
|
'@test/test1/test11/test111']
|
|
for t in testfolders: do('mh.makefolder(%s)' % `t`)
|
|
do('mh.listsubfolders(\'@test\')')
|
|
do('mh.listallsubfolders(\'@test\')')
|
|
f = mh.openfolder('@test')
|
|
do('f.listsubfolders()')
|
|
do('f.listallsubfolders()')
|
|
do('f.getsequences()')
|
|
seqs = f.getsequences()
|
|
seqs['foo'] = IntSet('1-10 12-20', ' ').tolist()
|
|
print seqs
|
|
f.putsequences(seqs)
|
|
do('f.getsequences()')
|
|
testfolders.reverse()
|
|
for t in testfolders: do('mh.deletefolder(%s)' % `t`)
|
|
do('mh.getcontext()')
|
|
context = mh.getcontext()
|
|
f = mh.openfolder(context)
|
|
do('f.getcurrent()')
|
|
for seq in ['first', 'last', 'cur', '.', 'prev', 'next',
|
|
'first:3', 'last:3', 'cur:3', 'cur:-3',
|
|
'prev:3', 'next:3',
|
|
'1:3', '1:-3', '100:3', '100:-3', '10000:3', '10000:-3',
|
|
'all']:
|
|
try:
|
|
do('f.parsesequence(%s)' % `seq`)
|
|
except Error, msg:
|
|
print "Error:", msg
|
|
stuff = os.popen("pick %s 2>/dev/null" % `seq`).read()
|
|
list = map(string.atoi, string.split(stuff))
|
|
print list, "<-- pick"
|
|
do('f.listmessages()')
|
|
|
|
|
|
if __name__ == '__main__':
|
|
test()
|