AppPkg/Applications/Python/Python-2.7.2/Lib/mhlib.py

   1 """MH interface -- purely object-oriented (well, almost)
   2
   3 Executive summary:
   4
   5 import mhlib
   6
   7 mh = mhlib.MH()         # use default mailbox directory and profile
   8 mh = mhlib.MH(mailbox)  # override mailbox location (default from profile)
   9 mh = mhlib.MH(mailbox, profile) # override mailbox and profile
  10
  11 mh.error(format, ...)   # print error message -- can be overridden
  12 s = mh.getprofile(key)  # profile entry (None if not set)
  13 path = mh.getpath()     # mailbox pathname
  14 name = mh.getcontext()  # name of current folder
  15 mh.setcontext(name)     # set name of current folder
  16
  17 list = mh.listfolders() # names of top-level folders
  18 list = mh.listallfolders() # names of all folders, including subfolders
  19 list = mh.listsubfolders(name) # direct subfolders of given folder
  20 list = mh.listallsubfolders(name) # all subfolders of given folder
  21
  22 mh.makefolder(name)     # create new folder
  23 mh.deletefolder(name)   # delete folder -- must have no subfolders
  24
  25 f = mh.openfolder(name) # new open folder object
  26
  27 f.error(format, ...)    # same as mh.error(format, ...)
  28 path = f.getfullname()  # folder's full pathname
  29 path = f.getsequencesfilename() # full pathname of folder's sequences file
  30 path = f.getmessagefilename(n)  # full pathname of message n in folder
  31
  32 list = f.listmessages() # list of messages in folder (as numbers)
  33 n = f.getcurrent()      # get current message
  34 f.setcurrent(n)         # set current message
  35 list = f.parsesequence(seq)     # parse msgs syntax into list of messages
  36 n = f.getlast()         # get last message (0 if no messagse)
  37 f.setlast(n)            # set last message (internal use only)
  38
  39 dict = f.getsequences() # dictionary of sequences in folder {name: list}
  40 f.putsequences(dict)    # write sequences back to folder
  41
  42 f.createmessage(n, fp)  # add message from file f as number n
  43 f.removemessages(list)  # remove messages in list from folder
  44 f.refilemessages(list, tofolder) # move messages in list to other folder
  45 f.movemessage(n, tofolder, ton)  # move one message to a given destination
  46 f.copymessage(n, tofolder, ton)  # copy one message to a given destination
  47
  48 m = f.openmessage(n)    # new open message object (costs a file descriptor)
  49 m is a derived class of mimetools.Message(rfc822.Message), with:
  50 s = m.getheadertext()   # text of message's headers
  51 s = m.getheadertext(pred) # text of message's headers, filtered by pred
  52 s = m.getbodytext()     # text of message's body, decoded
  53 s = m.getbodytext(0)    # text of message's body, not decoded
  54 """
  55 from warnings import warnpy3k
  56 warnpy3k("the mhlib module has been removed in Python 3.0; use the mailbox "
  57             "module instead", stacklevel=2)
  58 del warnpy3k
  59
  60 # XXX To do, functionality:
  61 # - annotate messages
  62 # - send messages
  63 #
  64 # XXX To do, organization:
  65 # - move IntSet to separate file
  66 # - move most Message functionality to module mimetools
  67
  68
  69 # Customizable defaults
  70
  71 MH_PROFILE = '~/.mh_profile'
  72 PATH = '~/Mail'
  73 MH_SEQUENCES = '.mh_sequences'
  74 FOLDER_PROTECT = 0700
  75
  76
  77 # Imported modules
  78
  79 import os
  80 import sys
  81 import re
  82 import mimetools
  83 import multifile
  84 import shutil
  85 from bisect import bisect
  86
  87 __all__ = ["MH","Error","Folder","Message"]
  88
  89 # Exported constants
  90
  91 class Error(Exception):
  92     pass
  93
  94
  95 class MH:
  96     """Class representing a particular collection of folders.
  97     Optional constructor arguments are the pathname for the directory
  98     containing the collection, and the MH profile to use.
  99     If either is omitted or empty a default is used; the default
 100     directory is taken from the MH profile if it is specified there."""
 101
 102     def __init__(self, path = None, profile = None):
 103         """Constructor."""
 104         if profile is None: profile = MH_PROFILE
 105         self.profile = os.path.expanduser(profile)
 106         if path is None: path = self.getprofile('Path')
 107         if not path: path = PATH
 108         if not os.path.isabs(path) and path[0] != '~':
 109             path = os.path.join('~', path)
 110         path = os.path.expanduser(path)
 111         if not os.path.isdir(path): raise Error, 'MH() path not found'
 112         self.path = path
 113
 114     def __repr__(self):
 115         """String representation."""
 116         return 'MH(%r, %r)' % (self.path, self.profile)
 117
 118     def error(self, msg, *args):
 119         """Routine to print an error.  May be overridden by a derived class."""
 120         sys.stderr.write('MH error: %s\n' % (msg % args))
 121
 122     def getprofile(self, key):
 123         """Return a profile entry, None if not found."""
 124         return pickline(self.profile, key)
 125
 126     def getpath(self):
 127         """Return the path (the name of the collection's directory)."""
 128         return self.path
 129
 130     def getcontext(self):
 131         """Return the name of the current folder."""
 132         context = pickline(os.path.join(self.getpath(), 'context'),
 133                   'Current-Folder')
 134         if not context: context = 'inbox'
 135         return context
 136
 137     def setcontext(self, context):
 138         """Set the name of the current folder."""
 139         fn = os.path.join(self.getpath(), 'context')
 140         f = open(fn, "w")
 141         f.write("Current-Folder: %s\n" % context)
 142         f.close()
 143
 144     def listfolders(self):
 145         """Return the names of the top-level folders."""
 146         folders = []
 147         path = self.getpath()
 148         for name in os.listdir(path):
 149             fullname = os.path.join(path, name)
 150             if os.path.isdir(fullname):
 151                 folders.append(name)
 152         folders.sort()
 153         return folders
 154
 155     def listsubfolders(self, name):
 156         """Return the names of the subfolders in a given folder
 157         (prefixed with the given folder name)."""
 158         fullname = os.path.join(self.path, name)
 159         # Get the link count so we can avoid listing folders
 160         # that have no subfolders.
 161         nlinks = os.stat(fullname).st_nlink
 162         if nlinks <= 2:
 163             return []
 164         subfolders = []
 165         subnames = os.listdir(fullname)
 166         for subname in subnames:
 167             fullsubname = os.path.join(fullname, subname)
 168             if os.path.isdir(fullsubname):
 169                 name_subname = os.path.join(name, subname)
 170                 subfolders.append(name_subname)
 171                 # Stop looking for subfolders when
 172                 # we've seen them all
 173                 nlinks = nlinks - 1
 174                 if nlinks <= 2:
 175                     break
 176         subfolders.sort()
 177         return subfolders
 178
 179     def listallfolders(self):
 180         """Return the names of all folders and subfolders, recursively."""
 181         return self.listallsubfolders('')
 182
 183     def listallsubfolders(self, name):
 184         """Return the names of subfolders in a given folder, recursively."""
 185         fullname = os.path.join(self.path, name)
 186         # Get the link count so we can avoid listing folders
 187         # that have no subfolders.
 188         nlinks = os.stat(fullname).st_nlink
 189         if nlinks <= 2:
 190             return []
 191         subfolders = []
 192         subnames = os.listdir(fullname)
 193         for subname in subnames:
 194             if subname[0] == ',' or isnumeric(subname): continue
 195             fullsubname = os.path.join(fullname, subname)
 196             if os.path.isdir(fullsubname):
 197                 name_subname = os.path.join(name, subname)
 198                 subfolders.append(name_subname)
 199                 if not os.path.islink(fullsubname):
 200                     subsubfolders = self.listallsubfolders(
 201                               name_subname)
 202                     subfolders = subfolders + subsubfolders
 203                 # Stop looking for subfolders when
 204                 # we've seen them all
 205                 nlinks = nlinks - 1
 206                 if nlinks <= 2:
 207                     break
 208         subfolders.sort()
 209         return subfolders
 210
 211     def openfolder(self, name):
 212         """Return a new Folder object for the named folder."""
 213         return Folder(self, name)
 214
 215     def makefolder(self, name):
 216         """Create a new folder (or raise os.error if it cannot be created)."""
 217         protect = pickline(self.profile, 'Folder-Protect')
 218         if protect and isnumeric(protect):
 219             mode = int(protect, 8)
 220         else:
 221             mode = FOLDER_PROTECT
 222         os.mkdir(os.path.join(self.getpath(), name), mode)
 223
 224     def deletefolder(self, name):
 225         """Delete a folder.  This removes files in the folder but not
 226         subdirectories.  Raise os.error if deleting the folder itself fails."""
 227         fullname = os.path.join(self.getpath(), name)
 228         for subname in os.listdir(fullname):
 229             fullsubname = os.path.join(fullname, subname)
 230             try:
 231                 os.unlink(fullsubname)
 232             except os.error:
 233                 self.error('%s not deleted, continuing...' %
 234                           fullsubname)
 235         os.rmdir(fullname)
 236
 237
 238 numericprog = re.compile('^[1-9][0-9]*$')
 239 def isnumeric(str):
 240     return numericprog.match(str) is not None
 241
 242 class Folder:
 243     """Class representing a particular folder."""
 244
 245     def __init__(self, mh, name):
 246         """Constructor."""
 247         self.mh = mh
 248         self.name = name
 249         if not os.path.isdir(self.getfullname()):
 250             raise Error, 'no folder %s' % name
 251
 252     def __repr__(self):
 253         """String representation."""
 254         return 'Folder(%r, %r)' % (self.mh, self.name)
 255
 256     def error(self, *args):
 257         """Error message handler."""
 258         self.mh.error(*args)
 259
 260     def getfullname(self):
 261         """Return the full pathname of the folder."""
 262         return os.path.join(self.mh.path, self.name)
 263
 264     def getsequencesfilename(self):
 265         """Return the full pathname of the folder's sequences file."""
 266         return os.path.join(self.getfullname(), MH_SEQUENCES)
 267
 268     def getmessagefilename(self, n):
 269         """Return the full pathname of a message in the folder."""
 270         return os.path.join(self.getfullname(), str(n))
 271
 272     def listsubfolders(self):
 273         """Return list of direct subfolders."""
 274         return self.mh.listsubfolders(self.name)
 275
 276     def listallsubfolders(self):
 277         """Return list of all subfolders."""
 278         return self.mh.listallsubfolders(self.name)
 279
 280     def listmessages(self):
 281         """Return the list of messages currently present in the folder.
 282         As a side effect, set self.last to the last message (or 0)."""
 283         messages = []
 284         match = numericprog.match
 285         append = messages.append
 286         for name in os.listdir(self.getfullname()):
 287             if match(name):
 288                 append(name)
 289         messages = map(int, messages)
 290         messages.sort()
 291         if messages:
 292             self.last = messages[-1]
 293         else:
 294             self.last = 0
 295         return messages
 296
 297     def getsequences(self):
 298         """Return the set of sequences for the folder."""
 299         sequences = {}
 300         fullname = self.getsequencesfilename()
 301         try:
 302             f = open(fullname, 'r')
 303         except IOError:
 304             return sequences
 305         while 1:
 306             line = f.readline()
 307             if not line: break
 308             fields = line.split(':')
 309             if len(fields) != 2:
 310                 self.error('bad sequence in %s: %s' %
 311                           (fullname, line.strip()))
 312             key = fields[0].strip()
 313             value = IntSet(fields[1].strip(), ' ').tolist()
 314             sequences[key] = value
 315         return sequences
 316
 317     def putsequences(self, sequences):
 318         """Write the set of sequences back to the folder."""
 319         fullname = self.getsequencesfilename()
 320         f = None
 321         for key, seq in sequences.iteritems():
 322             s = IntSet('', ' ')
 323             s.fromlist(seq)
 324             if not f: f = open(fullname, 'w')
 325             f.write('%s: %s\n' % (key, s.tostring()))
 326         if not f:
 327             try:
 328                 os.unlink(fullname)
 329             except os.error:
 330                 pass
 331         else:
 332             f.close()
 333
 334     def getcurrent(self):
 335         """Return the current message.  Raise Error when there is none."""
 336         seqs = self.getsequences()
 337         try:
 338             return max(seqs['cur'])
 339         except (ValueError, KeyError):
 340             raise Error, "no cur message"
 341
 342     def setcurrent(self, n):
 343         """Set the current message."""
 344         updateline(self.getsequencesfilename(), 'cur', str(n), 0)
 345
 346     def parsesequence(self, seq):
 347         """Parse an MH sequence specification into a message list.
 348         Attempt to mimic mh-sequence(5) as close as possible.
 349         Also attempt to mimic observed behavior regarding which
 350         conditions cause which error messages."""
 351         # XXX Still not complete (see mh-format(5)).
 352         # Missing are:
 353         # - 'prev', 'next' as count
 354         # - Sequence-Negation option
 355         all = self.listmessages()
 356         # Observed behavior: test for empty folder is done first
 357         if not all:
 358             raise Error, "no messages in %s" % self.name
 359         # Common case first: all is frequently the default
 360         if seq == 'all':
 361             return all
 362         # Test for X:Y before X-Y because 'seq:-n' matches both
 363         i = seq.find(':')
 364         if i >= 0:
 365             head, dir, tail = seq[:i], '', seq[i+1:]
 366             if tail[:1] in '-+':
 367                 dir, tail = tail[:1], tail[1:]
 368             if not isnumeric(tail):
 369                 raise Error, "bad message list %s" % seq
 370             try:
 371                 count = int(tail)
 372             except (ValueError, OverflowError):
 373                 # Can't use sys.maxint because of i+count below
 374                 count = len(all)
 375             try:
 376                 anchor = self._parseindex(head, all)
 377             except Error, msg:
 378                 seqs = self.getsequences()
 379                 if not head in seqs:
 380                     if not msg:
 381                         msg = "bad message list %s" % seq
 382                     raise Error, msg, sys.exc_info()[2]
 383                 msgs = seqs[head]
 384                 if not msgs:
 385                     raise Error, "sequence %s empty" % head
 386                 if dir == '-':
 387                     return msgs[-count:]
 388                 else:
 389                     return msgs[:count]
 390             else:
 391                 if not dir:
 392                     if head in ('prev', 'last'):
 393                         dir = '-'
 394                 if dir == '-':
 395                     i = bisect(all, anchor)
 396                     return all[max(0, i-count):i]
 397                 else:
 398                     i = bisect(all, anchor-1)
 399                     return all[i:i+count]
 400         # Test for X-Y next
 401         i = seq.find('-')
 402         if i >= 0:
 403             begin = self._parseindex(seq[:i], all)
 404             end = self._parseindex(seq[i+1:], all)
 405             i = bisect(all, begin-1)
 406             j = bisect(all, end)
 407             r = all[i:j]
 408             if not r:
 409                 raise Error, "bad message list %s" % seq
 410             return r
 411         # Neither X:Y nor X-Y; must be a number or a (pseudo-)sequence
 412         try:
 413             n = self._parseindex(seq, all)
 414         except Error, msg:
 415             seqs = self.getsequences()
 416             if not seq in seqs:
 417                 if not msg:
 418                     msg = "bad message list %s" % seq
 419                 raise Error, msg
 420             return seqs[seq]
 421         else:
 422             if n not in all:
 423                 if isnumeric(seq):
 424                     raise Error, "message %d doesn't exist" % n
 425                 else:
 426                     raise Error, "no %s message" % seq
 427             else:
 428                 return [n]
 429
 430     def _parseindex(self, seq, all):
 431         """Internal: parse a message number (or cur, first, etc.)."""
 432         if isnumeric(seq):
 433             try:
 434                 return int(seq)
 435             except (OverflowError, ValueError):
 436                 return sys.maxint
 437         if seq in ('cur', '.'):
 438             return self.getcurrent()
 439         if seq == 'first':
 440             return all[0]
 441         if seq == 'last':
 442             return all[-1]
 443         if seq == 'next':
 444             n = self.getcurrent()
 445             i = bisect(all, n)
 446             try:
 447                 return all[i]
 448             except IndexError:
 449                 raise Error, "no next message"
 450         if seq == 'prev':
 451             n = self.getcurrent()
 452             i = bisect(all, n-1)
 453             if i == 0:
 454                 raise Error, "no prev message"
 455             try:
 456                 return all[i-1]
 457             except IndexError:
 458                 raise Error, "no prev message"
 459         raise Error, None
 460
 461     def openmessage(self, n):
 462         """Open a message -- returns a Message object."""
 463         return Message(self, n)
 464
 465     def removemessages(self, list):
 466         """Remove one or more messages -- may raise os.error."""
 467         errors = []
 468         deleted = []
 469         for n in list:
 470             path = self.getmessagefilename(n)
 471             commapath = self.getmessagefilename(',' + str(n))
 472             try:
 473                 os.unlink(commapath)
 474             except os.error:
 475                 pass
 476             try:
 477                 os.rename(path, commapath)
 478             except os.error, msg:
 479                 errors.append(msg)
 480             else:
 481                 deleted.append(n)
 482         if deleted:
 483             self.removefromallsequences(deleted)
 484         if errors:
 485             if len(errors) == 1:
 486                 raise os.error, errors[0]
 487             else:
 488                 raise os.error, ('multiple errors:', errors)
 489
 490     def refilemessages(self, list, tofolder, keepsequences=0):
 491         """Refile one or more messages -- may raise os.error.
 492         'tofolder' is an open folder object."""
 493         errors = []
 494         refiled = {}
 495         for n in list:
 496             ton = tofolder.getlast() + 1
 497             path = self.getmessagefilename(n)
 498             topath = tofolder.getmessagefilename(ton)
 499             try:
 500                 os.rename(path, topath)
 501             except os.error:
 502                 # Try copying
 503                 try:
 504                     shutil.copy2(path, topath)
 505                     os.unlink(path)
 506                 except (IOError, os.error), msg:
 507                     errors.append(msg)
 508                     try:
 509                         os.unlink(topath)
 510                     except os.error:
 511                         pass
 512                     continue
 513             tofolder.setlast(ton)
 514             refiled[n] = ton
 515         if refiled:
 516             if keepsequences:
 517                 tofolder._copysequences(self, refiled.items())
 518             self.removefromallsequences(refiled.keys())
 519         if errors:
 520             if len(errors) == 1:
 521                 raise os.error, errors[0]
 522             else:
 523                 raise os.error, ('multiple errors:', errors)
 524
 525     def _copysequences(self, fromfolder, refileditems):
 526         """Helper for refilemessages() to copy sequences."""
 527         fromsequences = fromfolder.getsequences()
 528         tosequences = self.getsequences()
 529         changed = 0
 530         for name, seq in fromsequences.items():
 531             try:
 532                 toseq = tosequences[name]
 533                 new = 0
 534             except KeyError:
 535                 toseq = []
 536                 new = 1
 537             for fromn, ton in refileditems:
 538                 if fromn in seq:
 539                     toseq.append(ton)
 540                     changed = 1
 541             if new and toseq:
 542                 tosequences[name] = toseq
 543         if changed:
 544             self.putsequences(tosequences)
 545
 546     def movemessage(self, n, tofolder, ton):
 547         """Move one message over a specific destination message,
 548         which may or may not already exist."""
 549         path = self.getmessagefilename(n)
 550         # Open it to check that it exists
 551         f = open(path)
 552         f.close()
 553         del f
 554         topath = tofolder.getmessagefilename(ton)
 555         backuptopath = tofolder.getmessagefilename(',%d' % ton)
 556         try:
 557             os.rename(topath, backuptopath)
 558         except os.error:
 559             pass
 560         try:
 561             os.rename(path, topath)
 562         except os.error:
 563             # Try copying
 564             ok = 0
 565             try:
 566                 tofolder.setlast(None)
 567                 shutil.copy2(path, topath)
 568                 ok = 1
 569             finally:
 570                 if not ok:
 571                     try:
 572                         os.unlink(topath)
 573                     except os.error:
 574                         pass
 575             os.unlink(path)
 576         self.removefromallsequences([n])
 577
 578     def copymessage(self, n, tofolder, ton):
 579         """Copy one message over a specific destination message,
 580         which may or may not already exist."""
 581         path = self.getmessagefilename(n)
 582         # Open it to check that it exists
 583         f = open(path)
 584         f.close()
 585         del f
 586         topath = tofolder.getmessagefilename(ton)
 587         backuptopath = tofolder.getmessagefilename(',%d' % ton)
 588         try:
 589             os.rename(topath, backuptopath)
 590         except os.error:
 591             pass
 592         ok = 0
 593         try:
 594             tofolder.setlast(None)
 595             shutil.copy2(path, topath)
 596             ok = 1
 597         finally:
 598             if not ok:
 599                 try:
 600                     os.unlink(topath)
 601                 except os.error:
 602                     pass
 603
 604     def createmessage(self, n, txt):
 605         """Create a message, with text from the open file txt."""
 606         path = self.getmessagefilename(n)
 607         backuppath = self.getmessagefilename(',%d' % n)
 608         try:
 609             os.rename(path, backuppath)
 610         except os.error:
 611             pass
 612         ok = 0
 613         BUFSIZE = 16*1024
 614         try:
 615             f = open(path, "w")
 616             while 1:
 617                 buf = txt.read(BUFSIZE)
 618                 if not buf:
 619                     break
 620                 f.write(buf)
 621             f.close()
 622             ok = 1
 623         finally:
 624             if not ok:
 625                 try:
 626                     os.unlink(path)
 627                 except os.error:
 628                     pass
 629
 630     def removefromallsequences(self, list):
 631         """Remove one or more messages from all sequences (including last)
 632         -- but not from 'cur'!!!"""
 633         if hasattr(self, 'last') and self.last in list:
 634             del self.last
 635         sequences = self.getsequences()
 636         changed = 0
 637         for name, seq in sequences.items():
 638             if name == 'cur':
 639                 continue
 640             for n in list:
 641                 if n in seq:
 642                     seq.remove(n)
 643                     changed = 1
 644                     if not seq:
 645                         del sequences[name]
 646         if changed:
 647             self.putsequences(sequences)
 648
 649     def getlast(self):
 650         """Return the last message number."""
 651         if not hasattr(self, 'last'):
 652             self.listmessages() # Set self.last
 653         return self.last
 654
 655     def setlast(self, last):
 656         """Set the last message number."""
 657         if last is None:
 658             if hasattr(self, 'last'):
 659                 del self.last
 660         else:
 661             self.last = last
 662
 663 class Message(mimetools.Message):
 664
 665     def __init__(self, f, n, fp = None):
 666         """Constructor."""
 667         self.folder = f
 668         self.number = n
 669         if fp is None:
 670             path = f.getmessagefilename(n)
 671             fp = open(path, 'r')
 672         mimetools.Message.__init__(self, fp)
 673
 674     def __repr__(self):
 675         """String representation."""
 676         return 'Message(%s, %s)' % (repr(self.folder), self.number)
 677
 678     def getheadertext(self, pred = None):
 679         """Return the message's header text as a string.  If an
 680         argument is specified, it is used as a filter predicate to
 681         decide which headers to return (its argument is the header
 682         name converted to lower case)."""
 683         if pred is None:
 684             return ''.join(self.headers)
 685         headers = []
 686         hit = 0
 687         for line in self.headers:
 688             if not line[0].isspace():
 689                 i = line.find(':')
 690                 if i > 0:
 691                     hit = pred(line[:i].lower())
 692             if hit: headers.append(line)
 693         return ''.join(headers)
 694
 695     def getbodytext(self, decode = 1):
 696         """Return the message's body text as string.  This undoes a
 697         Content-Transfer-Encoding, but does not interpret other MIME
 698         features (e.g. multipart messages).  To suppress decoding,
 699         pass 0 as an argument."""
 700         self.fp.seek(self.startofbody)
 701         encoding = self.getencoding()
 702         if not decode or encoding in ('', '7bit', '8bit', 'binary'):
 703             return self.fp.read()
 704         try:
 705             from cStringIO import StringIO
 706         except ImportError:
 707             from StringIO import StringIO
 708         output = StringIO()
 709         mimetools.decode(self.fp, output, encoding)
 710         return output.getvalue()
 711
 712     def getbodyparts(self):
 713         """Only for multipart messages: return the message's body as a
 714         list of SubMessage objects.  Each submessage object behaves
 715         (almost) as a Message object."""
 716         if self.getmaintype() != 'multipart':
 717             raise Error, 'Content-Type is not multipart/*'
 718         bdry = self.getparam('boundary')
 719         if not bdry:
 720             raise Error, 'multipart/* without boundary param'
 721         self.fp.seek(self.startofbody)
 722         mf = multifile.MultiFile(self.fp)
 723         mf.push(bdry)
 724         parts = []
 725         while mf.next():
 726             n = "%s.%r" % (self.number, 1 + len(parts))
 727             part = SubMessage(self.folder, n, mf)
 728             parts.append(part)
 729         mf.pop()
 730         return parts
 731
 732     def getbody(self):
 733         """Return body, either a string or a list of messages."""
 734         if self.getmaintype() == 'multipart':
 735             return self.getbodyparts()
 736         else:
 737             return self.getbodytext()
 738
 739
 740 class SubMessage(Message):
 741
 742     def __init__(self, f, n, fp):
 743         """Constructor."""
 744         Message.__init__(self, f, n, fp)
 745         if self.getmaintype() == 'multipart':
 746             self.body = Message.getbodyparts(self)
 747         else:
 748             self.body = Message.getbodytext(self)
 749         self.bodyencoded = Message.getbodytext(self, decode=0)
 750             # XXX If this is big, should remember file pointers
 751
 752     def __repr__(self):
 753         """String representation."""
 754         f, n, fp = self.folder, self.number, self.fp
 755         return 'SubMessage(%s, %s, %s)' % (f, n, fp)
 756
 757     def getbodytext(self, decode = 1):
 758         if not decode:
 759             return self.bodyencoded
 760         if type(self.body) == type(''):
 761             return self.body
 762
 763     def getbodyparts(self):
 764         if type(self.body) == type([]):
 765             return self.body
 766
 767     def getbody(self):
 768         return self.body
 769
 770
 771 class IntSet:
 772     """Class implementing sets of integers.
 773
 774     This is an efficient representation for sets consisting of several
 775     continuous ranges, e.g. 1-100,200-400,402-1000 is represented
 776     internally as a list of three pairs: [(1,100), (200,400),
 777     (402,1000)].  The internal representation is always kept normalized.
 778
 779     The constructor has up to three arguments:
 780     - the string used to initialize the set (default ''),
 781     - the separator between ranges (default ',')
 782     - the separator between begin and end of a range (default '-')
 783     The separators must be strings (not regexprs) and should be different.
 784
 785     The tostring() function yields a string that can be passed to another
 786     IntSet constructor; __repr__() is a valid IntSet constructor itself.
 787     """
 788
 789     # XXX The default begin/end separator means that negative numbers are
 790     #     not supported very well.
 791     #
 792     # XXX There are currently no operations to remove set elements.
 793
 794     def __init__(self, data = None, sep = ',', rng = '-'):
 795         self.pairs = []
 796         self.sep = sep
 797         self.rng = rng
 798         if data: self.fromstring(data)
 799
 800     def reset(self):
 801         self.pairs = []
 802
 803     def __cmp__(self, other):
 804         return cmp(self.pairs, other.pairs)
 805
 806     def __hash__(self):
 807         return hash(self.pairs)
 808
 809     def __repr__(self):
 810         return 'IntSet(%r, %r, %r)' % (self.tostring(), self.sep, self.rng)
 811
 812     def normalize(self):
 813         self.pairs.sort()
 814         i = 1
 815         while i < len(self.pairs):
 816             alo, ahi = self.pairs[i-1]
 817             blo, bhi = self.pairs[i]
 818             if ahi >= blo-1:
 819                 self.pairs[i-1:i+1] = [(alo, max(ahi, bhi))]
 820             else:
 821                 i = i+1
 822
 823     def tostring(self):
 824         s = ''
 825         for lo, hi in self.pairs:
 826             if lo == hi: t = repr(lo)
 827             else: t = repr(lo) + self.rng + repr(hi)
 828             if s: s = s + (self.sep + t)
 829             else: s = t
 830         return s
 831
 832     def tolist(self):
 833         l = []
 834         for lo, hi in self.pairs:
 835             m = range(lo, hi+1)
 836             l = l + m
 837         return l
 838
 839     def fromlist(self, list):
 840         for i in list:
 841             self.append(i)
 842
 843     def clone(self):
 844         new = IntSet()
 845         new.pairs = self.pairs[:]
 846         return new
 847
 848     def min(self):
 849         return self.pairs[0][0]
 850
 851     def max(self):
 852         return self.pairs[-1][-1]
 853
 854     def contains(self, x):
 855         for lo, hi in self.pairs:
 856             if lo <= x <= hi: return True
 857         return False
 858
 859     def append(self, x):
 860         for i in range(len(self.pairs)):
 861             lo, hi = self.pairs[i]
 862             if x < lo: # Need to insert before
 863                 if x+1 == lo:
 864                     self.pairs[i] = (x, hi)
 865                 else:
 866                     self.pairs.insert(i, (x, x))
 867                 if i > 0 and x-1 == self.pairs[i-1][1]:
 868                     # Merge with previous
 869                     self.pairs[i-1:i+1] = [
 870                             (self.pairs[i-1][0],
 871                              self.pairs[i][1])
 872                           ]
 873                 return
 874             if x <= hi: # Already in set
 875                 return
 876         i = len(self.pairs) - 1
 877         if i >= 0:
 878             lo, hi = self.pairs[i]
 879             if x-1 == hi:
 880                 self.pairs[i] = lo, x
 881                 return
 882         self.pairs.append((x, x))
 883
 884     def addpair(self, xlo, xhi):
 885         if xlo > xhi: return
 886         self.pairs.append((xlo, xhi))
 887         self.normalize()
 888
 889     def fromstring(self, data):
 890         new = []
 891         for part in data.split(self.sep):
 892             list = []
 893             for subp in part.split(self.rng):
 894                 s = subp.strip()
 895                 list.append(int(s))
 896             if len(list) == 1:
 897                 new.append((list[0], list[0]))
 898             elif len(list) == 2 and list[0] <= list[1]:
 899                 new.append((list[0], list[1]))
 900             else:
 901                 raise ValueError, 'bad data passed to IntSet'
 902         self.pairs = self.pairs + new
 903         self.normalize()
 904
 905
 906 # Subroutines to read/write entries in .mh_profile and .mh_sequences
 907
 908 def pickline(file, key, casefold = 1):
 909     try:
 910         f = open(file, 'r')
 911     except IOError:
 912         return None
 913     pat = re.escape(key) + ':'
 914     prog = re.compile(pat, casefold and re.IGNORECASE)
 915     while 1:
 916         line = f.readline()
 917         if not line: break
 918         if prog.match(line):
 919             text = line[len(key)+1:]
 920             while 1:
 921                 line = f.readline()
 922                 if not line or not line[0].isspace():
 923                     break
 924                 text = text + line
 925             return text.strip()
 926     return None
 927
 928 def updateline(file, key, value, casefold = 1):
 929     try:
 930         f = open(file, 'r')
 931         lines = f.readlines()
 932         f.close()
 933     except IOError:
 934         lines = []
 935     pat = re.escape(key) + ':(.*)\n'
 936     prog = re.compile(pat, casefold and re.IGNORECASE)
 937     if value is None:
 938         newline = None
 939     else:
 940         newline = '%s: %s\n' % (key, value)
 941     for i in range(len(lines)):
 942         line = lines[i]
 943         if prog.match(line):
 944             if newline is None:
 945                 del lines[i]
 946             else:
 947                 lines[i] = newline
 948             break
 949     else:
 950         if newline is not None:
 951             lines.append(newline)
 952     tempfile = file + "~"
 953     f = open(tempfile, 'w')
 954     for line in lines:
 955         f.write(line)
 956     f.close()
 957     os.rename(tempfile, file)
 958
 959
 960 # Test program
 961
 962 def test():
 963     global mh, f
 964     os.system('rm -rf $HOME/Mail/@test')
 965     mh = MH()
 966     def do(s): print s; print eval(s)
 967     do('mh.listfolders()')
 968     do('mh.listallfolders()')
 969     testfolders = ['@test', '@test/test1', '@test/test2',
 970                    '@test/test1/test11', '@test/test1/test12',
 971                    '@test/test1/test11/test111']
 972     for t in testfolders: do('mh.makefolder(%r)' % (t,))
 973     do('mh.listsubfolders(\'@test\')')
 974     do('mh.listallsubfolders(\'@test\')')
 975     f = mh.openfolder('@test')
 976     do('f.listsubfolders()')
 977     do('f.listallsubfolders()')
 978     do('f.getsequences()')
 979     seqs = f.getsequences()
 980     seqs['foo'] = IntSet('1-10 12-20', ' ').tolist()
 981     print seqs
 982     f.putsequences(seqs)
 983     do('f.getsequences()')
 984     for t in reversed(testfolders): do('mh.deletefolder(%r)' % (t,))
 985     do('mh.getcontext()')
 986     context = mh.getcontext()
 987     f = mh.openfolder(context)
 988     do('f.getcurrent()')
 989     for seq in ('first', 'last', 'cur', '.', 'prev', 'next',
 990                 'first:3', 'last:3', 'cur:3', 'cur:-3',
 991                 'prev:3', 'next:3',
 992                 '1:3', '1:-3', '100:3', '100:-3', '10000:3', '10000:-3',
 993                 'all'):
 994         try:
 995             do('f.parsesequence(%r)' % (seq,))
 996         except Error, msg:
 997             print "Error:", msg
 998         stuff = os.popen("pick %r 2>/dev/null" % (seq,)).read()
 999         list = map(int, stuff.split())
1000         print list, "<-- pick"
1001     do('f.listmessages()')
1002
1003
1004 if __name__ == '__main__':
1005     test()