FM / python2.7

/usr/lib64/python2.7

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

Edit: /usr/lib64/python2.7/urllib.py (60228B)

"""Open an arbitrary URL.

See the following document for more info on URLs:
"Names and Addresses, URIs, URLs, URNs, URCs", at
http://www.w3.org/pub/WWW/Addressing/Overview.html

See also the HTTP spec (from which the error codes are derived):
"HTTP - Hypertext Transfer Protocol", at
http://www.w3.org/pub/WWW/Protocols/

Related standards and specs:
- RFC1808: the "relative URL" spec. (authoritative status)
- RFC1738 - the "URL standard". (authoritative status)
- RFC1630 - the "URI spec". (informational status)

The object returned by URLopener().open(file) will differ per
protocol.  All you know is that is has methods read(), readline(),
readlines(), fileno(), close() and info().  The read*(), fileno()
and close() methods work like those of open files.
The info() method returns a mimetools.Message object which can be
used to query various info about the object, if available.
(mimetools.Message objects are queried with the getheader() method.)
"""

import string
import socket
import os
import time
import sys
import base64
import re

from urlparse import urljoin as basejoin

__all__ = ["urlopen", "URLopener", "FancyURLopener", "urlretrieve",
           "urlcleanup", "quote", "quote_plus", "unquote", "unquote_plus",
           "urlencode", "url2pathname", "pathname2url", "splittag",
           "localhost", "thishost", "ftperrors", "basejoin", "unwrap",
           "splittype", "splithost", "splituser", "splitpasswd", "splitport",
           "splitnport", "splitquery", "splitattr", "splitvalue",
           "getproxies"]

__version__ = '1.17'    # XXX This version is not always updated :-(

MAXFTPCACHE = 10        # Trim the ftp cache beyond this size

# Helper for non-unix systems
if os.name == 'nt':
    from nturl2path import url2pathname, pathname2url
elif os.name == 'riscos':
    from rourl2path import url2pathname, pathname2url
else:
    def url2pathname(pathname):
        """OS-specific conversion from a relative URL of the 'file' scheme
        to a file system path; not recommended for general use."""
        return unquote(pathname)

def pathname2url(pathname):
        """OS-specific conversion from a file system path to a relative URL
        of the 'file' scheme; not recommended for general use."""
        return quote(pathname)

# This really consists of two pieces:
# (1) a class which handles opening of all sorts of URLs
#     (plus assorted utilities etc.)
# (2) a set of functions for parsing URLs
# XXX Should these be separated out into different modules?

# Shortcut for basic usage
_urlopener = None
def urlopen(url, data=None, proxies=None, context=None):
    """Create a file-like object for the specified URL to read from."""
    from warnings import warnpy3k
    warnpy3k("urllib.urlopen() has been removed in Python 3.0 in "
             "favor of urllib2.urlopen()", stacklevel=2)

global _urlopener
    if proxies is not None or context is not None:
        opener = FancyURLopener(proxies=proxies, context=context)
    elif not _urlopener:
        opener = FancyURLopener()
        _urlopener = opener
    else:
        opener = _urlopener
    if data is None:
        return opener.open(url)
    else:
        return opener.open(url, data)
def urlretrieve(url, filename=None, reporthook=None, data=None, context=None):
    global _urlopener
    if context is not None:
        opener = FancyURLopener(context=context)
    elif not _urlopener:
        _urlopener = opener = FancyURLopener()
    else:
        opener = _urlopener
    return opener.retrieve(url, filename, reporthook, data)
def urlcleanup():
    if _urlopener:
        _urlopener.cleanup()
    _safe_quoters.clear()
    ftpcache.clear()

# check for SSL
try:
    import ssl
except:
    _have_ssl = False
else:
    _have_ssl = True

# exception raised when downloaded size does not match content-length
class ContentTooShortError(IOError):
    def __init__(self, message, content):
        IOError.__init__(self, message)
        self.content = content

ftpcache = {}
class URLopener:
    """Class to open URLs.
    This is a class rather than just a subroutine because we may need
    more than one set of global protocol-specific options.
    Note -- this is a base class for those who don't want the
    automatic handling of errors type 302 (relocated) and 401
    (authorization needed)."""

__tempfiles = None

version = "Python-urllib/%s" % __version__

# Constructor
    def __init__(self, proxies=None, context=None, **x509):
        if proxies is None:
            proxies = getproxies()
        assert hasattr(proxies, 'has_key'), "proxies must be a mapping"
        self.proxies = proxies
        self.key_file = x509.get('key_file')
        self.cert_file = x509.get('cert_file')
        self.context = context
        self.addheaders = [('User-Agent', self.version), ('Accept', '*/*')]
        self.__tempfiles = []
        self.__unlink = os.unlink # See cleanup()
        self.tempcache = None
        # Undocumented feature: if you assign {} to tempcache,
        # it is used to cache files retrieved with
        # self.retrieve().  This is not enabled by default
        # since it does not work for changing documents (and I
        # haven't got the logic to check expiration headers
        # yet).
        self.ftpcache = ftpcache
        # Undocumented feature: you can use a different
        # ftp cache by assigning to the .ftpcache member;
        # in case you want logically independent URL openers
        # XXX This is not threadsafe.  Bah.

def __del__(self):
        self.close()

def close(self):
        self.cleanup()

def cleanup(self):
        # This code sometimes runs when the rest of this module
        # has already been deleted, so it can't use any globals
        # or import anything.
        if self.__tempfiles:
            for file in self.__tempfiles:
                try:
                    self.__unlink(file)
                except OSError:
                    pass
            del self.__tempfiles[:]
        if self.tempcache:
            self.tempcache.clear()

def addheader(self, *args):
        """Add a header to be used by the HTTP interface only
        e.g. u.addheader('Accept', 'sound/basic')"""
        self.addheaders.append(args)

# External interface
    def open(self, fullurl, data=None):
        """Use URLopener().open(file) instead of open(file, 'r')."""
        fullurl = unwrap(toBytes(fullurl))
        # percent encode url, fixing lame server errors for e.g, like space
        # within url paths.
        fullurl = quote(fullurl, safe="%/:=&?~#+!$,;'@()*[]|")
        if self.tempcache and fullurl in self.tempcache:
            filename, headers = self.tempcache[fullurl]
            fp = open(filename, 'rb')
            return addinfourl(fp, headers, fullurl)
        urltype, url = splittype(fullurl)
        if not urltype:
            urltype = 'file'
        if urltype in self.proxies:
            proxy = self.proxies[urltype]
            urltype, proxyhost = splittype(proxy)
            host, selector = splithost(proxyhost)
            url = (host, fullurl) # Signal special case to open_*()
        else:
            proxy = None
        name = 'open_' + urltype
        self.type = urltype
        name = name.replace('-', '_')

# bpo-35907: disallow the file reading with the type not allowed
        if not hasattr(self, name) or name == 'open_local_file':
            if proxy:
                return self.open_unknown_proxy(proxy, fullurl, data)
            else:
                return self.open_unknown(fullurl, data)
        try:
            if data is None:
                return getattr(self, name)(url)
            else:
                return getattr(self, name)(url, data)
        except socket.error, msg:
            raise IOError, ('socket error', msg), sys.exc_info()[2]

def open_unknown(self, fullurl, data=None):
        """Overridable interface to open unknown URL type."""
        type, url = splittype(fullurl)
        raise IOError, ('url error', 'unknown url type', type)

def open_unknown_proxy(self, proxy, fullurl, data=None):
        """Overridable interface to open unknown URL type."""
        type, url = splittype(fullurl)
        raise IOError, ('url error', 'invalid proxy for %s' % type, proxy)

# External interface
    def retrieve(self, url, filename=None, reporthook=None, data=None):
        """retrieve(url) returns (filename, headers) for a local object
        or (tempfilename, headers) for a remote object."""
        url = unwrap(toBytes(url))
        if self.tempcache and url in self.tempcache:
            return self.tempcache[url]
        type, url1 = splittype(url)
        if filename is None and (not type or type == 'file'):
            try:
                fp = self.open_local_file(url1)
                hdrs = fp.info()
                fp.close()
                return url2pathname(splithost(url1)[1]), hdrs
            except IOError:
                pass
        fp = self.open(url, data)
        try:
            headers = fp.info()
            if filename:
                tfp = open(filename, 'wb')
            else:
                import tempfile
                garbage, path = splittype(url)
                garbage, path = splithost(path or "")
                path, garbage = splitquery(path or "")
                path, garbage = splitattr(path or "")
                suffix = os.path.splitext(path)[1]
                (fd, filename) = tempfile.mkstemp(suffix)
                self.__tempfiles.append(filename)
                tfp = os.fdopen(fd, 'wb')
            try:
                result = filename, headers
                if self.tempcache is not None:
                    self.tempcache[url] = result
                bs = 1024*8
                size = -1
                read = 0
                blocknum = 0
                if "content-length" in headers:
                    size = int(headers["Content-Length"])
                if reporthook:
                    reporthook(blocknum, bs, size)
                while 1:
                    block = fp.read(bs)
                    if block == "":
                        break
                    read += len(block)
                    tfp.write(block)
                    blocknum += 1
                    if reporthook:
                        reporthook(blocknum, bs, size)
            finally:
                tfp.close()
        finally:
            fp.close()

# raise exception if actual size does not match content-length header
        if size >= 0 and read < size:
            raise ContentTooShortError("retrieval incomplete: got only %i out "
                                       "of %i bytes" % (read, size), result)

return result

# Each method named open_<type> knows how to open that type of URL

def open_http(self, url, data=None):
        """Use HTTP protocol."""
        import httplib
        user_passwd = None
        proxy_passwd= None
        if isinstance(url, str):
            host, selector = splithost(url)
            if host:
                user_passwd, host = splituser(host)
                host = unquote(host)
            realhost = host
        else:
            host, selector = url
            # check whether the proxy contains authorization information
            proxy_passwd, host = splituser(host)
            # now we proceed with the url we want to obtain
            urltype, rest = splittype(selector)
            url = rest
            user_passwd = None
            if urltype.lower() != 'http':
                realhost = None
            else:
                realhost, rest = splithost(rest)
                if realhost:
                    user_passwd, realhost = splituser(realhost)
                if user_passwd:
                    selector = "%s://%s%s" % (urltype, realhost, rest)
                if proxy_bypass(realhost):
                    host = realhost

#print "proxy via http:", host, selector
        if not host: raise IOError, ('http error', 'no host given')

if proxy_passwd:
            proxy_passwd = unquote(proxy_passwd)
            proxy_auth = base64.b64encode(proxy_passwd).strip()
        else:
            proxy_auth = None

if user_passwd:
            user_passwd = unquote(user_passwd)
            auth = base64.b64encode(user_passwd).strip()
        else:
            auth = None
        h = httplib.HTTP(host)
        if data is not None:
            h.putrequest('POST', selector)
            h.putheader('Content-Type', 'application/x-www-form-urlencoded')
            h.putheader('Content-Length', '%d' % len(data))
        else:
            h.putrequest('GET', selector)
        if proxy_auth: h.putheader('Proxy-Authorization', 'Basic %s' % proxy_auth)
        if auth: h.putheader('Authorization', 'Basic %s' % auth)
        if realhost: h.putheader('Host', realhost)
        for args in self.addheaders: h.putheader(*args)
        h.endheaders(data)
        errcode, errmsg, headers = h.getreply()
        fp = h.getfile()
        if errcode == -1:
            if fp: fp.close()
            # something went wrong with the HTTP status line
            raise IOError, ('http protocol error', 0,
                            'got a bad status line', None)
        # According to RFC 2616, "2xx" code indicates that the client's
        # request was successfully received, understood, and accepted.
        if (200 <= errcode < 300):
            return addinfourl(fp, headers, "http:" + url, errcode)
        else:
            if data is None:
                return self.http_error(url, fp, errcode, errmsg, headers)
            else:
                return self.http_error(url, fp, errcode, errmsg, headers, data)

def http_error(self, url, fp, errcode, errmsg, headers, data=None):
        """Handle http errors.
        Derived class can override this, or provide specific handlers
        named http_error_DDD where DDD is the 3-digit error code."""
        # First check if there's a specific handler for this error
        name = 'http_error_%d' % errcode
        if hasattr(self, name):
            method = getattr(self, name)
            if data is None:
                result = method(url, fp, errcode, errmsg, headers)
            else:
                result = method(url, fp, errcode, errmsg, headers, data)
            if result: return result
        return self.http_error_default(url, fp, errcode, errmsg, headers)

def http_error_default(self, url, fp, errcode, errmsg, headers):
        """Default error handler: close the connection and raise IOError."""
        fp.close()
        raise IOError, ('http error', errcode, errmsg, headers)

if _have_ssl:
        def open_https(self, url, data=None):
            """Use HTTPS protocol."""

import httplib
            user_passwd = None
            proxy_passwd = None
            if isinstance(url, str):
                host, selector = splithost(url)
                if host:
                    user_passwd, host = splituser(host)
                    host = unquote(host)
                realhost = host
            else:
                host, selector = url
                # here, we determine, whether the proxy contains authorization information
                proxy_passwd, host = splituser(host)
                urltype, rest = splittype(selector)
                url = rest
                user_passwd = None
                if urltype.lower() != 'https':
                    realhost = None
                else:
                    realhost, rest = splithost(rest)
                    if realhost:
                        user_passwd, realhost = splituser(realhost)
                    if user_passwd:
                        selector = "%s://%s%s" % (urltype, realhost, rest)
                #print "proxy via https:", host, selector
            if not host: raise IOError, ('https error', 'no host given')
            if proxy_passwd:
                proxy_passwd = unquote(proxy_passwd)
                proxy_auth = base64.b64encode(proxy_passwd).strip()
            else:
                proxy_auth = None
            if user_passwd:
                user_passwd = unquote(user_passwd)
                auth = base64.b64encode(user_passwd).strip()
            else:
                auth = None
            h = httplib.HTTPS(host, 0,
                              key_file=self.key_file,
                              cert_file=self.cert_file,
                              context=self.context)
            if data is not None:
                h.putrequest('POST', selector)
                h.putheader('Content-Type',
                            'application/x-www-form-urlencoded')
                h.putheader('Content-Length', '%d' % len(data))
            else:
                h.putrequest('GET', selector)
            if proxy_auth: h.putheader('Proxy-Authorization', 'Basic %s' % proxy_auth)
            if auth: h.putheader('Authorization', 'Basic %s' % auth)
            if realhost: h.putheader('Host', realhost)
            for args in self.addheaders: h.putheader(*args)
            h.endheaders(data)
            errcode, errmsg, headers = h.getreply()
            fp = h.getfile()
            if errcode == -1:
                if fp: fp.close()
                # something went wrong with the HTTP status line
                raise IOError, ('http protocol error', 0,
                                'got a bad status line', None)
            # According to RFC 2616, "2xx" code indicates that the client's
            # request was successfully received, understood, and accepted.
            if (200 <= errcode < 300):
                return addinfourl(fp, headers, "https:" + url, errcode)
            else:
                if data is None:
                    return self.http_error(url, fp, errcode, errmsg, headers)
                else:
                    return self.http_error(url, fp, errcode, errmsg, headers,
                                           data)

def open_file(self, url):
        """Use local file or FTP depending on form of URL."""
        if not isinstance(url, str):
            raise IOError, ('file error', 'proxy support for file protocol currently not implemented')
        if url[:2] == '//' and url[2:3] != '/' and url[2:12].lower() != 'localhost/':
            return self.open_ftp(url)
        else:
            return self.open_local_file(url)

def open_local_file(self, url):
        """Use local file."""
        import mimetypes, mimetools, email.utils
        try:
            from cStringIO import StringIO
        except ImportError:
            from StringIO import StringIO
        host, file = splithost(url)
        localname = url2pathname(file)
        try:
            stats = os.stat(localname)
        except OSError, e:
            raise IOError(e.errno, e.strerror, e.filename)
        size = stats.st_size
        modified = email.utils.formatdate(stats.st_mtime, usegmt=True)
        mtype = mimetypes.guess_type(url)[0]
        headers = mimetools.Message(StringIO(
            'Content-Type: %s\nContent-Length: %d\nLast-modified: %s\n' %
            (mtype or 'text/plain', size, modified)))
        if not host:
            urlfile = file
            if file[:1] == '/':
                urlfile = 'file://' + file
            elif file[:2] == './':
                raise ValueError("local file url may start with / or file:. Unknown url of type: %s" % url)
            return addinfourl(open(localname, 'rb'),
                              headers, urlfile)
        host, port = splitport(host)
        if not port \
           and socket.gethostbyname(host) in (localhost(), thishost()):
            urlfile = file
            if file[:1] == '/':
                urlfile = 'file://' + file
            return addinfourl(open(localname, 'rb'),
                              headers, urlfile)
        raise IOError, ('local file error', 'not on local host')

def open_ftp(self, url):
        """Use FTP protocol."""
        if not isinstance(url, str):
            raise IOError, ('ftp error', 'proxy support for ftp protocol currently not implemented')
        import mimetypes, mimetools
        try:
            from cStringIO import StringIO
        except ImportError:
            from StringIO import StringIO
        host, path = splithost(url)
        if not host: raise IOError, ('ftp error', 'no host given')
        host, port = splitport(host)
        user, host = splituser(host)
        if user: user, passwd = splitpasswd(user)
        else: passwd = None
        host = unquote(host)
        user = user or ''
        passwd = passwd or ''
        host = socket.gethostbyname(host)
        if not port:
            import ftplib
            port = ftplib.FTP_PORT
        else:
            port = int(port)
        path, attrs = splitattr(path)
        path = unquote(path)
        dirs = path.split('/')
        dirs, file = dirs[:-1], dirs[-1]
        if dirs and not dirs[0]: dirs = dirs[1:]
        if dirs and not dirs[0]: dirs[0] = '/'
        key = user, host, port, '/'.join(dirs)
        # XXX thread unsafe!
        if len(self.ftpcache) > MAXFTPCACHE:
            # Prune the cache, rather arbitrarily
            for k in self.ftpcache.keys():
                if k != key:
                    v = self.ftpcache[k]
                    del self.ftpcache[k]
                    v.close()
        try:
            if not key in self.ftpcache:
                self.ftpcache[key] = \
                    ftpwrapper(user, passwd, host, port, dirs)
            if not file: type = 'D'
            else: type = 'I'
            for attr in attrs:
                attr, value = splitvalue(attr)
                if attr.lower() == 'type' and \
                   value in ('a', 'A', 'i', 'I', 'd', 'D'):
                    type = value.upper()
            (fp, retrlen) = self.ftpcache[key].retrfile(file, type)
            mtype = mimetypes.guess_type("ftp:" + url)[0]
            headers = ""
            if mtype:
                headers += "Content-Type: %s\n" % mtype
            if retrlen is not None and retrlen >= 0:
                headers += "Content-Length: %d\n" % retrlen
            headers = mimetools.Message(StringIO(headers))
            return addinfourl(fp, headers, "ftp:" + url)
        except ftperrors(), msg:
            raise IOError, ('ftp error', msg), sys.exc_info()[2]

def open_data(self, url, data=None):
        """Use "data" URL."""
        if not isinstance(url, str):
            raise IOError, ('data error', 'proxy support for data protocol currently not implemented')
        # ignore POSTed data
        #
        # syntax of data URLs:
        # dataurl   := "data:" [ mediatype ] [ ";base64" ] "," data
        # mediatype := [ type "/" subtype ] *( ";" parameter )
        # data      := *urlchar
        # parameter := attribute "=" value
        import mimetools
        try:
            from cStringIO import StringIO
        except ImportError:
            from StringIO import StringIO
        try:
            [type, data] = url.split(',', 1)
        except ValueError:
            raise IOError, ('data error', 'bad data URL')
        if not type:
            type = 'text/plain;charset=US-ASCII'
        semi = type.rfind(';')
        if semi >= 0 and '=' not in type[semi:]:
            encoding = type[semi+1:]
            type = type[:semi]
        else:
            encoding = ''
        msg = []
        msg.append('Date: %s'%time.strftime('%a, %d %b %Y %H:%M:%S GMT',
                                            time.gmtime(time.time())))
        msg.append('Content-type: %s' % type)
        if encoding == 'base64':
            data = base64.decodestring(data)
        else:
            data = unquote(data)
        msg.append('Content-Length: %d' % len(data))
        msg.append('')
        msg.append(data)
        msg = '\n'.join(msg)
        f = StringIO(msg)
        headers = mimetools.Message(f, 0)
        #f.fileno = None     # needed for addinfourl
        return addinfourl(f, headers, url)

class FancyURLopener(URLopener):
    """Derived class with handlers for errors we can handle (perhaps)."""

def __init__(self, *args, **kwargs):
        URLopener.__init__(self, *args, **kwargs)
        self.auth_cache = {}
        self.tries = 0
        self.maxtries = 10

def http_error_default(self, url, fp, errcode, errmsg, headers):
        """Default error handling -- don't raise an exception."""
        return addinfourl(fp, headers, "http:" + url, errcode)

def http_error_302(self, url, fp, errcode, errmsg, headers, data=None):
        """Error 302 -- relocated (temporarily)."""
        self.tries += 1
        try:
            if self.maxtries and self.tries >= self.maxtries:
                if hasattr(self, "http_error_500"):
                    meth = self.http_error_500
                else:
                    meth = self.http_error_default
                return meth(url, fp, 500,
                            "Internal Server Error: Redirect Recursion",
                            headers)
            result = self.redirect_internal(url, fp, errcode, errmsg,
                                            headers, data)
            return result
        finally:
            self.tries = 0

def redirect_internal(self, url, fp, errcode, errmsg, headers, data):
        if 'location' in headers:
            newurl = headers['location']
        elif 'uri' in headers:
            newurl = headers['uri']
        else:
            return
        fp.close()
        # In case the server sent a relative URL, join with original:
        newurl = basejoin(self.type + ":" + url, newurl)

# For security reasons we do not allow redirects to protocols
        # other than HTTP, HTTPS or FTP.
        newurl_lower = newurl.lower()
        if not (newurl_lower.startswith('http://') or
                newurl_lower.startswith('https://') or
                newurl_lower.startswith('ftp://')):
            raise IOError('redirect error', errcode,
                          errmsg + " - Redirection to url '%s' is not allowed" %
                          newurl,
                          headers)

return self.open(newurl)

def http_error_301(self, url, fp, errcode, errmsg, headers, data=None):
        """Error 301 -- also relocated (permanently)."""
        return self.http_error_302(url, fp, errcode, errmsg, headers, data)

def http_error_303(self, url, fp, errcode, errmsg, headers, data=None):
        """Error 303 -- also relocated (essentially identical to 302)."""
        return self.http_error_302(url, fp, errcode, errmsg, headers, data)

def http_error_307(self, url, fp, errcode, errmsg, headers, data=None):
        """Error 307 -- relocated, but turn POST into error."""
        if data is None:
            return self.http_error_302(url, fp, errcode, errmsg, headers, data)
        else:
            return self.http_error_default(url, fp, errcode, errmsg, headers)

def http_error_401(self, url, fp, errcode, errmsg, headers, data=None):
        """Error 401 -- authentication required.
        This function supports Basic authentication only."""
        if not 'www-authenticate' in headers:
            URLopener.http_error_default(self, url, fp,
                                         errcode, errmsg, headers)
        stuff = headers['www-authenticate']
        import re
        match = re.match('[ \t]*([^ \t]+)[ \t]+realm="([^"]*)"', stuff)
        if not match:
            URLopener.http_error_default(self, url, fp,
                                         errcode, errmsg, headers)
        scheme, realm = match.groups()
        if scheme.lower() != 'basic':
            URLopener.http_error_default(self, url, fp,
                                         errcode, errmsg, headers)
        name = 'retry_' + self.type + '_basic_auth'
        if data is None:
            return getattr(self,name)(url, realm)
        else:
            return getattr(self,name)(url, realm, data)

def http_error_407(self, url, fp, errcode, errmsg, headers, data=None):
        """Error 407 -- proxy authentication required.
        This function supports Basic authentication only."""
        if not 'proxy-authenticate' in headers:
            URLopener.http_error_default(self, url, fp,
                                         errcode, errmsg, headers)
        stuff = headers['proxy-authenticate']
        import re
        match = re.match('[ \t]*([^ \t]+)[ \t]+realm="([^"]*)"', stuff)
        if not match:
            URLopener.http_error_default(self, url, fp,
                                         errcode, errmsg, headers)
        scheme, realm = match.groups()
        if scheme.lower() != 'basic':
            URLopener.http_error_default(self, url, fp,
                                         errcode, errmsg, headers)
        name = 'retry_proxy_' + self.type + '_basic_auth'
        if data is None:
            return getattr(self,name)(url, realm)
        else:
            return getattr(self,name)(url, realm, data)

def retry_proxy_http_basic_auth(self, url, realm, data=None):
        host, selector = splithost(url)
        newurl = 'http://' + host + selector
        proxy = self.proxies['http']
        urltype, proxyhost = splittype(proxy)
        proxyhost, proxyselector = splithost(proxyhost)
        i = proxyhost.find('@') + 1
        proxyhost = proxyhost[i:]
        user, passwd = self.get_user_passwd(proxyhost, realm, i)
        if not (user or passwd): return None
        proxyhost = quote(user, safe='') + ':' + quote(passwd, safe='') + '@' + proxyhost
        self.proxies['http'] = 'http://' + proxyhost + proxyselector
        if data is None:
            return self.open(newurl)
        else:
            return self.open(newurl, data)

def retry_proxy_https_basic_auth(self, url, realm, data=None):
        host, selector = splithost(url)
        newurl = 'https://' + host + selector
        proxy = self.proxies['https']
        urltype, proxyhost = splittype(proxy)
        proxyhost, proxyselector = splithost(proxyhost)
        i = proxyhost.find('@') + 1
        proxyhost = proxyhost[i:]
        user, passwd = self.get_user_passwd(proxyhost, realm, i)
        if not (user or passwd): return None
        proxyhost = quote(user, safe='') + ':' + quote(passwd, safe='') + '@' + proxyhost
        self.proxies['https'] = 'https://' + proxyhost + proxyselector
        if data is None:
            return self.open(newurl)
        else:
            return self.open(newurl, data)

def retry_http_basic_auth(self, url, realm, data=None):
        host, selector = splithost(url)
        i = host.find('@') + 1
        host = host[i:]
        user, passwd = self.get_user_passwd(host, realm, i)
        if not (user or passwd): return None
        host = quote(user, safe='') + ':' + quote(passwd, safe='') + '@' + host
        newurl = 'http://' + host + selector
        if data is None:
            return self.open(newurl)
        else:
            return self.open(newurl, data)

def retry_https_basic_auth(self, url, realm, data=None):
        host, selector = splithost(url)
        i = host.find('@') + 1
        host = host[i:]
        user, passwd = self.get_user_passwd(host, realm, i)
        if not (user or passwd): return None
        host = quote(user, safe='') + ':' + quote(passwd, safe='') + '@' + host
        newurl = 'https://' + host + selector
        if data is None:
            return self.open(newurl)
        else:
            return self.open(newurl, data)

def get_user_passwd(self, host, realm, clear_cache=0):
        key = realm + '@' + host.lower()
        if key in self.auth_cache:
            if clear_cache:
                del self.auth_cache[key]
            else:
                return self.auth_cache[key]
        user, passwd = self.prompt_user_passwd(host, realm)
        if user or passwd: self.auth_cache[key] = (user, passwd)
        return user, passwd

def prompt_user_passwd(self, host, realm):
        """Override this in a GUI environment!"""
        import getpass
        try:
            user = raw_input("Enter username for %s at %s: " % (realm,
                                                                host))
            passwd = getpass.getpass("Enter password for %s in %s at %s: " %
                (user, realm, host))
            return user, passwd
        except KeyboardInterrupt:
            print
            return None, None

# Utility functions

_localhost = None
def localhost():
    """Return the IP address of the magic hostname 'localhost'."""
    global _localhost
    if _localhost is None:
        _localhost = socket.gethostbyname('localhost')
    return _localhost

_thishost = None
def thishost():
    """Return the IP address of the current host."""
    global _thishost
    if _thishost is None:
        try:
            _thishost = socket.gethostbyname(socket.gethostname())
        except socket.gaierror:
            _thishost = socket.gethostbyname('localhost')
    return _thishost

_ftperrors = None
def ftperrors():
    """Return the set of errors raised by the FTP class."""
    global _ftperrors
    if _ftperrors is None:
        import ftplib
        _ftperrors = ftplib.all_errors
    return _ftperrors

_noheaders = None
def noheaders():
    """Return an empty mimetools.Message object."""
    global _noheaders
    if _noheaders is None:
        import mimetools
        try:
            from cStringIO import StringIO
        except ImportError:
            from StringIO import StringIO
        _noheaders = mimetools.Message(StringIO(), 0)
        _noheaders.fp.close()   # Recycle file descriptor
    return _noheaders

# Utility classes

class ftpwrapper:
    """Class used by open_ftp() for cache of open FTP connections."""

def __init__(self, user, passwd, host, port, dirs,
                 timeout=socket._GLOBAL_DEFAULT_TIMEOUT,
                 persistent=True):
        self.user = user
        self.passwd = passwd
        self.host = host
        self.port = port
        self.dirs = dirs
        self.timeout = timeout
        self.refcount = 0
        self.keepalive = persistent
        try:
            self.init()
        except:
            self.close()
            raise

def init(self):
        import ftplib
        self.busy = 0
        self.ftp = ftplib.FTP()
        self.ftp.connect(self.host, self.port, self.timeout)
        self.ftp.login(self.user, self.passwd)
        _target = '/'.join(self.dirs)
        self.ftp.cwd(_target)

def retrfile(self, file, type):
        import ftplib
        self.endtransfer()
        if type in ('d', 'D'): cmd = 'TYPE A'; isdir = 1
        else: cmd = 'TYPE ' + type; isdir = 0
        try:
            self.ftp.voidcmd(cmd)
        except ftplib.all_errors:
            self.init()
            self.ftp.voidcmd(cmd)
        conn = None
        if file and not isdir:
            # Try to retrieve as a file
            try:
                cmd = 'RETR ' + file
                conn, retrlen = self.ftp.ntransfercmd(cmd)
            except ftplib.error_perm, reason:
                if str(reason)[:3] != '550':
                    raise IOError, ('ftp error', reason), sys.exc_info()[2]
        if not conn:
            # Set transfer mode to ASCII!
            self.ftp.voidcmd('TYPE A')
            # Try a directory listing. Verify that directory exists.
            if file:
                pwd = self.ftp.pwd()
                try:
                    try:
                        self.ftp.cwd(file)
                    except ftplib.error_perm, reason:
                        raise IOError, ('ftp error', reason), sys.exc_info()[2]
                finally:
                    self.ftp.cwd(pwd)
                cmd = 'LIST ' + file
            else:
                cmd = 'LIST'
            conn, retrlen = self.ftp.ntransfercmd(cmd)
        self.busy = 1
        ftpobj = addclosehook(conn.makefile('rb'), self.file_close)
        self.refcount += 1
        conn.close()
        # Pass back both a suitably decorated object and a retrieval length
        return (ftpobj, retrlen)

def endtransfer(self):
        if not self.busy:
            return
        self.busy = 0
        try:
            self.ftp.voidresp()
        except ftperrors():
            pass

def close(self):
        self.keepalive = False
        if self.refcount <= 0:
            self.real_close()

def file_close(self):
        self.endtransfer()
        self.refcount -= 1
        if self.refcount <= 0 and not self.keepalive:
            self.real_close()

def real_close(self):
        self.endtransfer()
        try:
            self.ftp.close()
        except ftperrors():
            pass

class addbase:
    """Base class for addinfo and addclosehook."""

def __init__(self, fp):
        self.fp = fp
        self.read = self.fp.read
        self.readline = self.fp.readline
        if hasattr(self.fp, "readlines"): self.readlines = self.fp.readlines
        if hasattr(self.fp, "fileno"):
            self.fileno = self.fp.fileno
        else:
            self.fileno = lambda: None
        if hasattr(self.fp, "__iter__"):
            self.__iter__ = self.fp.__iter__
            if hasattr(self.fp, "next"):
                self.next = self.fp.next

def __repr__(self):
        return '<%s at %r whose fp = %r>' % (self.__class__.__name__,
                                             id(self), self.fp)

def close(self):
        self.read = None
        self.readline = None
        self.readlines = None
        self.fileno = None
        if self.fp: self.fp.close()
        self.fp = None

class addclosehook(addbase):
    """Class to add a close hook to an open file."""

def __init__(self, fp, closehook, *hookargs):
        addbase.__init__(self, fp)
        self.closehook = closehook
        self.hookargs = hookargs

def close(self):
        try:
            closehook = self.closehook
            hookargs = self.hookargs
            if closehook:
                self.closehook = None
                self.hookargs = None
                closehook(*hookargs)
        finally:
            addbase.close(self)

class addinfo(addbase):
    """class to add an info() method to an open file."""

def __init__(self, fp, headers):
        addbase.__init__(self, fp)
        self.headers = headers

def info(self):
        return self.headers

class addinfourl(addbase):
    """class to add info() and geturl() methods to an open file."""

def __init__(self, fp, headers, url, code=None):
        addbase.__init__(self, fp)
        self.headers = headers
        self.url = url
        self.code = code

def info(self):
        return self.headers

def getcode(self):
        return self.code

def geturl(self):
        return self.url

# Utilities to parse URLs (most of these return None for missing parts):
# unwrap('<URL:type://host/path>') --> 'type://host/path'
# splittype('type:opaquestring') --> 'type', 'opaquestring'
# splithost('//host[:port]/path') --> 'host[:port]', '/path'
# splituser('user[:passwd]@host[:port]') --> 'user[:passwd]', 'host[:port]'
# splitpasswd('user:passwd') -> 'user', 'passwd'
# splitport('host:port') --> 'host', 'port'
# splitquery('/path?query') --> '/path', 'query'
# splittag('/path#tag') --> '/path', 'tag'
# splitattr('/path;attr1=value1;attr2=value2;...') ->
#   '/path', ['attr1=value1', 'attr2=value2', ...]
# splitvalue('attr=value') --> 'attr', 'value'
# unquote('abc%20def') -> 'abc def'
# quote('abc def') -> 'abc%20def')

try:
    unicode
except NameError:
    def _is_unicode(x):
        return 0
else:
    def _is_unicode(x):
        return isinstance(x, unicode)

def toBytes(url):
    """toBytes(u"URL") --> 'URL'."""
    # Most URL schemes require ASCII. If that changes, the conversion
    # can be relaxed
    if _is_unicode(url):
        try:
            url = url.encode("ASCII")
        except UnicodeError:
            raise UnicodeError("URL " + repr(url) +
                               " contains non-ASCII characters")
    return url

def unwrap(url):
    """unwrap('<URL:type://host/path>') --> 'type://host/path'."""
    url = url.strip()
    if url[:1] == '<' and url[-1:] == '>':
        url = url[1:-1].strip()
    if url[:4] == 'URL:': url = url[4:].strip()
    return url

_typeprog = None
def splittype(url):
    """splittype('type:opaquestring') --> 'type', 'opaquestring'."""
    global _typeprog
    if _typeprog is None:
        import re
        _typeprog = re.compile('^([^/:]+):')

match = _typeprog.match(url)
    if match:
        scheme = match.group(1)
        return scheme.lower(), url[len(scheme) + 1:]
    return None, url

_hostprog = None
def splithost(url):
    """splithost('//host[:port]/path') --> 'host[:port]', '/path'."""
    global _hostprog
    if _hostprog is None:
        _hostprog = re.compile('//([^/#?]*)(.*)', re.DOTALL)

match = _hostprog.match(url)
    if match:
        host_port = match.group(1)
        path = match.group(2)
        if path and not path.startswith('/'):
            path = '/' + path
        return host_port, path
    return None, url

_userprog = None
def splituser(host):
    """splituser('user[:passwd]@host[:port]') --> 'user[:passwd]', 'host[:port]'."""
    global _userprog
    if _userprog is None:
        import re
        _userprog = re.compile('^(.*)@(.*)$')

match = _userprog.match(host)
    if match: return match.group(1, 2)
    return None, host

_passwdprog = None
def splitpasswd(user):
    """splitpasswd('user:passwd') -> 'user', 'passwd'."""
    global _passwdprog
    if _passwdprog is None:
        import re
        _passwdprog = re.compile('^([^:]*):(.*)$',re.S)

match = _passwdprog.match(user)
    if match: return match.group(1, 2)
    return user, None

# splittag('/path#tag') --> '/path', 'tag'
_portprog = None
def splitport(host):
    """splitport('host:port') --> 'host', 'port'."""
    global _portprog
    if _portprog is None:
        import re
        _portprog = re.compile('^(.*):([0-9]*)$')

match = _portprog.match(host)
    if match:
        host, port = match.groups()
        if port:
            return host, port
    return host, None

_nportprog = None
def splitnport(host, defport=-1):
    """Split host and port, returning numeric port.
    Return given default port if no ':' found; defaults to -1.
    Return numerical port if a valid number are found after ':'.
    Return None if ':' but not a valid number."""
    global _nportprog
    if _nportprog is None:
        import re
        _nportprog = re.compile('^(.*):(.*)$')

match = _nportprog.match(host)
    if match:
        host, port = match.group(1, 2)
        if port:
            try:
                nport = int(port)
            except ValueError:
                nport = None
            return host, nport
    return host, defport

_queryprog = None
def splitquery(url):
    """splitquery('/path?query') --> '/path', 'query'."""
    global _queryprog
    if _queryprog is None:
        import re
        _queryprog = re.compile('^(.*)\?([^?]*)$')

match = _queryprog.match(url)
    if match: return match.group(1, 2)
    return url, None

_tagprog = None
def splittag(url):
    """splittag('/path#tag') --> '/path', 'tag'."""
    global _tagprog
    if _tagprog is None:
        import re
        _tagprog = re.compile('^(.*)#([^#]*)$')

match = _tagprog.match(url)
    if match: return match.group(1, 2)
    return url, None

def splitattr(url):
    """splitattr('/path;attr1=value1;attr2=value2;...') ->
        '/path', ['attr1=value1', 'attr2=value2', ...]."""
    words = url.split(';')
    return words[0], words[1:]

_valueprog = None
def splitvalue(attr):
    """splitvalue('attr=value') --> 'attr', 'value'."""
    global _valueprog
    if _valueprog is None:
        import re
        _valueprog = re.compile('^([^=]*)=(.*)$')

match = _valueprog.match(attr)
    if match: return match.group(1, 2)
    return attr, None

# urlparse contains a duplicate of this method to avoid a circular import.  If
# you update this method, also update the copy in urlparse.  This code
# duplication does not exist in Python3.

_hexdig = '0123456789ABCDEFabcdef'
_hextochr = dict((a + b, chr(int(a + b, 16)))
                 for a in _hexdig for b in _hexdig)
_asciire = re.compile('([\x00-\x7f]+)')

def unquote(s):
    """unquote('abc%20def') -> 'abc def'."""
    if _is_unicode(s):
        if '%' not in s:
            return s
        bits = _asciire.split(s)
        res = [bits[0]]
        append = res.append
        for i in range(1, len(bits), 2):
            append(unquote(str(bits[i])).decode('latin1'))
            append(bits[i + 1])
        return ''.join(res)

bits = s.split('%')
    # fastpath
    if len(bits) == 1:
        return s
    res = [bits[0]]
    append = res.append
    for item in bits[1:]:
        try:
            append(_hextochr[item[:2]])
            append(item[2:])
        except KeyError:
            append('%')
            append(item)
    return ''.join(res)

def unquote_plus(s):
    """unquote('%7e/abc+def') -> '~/abc def'"""
    s = s.replace('+', ' ')
    return unquote(s)

always_safe = ('ABCDEFGHIJKLMNOPQRSTUVWXYZ'
               'abcdefghijklmnopqrstuvwxyz'
               '0123456789' '_.-')
_safe_map = {}
for i, c in zip(xrange(256), str(bytearray(xrange(256)))):
    _safe_map[c] = c if (i < 128 and c in always_safe) else '%{:02X}'.format(i)
_safe_quoters = {}

def quote(s, safe='/'):
    """quote('abc def') -> 'abc%20def'

Each part of a URL, e.g. the path info, the query, etc., has a
    different set of reserved characters that must be quoted.

RFC 2396 Uniform Resource Identifiers (URI): Generic Syntax lists
    the following reserved characters.

reserved    = ";" | "/" | "?" | ":" | "@" | "&" | "=" | "+" |
                  "$" | ","

Each of these characters is reserved in some component of a URL,
    but not necessarily in all of them.

By default, the quote function is intended for quoting the path
    section of a URL.  Thus, it will not encode '/'.  This character
    is reserved, but in typical usage the quote function is being
    called on a path where the existing slash characters are used as
    reserved characters.
    """
    # fastpath
    if not s:
        if s is None:
            raise TypeError('None object cannot be quoted')
        return s
    cachekey = (safe, always_safe)
    try:
        (quoter, safe) = _safe_quoters[cachekey]
    except KeyError:
        safe_map = _safe_map.copy()
        safe_map.update([(c, c) for c in safe])
        quoter = safe_map.__getitem__
        safe = always_safe + safe
        _safe_quoters[cachekey] = (quoter, safe)
    if not s.rstrip(safe):
        return s
    return ''.join(map(quoter, s))

def quote_plus(s, safe=''):
    """Quote the query fragment of a URL; replacing ' ' with '+'"""
    if ' ' in s:
        s = quote(s, safe + ' ')
        return s.replace(' ', '+')
    return quote(s, safe)

def urlencode(query, doseq=0):
    """Encode a sequence of two-element tuples or dictionary into a URL query string.

If any values in the query arg are sequences and doseq is true, each
    sequence element is converted to a separate parameter.

If the query arg is a sequence of two-element tuples, the order of the
    parameters in the output will match the order of parameters in the
    input.
    """

if hasattr(query,"items"):
        # mapping objects
        query = query.items()
    else:
        # it's a bother at times that strings and string-like objects are
        # sequences...
        try:
            # non-sequence items should not work with len()
            # non-empty strings will fail this
            if len(query) and not isinstance(query[0], tuple):
                raise TypeError
            # zero-length sequences of all types will get here and succeed,
            # but that's a minor nit - since the original implementation
            # allowed empty dicts that type of behavior probably should be
            # preserved for consistency
        except TypeError:
            ty,va,tb = sys.exc_info()
            raise TypeError, "not a valid non-string sequence or mapping object", tb

l = []
    if not doseq:
        # preserve old behavior
        for k, v in query:
            k = quote_plus(str(k))
            v = quote_plus(str(v))
            l.append(k + '=' + v)
    else:
        for k, v in query:
            k = quote_plus(str(k))
            if isinstance(v, str):
                v = quote_plus(v)
                l.append(k + '=' + v)
            elif _is_unicode(v):
                # is there a reasonable way to convert to ASCII?
                # encode generates a string, but "replace" or "ignore"
                # lose information and "strict" can raise UnicodeError
                v = quote_plus(v.encode("ASCII","replace"))
                l.append(k + '=' + v)
            else:
                try:
                    # is this a sufficient test for sequence-ness?
                    len(v)
                except TypeError:
                    # not a sequence
                    v = quote_plus(str(v))
                    l.append(k + '=' + v)
                else:
                    # loop over the sequence
                    for elt in v:
                        l.append(k + '=' + quote_plus(str(elt)))
    return '&'.join(l)

# Proxy handling
def getproxies_environment():
    """Return a dictionary of scheme -> proxy server URL mappings.

Scan the environment for variables named <scheme>_proxy;
    this seems to be the standard convention.  In order to prefer lowercase
    variables, we process the environment in two passes, first matches any
    and second matches only lower case proxies.

If you need a different way, you can pass a proxies dictionary to the
    [Fancy]URLopener constructor.
    """
    # Get all variables
    proxies = {}
    for name, value in os.environ.items():
        name = name.lower()
        if value and name[-6:] == '_proxy':
            proxies[name[:-6]] = value

# CVE-2016-1000110 - If we are running as CGI script, forget HTTP_PROXY
    # (non-all-lowercase) as it may be set from the web server by a "Proxy:"
    # header from the client
    # If "proxy" is lowercase, it will still be used thanks to the next block
    if 'REQUEST_METHOD' in os.environ:
        proxies.pop('http', None)

# Get lowercase variables
    for name, value in os.environ.items():
        if name[-6:] == '_proxy':
            name = name.lower()
            if value:
                proxies[name[:-6]] = value
            else:
                proxies.pop(name[:-6], None)

return proxies

def proxy_bypass_environment(host, proxies=None):
    """Test if proxies should not be used for a particular host.

Checks the proxies dict for the value of no_proxy, which should be a
    list of comma separated DNS suffixes, or '*' for all hosts.
    """
    if proxies is None:
        proxies = getproxies_environment()
    # don't bypass, if no_proxy isn't specified
    try:
        no_proxy = proxies['no']
    except KeyError:
        return 0
    # '*' is special case for always bypass
    if no_proxy == '*':
        return 1
    # strip port off host
    hostonly, port = splitport(host)
    # check if the host ends with any of the DNS suffixes
    no_proxy_list = [proxy.strip() for proxy in no_proxy.split(',')]
    for name in no_proxy_list:
        if name:
            name = name.lstrip('.')  # ignore leading dots
            name = re.escape(name)
            pattern = r'(.+\.)?%s$' % name
            if (re.match(pattern, hostonly, re.I)
                    or re.match(pattern, host, re.I)):
                return 1
    # otherwise, don't bypass
    return 0

if sys.platform == 'darwin':
    from _scproxy import _get_proxy_settings, _get_proxies

def proxy_bypass_macosx_sysconf(host):
        """
        Return True iff this host shouldn't be accessed using a proxy

This function uses the MacOSX framework SystemConfiguration
        to fetch the proxy information.
        """
        import re
        import socket
        from fnmatch import fnmatch

hostonly, port = splitport(host)

def ip2num(ipAddr):
            parts = ipAddr.split('.')
            parts = map(int, parts)
            if len(parts) != 4:
                parts = (parts + [0, 0, 0, 0])[:4]
            return (parts[0] << 24) | (parts[1] << 16) | (parts[2] << 8) | parts[3]

proxy_settings = _get_proxy_settings()

# Check for simple host names:
        if '.' not in host:
            if proxy_settings['exclude_simple']:
                return True

hostIP = None

for value in proxy_settings.get('exceptions', ()):
            # Items in the list are strings like these: *.local, 169.254/16
            if not value: continue

m = re.match(r"(\d+(?:\.\d+)*)(/\d+)?", value)
            if m is not None:
                if hostIP is None:
                    try:
                        hostIP = socket.gethostbyname(hostonly)
                        hostIP = ip2num(hostIP)
                    except socket.error:
                        continue

base = ip2num(m.group(1))
                mask = m.group(2)
                if mask is None:
                    mask = 8 * (m.group(1).count('.') + 1)

else:
                    mask = int(mask[1:])
                mask = 32 - mask

if (hostIP >> mask) == (base >> mask):
                    return True

elif fnmatch(host, value):
                return True

return False

def getproxies_macosx_sysconf():
        """Return a dictionary of scheme -> proxy server URL mappings.

This function uses the MacOSX framework SystemConfiguration
        to fetch the proxy information.
        """
        return _get_proxies()

def proxy_bypass(host):
        """Return True, if a host should be bypassed.

Checks proxy settings gathered from the environment, if specified, or
        from the MacOSX framework SystemConfiguration.
        """
        proxies = getproxies_environment()
        if proxies:
            return proxy_bypass_environment(host, proxies)
        else:
            return proxy_bypass_macosx_sysconf(host)

def getproxies():
        return getproxies_environment() or getproxies_macosx_sysconf()

elif os.name == 'nt':
    def getproxies_registry():
        """Return a dictionary of scheme -> proxy server URL mappings.

Win32 uses the registry to store proxies.

"""
        proxies = {}
        try:
            import _winreg
        except ImportError:
            # Std module, so should be around - but you never know!
            return proxies
        try:
            internetSettings = _winreg.OpenKey(_winreg.HKEY_CURRENT_USER,
                r'Software\Microsoft\Windows\CurrentVersion\Internet Settings')
            proxyEnable = _winreg.QueryValueEx(internetSettings,
                                               'ProxyEnable')[0]
            if proxyEnable:
                # Returned as Unicode but problems if not converted to ASCII
                proxyServer = str(_winreg.QueryValueEx(internetSettings,
                                                       'ProxyServer')[0])
                if '=' in proxyServer:
                    # Per-protocol settings
                    for p in proxyServer.split(';'):
                        protocol, address = p.split('=', 1)
                        # See if address has a type:// prefix
                        import re
                        if not re.match('^([^/:]+)://', address):
                            address = '%s://%s' % (protocol, address)
                        proxies[protocol] = address
                else:
                    # Use one setting for all protocols
                    if proxyServer[:5] == 'http:':
                        proxies['http'] = proxyServer
                    else:
                        proxies['http'] = 'http://%s' % proxyServer
                        proxies['https'] = 'https://%s' % proxyServer
                        proxies['ftp'] = 'ftp://%s' % proxyServer
            internetSettings.Close()
        except (WindowsError, ValueError, TypeError):
            # Either registry key not found etc, or the value in an
            # unexpected format.
            # proxies already set up to be empty so nothing to do
            pass
        return proxies

def getproxies():
        """Return a dictionary of scheme -> proxy server URL mappings.

Returns settings gathered from the environment, if specified,
        or the registry.

"""
        return getproxies_environment() or getproxies_registry()

def proxy_bypass_registry(host):
        try:
            import _winreg
            import re
        except ImportError:
            # Std modules, so should be around - but you never know!
            return 0
        try:
            internetSettings = _winreg.OpenKey(_winreg.HKEY_CURRENT_USER,
                r'Software\Microsoft\Windows\CurrentVersion\Internet Settings')
            proxyEnable = _winreg.QueryValueEx(internetSettings,
                                               'ProxyEnable')[0]
            proxyOverride = str(_winreg.QueryValueEx(internetSettings,
                                                     'ProxyOverride')[0])
            # ^^^^ Returned as Unicode but problems if not converted to ASCII
        except WindowsError:
            return 0
        if not proxyEnable or not proxyOverride:
            return 0
        # try to make a host list from name and IP address.
        rawHost, port = splitport(host)
        host = [rawHost]
        try:
            addr = socket.gethostbyname(rawHost)
            if addr != rawHost:
                host.append(addr)
        except socket.error:
            pass
        try:
            fqdn = socket.getfqdn(rawHost)
            if fqdn != rawHost:
                host.append(fqdn)
        except socket.error:
            pass
        # make a check value list from the registry entry: replace the
        # '<local>' string by the localhost entry and the corresponding
        # canonical entry.
        proxyOverride = proxyOverride.split(';')
        # now check if we match one of the registry values.
        for test in proxyOverride:
            if test == '<local>':
                if '.' not in rawHost:
                    return 1
            test = test.replace(".", r"\.")     # mask dots
            test = test.replace("*", r".*")     # change glob sequence
            test = test.replace("?", r".")      # change glob char
            for val in host:
                # print "%s <--> %s" %( test, val )
                if re.match(test, val, re.I):
                    return 1
        return 0

def proxy_bypass(host):
        """Return True, if the host should be bypassed.

Checks proxy settings gathered from the environment, if specified,
        or the registry.
        """
        proxies = getproxies_environment()
        if proxies:
            return proxy_bypass_environment(host, proxies)
        else:
            return proxy_bypass_registry(host)

else:
    # By default use environment variables
    getproxies = getproxies_environment
    proxy_bypass = proxy_bypass_environment

# Test and time quote() and unquote()
def test1():
    s = ''
    for i in range(256): s = s + chr(i)
    s = s*4
    t0 = time.time()
    qs = quote(s)
    uqs = unquote(qs)
    t1 = time.time()
    if uqs != s:
        print 'Wrong!'
    print repr(s)
    print repr(qs)
    print repr(uqs)
    print round(t1 - t0, 3), 'sec'

def reporthook(blocknum, blocksize, totalsize):
    # Report during remote transfers
    print "Block number: %d, Block size: %d, Total size: %d" % (
        blocknum, blocksize, totalsize)

cmd: