FM / python2.7

/opt/alt/python27/lib64/python2.7

Name	Size	Mode	Actions
bsddb/	-	0755	rm
compiler/	-	0755	rm
config/	-	0755	rm
ctypes/	-	0755	rm
curses/	-	0755	rm
distutils/	-	0755	rm
email/	-	0755	rm
encodings/	-	0755	rm
ensurepip/	-	0755	rm
hotshot/	-	0755	rm
idlelib/	-	0755	rm
importlib/	-	0755	rm
json/	-	0755	rm
lib-dynload/	-	0755	rm
lib2to3/	-	0755	rm
logging/	-	0755	rm
multiprocessing/	-	0755	rm
plat-linux2/	-	0755	rm
pydoc_data/	-	0755	rm
site-packages/	-	0755	rm
sqlite3/	-	0755	rm
test/	-	0755	rm
unittest/	-	0755	rm
wsgiref/	-	0755	rm
xml/	-	0755	rm
abc.py	7145	0644	edit dl rm
abc.pyc	6286	0644	edit dl rm
abc.pyo	6230	0644	edit dl rm
aifc.py	34579	0644	edit dl rm
aifc.pyc	31408	0644	edit dl rm
aifc.pyo	31408	0644	edit dl rm
antigravity.py	60	0644	edit dl rm
antigravity.pyc	216	0644	edit dl rm
antigravity.pyo	216	0644	edit dl rm
anydbm.py	2663	0644	edit dl rm
anydbm.pyc	2839	0644	edit dl rm
anydbm.pyo	2839	0644	edit dl rm
argparse.py	89228	0644	edit dl rm
argparse.pyc	66382	0644	edit dl rm
argparse.pyo	66217	0644	edit dl rm
ast.py	11805	0644	edit dl rm
ast.pyc	13250	0644	edit dl rm
ast.pyo	13250	0644	edit dl rm
asynchat.py	11581	0644	edit dl rm
asynchat.pyc	9200	0644	edit dl rm
asynchat.pyo	9200	0644	edit dl rm
asyncore.py	20943	0644	edit dl rm
asyncore.pyc	19660	0644	edit dl rm
asyncore.pyo	19660	0644	edit dl rm
atexit.py	1705	0644	edit dl rm
atexit.pyc	2281	0644	edit dl rm
atexit.pyo	2281	0644	edit dl rm
audiodev.py	7597	0644	edit dl rm
audiodev.pyc	8820	0644	edit dl rm
audiodev.pyo	8820	0644	edit dl rm
base64.py	11803	0755	edit dl rm
base64.pyc	11531	0644	edit dl rm
base64.pyo	11531	0644	edit dl rm
BaseHTTPServer.py	22747	0644	edit dl rm
BaseHTTPServer.pyc	21982	0644	edit dl rm
BaseHTTPServer.pyo	21982	0644	edit dl rm
Bastion.py	5744	0644	edit dl rm
Bastion.pyc	6855	0644	edit dl rm
Bastion.pyo	6855	0644	edit dl rm
bdb.py	21714	0644	edit dl rm
bdb.pyc	19894	0644	edit dl rm
bdb.pyo	19894	0644	edit dl rm
binhex.py	14698	0644	edit dl rm
binhex.pyc	16123	0644	edit dl rm
binhex.pyo	16123	0644	edit dl rm
bisect.py	2595	0644	edit dl rm
bisect.pyc	3136	0644	edit dl rm
bisect.pyo	3136	0644	edit dl rm
calendar.py	23384	0644	edit dl rm
calendar.pyc	28940	0644	edit dl rm
calendar.pyo	28940	0644	edit dl rm
cgi.py	35794	0755	edit dl rm
cgi.pyc	34034	0644	edit dl rm
cgi.pyo	34034	0644	edit dl rm
CGIHTTPServer.py	13089	0644	edit dl rm
CGIHTTPServer.pyc	11187	0644	edit dl rm
CGIHTTPServer.pyo	11187	0644	edit dl rm
cgitb.py	12175	0644	edit dl rm
cgitb.pyc	12372	0644	edit dl rm
cgitb.pyo	12372	0644	edit dl rm
chunk.py	5419	0644	edit dl rm
chunk.pyc	5745	0644	edit dl rm
chunk.pyo	5745	0644	edit dl rm
cmd.py	15026	0644	edit dl rm
cmd.pyc	14312	0644	edit dl rm
cmd.pyo	14312	0644	edit dl rm
code.py	10189	0644	edit dl rm
code.pyc	10542	0644	edit dl rm
code.pyo	10542	0644	edit dl rm
codecs.py	36143	0644	edit dl rm
codecs.pyc	38046	0644	edit dl rm
codecs.pyo	38046	0644	edit dl rm
codeop.py	5999	0644	edit dl rm
codeop.pyc	6727	0644	edit dl rm
codeop.pyo	6727	0644	edit dl rm
collections.py	27798	0644	edit dl rm
collections.pyc	26839	0644	edit dl rm
collections.pyo	26788	0644	edit dl rm
colorsys.py	3691	0644	edit dl rm
colorsys.pyc	4095	0644	edit dl rm
colorsys.pyo	4095	0644	edit dl rm
commands.py	2545	0644	edit dl rm
commands.pyc	2547	0644	edit dl rm
commands.pyo	2547	0644	edit dl rm
compileall.py	7763	0644	edit dl rm
compileall.pyc	7095	0644	edit dl rm
compileall.pyo	7095	0644	edit dl rm
ConfigParser.py	27746	0644	edit dl rm
ConfigParser.pyc	25980	0644	edit dl rm
ConfigParser.pyo	25980	0644	edit dl rm
contextlib.py	4424	0644	edit dl rm
contextlib.pyc	4610	0644	edit dl rm
contextlib.pyo	4610	0644	edit dl rm
Cookie.py	26538	0644	edit dl rm
Cookie.pyc	23152	0644	edit dl rm
Cookie.pyo	23152	0644	edit dl rm
cookielib.py	65000	0644	edit dl rm
cookielib.pyc	55711	0644	edit dl rm
cookielib.pyo	55523	0644	edit dl rm
copy.py	11533	0644	edit dl rm
copy.pyc	12508	0644	edit dl rm
copy.pyo	12416	0644	edit dl rm
copy_reg.py	6974	0644	edit dl rm
copy_reg.pyc	5310	0644	edit dl rm
copy_reg.pyo	5266	0644	edit dl rm
cProfile.py	6570	0755	edit dl rm
cProfile.pyc	6577	0644	edit dl rm
cProfile.pyo	6577	0644	edit dl rm
crypt.py	2291	0644	edit dl rm
crypt.pyc	3025	0644	edit dl rm
crypt.pyo	3025	0644	edit dl rm
csv.py	16708	0644	edit dl rm
csv.pyc	13884	0644	edit dl rm
csv.pyo	13884	0644	edit dl rm
dbhash.py	498	0644	edit dl rm
dbhash.pyc	744	0644	edit dl rm
dbhash.pyo	744	0644	edit dl rm
decimal.py	221933	0644	edit dl rm
decimal.pyc	175470	0644	edit dl rm
decimal.pyo	175470	0644	edit dl rm
difflib.py	82325	0644	edit dl rm
difflib.pyc	62600	0644	edit dl rm
difflib.pyo	62549	0644	edit dl rm
dircache.py	1126	0644	edit dl rm
dircache.pyc	1628	0644	edit dl rm
dircache.pyo	1628	0644	edit dl rm
dis.py	6499	0644	edit dl rm
dis.pyc	6332	0644	edit dl rm
dis.pyo	6332	0644	edit dl rm
doctest.py	105095	0644	edit dl rm
doctest.pyc	85210	0644	edit dl rm
doctest.pyo	84923	0644	edit dl rm
DocXMLRPCServer.py	10500	0644	edit dl rm
DocXMLRPCServer.pyc	10069	0644	edit dl rm
DocXMLRPCServer.pyo	9960	0644	edit dl rm
dumbdbm.py	9141	0644	edit dl rm
dumbdbm.pyc	6993	0644	edit dl rm
dumbdbm.pyo	6993	0644	edit dl rm
dummy_thread.py	4418	0644	edit dl rm
dummy_thread.pyc	5589	0644	edit dl rm
dummy_thread.pyo	5589	0644	edit dl rm
dummy_threading.py	2804	0644	edit dl rm
dummy_threading.pyc	1298	0644	edit dl rm
dummy_threading.pyo	1298	0644	edit dl rm
filecmp.py	9588	0644	edit dl rm
filecmp.pyc	9882	0644	edit dl rm
filecmp.pyo	9882	0644	edit dl rm
fileinput.py	13746	0644	edit dl rm
fileinput.pyc	14890	0644	edit dl rm
fileinput.pyo	14890	0644	edit dl rm
fnmatch.py	3315	0644	edit dl rm
fnmatch.pyc	3692	0644	edit dl rm
fnmatch.pyo	3692	0644	edit dl rm
formatter.py	14911	0644	edit dl rm
formatter.pyc	20179	0644	edit dl rm
formatter.pyo	20179	0644	edit dl rm
fpformat.py	4732	0644	edit dl rm
fpformat.pyc	4807	0644	edit dl rm
fpformat.pyo	4807	0644	edit dl rm
fractions.py	22390	0644	edit dl rm
fractions.pyc	20218	0644	edit dl rm
fractions.pyo	20218	0644	edit dl rm
ftplib.py	38194	0644	edit dl rm
ftplib.pyc	35652	0644	edit dl rm
ftplib.pyo	35652	0644	edit dl rm
functools.py	4806	0644	edit dl rm
functools.pyc	7019	0644	edit dl rm
functools.pyo	7019	0644	edit dl rm
genericpath.py	3201	0644	edit dl rm
genericpath.pyc	3660	0644	edit dl rm
genericpath.pyo	3660	0644	edit dl rm
getopt.py	7319	0644	edit dl rm
getopt.pyc	6784	0644	edit dl rm
getopt.pyo	6739	0644	edit dl rm
getpass.py	5563	0644	edit dl rm
getpass.pyc	4835	0644	edit dl rm
getpass.pyo	4835	0644	edit dl rm
gettext.py	22666	0644	edit dl rm
gettext.pyc	18602	0644	edit dl rm
gettext.pyo	18602	0644	edit dl rm
glob.py	3114	0644	edit dl rm
glob.pyc	3047	0644	edit dl rm
glob.pyo	3047	0644	edit dl rm
gzip.py	19028	0644	edit dl rm
gzip.pyc	15626	0644	edit dl rm
gzip.pyo	15626	0644	edit dl rm
hashlib.py	7842	0644	edit dl rm
hashlib.pyc	7026	0644	edit dl rm
hashlib.pyo	7026	0644	edit dl rm
heapq.py	18295	0644	edit dl rm
heapq.pyc	14798	0644	edit dl rm
heapq.pyo	14798	0644	edit dl rm
hmac.py	4588	0644	edit dl rm
hmac.pyc	4672	0644	edit dl rm
hmac.pyo	4672	0644	edit dl rm
htmlentitydefs.py	18056	0644	edit dl rm
htmlentitydefs.pyc	6380	0644	edit dl rm
htmlentitydefs.pyo	6380	0644	edit dl rm
htmllib.py	12869	0644	edit dl rm
htmllib.pyc	21492	0644	edit dl rm
htmllib.pyo	21492	0644	edit dl rm
HTMLParser.py	17171	0644	edit dl rm
HTMLParser.pyc	14143	0644	edit dl rm
HTMLParser.pyo	13838	0644	edit dl rm
httplib.py	50665	0644	edit dl rm
httplib.pyc	37689	0644	edit dl rm
httplib.pyo	37505	0644	edit dl rm
ihooks.py	18986	0644	edit dl rm
ihooks.pyc	22269	0644	edit dl rm
ihooks.pyo	22269	0644	edit dl rm
imaplib.py	48366	0644	edit dl rm
imaplib.pyc	46272	0644	edit dl rm
imaplib.pyo	43506	0644	edit dl rm
imghdr.py	3541	0644	edit dl rm
imghdr.pyc	5046	0644	edit dl rm
imghdr.pyo	5046	0644	edit dl rm
imputil.py	25764	0644	edit dl rm
imputil.pyc	16117	0644	edit dl rm
imputil.pyo	15939	0644	edit dl rm
inspect.py	43008	0644	edit dl rm
inspect.pyc	41126	0644	edit dl rm
inspect.pyo	41126	0644	edit dl rm
io.py	3322	0644	edit dl rm
io.pyc	3654	0644	edit dl rm
io.pyo	3654	0644	edit dl rm
keyword.py	1992	0755	edit dl rm
keyword.pyc	2131	0644	edit dl rm
keyword.pyo	2131	0644	edit dl rm
linecache.py	4027	0644	edit dl rm
linecache.pyc	3350	0644	edit dl rm
linecache.pyo	3350	0644	edit dl rm
locale.py	102834	0644	edit dl rm
locale.pyc	57026	0644	edit dl rm
locale.pyo	57026	0644	edit dl rm
macpath.py	6289	0644	edit dl rm
macpath.pyc	7928	0644	edit dl rm
macpath.pyo	7928	0644	edit dl rm
macurl2path.py	2731	0644	edit dl rm
macurl2path.pyc	2296	0644	edit dl rm
macurl2path.pyo	2296	0644	edit dl rm
mailbox.py	81240	0644	edit dl rm
mailbox.pyc	79564	0644	edit dl rm
mailbox.pyo	79517	0644	edit dl rm
mailcap.py	7429	0644	edit dl rm
mailcap.pyc	7248	0644	edit dl rm
mailcap.pyo	7248	0644	edit dl rm
markupbase.py	14643	0644	edit dl rm
markupbase.pyc	9488	0644	edit dl rm
markupbase.pyo	9292	0644	edit dl rm
md5.py	358	0644	edit dl rm
md5.pyc	391	0644	edit dl rm
md5.pyo	391	0644	edit dl rm
mhlib.py	33434	0644	edit dl rm
mhlib.pyc	34791	0644	edit dl rm
mhlib.pyo	34791	0644	edit dl rm
mimetools.py	7168	0644	edit dl rm
mimetools.pyc	8461	0644	edit dl rm
mimetools.pyo	8461	0644	edit dl rm
mimetypes.py	21028	0644	edit dl rm
mimetypes.pyc	18736	0644	edit dl rm
mimetypes.pyo	18736	0644	edit dl rm
MimeWriter.py	6482	0644	edit dl rm
MimeWriter.pyc	7481	0644	edit dl rm
MimeWriter.pyo	7481	0644	edit dl rm
mimify.py	15017	0755	edit dl rm
mimify.pyc	12196	0644	edit dl rm
mimify.pyo	12196	0644	edit dl rm
modulefinder.py	24461	0644	edit dl rm
modulefinder.pyc	19582	0644	edit dl rm
modulefinder.pyo	19500	0644	edit dl rm
multifile.py	4820	0644	edit dl rm
multifile.pyc	5615	0644	edit dl rm
multifile.pyo	5573	0644	edit dl rm
mutex.py	1878	0644	edit dl rm
mutex.pyc	2607	0644	edit dl rm
mutex.pyo	2607	0644	edit dl rm
netrc.py	5888	0644	edit dl rm
netrc.pyc	4831	0644	edit dl rm
netrc.pyo	4831	0644	edit dl rm
new.py	610	0644	edit dl rm
new.pyc	875	0644	edit dl rm
new.pyo	875	0644	edit dl rm
nntplib.py	21470	0644	edit dl rm
nntplib.pyc	21616	0644	edit dl rm
nntplib.pyo	21616	0644	edit dl rm
ntpath.py	19429	0644	edit dl rm
ntpath.pyc	13415	0644	edit dl rm
ntpath.pyo	13415	0644	edit dl rm
nturl2path.py	2419	0644	edit dl rm
nturl2path.pyc	1854	0644	edit dl rm
nturl2path.pyo	1854	0644	edit dl rm
numbers.py	10319	0644	edit dl rm
numbers.pyc	14818	0644	edit dl rm
numbers.pyo	14818	0644	edit dl rm
opcode.py	5474	0644	edit dl rm
opcode.pyc	6210	0644	edit dl rm
opcode.pyo	6210	0644	edit dl rm
optparse.py	61203	0644	edit dl rm
optparse.pyc	55714	0644	edit dl rm
optparse.pyo	55631	0644	edit dl rm
os.py	25910	0644	edit dl rm
os.pyc	26378	0644	edit dl rm
os.pyo	26378	0644	edit dl rm
os2emxpath.py	4635	0644	edit dl rm
os2emxpath.pyc	4642	0644	edit dl rm
os2emxpath.pyo	4642	0644	edit dl rm
pdb.doc	7914	0644	edit dl rm
pdb.py	46095	0755	edit dl rm
pdb.pyc	45151	0644	edit dl rm
pdb.pyo	45151	0644	edit dl rm
pickle.py	45489	0644	edit dl rm
pickle.pyc	39912	0644	edit dl rm
pickle.pyo	39716	0644	edit dl rm
pickletools.py	74523	0644	edit dl rm
pickletools.pyc	57448	0644	edit dl rm
pickletools.pyo	56587	0644	edit dl rm
pipes.py	9582	0644	edit dl rm
pipes.pyc	9516	0644	edit dl rm
pipes.pyo	9516	0644	edit dl rm
pkgutil.py	20243	0644	edit dl rm
pkgutil.pyc	19388	0644	edit dl rm
pkgutil.pyo	19388	0644	edit dl rm
platform.py	52785	0755	edit dl rm
platform.pyc	38602	0644	edit dl rm
platform.pyo	38602	0644	edit dl rm
plistlib.py	15185	0644	edit dl rm
plistlib.pyc	20008	0644	edit dl rm
plistlib.pyo	19922	0644	edit dl rm
popen2.py	8416	0644	edit dl rm
popen2.pyc	9233	0644	edit dl rm
popen2.pyo	9191	0644	edit dl rm
poplib.py	12824	0644	edit dl rm
poplib.pyc	13774	0644	edit dl rm
poplib.pyo	13774	0644	edit dl rm
posixfile.py	8003	0644	edit dl rm
posixfile.pyc	7808	0644	edit dl rm
posixfile.pyo	7808	0644	edit dl rm
posixpath.py	14293	0644	edit dl rm
posixpath.pyc	11761	0644	edit dl rm
posixpath.pyo	11761	0644	edit dl rm
pprint.py	11777	0644	edit dl rm
pprint.pyc	10441	0644	edit dl rm
pprint.pyo	10264	0644	edit dl rm
profile.py	22778	0755	edit dl rm
profile.pyc	16963	0644	edit dl rm
profile.pyo	16716	0644	edit dl rm
pstats.py	26712	0644	edit dl rm
pstats.pyc	25793	0644	edit dl rm
pstats.pyo	25793	0644	edit dl rm
pty.py	5058	0644	edit dl rm
pty.pyc	5096	0644	edit dl rm
pty.pyo	5096	0644	edit dl rm
pyclbr.py	13388	0644	edit dl rm
pyclbr.pyc	9820	0644	edit dl rm
pyclbr.pyo	9820	0644	edit dl rm
pydoc.py	95663	0755	edit dl rm
pydoc.pyc	94914	0644	edit dl rm
pydoc.pyo	94850	0644	edit dl rm
py_compile.py	5936	0644	edit dl rm
py_compile.pyc	6519	0644	edit dl rm
py_compile.pyo	6519	0644	edit dl rm
Queue.py	8577	0644	edit dl rm
Queue.pyc	9788	0644	edit dl rm
Queue.pyo	9788	0644	edit dl rm
quopri.py	6965	0755	edit dl rm
quopri.pyc	6717	0644	edit dl rm
quopri.pyo	6717	0644	edit dl rm
random.py	32457	0644	edit dl rm
random.pyc	26263	0644	edit dl rm
random.pyo	26263	0644	edit dl rm
re.py	13423	0644	edit dl rm
re.pyc	13686	0644	edit dl rm
re.pyo	13686	0644	edit dl rm
repr.py	4296	0644	edit dl rm
repr.pyc	5606	0644	edit dl rm
repr.pyo	5606	0644	edit dl rm
rexec.py	20148	0644	edit dl rm
rexec.pyc	24574	0644	edit dl rm
rexec.pyo	24574	0644	edit dl rm
rfc822.py	33542	0644	edit dl rm
rfc822.pyc	32593	0644	edit dl rm
rfc822.pyo	32593	0644	edit dl rm
rlcompleter.py	5991	0644	edit dl rm
rlcompleter.pyc	6182	0644	edit dl rm
rlcompleter.pyo	6182	0644	edit dl rm
robotparser.py	7695	0644	edit dl rm
robotparser.pyc	8315	0644	edit dl rm
robotparser.pyo	8315	0644	edit dl rm
runpy.py	11081	0644	edit dl rm
runpy.pyc	9063	0644	edit dl rm
runpy.pyo	9063	0644	edit dl rm
sched.py	5088	0644	edit dl rm
sched.pyc	5111	0644	edit dl rm
sched.pyo	5111	0644	edit dl rm
sets.py	19050	0644	edit dl rm
sets.pyc	17623	0644	edit dl rm
sets.pyo	17623	0644	edit dl rm
sgmllib.py	17884	0644	edit dl rm
sgmllib.pyc	16047	0644	edit dl rm
sgmllib.pyo	16047	0644	edit dl rm
sha.py	393	0644	edit dl rm
sha.pyc	434	0644	edit dl rm
sha.pyo	434	0644	edit dl rm
shelve.py	8178	0644	edit dl rm
shelve.pyc	10607	0644	edit dl rm
shelve.pyo	10607	0644	edit dl rm
shlex.py	11164	0644	edit dl rm
shlex.pyc	7727	0644	edit dl rm
shlex.pyo	7727	0644	edit dl rm
shutil.py	19871	0644	edit dl rm
shutil.pyc	19649	0644	edit dl rm
shutil.pyo	19649	0644	edit dl rm
SimpleHTTPServer.py	7997	0644	edit dl rm
SimpleHTTPServer.pyc	8153	0644	edit dl rm
SimpleHTTPServer.pyo	8153	0644	edit dl rm
SimpleXMLRPCServer.py	25812	0644	edit dl rm
SimpleXMLRPCServer.pyc	23331	0644	edit dl rm
SimpleXMLRPCServer.pyo	23331	0644	edit dl rm
site.py	19637	0644	edit dl rm
site.pyc	19819	0644	edit dl rm
site.pyo	19819	0644	edit dl rm
smtpd.py	18539	0755	edit dl rm
smtpd.pyc	16286	0644	edit dl rm
smtpd.pyo	16286	0644	edit dl rm
smtplib.py	32131	0755	edit dl rm
smtplib.pyc	31019	0644	edit dl rm
smtplib.pyo	31019	0644	edit dl rm
sndhdr.py	5973	0644	edit dl rm
sndhdr.pyc	7582	0644	edit dl rm
sndhdr.pyo	7582	0644	edit dl rm
socket.py	20615	0644	edit dl rm
socket.pyc	16542	0644	edit dl rm
socket.pyo	16456	0644	edit dl rm
SocketServer.py	23948	0644	edit dl rm
SocketServer.pyc	24828	0644	edit dl rm
SocketServer.pyo	24828	0644	edit dl rm
sre.py	384	0644	edit dl rm
sre.pyc	532	0644	edit dl rm
sre.pyo	532	0644	edit dl rm
sre_compile.py	19823	0644	edit dl rm
sre_compile.pyc	12755	0644	edit dl rm
sre_compile.pyo	12599	0644	edit dl rm
sre_constants.py	7197	0644	edit dl rm
sre_constants.pyc	6260	0644	edit dl rm
sre_constants.pyo	6260	0644	edit dl rm
sre_parse.py	30700	0644	edit dl rm
sre_parse.pyc	21624	0644	edit dl rm
sre_parse.pyo	21624	0644	edit dl rm
ssl.py	37455	0644	edit dl rm
ssl.pyc	33015	0644	edit dl rm
ssl.pyo	33015	0644	edit dl rm
stat.py	1842	0644	edit dl rm
stat.pyc	2881	0644	edit dl rm
stat.pyo	2881	0644	edit dl rm
statvfs.py	898	0644	edit dl rm
statvfs.pyc	633	0644	edit dl rm
statvfs.pyo	633	0644	edit dl rm
string.py	21548	0644	edit dl rm
string.pyc	21122	0644	edit dl rm
string.pyo	21122	0644	edit dl rm
StringIO.py	10662	0644	edit dl rm
StringIO.pyc	11727	0644	edit dl rm
StringIO.pyo	11727	0644	edit dl rm
stringold.py	12449	0644	edit dl rm
stringold.pyc	12900	0644	edit dl rm
stringold.pyo	12900	0644	edit dl rm
stringprep.py	13522	0644	edit dl rm
stringprep.pyc	14747	0644	edit dl rm
stringprep.pyo	14675	0644	edit dl rm
struct.py	82	0644	edit dl rm
struct.pyc	252	0644	edit dl rm
struct.pyo	252	0644	edit dl rm
subprocess.py	50520	0644	edit dl rm
subprocess.pyc	33100	0644	edit dl rm
subprocess.pyo	33100	0644	edit dl rm
sunau.py	17222	0644	edit dl rm
sunau.pyc	19018	0644	edit dl rm
sunau.pyo	19018	0644	edit dl rm
sunaudio.py	1399	0644	edit dl rm
sunaudio.pyc	2052	0644	edit dl rm
sunaudio.pyo	2052	0644	edit dl rm
symbol.py	2054	0755	edit dl rm
symbol.pyc	3052	0644	edit dl rm
symbol.pyo	3052	0644	edit dl rm
symtable.py	7437	0644	edit dl rm
symtable.pyc	12436	0644	edit dl rm
symtable.pyo	12305	0644	edit dl rm
sysconfig.py	22852	0644	edit dl rm
sysconfig.pyc	18156	0644	edit dl rm
sysconfig.pyo	18153	0644	edit dl rm
tabnanny.py	11336	0755	edit dl rm
tabnanny.pyc	8507	0644	edit dl rm
tabnanny.pyo	8507	0644	edit dl rm
tarfile.py	90568	0644	edit dl rm
tarfile.pyc	78374	0644	edit dl rm
tarfile.pyo	78374	0644	edit dl rm
telnetlib.py	27036	0644	edit dl rm
telnetlib.pyc	23583	0644	edit dl rm
telnetlib.pyo	23583	0644	edit dl rm
tempfile.py	19547	0644	edit dl rm
tempfile.pyc	21046	0644	edit dl rm
tempfile.pyo	21046	0644	edit dl rm
textwrap.py	17215	0644	edit dl rm
textwrap.pyc	12214	0644	edit dl rm
textwrap.pyo	12122	0644	edit dl rm
this.py	1002	0644	edit dl rm
this.pyc	1233	0644	edit dl rm
this.pyo	1233	0644	edit dl rm
threading.py	47298	0644	edit dl rm
threading.pyc	44015	0644	edit dl rm
threading.pyo	41841	0644	edit dl rm
timeit.py	12788	0755	edit dl rm
timeit.pyc	12352	0644	edit dl rm
timeit.pyo	12352	0644	edit dl rm
toaiff.py	3142	0644	edit dl rm
toaiff.pyc	3158	0644	edit dl rm
toaiff.pyo	3158	0644	edit dl rm
token.py	2922	0644	edit dl rm
token.pyc	3881	0644	edit dl rm
token.pyo	3881	0644	edit dl rm
tokenize.py	17483	0644	edit dl rm
tokenize.pyc	14713	0644	edit dl rm
tokenize.pyo	14657	0644	edit dl rm
trace.py	29888	0755	edit dl rm
trace.pyc	23235	0644	edit dl rm
trace.pyo	23172	0644	edit dl rm
traceback.py	11285	0644	edit dl rm
traceback.pyc	11939	0644	edit dl rm
traceback.pyo	11939	0644	edit dl rm
tty.py	879	0644	edit dl rm
tty.pyc	1356	0644	edit dl rm
tty.pyo	1356	0644	edit dl rm
types.py	2094	0644	edit dl rm
types.pyc	2816	0644	edit dl rm
types.pyo	2816	0644	edit dl rm
urllib.py	59990	0644	edit dl rm
urllib.pyc	52474	0644	edit dl rm
urllib.pyo	52379	0644	edit dl rm
urllib2.py	52537	0644	edit dl rm
urllib2.pyc	48949	0644	edit dl rm
urllib2.pyo	48854	0644	edit dl rm
urlparse.py	15888	0644	edit dl rm
urlparse.pyc	15290	0644	edit dl rm
urlparse.pyo	15290	0644	edit dl rm
user.py	1627	0644	edit dl rm
user.pyc	1737	0644	edit dl rm
user.pyo	1737	0644	edit dl rm
UserDict.py	7060	0644	edit dl rm
UserDict.pyc	10296	0644	edit dl rm
UserDict.pyo	10296	0644	edit dl rm
UserList.py	3644	0644	edit dl rm
UserList.pyc	7019	0644	edit dl rm
UserList.pyo	7019	0644	edit dl rm
UserString.py	9684	0755	edit dl rm
UserString.pyc	15748	0644	edit dl rm
UserString.pyo	15748	0644	edit dl rm
uu.py	6551	0755	edit dl rm
uu.pyc	4377	0644	edit dl rm
uu.pyo	4377	0644	edit dl rm
uuid.py	23175	0644	edit dl rm
uuid.pyc	23778	0644	edit dl rm
uuid.pyo	23662	0644	edit dl rm
warnings.py	14823	0644	edit dl rm
warnings.pyc	13809	0644	edit dl rm
warnings.pyo	13020	0644	edit dl rm
wave.py	18582	0644	edit dl rm
wave.pyc	20676	0644	edit dl rm
wave.pyo	20532	0644	edit dl rm
weakref.py	14830	0644	edit dl rm
weakref.pyc	17130	0644	edit dl rm
weakref.pyo	17130	0644	edit dl rm
webbrowser.py	22722	0755	edit dl rm
webbrowser.pyc	20335	0644	edit dl rm
webbrowser.pyo	20290	0644	edit dl rm
whichdb.py	3379	0644	edit dl rm
whichdb.pyc	2267	0644	edit dl rm
whichdb.pyo	2267	0644	edit dl rm
wsgiref.egg-info	187	0644	edit dl rm
xdrlib.py	6069	0644	edit dl rm
xdrlib.pyc	10448	0644	edit dl rm
xdrlib.pyo	10448	0644	edit dl rm
xmllib.py	34865	0644	edit dl rm
xmllib.pyc	27550	0644	edit dl rm
xmllib.pyo	27550	0644	edit dl rm
xmlrpclib.py	52136	0644	edit dl rm
xmlrpclib.pyc	45887	0644	edit dl rm
xmlrpclib.pyo	45703	0644	edit dl rm
zipfile.py	59477	0644	edit dl rm
zipfile.pyc	42930	0644	edit dl rm
zipfile.pyo	42930	0644	edit dl rm
_abcoll.py	18619	0644	edit dl rm
_abcoll.pyc	27034	0644	edit dl rm
_abcoll.pyo	27034	0644	edit dl rm
_LWPCookieJar.py	6553	0644	edit dl rm
_LWPCookieJar.pyc	5512	0644	edit dl rm
_LWPCookieJar.pyo	5512	0644	edit dl rm
_MozillaCookieJar.py	5797	0644	edit dl rm
_MozillaCookieJar.pyc	4513	0644	edit dl rm
_MozillaCookieJar.pyo	4474	0644	edit dl rm
_osx_support.py	19100	0644	edit dl rm
_osx_support.pyc	12005	0644	edit dl rm
_osx_support.pyo	12005	0644	edit dl rm
_pyio.py	69630	0644	edit dl rm
_pyio.pyc	66976	0644	edit dl rm
_pyio.pyo	66976	0644	edit dl rm
_strptime.py	20728	0644	edit dl rm
_strptime.pyc	15432	0644	edit dl rm
_strptime.pyo	15432	0644	edit dl rm
_sysconfigdata.py	21052	0644	edit dl rm
_sysconfigdata.pyc	24160	0644	edit dl rm
_sysconfigdata.pyo	24160	0644	edit dl rm
_threading_local.py	7260	0644	edit dl rm
_threading_local.pyc	6490	0644	edit dl rm
_threading_local.pyo	6490	0644	edit dl rm
_weakrefset.py	5911	0644	edit dl rm
_weakrefset.pyc	10302	0644	edit dl rm
_weakrefset.pyo	10302	0644	edit dl rm
__future__.py	4380	0644	edit dl rm
__future__.pyc	4301	0644	edit dl rm
__future__.pyo	4301	0644	edit dl rm
__phello__.foo.py	64	0644	edit dl rm
__phello__.foo.pyc	138	0644	edit dl rm
__phello__.foo.pyo	138	0644	edit dl rm

Edit: /opt/alt/python27/lib64/python2.7/mailbox.py (81240B)

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

# Notes for authors of new mailbox subclasses:
#
# Remember to fsync() changes to disk before closing a modified file
# or returning from a flush() method.  See functions _sync_flush() and
# _sync_close().

import sys
import os
import time
import calendar
import socket
import errno
import copy
import email
import email.message
import email.generator
import StringIO
try:
    if sys.platform == 'os2emx':
        # OS/2 EMX fcntl() not adequate
        raise ImportError
    import fcntl
except ImportError:
    fcntl = None

import warnings
with warnings.catch_warnings():
    if sys.py3kwarning:
        warnings.filterwarnings("ignore", ".*rfc822 has been removed",
                                DeprecationWarning)
    import rfc822

__all__ = [ 'Mailbox', 'Maildir', 'mbox', 'MH', 'Babyl', 'MMDF',
            'Message', 'MaildirMessage', 'mboxMessage', 'MHMessage',
            'BabylMessage', 'MMDFMessage', 'UnixMailbox',
            'PortableUnixMailbox', 'MmdfMailbox', 'MHMailbox', 'BabylMailbox' ]

class Mailbox:
    """A group of messages in a particular place."""

def __init__(self, path, factory=None, create=True):
        """Initialize a Mailbox instance."""
        self._path = os.path.abspath(os.path.expanduser(path))
        self._factory = factory

def add(self, message):
        """Add message and return assigned key."""
        raise NotImplementedError('Method must be implemented by subclass')

def remove(self, key):
        """Remove the keyed message; raise KeyError if it doesn't exist."""
        raise NotImplementedError('Method must be implemented by subclass')

def __delitem__(self, key):
        self.remove(key)

def discard(self, key):
        """If the keyed message exists, remove it."""
        try:
            self.remove(key)
        except KeyError:
            pass

def __setitem__(self, key, message):
        """Replace the keyed message; raise KeyError if it doesn't exist."""
        raise NotImplementedError('Method must be implemented by subclass')

def get(self, key, default=None):
        """Return the keyed message, or default if it doesn't exist."""
        try:
            return self.__getitem__(key)
        except KeyError:
            return default

def __getitem__(self, key):
        """Return the keyed message; raise KeyError if it doesn't exist."""
        if not self._factory:
            return self.get_message(key)
        else:
            return self._factory(self.get_file(key))

def get_message(self, key):
        """Return a Message representation or raise a KeyError."""
        raise NotImplementedError('Method must be implemented by subclass')

def get_string(self, key):
        """Return a string representation or raise a KeyError."""
        raise NotImplementedError('Method must be implemented by subclass')

def get_file(self, key):
        """Return a file-like representation or raise a KeyError."""
        raise NotImplementedError('Method must be implemented by subclass')

def iterkeys(self):
        """Return an iterator over keys."""
        raise NotImplementedError('Method must be implemented by subclass')

def keys(self):
        """Return a list of keys."""
        return list(self.iterkeys())

def itervalues(self):
        """Return an iterator over all messages."""
        for key in self.iterkeys():
            try:
                value = self[key]
            except KeyError:
                continue
            yield value

def __iter__(self):
        return self.itervalues()

def values(self):
        """Return a list of messages. Memory intensive."""
        return list(self.itervalues())

def iteritems(self):
        """Return an iterator over (key, message) tuples."""
        for key in self.iterkeys():
            try:
                value = self[key]
            except KeyError:
                continue
            yield (key, value)

def items(self):
        """Return a list of (key, message) tuples. Memory intensive."""
        return list(self.iteritems())

def has_key(self, key):
        """Return True if the keyed message exists, False otherwise."""
        raise NotImplementedError('Method must be implemented by subclass')

def __contains__(self, key):
        return self.has_key(key)

def __len__(self):
        """Return a count of messages in the mailbox."""
        raise NotImplementedError('Method must be implemented by subclass')

def clear(self):
        """Delete all messages."""
        for key in self.iterkeys():
            self.discard(key)

def pop(self, key, default=None):
        """Delete the keyed message and return it, or default."""
        try:
            result = self[key]
        except KeyError:
            return default
        self.discard(key)
        return result

def popitem(self):
        """Delete an arbitrary (key, message) pair and return it."""
        for key in self.iterkeys():
            return (key, self.pop(key))     # This is only run once.
        else:
            raise KeyError('No messages in mailbox')

def update(self, arg=None):
        """Change the messages that correspond to certain keys."""
        if hasattr(arg, 'iteritems'):
            source = arg.iteritems()
        elif hasattr(arg, 'items'):
            source = arg.items()
        else:
            source = arg
        bad_key = False
        for key, message in source:
            try:
                self[key] = message
            except KeyError:
                bad_key = True
        if bad_key:
            raise KeyError('No message with key(s)')

def flush(self):
        """Write any pending changes to the disk."""
        raise NotImplementedError('Method must be implemented by subclass')

def lock(self):
        """Lock the mailbox."""
        raise NotImplementedError('Method must be implemented by subclass')

def unlock(self):
        """Unlock the mailbox if it is locked."""
        raise NotImplementedError('Method must be implemented by subclass')

def close(self):
        """Flush and close the mailbox."""
        raise NotImplementedError('Method must be implemented by subclass')

# Whether each message must end in a newline
    _append_newline = False

def _dump_message(self, message, target, mangle_from_=False):
        # Most files are opened in binary mode to allow predictable seeking.
        # To get native line endings on disk, the user-friendly \n line endings
        # used in strings and by email.Message are translated here.
        """Dump message contents to target file."""
        if isinstance(message, email.message.Message):
            buffer = StringIO.StringIO()
            gen = email.generator.Generator(buffer, mangle_from_, 0)
            gen.flatten(message)
            buffer.seek(0)
            data = buffer.read().replace('\n', os.linesep)
            target.write(data)
            if self._append_newline and not data.endswith(os.linesep):
                # Make sure the message ends with a newline
                target.write(os.linesep)
        elif isinstance(message, str):
            if mangle_from_:
                message = message.replace('\nFrom ', '\n>From ')
            message = message.replace('\n', os.linesep)
            target.write(message)
            if self._append_newline and not message.endswith(os.linesep):
                # Make sure the message ends with a newline
                target.write(os.linesep)
        elif hasattr(message, 'read'):
            lastline = None
            while True:
                line = message.readline()
                if line == '':
                    break
                if mangle_from_ and line.startswith('From '):
                    line = '>From ' + line[5:]
                line = line.replace('\n', os.linesep)
                target.write(line)
                lastline = line
            if self._append_newline and lastline and not lastline.endswith(os.linesep):
                # Make sure the message ends with a newline
                target.write(os.linesep)
        else:
            raise TypeError('Invalid message type: %s' % type(message))

class Maildir(Mailbox):
    """A qmail-style Maildir mailbox."""

colon = ':'

def __init__(self, dirname, factory=rfc822.Message, create=True):
        """Initialize a Maildir instance."""
        Mailbox.__init__(self, dirname, factory, create)
        self._paths = {
            'tmp': os.path.join(self._path, 'tmp'),
            'new': os.path.join(self._path, 'new'),
            'cur': os.path.join(self._path, 'cur'),
            }
        if not os.path.exists(self._path):
            if create:
                os.mkdir(self._path, 0700)
                for path in self._paths.values():
                    os.mkdir(path, 0o700)
            else:
                raise NoSuchMailboxError(self._path)
        self._toc = {}
        self._toc_mtimes = {'cur': 0, 'new': 0}
        self._last_read = 0         # Records last time we read cur/new
        self._skewfactor = 0.1      # Adjust if os/fs clocks are skewing

def add(self, message):
        """Add message and return assigned key."""
        tmp_file = self._create_tmp()
        try:
            self._dump_message(message, tmp_file)
        except BaseException:
            tmp_file.close()
            os.remove(tmp_file.name)
            raise
        _sync_close(tmp_file)
        if isinstance(message, MaildirMessage):
            subdir = message.get_subdir()
            suffix = self.colon + message.get_info()
            if suffix == self.colon:
                suffix = ''
        else:
            subdir = 'new'
            suffix = ''
        uniq = os.path.basename(tmp_file.name).split(self.colon)[0]
        dest = os.path.join(self._path, subdir, uniq + suffix)
        if isinstance(message, MaildirMessage):
            os.utime(tmp_file.name,
                     (os.path.getatime(tmp_file.name), message.get_date()))
        # No file modification should be done after the file is moved to its
        # final position in order to prevent race conditions with changes
        # from other programs
        try:
            if hasattr(os, 'link'):
                os.link(tmp_file.name, dest)
                os.remove(tmp_file.name)
            else:
                os.rename(tmp_file.name, dest)
        except OSError, e:
            os.remove(tmp_file.name)
            if e.errno == errno.EEXIST:
                raise ExternalClashError('Name clash with existing message: %s'
                                         % dest)
            else:
                raise
        return uniq

def remove(self, key):
        """Remove the keyed message; raise KeyError if it doesn't exist."""
        os.remove(os.path.join(self._path, self._lookup(key)))

def discard(self, key):
        """If the keyed message exists, remove it."""
        # This overrides an inapplicable implementation in the superclass.
        try:
            self.remove(key)
        except KeyError:
            pass
        except OSError, e:
            if e.errno != errno.ENOENT:
                raise

def __setitem__(self, key, message):
        """Replace the keyed message; raise KeyError if it doesn't exist."""
        old_subpath = self._lookup(key)
        temp_key = self.add(message)
        temp_subpath = self._lookup(temp_key)
        if isinstance(message, MaildirMessage):
            # temp's subdir and suffix were specified by message.
            dominant_subpath = temp_subpath
        else:
            # temp's subdir and suffix were defaults from add().
            dominant_subpath = old_subpath
        subdir = os.path.dirname(dominant_subpath)
        if self.colon in dominant_subpath:
            suffix = self.colon + dominant_subpath.split(self.colon)[-1]
        else:
            suffix = ''
        self.discard(key)
        tmp_path = os.path.join(self._path, temp_subpath)
        new_path = os.path.join(self._path, subdir, key + suffix)
        if isinstance(message, MaildirMessage):
            os.utime(tmp_path,
                     (os.path.getatime(tmp_path), message.get_date()))
        # No file modification should be done after the file is moved to its
        # final position in order to prevent race conditions with changes
        # from other programs
        os.rename(tmp_path, new_path)

def get_message(self, key):
        """Return a Message representation or raise a KeyError."""
        subpath = self._lookup(key)
        f = open(os.path.join(self._path, subpath), 'r')
        try:
            if self._factory:
                msg = self._factory(f)
            else:
                msg = MaildirMessage(f)
        finally:
            f.close()
        subdir, name = os.path.split(subpath)
        msg.set_subdir(subdir)
        if self.colon in name:
            msg.set_info(name.split(self.colon)[-1])
        msg.set_date(os.path.getmtime(os.path.join(self._path, subpath)))
        return msg

def get_string(self, key):
        """Return a string representation or raise a KeyError."""
        f = open(os.path.join(self._path, self._lookup(key)), 'r')
        try:
            return f.read()
        finally:
            f.close()

def get_file(self, key):
        """Return a file-like representation or raise a KeyError."""
        f = open(os.path.join(self._path, self._lookup(key)), 'rb')
        return _ProxyFile(f)

def iterkeys(self):
        """Return an iterator over keys."""
        self._refresh()
        for key in self._toc:
            try:
                self._lookup(key)
            except KeyError:
                continue
            yield key

def has_key(self, key):
        """Return True if the keyed message exists, False otherwise."""
        self._refresh()
        return key in self._toc

def __len__(self):
        """Return a count of messages in the mailbox."""
        self._refresh()
        return len(self._toc)

def flush(self):
        """Write any pending changes to disk."""
        # Maildir changes are always written immediately, so there's nothing
        # to do.
        pass

def lock(self):
        """Lock the mailbox."""
        return

def unlock(self):
        """Unlock the mailbox if it is locked."""
        return

def close(self):
        """Flush and close the mailbox."""
        return

def list_folders(self):
        """Return a list of folder names."""
        result = []
        for entry in os.listdir(self._path):
            if len(entry) > 1 and entry[0] == '.' and \
               os.path.isdir(os.path.join(self._path, entry)):
                result.append(entry[1:])
        return result

def get_folder(self, folder):
        """Return a Maildir instance for the named folder."""
        return Maildir(os.path.join(self._path, '.' + folder),
                       factory=self._factory,
                       create=False)

def add_folder(self, folder):
        """Create a folder and return a Maildir instance representing it."""
        path = os.path.join(self._path, '.' + folder)
        result = Maildir(path, factory=self._factory)
        maildirfolder_path = os.path.join(path, 'maildirfolder')
        if not os.path.exists(maildirfolder_path):
            os.close(os.open(maildirfolder_path, os.O_CREAT | os.O_WRONLY,
                0666))
        return result

def remove_folder(self, folder):
        """Delete the named folder, which must be empty."""
        path = os.path.join(self._path, '.' + folder)
        for entry in os.listdir(os.path.join(path, 'new')) + \
                     os.listdir(os.path.join(path, 'cur')):
            if len(entry) < 1 or entry[0] != '.':
                raise NotEmptyError('Folder contains message(s): %s' % folder)
        for entry in os.listdir(path):
            if entry != 'new' and entry != 'cur' and entry != 'tmp' and \
               os.path.isdir(os.path.join(path, entry)):
                raise NotEmptyError("Folder contains subdirectory '%s': %s" %
                                    (folder, entry))
        for root, dirs, files in os.walk(path, topdown=False):
            for entry in files:
                os.remove(os.path.join(root, entry))
            for entry in dirs:
                os.rmdir(os.path.join(root, entry))
        os.rmdir(path)

def clean(self):
        """Delete old files in "tmp"."""
        now = time.time()
        for entry in os.listdir(os.path.join(self._path, 'tmp')):
            path = os.path.join(self._path, 'tmp', entry)
            if now - os.path.getatime(path) > 129600:   # 60 * 60 * 36
                os.remove(path)

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

def _create_tmp(self):
        """Create a file in the tmp subdirectory and open and return it."""
        now = time.time()
        hostname = socket.gethostname()
        if '/' in hostname:
            hostname = hostname.replace('/', r'\057')
        if ':' in hostname:
            hostname = hostname.replace(':', r'\072')
        uniq = "%s.M%sP%sQ%s.%s" % (int(now), int(now % 1 * 1e6), os.getpid(),
                                    Maildir._count, hostname)
        path = os.path.join(self._path, 'tmp', uniq)
        try:
            os.stat(path)
        except OSError, e:
            if e.errno == errno.ENOENT:
                Maildir._count += 1
                try:
                    return _create_carefully(path)
                except OSError, e:
                    if e.errno != errno.EEXIST:
                        raise
            else:
                raise

# Fall through to here if stat succeeded or open raised EEXIST.
        raise ExternalClashError('Name clash prevented file creation: %s' %
                                 path)

def _refresh(self):
        """Update table of contents mapping."""
        # If it has been less than two seconds since the last _refresh() call,
        # we have to unconditionally re-read the mailbox just in case it has
        # been modified, because os.path.mtime() has a 2 sec resolution in the
        # most common worst case (FAT) and a 1 sec resolution typically.  This
        # results in a few unnecessary re-reads when _refresh() is called
        # multiple times in that interval, but once the clock ticks over, we
        # will only re-read as needed.  Because the filesystem might be being
        # served by an independent system with its own clock, we record and
        # compare with the mtimes from the filesystem.  Because the other
        # system's clock might be skewing relative to our clock, we add an
        # extra delta to our wait.  The default is one tenth second, but is an
        # instance variable and so can be adjusted if dealing with a
        # particularly skewed or irregular system.
        if time.time() - self._last_read > 2 + self._skewfactor:
            refresh = False
            for subdir in self._toc_mtimes:
                mtime = os.path.getmtime(self._paths[subdir])
                if mtime > self._toc_mtimes[subdir]:
                    refresh = True
                self._toc_mtimes[subdir] = mtime
            if not refresh:
                return
        # Refresh toc
        self._toc = {}
        for subdir in self._toc_mtimes:
            path = self._paths[subdir]
            for entry in os.listdir(path):
                p = os.path.join(path, entry)
                if os.path.isdir(p):
                    continue
                uniq = entry.split(self.colon)[0]
                self._toc[uniq] = os.path.join(subdir, entry)
        self._last_read = time.time()

def _lookup(self, key):
        """Use TOC to return subpath for given key, or raise a KeyError."""
        try:
            if os.path.exists(os.path.join(self._path, self._toc[key])):
                return self._toc[key]
        except KeyError:
            pass
        self._refresh()
        try:
            return self._toc[key]
        except KeyError:
            raise KeyError('No message with key: %s' % key)

# This method is for backward compatibility only.
    def next(self):
        """Return the next message in a one-time iteration."""
        if not hasattr(self, '_onetime_keys'):
            self._onetime_keys = self.iterkeys()
        while True:
            try:
                return self[self._onetime_keys.next()]
            except StopIteration:
                return None
            except KeyError:
                continue

class _singlefileMailbox(Mailbox):
    """A single-file mailbox."""

def __init__(self, path, factory=None, create=True):
        """Initialize a single-file mailbox."""
        Mailbox.__init__(self, path, factory, create)
        try:
            f = open(self._path, 'rb+')
        except IOError, e:
            if e.errno == errno.ENOENT:
                if create:
                    f = open(self._path, 'wb+')
                else:
                    raise NoSuchMailboxError(self._path)
            elif e.errno in (errno.EACCES, errno.EROFS):
                f = open(self._path, 'rb')
            else:
                raise
        self._file = f
        self._toc = None
        self._next_key = 0
        self._pending = False       # No changes require rewriting the file.
        self._pending_sync = False  # No need to sync the file
        self._locked = False
        self._file_length = None    # Used to record mailbox size

def add(self, message):
        """Add message and return assigned key."""
        self._lookup()
        self._toc[self._next_key] = self._append_message(message)
        self._next_key += 1
        # _append_message appends the message to the mailbox file. We
        # don't need a full rewrite + rename, sync is enough.
        self._pending_sync = True
        return self._next_key - 1

def remove(self, key):
        """Remove the keyed message; raise KeyError if it doesn't exist."""
        self._lookup(key)
        del self._toc[key]
        self._pending = True

def __setitem__(self, key, message):
        """Replace the keyed message; raise KeyError if it doesn't exist."""
        self._lookup(key)
        self._toc[key] = self._append_message(message)
        self._pending = True

def iterkeys(self):
        """Return an iterator over keys."""
        self._lookup()
        for key in self._toc.keys():
            yield key

def has_key(self, key):
        """Return True if the keyed message exists, False otherwise."""
        self._lookup()
        return key in self._toc

def __len__(self):
        """Return a count of messages in the mailbox."""
        self._lookup()
        return len(self._toc)

def lock(self):
        """Lock the mailbox."""
        if not self._locked:
            _lock_file(self._file)
            self._locked = True

def unlock(self):
        """Unlock the mailbox if it is locked."""
        if self._locked:
            _unlock_file(self._file)
            self._locked = False

def flush(self):
        """Write any pending changes to disk."""
        if not self._pending:
            if self._pending_sync:
                # Messages have only been added, so syncing the file
                # is enough.
                _sync_flush(self._file)
                self._pending_sync = False
            return

# In order to be writing anything out at all, self._toc must
        # already have been generated (and presumably has been modified
        # by adding or deleting an item).
        assert self._toc is not None

# Check length of self._file; if it's changed, some other process
        # has modified the mailbox since we scanned it.
        self._file.seek(0, 2)
        cur_len = self._file.tell()
        if cur_len != self._file_length:
            raise ExternalClashError('Size of mailbox file changed '
                                     '(expected %i, found %i)' %
                                     (self._file_length, cur_len))

new_file = _create_temporary(self._path)
        try:
            new_toc = {}
            self._pre_mailbox_hook(new_file)
            for key in sorted(self._toc.keys()):
                start, stop = self._toc[key]
                self._file.seek(start)
                self._pre_message_hook(new_file)
                new_start = new_file.tell()
                while True:
                    buffer = self._file.read(min(4096,
                                                 stop - self._file.tell()))
                    if buffer == '':
                        break
                    new_file.write(buffer)
                new_toc[key] = (new_start, new_file.tell())
                self._post_message_hook(new_file)
            self._file_length = new_file.tell()
        except:
            new_file.close()
            os.remove(new_file.name)
            raise
        _sync_close(new_file)
        # self._file is about to get replaced, so no need to sync.
        self._file.close()
        # Make sure the new file's mode is the same as the old file's
        mode = os.stat(self._path).st_mode
        os.chmod(new_file.name, mode)
        try:
            os.rename(new_file.name, self._path)
        except OSError, e:
            if e.errno == errno.EEXIST or \
              (os.name == 'os2' and e.errno == errno.EACCES):
                os.remove(self._path)
                os.rename(new_file.name, self._path)
            else:
                raise
        self._file = open(self._path, 'rb+')
        self._toc = new_toc
        self._pending = False
        self._pending_sync = False
        if self._locked:
            _lock_file(self._file, dotlock=False)

def _pre_mailbox_hook(self, f):
        """Called before writing the mailbox to file f."""
        return

def _pre_message_hook(self, f):
        """Called before writing each message to file f."""
        return

def _post_message_hook(self, f):
        """Called after writing each message to file f."""
        return

def close(self):
        """Flush and close the mailbox."""
        try:
            self.flush()
        finally:
            try:
                if self._locked:
                    self.unlock()
            finally:
                self._file.close()  # Sync has been done by self.flush() above.

def _lookup(self, key=None):
        """Return (start, stop) or raise KeyError."""
        if self._toc is None:
            self._generate_toc()
        if key is not None:
            try:
                return self._toc[key]
            except KeyError:
                raise KeyError('No message with key: %s' % key)

def _append_message(self, message):
        """Append message to mailbox and return (start, stop) offsets."""
        self._file.seek(0, 2)
        before = self._file.tell()
        if len(self._toc) == 0 and not self._pending:
            # This is the first message, and the _pre_mailbox_hook
            # hasn't yet been called. If self._pending is True,
            # messages have been removed, so _pre_mailbox_hook must
            # have been called already.
            self._pre_mailbox_hook(self._file)
        try:
            self._pre_message_hook(self._file)
            offsets = self._install_message(message)
            self._post_message_hook(self._file)
        except BaseException:
            self._file.truncate(before)
            raise
        self._file.flush()
        self._file_length = self._file.tell()  # Record current length of mailbox
        return offsets

class _mboxMMDF(_singlefileMailbox):
    """An mbox or MMDF mailbox."""

_mangle_from_ = True

def get_message(self, key):
        """Return a Message representation or raise a KeyError."""
        start, stop = self._lookup(key)
        self._file.seek(start)
        from_line = self._file.readline().replace(os.linesep, '')
        string = self._file.read(stop - self._file.tell())
        msg = self._message_factory(string.replace(os.linesep, '\n'))
        msg.set_from(from_line[5:])
        return msg

def get_string(self, key, from_=False):
        """Return a string representation or raise a KeyError."""
        start, stop = self._lookup(key)
        self._file.seek(start)
        if not from_:
            self._file.readline()
        string = self._file.read(stop - self._file.tell())
        return string.replace(os.linesep, '\n')

def get_file(self, key, from_=False):
        """Return a file-like representation or raise a KeyError."""
        start, stop = self._lookup(key)
        self._file.seek(start)
        if not from_:
            self._file.readline()
        return _PartialFile(self._file, self._file.tell(), stop)

def _install_message(self, message):
        """Format a message and blindly write to self._file."""
        from_line = None
        if isinstance(message, str) and message.startswith('From '):
            newline = message.find('\n')
            if newline != -1:
                from_line = message[:newline]
                message = message[newline + 1:]
            else:
                from_line = message
                message = ''
        elif isinstance(message, _mboxMMDFMessage):
            from_line = 'From ' + message.get_from()
        elif isinstance(message, email.message.Message):
            from_line = message.get_unixfrom()  # May be None.
        if from_line is None:
            from_line = 'From MAILER-DAEMON %s' % time.asctime(time.gmtime())
        start = self._file.tell()
        self._file.write(from_line + os.linesep)
        self._dump_message(message, self._file, self._mangle_from_)
        stop = self._file.tell()
        return (start, stop)

class mbox(_mboxMMDF):
    """A classic mbox mailbox."""

_mangle_from_ = True

# All messages must end in a newline character, and
    # _post_message_hooks outputs an empty line between messages.
    _append_newline = True

def __init__(self, path, factory=None, create=True):
        """Initialize an mbox mailbox."""
        self._message_factory = mboxMessage
        _mboxMMDF.__init__(self, path, factory, create)

def _post_message_hook(self, f):
        """Called after writing each message to file f."""
        f.write(os.linesep)

def _generate_toc(self):
        """Generate key-to-(start, stop) table of contents."""
        starts, stops = [], []
        last_was_empty = False
        self._file.seek(0)
        while True:
            line_pos = self._file.tell()
            line = self._file.readline()
            if line.startswith('From '):
                if len(stops) < len(starts):
                    if last_was_empty:
                        stops.append(line_pos - len(os.linesep))
                    else:
                        # The last line before the "From " line wasn't
                        # blank, but we consider it a start of a
                        # message anyway.
                        stops.append(line_pos)
                starts.append(line_pos)
                last_was_empty = False
            elif not line:
                if last_was_empty:
                    stops.append(line_pos - len(os.linesep))
                else:
                    stops.append(line_pos)
                break
            elif line == os.linesep:
                last_was_empty = True
            else:
                last_was_empty = False
        self._toc = dict(enumerate(zip(starts, stops)))
        self._next_key = len(self._toc)
        self._file_length = self._file.tell()

class MMDF(_mboxMMDF):
    """An MMDF mailbox."""

def __init__(self, path, factory=None, create=True):
        """Initialize an MMDF mailbox."""
        self._message_factory = MMDFMessage
        _mboxMMDF.__init__(self, path, factory, create)

def _pre_message_hook(self, f):
        """Called before writing each message to file f."""
        f.write('\001\001\001\001' + os.linesep)

def _post_message_hook(self, f):
        """Called after writing each message to file f."""
        f.write(os.linesep + '\001\001\001\001' + os.linesep)

def _generate_toc(self):
        """Generate key-to-(start, stop) table of contents."""
        starts, stops = [], []
        self._file.seek(0)
        next_pos = 0
        while True:
            line_pos = next_pos
            line = self._file.readline()
            next_pos = self._file.tell()
            if line.startswith('\001\001\001\001' + os.linesep):
                starts.append(next_pos)
                while True:
                    line_pos = next_pos
                    line = self._file.readline()
                    next_pos = self._file.tell()
                    if line == '\001\001\001\001' + os.linesep:
                        stops.append(line_pos - len(os.linesep))
                        break
                    elif line == '':
                        stops.append(line_pos)
                        break
            elif line == '':
                break
        self._toc = dict(enumerate(zip(starts, stops)))
        self._next_key = len(self._toc)
        self._file.seek(0, 2)
        self._file_length = self._file.tell()

class MH(Mailbox):
    """An MH mailbox."""

def __init__(self, path, factory=None, create=True):
        """Initialize an MH instance."""
        Mailbox.__init__(self, path, factory, create)
        if not os.path.exists(self._path):
            if create:
                os.mkdir(self._path, 0700)
                os.close(os.open(os.path.join(self._path, '.mh_sequences'),
                                 os.O_CREAT | os.O_EXCL | os.O_WRONLY, 0600))
            else:
                raise NoSuchMailboxError(self._path)
        self._locked = False

def add(self, message):
        """Add message and return assigned key."""
        keys = self.keys()
        if len(keys) == 0:
            new_key = 1
        else:
            new_key = max(keys) + 1
        new_path = os.path.join(self._path, str(new_key))
        f = _create_carefully(new_path)
        closed = False
        try:
            if self._locked:
                _lock_file(f)
            try:
                try:
                    self._dump_message(message, f)
                except BaseException:
                    # Unlock and close so it can be deleted on Windows
                    if self._locked:
                        _unlock_file(f)
                    _sync_close(f)
                    closed = True
                    os.remove(new_path)
                    raise
                if isinstance(message, MHMessage):
                    self._dump_sequences(message, new_key)
            finally:
                if self._locked:
                    _unlock_file(f)
        finally:
            if not closed:
                _sync_close(f)
        return new_key

def remove(self, key):
        """Remove the keyed message; raise KeyError if it doesn't exist."""
        path = os.path.join(self._path, str(key))
        try:
            f = open(path, 'rb+')
        except IOError, e:
            if e.errno == errno.ENOENT:
                raise KeyError('No message with key: %s' % key)
            else:
                raise
        else:
            f.close()
            os.remove(path)

def __setitem__(self, key, message):
        """Replace the keyed message; raise KeyError if it doesn't exist."""
        path = os.path.join(self._path, str(key))
        try:
            f = open(path, 'rb+')
        except IOError, e:
            if e.errno == errno.ENOENT:
                raise KeyError('No message with key: %s' % key)
            else:
                raise
        try:
            if self._locked:
                _lock_file(f)
            try:
                os.close(os.open(path, os.O_WRONLY | os.O_TRUNC))
                self._dump_message(message, f)
                if isinstance(message, MHMessage):
                    self._dump_sequences(message, key)
            finally:
                if self._locked:
                    _unlock_file(f)
        finally:
            _sync_close(f)

def get_message(self, key):
        """Return a Message representation or raise a KeyError."""
        try:
            if self._locked:
                f = open(os.path.join(self._path, str(key)), 'r+')
            else:
                f = open(os.path.join(self._path, str(key)), 'r')
        except IOError, e:
            if e.errno == errno.ENOENT:
                raise KeyError('No message with key: %s' % key)
            else:
                raise
        try:
            if self._locked:
                _lock_file(f)
            try:
                msg = MHMessage(f)
            finally:
                if self._locked:
                    _unlock_file(f)
        finally:
            f.close()
        for name, key_list in self.get_sequences().iteritems():
            if key in key_list:
                msg.add_sequence(name)
        return msg

def get_string(self, key):
        """Return a string representation or raise a KeyError."""
        try:
            if self._locked:
                f = open(os.path.join(self._path, str(key)), 'r+')
            else:
                f = open(os.path.join(self._path, str(key)), 'r')
        except IOError, e:
            if e.errno == errno.ENOENT:
                raise KeyError('No message with key: %s' % key)
            else:
                raise
        try:
            if self._locked:
                _lock_file(f)
            try:
                return f.read()
            finally:
                if self._locked:
                    _unlock_file(f)
        finally:
            f.close()

def get_file(self, key):
        """Return a file-like representation or raise a KeyError."""
        try:
            f = open(os.path.join(self._path, str(key)), 'rb')
        except IOError, e:
            if e.errno == errno.ENOENT:
                raise KeyError('No message with key: %s' % key)
            else:
                raise
        return _ProxyFile(f)

def iterkeys(self):
        """Return an iterator over keys."""
        return iter(sorted(int(entry) for entry in os.listdir(self._path)
                                      if entry.isdigit()))

def has_key(self, key):
        """Return True if the keyed message exists, False otherwise."""
        return os.path.exists(os.path.join(self._path, str(key)))

def __len__(self):
        """Return a count of messages in the mailbox."""
        return len(list(self.iterkeys()))

def lock(self):
        """Lock the mailbox."""
        if not self._locked:
            self._file = open(os.path.join(self._path, '.mh_sequences'), 'rb+')
            _lock_file(self._file)
            self._locked = True

def unlock(self):
        """Unlock the mailbox if it is locked."""
        if self._locked:
            _unlock_file(self._file)
            _sync_close(self._file)
            del self._file
            self._locked = False

def flush(self):
        """Write any pending changes to the disk."""
        return

def close(self):
        """Flush and close the mailbox."""
        if self._locked:
            self.unlock()

def list_folders(self):
        """Return a list of folder names."""
        result = []
        for entry in os.listdir(self._path):
            if os.path.isdir(os.path.join(self._path, entry)):
                result.append(entry)
        return result

def get_folder(self, folder):
        """Return an MH instance for the named folder."""
        return MH(os.path.join(self._path, folder),
                  factory=self._factory, create=False)

def add_folder(self, folder):
        """Create a folder and return an MH instance representing it."""
        return MH(os.path.join(self._path, folder),
                  factory=self._factory)

def remove_folder(self, folder):
        """Delete the named folder, which must be empty."""
        path = os.path.join(self._path, folder)
        entries = os.listdir(path)
        if entries == ['.mh_sequences']:
            os.remove(os.path.join(path, '.mh_sequences'))
        elif entries == []:
            pass
        else:
            raise NotEmptyError('Folder not empty: %s' % self._path)
        os.rmdir(path)

def get_sequences(self):
        """Return a name-to-key-list dictionary to define each sequence."""
        results = {}
        f = open(os.path.join(self._path, '.mh_sequences'), 'r')
        try:
            all_keys = set(self.keys())
            for line in f:
                try:
                    name, contents = line.split(':')
                    keys = set()
                    for spec in contents.split():
                        if spec.isdigit():
                            keys.add(int(spec))
                        else:
                            start, stop = (int(x) for x in spec.split('-'))
                            keys.update(range(start, stop + 1))
                    results[name] = [key for key in sorted(keys) \
                                         if key in all_keys]
                    if len(results[name]) == 0:
                        del results[name]
                except ValueError:
                    raise FormatError('Invalid sequence specification: %s' %
                                      line.rstrip())
        finally:
            f.close()
        return results

def set_sequences(self, sequences):
        """Set sequences using the given name-to-key-list dictionary."""
        f = open(os.path.join(self._path, '.mh_sequences'), 'r+')
        try:
            os.close(os.open(f.name, os.O_WRONLY | os.O_TRUNC))
            for name, keys in sequences.iteritems():
                if len(keys) == 0:
                    continue
                f.write('%s:' % name)
                prev = None
                completing = False
                for key in sorted(set(keys)):
                    if key - 1 == prev:
                        if not completing:
                            completing = True
                            f.write('-')
                    elif completing:
                        completing = False
                        f.write('%s %s' % (prev, key))
                    else:
                        f.write(' %s' % key)
                    prev = key
                if completing:
                    f.write(str(prev) + '\n')
                else:
                    f.write('\n')
        finally:
            _sync_close(f)

def pack(self):
        """Re-name messages to eliminate numbering gaps. Invalidates keys."""
        sequences = self.get_sequences()
        prev = 0
        changes = []
        for key in self.iterkeys():
            if key - 1 != prev:
                changes.append((key, prev + 1))
                if hasattr(os, 'link'):
                    os.link(os.path.join(self._path, str(key)),
                            os.path.join(self._path, str(prev + 1)))
                    os.unlink(os.path.join(self._path, str(key)))
                else:
                    os.rename(os.path.join(self._path, str(key)),
                              os.path.join(self._path, str(prev + 1)))
            prev += 1
        self._next_key = prev + 1
        if len(changes) == 0:
            return
        for name, key_list in sequences.items():
            for old, new in changes:
                if old in key_list:
                    key_list[key_list.index(old)] = new
        self.set_sequences(sequences)

def _dump_sequences(self, message, key):
        """Inspect a new MHMessage and update sequences appropriately."""
        pending_sequences = message.get_sequences()
        all_sequences = self.get_sequences()
        for name, key_list in all_sequences.iteritems():
            if name in pending_sequences:
                key_list.append(key)
            elif key in key_list:
                del key_list[key_list.index(key)]
        for sequence in pending_sequences:
            if sequence not in all_sequences:
                all_sequences[sequence] = [key]
        self.set_sequences(all_sequences)

class Babyl(_singlefileMailbox):
    """An Rmail-style Babyl mailbox."""

_special_labels = frozenset(('unseen', 'deleted', 'filed', 'answered',
                                 'forwarded', 'edited', 'resent'))

def __init__(self, path, factory=None, create=True):
        """Initialize a Babyl mailbox."""
        _singlefileMailbox.__init__(self, path, factory, create)
        self._labels = {}

def add(self, message):
        """Add message and return assigned key."""
        key = _singlefileMailbox.add(self, message)
        if isinstance(message, BabylMessage):
            self._labels[key] = message.get_labels()
        return key

def remove(self, key):
        """Remove the keyed message; raise KeyError if it doesn't exist."""
        _singlefileMailbox.remove(self, key)
        if key in self._labels:
            del self._labels[key]

def __setitem__(self, key, message):
        """Replace the keyed message; raise KeyError if it doesn't exist."""
        _singlefileMailbox.__setitem__(self, key, message)
        if isinstance(message, BabylMessage):
            self._labels[key] = message.get_labels()

def get_message(self, key):
        """Return a Message representation or raise a KeyError."""
        start, stop = self._lookup(key)
        self._file.seek(start)
        self._file.readline()   # Skip '1,' line specifying labels.
        original_headers = StringIO.StringIO()
        while True:
            line = self._file.readline()
            if line == '*** EOOH ***' + os.linesep or line == '':
                break
            original_headers.write(line.replace(os.linesep, '\n'))
        visible_headers = StringIO.StringIO()
        while True:
            line = self._file.readline()
            if line == os.linesep or line == '':
                break
            visible_headers.write(line.replace(os.linesep, '\n'))
        body = self._file.read(stop - self._file.tell()).replace(os.linesep,
                                                                 '\n')
        msg = BabylMessage(original_headers.getvalue() + body)
        msg.set_visible(visible_headers.getvalue())
        if key in self._labels:
            msg.set_labels(self._labels[key])
        return msg

def get_string(self, key):
        """Return a string representation or raise a KeyError."""
        start, stop = self._lookup(key)
        self._file.seek(start)
        self._file.readline()   # Skip '1,' line specifying labels.
        original_headers = StringIO.StringIO()
        while True:
            line = self._file.readline()
            if line == '*** EOOH ***' + os.linesep or line == '':
                break
            original_headers.write(line.replace(os.linesep, '\n'))
        while True:
            line = self._file.readline()
            if line == os.linesep or line == '':
                break
        return original_headers.getvalue() + \
               self._file.read(stop - self._file.tell()).replace(os.linesep,
                                                                 '\n')

def get_file(self, key):
        """Return a file-like representation or raise a KeyError."""
        return StringIO.StringIO(self.get_string(key).replace('\n',
                                                              os.linesep))

def get_labels(self):
        """Return a list of user-defined labels in the mailbox."""
        self._lookup()
        labels = set()
        for label_list in self._labels.values():
            labels.update(label_list)
        labels.difference_update(self._special_labels)
        return list(labels)

def _generate_toc(self):
        """Generate key-to-(start, stop) table of contents."""
        starts, stops = [], []
        self._file.seek(0)
        next_pos = 0
        label_lists = []
        while True:
            line_pos = next_pos
            line = self._file.readline()
            next_pos = self._file.tell()
            if line == '\037\014' + os.linesep:
                if len(stops) < len(starts):
                    stops.append(line_pos - len(os.linesep))
                starts.append(next_pos)
                labels = [label.strip() for label
                                        in self._file.readline()[1:].split(',')
                                        if label.strip() != '']
                label_lists.append(labels)
            elif line == '\037' or line == '\037' + os.linesep:
                if len(stops) < len(starts):
                    stops.append(line_pos - len(os.linesep))
            elif line == '':
                stops.append(line_pos - len(os.linesep))
                break
        self._toc = dict(enumerate(zip(starts, stops)))
        self._labels = dict(enumerate(label_lists))
        self._next_key = len(self._toc)
        self._file.seek(0, 2)
        self._file_length = self._file.tell()

def _pre_mailbox_hook(self, f):
        """Called before writing the mailbox to file f."""
        f.write('BABYL OPTIONS:%sVersion: 5%sLabels:%s%s\037' %
                (os.linesep, os.linesep, ','.join(self.get_labels()),
                 os.linesep))

def _pre_message_hook(self, f):
        """Called before writing each message to file f."""
        f.write('\014' + os.linesep)

def _post_message_hook(self, f):
        """Called after writing each message to file f."""
        f.write(os.linesep + '\037')

def _install_message(self, message):
        """Write message contents and return (start, stop)."""
        start = self._file.tell()
        if isinstance(message, BabylMessage):
            special_labels = []
            labels = []
            for label in message.get_labels():
                if label in self._special_labels:
                    special_labels.append(label)
                else:
                    labels.append(label)
            self._file.write('1')
            for label in special_labels:
                self._file.write(', ' + label)
            self._file.write(',,')
            for label in labels:
                self._file.write(' ' + label + ',')
            self._file.write(os.linesep)
        else:
            self._file.write('1,,' + os.linesep)
        if isinstance(message, email.message.Message):
            orig_buffer = StringIO.StringIO()
            orig_generator = email.generator.Generator(orig_buffer, False, 0)
            orig_generator.flatten(message)
            orig_buffer.seek(0)
            while True:
                line = orig_buffer.readline()
                self._file.write(line.replace('\n', os.linesep))
                if line == '\n' or line == '':
                    break
            self._file.write('*** EOOH ***' + os.linesep)
            if isinstance(message, BabylMessage):
                vis_buffer = StringIO.StringIO()
                vis_generator = email.generator.Generator(vis_buffer, False, 0)
                vis_generator.flatten(message.get_visible())
                while True:
                    line = vis_buffer.readline()
                    self._file.write(line.replace('\n', os.linesep))
                    if line == '\n' or line == '':
                        break
            else:
                orig_buffer.seek(0)
                while True:
                    line = orig_buffer.readline()
                    self._file.write(line.replace('\n', os.linesep))
                    if line == '\n' or line == '':
                        break
            while True:
                buffer = orig_buffer.read(4096) # Buffer size is arbitrary.
                if buffer == '':
                    break
                self._file.write(buffer.replace('\n', os.linesep))
        elif isinstance(message, str):
            body_start = message.find('\n\n') + 2
            if body_start - 2 != -1:
                self._file.write(message[:body_start].replace('\n',
                                                              os.linesep))
                self._file.write('*** EOOH ***' + os.linesep)
                self._file.write(message[:body_start].replace('\n',
                                                              os.linesep))
                self._file.write(message[body_start:].replace('\n',
                                                              os.linesep))
            else:
                self._file.write('*** EOOH ***' + os.linesep + os.linesep)
                self._file.write(message.replace('\n', os.linesep))
        elif hasattr(message, 'readline'):
            original_pos = message.tell()
            first_pass = True
            while True:
                line = message.readline()
                self._file.write(line.replace('\n', os.linesep))
                if line == '\n' or line == '':
                    if first_pass:
                        first_pass = False
                        self._file.write('*** EOOH ***' + os.linesep)
                        message.seek(original_pos)
                    else:
                        break
            while True:
                buffer = message.read(4096)     # Buffer size is arbitrary.
                if buffer == '':
                    break
                self._file.write(buffer.replace('\n', os.linesep))
        else:
            raise TypeError('Invalid message type: %s' % type(message))
        stop = self._file.tell()
        return (start, stop)

class Message(email.message.Message):
    """Message with mailbox-format-specific properties."""

def __init__(self, message=None):
        """Initialize a Message instance."""
        if isinstance(message, email.message.Message):
            self._become_message(copy.deepcopy(message))
            if isinstance(message, Message):
                message._explain_to(self)
        elif isinstance(message, str):
            self._become_message(email.message_from_string(message))
        elif hasattr(message, "read"):
            self._become_message(email.message_from_file(message))
        elif message is None:
            email.message.Message.__init__(self)
        else:
            raise TypeError('Invalid message type: %s' % type(message))

def _become_message(self, message):
        """Assume the non-format-specific state of message."""
        for name in ('_headers', '_unixfrom', '_payload', '_charset',
                     'preamble', 'epilogue', 'defects', '_default_type'):
            self.__dict__[name] = message.__dict__[name]

def _explain_to(self, message):
        """Copy format-specific state to message insofar as possible."""
        if isinstance(message, Message):
            return  # There's nothing format-specific to explain.
        else:
            raise TypeError('Cannot convert to specified type')

class MaildirMessage(Message):
    """Message with Maildir-specific properties."""

def __init__(self, message=None):
        """Initialize a MaildirMessage instance."""
        self._subdir = 'new'
        self._info = ''
        self._date = time.time()
        Message.__init__(self, message)

def get_subdir(self):
        """Return 'new' or 'cur'."""
        return self._subdir

def set_subdir(self, subdir):
        """Set subdir to 'new' or 'cur'."""
        if subdir == 'new' or subdir == 'cur':
            self._subdir = subdir
        else:
            raise ValueError("subdir must be 'new' or 'cur': %s" % subdir)

def get_flags(self):
        """Return as a string the flags that are set."""
        if self._info.startswith('2,'):
            return self._info[2:]
        else:
            return ''

def set_flags(self, flags):
        """Set the given flags and unset all others."""
        self._info = '2,' + ''.join(sorted(flags))

def add_flag(self, flag):
        """Set the given flag(s) without changing others."""
        self.set_flags(''.join(set(self.get_flags()) | set(flag)))

def remove_flag(self, flag):
        """Unset the given string flag(s) without changing others."""
        if self.get_flags() != '':
            self.set_flags(''.join(set(self.get_flags()) - set(flag)))

def get_date(self):
        """Return delivery date of message, in seconds since the epoch."""
        return self._date

def set_date(self, date):
        """Set delivery date of message, in seconds since the epoch."""
        try:
            self._date = float(date)
        except ValueError:
            raise TypeError("can't convert to float: %s" % date)

def get_info(self):
        """Get the message's "info" as a string."""
        return self._info

def set_info(self, info):
        """Set the message's "info" string."""
        if isinstance(info, str):
            self._info = info
        else:
            raise TypeError('info must be a string: %s' % type(info))

def _explain_to(self, message):
        """Copy Maildir-specific state to message insofar as possible."""
        if isinstance(message, MaildirMessage):
            message.set_flags(self.get_flags())
            message.set_subdir(self.get_subdir())
            message.set_date(self.get_date())
        elif isinstance(message, _mboxMMDFMessage):
            flags = set(self.get_flags())
            if 'S' in flags:
                message.add_flag('R')
            if self.get_subdir() == 'cur':
                message.add_flag('O')
            if 'T' in flags:
                message.add_flag('D')
            if 'F' in flags:
                message.add_flag('F')
            if 'R' in flags:
                message.add_flag('A')
            message.set_from('MAILER-DAEMON', time.gmtime(self.get_date()))
        elif isinstance(message, MHMessage):
            flags = set(self.get_flags())
            if 'S' not in flags:
                message.add_sequence('unseen')
            if 'R' in flags:
                message.add_sequence('replied')
            if 'F' in flags:
                message.add_sequence('flagged')
        elif isinstance(message, BabylMessage):
            flags = set(self.get_flags())
            if 'S' not in flags:
                message.add_label('unseen')
            if 'T' in flags:
                message.add_label('deleted')
            if 'R' in flags:
                message.add_label('answered')
            if 'P' in flags:
                message.add_label('forwarded')
        elif isinstance(message, Message):
            pass
        else:
            raise TypeError('Cannot convert to specified type: %s' %
                            type(message))

class _mboxMMDFMessage(Message):
    """Message with mbox- or MMDF-specific properties."""

def __init__(self, message=None):
        """Initialize an mboxMMDFMessage instance."""
        self.set_from('MAILER-DAEMON', True)
        if isinstance(message, email.message.Message):
            unixfrom = message.get_unixfrom()
            if unixfrom is not None and unixfrom.startswith('From '):
                self.set_from(unixfrom[5:])
        Message.__init__(self, message)

def get_from(self):
        """Return contents of "From " line."""
        return self._from

def set_from(self, from_, time_=None):
        """Set "From " line, formatting and appending time_ if specified."""
        if time_ is not None:
            if time_ is True:
                time_ = time.gmtime()
            from_ += ' ' + time.asctime(time_)
        self._from = from_

def get_flags(self):
        """Return as a string the flags that are set."""
        return self.get('Status', '') + self.get('X-Status', '')

def set_flags(self, flags):
        """Set the given flags and unset all others."""
        flags = set(flags)
        status_flags, xstatus_flags = '', ''
        for flag in ('R', 'O'):
            if flag in flags:
                status_flags += flag
                flags.remove(flag)
        for flag in ('D', 'F', 'A'):
            if flag in flags:
                xstatus_flags += flag
                flags.remove(flag)
        xstatus_flags += ''.join(sorted(flags))
        try:
            self.replace_header('Status', status_flags)
        except KeyError:
            self.add_header('Status', status_flags)
        try:
            self.replace_header('X-Status', xstatus_flags)
        except KeyError:
            self.add_header('X-Status', xstatus_flags)

def add_flag(self, flag):
        """Set the given flag(s) without changing others."""
        self.set_flags(''.join(set(self.get_flags()) | set(flag)))

def remove_flag(self, flag):
        """Unset the given string flag(s) without changing others."""
        if 'Status' in self or 'X-Status' in self:
            self.set_flags(''.join(set(self.get_flags()) - set(flag)))

def _explain_to(self, message):
        """Copy mbox- or MMDF-specific state to message insofar as possible."""
        if isinstance(message, MaildirMessage):
            flags = set(self.get_flags())
            if 'O' in flags:
                message.set_subdir('cur')
            if 'F' in flags:
                message.add_flag('F')
            if 'A' in flags:
                message.add_flag('R')
            if 'R' in flags:
                message.add_flag('S')
            if 'D' in flags:
                message.add_flag('T')
            del message['status']
            del message['x-status']
            maybe_date = ' '.join(self.get_from().split()[-5:])
            try:
                message.set_date(calendar.timegm(time.strptime(maybe_date,
                                                      '%a %b %d %H:%M:%S %Y')))
            except (ValueError, OverflowError):
                pass
        elif isinstance(message, _mboxMMDFMessage):
            message.set_flags(self.get_flags())
            message.set_from(self.get_from())
        elif isinstance(message, MHMessage):
            flags = set(self.get_flags())
            if 'R' not in flags:
                message.add_sequence('unseen')
            if 'A' in flags:
                message.add_sequence('replied')
            if 'F' in flags:
                message.add_sequence('flagged')
            del message['status']
            del message['x-status']
        elif isinstance(message, BabylMessage):
            flags = set(self.get_flags())
            if 'R' not in flags:
                message.add_label('unseen')
            if 'D' in flags:
                message.add_label('deleted')
            if 'A' in flags:
                message.add_label('answered')
            del message['status']
            del message['x-status']
        elif isinstance(message, Message):
            pass
        else:
            raise TypeError('Cannot convert to specified type: %s' %
                            type(message))

class mboxMessage(_mboxMMDFMessage):
    """Message with mbox-specific properties."""

class MHMessage(Message):
    """Message with MH-specific properties."""

def __init__(self, message=None):
        """Initialize an MHMessage instance."""
        self._sequences = []
        Message.__init__(self, message)

def get_sequences(self):
        """Return a list of sequences that include the message."""
        return self._sequences[:]

def set_sequences(self, sequences):
        """Set the list of sequences that include the message."""
        self._sequences = list(sequences)

def add_sequence(self, sequence):
        """Add sequence to list of sequences including the message."""
        if isinstance(sequence, str):
            if not sequence in self._sequences:
                self._sequences.append(sequence)
        else:
            raise TypeError('sequence must be a string: %s' % type(sequence))

def remove_sequence(self, sequence):
        """Remove sequence from the list of sequences including the message."""
        try:
            self._sequences.remove(sequence)
        except ValueError:
            pass

def _explain_to(self, message):
        """Copy MH-specific state to message insofar as possible."""
        if isinstance(message, MaildirMessage):
            sequences = set(self.get_sequences())
            if 'unseen' in sequences:
                message.set_subdir('cur')
            else:
                message.set_subdir('cur')
                message.add_flag('S')
            if 'flagged' in sequences:
                message.add_flag('F')
            if 'replied' in sequences:
                message.add_flag('R')
        elif isinstance(message, _mboxMMDFMessage):
            sequences = set(self.get_sequences())
            if 'unseen' not in sequences:
                message.add_flag('RO')
            else:
                message.add_flag('O')
            if 'flagged' in sequences:
                message.add_flag('F')
            if 'replied' in sequences:
                message.add_flag('A')
        elif isinstance(message, MHMessage):
            for sequence in self.get_sequences():
                message.add_sequence(sequence)
        elif isinstance(message, BabylMessage):
            sequences = set(self.get_sequences())
            if 'unseen' in sequences:
                message.add_label('unseen')
            if 'replied' in sequences:
                message.add_label('answered')
        elif isinstance(message, Message):
            pass
        else:
            raise TypeError('Cannot convert to specified type: %s' %
                            type(message))

class BabylMessage(Message):
    """Message with Babyl-specific properties."""

def __init__(self, message=None):
        """Initialize a BabylMessage instance."""
        self._labels = []
        self._visible = Message()
        Message.__init__(self, message)

def get_labels(self):
        """Return a list of labels on the message."""
        return self._labels[:]

def set_labels(self, labels):
        """Set the list of labels on the message."""
        self._labels = list(labels)

def add_label(self, label):
        """Add label to list of labels on the message."""
        if isinstance(label, str):
            if label not in self._labels:
                self._labels.append(label)
        else:
            raise TypeError('label must be a string: %s' % type(label))

def remove_label(self, label):
        """Remove label from the list of labels on the message."""
        try:
            self._labels.remove(label)
        except ValueError:
            pass

def get_visible(self):
        """Return a Message representation of visible headers."""
        return Message(self._visible)

def set_visible(self, visible):
        """Set the Message representation of visible headers."""
        self._visible = Message(visible)

def update_visible(self):
        """Update and/or sensibly generate a set of visible headers."""
        for header in self._visible.keys():
            if header in self:
                self._visible.replace_header(header, self[header])
            else:
                del self._visible[header]
        for header in ('Date', 'From', 'Reply-To', 'To', 'CC', 'Subject'):
            if header in self and header not in self._visible:
                self._visible[header] = self[header]

def _explain_to(self, message):
        """Copy Babyl-specific state to message insofar as possible."""
        if isinstance(message, MaildirMessage):
            labels = set(self.get_labels())
            if 'unseen' in labels:
                message.set_subdir('cur')
            else:
                message.set_subdir('cur')
                message.add_flag('S')
            if 'forwarded' in labels or 'resent' in labels:
                message.add_flag('P')
            if 'answered' in labels:
                message.add_flag('R')
            if 'deleted' in labels:
                message.add_flag('T')
        elif isinstance(message, _mboxMMDFMessage):
            labels = set(self.get_labels())
            if 'unseen' not in labels:
                message.add_flag('RO')
            else:
                message.add_flag('O')
            if 'deleted' in labels:
                message.add_flag('D')
            if 'answered' in labels:
                message.add_flag('A')
        elif isinstance(message, MHMessage):
            labels = set(self.get_labels())
            if 'unseen' in labels:
                message.add_sequence('unseen')
            if 'answered' in labels:
                message.add_sequence('replied')
        elif isinstance(message, BabylMessage):
            message.set_visible(self.get_visible())
            for label in self.get_labels():
                message.add_label(label)
        elif isinstance(message, Message):
            pass
        else:
            raise TypeError('Cannot convert to specified type: %s' %
                            type(message))

class MMDFMessage(_mboxMMDFMessage):
    """Message with MMDF-specific properties."""

class _ProxyFile:
    """A read-only wrapper of a file."""

def __init__(self, f, pos=None):
        """Initialize a _ProxyFile."""
        self._file = f
        if pos is None:
            self._pos = f.tell()
        else:
            self._pos = pos

def read(self, size=None):
        """Read bytes."""
        return self._read(size, self._file.read)

def readline(self, size=None):
        """Read a line."""
        return self._read(size, self._file.readline)

def readlines(self, sizehint=None):
        """Read multiple lines."""
        result = []
        for line in self:
            result.append(line)
            if sizehint is not None:
                sizehint -= len(line)
                if sizehint <= 0:
                    break
        return result

def __iter__(self):
        """Iterate over lines."""
        return iter(self.readline, "")

def tell(self):
        """Return the position."""
        return self._pos

def seek(self, offset, whence=0):
        """Change position."""
        if whence == 1:
            self._file.seek(self._pos)
        self._file.seek(offset, whence)
        self._pos = self._file.tell()

def close(self):
        """Close the file."""
        if hasattr(self, '_file'):
            if hasattr(self._file, 'close'):
                self._file.close()
            del self._file

def _read(self, size, read_method):
        """Read size bytes using read_method."""
        if size is None:
            size = -1
        self._file.seek(self._pos)
        result = read_method(size)
        self._pos = self._file.tell()
        return result

class _PartialFile(_ProxyFile):
    """A read-only wrapper of part of a file."""

def __init__(self, f, start=None, stop=None):
        """Initialize a _PartialFile."""
        _ProxyFile.__init__(self, f, start)
        self._start = start
        self._stop = stop

def tell(self):
        """Return the position with respect to start."""
        return _ProxyFile.tell(self) - self._start

def seek(self, offset, whence=0):
        """Change position, possibly with respect to start or stop."""
        if whence == 0:
            self._pos = self._start
            whence = 1
        elif whence == 2:
            self._pos = self._stop
            whence = 1
        _ProxyFile.seek(self, offset, whence)

def _read(self, size, read_method):
        """Read size bytes using read_method, honoring start and stop."""
        remaining = self._stop - self._pos
        if remaining <= 0:
            return ''
        if size is None or size < 0 or size > remaining:
            size = remaining
        return _ProxyFile._read(self, size, read_method)

def close(self):
        # do *not* close the underlying file object for partial files,
        # since it's global to the mailbox object
        if hasattr(self, '_file'):
            del self._file

def _lock_file(f, dotlock=True):
    """Lock file f using lockf and dot locking."""
    dotlock_done = False
    try:
        if fcntl:
            try:
                fcntl.lockf(f, fcntl.LOCK_EX | fcntl.LOCK_NB)
            except IOError, e:
                if e.errno in (errno.EAGAIN, errno.EACCES, errno.EROFS):
                    raise ExternalClashError('lockf: lock unavailable: %s' %
                                             f.name)
                else:
                    raise
        if dotlock:
            try:
                pre_lock = _create_temporary(f.name + '.lock')
                pre_lock.close()
            except IOError, e:
                if e.errno in (errno.EACCES, errno.EROFS):
                    return  # Without write access, just skip dotlocking.
                else:
                    raise
            try:
                if hasattr(os, 'link'):
                    os.link(pre_lock.name, f.name + '.lock')
                    dotlock_done = True
                    os.unlink(pre_lock.name)
                else:
                    os.rename(pre_lock.name, f.name + '.lock')
                    dotlock_done = True
            except OSError, e:
                if e.errno == errno.EEXIST or \
                  (os.name == 'os2' and e.errno == errno.EACCES):
                    os.remove(pre_lock.name)
                    raise ExternalClashError('dot lock unavailable: %s' %
                                             f.name)
                else:
                    raise
    except:
        if fcntl:
            fcntl.lockf(f, fcntl.LOCK_UN)
        if dotlock_done:
            os.remove(f.name + '.lock')
        raise

def _unlock_file(f):
    """Unlock file f using lockf and dot locking."""
    if fcntl:
        fcntl.lockf(f, fcntl.LOCK_UN)
    if os.path.exists(f.name + '.lock'):
        os.remove(f.name + '.lock')

def _create_carefully(path):
    """Create a file if it doesn't exist and open for reading and writing."""
    fd = os.open(path, os.O_CREAT | os.O_EXCL | os.O_RDWR, 0666)
    try:
        return open(path, 'rb+')
    finally:
        os.close(fd)

def _create_temporary(path):
    """Create a temp file based on path and open for reading and writing."""
    return _create_carefully('%s.%s.%s.%s' % (path, int(time.time()),
                                              socket.gethostname(),
                                              os.getpid()))

def _sync_flush(f):
    """Ensure changes to file f are physically on disk."""
    f.flush()
    if hasattr(os, 'fsync'):
        os.fsync(f.fileno())

def _sync_close(f):
    """Close file f, ensuring all changes are physically on disk."""
    _sync_flush(f)
    f.close()

## Start: classes from the original module (for backward compatibility).

# Note that the Maildir class, whose name is unchanged, itself offers a next()
# method for backward compatibility.

class _Mailbox:

def __init__(self, fp, factory=rfc822.Message):
        self.fp = fp
        self.seekp = 0
        self.factory = factory

def __iter__(self):
        return iter(self.next, None)

def next(self):
        while 1:
            self.fp.seek(self.seekp)
            try:
                self._search_start()
            except EOFError:
                self.seekp = self.fp.tell()
                return None
            start = self.fp.tell()
            self._search_end()
            self.seekp = stop = self.fp.tell()
            if start != stop:
                break
        return self.factory(_PartialFile(self.fp, start, stop))

# Recommended to use PortableUnixMailbox instead!
class UnixMailbox(_Mailbox):

def _search_start(self):
        while 1:
            pos = self.fp.tell()
            line = self.fp.readline()
            if not line:
                raise EOFError
            if line[:5] == 'From ' and self._isrealfromline(line):
                self.fp.seek(pos)
                return

def _search_end(self):
        self.fp.readline()      # Throw away header line
        while 1:
            pos = self.fp.tell()
            line = self.fp.readline()
            if not line:
                return
            if line[:5] == 'From ' and self._isrealfromline(line):
                self.fp.seek(pos)
                return

# An overridable mechanism to test for From-line-ness.  You can either
    # specify a different regular expression or define a whole new
    # _isrealfromline() method.  Note that this only gets called for lines
    # starting with the 5 characters "From ".
    #
    # BAW: According to
    #http://home.netscape.com/eng/mozilla/2.0/relnotes/demo/content-length.html
    # the only portable, reliable way to find message delimiters in a BSD (i.e
    # Unix mailbox) style folder is to search for "\n\nFrom .*\n", or at the
    # beginning of the file, "^From .*\n".  While _fromlinepattern below seems
    # like a good idea, in practice, there are too many variations for more
    # strict parsing of the line to be completely accurate.
    #
    # _strict_isrealfromline() is the old version which tries to do stricter
    # parsing of the From_ line.  _portable_isrealfromline() simply returns
    # true, since it's never called if the line doesn't already start with
    # "From ".
    #
    # This algorithm, and the way it interacts with _search_start() and
    # _search_end() may not be completely correct, because it doesn't check
    # that the two characters preceding "From " are \n\n or the beginning of
    # the file.  Fixing this would require a more extensive rewrite than is
    # necessary.  For convenience, we've added a PortableUnixMailbox class
    # which does no checking of the format of the 'From' line.

_fromlinepattern = (r"From \s*[^\s]+\s+\w\w\w\s+\w\w\w\s+\d?\d\s+"
                        r"\d?\d:\d\d(:\d\d)?(\s+[^\s]+)?\s+\d\d\d\d\s*"
                        r"[^\s]*\s*"
                        "$")
    _regexp = None

def _strict_isrealfromline(self, line):
        if not self._regexp:
            import re
            self._regexp = re.compile(self._fromlinepattern)
        return self._regexp.match(line)

def _portable_isrealfromline(self, line):
        return True

_isrealfromline = _strict_isrealfromline

class PortableUnixMailbox(UnixMailbox):
    _isrealfromline = UnixMailbox._portable_isrealfromline

class MmdfMailbox(_Mailbox):

def _search_start(self):
        while 1:
            line = self.fp.readline()
            if not line:
                raise EOFError
            if line[:5] == '\001\001\001\001\n':
                return

def _search_end(self):
        while 1:
            pos = self.fp.tell()
            line = self.fp.readline()
            if not line:
                return
            if line == '\001\001\001\001\n':
                self.fp.seek(pos)
                return

class MHMailbox:

def __init__(self, dirname, factory=rfc822.Message):
        import re
        pat = re.compile('^[1-9][0-9]*$')
        self.dirname = dirname
        # the three following lines could be combined into:
        # list = map(long, filter(pat.match, os.listdir(self.dirname)))
        list = os.listdir(self.dirname)
        list = filter(pat.match, list)
        list = map(long, list)
        list.sort()
        # This only works in Python 1.6 or later;
        # before that str() added 'L':
        self.boxes = map(str, list)
        self.boxes.reverse()
        self.factory = factory

def __iter__(self):
        return iter(self.next, None)

def next(self):
        if not self.boxes:
            return None
        fn = self.boxes.pop()
        fp = open(os.path.join(self.dirname, fn))
        msg = self.factory(fp)
        try:
            msg._mh_msgno = fn
        except (AttributeError, TypeError):
            pass
        return msg

class BabylMailbox(_Mailbox):

def _search_start(self):
        while 1:
            line = self.fp.readline()
            if not line:
                raise EOFError
            if line == '*** EOOH ***\n':
                return

def _search_end(self):
        while 1:
            pos = self.fp.tell()
            line = self.fp.readline()
            if not line:
                return
            if line == '\037\014\n' or line == '\037':
                self.fp.seek(pos)
                return

## End: classes from the original module (for backward compatibility).

class Error(Exception):
    """Raised for module-specific errors."""

class NoSuchMailboxError(Error):
    """The specified mailbox does not exist and won't be created."""

class NotEmptyError(Error):
    """The specified mailbox is not empty and deletion was requested."""

class ExternalClashError(Error):
    """Another process caused an action to fail."""

class FormatError(Error):
    """A file appears to have an invalid format."""

cmd: