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	65486	0644	edit dl rm
cookielib.pyc	55986	0644	edit dl rm
cookielib.pyo	55798	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	10768	0644	edit dl rm
DocXMLRPCServer.pyc	10442	0644	edit dl rm
DocXMLRPCServer.pyo	10333	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	52300	0644	edit dl rm
httplib.pyc	38793	0644	edit dl rm
httplib.pyo	38609	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	17280	0644	edit dl rm
textwrap.pyc	12279	0644	edit dl rm
textwrap.pyo	12187	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	47282	0644	edit dl rm
threading.pyc	43999	0644	edit dl rm
threading.pyo	41825	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	60228	0644	edit dl rm
urllib.pyc	52580	0644	edit dl rm
urllib.pyo	52485	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	16678	0644	edit dl rm
urlparse.pyc	15886	0644	edit dl rm
urlparse.pyo	15886	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	6694	0755	edit dl rm
uu.pyc	4455	0644	edit dl rm
uu.pyo	4455	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	3388	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	19182	0644	edit dl rm
_sysconfigdata.pyc	22361	0644	edit dl rm
_sysconfigdata.pyo	22361	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/argparse.py (89228B)

# Author: Steven J. Bethard <steven.bethard@gmail.com>.

"""Command-line parsing library

This module is an optparse-inspired command-line parsing library that:

- handles both optional and positional arguments
    - produces highly informative usage messages
    - supports parsers that dispatch to sub-parsers

The following is a simple usage example that sums integers from the
command-line and writes the result to a file::

parser = argparse.ArgumentParser(
        description='sum the integers at the command line')
    parser.add_argument(
        'integers', metavar='int', nargs='+', type=int,
        help='an integer to be summed')
    parser.add_argument(
        '--log', default=sys.stdout, type=argparse.FileType('w'),
        help='the file where the sum should be written')
    args = parser.parse_args()
    args.log.write('%s' % sum(args.integers))
    args.log.close()

The module contains the following public classes:

- ArgumentParser -- The main entry point for command-line parsing. As the
        example above shows, the add_argument() method is used to populate
        the parser with actions for optional and positional arguments. Then
        the parse_args() method is invoked to convert the args at the
        command-line into an object with attributes.

- ArgumentError -- The exception raised by ArgumentParser objects when
        there are errors with the parser's actions. Errors raised while
        parsing the command-line are caught by ArgumentParser and emitted
        as command-line messages.

- FileType -- A factory for defining types of files to be created. As the
        example above shows, instances of FileType are typically passed as
        the type= argument of add_argument() calls.

- Action -- The base class for parser actions. Typically actions are
        selected by passing strings like 'store_true' or 'append_const' to
        the action= argument of add_argument(). However, for greater
        customization of ArgumentParser actions, subclasses of Action may
        be defined and passed as the action= argument.

- HelpFormatter, RawDescriptionHelpFormatter, RawTextHelpFormatter,
        ArgumentDefaultsHelpFormatter -- Formatter classes which
        may be passed as the formatter_class= argument to the
        ArgumentParser constructor. HelpFormatter is the default,
        RawDescriptionHelpFormatter and RawTextHelpFormatter tell the parser
        not to change the formatting for help text, and
        ArgumentDefaultsHelpFormatter adds information about argument defaults
        to the help.

All other classes in this module are considered implementation details.
(Also note that HelpFormatter and RawDescriptionHelpFormatter are only
considered public as object names -- the API of the formatter objects is
still considered an implementation detail.)
"""

__version__ = '1.1'
__all__ = [
    'ArgumentParser',
    'ArgumentError',
    'ArgumentTypeError',
    'FileType',
    'HelpFormatter',
    'ArgumentDefaultsHelpFormatter',
    'RawDescriptionHelpFormatter',
    'RawTextHelpFormatter',
    'Namespace',
    'Action',
    'ONE_OR_MORE',
    'OPTIONAL',
    'PARSER',
    'REMAINDER',
    'SUPPRESS',
    'ZERO_OR_MORE',
]

import collections as _collections
import copy as _copy
import os as _os
import re as _re
import sys as _sys
import textwrap as _textwrap

from gettext import gettext as _

def _callable(obj):
    return hasattr(obj, '__call__') or hasattr(obj, '__bases__')

SUPPRESS = '==SUPPRESS=='

OPTIONAL = '?'
ZERO_OR_MORE = '*'
ONE_OR_MORE = '+'
PARSER = 'A...'
REMAINDER = '...'
_UNRECOGNIZED_ARGS_ATTR = '_unrecognized_args'

# =============================
# Utility functions and classes
# =============================

class _AttributeHolder(object):
    """Abstract base class that provides __repr__.

The __repr__ method returns a string in the format::
        ClassName(attr=name, attr=name, ...)
    The attributes are determined either by a class-level attribute,
    '_kwarg_names', or by inspecting the instance __dict__.
    """

def __repr__(self):
        type_name = type(self).__name__
        arg_strings = []
        for arg in self._get_args():
            arg_strings.append(repr(arg))
        for name, value in self._get_kwargs():
            arg_strings.append('%s=%r' % (name, value))
        return '%s(%s)' % (type_name, ', '.join(arg_strings))

def _get_kwargs(self):
        return sorted(self.__dict__.items())

def _get_args(self):
        return []

def _ensure_value(namespace, name, value):
    if getattr(namespace, name, None) is None:
        setattr(namespace, name, value)
    return getattr(namespace, name)

# ===============
# Formatting Help
# ===============

class HelpFormatter(object):
    """Formatter for generating usage messages and argument help strings.

Only the name of this class is considered a public API. All the methods
    provided by the class are considered an implementation detail.
    """

def __init__(self,
                 prog,
                 indent_increment=2,
                 max_help_position=24,
                 width=None):

# default setting for width
        if width is None:
            try:
                width = int(_os.environ['COLUMNS'])
            except (KeyError, ValueError):
                width = 80
            width -= 2

self._prog = prog
        self._indent_increment = indent_increment
        self._max_help_position = max_help_position
        self._max_help_position = min(max_help_position,
                                      max(width - 20, indent_increment * 2))
        self._width = width

self._current_indent = 0
        self._level = 0
        self._action_max_length = 0

self._root_section = self._Section(self, None)
        self._current_section = self._root_section

self._whitespace_matcher = _re.compile(r'\s+')
        self._long_break_matcher = _re.compile(r'\n\n\n+')

# ===============================
    # Section and indentation methods
    # ===============================
    def _indent(self):
        self._current_indent += self._indent_increment
        self._level += 1

def _dedent(self):
        self._current_indent -= self._indent_increment
        assert self._current_indent >= 0, 'Indent decreased below 0.'
        self._level -= 1

class _Section(object):

def __init__(self, formatter, parent, heading=None):
            self.formatter = formatter
            self.parent = parent
            self.heading = heading
            self.items = []

def format_help(self):
            # format the indented section
            if self.parent is not None:
                self.formatter._indent()
            join = self.formatter._join_parts
            for func, args in self.items:
                func(*args)
            item_help = join([func(*args) for func, args in self.items])
            if self.parent is not None:
                self.formatter._dedent()

# return nothing if the section was empty
            if not item_help:
                return ''

# add the heading if the section was non-empty
            if self.heading is not SUPPRESS and self.heading is not None:
                current_indent = self.formatter._current_indent
                heading = '%*s%s:\n' % (current_indent, '', self.heading)
            else:
                heading = ''

# join the section-initial newline, the heading and the help
            return join(['\n', heading, item_help, '\n'])

def _add_item(self, func, args):
        self._current_section.items.append((func, args))

# ========================
    # Message building methods
    # ========================
    def start_section(self, heading):
        self._indent()
        section = self._Section(self, self._current_section, heading)
        self._add_item(section.format_help, [])
        self._current_section = section

def end_section(self):
        self._current_section = self._current_section.parent
        self._dedent()

def add_text(self, text):
        if text is not SUPPRESS and text is not None:
            self._add_item(self._format_text, [text])

def add_usage(self, usage, actions, groups, prefix=None):
        if usage is not SUPPRESS:
            args = usage, actions, groups, prefix
            self._add_item(self._format_usage, args)

def add_argument(self, action):
        if action.help is not SUPPRESS:

# find all invocations
            get_invocation = self._format_action_invocation
            invocations = [get_invocation(action)]
            for subaction in self._iter_indented_subactions(action):
                invocations.append(get_invocation(subaction))

# update the maximum item length
            invocation_length = max([len(s) for s in invocations])
            action_length = invocation_length + self._current_indent
            self._action_max_length = max(self._action_max_length,
                                          action_length)

# add the item to the list
            self._add_item(self._format_action, [action])

def add_arguments(self, actions):
        for action in actions:
            self.add_argument(action)

# =======================
    # Help-formatting methods
    # =======================
    def format_help(self):
        help = self._root_section.format_help()
        if help:
            help = self._long_break_matcher.sub('\n\n', help)
            help = help.strip('\n') + '\n'
        return help

def _join_parts(self, part_strings):
        return ''.join([part
                        for part in part_strings
                        if part and part is not SUPPRESS])

def _format_usage(self, usage, actions, groups, prefix):
        if prefix is None:
            prefix = _('usage: ')

# if usage is specified, use that
        if usage is not None:
            usage = usage % dict(prog=self._prog)

# if no optionals or positionals are available, usage is just prog
        elif usage is None and not actions:
            usage = '%(prog)s' % dict(prog=self._prog)

# if optionals and positionals are available, calculate usage
        elif usage is None:
            prog = '%(prog)s' % dict(prog=self._prog)

# split optionals from positionals
            optionals = []
            positionals = []
            for action in actions:
                if action.option_strings:
                    optionals.append(action)
                else:
                    positionals.append(action)

# build full usage string
            format = self._format_actions_usage
            action_usage = format(optionals + positionals, groups)
            usage = ' '.join([s for s in [prog, action_usage] if s])

# wrap the usage parts if it's too long
            text_width = self._width - self._current_indent
            if len(prefix) + len(usage) > text_width:

# break usage into wrappable parts
                part_regexp = (
                    r'$.*?$+(?=\s|$)|'
                    r'\[.*?\]+(?=\s|$)|'
                    r'\S+'
                )
                opt_usage = format(optionals, groups)
                pos_usage = format(positionals, groups)
                opt_parts = _re.findall(part_regexp, opt_usage)
                pos_parts = _re.findall(part_regexp, pos_usage)
                assert ' '.join(opt_parts) == opt_usage
                assert ' '.join(pos_parts) == pos_usage

# helper for wrapping lines
                def get_lines(parts, indent, prefix=None):
                    lines = []
                    line = []
                    if prefix is not None:
                        line_len = len(prefix) - 1
                    else:
                        line_len = len(indent) - 1
                    for part in parts:
                        if line_len + 1 + len(part) > text_width and line:
                            lines.append(indent + ' '.join(line))
                            line = []
                            line_len = len(indent) - 1
                        line.append(part)
                        line_len += len(part) + 1
                    if line:
                        lines.append(indent + ' '.join(line))
                    if prefix is not None:
                        lines[0] = lines[0][len(indent):]
                    return lines

# if prog is short, follow it with optionals or positionals
                if len(prefix) + len(prog) <= 0.75 * text_width:
                    indent = ' ' * (len(prefix) + len(prog) + 1)
                    if opt_parts:
                        lines = get_lines([prog] + opt_parts, indent, prefix)
                        lines.extend(get_lines(pos_parts, indent))
                    elif pos_parts:
                        lines = get_lines([prog] + pos_parts, indent, prefix)
                    else:
                        lines = [prog]

# if prog is long, put it on its own line
                else:
                    indent = ' ' * len(prefix)
                    parts = opt_parts + pos_parts
                    lines = get_lines(parts, indent)
                    if len(lines) > 1:
                        lines = []
                        lines.extend(get_lines(opt_parts, indent))
                        lines.extend(get_lines(pos_parts, indent))
                    lines = [prog] + lines

# join lines into usage
                usage = '\n'.join(lines)

# prefix with 'usage:'
        return '%s%s\n\n' % (prefix, usage)

def _format_actions_usage(self, actions, groups):
        # find group indices and identify actions in groups
        group_actions = set()
        inserts = {}
        for group in groups:
            try:
                start = actions.index(group._group_actions[0])
            except ValueError:
                continue
            else:
                end = start + len(group._group_actions)
                if actions[start:end] == group._group_actions:
                    for action in group._group_actions:
                        group_actions.add(action)
                    if not group.required:
                        if start in inserts:
                            inserts[start] += ' ['
                        else:
                            inserts[start] = '['
                        inserts[end] = ']'
                    else:
                        if start in inserts:
                            inserts[start] += ' ('
                        else:
                            inserts[start] = '('
                        inserts[end] = ')'
                    for i in range(start + 1, end):
                        inserts[i] = '|'

# collect all actions format strings
        parts = []
        for i, action in enumerate(actions):

# suppressed arguments are marked with None
            # remove | separators for suppressed arguments
            if action.help is SUPPRESS:
                parts.append(None)
                if inserts.get(i) == '|':
                    inserts.pop(i)
                elif inserts.get(i + 1) == '|':
                    inserts.pop(i + 1)

# produce all arg strings
            elif not action.option_strings:
                part = self._format_args(action, action.dest)

# if it's in a group, strip the outer []
                if action in group_actions:
                    if part[0] == '[' and part[-1] == ']':
                        part = part[1:-1]

# add the action string to the list
                parts.append(part)

# produce the first way to invoke the option in brackets
            else:
                option_string = action.option_strings[0]

# if the Optional doesn't take a value, format is:
                #    -s or --long
                if action.nargs == 0:
                    part = '%s' % option_string

# if the Optional takes a value, format is:
                #    -s ARGS or --long ARGS
                else:
                    default = action.dest.upper()
                    args_string = self._format_args(action, default)
                    part = '%s %s' % (option_string, args_string)

# make it look optional if it's not required or in a group
                if not action.required and action not in group_actions:
                    part = '[%s]' % part

# add the action string to the list
                parts.append(part)

# insert things at the necessary indices
        for i in sorted(inserts, reverse=True):
            parts[i:i] = [inserts[i]]

# join all the action items with spaces
        text = ' '.join([item for item in parts if item is not None])

# clean up separators for mutually exclusive groups
        open = r'[\[(]'
        close = r'[\])]'
        text = _re.sub(r'(%s) ' % open, r'\1', text)
        text = _re.sub(r' (%s)' % close, r'\1', text)
        text = _re.sub(r'%s *%s' % (open, close), r'', text)
        text = _re.sub(r'$([^|]*)$', r'\1', text)
        text = text.strip()

# return the text
        return text

def _format_text(self, text):
        if '%(prog)' in text:
            text = text % dict(prog=self._prog)
        text_width = max(self._width - self._current_indent, 11)
        indent = ' ' * self._current_indent
        return self._fill_text(text, text_width, indent) + '\n\n'

def _format_action(self, action):
        # determine the required width and the entry label
        help_position = min(self._action_max_length + 2,
                            self._max_help_position)
        help_width = max(self._width - help_position, 11)
        action_width = help_position - self._current_indent - 2
        action_header = self._format_action_invocation(action)

# ho nelp; start on same line and add a final newline
        if not action.help:
            tup = self._current_indent, '', action_header
            action_header = '%*s%s\n' % tup

# short action name; start on the same line and pad two spaces
        elif len(action_header) <= action_width:
            tup = self._current_indent, '', action_width, action_header
            action_header = '%*s%-*s  ' % tup
            indent_first = 0

# long action name; start on the next line
        else:
            tup = self._current_indent, '', action_header
            action_header = '%*s%s\n' % tup
            indent_first = help_position

# collect the pieces of the action help
        parts = [action_header]

# if there was help for the action, add lines of help text
        if action.help:
            help_text = self._expand_help(action)
            help_lines = self._split_lines(help_text, help_width)
            parts.append('%*s%s\n' % (indent_first, '', help_lines[0]))
            for line in help_lines[1:]:
                parts.append('%*s%s\n' % (help_position, '', line))

# or add a newline if the description doesn't end with one
        elif not action_header.endswith('\n'):
            parts.append('\n')

# if there are any sub-actions, add their help as well
        for subaction in self._iter_indented_subactions(action):
            parts.append(self._format_action(subaction))

# return a single string
        return self._join_parts(parts)

def _format_action_invocation(self, action):
        if not action.option_strings:
            metavar, = self._metavar_formatter(action, action.dest)(1)
            return metavar

else:
            parts = []

# if the Optional doesn't take a value, format is:
            #    -s, --long
            if action.nargs == 0:
                parts.extend(action.option_strings)

# if the Optional takes a value, format is:
            #    -s ARGS, --long ARGS
            else:
                default = action.dest.upper()
                args_string = self._format_args(action, default)
                for option_string in action.option_strings:
                    parts.append('%s %s' % (option_string, args_string))

return ', '.join(parts)

def _metavar_formatter(self, action, default_metavar):
        if action.metavar is not None:
            result = action.metavar
        elif action.choices is not None:
            choice_strs = [str(choice) for choice in action.choices]
            result = '{%s}' % ','.join(choice_strs)
        else:
            result = default_metavar

def format(tuple_size):
            if isinstance(result, tuple):
                return result
            else:
                return (result, ) * tuple_size
        return format

def _format_args(self, action, default_metavar):
        get_metavar = self._metavar_formatter(action, default_metavar)
        if action.nargs is None:
            result = '%s' % get_metavar(1)
        elif action.nargs == OPTIONAL:
            result = '[%s]' % get_metavar(1)
        elif action.nargs == ZERO_OR_MORE:
            result = '[%s [%s ...]]' % get_metavar(2)
        elif action.nargs == ONE_OR_MORE:
            result = '%s [%s ...]' % get_metavar(2)
        elif action.nargs == REMAINDER:
            result = '...'
        elif action.nargs == PARSER:
            result = '%s ...' % get_metavar(1)
        else:
            formats = ['%s' for _ in range(action.nargs)]
            result = ' '.join(formats) % get_metavar(action.nargs)
        return result

def _expand_help(self, action):
        params = dict(vars(action), prog=self._prog)
        for name in list(params):
            if params[name] is SUPPRESS:
                del params[name]
        for name in list(params):
            if hasattr(params[name], '__name__'):
                params[name] = params[name].__name__
        if params.get('choices') is not None:
            choices_str = ', '.join([str(c) for c in params['choices']])
            params['choices'] = choices_str
        return self._get_help_string(action) % params

def _iter_indented_subactions(self, action):
        try:
            get_subactions = action._get_subactions
        except AttributeError:
            pass
        else:
            self._indent()
            for subaction in get_subactions():
                yield subaction
            self._dedent()

def _split_lines(self, text, width):
        text = self._whitespace_matcher.sub(' ', text).strip()
        return _textwrap.wrap(text, width)

def _fill_text(self, text, width, indent):
        text = self._whitespace_matcher.sub(' ', text).strip()
        return _textwrap.fill(text, width, initial_indent=indent,
                                           subsequent_indent=indent)

def _get_help_string(self, action):
        return action.help

class RawDescriptionHelpFormatter(HelpFormatter):
    """Help message formatter which retains any formatting in descriptions.

Only the name of this class is considered a public API. All the methods
    provided by the class are considered an implementation detail.
    """

def _fill_text(self, text, width, indent):
        return ''.join([indent + line for line in text.splitlines(True)])

class RawTextHelpFormatter(RawDescriptionHelpFormatter):
    """Help message formatter which retains formatting of all help text.

Only the name of this class is considered a public API. All the methods
    provided by the class are considered an implementation detail.
    """

def _split_lines(self, text, width):
        return text.splitlines()

class ArgumentDefaultsHelpFormatter(HelpFormatter):
    """Help message formatter which adds default values to argument help.

Only the name of this class is considered a public API. All the methods
    provided by the class are considered an implementation detail.
    """

def _get_help_string(self, action):
        help = action.help
        if '%(default)' not in action.help:
            if action.default is not SUPPRESS:
                defaulting_nargs = [OPTIONAL, ZERO_OR_MORE]
                if action.option_strings or action.nargs in defaulting_nargs:
                    help += ' (default: %(default)s)'
        return help

# =====================
# Options and Arguments
# =====================

def _get_action_name(argument):
    if argument is None:
        return None
    elif argument.option_strings:
        return  '/'.join(argument.option_strings)
    elif argument.metavar not in (None, SUPPRESS):
        return argument.metavar
    elif argument.dest not in (None, SUPPRESS):
        return argument.dest
    else:
        return None

class ArgumentError(Exception):
    """An error from creating or using an argument (optional or positional).

The string value of this exception is the message, augmented with
    information about the argument that caused it.
    """

def __init__(self, argument, message):
        self.argument_name = _get_action_name(argument)
        self.message = message

def __str__(self):
        if self.argument_name is None:
            format = '%(message)s'
        else:
            format = 'argument %(argument_name)s: %(message)s'
        return format % dict(message=self.message,
                             argument_name=self.argument_name)

class ArgumentTypeError(Exception):
    """An error from trying to convert a command line string to a type."""
    pass

# ==============
# Action classes
# ==============

class Action(_AttributeHolder):
    """Information about how to convert command line strings to Python objects.

Action objects are used by an ArgumentParser to represent the information
    needed to parse a single argument from one or more strings from the
    command line. The keyword arguments to the Action constructor are also
    all attributes of Action instances.

Keyword Arguments:

- option_strings -- A list of command-line option strings which
            should be associated with this action.

- dest -- The name of the attribute to hold the created object(s)

- nargs -- The number of command-line arguments that should be
            consumed. By default, one argument will be consumed and a single
            value will be produced.  Other values include:
                - N (an integer) consumes N arguments (and produces a list)
                - '?' consumes zero or one arguments
                - '*' consumes zero or more arguments (and produces a list)
                - '+' consumes one or more arguments (and produces a list)
            Note that the difference between the default and nargs=1 is that
            with the default, a single value will be produced, while with
            nargs=1, a list containing a single value will be produced.

- const -- The value to be produced if the option is specified and the
            option uses an action that takes no values.

- default -- The value to be produced if the option is not specified.

- type -- A callable that accepts a single string argument, and
            returns the converted value.  The standard Python types str, int,
            float, and complex are useful examples of such callables.  If None,
            str is used.

- choices -- A container of values that should be allowed. If not None,
            after a command-line argument has been converted to the appropriate
            type, an exception will be raised if it is not a member of this
            collection.

- required -- True if the action must always be specified at the
            command line. This is only meaningful for optional command-line
            arguments.

- help -- The help string describing the argument.

- metavar -- The name to be used for the option's argument with the
            help string. If None, the 'dest' value will be used as the name.
    """

def __init__(self,
                 option_strings,
                 dest,
                 nargs=None,
                 const=None,
                 default=None,
                 type=None,
                 choices=None,
                 required=False,
                 help=None,
                 metavar=None):
        self.option_strings = option_strings
        self.dest = dest
        self.nargs = nargs
        self.const = const
        self.default = default
        self.type = type
        self.choices = choices
        self.required = required
        self.help = help
        self.metavar = metavar

def _get_kwargs(self):
        names = [
            'option_strings',
            'dest',
            'nargs',
            'const',
            'default',
            'type',
            'choices',
            'help',
            'metavar',
        ]
        return [(name, getattr(self, name)) for name in names]

def __call__(self, parser, namespace, values, option_string=None):
        raise NotImplementedError(_('.__call__() not defined'))

class _StoreAction(Action):

def __init__(self,
                 option_strings,
                 dest,
                 nargs=None,
                 const=None,
                 default=None,
                 type=None,
                 choices=None,
                 required=False,
                 help=None,
                 metavar=None):
        if nargs == 0:
            raise ValueError('nargs for store actions must be > 0; if you '
                             'have nothing to store, actions such as store '
                             'true or store const may be more appropriate')
        if const is not None and nargs != OPTIONAL:
            raise ValueError('nargs must be %r to supply const' % OPTIONAL)
        super(_StoreAction, self).__init__(
            option_strings=option_strings,
            dest=dest,
            nargs=nargs,
            const=const,
            default=default,
            type=type,
            choices=choices,
            required=required,
            help=help,
            metavar=metavar)

def __call__(self, parser, namespace, values, option_string=None):
        setattr(namespace, self.dest, values)

class _StoreConstAction(Action):

def __init__(self,
                 option_strings,
                 dest,
                 const,
                 default=None,
                 required=False,
                 help=None,
                 metavar=None):
        super(_StoreConstAction, self).__init__(
            option_strings=option_strings,
            dest=dest,
            nargs=0,
            const=const,
            default=default,
            required=required,
            help=help)

def __call__(self, parser, namespace, values, option_string=None):
        setattr(namespace, self.dest, self.const)

class _StoreTrueAction(_StoreConstAction):

def __init__(self,
                 option_strings,
                 dest,
                 default=False,
                 required=False,
                 help=None):
        super(_StoreTrueAction, self).__init__(
            option_strings=option_strings,
            dest=dest,
            const=True,
            default=default,
            required=required,
            help=help)

class _StoreFalseAction(_StoreConstAction):

def __init__(self,
                 option_strings,
                 dest,
                 default=True,
                 required=False,
                 help=None):
        super(_StoreFalseAction, self).__init__(
            option_strings=option_strings,
            dest=dest,
            const=False,
            default=default,
            required=required,
            help=help)

class _AppendAction(Action):

def __init__(self,
                 option_strings,
                 dest,
                 nargs=None,
                 const=None,
                 default=None,
                 type=None,
                 choices=None,
                 required=False,
                 help=None,
                 metavar=None):
        if nargs == 0:
            raise ValueError('nargs for append actions must be > 0; if arg '
                             'strings are not supplying the value to append, '
                             'the append const action may be more appropriate')
        if const is not None and nargs != OPTIONAL:
            raise ValueError('nargs must be %r to supply const' % OPTIONAL)
        super(_AppendAction, self).__init__(
            option_strings=option_strings,
            dest=dest,
            nargs=nargs,
            const=const,
            default=default,
            type=type,
            choices=choices,
            required=required,
            help=help,
            metavar=metavar)

def __call__(self, parser, namespace, values, option_string=None):
        items = _copy.copy(_ensure_value(namespace, self.dest, []))
        items.append(values)
        setattr(namespace, self.dest, items)

class _AppendConstAction(Action):

def __init__(self,
                 option_strings,
                 dest,
                 const,
                 default=None,
                 required=False,
                 help=None,
                 metavar=None):
        super(_AppendConstAction, self).__init__(
            option_strings=option_strings,
            dest=dest,
            nargs=0,
            const=const,
            default=default,
            required=required,
            help=help,
            metavar=metavar)

def __call__(self, parser, namespace, values, option_string=None):
        items = _copy.copy(_ensure_value(namespace, self.dest, []))
        items.append(self.const)
        setattr(namespace, self.dest, items)

class _CountAction(Action):

def __init__(self,
                 option_strings,
                 dest,
                 default=None,
                 required=False,
                 help=None):
        super(_CountAction, self).__init__(
            option_strings=option_strings,
            dest=dest,
            nargs=0,
            default=default,
            required=required,
            help=help)

def __call__(self, parser, namespace, values, option_string=None):
        new_count = _ensure_value(namespace, self.dest, 0) + 1
        setattr(namespace, self.dest, new_count)

class _HelpAction(Action):

def __init__(self,
                 option_strings,
                 dest=SUPPRESS,
                 default=SUPPRESS,
                 help=None):
        super(_HelpAction, self).__init__(
            option_strings=option_strings,
            dest=dest,
            default=default,
            nargs=0,
            help=help)

def __call__(self, parser, namespace, values, option_string=None):
        parser.print_help()
        parser.exit()

class _VersionAction(Action):

def __init__(self,
                 option_strings,
                 version=None,
                 dest=SUPPRESS,
                 default=SUPPRESS,
                 help="show program's version number and exit"):
        super(_VersionAction, self).__init__(
            option_strings=option_strings,
            dest=dest,
            default=default,
            nargs=0,
            help=help)
        self.version = version

def __call__(self, parser, namespace, values, option_string=None):
        version = self.version
        if version is None:
            version = parser.version
        formatter = parser._get_formatter()
        formatter.add_text(version)
        parser.exit(message=formatter.format_help())

class _SubParsersAction(Action):

class _ChoicesPseudoAction(Action):

def __init__(self, name, help):
            sup = super(_SubParsersAction._ChoicesPseudoAction, self)
            sup.__init__(option_strings=[], dest=name, help=help)

def __init__(self,
                 option_strings,
                 prog,
                 parser_class,
                 dest=SUPPRESS,
                 help=None,
                 metavar=None):

self._prog_prefix = prog
        self._parser_class = parser_class
        self._name_parser_map = _collections.OrderedDict()
        self._choices_actions = []

super(_SubParsersAction, self).__init__(
            option_strings=option_strings,
            dest=dest,
            nargs=PARSER,
            choices=self._name_parser_map,
            help=help,
            metavar=metavar)

def add_parser(self, name, **kwargs):
        # set prog from the existing prefix
        if kwargs.get('prog') is None:
            kwargs['prog'] = '%s %s' % (self._prog_prefix, name)

# create a pseudo-action to hold the choice help
        if 'help' in kwargs:
            help = kwargs.pop('help')
            choice_action = self._ChoicesPseudoAction(name, help)
            self._choices_actions.append(choice_action)

# create the parser and add it to the map
        parser = self._parser_class(**kwargs)
        self._name_parser_map[name] = parser
        return parser

def _get_subactions(self):
        return self._choices_actions

def __call__(self, parser, namespace, values, option_string=None):
        parser_name = values[0]
        arg_strings = values[1:]

# set the parser name if requested
        if self.dest is not SUPPRESS:
            setattr(namespace, self.dest, parser_name)

# select the parser
        try:
            parser = self._name_parser_map[parser_name]
        except KeyError:
            tup = parser_name, ', '.join(self._name_parser_map)
            msg = _('unknown parser %r (choices: %s)') % tup
            raise ArgumentError(self, msg)

# parse all the remaining options into the namespace
        # store any unrecognized options on the object, so that the top
        # level parser can decide what to do with them

# In case this subparser defines new defaults, we parse them
        # in a new namespace object and then update the original
        # namespace for the relevant parts.
        subnamespace, arg_strings = parser.parse_known_args(arg_strings, None)
        for key, value in vars(subnamespace).items():
            setattr(namespace, key, value)

if arg_strings:
            vars(namespace).setdefault(_UNRECOGNIZED_ARGS_ATTR, [])
            getattr(namespace, _UNRECOGNIZED_ARGS_ATTR).extend(arg_strings)

# ==============
# Type classes
# ==============

class FileType(object):
    """Factory for creating file object types

Instances of FileType are typically passed as type= arguments to the
    ArgumentParser add_argument() method.

Keyword Arguments:
        - mode -- A string indicating how the file is to be opened. Accepts the
            same values as the builtin open() function.
        - bufsize -- The file's desired buffer size. Accepts the same values as
            the builtin open() function.
    """

def __init__(self, mode='r', bufsize=-1):
        self._mode = mode
        self._bufsize = bufsize

def __call__(self, string):
        # the special argument "-" means sys.std{in,out}
        if string == '-':
            if 'r' in self._mode:
                return _sys.stdin
            elif 'w' in self._mode:
                return _sys.stdout
            else:
                msg = _('argument "-" with mode %r') % self._mode
                raise ValueError(msg)

# all other arguments are used as file names
        try:
            return open(string, self._mode, self._bufsize)
        except IOError as e:
            message = _("can't open '%s': %s")
            raise ArgumentTypeError(message % (string, e))

def __repr__(self):
        args = self._mode, self._bufsize
        args_str = ', '.join(repr(arg) for arg in args if arg != -1)
        return '%s(%s)' % (type(self).__name__, args_str)

# ===========================
# Optional and Positional Parsing
# ===========================

class Namespace(_AttributeHolder):
    """Simple object for storing attributes.

Implements equality by attribute names and values, and provides a simple
    string representation.
    """

def __init__(self, **kwargs):
        for name in kwargs:
            setattr(self, name, kwargs[name])

__hash__ = None

def __eq__(self, other):
        if not isinstance(other, Namespace):
            return NotImplemented
        return vars(self) == vars(other)

def __ne__(self, other):
        if not isinstance(other, Namespace):
            return NotImplemented
        return not (self == other)

def __contains__(self, key):
        return key in self.__dict__

class _ActionsContainer(object):

def __init__(self,
                 description,
                 prefix_chars,
                 argument_default,
                 conflict_handler):
        super(_ActionsContainer, self).__init__()

self.description = description
        self.argument_default = argument_default
        self.prefix_chars = prefix_chars
        self.conflict_handler = conflict_handler

# set up registries
        self._registries = {}

# register actions
        self.register('action', None, _StoreAction)
        self.register('action', 'store', _StoreAction)
        self.register('action', 'store_const', _StoreConstAction)
        self.register('action', 'store_true', _StoreTrueAction)
        self.register('action', 'store_false', _StoreFalseAction)
        self.register('action', 'append', _AppendAction)
        self.register('action', 'append_const', _AppendConstAction)
        self.register('action', 'count', _CountAction)
        self.register('action', 'help', _HelpAction)
        self.register('action', 'version', _VersionAction)
        self.register('action', 'parsers', _SubParsersAction)

# raise an exception if the conflict handler is invalid
        self._get_handler()

# action storage
        self._actions = []
        self._option_string_actions = {}

# groups
        self._action_groups = []
        self._mutually_exclusive_groups = []

# defaults storage
        self._defaults = {}

# determines whether an "option" looks like a negative number
        self._negative_number_matcher = _re.compile(r'^-\d+$|^-\d*\.\d+$')

# whether or not there are any optionals that look like negative
        # numbers -- uses a list so it can be shared and edited
        self._has_negative_number_optionals = []

# ====================
    # Registration methods
    # ====================
    def register(self, registry_name, value, object):
        registry = self._registries.setdefault(registry_name, {})
        registry[value] = object

def _registry_get(self, registry_name, value, default=None):
        return self._registries[registry_name].get(value, default)

# ==================================
    # Namespace default accessor methods
    # ==================================
    def set_defaults(self, **kwargs):
        self._defaults.update(kwargs)

# if these defaults match any existing arguments, replace
        # the previous default on the object with the new one
        for action in self._actions:
            if action.dest in kwargs:
                action.default = kwargs[action.dest]

def get_default(self, dest):
        for action in self._actions:
            if action.dest == dest and action.default is not None:
                return action.default
        return self._defaults.get(dest, None)

# =======================
    # Adding argument actions
    # =======================
    def add_argument(self, *args, **kwargs):
        """
        add_argument(dest, ..., name=value, ...)
        add_argument(option_string, option_string, ..., name=value, ...)
        """

# if no positional args are supplied or only one is supplied and
        # it doesn't look like an option string, parse a positional
        # argument
        chars = self.prefix_chars
        if not args or len(args) == 1 and args[0][0] not in chars:
            if args and 'dest' in kwargs:
                raise ValueError('dest supplied twice for positional argument')
            kwargs = self._get_positional_kwargs(*args, **kwargs)

# otherwise, we're adding an optional argument
        else:
            kwargs = self._get_optional_kwargs(*args, **kwargs)

# if no default was supplied, use the parser-level default
        if 'default' not in kwargs:
            dest = kwargs['dest']
            if dest in self._defaults:
                kwargs['default'] = self._defaults[dest]
            elif self.argument_default is not None:
                kwargs['default'] = self.argument_default

# create the action object, and add it to the parser
        action_class = self._pop_action_class(kwargs)
        if not _callable(action_class):
            raise ValueError('unknown action "%s"' % (action_class,))
        action = action_class(**kwargs)

# raise an error if the action type is not callable
        type_func = self._registry_get('type', action.type, action.type)
        if not _callable(type_func):
            raise ValueError('%r is not callable' % (type_func,))

# raise an error if the metavar does not match the type
        if hasattr(self, "_get_formatter"):
            try:
                self._get_formatter()._format_args(action, None)
            except TypeError:
                raise ValueError("length of metavar tuple does not match nargs")

return self._add_action(action)

def add_argument_group(self, *args, **kwargs):
        group = _ArgumentGroup(self, *args, **kwargs)
        self._action_groups.append(group)
        return group

def add_mutually_exclusive_group(self, **kwargs):
        group = _MutuallyExclusiveGroup(self, **kwargs)
        self._mutually_exclusive_groups.append(group)
        return group

def _add_action(self, action):
        # resolve any conflicts
        self._check_conflict(action)

# add to actions list
        self._actions.append(action)
        action.container = self

# index the action by any option strings it has
        for option_string in action.option_strings:
            self._option_string_actions[option_string] = action

# set the flag if any option strings look like negative numbers
        for option_string in action.option_strings:
            if self._negative_number_matcher.match(option_string):
                if not self._has_negative_number_optionals:
                    self._has_negative_number_optionals.append(True)

# return the created action
        return action

def _remove_action(self, action):
        self._actions.remove(action)

def _add_container_actions(self, container):
        # collect groups by titles
        title_group_map = {}
        for group in self._action_groups:
            if group.title in title_group_map:
                msg = _('cannot merge actions - two groups are named %r')
                raise ValueError(msg % (group.title))
            title_group_map[group.title] = group

# map each action to its group
        group_map = {}
        for group in container._action_groups:

# if a group with the title exists, use that, otherwise
            # create a new group matching the container's group
            if group.title not in title_group_map:
                title_group_map[group.title] = self.add_argument_group(
                    title=group.title,
                    description=group.description,
                    conflict_handler=group.conflict_handler)

# map the actions to their new group
            for action in group._group_actions:
                group_map[action] = title_group_map[group.title]

# add container's mutually exclusive groups
        # NOTE: if add_mutually_exclusive_group ever gains title= and
        # description= then this code will need to be expanded as above
        for group in container._mutually_exclusive_groups:
            mutex_group = self.add_mutually_exclusive_group(
                required=group.required)

# map the actions to their new mutex group
            for action in group._group_actions:
                group_map[action] = mutex_group

# add all actions to this container or their group
        for action in container._actions:
            group_map.get(action, self)._add_action(action)

def _get_positional_kwargs(self, dest, **kwargs):
        # make sure required is not specified
        if 'required' in kwargs:
            msg = _("'required' is an invalid argument for positionals")
            raise TypeError(msg)

# mark positional arguments as required if at least one is
        # always required
        if kwargs.get('nargs') not in [OPTIONAL, ZERO_OR_MORE]:
            kwargs['required'] = True
        if kwargs.get('nargs') == ZERO_OR_MORE and 'default' not in kwargs:
            kwargs['required'] = True

# return the keyword arguments with no option strings
        return dict(kwargs, dest=dest, option_strings=[])

def _get_optional_kwargs(self, *args, **kwargs):
        # determine short and long option strings
        option_strings = []
        long_option_strings = []
        for option_string in args:
            # error on strings that don't start with an appropriate prefix
            if not option_string[0] in self.prefix_chars:
                msg = _('invalid option string %r: '
                        'must start with a character %r')
                tup = option_string, self.prefix_chars
                raise ValueError(msg % tup)

# strings starting with two prefix characters are long options
            option_strings.append(option_string)
            if option_string[0] in self.prefix_chars:
                if len(option_string) > 1:
                    if option_string[1] in self.prefix_chars:
                        long_option_strings.append(option_string)

# infer destination, '--foo-bar' -> 'foo_bar' and '-x' -> 'x'
        dest = kwargs.pop('dest', None)
        if dest is None:
            if long_option_strings:
                dest_option_string = long_option_strings[0]
            else:
                dest_option_string = option_strings[0]
            dest = dest_option_string.lstrip(self.prefix_chars)
            if not dest:
                msg = _('dest= is required for options like %r')
                raise ValueError(msg % option_string)
            dest = dest.replace('-', '_')

# return the updated keyword arguments
        return dict(kwargs, dest=dest, option_strings=option_strings)

def _pop_action_class(self, kwargs, default=None):
        action = kwargs.pop('action', default)
        return self._registry_get('action', action, action)

def _get_handler(self):
        # determine function from conflict handler string
        handler_func_name = '_handle_conflict_%s' % self.conflict_handler
        try:
            return getattr(self, handler_func_name)
        except AttributeError:
            msg = _('invalid conflict_resolution value: %r')
            raise ValueError(msg % self.conflict_handler)

def _check_conflict(self, action):

# find all options that conflict with this option
        confl_optionals = []
        for option_string in action.option_strings:
            if option_string in self._option_string_actions:
                confl_optional = self._option_string_actions[option_string]
                confl_optionals.append((option_string, confl_optional))

# resolve any conflicts
        if confl_optionals:
            conflict_handler = self._get_handler()
            conflict_handler(action, confl_optionals)

def _handle_conflict_error(self, action, conflicting_actions):
        message = _('conflicting option string(s): %s')
        conflict_string = ', '.join([option_string
                                     for option_string, action
                                     in conflicting_actions])
        raise ArgumentError(action, message % conflict_string)

def _handle_conflict_resolve(self, action, conflicting_actions):

# remove all conflicting options
        for option_string, action in conflicting_actions:

# remove the conflicting option
            action.option_strings.remove(option_string)
            self._option_string_actions.pop(option_string, None)

# if the option now has no option string, remove it from the
            # container holding it
            if not action.option_strings:
                action.container._remove_action(action)

class _ArgumentGroup(_ActionsContainer):

def __init__(self, container, title=None, description=None, **kwargs):
        # add any missing keyword arguments by checking the container
        update = kwargs.setdefault
        update('conflict_handler', container.conflict_handler)
        update('prefix_chars', container.prefix_chars)
        update('argument_default', container.argument_default)
        super_init = super(_ArgumentGroup, self).__init__
        super_init(description=description, **kwargs)

# group attributes
        self.title = title
        self._group_actions = []

# share most attributes with the container
        self._registries = container._registries
        self._actions = container._actions
        self._option_string_actions = container._option_string_actions
        self._defaults = container._defaults
        self._has_negative_number_optionals = \
            container._has_negative_number_optionals
        self._mutually_exclusive_groups = container._mutually_exclusive_groups

def _add_action(self, action):
        action = super(_ArgumentGroup, self)._add_action(action)
        self._group_actions.append(action)
        return action

def _remove_action(self, action):
        super(_ArgumentGroup, self)._remove_action(action)
        self._group_actions.remove(action)

class _MutuallyExclusiveGroup(_ArgumentGroup):

def __init__(self, container, required=False):
        super(_MutuallyExclusiveGroup, self).__init__(container)
        self.required = required
        self._container = container

def _add_action(self, action):
        if action.required:
            msg = _('mutually exclusive arguments must be optional')
            raise ValueError(msg)
        action = self._container._add_action(action)
        self._group_actions.append(action)
        return action

def _remove_action(self, action):
        self._container._remove_action(action)
        self._group_actions.remove(action)

class ArgumentParser(_AttributeHolder, _ActionsContainer):
    """Object for parsing command line strings into Python objects.

Keyword Arguments:
        - prog -- The name of the program (default: sys.argv[0])
        - usage -- A usage message (default: auto-generated from arguments)
        - description -- A description of what the program does
        - epilog -- Text following the argument descriptions
        - parents -- Parsers whose arguments should be copied into this one
        - formatter_class -- HelpFormatter class for printing help messages
        - prefix_chars -- Characters that prefix optional arguments
        - fromfile_prefix_chars -- Characters that prefix files containing
            additional arguments
        - argument_default -- The default value for all arguments
        - conflict_handler -- String indicating how to handle conflicts
        - add_help -- Add a -h/-help option
    """

def __init__(self,
                 prog=None,
                 usage=None,
                 description=None,
                 epilog=None,
                 version=None,
                 parents=[],
                 formatter_class=HelpFormatter,
                 prefix_chars='-',
                 fromfile_prefix_chars=None,
                 argument_default=None,
                 conflict_handler='error',
                 add_help=True):

if version is not None:
            import warnings
            warnings.warn(
                """The "version" argument to ArgumentParser is deprecated. """
                """Please use """
                """"add_argument(..., action='version', version="N", ...)" """
                """instead""", DeprecationWarning)

superinit = super(ArgumentParser, self).__init__
        superinit(description=description,
                  prefix_chars=prefix_chars,
                  argument_default=argument_default,
                  conflict_handler=conflict_handler)

# default setting for prog
        if prog is None:
            prog = _os.path.basename(_sys.argv[0])

self.prog = prog
        self.usage = usage
        self.epilog = epilog
        self.version = version
        self.formatter_class = formatter_class
        self.fromfile_prefix_chars = fromfile_prefix_chars
        self.add_help = add_help

add_group = self.add_argument_group
        self._positionals = add_group(_('positional arguments'))
        self._optionals = add_group(_('optional arguments'))
        self._subparsers = None

# register types
        def identity(string):
            return string
        self.register('type', None, identity)

# add help and version arguments if necessary
        # (using explicit default to override global argument_default)
        default_prefix = '-' if '-' in prefix_chars else prefix_chars[0]
        if self.add_help:
            self.add_argument(
                default_prefix+'h', default_prefix*2+'help',
                action='help', default=SUPPRESS,
                help=_('show this help message and exit'))
        if self.version:
            self.add_argument(
                default_prefix+'v', default_prefix*2+'version',
                action='version', default=SUPPRESS,
                version=self.version,
                help=_("show program's version number and exit"))

# add parent arguments and defaults
        for parent in parents:
            self._add_container_actions(parent)
            try:
                defaults = parent._defaults
            except AttributeError:
                pass
            else:
                self._defaults.update(defaults)

# =======================
    # Pretty __repr__ methods
    # =======================
    def _get_kwargs(self):
        names = [
            'prog',
            'usage',
            'description',
            'version',
            'formatter_class',
            'conflict_handler',
            'add_help',
        ]
        return [(name, getattr(self, name)) for name in names]

# ==================================
    # Optional/Positional adding methods
    # ==================================
    def add_subparsers(self, **kwargs):
        if self._subparsers is not None:
            self.error(_('cannot have multiple subparser arguments'))

# add the parser class to the arguments if it's not present
        kwargs.setdefault('parser_class', type(self))

if 'title' in kwargs or 'description' in kwargs:
            title = _(kwargs.pop('title', 'subcommands'))
            description = _(kwargs.pop('description', None))
            self._subparsers = self.add_argument_group(title, description)
        else:
            self._subparsers = self._positionals

# prog defaults to the usage message of this parser, skipping
        # optional arguments and with no "usage:" prefix
        if kwargs.get('prog') is None:
            formatter = self._get_formatter()
            positionals = self._get_positional_actions()
            groups = self._mutually_exclusive_groups
            formatter.add_usage(self.usage, positionals, groups, '')
            kwargs['prog'] = formatter.format_help().strip()

# create the parsers action and add it to the positionals list
        parsers_class = self._pop_action_class(kwargs, 'parsers')
        action = parsers_class(option_strings=[], **kwargs)
        self._subparsers._add_action(action)

# return the created parsers action
        return action

def _add_action(self, action):
        if action.option_strings:
            self._optionals._add_action(action)
        else:
            self._positionals._add_action(action)
        return action

def _get_optional_actions(self):
        return [action
                for action in self._actions
                if action.option_strings]

def _get_positional_actions(self):
        return [action
                for action in self._actions
                if not action.option_strings]

# =====================================
    # Command line argument parsing methods
    # =====================================
    def parse_args(self, args=None, namespace=None):
        args, argv = self.parse_known_args(args, namespace)
        if argv:
            msg = _('unrecognized arguments: %s')
            self.error(msg % ' '.join(argv))
        return args

def parse_known_args(self, args=None, namespace=None):
        if args is None:
            # args default to the system args
            args = _sys.argv[1:]
        else:
            # make sure that args are mutable
            args = list(args)

# default Namespace built from parser defaults
        if namespace is None:
            namespace = Namespace()

# add any action defaults that aren't present
        for action in self._actions:
            if action.dest is not SUPPRESS:
                if not hasattr(namespace, action.dest):
                    if action.default is not SUPPRESS:
                        setattr(namespace, action.dest, action.default)

# add any parser defaults that aren't present
        for dest in self._defaults:
            if not hasattr(namespace, dest):
                setattr(namespace, dest, self._defaults[dest])

# parse the arguments and exit if there are any errors
        try:
            namespace, args = self._parse_known_args(args, namespace)
            if hasattr(namespace, _UNRECOGNIZED_ARGS_ATTR):
                args.extend(getattr(namespace, _UNRECOGNIZED_ARGS_ATTR))
                delattr(namespace, _UNRECOGNIZED_ARGS_ATTR)
            return namespace, args
        except ArgumentError:
            err = _sys.exc_info()[1]
            self.error(str(err))

def _parse_known_args(self, arg_strings, namespace):
        # replace arg strings that are file references
        if self.fromfile_prefix_chars is not None:
            arg_strings = self._read_args_from_files(arg_strings)

# map all mutually exclusive arguments to the other arguments
        # they can't occur with
        action_conflicts = {}
        for mutex_group in self._mutually_exclusive_groups:
            group_actions = mutex_group._group_actions
            for i, mutex_action in enumerate(mutex_group._group_actions):
                conflicts = action_conflicts.setdefault(mutex_action, [])
                conflicts.extend(group_actions[:i])
                conflicts.extend(group_actions[i + 1:])

# find all option indices, and determine the arg_string_pattern
        # which has an 'O' if there is an option at an index,
        # an 'A' if there is an argument, or a '-' if there is a '--'
        option_string_indices = {}
        arg_string_pattern_parts = []
        arg_strings_iter = iter(arg_strings)
        for i, arg_string in enumerate(arg_strings_iter):

# all args after -- are non-options
            if arg_string == '--':
                arg_string_pattern_parts.append('-')
                for arg_string in arg_strings_iter:
                    arg_string_pattern_parts.append('A')

# otherwise, add the arg to the arg strings
            # and note the index if it was an option
            else:
                option_tuple = self._parse_optional(arg_string)
                if option_tuple is None:
                    pattern = 'A'
                else:
                    option_string_indices[i] = option_tuple
                    pattern = 'O'
                arg_string_pattern_parts.append(pattern)

# join the pieces together to form the pattern
        arg_strings_pattern = ''.join(arg_string_pattern_parts)

# converts arg strings to the appropriate and then takes the action
        seen_actions = set()
        seen_non_default_actions = set()

def take_action(action, argument_strings, option_string=None):
            seen_actions.add(action)
            argument_values = self._get_values(action, argument_strings)

# error if this argument is not allowed with other previously
            # seen arguments, assuming that actions that use the default
            # value don't really count as "present"
            if argument_values is not action.default:
                seen_non_default_actions.add(action)
                for conflict_action in action_conflicts.get(action, []):
                    if conflict_action in seen_non_default_actions:
                        msg = _('not allowed with argument %s')
                        action_name = _get_action_name(conflict_action)
                        raise ArgumentError(action, msg % action_name)

# take the action if we didn't receive a SUPPRESS value
            # (e.g. from a default)
            if argument_values is not SUPPRESS:
                action(self, namespace, argument_values, option_string)

# function to convert arg_strings into an optional action
        def consume_optional(start_index):

# get the optional identified at this index
            option_tuple = option_string_indices[start_index]
            action, option_string, explicit_arg = option_tuple

# identify additional optionals in the same arg string
            # (e.g. -xyz is the same as -x -y -z if no args are required)
            match_argument = self._match_argument
            action_tuples = []
            while True:

# if we found no optional action, skip it
                if action is None:
                    extras.append(arg_strings[start_index])
                    return start_index + 1

# if there is an explicit argument, try to match the
                # optional's string arguments to only this
                if explicit_arg is not None:
                    arg_count = match_argument(action, 'A')

# if the action is a single-dash option and takes no
                    # arguments, try to parse more single-dash options out
                    # of the tail of the option string
                    chars = self.prefix_chars
                    if arg_count == 0 and option_string[1] not in chars:
                        action_tuples.append((action, [], option_string))
                        char = option_string[0]
                        option_string = char + explicit_arg[0]
                        new_explicit_arg = explicit_arg[1:] or None
                        optionals_map = self._option_string_actions
                        if option_string in optionals_map:
                            action = optionals_map[option_string]
                            explicit_arg = new_explicit_arg
                        else:
                            msg = _('ignored explicit argument %r')
                            raise ArgumentError(action, msg % explicit_arg)

# if the action expect exactly one argument, we've
                    # successfully matched the option; exit the loop
                    elif arg_count == 1:
                        stop = start_index + 1
                        args = [explicit_arg]
                        action_tuples.append((action, args, option_string))
                        break

# error if a double-dash option did not use the
                    # explicit argument
                    else:
                        msg = _('ignored explicit argument %r')
                        raise ArgumentError(action, msg % explicit_arg)

# if there is no explicit argument, try to match the
                # optional's string arguments with the following strings
                # if successful, exit the loop
                else:
                    start = start_index + 1
                    selected_patterns = arg_strings_pattern[start:]
                    arg_count = match_argument(action, selected_patterns)
                    stop = start + arg_count
                    args = arg_strings[start:stop]
                    action_tuples.append((action, args, option_string))
                    break

# add the Optional to the list and return the index at which
            # the Optional's string args stopped
            assert action_tuples
            for action, args, option_string in action_tuples:
                take_action(action, args, option_string)
            return stop

# the list of Positionals left to be parsed; this is modified
        # by consume_positionals()
        positionals = self._get_positional_actions()

# function to convert arg_strings into positional actions
        def consume_positionals(start_index):
            # match as many Positionals as possible
            match_partial = self._match_arguments_partial
            selected_pattern = arg_strings_pattern[start_index:]
            arg_counts = match_partial(positionals, selected_pattern)

# slice off the appropriate arg strings for each Positional
            # and add the Positional and its args to the list
            for action, arg_count in zip(positionals, arg_counts):
                args = arg_strings[start_index: start_index + arg_count]
                start_index += arg_count
                take_action(action, args)

# slice off the Positionals that we just parsed and return the
            # index at which the Positionals' string args stopped
            positionals[:] = positionals[len(arg_counts):]
            return start_index

# consume Positionals and Optionals alternately, until we have
        # passed the last option string
        extras = []
        start_index = 0
        if option_string_indices:
            max_option_string_index = max(option_string_indices)
        else:
            max_option_string_index = -1
        while start_index <= max_option_string_index:

# consume any Positionals preceding the next option
            next_option_string_index = min([
                index
                for index in option_string_indices
                if index >= start_index])
            if start_index != next_option_string_index:
                positionals_end_index = consume_positionals(start_index)

# only try to parse the next optional if we didn't consume
                # the option string during the positionals parsing
                if positionals_end_index > start_index:
                    start_index = positionals_end_index
                    continue
                else:
                    start_index = positionals_end_index

# if we consumed all the positionals we could and we're not
            # at the index of an option string, there were extra arguments
            if start_index not in option_string_indices:
                strings = arg_strings[start_index:next_option_string_index]
                extras.extend(strings)
                start_index = next_option_string_index

# consume the next optional and any arguments for it
            start_index = consume_optional(start_index)

# consume any positionals following the last Optional
        stop_index = consume_positionals(start_index)

# if we didn't consume all the argument strings, there were extras
        extras.extend(arg_strings[stop_index:])

# if we didn't use all the Positional objects, there were too few
        # arg strings supplied.
        if positionals:
            self.error(_('too few arguments'))

# make sure all required actions were present, and convert defaults.
        for action in self._actions:
            if action not in seen_actions:
                if action.required:
                    name = _get_action_name(action)
                    self.error(_('argument %s is required') % name)
                else:
                    # Convert action default now instead of doing it before
                    # parsing arguments to avoid calling convert functions
                    # twice (which may fail) if the argument was given, but
                    # only if it was defined already in the namespace
                    if (action.default is not None and
                            isinstance(action.default, basestring) and
                            hasattr(namespace, action.dest) and
                            action.default is getattr(namespace, action.dest)):
                        setattr(namespace, action.dest,
                                self._get_value(action, action.default))

# make sure all required groups had one option present
        for group in self._mutually_exclusive_groups:
            if group.required:
                for action in group._group_actions:
                    if action in seen_non_default_actions:
                        break

# if no actions were used, report the error
                else:
                    names = [_get_action_name(action)
                             for action in group._group_actions
                             if action.help is not SUPPRESS]
                    msg = _('one of the arguments %s is required')
                    self.error(msg % ' '.join(names))

# return the updated namespace and the extra arguments
        return namespace, extras

def _read_args_from_files(self, arg_strings):
        # expand arguments referencing files
        new_arg_strings = []
        for arg_string in arg_strings:

# for regular arguments, just add them back into the list
            if not arg_string or arg_string[0] not in self.fromfile_prefix_chars:
                new_arg_strings.append(arg_string)

# replace arguments referencing files with the file content
            else:
                try:
                    args_file = open(arg_string[1:])
                    try:
                        arg_strings = []
                        for arg_line in args_file.read().splitlines():
                            for arg in self.convert_arg_line_to_args(arg_line):
                                arg_strings.append(arg)
                        arg_strings = self._read_args_from_files(arg_strings)
                        new_arg_strings.extend(arg_strings)
                    finally:
                        args_file.close()
                except IOError:
                    err = _sys.exc_info()[1]
                    self.error(str(err))

# return the modified argument list
        return new_arg_strings

def convert_arg_line_to_args(self, arg_line):
        return [arg_line]

def _match_argument(self, action, arg_strings_pattern):
        # match the pattern for this action to the arg strings
        nargs_pattern = self._get_nargs_pattern(action)
        match = _re.match(nargs_pattern, arg_strings_pattern)

# raise an exception if we weren't able to find a match
        if match is None:
            nargs_errors = {
                None: _('expected one argument'),
                OPTIONAL: _('expected at most one argument'),
                ONE_OR_MORE: _('expected at least one argument'),
            }
            default = _('expected %s argument(s)') % action.nargs
            msg = nargs_errors.get(action.nargs, default)
            raise ArgumentError(action, msg)

# return the number of arguments matched
        return len(match.group(1))

def _match_arguments_partial(self, actions, arg_strings_pattern):
        # progressively shorten the actions list by slicing off the
        # final actions until we find a match
        result = []
        for i in range(len(actions), 0, -1):
            actions_slice = actions[:i]
            pattern = ''.join([self._get_nargs_pattern(action)
                               for action in actions_slice])
            match = _re.match(pattern, arg_strings_pattern)
            if match is not None:
                result.extend([len(string) for string in match.groups()])
                break

# return the list of arg string counts
        return result

def _parse_optional(self, arg_string):
        # if it's an empty string, it was meant to be a positional
        if not arg_string:
            return None

# if it doesn't start with a prefix, it was meant to be positional
        if not arg_string[0] in self.prefix_chars:
            return None

# if the option string is present in the parser, return the action
        if arg_string in self._option_string_actions:
            action = self._option_string_actions[arg_string]
            return action, arg_string, None

# if it's just a single character, it was meant to be positional
        if len(arg_string) == 1:
            return None

# if the option string before the "=" is present, return the action
        if '=' in arg_string:
            option_string, explicit_arg = arg_string.split('=', 1)
            if option_string in self._option_string_actions:
                action = self._option_string_actions[option_string]
                return action, option_string, explicit_arg

# search through all possible prefixes of the option string
        # and all actions in the parser for possible interpretations
        option_tuples = self._get_option_tuples(arg_string)

# if multiple actions match, the option string was ambiguous
        if len(option_tuples) > 1:
            options = ', '.join([option_string
                for action, option_string, explicit_arg in option_tuples])
            tup = arg_string, options
            self.error(_('ambiguous option: %s could match %s') % tup)

# if exactly one action matched, this segmentation is good,
        # so return the parsed action
        elif len(option_tuples) == 1:
            option_tuple, = option_tuples
            return option_tuple

# if it was not found as an option, but it looks like a negative
        # number, it was meant to be positional
        # unless there are negative-number-like options
        if self._negative_number_matcher.match(arg_string):
            if not self._has_negative_number_optionals:
                return None

# if it contains a space, it was meant to be a positional
        if ' ' in arg_string:
            return None

# it was meant to be an optional but there is no such option
        # in this parser (though it might be a valid option in a subparser)
        return None, arg_string, None

def _get_option_tuples(self, option_string):
        result = []

# option strings starting with two prefix characters are only
        # split at the '='
        chars = self.prefix_chars
        if option_string[0] in chars and option_string[1] in chars:
            if '=' in option_string:
                option_prefix, explicit_arg = option_string.split('=', 1)
            else:
                option_prefix = option_string
                explicit_arg = None
            for option_string in self._option_string_actions:
                if option_string.startswith(option_prefix):
                    action = self._option_string_actions[option_string]
                    tup = action, option_string, explicit_arg
                    result.append(tup)

# single character options can be concatenated with their arguments
        # but multiple character options always have to have their argument
        # separate
        elif option_string[0] in chars and option_string[1] not in chars:
            option_prefix = option_string
            explicit_arg = None
            short_option_prefix = option_string[:2]
            short_explicit_arg = option_string[2:]

for option_string in self._option_string_actions:
                if option_string == short_option_prefix:
                    action = self._option_string_actions[option_string]
                    tup = action, option_string, short_explicit_arg
                    result.append(tup)
                elif option_string.startswith(option_prefix):
                    action = self._option_string_actions[option_string]
                    tup = action, option_string, explicit_arg
                    result.append(tup)

# shouldn't ever get here
        else:
            self.error(_('unexpected option string: %s') % option_string)

# return the collected option tuples
        return result

def _get_nargs_pattern(self, action):
        # in all examples below, we have to allow for '--' args
        # which are represented as '-' in the pattern
        nargs = action.nargs

# the default (None) is assumed to be a single argument
        if nargs is None:
            nargs_pattern = '(-*A-*)'

# allow zero or one arguments
        elif nargs == OPTIONAL:
            nargs_pattern = '(-*A?-*)'

# allow zero or more arguments
        elif nargs == ZERO_OR_MORE:
            nargs_pattern = '(-*[A-]*)'

# allow one or more arguments
        elif nargs == ONE_OR_MORE:
            nargs_pattern = '(-*A[A-]*)'

# allow any number of options or arguments
        elif nargs == REMAINDER:
            nargs_pattern = '([-AO]*)'

# allow one argument followed by any number of options or arguments
        elif nargs == PARSER:
            nargs_pattern = '(-*A[-AO]*)'

# all others should be integers
        else:
            nargs_pattern = '(-*%s-*)' % '-*'.join('A' * nargs)

# if this is an optional action, -- is not allowed
        if action.option_strings:
            nargs_pattern = nargs_pattern.replace('-*', '')
            nargs_pattern = nargs_pattern.replace('-', '')

# return the pattern
        return nargs_pattern

# ========================
    # Value conversion methods
    # ========================
    def _get_values(self, action, arg_strings):
        # for everything but PARSER, REMAINDER args, strip out first '--'
        if action.nargs not in [PARSER, REMAINDER]:
            try:
                arg_strings.remove('--')
            except ValueError:
                pass

# optional argument produces a default when not present
        if not arg_strings and action.nargs == OPTIONAL:
            if action.option_strings:
                value = action.const
            else:
                value = action.default
            if isinstance(value, basestring):
                value = self._get_value(action, value)
                self._check_value(action, value)

# when nargs='*' on a positional, if there were no command-line
        # args, use the default if it is anything other than None
        elif (not arg_strings and action.nargs == ZERO_OR_MORE and
              not action.option_strings):
            if action.default is not None:
                value = action.default
            else:
                value = arg_strings
            self._check_value(action, value)

# single argument or optional argument produces a single value
        elif len(arg_strings) == 1 and action.nargs in [None, OPTIONAL]:
            arg_string, = arg_strings
            value = self._get_value(action, arg_string)
            self._check_value(action, value)

# REMAINDER arguments convert all values, checking none
        elif action.nargs == REMAINDER:
            value = [self._get_value(action, v) for v in arg_strings]

# PARSER arguments convert all values, but check only the first
        elif action.nargs == PARSER:
            value = [self._get_value(action, v) for v in arg_strings]
            self._check_value(action, value[0])

# all other types of nargs produce a list
        else:
            value = [self._get_value(action, v) for v in arg_strings]
            for v in value:
                self._check_value(action, v)

# return the converted value
        return value

def _get_value(self, action, arg_string):
        type_func = self._registry_get('type', action.type, action.type)
        if not _callable(type_func):
            msg = _('%r is not callable')
            raise ArgumentError(action, msg % type_func)

# convert the value to the appropriate type
        try:
            result = type_func(arg_string)

# ArgumentTypeErrors indicate errors
        except ArgumentTypeError:
            name = getattr(action.type, '__name__', repr(action.type))
            msg = str(_sys.exc_info()[1])
            raise ArgumentError(action, msg)

# TypeErrors or ValueErrors also indicate errors
        except (TypeError, ValueError):
            name = getattr(action.type, '__name__', repr(action.type))
            msg = _('invalid %s value: %r')
            raise ArgumentError(action, msg % (name, arg_string))

# return the converted value
        return result

def _check_value(self, action, value):
        # converted value must be one of the choices (if specified)
        if action.choices is not None and value not in action.choices:
            tup = value, ', '.join(map(repr, action.choices))
            msg = _('invalid choice: %r (choose from %s)') % tup
            raise ArgumentError(action, msg)

# =======================
    # Help-formatting methods
    # =======================
    def format_usage(self):
        formatter = self._get_formatter()
        formatter.add_usage(self.usage, self._actions,
                            self._mutually_exclusive_groups)
        return formatter.format_help()

def format_help(self):
        formatter = self._get_formatter()

# usage
        formatter.add_usage(self.usage, self._actions,
                            self._mutually_exclusive_groups)

# description
        formatter.add_text(self.description)

# positionals, optionals and user-defined groups
        for action_group in self._action_groups:
            formatter.start_section(action_group.title)
            formatter.add_text(action_group.description)
            formatter.add_arguments(action_group._group_actions)
            formatter.end_section()

# epilog
        formatter.add_text(self.epilog)

# determine help from format above
        return formatter.format_help()

def format_version(self):
        import warnings
        warnings.warn(
            'The format_version method is deprecated -- the "version" '
            'argument to ArgumentParser is no longer supported.',
            DeprecationWarning)
        formatter = self._get_formatter()
        formatter.add_text(self.version)
        return formatter.format_help()

def _get_formatter(self):
        return self.formatter_class(prog=self.prog)

# =====================
    # Help-printing methods
    # =====================
    def print_usage(self, file=None):
        if file is None:
            file = _sys.stdout
        self._print_message(self.format_usage(), file)

def print_help(self, file=None):
        if file is None:
            file = _sys.stdout
        self._print_message(self.format_help(), file)

def print_version(self, file=None):
        import warnings
        warnings.warn(
            'The print_version method is deprecated -- the "version" '
            'argument to ArgumentParser is no longer supported.',
            DeprecationWarning)
        self._print_message(self.format_version(), file)

def _print_message(self, message, file=None):
        if message:
            if file is None:
                file = _sys.stderr
            file.write(message)

# ===============
    # Exiting methods
    # ===============
    def exit(self, status=0, message=None):
        if message:
            self._print_message(message, _sys.stderr)
        _sys.exit(status)

def error(self, message):
        """error(message: string)

Prints a usage message incorporating the message to stderr and
        exits.

If you override this in a subclass, it should not return -- it
        should either exit or raise an exception.
        """
        self.print_usage(_sys.stderr)
        self.exit(2, _('%s: error: %s\n') % (self.prog, message))

cmd: