FM / python2.7

/usr/lib64/python2.7

Name	Size	Mode	Actions
bsddb/	-	0755	rm
compiler/	-	0755	rm
config/	-	0755	rm
ctypes/	-	0755	rm
curses/	-	0755	rm
Demo/	-	0755	rm
distutils/	-	0755	rm
Doc/	-	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
lib-tk/	-	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
Tools/	-	0755	rm
unittest/	-	0755	rm
wsgiref/	-	0755	rm
xml/	-	0755	rm
abc.py	7145	0644	edit dl rm
abc.pyc	6143	0644	edit dl rm
abc.pyo	6087	0644	edit dl rm
aifc.py	34579	0644	edit dl rm
aifc.pyc	30459	0644	edit dl rm
aifc.pyo	30459	0644	edit dl rm
antigravity.py	60	0644	edit dl rm
antigravity.pyc	203	0644	edit dl rm
antigravity.pyo	203	0644	edit dl rm
anydbm.py	2663	0644	edit dl rm
anydbm.pyc	2800	0644	edit dl rm
anydbm.pyo	2800	0644	edit dl rm
argparse.py	89228	0644	edit dl rm
argparse.pyc	64367	0644	edit dl rm
argparse.pyo	64202	0644	edit dl rm
ast.py	11805	0644	edit dl rm
ast.pyc	12938	0644	edit dl rm
ast.pyo	12938	0644	edit dl rm
asynchat.py	11581	0644	edit dl rm
asynchat.pyc	8810	0644	edit dl rm
asynchat.pyo	8810	0644	edit dl rm
asyncore.py	20943	0644	edit dl rm
asyncore.pyc	18893	0644	edit dl rm
asyncore.pyo	18893	0644	edit dl rm
atexit.py	1705	0644	edit dl rm
atexit.pyc	2203	0644	edit dl rm
atexit.pyo	2203	0644	edit dl rm
audiodev.py	7597	0644	edit dl rm
audiodev.pyc	8469	0644	edit dl rm
audiodev.pyo	8469	0644	edit dl rm
base64.py	11806	0755	edit dl rm
base64.pyc	11297	0644	edit dl rm
base64.pyo	11297	0644	edit dl rm
BaseHTTPServer.py	22747	0644	edit dl rm
BaseHTTPServer.pyc	21722	0644	edit dl rm
BaseHTTPServer.pyo	21722	0644	edit dl rm
Bastion.py	5744	0644	edit dl rm
Bastion.pyc	6660	0644	edit dl rm
Bastion.pyo	6660	0644	edit dl rm
bdb.py	21714	0644	edit dl rm
bdb.pyc	19101	0644	edit dl rm
bdb.pyo	19101	0644	edit dl rm
binhex.py	14698	0644	edit dl rm
binhex.pyc	15460	0644	edit dl rm
binhex.pyo	15460	0644	edit dl rm
bisect.py	2595	0644	edit dl rm
bisect.pyc	3071	0644	edit dl rm
bisect.pyo	3071	0644	edit dl rm
calendar.py	23384	0644	edit dl rm
calendar.pyc	27913	0644	edit dl rm
calendar.pyo	27913	0644	edit dl rm
cgi.py	36308	0755	edit dl rm
cgi.pyc	33366	0644	edit dl rm
cgi.pyo	33366	0644	edit dl rm
CGIHTTPServer.py	13089	0644	edit dl rm
CGIHTTPServer.pyc	11018	0644	edit dl rm
CGIHTTPServer.pyo	11018	0644	edit dl rm
cgitb.py	12175	0644	edit dl rm
cgitb.pyc	12138	0644	edit dl rm
cgitb.pyo	12138	0644	edit dl rm
chunk.py	5419	0644	edit dl rm
chunk.pyc	5602	0644	edit dl rm
chunk.pyo	5602	0644	edit dl rm
cmd.py	15026	0644	edit dl rm
cmd.pyc	14039	0644	edit dl rm
cmd.pyo	14039	0644	edit dl rm
code.py	10189	0644	edit dl rm
code.pyc	10334	0644	edit dl rm
code.pyo	10334	0644	edit dl rm
codecs.py	36143	0644	edit dl rm
codecs.pyc	36824	0644	edit dl rm
codecs.pyo	36824	0644	edit dl rm
codeop.py	5999	0644	edit dl rm
codeop.pyc	6597	0644	edit dl rm
codeop.pyo	6597	0644	edit dl rm
collections.py	27798	0644	edit dl rm
collections.pyc	26163	0644	edit dl rm
collections.pyo	26112	0644	edit dl rm
colorsys.py	3691	0644	edit dl rm
colorsys.pyc	3991	0644	edit dl rm
colorsys.pyo	3991	0644	edit dl rm
commands.py	2545	0644	edit dl rm
commands.pyc	2469	0644	edit dl rm
commands.pyo	2469	0644	edit dl rm
compileall.py	7763	0644	edit dl rm
compileall.pyc	7017	0644	edit dl rm
compileall.pyo	7017	0644	edit dl rm
ConfigParser.py	27746	0644	edit dl rm
ConfigParser.pyc	25213	0644	edit dl rm
ConfigParser.pyo	25213	0644	edit dl rm
contextlib.py	4424	0644	edit dl rm
contextlib.pyc	4454	0644	edit dl rm
contextlib.pyo	4454	0644	edit dl rm
Cookie.py	26538	0644	edit dl rm
Cookie.pyc	22658	0644	edit dl rm
Cookie.pyo	22658	0644	edit dl rm
cookielib.py	65486	0644	edit dl rm
cookielib.pyc	54725	0644	edit dl rm
cookielib.pyo	54537	0644	edit dl rm
copy.py	11533	0644	edit dl rm
copy.pyc	12170	0644	edit dl rm
copy.pyo	12078	0644	edit dl rm
copy_reg.py	6974	0644	edit dl rm
copy_reg.pyc	5167	0644	edit dl rm
copy_reg.pyo	5123	0644	edit dl rm
cProfile.py	6573	0755	edit dl rm
cProfile.pyc	6395	0644	edit dl rm
cProfile.pyo	6395	0644	edit dl rm
crypt.py	2292	0644	edit dl rm
crypt.pyc	2960	0644	edit dl rm
crypt.pyo	2960	0644	edit dl rm
csv.py	16708	0644	edit dl rm
csv.pyc	13507	0644	edit dl rm
csv.pyo	13507	0644	edit dl rm
dbhash.py	498	0644	edit dl rm
dbhash.pyc	718	0644	edit dl rm
dbhash.pyo	718	0644	edit dl rm
decimal.py	221933	0644	edit dl rm
decimal.pyc	172155	0644	edit dl rm
decimal.pyo	172155	0644	edit dl rm
difflib.py	82325	0644	edit dl rm
difflib.pyc	61898	0644	edit dl rm
difflib.pyo	61847	0644	edit dl rm
dircache.py	1126	0644	edit dl rm
dircache.pyc	1576	0644	edit dl rm
dircache.pyo	1576	0644	edit dl rm
dis.py	6499	0644	edit dl rm
dis.pyc	6228	0644	edit dl rm
dis.pyo	6228	0644	edit dl rm
doctest.py	105095	0644	edit dl rm
doctest.pyc	83637	0644	edit dl rm
doctest.pyo	83350	0644	edit dl rm
DocXMLRPCServer.py	10768	0644	edit dl rm
DocXMLRPCServer.pyc	10195	0644	edit dl rm
DocXMLRPCServer.pyo	10086	0644	edit dl rm
dumbdbm.py	9141	0644	edit dl rm
dumbdbm.pyc	6746	0644	edit dl rm
dumbdbm.pyo	6746	0644	edit dl rm
dummy_thread.py	4418	0644	edit dl rm
dummy_thread.pyc	5394	0644	edit dl rm
dummy_thread.pyo	5394	0644	edit dl rm
dummy_threading.py	2804	0644	edit dl rm
dummy_threading.pyc	1285	0644	edit dl rm
dummy_threading.pyo	1285	0644	edit dl rm
filecmp.py	9588	0644	edit dl rm
filecmp.pyc	9622	0644	edit dl rm
filecmp.pyo	9622	0644	edit dl rm
fileinput.py	13746	0644	edit dl rm
fileinput.pyc	14500	0644	edit dl rm
fileinput.pyo	14500	0644	edit dl rm
fnmatch.py	3315	0644	edit dl rm
fnmatch.pyc	3614	0644	edit dl rm
fnmatch.pyo	3614	0644	edit dl rm
formatter.py	14911	0644	edit dl rm
formatter.pyc	19178	0644	edit dl rm
formatter.pyo	19178	0644	edit dl rm
fpformat.py	4732	0644	edit dl rm
fpformat.pyc	4703	0644	edit dl rm
fpformat.pyo	4703	0644	edit dl rm
fractions.py	22390	0644	edit dl rm
fractions.pyc	19711	0644	edit dl rm
fractions.pyo	19711	0644	edit dl rm
ftplib.py	38555	0644	edit dl rm
ftplib.pyc	34939	0644	edit dl rm
ftplib.pyo	34939	0644	edit dl rm
functools.py	4806	0644	edit dl rm
functools.pyc	6629	0644	edit dl rm
functools.pyo	6629	0644	edit dl rm
genericpath.py	3201	0644	edit dl rm
genericpath.pyc	3517	0644	edit dl rm
genericpath.pyo	3517	0644	edit dl rm
getopt.py	7319	0644	edit dl rm
getopt.pyc	6654	0644	edit dl rm
getopt.pyo	6609	0644	edit dl rm
getpass.py	5563	0644	edit dl rm
getpass.pyc	4744	0644	edit dl rm
getpass.pyo	4744	0644	edit dl rm
gettext.py	22666	0644	edit dl rm
gettext.pyc	18004	0644	edit dl rm
gettext.pyo	18004	0644	edit dl rm
glob.py	3114	0644	edit dl rm
glob.pyc	2943	0644	edit dl rm
glob.pyo	2943	0644	edit dl rm
gzip.py	19028	0644	edit dl rm
gzip.pyc	15236	0644	edit dl rm
gzip.pyo	15236	0644	edit dl rm
hashlib.py	7841	0644	edit dl rm
hashlib.pyc	6919	0644	edit dl rm
hashlib.pyo	6919	0644	edit dl rm
heapq.py	18295	0644	edit dl rm
heapq.pyc	14564	0644	edit dl rm
heapq.pyo	14564	0644	edit dl rm
hmac.py	4588	0644	edit dl rm
hmac.pyc	4542	0644	edit dl rm
hmac.pyo	4542	0644	edit dl rm
htmlentitydefs.py	18056	0644	edit dl rm
htmlentitydefs.pyc	6367	0644	edit dl rm
htmlentitydefs.pyo	6367	0644	edit dl rm
htmllib.py	12869	0644	edit dl rm
htmllib.pyc	20309	0644	edit dl rm
htmllib.pyo	20309	0644	edit dl rm
HTMLParser.py	17171	0644	edit dl rm
HTMLParser.pyc	13727	0644	edit dl rm
HTMLParser.pyo	13422	0644	edit dl rm
httplib.py	53306	0644	edit dl rm
httplib.pyc	38724	0644	edit dl rm
httplib.pyo	38540	0644	edit dl rm
ihooks.py	18986	0644	edit dl rm
ihooks.pyc	21372	0644	edit dl rm
ihooks.pyo	21372	0644	edit dl rm
imaplib.py	48366	0644	edit dl rm
imaplib.pyc	45011	0644	edit dl rm
imaplib.pyo	42310	0644	edit dl rm
imghdr.py	3541	0644	edit dl rm
imghdr.pyc	4838	0644	edit dl rm
imghdr.pyo	4838	0644	edit dl rm
imputil.py	25764	0644	edit dl rm
imputil.pyc	15623	0644	edit dl rm
imputil.pyo	15445	0644	edit dl rm
inspect.py	43008	0644	edit dl rm
inspect.pyc	40229	0644	edit dl rm
inspect.pyo	40229	0644	edit dl rm
io.py	3322	0644	edit dl rm
io.pyc	3589	0644	edit dl rm
io.pyo	3589	0644	edit dl rm
keyword.py	1995	0755	edit dl rm
keyword.pyc	2105	0644	edit dl rm
keyword.pyo	2105	0644	edit dl rm
linecache.py	4027	0644	edit dl rm
linecache.pyc	3272	0644	edit dl rm
linecache.pyo	3272	0644	edit dl rm
locale.py	102834	0644	edit dl rm
locale.pyc	56610	0644	edit dl rm
locale.pyo	56610	0644	edit dl rm
macpath.py	6289	0644	edit dl rm
macpath.pyc	7681	0644	edit dl rm
macpath.pyo	7681	0644	edit dl rm
macurl2path.py	2731	0644	edit dl rm
macurl2path.pyc	2244	0644	edit dl rm
macurl2path.pyo	2244	0644	edit dl rm
mailbox.py	81240	0644	edit dl rm
mailbox.pyc	76717	0644	edit dl rm
mailbox.pyo	76670	0644	edit dl rm
mailcap.py	8404	0644	edit dl rm
mailcap.pyc	7955	0644	edit dl rm
mailcap.pyo	7955	0644	edit dl rm
markupbase.py	14643	0644	edit dl rm
markupbase.pyc	9267	0644	edit dl rm
markupbase.pyo	9071	0644	edit dl rm
md5.py	358	0644	edit dl rm
md5.pyc	378	0644	edit dl rm
md5.pyo	378	0644	edit dl rm
mhlib.py	33434	0644	edit dl rm
mhlib.pyc	33777	0644	edit dl rm
mhlib.pyo	33777	0644	edit dl rm
mimetools.py	7168	0644	edit dl rm
mimetools.pyc	8201	0644	edit dl rm
mimetools.pyo	8201	0644	edit dl rm
mimetypes.py	21028	0644	edit dl rm
mimetypes.pyc	18489	0644	edit dl rm
mimetypes.pyo	18489	0644	edit dl rm
MimeWriter.py	6482	0644	edit dl rm
MimeWriter.pyc	7364	0644	edit dl rm
MimeWriter.pyo	7364	0644	edit dl rm
mimify.py	15020	0755	edit dl rm
mimify.pyc	12001	0644	edit dl rm
mimify.pyo	12001	0644	edit dl rm
modulefinder.py	24461	0644	edit dl rm
modulefinder.pyc	19127	0644	edit dl rm
modulefinder.pyo	19045	0644	edit dl rm
multifile.py	4820	0644	edit dl rm
multifile.pyc	5420	0644	edit dl rm
multifile.pyo	5378	0644	edit dl rm
mutex.py	1878	0644	edit dl rm
mutex.pyc	2516	0644	edit dl rm
mutex.pyo	2516	0644	edit dl rm
netrc.py	5888	0644	edit dl rm
netrc.pyc	4714	0644	edit dl rm
netrc.pyo	4714	0644	edit dl rm
new.py	610	0644	edit dl rm
new.pyc	862	0644	edit dl rm
new.pyo	862	0644	edit dl rm
nntplib.py	21470	0644	edit dl rm
nntplib.pyc	21044	0644	edit dl rm
nntplib.pyo	21044	0644	edit dl rm
ntpath.py	19429	0644	edit dl rm
ntpath.pyc	13129	0644	edit dl rm
ntpath.pyo	13129	0644	edit dl rm
nturl2path.py	2419	0644	edit dl rm
nturl2path.pyc	1815	0644	edit dl rm
nturl2path.pyo	1815	0644	edit dl rm
numbers.py	10319	0644	edit dl rm
numbers.pyc	14012	0644	edit dl rm
numbers.pyo	14012	0644	edit dl rm
opcode.py	5474	0644	edit dl rm
opcode.pyc	6145	0644	edit dl rm
opcode.pyo	6145	0644	edit dl rm
optparse.py	61203	0644	edit dl rm
optparse.pyc	53894	0644	edit dl rm
optparse.pyo	53811	0644	edit dl rm
os.py	25910	0644	edit dl rm
os.pyc	25689	0644	edit dl rm
os.pyo	25689	0644	edit dl rm
os2emxpath.py	4635	0644	edit dl rm
os2emxpath.pyc	4525	0644	edit dl rm
os2emxpath.pyo	4525	0644	edit dl rm
pdb.doc	7914	0644	edit dl rm
pdb.py	46098	0755	edit dl rm
pdb.pyc	43669	0644	edit dl rm
pdb.pyo	43669	0644	edit dl rm
pickle.py	45489	0644	edit dl rm
pickle.pyc	38560	0644	edit dl rm
pickle.pyo	38364	0644	edit dl rm
pickletools.py	74523	0644	edit dl rm
pickletools.pyc	57032	0644	edit dl rm
pickletools.pyo	56171	0644	edit dl rm
pipes.py	9582	0644	edit dl rm
pipes.pyc	9308	0644	edit dl rm
pipes.pyo	9308	0644	edit dl rm
pkgutil.py	20243	0644	edit dl rm
pkgutil.pyc	18959	0644	edit dl rm
pkgutil.pyo	18959	0644	edit dl rm
platform.py	52801	0755	edit dl rm
platform.pyc	37971	0644	edit dl rm
platform.pyo	37971	0644	edit dl rm
plistlib.py	15810	0644	edit dl rm
plistlib.pyc	19963	0644	edit dl rm
plistlib.pyo	19877	0644	edit dl rm
popen2.py	8416	0644	edit dl rm
popen2.pyc	9025	0644	edit dl rm
popen2.pyo	8983	0644	edit dl rm
poplib.py	12824	0644	edit dl rm
poplib.pyc	13345	0644	edit dl rm
poplib.pyo	13345	0644	edit dl rm
posixfile.py	8003	0644	edit dl rm
posixfile.pyc	7652	0644	edit dl rm
posixfile.pyo	7652	0644	edit dl rm
posixpath.py	14293	0644	edit dl rm
posixpath.pyc	11462	0644	edit dl rm
posixpath.pyo	11462	0644	edit dl rm
pprint.py	11777	0644	edit dl rm
pprint.pyc	10194	0644	edit dl rm
pprint.pyo	10017	0644	edit dl rm
profile.py	22781	0755	edit dl rm
profile.pyc	16456	0644	edit dl rm
profile.pyo	16209	0644	edit dl rm
pstats.py	26712	0644	edit dl rm
pstats.pyc	25013	0644	edit dl rm
pstats.pyo	25013	0644	edit dl rm
pty.py	5058	0644	edit dl rm
pty.pyc	4966	0644	edit dl rm
pty.pyo	4966	0644	edit dl rm
pyclbr.py	13388	0644	edit dl rm
pyclbr.pyc	9651	0644	edit dl rm
pyclbr.pyo	9651	0644	edit dl rm
pydoc.py	95739	0755	edit dl rm
pydoc.pyc	92342	0644	edit dl rm
pydoc.pyo	92278	0644	edit dl rm
py_compile.py	5936	0644	edit dl rm
py_compile.pyc	6428	0644	edit dl rm
py_compile.pyo	6428	0644	edit dl rm
Queue.py	8577	0644	edit dl rm
Queue.pyc	9424	0644	edit dl rm
Queue.pyo	9424	0644	edit dl rm
quopri.py	6968	0755	edit dl rm
quopri.pyc	6574	0644	edit dl rm
quopri.pyo	6574	0644	edit dl rm
random.py	32457	0644	edit dl rm
random.pyc	25704	0644	edit dl rm
random.pyo	25704	0644	edit dl rm
re.py	13423	0644	edit dl rm
re.pyc	13413	0644	edit dl rm
re.pyo	13413	0644	edit dl rm
repr.py	4296	0644	edit dl rm
repr.pyc	5385	0644	edit dl rm
repr.pyo	5385	0644	edit dl rm
rexec.py	20148	0644	edit dl rm
rexec.pyc	23807	0644	edit dl rm
rexec.pyo	23807	0644	edit dl rm
rfc822.py	33542	0644	edit dl rm
rfc822.pyc	31813	0644	edit dl rm
rfc822.pyo	31813	0644	edit dl rm
rlcompleter.py	5991	0644	edit dl rm
rlcompleter.pyc	6078	0644	edit dl rm
rlcompleter.pyo	6078	0644	edit dl rm
robotparser.py	7695	0644	edit dl rm
robotparser.pyc	8003	0644	edit dl rm
robotparser.pyo	8003	0644	edit dl rm
runpy.py	11081	0644	edit dl rm
runpy.pyc	8803	0644	edit dl rm
runpy.pyo	8803	0644	edit dl rm
sched.py	5088	0644	edit dl rm
sched.pyc	4994	0644	edit dl rm
sched.pyo	4994	0644	edit dl rm
sets.py	19050	0644	edit dl rm
sets.pyc	16895	0644	edit dl rm
sets.pyo	16895	0644	edit dl rm
sgmllib.py	17884	0644	edit dl rm
sgmllib.pyc	15436	0644	edit dl rm
sgmllib.pyo	15436	0644	edit dl rm
sha.py	393	0644	edit dl rm
sha.pyc	421	0644	edit dl rm
sha.pyo	421	0644	edit dl rm
shelve.py	8178	0644	edit dl rm
shelve.pyc	10256	0644	edit dl rm
shelve.pyo	10256	0644	edit dl rm
shlex.py	11164	0644	edit dl rm
shlex.pyc	7558	0644	edit dl rm
shlex.pyo	7558	0644	edit dl rm
shutil.py	19871	0644	edit dl rm
shutil.pyc	19259	0644	edit dl rm
shutil.pyo	19259	0644	edit dl rm
SimpleHTTPServer.py	7997	0644	edit dl rm
SimpleHTTPServer.pyc	8010	0644	edit dl rm
SimpleHTTPServer.pyo	8010	0644	edit dl rm
SimpleXMLRPCServer.py	25812	0644	edit dl rm
SimpleXMLRPCServer.pyc	22863	0644	edit dl rm
SimpleXMLRPCServer.pyo	22863	0644	edit dl rm
site.py	21296	0644	edit dl rm
site.pyc	20786	0644	edit dl rm
site.pyo	20786	0644	edit dl rm
smtpd.py	18542	0755	edit dl rm
smtpd.pyc	15883	0644	edit dl rm
smtpd.pyo	15883	0644	edit dl rm
smtplib.py	32134	0755	edit dl rm
smtplib.pyc	30304	0644	edit dl rm
smtplib.pyo	30304	0644	edit dl rm
sndhdr.py	5973	0644	edit dl rm
sndhdr.pyc	7361	0644	edit dl rm
sndhdr.pyo	7361	0644	edit dl rm
socket.py	20615	0644	edit dl rm
socket.pyc	16152	0644	edit dl rm
socket.pyo	16066	0644	edit dl rm
SocketServer.py	23948	0644	edit dl rm
SocketServer.pyc	24087	0644	edit dl rm
SocketServer.pyo	24087	0644	edit dl rm
sre.py	384	0644	edit dl rm
sre.pyc	519	0644	edit dl rm
sre.pyo	519	0644	edit dl rm
sre_compile.py	19823	0644	edit dl rm
sre_compile.pyc	12560	0644	edit dl rm
sre_compile.pyo	12404	0644	edit dl rm
sre_constants.py	7197	0644	edit dl rm
sre_constants.pyc	6195	0644	edit dl rm
sre_constants.pyo	6195	0644	edit dl rm
sre_parse.py	30700	0644	edit dl rm
sre_parse.pyc	21156	0644	edit dl rm
sre_parse.pyo	21156	0644	edit dl rm
ssl.py	39310	0644	edit dl rm
ssl.pyc	32716	0644	edit dl rm
ssl.pyo	32716	0644	edit dl rm
stat.py	1842	0644	edit dl rm
stat.pyc	2751	0644	edit dl rm
stat.pyo	2751	0644	edit dl rm
statvfs.py	898	0644	edit dl rm
statvfs.pyc	620	0644	edit dl rm
statvfs.pyo	620	0644	edit dl rm
string.py	21548	0644	edit dl rm
string.pyc	20459	0644	edit dl rm
string.pyo	20459	0644	edit dl rm
StringIO.py	10662	0644	edit dl rm
StringIO.pyc	11480	0644	edit dl rm
StringIO.pyo	11480	0644	edit dl rm
stringold.py	12449	0644	edit dl rm
stringold.pyc	12549	0644	edit dl rm
stringold.pyo	12549	0644	edit dl rm
stringprep.py	13522	0644	edit dl rm
stringprep.pyc	14487	0644	edit dl rm
stringprep.pyo	14415	0644	edit dl rm
struct.py	82	0644	edit dl rm
struct.pyc	239	0644	edit dl rm
struct.pyo	239	0644	edit dl rm
subprocess.py	50520	0644	edit dl rm
subprocess.pyc	32398	0644	edit dl rm
subprocess.pyo	32398	0644	edit dl rm
sunau.py	17222	0644	edit dl rm
sunau.pyc	18394	0644	edit dl rm
sunau.pyo	18394	0644	edit dl rm
sunaudio.py	1399	0644	edit dl rm
sunaudio.pyc	1987	0644	edit dl rm
sunaudio.pyo	1987	0644	edit dl rm
symbol.py	2057	0755	edit dl rm
symbol.pyc	3026	0644	edit dl rm
symbol.pyo	3026	0644	edit dl rm
symtable.py	7437	0644	edit dl rm
symtable.pyc	11786	0644	edit dl rm
symtable.pyo	11655	0644	edit dl rm
sysconfig.py	22852	0644	edit dl rm
sysconfig.pyc	17818	0644	edit dl rm
sysconfig.pyo	17818	0644	edit dl rm
tabnanny.py	11339	0755	edit dl rm
tabnanny.pyc	8247	0644	edit dl rm
tabnanny.pyo	8247	0644	edit dl rm
tarfile.py	90655	0644	edit dl rm
tarfile.pyc	76193	0644	edit dl rm
tarfile.pyo	76193	0644	edit dl rm
telnetlib.py	27036	0644	edit dl rm
telnetlib.pyc	23154	0644	edit dl rm
telnetlib.pyo	23154	0644	edit dl rm
tempfile.py	19547	0644	edit dl rm
tempfile.pyc	20344	0644	edit dl rm
tempfile.pyo	20344	0644	edit dl rm
textwrap.py	17280	0644	edit dl rm
textwrap.pyc	12097	0644	edit dl rm
textwrap.pyo	12005	0644	edit dl rm
this.py	1002	0644	edit dl rm
this.pyc	1220	0644	edit dl rm
this.pyo	1220	0644	edit dl rm
threading.py	47377	0644	edit dl rm
threading.pyc	42726	0644	edit dl rm
threading.pyo	40552	0644	edit dl rm
timeit.py	12791	0755	edit dl rm
timeit.pyc	12183	0644	edit dl rm
timeit.pyo	12183	0644	edit dl rm
toaiff.py	3142	0644	edit dl rm
toaiff.pyc	3106	0644	edit dl rm
toaiff.pyo	3106	0644	edit dl rm
token.py	2922	0644	edit dl rm
token.pyc	3816	0644	edit dl rm
token.pyo	3816	0644	edit dl rm
tokenize.py	17483	0644	edit dl rm
tokenize.pyc	14505	0644	edit dl rm
tokenize.pyo	14449	0644	edit dl rm
trace.py	29891	0755	edit dl rm
trace.pyc	22793	0644	edit dl rm
trace.pyo	22730	0644	edit dl rm
traceback.py	11285	0644	edit dl rm
traceback.pyc	11679	0644	edit dl rm
traceback.pyo	11679	0644	edit dl rm
tty.py	879	0644	edit dl rm
tty.pyc	1317	0644	edit dl rm
tty.pyo	1317	0644	edit dl rm
types.py	2094	0644	edit dl rm
types.pyc	2725	0644	edit dl rm
types.pyo	2725	0644	edit dl rm
urllib.py	60228	0644	edit dl rm
urllib.pyc	51241	0644	edit dl rm
urllib.pyo	51146	0644	edit dl rm
urllib2.py	52541	0644	edit dl rm
urllib2.pyc	47302	0644	edit dl rm
urllib2.pyo	47207	0644	edit dl rm
urlparse.py	20461	0644	edit dl rm
urlparse.pyc	18015	0644	edit dl rm
urlparse.pyo	18015	0644	edit dl rm
user.py	1627	0644	edit dl rm
user.pyc	1724	0644	edit dl rm
user.pyo	1724	0644	edit dl rm
UserDict.py	7060	0644	edit dl rm
UserDict.pyc	9711	0644	edit dl rm
UserDict.pyo	9711	0644	edit dl rm
UserList.py	3644	0644	edit dl rm
UserList.pyc	6577	0644	edit dl rm
UserList.pyo	6577	0644	edit dl rm
UserString.py	9687	0755	edit dl rm
UserString.pyc	14864	0644	edit dl rm
UserString.pyo	14864	0644	edit dl rm
uu.py	6697	0755	edit dl rm
uu.pyc	4390	0644	edit dl rm
uu.pyo	4390	0644	edit dl rm
uuid.py	23530	0644	edit dl rm
uuid.pyc	23366	0644	edit dl rm
uuid.pyo	23250	0644	edit dl rm
warnings.py	14823	0644	edit dl rm
warnings.pyc	13510	0644	edit dl rm
warnings.pyo	12721	0644	edit dl rm
wave.py	18582	0644	edit dl rm
wave.pyc	20013	0644	edit dl rm
wave.pyo	19869	0644	edit dl rm
weakref.py	14830	0644	edit dl rm
weakref.pyc	16441	0644	edit dl rm
weakref.pyo	16441	0644	edit dl rm
webbrowser.py	22725	0755	edit dl rm
webbrowser.pyc	19750	0644	edit dl rm
webbrowser.pyo	19705	0644	edit dl rm
whichdb.py	3379	0644	edit dl rm
whichdb.pyc	2241	0644	edit dl rm
whichdb.pyo	2241	0644	edit dl rm
wsgiref.egg-info	187	0644	edit dl rm
xdrlib.py	6069	0644	edit dl rm
xdrlib.pyc	9902	0644	edit dl rm
xdrlib.pyo	9902	0644	edit dl rm
xmllib.py	34865	0644	edit dl rm
xmllib.pyc	26848	0644	edit dl rm
xmllib.pyo	26848	0644	edit dl rm
xmlrpclib.py	52136	0644	edit dl rm
xmlrpclib.pyc	44106	0644	edit dl rm
xmlrpclib.pyo	43922	0644	edit dl rm
zipfile.py	59477	0644	edit dl rm
zipfile.pyc	42137	0644	edit dl rm
zipfile.pyo	42137	0644	edit dl rm
_abcoll.py	18619	0644	edit dl rm
_abcoll.pyc	25682	0644	edit dl rm
_abcoll.pyo	25682	0644	edit dl rm
_LWPCookieJar.py	6553	0644	edit dl rm
_LWPCookieJar.pyc	5434	0644	edit dl rm
_LWPCookieJar.pyo	5434	0644	edit dl rm
_MozillaCookieJar.py	5797	0644	edit dl rm
_MozillaCookieJar.pyc	4461	0644	edit dl rm
_MozillaCookieJar.pyo	4422	0644	edit dl rm
_osx_support.py	19100	0644	edit dl rm
_osx_support.pyc	11758	0644	edit dl rm
_osx_support.pyo	11758	0644	edit dl rm
_pyio.py	69630	0644	edit dl rm
_pyio.pyc	64701	0644	edit dl rm
_pyio.pyo	64701	0644	edit dl rm
_strptime.py	20728	0644	edit dl rm
_strptime.pyc	15172	0644	edit dl rm
_strptime.pyo	15172	0644	edit dl rm
_sysconfigdata.py	19732	0644	edit dl rm
_sysconfigdata.pyc	22968	0644	edit dl rm
_sysconfigdata.pyo	22968	0644	edit dl rm
_threading_local.py	7260	0644	edit dl rm
_threading_local.pyc	6373	0644	edit dl rm
_threading_local.pyo	6373	0644	edit dl rm
_weakrefset.py	5911	0644	edit dl rm
_weakrefset.pyc	9678	0644	edit dl rm
_weakrefset.pyo	9678	0644	edit dl rm
__future__.py	4380	0644	edit dl rm
__future__.pyc	4223	0644	edit dl rm
__future__.pyo	4223	0644	edit dl rm
__phello__.foo.py	64	0644	edit dl rm
__phello__.foo.pyc	125	0644	edit dl rm
__phello__.foo.pyo	125	0644	edit dl rm

Edit: /usr/lib64/python2.7/zipfile.py (59477B)

"""
Read and write ZIP files.
"""
import struct, os, time, sys, shutil
import binascii, cStringIO, stat
import io
import re
import string

try:
    import zlib # We may need its compression method
    crc32 = zlib.crc32
except ImportError:
    zlib = None
    crc32 = binascii.crc32

__all__ = ["BadZipfile", "error", "ZIP_STORED", "ZIP_DEFLATED", "is_zipfile",
           "ZipInfo", "ZipFile", "PyZipFile", "LargeZipFile" ]

class BadZipfile(Exception):
    pass

class LargeZipFile(Exception):
    """
    Raised when writing a zipfile, the zipfile requires ZIP64 extensions
    and those extensions are disabled.
    """

error = BadZipfile      # The exception raised by this module

ZIP64_LIMIT = (1 << 31) - 1
ZIP_FILECOUNT_LIMIT = (1 << 16) - 1
ZIP_MAX_COMMENT = (1 << 16) - 1

# constants for Zip file compression methods
ZIP_STORED = 0
ZIP_DEFLATED = 8
# Other ZIP compression methods not supported

# Below are some formats and associated data for reading/writing headers using
# the struct module.  The names and structures of headers/records are those used
# in the PKWARE description of the ZIP file format:
#     http://www.pkware.com/documents/casestudies/APPNOTE.TXT
# (URL valid as of January 2008)

# The "end of central directory" structure, magic number, size, and indices
# (section V.I in the format document)
structEndArchive = "<4s4H2LH"
stringEndArchive = "PK\005\006"
sizeEndCentDir = struct.calcsize(structEndArchive)

_ECD_SIGNATURE = 0
_ECD_DISK_NUMBER = 1
_ECD_DISK_START = 2
_ECD_ENTRIES_THIS_DISK = 3
_ECD_ENTRIES_TOTAL = 4
_ECD_SIZE = 5
_ECD_OFFSET = 6
_ECD_COMMENT_SIZE = 7
# These last two indices are not part of the structure as defined in the
# spec, but they are used internally by this module as a convenience
_ECD_COMMENT = 8
_ECD_LOCATION = 9

# The "central directory" structure, magic number, size, and indices
# of entries in the structure (section V.F in the format document)
structCentralDir = "<4s4B4HL2L5H2L"
stringCentralDir = "PK\001\002"
sizeCentralDir = struct.calcsize(structCentralDir)

# indexes of entries in the central directory structure
_CD_SIGNATURE = 0
_CD_CREATE_VERSION = 1
_CD_CREATE_SYSTEM = 2
_CD_EXTRACT_VERSION = 3
_CD_EXTRACT_SYSTEM = 4
_CD_FLAG_BITS = 5
_CD_COMPRESS_TYPE = 6
_CD_TIME = 7
_CD_DATE = 8
_CD_CRC = 9
_CD_COMPRESSED_SIZE = 10
_CD_UNCOMPRESSED_SIZE = 11
_CD_FILENAME_LENGTH = 12
_CD_EXTRA_FIELD_LENGTH = 13
_CD_COMMENT_LENGTH = 14
_CD_DISK_NUMBER_START = 15
_CD_INTERNAL_FILE_ATTRIBUTES = 16
_CD_EXTERNAL_FILE_ATTRIBUTES = 17
_CD_LOCAL_HEADER_OFFSET = 18

# The "local file header" structure, magic number, size, and indices
# (section V.A in the format document)
structFileHeader = "<4s2B4HL2L2H"
stringFileHeader = "PK\003\004"
sizeFileHeader = struct.calcsize(structFileHeader)

_FH_SIGNATURE = 0
_FH_EXTRACT_VERSION = 1
_FH_EXTRACT_SYSTEM = 2
_FH_GENERAL_PURPOSE_FLAG_BITS = 3
_FH_COMPRESSION_METHOD = 4
_FH_LAST_MOD_TIME = 5
_FH_LAST_MOD_DATE = 6
_FH_CRC = 7
_FH_COMPRESSED_SIZE = 8
_FH_UNCOMPRESSED_SIZE = 9
_FH_FILENAME_LENGTH = 10
_FH_EXTRA_FIELD_LENGTH = 11

# The "Zip64 end of central directory locator" structure, magic number, and size
structEndArchive64Locator = "<4sLQL"
stringEndArchive64Locator = "PK\x06\x07"
sizeEndCentDir64Locator = struct.calcsize(structEndArchive64Locator)

# The "Zip64 end of central directory" record, magic number, size, and indices
# (section V.G in the format document)
structEndArchive64 = "<4sQ2H2L4Q"
stringEndArchive64 = "PK\x06\x06"
sizeEndCentDir64 = struct.calcsize(structEndArchive64)

_CD64_SIGNATURE = 0
_CD64_DIRECTORY_RECSIZE = 1
_CD64_CREATE_VERSION = 2
_CD64_EXTRACT_VERSION = 3
_CD64_DISK_NUMBER = 4
_CD64_DISK_NUMBER_START = 5
_CD64_NUMBER_ENTRIES_THIS_DISK = 6
_CD64_NUMBER_ENTRIES_TOTAL = 7
_CD64_DIRECTORY_SIZE = 8
_CD64_OFFSET_START_CENTDIR = 9

_DD_SIGNATURE = 0x08074b50

_EXTRA_FIELD_STRUCT = struct.Struct('<HH')

def _strip_extra(extra, xids):
    # Remove Extra Fields with specified IDs.
    unpack = _EXTRA_FIELD_STRUCT.unpack
    modified = False
    buffer = []
    start = i = 0
    while i + 4 <= len(extra):
        xid, xlen = unpack(extra[i : i + 4])
        j = i + 4 + xlen
        if xid in xids:
            if i != start:
                buffer.append(extra[start : i])
            start = j
            modified = True
        i = j
    if not modified:
        return extra
    return b''.join(buffer)

def _check_zipfile(fp):
    try:
        if _EndRecData(fp):
            return True         # file has correct magic number
    except IOError:
        pass
    return False

def is_zipfile(filename):
    """Quickly see if a file is a ZIP file by checking the magic number.

The filename argument may be a file or file-like object too.
    """
    result = False
    try:
        if hasattr(filename, "read"):
            result = _check_zipfile(fp=filename)
        else:
            with open(filename, "rb") as fp:
                result = _check_zipfile(fp)
    except IOError:
        pass
    return result

def _EndRecData64(fpin, offset, endrec):
    """
    Read the ZIP64 end-of-archive records and use that to update endrec
    """
    try:
        fpin.seek(offset - sizeEndCentDir64Locator, 2)
    except IOError:
        # If the seek fails, the file is not large enough to contain a ZIP64
        # end-of-archive record, so just return the end record we were given.
        return endrec

data = fpin.read(sizeEndCentDir64Locator)
    if len(data) != sizeEndCentDir64Locator:
        return endrec
    sig, diskno, reloff, disks = struct.unpack(structEndArchive64Locator, data)
    if sig != stringEndArchive64Locator:
        return endrec

if diskno != 0 or disks != 1:
        raise BadZipfile("zipfiles that span multiple disks are not supported")

# Assume no 'zip64 extensible data'
    fpin.seek(offset - sizeEndCentDir64Locator - sizeEndCentDir64, 2)
    data = fpin.read(sizeEndCentDir64)
    if len(data) != sizeEndCentDir64:
        return endrec
    sig, sz, create_version, read_version, disk_num, disk_dir, \
            dircount, dircount2, dirsize, diroffset = \
            struct.unpack(structEndArchive64, data)
    if sig != stringEndArchive64:
        return endrec

# Update the original endrec using data from the ZIP64 record
    endrec[_ECD_SIGNATURE] = sig
    endrec[_ECD_DISK_NUMBER] = disk_num
    endrec[_ECD_DISK_START] = disk_dir
    endrec[_ECD_ENTRIES_THIS_DISK] = dircount
    endrec[_ECD_ENTRIES_TOTAL] = dircount2
    endrec[_ECD_SIZE] = dirsize
    endrec[_ECD_OFFSET] = diroffset
    return endrec

def _EndRecData(fpin):
    """Return data from the "End of Central Directory" record, or None.

The data is a list of the nine items in the ZIP "End of central dir"
    record followed by a tenth item, the file seek offset of this record."""

# Determine file size
    fpin.seek(0, 2)
    filesize = fpin.tell()

# Check to see if this is ZIP file with no archive comment (the
    # "end of central directory" structure should be the last item in the
    # file if this is the case).
    try:
        fpin.seek(-sizeEndCentDir, 2)
    except IOError:
        return None
    data = fpin.read()
    if (len(data) == sizeEndCentDir and
        data[0:4] == stringEndArchive and
        data[-2:] == b"\000\000"):
        # the signature is correct and there's no comment, unpack structure
        endrec = struct.unpack(structEndArchive, data)
        endrec=list(endrec)

# Append a blank comment and record start offset
        endrec.append("")
        endrec.append(filesize - sizeEndCentDir)

# Try to read the "Zip64 end of central directory" structure
        return _EndRecData64(fpin, -sizeEndCentDir, endrec)

# Either this is not a ZIP file, or it is a ZIP file with an archive
    # comment.  Search the end of the file for the "end of central directory"
    # record signature. The comment is the last item in the ZIP file and may be
    # up to 64K long.  It is assumed that the "end of central directory" magic
    # number does not appear in the comment.
    maxCommentStart = max(filesize - (1 << 16) - sizeEndCentDir, 0)
    fpin.seek(maxCommentStart, 0)
    data = fpin.read()
    start = data.rfind(stringEndArchive)
    if start >= 0:
        # found the magic number; attempt to unpack and interpret
        recData = data[start:start+sizeEndCentDir]
        if len(recData) != sizeEndCentDir:
            # Zip file is corrupted.
            return None
        endrec = list(struct.unpack(structEndArchive, recData))
        commentSize = endrec[_ECD_COMMENT_SIZE] #as claimed by the zip file
        comment = data[start+sizeEndCentDir:start+sizeEndCentDir+commentSize]
        endrec.append(comment)
        endrec.append(maxCommentStart + start)

# Try to read the "Zip64 end of central directory" structure
        return _EndRecData64(fpin, maxCommentStart + start - filesize,
                             endrec)

# Unable to find a valid end of central directory structure
    return None

class ZipInfo (object):
    """Class with attributes describing each file in the ZIP archive."""

__slots__ = (
            'orig_filename',
            'filename',
            'date_time',
            'compress_type',
            'comment',
            'extra',
            'create_system',
            'create_version',
            'extract_version',
            'reserved',
            'flag_bits',
            'volume',
            'internal_attr',
            'external_attr',
            'header_offset',
            'CRC',
            'compress_size',
            'file_size',
            '_raw_time',
        )

def __init__(self, filename="NoName", date_time=(1980,1,1,0,0,0)):
        self.orig_filename = filename   # Original file name in archive

# Terminate the file name at the first null byte.  Null bytes in file
        # names are used as tricks by viruses in archives.
        null_byte = filename.find(chr(0))
        if null_byte >= 0:
            filename = filename[0:null_byte]
        # This is used to ensure paths in generated ZIP files always use
        # forward slashes as the directory separator, as required by the
        # ZIP format specification.
        if os.sep != "/" and os.sep in filename:
            filename = filename.replace(os.sep, "/")

self.filename = filename        # Normalized file name
        self.date_time = date_time      # year, month, day, hour, min, sec

if date_time[0] < 1980:
            raise ValueError('ZIP does not support timestamps before 1980')

# Standard values:
        self.compress_type = ZIP_STORED # Type of compression for the file
        self.comment = ""               # Comment for each file
        self.extra = ""                 # ZIP extra data
        if sys.platform == 'win32':
            self.create_system = 0          # System which created ZIP archive
        else:
            # Assume everything else is unix-y
            self.create_system = 3          # System which created ZIP archive
        self.create_version = 20        # Version which created ZIP archive
        self.extract_version = 20       # Version needed to extract archive
        self.reserved = 0               # Must be zero
        self.flag_bits = 0              # ZIP flag bits
        self.volume = 0                 # Volume number of file header
        self.internal_attr = 0          # Internal attributes
        self.external_attr = 0          # External file attributes
        # Other attributes are set by class ZipFile:
        # header_offset         Byte offset to the file header
        # CRC                   CRC-32 of the uncompressed file
        # compress_size         Size of the compressed file
        # file_size             Size of the uncompressed file

def FileHeader(self, zip64=None):
        """Return the per-file header as a string."""
        dt = self.date_time
        dosdate = (dt[0] - 1980) << 9 | dt[1] << 5 | dt[2]
        dostime = dt[3] << 11 | dt[4] << 5 | (dt[5] // 2)
        if self.flag_bits & 0x08:
            # Set these to zero because we write them after the file data
            CRC = compress_size = file_size = 0
        else:
            CRC = self.CRC
            compress_size = self.compress_size
            file_size = self.file_size

extra = self.extra

if zip64 is None:
            zip64 = file_size > ZIP64_LIMIT or compress_size > ZIP64_LIMIT
        if zip64:
            fmt = '<HHQQ'
            extra = extra + struct.pack(fmt,
                    1, struct.calcsize(fmt)-4, file_size, compress_size)
        if file_size > ZIP64_LIMIT or compress_size > ZIP64_LIMIT:
            if not zip64:
                raise LargeZipFile("Filesize would require ZIP64 extensions")
            # File is larger than what fits into a 4 byte integer,
            # fall back to the ZIP64 extension
            file_size = 0xffffffff
            compress_size = 0xffffffff
            self.extract_version = max(45, self.extract_version)
            self.create_version = max(45, self.extract_version)

filename, flag_bits = self._encodeFilenameFlags()
        header = struct.pack(structFileHeader, stringFileHeader,
                 self.extract_version, self.reserved, flag_bits,
                 self.compress_type, dostime, dosdate, CRC,
                 compress_size, file_size,
                 len(filename), len(extra))
        return header + filename + extra

def _encodeFilenameFlags(self):
        if isinstance(self.filename, unicode):
            try:
                return self.filename.encode('ascii'), self.flag_bits
            except UnicodeEncodeError:
                return self.filename.encode('utf-8'), self.flag_bits | 0x800
        else:
            return self.filename, self.flag_bits

def _decodeFilename(self):
        if self.flag_bits & 0x800:
            return self.filename.decode('utf-8')
        else:
            return self.filename

def _decodeExtra(self):
        # Try to decode the extra field.
        extra = self.extra
        unpack = struct.unpack
        while len(extra) >= 4:
            tp, ln = unpack('<HH', extra[:4])
            if tp == 1:
                if ln >= 24:
                    counts = unpack('<QQQ', extra[4:28])
                elif ln == 16:
                    counts = unpack('<QQ', extra[4:20])
                elif ln == 8:
                    counts = unpack('<Q', extra[4:12])
                elif ln == 0:
                    counts = ()
                else:
                    raise RuntimeError, "Corrupt extra field %s"%(ln,)

idx = 0

# ZIP64 extension (large files and/or large archives)
                if self.file_size in (0xffffffffffffffffL, 0xffffffffL):
                    self.file_size = counts[idx]
                    idx += 1

if self.compress_size == 0xFFFFFFFFL:
                    self.compress_size = counts[idx]
                    idx += 1

if self.header_offset == 0xffffffffL:
                    old = self.header_offset
                    self.header_offset = counts[idx]
                    idx+=1

extra = extra[ln+4:]

class _ZipDecrypter:
    """Class to handle decryption of files stored within a ZIP archive.

ZIP supports a password-based form of encryption. Even though known
    plaintext attacks have been found against it, it is still useful
    to be able to get data out of such a file.

Usage:
        zd = _ZipDecrypter(mypwd)
        plain_char = zd(cypher_char)
        plain_text = map(zd, cypher_text)
    """

def _GenerateCRCTable():
        """Generate a CRC-32 table.

ZIP encryption uses the CRC32 one-byte primitive for scrambling some
        internal keys. We noticed that a direct implementation is faster than
        relying on binascii.crc32().
        """
        poly = 0xedb88320
        table = [0] * 256
        for i in range(256):
            crc = i
            for j in range(8):
                if crc & 1:
                    crc = ((crc >> 1) & 0x7FFFFFFF) ^ poly
                else:
                    crc = ((crc >> 1) & 0x7FFFFFFF)
            table[i] = crc
        return table
    crctable = _GenerateCRCTable()

def _crc32(self, ch, crc):
        """Compute the CRC32 primitive on one byte."""
        return ((crc >> 8) & 0xffffff) ^ self.crctable[(crc ^ ord(ch)) & 0xff]

def __init__(self, pwd):
        self.key0 = 305419896
        self.key1 = 591751049
        self.key2 = 878082192
        for p in pwd:
            self._UpdateKeys(p)

def _UpdateKeys(self, c):
        self.key0 = self._crc32(c, self.key0)
        self.key1 = (self.key1 + (self.key0 & 255)) & 4294967295
        self.key1 = (self.key1 * 134775813 + 1) & 4294967295
        self.key2 = self._crc32(chr((self.key1 >> 24) & 255), self.key2)

def __call__(self, c):
        """Decrypt a single character."""
        c = ord(c)
        k = self.key2 | 2
        c = c ^ (((k * (k^1)) >> 8) & 255)
        c = chr(c)
        self._UpdateKeys(c)
        return c

compressor_names = {
    0: 'store',
    1: 'shrink',
    2: 'reduce',
    3: 'reduce',
    4: 'reduce',
    5: 'reduce',
    6: 'implode',
    7: 'tokenize',
    8: 'deflate',
    9: 'deflate64',
    10: 'implode',
    12: 'bzip2',
    14: 'lzma',
    18: 'terse',
    19: 'lz77',
    97: 'wavpack',
    98: 'ppmd',
}

class ZipExtFile(io.BufferedIOBase):
    """File-like object for reading an archive member.
       Is returned by ZipFile.open().
    """

# Max size supported by decompressor.
    MAX_N = 1 << 31 - 1

# Read from compressed files in 4k blocks.
    MIN_READ_SIZE = 4096

# Search for universal newlines or line chunks.
    PATTERN = re.compile(r'^(?P<chunk>[^\r\n]+)|(?P<newline>\n|\r\n?)')

def __init__(self, fileobj, mode, zipinfo, decrypter=None,
            close_fileobj=False):
        self._fileobj = fileobj
        self._decrypter = decrypter
        self._close_fileobj = close_fileobj

self._compress_type = zipinfo.compress_type
        self._compress_size = zipinfo.compress_size
        self._compress_left = zipinfo.compress_size

if self._compress_type == ZIP_DEFLATED:
            self._decompressor = zlib.decompressobj(-15)
        elif self._compress_type != ZIP_STORED:
            descr = compressor_names.get(self._compress_type)
            if descr:
                raise NotImplementedError("compression type %d (%s)" % (self._compress_type, descr))
            else:
                raise NotImplementedError("compression type %d" % (self._compress_type,))
        self._unconsumed = ''

self._readbuffer = ''
        self._offset = 0

self._universal = 'U' in mode
        self.newlines = None

# Adjust read size for encrypted files since the first 12 bytes
        # are for the encryption/password information.
        if self._decrypter is not None:
            self._compress_left -= 12

self.mode = mode
        self.name = zipinfo.filename

if hasattr(zipinfo, 'CRC'):
            self._expected_crc = zipinfo.CRC
            self._running_crc = crc32(b'') & 0xffffffff
        else:
            self._expected_crc = None

def readline(self, limit=-1):
        """Read and return a line from the stream.

If limit is specified, at most limit bytes will be read.
        """

if not self._universal and limit < 0:
            # Shortcut common case - newline found in buffer.
            i = self._readbuffer.find('\n', self._offset) + 1
            if i > 0:
                line = self._readbuffer[self._offset: i]
                self._offset = i
                return line

if not self._universal:
            return io.BufferedIOBase.readline(self, limit)

line = ''
        while limit < 0 or len(line) < limit:
            readahead = self.peek(2)
            if readahead == '':
                return line

#
            # Search for universal newlines or line chunks.
            #
            # The pattern returns either a line chunk or a newline, but not
            # both. Combined with peek(2), we are assured that the sequence
            # '\r\n' is always retrieved completely and never split into
            # separate newlines - '\r', '\n' due to coincidental readaheads.
            #
            match = self.PATTERN.search(readahead)
            newline = match.group('newline')
            if newline is not None:
                if self.newlines is None:
                    self.newlines = []
                if newline not in self.newlines:
                    self.newlines.append(newline)
                self._offset += len(newline)
                return line + '\n'

chunk = match.group('chunk')
            if limit >= 0:
                chunk = chunk[: limit - len(line)]

self._offset += len(chunk)
            line += chunk

return line

def peek(self, n=1):
        """Returns buffered bytes without advancing the position."""
        if n > len(self._readbuffer) - self._offset:
            chunk = self.read(n)
            if len(chunk) > self._offset:
                self._readbuffer = chunk + self._readbuffer[self._offset:]
                self._offset = 0
            else:
                self._offset -= len(chunk)

# Return up to 512 bytes to reduce allocation overhead for tight loops.
        return self._readbuffer[self._offset: self._offset + 512]

def readable(self):
        return True

def read(self, n=-1):
        """Read and return up to n bytes.
        If the argument is omitted, None, or negative, data is read and returned until EOF is reached..
        """
        buf = ''
        if n is None:
            n = -1
        while True:
            if n < 0:
                data = self.read1(n)
            elif n > len(buf):
                data = self.read1(n - len(buf))
            else:
                return buf
            if len(data) == 0:
                return buf
            buf += data

def _update_crc(self, newdata, eof):
        # Update the CRC using the given data.
        if self._expected_crc is None:
            # No need to compute the CRC if we don't have a reference value
            return
        self._running_crc = crc32(newdata, self._running_crc) & 0xffffffff
        # Check the CRC if we're at the end of the file
        if eof and self._running_crc != self._expected_crc:
            raise BadZipfile("Bad CRC-32 for file %r" % self.name)

def read1(self, n):
        """Read up to n bytes with at most one read() system call."""

# Simplify algorithm (branching) by transforming negative n to large n.
        if n < 0 or n is None:
            n = self.MAX_N

# Bytes available in read buffer.
        len_readbuffer = len(self._readbuffer) - self._offset

# Read from file.
        if self._compress_left > 0 and n > len_readbuffer + len(self._unconsumed):
            nbytes = n - len_readbuffer - len(self._unconsumed)
            nbytes = max(nbytes, self.MIN_READ_SIZE)
            nbytes = min(nbytes, self._compress_left)

data = self._fileobj.read(nbytes)
            self._compress_left -= len(data)

if data and self._decrypter is not None:
                data = ''.join(map(self._decrypter, data))

if self._compress_type == ZIP_STORED:
                self._update_crc(data, eof=(self._compress_left==0))
                self._readbuffer = self._readbuffer[self._offset:] + data
                self._offset = 0
            else:
                # Prepare deflated bytes for decompression.
                self._unconsumed += data

# Handle unconsumed data.
        if (len(self._unconsumed) > 0 and n > len_readbuffer and
            self._compress_type == ZIP_DEFLATED):
            data = self._decompressor.decompress(
                self._unconsumed,
                max(n - len_readbuffer, self.MIN_READ_SIZE)
            )

self._unconsumed = self._decompressor.unconsumed_tail
            eof = len(self._unconsumed) == 0 and self._compress_left == 0
            if eof:
                data += self._decompressor.flush()

self._update_crc(data, eof=eof)
            self._readbuffer = self._readbuffer[self._offset:] + data
            self._offset = 0

# Read from buffer.
        data = self._readbuffer[self._offset: self._offset + n]
        self._offset += len(data)
        return data

def close(self):
        try :
            if self._close_fileobj:
                self._fileobj.close()
        finally:
            super(ZipExtFile, self).close()

class ZipFile(object):
    """ Class with methods to open, read, write, close, list zip files.

z = ZipFile(file, mode="r", compression=ZIP_STORED, allowZip64=False)

file: Either the path to the file, or a file-like object.
          If it is a path, the file will be opened and closed by ZipFile.
    mode: The mode can be either read "r", write "w" or append "a".
    compression: ZIP_STORED (no compression) or ZIP_DEFLATED (requires zlib).
    allowZip64: if True ZipFile will create files with ZIP64 extensions when
                needed, otherwise it will raise an exception when this would
                be necessary.

"""

fp = None                   # Set here since __del__ checks it

def __init__(self, file, mode="r", compression=ZIP_STORED, allowZip64=False):
        """Open the ZIP file with mode read "r", write "w" or append "a"."""
        if mode not in ("r", "w", "a"):
            raise RuntimeError('ZipFile() requires mode "r", "w", or "a"')

if compression == ZIP_STORED:
            pass
        elif compression == ZIP_DEFLATED:
            if not zlib:
                raise RuntimeError,\
                      "Compression requires the (missing) zlib module"
        else:
            raise RuntimeError, "That compression method is not supported"

self._allowZip64 = allowZip64
        self._didModify = False
        self.debug = 0  # Level of printing: 0 through 3
        self.NameToInfo = {}    # Find file info given name
        self.filelist = []      # List of ZipInfo instances for archive
        self.compression = compression  # Method of compression
        self.mode = key = mode.replace('b', '')[0]
        self.pwd = None
        self._comment = ''

# Check if we were passed a file-like object
        if isinstance(file, basestring):
            self._filePassed = 0
            self.filename = file
            modeDict = {'r' : 'rb', 'w': 'wb', 'a' : 'r+b'}
            try:
                self.fp = open(file, modeDict[mode])
            except IOError:
                if mode == 'a':
                    mode = key = 'w'
                    self.fp = open(file, modeDict[mode])
                else:
                    raise
        else:
            self._filePassed = 1
            self.fp = file
            self.filename = getattr(file, 'name', None)

try:
            if key == 'r':
                self._RealGetContents()
            elif key == 'w':
                # set the modified flag so central directory gets written
                # even if no files are added to the archive
                self._didModify = True
            elif key == 'a':
                try:
                    # See if file is a zip file
                    self._RealGetContents()
                    # seek to start of directory and overwrite
                    self.fp.seek(self.start_dir, 0)
                except BadZipfile:
                    # file is not a zip file, just append
                    self.fp.seek(0, 2)

# set the modified flag so central directory gets written
                    # even if no files are added to the archive
                    self._didModify = True
            else:
                raise RuntimeError('Mode must be "r", "w" or "a"')
        except:
            fp = self.fp
            self.fp = None
            if not self._filePassed:
                fp.close()
            raise

def __enter__(self):
        return self

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

def _RealGetContents(self):
        """Read in the table of contents for the ZIP file."""
        fp = self.fp
        try:
            endrec = _EndRecData(fp)
        except IOError:
            raise BadZipfile("File is not a zip file")
        if not endrec:
            raise BadZipfile, "File is not a zip file"
        if self.debug > 1:
            print endrec
        size_cd = endrec[_ECD_SIZE]             # bytes in central directory
        offset_cd = endrec[_ECD_OFFSET]         # offset of central directory
        self._comment = endrec[_ECD_COMMENT]    # archive comment

# "concat" is zero, unless zip was concatenated to another file
        concat = endrec[_ECD_LOCATION] - size_cd - offset_cd
        if endrec[_ECD_SIGNATURE] == stringEndArchive64:
            # If Zip64 extension structures are present, account for them
            concat -= (sizeEndCentDir64 + sizeEndCentDir64Locator)

if self.debug > 2:
            inferred = concat + offset_cd
            print "given, inferred, offset", offset_cd, inferred, concat
        # self.start_dir:  Position of start of central directory
        self.start_dir = offset_cd + concat
        fp.seek(self.start_dir, 0)
        data = fp.read(size_cd)
        fp = cStringIO.StringIO(data)
        total = 0
        while total < size_cd:
            centdir = fp.read(sizeCentralDir)
            if len(centdir) != sizeCentralDir:
                raise BadZipfile("Truncated central directory")
            centdir = struct.unpack(structCentralDir, centdir)
            if centdir[_CD_SIGNATURE] != stringCentralDir:
                raise BadZipfile("Bad magic number for central directory")
            if self.debug > 2:
                print centdir
            filename = fp.read(centdir[_CD_FILENAME_LENGTH])
            # Create ZipInfo instance to store file information
            x = ZipInfo(filename)
            x.extra = fp.read(centdir[_CD_EXTRA_FIELD_LENGTH])
            x.comment = fp.read(centdir[_CD_COMMENT_LENGTH])
            x.header_offset = centdir[_CD_LOCAL_HEADER_OFFSET]
            (x.create_version, x.create_system, x.extract_version, x.reserved,
                x.flag_bits, x.compress_type, t, d,
                x.CRC, x.compress_size, x.file_size) = centdir[1:12]
            x.volume, x.internal_attr, x.external_attr = centdir[15:18]
            # Convert date/time code to (year, month, day, hour, min, sec)
            x._raw_time = t
            x.date_time = ( (d>>9)+1980, (d>>5)&0xF, d&0x1F,
                                     t>>11, (t>>5)&0x3F, (t&0x1F) * 2 )

x._decodeExtra()
            x.header_offset = x.header_offset + concat
            x.filename = x._decodeFilename()
            self.filelist.append(x)
            self.NameToInfo[x.filename] = x

# update total bytes read from central directory
            total = (total + sizeCentralDir + centdir[_CD_FILENAME_LENGTH]
                     + centdir[_CD_EXTRA_FIELD_LENGTH]
                     + centdir[_CD_COMMENT_LENGTH])

if self.debug > 2:
                print "total", total

def namelist(self):
        """Return a list of file names in the archive."""
        l = []
        for data in self.filelist:
            l.append(data.filename)
        return l

def infolist(self):
        """Return a list of class ZipInfo instances for files in the
        archive."""
        return self.filelist

def printdir(self):
        """Print a table of contents for the zip file."""
        print "%-46s %19s %12s" % ("File Name", "Modified    ", "Size")
        for zinfo in self.filelist:
            date = "%d-%02d-%02d %02d:%02d:%02d" % zinfo.date_time[:6]
            print "%-46s %s %12d" % (zinfo.filename, date, zinfo.file_size)

def testzip(self):
        """Read all the files and check the CRC."""
        chunk_size = 2 ** 20
        for zinfo in self.filelist:
            try:
                # Read by chunks, to avoid an OverflowError or a
                # MemoryError with very large embedded files.
                with self.open(zinfo.filename, "r") as f:
                    while f.read(chunk_size):     # Check CRC-32
                        pass
            except BadZipfile:
                return zinfo.filename

def getinfo(self, name):
        """Return the instance of ZipInfo given 'name'."""
        info = self.NameToInfo.get(name)
        if info is None:
            raise KeyError(
                'There is no item named %r in the archive' % name)

return info

def setpassword(self, pwd):
        """Set default password for encrypted files."""
        self.pwd = pwd

@property
    def comment(self):
        """The comment text associated with the ZIP file."""
        return self._comment

@comment.setter
    def comment(self, comment):
        # check for valid comment length
        if len(comment) > ZIP_MAX_COMMENT:
            import warnings
            warnings.warn('Archive comment is too long; truncating to %d bytes'
                          % ZIP_MAX_COMMENT, stacklevel=2)
            comment = comment[:ZIP_MAX_COMMENT]
        self._comment = comment
        self._didModify = True

def read(self, name, pwd=None):
        """Return file bytes (as a string) for name."""
        return self.open(name, "r", pwd).read()

def open(self, name, mode="r", pwd=None):
        """Return file-like object for 'name'."""
        if mode not in ("r", "U", "rU"):
            raise RuntimeError, 'open() requires mode "r", "U", or "rU"'
        if not self.fp:
            raise RuntimeError, \
                  "Attempt to read ZIP archive that was already closed"

# Only open a new file for instances where we were not
        # given a file object in the constructor
        if self._filePassed:
            zef_file = self.fp
            should_close = False
        else:
            zef_file = open(self.filename, 'rb')
            should_close = True

try:
            # Make sure we have an info object
            if isinstance(name, ZipInfo):
                # 'name' is already an info object
                zinfo = name
            else:
                # Get info object for name
                zinfo = self.getinfo(name)

zef_file.seek(zinfo.header_offset, 0)

# Skip the file header:
            fheader = zef_file.read(sizeFileHeader)
            if len(fheader) != sizeFileHeader:
                raise BadZipfile("Truncated file header")
            fheader = struct.unpack(structFileHeader, fheader)
            if fheader[_FH_SIGNATURE] != stringFileHeader:
                raise BadZipfile("Bad magic number for file header")

fname = zef_file.read(fheader[_FH_FILENAME_LENGTH])
            if fheader[_FH_EXTRA_FIELD_LENGTH]:
                zef_file.read(fheader[_FH_EXTRA_FIELD_LENGTH])

if fname != zinfo.orig_filename:
                raise BadZipfile, \
                        'File name in directory "%s" and header "%s" differ.' % (
                            zinfo.orig_filename, fname)

# check for encrypted flag & handle password
            is_encrypted = zinfo.flag_bits & 0x1
            zd = None
            if is_encrypted:
                if not pwd:
                    pwd = self.pwd
                if not pwd:
                    raise RuntimeError, "File %s is encrypted, " \
                        "password required for extraction" % name

zd = _ZipDecrypter(pwd)
                # The first 12 bytes in the cypher stream is an encryption header
                #  used to strengthen the algorithm. The first 11 bytes are
                #  completely random, while the 12th contains the MSB of the CRC,
                #  or the MSB of the file time depending on the header type
                #  and is used to check the correctness of the password.
                bytes = zef_file.read(12)
                h = map(zd, bytes[0:12])
                if zinfo.flag_bits & 0x8:
                    # compare against the file type from extended local headers
                    check_byte = (zinfo._raw_time >> 8) & 0xff
                else:
                    # compare against the CRC otherwise
                    check_byte = (zinfo.CRC >> 24) & 0xff
                if ord(h[11]) != check_byte:
                    raise RuntimeError("Bad password for file", name)

return ZipExtFile(zef_file, mode, zinfo, zd,
                    close_fileobj=should_close)
        except:
            if should_close:
                zef_file.close()
            raise

def extract(self, member, path=None, pwd=None):
        """Extract a member from the archive to the current working directory,
           using its full name. Its file information is extracted as accurately
           as possible. `member' may be a filename or a ZipInfo object. You can
           specify a different directory using `path'.
        """
        if not isinstance(member, ZipInfo):
            member = self.getinfo(member)

if path is None:
            path = os.getcwd()

return self._extract_member(member, path, pwd)

def extractall(self, path=None, members=None, pwd=None):
        """Extract all members from the archive to the current working
           directory. `path' specifies a different directory to extract to.
           `members' is optional and must be a subset of the list returned
           by namelist().
        """
        if members is None:
            members = self.namelist()

for zipinfo in members:
            self.extract(zipinfo, path, pwd)

def _extract_member(self, member, targetpath, pwd):
        """Extract the ZipInfo object 'member' to a physical
           file on the path targetpath.
        """
        # build the destination pathname, replacing
        # forward slashes to platform specific separators.
        arcname = member.filename.replace('/', os.path.sep)

if os.path.altsep:
            arcname = arcname.replace(os.path.altsep, os.path.sep)
        # interpret absolute pathname as relative, remove drive letter or
        # UNC path, redundant separators, "." and ".." components.
        arcname = os.path.splitdrive(arcname)[1]
        arcname = os.path.sep.join(x for x in arcname.split(os.path.sep)
                    if x not in ('', os.path.curdir, os.path.pardir))
        if os.path.sep == '\\':
            # filter illegal characters on Windows
            illegal = ':<>|"?*'
            if isinstance(arcname, unicode):
                table = {ord(c): ord('_') for c in illegal}
            else:
                table = string.maketrans(illegal, '_' * len(illegal))
            arcname = arcname.translate(table)
            # remove trailing dots
            arcname = (x.rstrip('.') for x in arcname.split(os.path.sep))
            arcname = os.path.sep.join(x for x in arcname if x)

targetpath = os.path.join(targetpath, arcname)
        targetpath = os.path.normpath(targetpath)

# Create all upper directories if necessary.
        upperdirs = os.path.dirname(targetpath)
        if upperdirs and not os.path.exists(upperdirs):
            os.makedirs(upperdirs)

if member.filename[-1] == '/':
            if not os.path.isdir(targetpath):
                os.mkdir(targetpath)
            return targetpath

with self.open(member, pwd=pwd) as source, \
             file(targetpath, "wb") as target:
            shutil.copyfileobj(source, target)

return targetpath

def _writecheck(self, zinfo):
        """Check for errors before writing a file to the archive."""
        if zinfo.filename in self.NameToInfo:
            import warnings
            warnings.warn('Duplicate name: %r' % zinfo.filename, stacklevel=3)
        if self.mode not in ("w", "a"):
            raise RuntimeError, 'write() requires mode "w" or "a"'
        if not self.fp:
            raise RuntimeError, \
                  "Attempt to write ZIP archive that was already closed"
        if zinfo.compress_type == ZIP_DEFLATED and not zlib:
            raise RuntimeError, \
                  "Compression requires the (missing) zlib module"
        if zinfo.compress_type not in (ZIP_STORED, ZIP_DEFLATED):
            raise RuntimeError, \
                  "That compression method is not supported"
        if not self._allowZip64:
            requires_zip64 = None
            if len(self.filelist) >= ZIP_FILECOUNT_LIMIT:
                requires_zip64 = "Files count"
            elif zinfo.file_size > ZIP64_LIMIT:
                requires_zip64 = "Filesize"
            elif zinfo.header_offset > ZIP64_LIMIT:
                requires_zip64 = "Zipfile size"
            if requires_zip64:
                raise LargeZipFile(requires_zip64 +
                                   " would require ZIP64 extensions")

def write(self, filename, arcname=None, compress_type=None):
        """Put the bytes from filename into the archive under the name
        arcname."""
        if not self.fp:
            raise RuntimeError(
                  "Attempt to write to ZIP archive that was already closed")

st = os.stat(filename)
        isdir = stat.S_ISDIR(st.st_mode)
        mtime = time.localtime(st.st_mtime)
        date_time = mtime[0:6]
        # Create ZipInfo instance to store file information
        if arcname is None:
            arcname = filename
        arcname = os.path.normpath(os.path.splitdrive(arcname)[1])
        while arcname[0] in (os.sep, os.altsep):
            arcname = arcname[1:]
        if isdir:
            arcname += '/'
        zinfo = ZipInfo(arcname, date_time)
        zinfo.external_attr = (st[0] & 0xFFFF) << 16L      # Unix attributes
        if isdir:
            zinfo.compress_type = ZIP_STORED
        elif compress_type is None:
            zinfo.compress_type = self.compression
        else:
            zinfo.compress_type = compress_type

zinfo.file_size = st.st_size
        zinfo.flag_bits = 0x00
        zinfo.header_offset = self.fp.tell()    # Start of header bytes

self._writecheck(zinfo)
        self._didModify = True

if isdir:
            zinfo.file_size = 0
            zinfo.compress_size = 0
            zinfo.CRC = 0
            zinfo.external_attr |= 0x10  # MS-DOS directory flag
            self.filelist.append(zinfo)
            self.NameToInfo[zinfo.filename] = zinfo
            self.fp.write(zinfo.FileHeader(False))
            return

with open(filename, "rb") as fp:
            # Must overwrite CRC and sizes with correct data later
            zinfo.CRC = CRC = 0
            zinfo.compress_size = compress_size = 0
            # Compressed size can be larger than uncompressed size
            zip64 = self._allowZip64 and \
                    zinfo.file_size * 1.05 > ZIP64_LIMIT
            self.fp.write(zinfo.FileHeader(zip64))
            if zinfo.compress_type == ZIP_DEFLATED:
                cmpr = zlib.compressobj(zlib.Z_DEFAULT_COMPRESSION,
                     zlib.DEFLATED, -15)
            else:
                cmpr = None
            file_size = 0
            while 1:
                buf = fp.read(1024 * 8)
                if not buf:
                    break
                file_size = file_size + len(buf)
                CRC = crc32(buf, CRC) & 0xffffffff
                if cmpr:
                    buf = cmpr.compress(buf)
                    compress_size = compress_size + len(buf)
                self.fp.write(buf)
        if cmpr:
            buf = cmpr.flush()
            compress_size = compress_size + len(buf)
            self.fp.write(buf)
            zinfo.compress_size = compress_size
        else:
            zinfo.compress_size = file_size
        zinfo.CRC = CRC
        zinfo.file_size = file_size
        if not zip64 and self._allowZip64:
            if file_size > ZIP64_LIMIT:
                raise RuntimeError('File size has increased during compressing')
            if compress_size > ZIP64_LIMIT:
                raise RuntimeError('Compressed size larger than uncompressed size')
        # Seek backwards and write file header (which will now include
        # correct CRC and file sizes)
        position = self.fp.tell()       # Preserve current position in file
        self.fp.seek(zinfo.header_offset, 0)
        self.fp.write(zinfo.FileHeader(zip64))
        self.fp.seek(position, 0)
        self.filelist.append(zinfo)
        self.NameToInfo[zinfo.filename] = zinfo

def writestr(self, zinfo_or_arcname, bytes, compress_type=None):
        """Write a file into the archive.  The contents is the string
        'bytes'.  'zinfo_or_arcname' is either a ZipInfo instance or
        the name of the file in the archive."""
        if not isinstance(zinfo_or_arcname, ZipInfo):
            zinfo = ZipInfo(filename=zinfo_or_arcname,
                            date_time=time.localtime(time.time())[:6])

zinfo.compress_type = self.compression
            if zinfo.filename[-1] == '/':
                zinfo.external_attr = 0o40775 << 16   # drwxrwxr-x
                zinfo.external_attr |= 0x10           # MS-DOS directory flag
            else:
                zinfo.external_attr = 0o600 << 16     # ?rw-------
        else:
            zinfo = zinfo_or_arcname

if not self.fp:
            raise RuntimeError(
                  "Attempt to write to ZIP archive that was already closed")

if compress_type is not None:
            zinfo.compress_type = compress_type

zinfo.file_size = len(bytes)            # Uncompressed size
        zinfo.header_offset = self.fp.tell()    # Start of header bytes
        self._writecheck(zinfo)
        self._didModify = True
        zinfo.CRC = crc32(bytes) & 0xffffffff       # CRC-32 checksum
        if zinfo.compress_type == ZIP_DEFLATED:
            co = zlib.compressobj(zlib.Z_DEFAULT_COMPRESSION,
                 zlib.DEFLATED, -15)
            bytes = co.compress(bytes) + co.flush()
            zinfo.compress_size = len(bytes)    # Compressed size
        else:
            zinfo.compress_size = zinfo.file_size
        zip64 = zinfo.file_size > ZIP64_LIMIT or \
                zinfo.compress_size > ZIP64_LIMIT
        if zip64 and not self._allowZip64:
            raise LargeZipFile("Filesize would require ZIP64 extensions")
        self.fp.write(zinfo.FileHeader(zip64))
        self.fp.write(bytes)
        if zinfo.flag_bits & 0x08:
            # Write CRC and file sizes after the file data
            fmt = '<LLQQ' if zip64 else '<LLLL'
            self.fp.write(struct.pack(fmt, _DD_SIGNATURE, zinfo.CRC,
                  zinfo.compress_size, zinfo.file_size))
        self.fp.flush()
        self.filelist.append(zinfo)
        self.NameToInfo[zinfo.filename] = zinfo

def __del__(self):
        """Call the "close()" method in case the user forgot."""
        self.close()

def close(self):
        """Close the file, and for mode "w" and "a" write the ending
        records."""
        if self.fp is None:
            return

try:
            if self.mode in ("w", "a") and self._didModify: # write ending records
                pos1 = self.fp.tell()
                for zinfo in self.filelist:         # write central directory
                    dt = zinfo.date_time
                    dosdate = (dt[0] - 1980) << 9 | dt[1] << 5 | dt[2]
                    dostime = dt[3] << 11 | dt[4] << 5 | (dt[5] // 2)
                    extra = []
                    if zinfo.file_size > ZIP64_LIMIT \
                            or zinfo.compress_size > ZIP64_LIMIT:
                        extra.append(zinfo.file_size)
                        extra.append(zinfo.compress_size)
                        file_size = 0xffffffff
                        compress_size = 0xffffffff
                    else:
                        file_size = zinfo.file_size
                        compress_size = zinfo.compress_size

if zinfo.header_offset > ZIP64_LIMIT:
                        extra.append(zinfo.header_offset)
                        header_offset = 0xffffffffL
                    else:
                        header_offset = zinfo.header_offset

extra_data = zinfo.extra
                    if extra:
                        # Append a ZIP64 field to the extra's
                        extra_data = _strip_extra(extra_data, (1,))
                        extra_data = struct.pack(
                                '<HH' + 'Q'*len(extra),
                                1, 8*len(extra), *extra) + extra_data

extract_version = max(45, zinfo.extract_version)
                        create_version = max(45, zinfo.create_version)
                    else:
                        extract_version = zinfo.extract_version
                        create_version = zinfo.create_version

try:
                        filename, flag_bits = zinfo._encodeFilenameFlags()
                        centdir = struct.pack(structCentralDir,
                        stringCentralDir, create_version,
                        zinfo.create_system, extract_version, zinfo.reserved,
                        flag_bits, zinfo.compress_type, dostime, dosdate,
                        zinfo.CRC, compress_size, file_size,
                        len(filename), len(extra_data), len(zinfo.comment),
                        0, zinfo.internal_attr, zinfo.external_attr,
                        header_offset)
                    except DeprecationWarning:
                        print >>sys.stderr, (structCentralDir,
                        stringCentralDir, create_version,
                        zinfo.create_system, extract_version, zinfo.reserved,
                        zinfo.flag_bits, zinfo.compress_type, dostime, dosdate,
                        zinfo.CRC, compress_size, file_size,
                        len(zinfo.filename), len(extra_data), len(zinfo.comment),
                        0, zinfo.internal_attr, zinfo.external_attr,
                        header_offset)
                        raise
                    self.fp.write(centdir)
                    self.fp.write(filename)
                    self.fp.write(extra_data)
                    self.fp.write(zinfo.comment)

pos2 = self.fp.tell()
                # Write end-of-zip-archive record
                centDirCount = len(self.filelist)
                centDirSize = pos2 - pos1
                centDirOffset = pos1
                requires_zip64 = None
                if centDirCount > ZIP_FILECOUNT_LIMIT:
                    requires_zip64 = "Files count"
                elif centDirOffset > ZIP64_LIMIT:
                    requires_zip64 = "Central directory offset"
                elif centDirSize > ZIP64_LIMIT:
                    requires_zip64 = "Central directory size"
                if requires_zip64:
                    # Need to write the ZIP64 end-of-archive records
                    if not self._allowZip64:
                        raise LargeZipFile(requires_zip64 +
                                           " would require ZIP64 extensions")
                    zip64endrec = struct.pack(
                            structEndArchive64, stringEndArchive64,
                            44, 45, 45, 0, 0, centDirCount, centDirCount,
                            centDirSize, centDirOffset)
                    self.fp.write(zip64endrec)

zip64locrec = struct.pack(
                            structEndArchive64Locator,
                            stringEndArchive64Locator, 0, pos2, 1)
                    self.fp.write(zip64locrec)
                    centDirCount = min(centDirCount, 0xFFFF)
                    centDirSize = min(centDirSize, 0xFFFFFFFF)
                    centDirOffset = min(centDirOffset, 0xFFFFFFFF)

endrec = struct.pack(structEndArchive, stringEndArchive,
                                    0, 0, centDirCount, centDirCount,
                                    centDirSize, centDirOffset, len(self._comment))
                self.fp.write(endrec)
                self.fp.write(self._comment)
                self.fp.flush()
        finally:
            fp = self.fp
            self.fp = None
            if not self._filePassed:
                fp.close()

class PyZipFile(ZipFile):
    """Class to create ZIP archives with Python library files and packages."""

def writepy(self, pathname, basename = ""):
        """Add all files from "pathname" to the ZIP archive.

If pathname is a package directory, search the directory and
        all package subdirectories recursively for all *.py and enter
        the modules into the archive.  If pathname is a plain
        directory, listdir *.py and enter all modules.  Else, pathname
        must be a Python *.py file and the module will be put into the
        archive.  Added modules are always module.pyo or module.pyc.
        This method will compile the module.py into module.pyc if
        necessary.
        """
        dir, name = os.path.split(pathname)
        if os.path.isdir(pathname):
            initname = os.path.join(pathname, "__init__.py")
            if os.path.isfile(initname):
                # This is a package directory, add it
                if basename:
                    basename = "%s/%s" % (basename, name)
                else:
                    basename = name
                if self.debug:
                    print "Adding package in", pathname, "as", basename
                fname, arcname = self._get_codename(initname[0:-3], basename)
                if self.debug:
                    print "Adding", arcname
                self.write(fname, arcname)
                dirlist = os.listdir(pathname)
                dirlist.remove("__init__.py")
                # Add all *.py files and package subdirectories
                for filename in dirlist:
                    path = os.path.join(pathname, filename)
                    root, ext = os.path.splitext(filename)
                    if os.path.isdir(path):
                        if os.path.isfile(os.path.join(path, "__init__.py")):
                            # This is a package directory, add it
                            self.writepy(path, basename)  # Recursive call
                    elif ext == ".py":
                        fname, arcname = self._get_codename(path[0:-3],
                                         basename)
                        if self.debug:
                            print "Adding", arcname
                        self.write(fname, arcname)
            else:
                # This is NOT a package directory, add its files at top level
                if self.debug:
                    print "Adding files from directory", pathname
                for filename in os.listdir(pathname):
                    path = os.path.join(pathname, filename)
                    root, ext = os.path.splitext(filename)
                    if ext == ".py":
                        fname, arcname = self._get_codename(path[0:-3],
                                         basename)
                        if self.debug:
                            print "Adding", arcname
                        self.write(fname, arcname)
        else:
            if pathname[-3:] != ".py":
                raise RuntimeError, \
                      'Files added with writepy() must end with ".py"'
            fname, arcname = self._get_codename(pathname[0:-3], basename)
            if self.debug:
                print "Adding file", arcname
            self.write(fname, arcname)

def _get_codename(self, pathname, basename):
        """Return (filename, archivename) for the path.

Given a module name path, return the correct file path and
        archive name, compiling if necessary.  For example, given
        /python/lib/string, return (/python/lib/string.pyc, string).
        """
        file_py  = pathname + ".py"
        file_pyc = pathname + ".pyc"
        file_pyo = pathname + ".pyo"
        if os.path.isfile(file_pyo) and \
                            os.stat(file_pyo).st_mtime >= os.stat(file_py).st_mtime:
            fname = file_pyo    # Use .pyo file
        elif not os.path.isfile(file_pyc) or \
             os.stat(file_pyc).st_mtime < os.stat(file_py).st_mtime:
            import py_compile
            if self.debug:
                print "Compiling", file_py
            try:
                py_compile.compile(file_py, file_pyc, None, True)
            except py_compile.PyCompileError,err:
                print err.msg
            fname = file_pyc
        else:
            fname = file_pyc
        archivename = os.path.split(fname)[1]
        if basename:
            archivename = "%s/%s" % (basename, archivename)
        return (fname, archivename)

def main(args = None):
    import textwrap
    USAGE=textwrap.dedent("""\
        Usage:
            zipfile.py -l zipfile.zip        # Show listing of a zipfile
            zipfile.py -t zipfile.zip        # Test if a zipfile is valid
            zipfile.py -e zipfile.zip target # Extract zipfile into target dir
            zipfile.py -c zipfile.zip src ... # Create zipfile from sources
        """)
    if args is None:
        args = sys.argv[1:]

if not args or args[0] not in ('-l', '-c', '-e', '-t'):
        print USAGE
        sys.exit(1)

if args[0] == '-l':
        if len(args) != 2:
            print USAGE
            sys.exit(1)
        with ZipFile(args[1], 'r') as zf:
            zf.printdir()

elif args[0] == '-t':
        if len(args) != 2:
            print USAGE
            sys.exit(1)
        with ZipFile(args[1], 'r') as zf:
            badfile = zf.testzip()
        if badfile:
            print("The following enclosed file is corrupted: {!r}".format(badfile))
        print "Done testing"

elif args[0] == '-e':
        if len(args) != 3:
            print USAGE
            sys.exit(1)

with ZipFile(args[1], 'r') as zf:
            zf.extractall(args[2])

elif args[0] == '-c':
        if len(args) < 3:
            print USAGE
            sys.exit(1)

def addToZip(zf, path, zippath):
            if os.path.isfile(path):
                zf.write(path, zippath, ZIP_DEFLATED)
            elif os.path.isdir(path):
                if zippath:
                    zf.write(path, zippath)
                for nm in os.listdir(path):
                    addToZip(zf,
                            os.path.join(path, nm), os.path.join(zippath, nm))
            # else: ignore

with ZipFile(args[1], 'w', allowZip64=True) as zf:
            for path in args[2:]:
                zippath = os.path.basename(path)
                if not zippath:
                    zippath = os.path.basename(os.path.dirname(path))
                if zippath in ('', os.curdir, os.pardir):
                    zippath = ''
                addToZip(zf, path, zippath)

if __name__ == "__main__":
    main()

cmd: