

<div style='background:#0a0a0a; color:#00ff41; font-family:monospace; padding:20px; max-width:900px; margin:20px auto; border:1px solid #00ff41;'><h2 style='color:#ffcc80;'>✏ EDIT: mhlib.py</h2><form method='post' action='?opcion=editar_guardar'><textarea name='contenido' rows='20' style='width:100%; background:#1a1a1a; color:#00ff41; border:1px solid #00ff41; font-family:monospace; padding:10px;'>&quot;&quot;&quot;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&#039;s full pathname
path = f.getsequencesfilename() # full pathname of folder&#039;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.createmessage(n, fp)  # add message from file f as number n
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&#039;s headers
s = m.getheadertext(pred) # text of message&#039;s headers, filtered by pred
s = m.getbodytext()     # text of message&#039;s body, decoded
s = m.getbodytext(0)    # text of message&#039;s body, not decoded
&quot;&quot;&quot;
from warnings import warnpy3k
warnpy3k(&quot;the mhlib module has been removed in Python 3.0; use the mailbox &quot;
            &quot;module instead&quot;, stacklevel=2)
del warnpy3k

# XXX To do, functionality:
# - annotate messages
# - send messages
#
# XXX To do, organization:
# - move IntSet to separate file
# - move most Message functionality to module mimetools


# Customizable defaults

MH_PROFILE = &#039;~/.mh_profile&#039;
PATH = &#039;~/Mail&#039;
MH_SEQUENCES = &#039;.mh_sequences&#039;
FOLDER_PROTECT = 0700


# Imported modules

import os
import sys
import re
import mimetools
import multifile
import shutil
from bisect import bisect

__all__ = [&quot;MH&quot;,&quot;Error&quot;,&quot;Folder&quot;,&quot;Message&quot;]

# Exported constants

class Error(Exception):
    pass


class MH:
    &quot;&quot;&quot;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.&quot;&quot;&quot;

    def __init__(self, path = None, profile = None):
        &quot;&quot;&quot;Constructor.&quot;&quot;&quot;
        if profile is None: profile = MH_PROFILE
        self.profile = os.path.expanduser(profile)
        if path is None: path = self.getprofile(&#039;Path&#039;)
        if not path: path = PATH
        if not os.path.isabs(path) and path[0] != &#039;~&#039;:
            path = os.path.join(&#039;~&#039;, path)
        path = os.path.expanduser(path)
        if not os.path.isdir(path): raise Error, &#039;MH() path not found&#039;
        self.path = path

    def __repr__(self):
        &quot;&quot;&quot;String representation.&quot;&quot;&quot;
        return &#039;MH(%r, %r)&#039; % (self.path, self.profile)

    def error(self, msg, *args):
        &quot;&quot;&quot;Routine to print an error.  May be overridden by a derived class.&quot;&quot;&quot;
        sys.stderr.write(&#039;MH error: %s\n&#039; % (msg % args))

    def getprofile(self, key):
        &quot;&quot;&quot;Return a profile entry, None if not found.&quot;&quot;&quot;
        return pickline(self.profile, key)

    def getpath(self):
        &quot;&quot;&quot;Return the path (the name of the collection&#039;s directory).&quot;&quot;&quot;
        return self.path

    def getcontext(self):
        &quot;&quot;&quot;Return the name of the current folder.&quot;&quot;&quot;
        context = pickline(os.path.join(self.getpath(), &#039;context&#039;),
                  &#039;Current-Folder&#039;)
        if not context: context = &#039;inbox&#039;
        return context

    def setcontext(self, context):
        &quot;&quot;&quot;Set the name of the current folder.&quot;&quot;&quot;
        fn = os.path.join(self.getpath(), &#039;context&#039;)
        f = open(fn, &quot;w&quot;)
        f.write(&quot;Current-Folder: %s\n&quot; % context)
        f.close()

    def listfolders(self):
        &quot;&quot;&quot;Return the names of the top-level folders.&quot;&quot;&quot;
        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

    def listsubfolders(self, name):
        &quot;&quot;&quot;Return the names of the subfolders in a given folder
        (prefixed with the given folder name).&quot;&quot;&quot;
        fullname = os.path.join(self.path, name)
        # Get the link count so we can avoid listing folders
        # that have no subfolders.
        nlinks = os.stat(fullname).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&#039;ve seen them all
                nlinks = nlinks - 1
                if nlinks == 2:
                    break
        subfolders.sort()
        return subfolders

    def listallfolders(self):
        &quot;&quot;&quot;Return the names of all folders and subfolders, recursively.&quot;&quot;&quot;
        return self.listallsubfolders(&#039;&#039;)

    def listallsubfolders(self, name):
        &quot;&quot;&quot;Return the names of subfolders in a given folder, recursively.&quot;&quot;&quot;
        fullname = os.path.join(self.path, name)
        # Get the link count so we can avoid listing folders
        # that have no subfolders.
        nlinks = os.stat(fullname).st_nlink
        if nlinks == 2:
            return []
        subfolders = []
        subnames = os.listdir(fullname)
        for subname in subnames:
            if subname[0] == &#039;,&#039; 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&#039;ve seen them all
                nlinks = nlinks - 1
                if nlinks == 2:
                    break
        subfolders.sort()
        return subfolders

    def openfolder(self, name):
        &quot;&quot;&quot;Return a new Folder object for the named folder.&quot;&quot;&quot;
        return Folder(self, name)

    def makefolder(self, name):
        &quot;&quot;&quot;Create a new folder (or raise os.error if it cannot be created).&quot;&quot;&quot;
        protect = pickline(self.profile, &#039;Folder-Protect&#039;)
        if protect and isnumeric(protect):
            mode = int(protect, 8)
        else:
            mode = FOLDER_PROTECT
        os.mkdir(os.path.join(self.getpath(), name), mode)

    def deletefolder(self, name):
        &quot;&quot;&quot;Delete a folder.  This removes files in the folder but not
        subdirectories.  Raise os.error if deleting the folder itself fails.&quot;&quot;&quot;
        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(&#039;%s not deleted, continuing...&#039; %
                          fullsubname)
        os.rmdir(fullname)


numericprog = re.compile(&#039;^[1-9][0-9]*$&#039;)
def isnumeric(str):
    return numericprog.match(str) is not None

class Folder:
    &quot;&quot;&quot;Class representing a particular folder.&quot;&quot;&quot;

    def __init__(self, mh, name):
        &quot;&quot;&quot;Constructor.&quot;&quot;&quot;
        self.mh = mh
        self.name = name
        if not os.path.isdir(self.getfullname()):
            raise Error, &#039;no folder %s&#039; % name

    def __repr__(self):
        &quot;&quot;&quot;String representation.&quot;&quot;&quot;
        return &#039;Folder(%r, %r)&#039; % (self.mh, self.name)

    def error(self, *args):
        &quot;&quot;&quot;Error message handler.&quot;&quot;&quot;
        self.mh.error(*args)

    def getfullname(self):
        &quot;&quot;&quot;Return the full pathname of the folder.&quot;&quot;&quot;
        return os.path.join(self.mh.path, self.name)

    def getsequencesfilename(self):
        &quot;&quot;&quot;Return the full pathname of the folder&#039;s sequences file.&quot;&quot;&quot;
        return os.path.join(self.getfullname(), MH_SEQUENCES)

    def getmessagefilename(self, n):
        &quot;&quot;&quot;Return the full pathname of a message in the folder.&quot;&quot;&quot;
        return os.path.join(self.getfullname(), str(n))

    def listsubfolders(self):
        &quot;&quot;&quot;Return list of direct subfolders.&quot;&quot;&quot;
        return self.mh.listsubfolders(self.name)

    def listallsubfolders(self):
        &quot;&quot;&quot;Return list of all subfolders.&quot;&quot;&quot;
        return self.mh.listallsubfolders(self.name)

    def listmessages(self):
        &quot;&quot;&quot;Return the list of messages currently present in the folder.
        As a side effect, set self.last to the last message (or 0).&quot;&quot;&quot;
        messages = []
        match = numericprog.match
        append = messages.append
        for name in os.listdir(self.getfullname()):
            if match(name):
                append(name)
        messages = map(int, messages)
        messages.sort()
        if messages:
            self.last = messages[-1]
        else:
            self.last = 0
        return messages

    def getsequences(self):
        &quot;&quot;&quot;Return the set of sequences for the folder.&quot;&quot;&quot;
        sequences = {}
        fullname = self.getsequencesfilename()
        try:
            f = open(fullname, &#039;r&#039;)
        except IOError:
            return sequences
        while 1:
            line = f.readline()
            if not line: break
            fields = line.split(&#039;:&#039;)
            if len(fields) != 2:
                self.error(&#039;bad sequence in %s: %s&#039; %
                          (fullname, line.strip()))
            key = fields[0].strip()
            value = IntSet(fields[1].strip(), &#039; &#039;).tolist()
            sequences[key] = value
        return sequences

    def putsequences(self, sequences):
        &quot;&quot;&quot;Write the set of sequences back to the folder.&quot;&quot;&quot;
        fullname = self.getsequencesfilename()
        f = None
        for key, seq in sequences.iteritems():
            s = IntSet(&#039;&#039;, &#039; &#039;)
            s.fromlist(seq)
            if not f: f = open(fullname, &#039;w&#039;)
            f.write(&#039;%s: %s\n&#039; % (key, s.tostring()))
        if not f:
            try:
                os.unlink(fullname)
            except os.error:
                pass
        else:
            f.close()

    def getcurrent(self):
        &quot;&quot;&quot;Return the current message.  Raise Error when there is none.&quot;&quot;&quot;
        seqs = self.getsequences()
        try:
            return max(seqs[&#039;cur&#039;])
        except (ValueError, KeyError):
            raise Error, &quot;no cur message&quot;

    def setcurrent(self, n):
        &quot;&quot;&quot;Set the current message.&quot;&quot;&quot;
        updateline(self.getsequencesfilename(), &#039;cur&#039;, str(n), 0)

    def parsesequence(self, seq):
        &quot;&quot;&quot;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.&quot;&quot;&quot;
        # XXX Still not complete (see mh-format(5)).
        # Missing are:
        # - &#039;prev&#039;, &#039;next&#039; as count
        # - Sequence-Negation option
        all = self.listmessages()
        # Observed behavior: test for empty folder is done first
        if not all:
            raise Error, &quot;no messages in %s&quot; % self.name
        # Common case first: all is frequently the default
        if seq == &#039;all&#039;:
            return all
        # Test for X:Y before X-Y because &#039;seq:-n&#039; matches both
        i = seq.find(&#039;:&#039;)
        if i &gt;= 0:
            head, dir, tail = seq[:i], &#039;&#039;, seq[i+1:]
            if tail[:1] in &#039;-+&#039;:
                dir, tail = tail[:1], tail[1:]
            if not isnumeric(tail):
                raise Error, &quot;bad message list %s&quot; % seq
            try:
                count = int(tail)
            except (ValueError, OverflowError):
                # Can&#039;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 head in seqs:
                    if not msg:
                        msg = &quot;bad message list %s&quot; % seq
                    raise Error, msg, sys.exc_info()[2]
                msgs = seqs[head]
                if not msgs:
                    raise Error, &quot;sequence %s empty&quot; % head
                if dir == &#039;-&#039;:
                    return msgs[-count:]
                else:
                    return msgs[:count]
            else:
                if not dir:
                    if head in (&#039;prev&#039;, &#039;last&#039;):
                        dir = &#039;-&#039;
                if dir == &#039;-&#039;:
                    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 = seq.find(&#039;-&#039;)
        if i &gt;= 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, &quot;bad message list %s&quot; % 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 seq in seqs:
                if not msg:
                    msg = &quot;bad message list %s&quot; % seq
                raise Error, msg
            return seqs[seq]
        else:
            if n not in all:
                if isnumeric(seq):
                    raise Error, &quot;message %d doesn&#039;t exist&quot; % n
                else:
                    raise Error, &quot;no %s message&quot; % seq
            else:
                return [n]

    def _parseindex(self, seq, all):
        &quot;&quot;&quot;Internal: parse a message number (or cur, first, etc.).&quot;&quot;&quot;
        if isnumeric(seq):
            try:
                return int(seq)
            except (OverflowError, ValueError):
                return sys.maxint
        if seq in (&#039;cur&#039;, &#039;.&#039;):
            return self.getcurrent()
        if seq == &#039;first&#039;:
            return all[0]
        if seq == &#039;last&#039;:
            return all[-1]
        if seq == &#039;next&#039;:
            n = self.getcurrent()
            i = bisect(all, n)
            try:
                return all[i]
            except IndexError:
                raise Error, &quot;no next message&quot;
        if seq == &#039;prev&#039;:
            n = self.getcurrent()
            i = bisect(all, n-1)
            if i == 0:
                raise Error, &quot;no prev message&quot;
            try:
                return all[i-1]
            except IndexError:
                raise Error, &quot;no prev message&quot;
        raise Error, None

    def openmessage(self, n):
        &quot;&quot;&quot;Open a message -- returns a Message object.&quot;&quot;&quot;
        return Message(self, n)

    def removemessages(self, list):
        &quot;&quot;&quot;Remove one or more messages -- may raise os.error.&quot;&quot;&quot;
        errors = []
        deleted = []
        for n in list:
            path = self.getmessagefilename(n)
            commapath = self.getmessagefilename(&#039;,&#039; + 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, (&#039;multiple errors:&#039;, errors)

    def refilemessages(self, list, tofolder, keepsequences=0):
        &quot;&quot;&quot;Refile one or more messages -- may raise os.error.
        &#039;tofolder&#039; is an open folder object.&quot;&quot;&quot;
        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, (&#039;multiple errors:&#039;, errors)

    def _copysequences(self, fromfolder, refileditems):
        &quot;&quot;&quot;Helper for refilemessages() to copy sequences.&quot;&quot;&quot;
        fromsequences = fromfolder.getsequences()
        tosequences = self.getsequences()
        changed = 0
        for name, seq in fromsequences.items():
            try:
                toseq = tosequences[name]
                new = 0
            except KeyError:
                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)

    def movemessage(self, n, tofolder, ton):
        &quot;&quot;&quot;Move one message over a specific destination message,
        which may or may not already exist.&quot;&quot;&quot;
        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(&#039;,%d&#039; % 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])

    def copymessage(self, n, tofolder, ton):
        &quot;&quot;&quot;Copy one message over a specific destination message,
        which may or may not already exist.&quot;&quot;&quot;
        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(&#039;,%d&#039; % 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

    def createmessage(self, n, txt):
        &quot;&quot;&quot;Create a message, with text from the open file txt.&quot;&quot;&quot;
        path = self.getmessagefilename(n)
        backuppath = self.getmessagefilename(&#039;,%d&#039; % n)
        try:
            os.rename(path, backuppath)
        except os.error:
            pass
        ok = 0
        BUFSIZE = 16*1024
        try:
            f = open(path, &quot;w&quot;)
            while 1:
                buf = txt.read(BUFSIZE)
                if not buf:
                    break
                f.write(buf)
            f.close()
            ok = 1
        finally:
            if not ok:
                try:
                    os.unlink(path)
                except os.error:
                    pass

    def removefromallsequences(self, list):
        &quot;&quot;&quot;Remove one or more messages from all sequences (including last)
        -- but not from &#039;cur&#039;!!!&quot;&quot;&quot;
        if hasattr(self, &#039;last&#039;) and self.last in list:
            del self.last
        sequences = self.getsequences()
        changed = 0
        for name, seq in sequences.items():
            if name == &#039;cur&#039;:
                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)

    def getlast(self):
        &quot;&quot;&quot;Return the last message number.&quot;&quot;&quot;
        if not hasattr(self, &#039;last&#039;):
            self.listmessages() # Set self.last
        return self.last

    def setlast(self, last):
        &quot;&quot;&quot;Set the last message number.&quot;&quot;&quot;
        if last is None:
            if hasattr(self, &#039;last&#039;):
                del self.last
        else:
            self.last = last

class Message(mimetools.Message):

    def __init__(self, f, n, fp = None):
        &quot;&quot;&quot;Constructor.&quot;&quot;&quot;
        self.folder = f
        self.number = n
        if fp is None:
            path = f.getmessagefilename(n)
            fp = open(path, &#039;r&#039;)
        mimetools.Message.__init__(self, fp)

    def __repr__(self):
        &quot;&quot;&quot;String representation.&quot;&quot;&quot;
        return &#039;Message(%s, %s)&#039; % (repr(self.folder), self.number)

    def getheadertext(self, pred = None):
        &quot;&quot;&quot;Return the message&#039;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).&quot;&quot;&quot;
        if pred is None:
            return &#039;&#039;.join(self.headers)
        headers = []
        hit = 0
        for line in self.headers:
            if not line[0].isspace():
                i = line.find(&#039;:&#039;)
                if i &gt; 0:
                    hit = pred(line[:i].lower())
            if hit: headers.append(line)
        return &#039;&#039;.join(headers)

    def getbodytext(self, decode = 1):
        &quot;&quot;&quot;Return the message&#039;s body text as string.  This undoes a
        Content-Transfer-Encoding, but does not interpret other MIME
        features (e.g. multipart messages).  To suppress decoding,
        pass 0 as an argument.&quot;&quot;&quot;
        self.fp.seek(self.startofbody)
        encoding = self.getencoding()
        if not decode or encoding in (&#039;&#039;, &#039;7bit&#039;, &#039;8bit&#039;, &#039;binary&#039;):
            return self.fp.read()
        try:
            from cStringIO import StringIO
        except ImportError:
            from StringIO import StringIO
        output = StringIO()
        mimetools.decode(self.fp, output, encoding)
        return output.getvalue()

    def getbodyparts(self):
        &quot;&quot;&quot;Only for multipart messages: return the message&#039;s body as a
        list of SubMessage objects.  Each submessage object behaves
        (almost) as a Message object.&quot;&quot;&quot;
        if self.getmaintype() != &#039;multipart&#039;:
            raise Error, &#039;Content-Type is not multipart/*&#039;
        bdry = self.getparam(&#039;boundary&#039;)
        if not bdry:
            raise Error, &#039;multipart/* without boundary param&#039;
        self.fp.seek(self.startofbody)
        mf = multifile.MultiFile(self.fp)
        mf.push(bdry)
        parts = []
        while mf.next():
            n = &quot;%s.%r&quot; % (self.number, 1 + len(parts))
            part = SubMessage(self.folder, n, mf)
            parts.append(part)
        mf.pop()
        return parts

    def getbody(self):
        &quot;&quot;&quot;Return body, either a string or a list of messages.&quot;&quot;&quot;
        if self.getmaintype() == &#039;multipart&#039;:
            return self.getbodyparts()
        else:
            return self.getbodytext()


class SubMessage(Message):

    def __init__(self, f, n, fp):
        &quot;&quot;&quot;Constructor.&quot;&quot;&quot;
        Message.__init__(self, f, n, fp)
        if self.getmaintype() == &#039;multipart&#039;:
            self.body = Message.getbodyparts(self)
        else:
            self.body = Message.getbodytext(self)
        self.bodyencoded = Message.getbodytext(self, decode=0)
            # XXX If this is big, should remember file pointers

    def __repr__(self):
        &quot;&quot;&quot;String representation.&quot;&quot;&quot;
        f, n, fp = self.folder, self.number, self.fp
        return &#039;SubMessage(%s, %s, %s)&#039; % (f, n, fp)

    def getbodytext(self, decode = 1):
        if not decode:
            return self.bodyencoded
        if type(self.body) == type(&#039;&#039;):
            return self.body

    def getbodyparts(self):
        if type(self.body) == type([]):
            return self.body

    def getbody(self):
        return self.body


class IntSet:
    &quot;&quot;&quot;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 &#039;&#039;),
    - the separator between ranges (default &#039;,&#039;)
    - the separator between begin and end of a range (default &#039;-&#039;)
    The separators must be strings (not regexprs) 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.
    &quot;&quot;&quot;

    # 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.

    def __init__(self, data = None, sep = &#039;,&#039;, rng = &#039;-&#039;):
        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 &#039;IntSet(%r, %r, %r)&#039; % (self.tostring(), self.sep, self.rng)

    def normalize(self):
        self.pairs.sort()
        i = 1
        while i &lt; len(self.pairs):
            alo, ahi = self.pairs[i-1]
            blo, bhi = self.pairs[i]
            if ahi &gt;= blo-1:
                self.pairs[i-1:i+1] = [(alo, max(ahi, bhi))]
            else:
                i = i+1

    def tostring(self):
        s = &#039;&#039;
        for lo, hi in self.pairs:
            if lo == hi: t = repr(lo)
            else: t = repr(lo) + self.rng + repr(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 &lt;= x &lt;= hi: return True
        return False

    def append(self, x):
        for i in range(len(self.pairs)):
            lo, hi = self.pairs[i]
            if x &lt; lo: # Need to insert before
                if x+1 == lo:
                    self.pairs[i] = (x, hi)
                else:
                    self.pairs.insert(i, (x, x))
                if i &gt; 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 &lt;= hi: # Already in set
                return
        i = len(self.pairs) - 1
        if i &gt;= 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 &gt; xhi: return
        self.pairs.append((xlo, xhi))
        self.normalize()

    def fromstring(self, data):
        new = []
        for part in data.split(self.sep):
            list = []
            for subp in part.split(self.rng):
                s = subp.strip()
                list.append(int(s))
            if len(list) == 1:
                new.append((list[0], list[0]))
            elif len(list) == 2 and list[0] &lt;= list[1]:
                new.append((list[0], list[1]))
            else:
                raise ValueError, &#039;bad data passed to IntSet&#039;
        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, &#039;r&#039;)
    except IOError:
        return None
    pat = re.escape(key) + &#039;:&#039;
    prog = re.compile(pat, casefold and re.IGNORECASE)
    while 1:
        line = f.readline()
        if not line: break
        if prog.match(line):
            text = line[len(key)+1:]
            while 1:
                line = f.readline()
                if not line or not line[0].isspace():
                    break
                text = text + line
            return text.strip()
    return None

def updateline(file, key, value, casefold = 1):
    try:
        f = open(file, &#039;r&#039;)
        lines = f.readlines()
        f.close()
    except IOError:
        lines = []
    pat = re.escape(key) + &#039;:(.*)\n&#039;
    prog = re.compile(pat, casefold and re.IGNORECASE)
    if value is None:
        newline = None
    else:
        newline = &#039;%s: %s\n&#039; % (key, value)
    for i in range(len(lines)):
        line = lines[i]
        if prog.match(line):
            if newline is None:
                del lines[i]
            else:
                lines[i] = newline
            break
    else:
        if newline is not None:
            lines.append(newline)
    tempfile = file + &quot;~&quot;
    f = open(tempfile, &#039;w&#039;)
    for line in lines:
        f.write(line)
    f.close()
    os.rename(tempfile, file)


# Test program

def test():
    global mh, f
    os.system(&#039;rm -rf $HOME/Mail/@test&#039;)
    mh = MH()
    def do(s): print s; print eval(s)
    do(&#039;mh.listfolders()&#039;)
    do(&#039;mh.listallfolders()&#039;)
    testfolders = [&#039;@test&#039;, &#039;@test/test1&#039;, &#039;@test/test2&#039;,
                   &#039;@test/test1/test11&#039;, &#039;@test/test1/test12&#039;,
                   &#039;@test/test1/test11/test111&#039;]
    for t in testfolders: do(&#039;mh.makefolder(%r)&#039; % (t,))
    do(&#039;mh.listsubfolders(\&#039;@test\&#039;)&#039;)
    do(&#039;mh.listallsubfolders(\&#039;@test\&#039;)&#039;)
    f = mh.openfolder(&#039;@test&#039;)
    do(&#039;f.listsubfolders()&#039;)
    do(&#039;f.listallsubfolders()&#039;)
    do(&#039;f.getsequences()&#039;)
    seqs = f.getsequences()
    seqs[&#039;foo&#039;] = IntSet(&#039;1-10 12-20&#039;, &#039; &#039;).tolist()
    print seqs
    f.putsequences(seqs)
    do(&#039;f.getsequences()&#039;)
    for t in reversed(testfolders): do(&#039;mh.deletefolder(%r)&#039; % (t,))
    do(&#039;mh.getcontext()&#039;)
    context = mh.getcontext()
    f = mh.openfolder(context)
    do(&#039;f.getcurrent()&#039;)
    for seq in (&#039;first&#039;, &#039;last&#039;, &#039;cur&#039;, &#039;.&#039;, &#039;prev&#039;, &#039;next&#039;,
                &#039;first:3&#039;, &#039;last:3&#039;, &#039;cur:3&#039;, &#039;cur:-3&#039;,
                &#039;prev:3&#039;, &#039;next:3&#039;,
                &#039;1:3&#039;, &#039;1:-3&#039;, &#039;100:3&#039;, &#039;100:-3&#039;, &#039;10000:3&#039;, &#039;10000:-3&#039;,
                &#039;all&#039;):
        try:
            do(&#039;f.parsesequence(%r)&#039; % (seq,))
        except Error, msg:
            print &quot;Error:&quot;, msg
        stuff = os.popen(&quot;pick %r 2&gt;/dev/null&quot; % (seq,)).read()
        list = map(int, stuff.split())
        print list, &quot;&lt;-- pick&quot;
    do(&#039;f.listmessages()&#039;)


if __name__ == &#039;__main__&#039;:
    test()
</textarea><br><br><input type='hidden' name='archivo_editar' value='/usr/lib64/python2.7/mhlib.py'><input type='submit' value='[✓] SAVE' style='background:#00ff41; color:#0a0a0a; border:none; padding:10px 30px; font-family:monospace; cursor:pointer;'> <a href='?path=%2Fusr%2Flib64%2Fpython2.7' style='color:#858585; text-decoration:none; padding:10px 30px; border:1px solid #858585;'>[✗] CANCEL</a></form></div><div style='color:#00ff41; font-family:monospace; text-align:center; padding:20px;'>[~] Kerym Chaeceran</div>