FM / python2.6

/usr/lib/python2.6

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
hotshot/	-	0755	rm
idlelib/	-	0755	rm
json/	-	0755	rm
lib-dynload/	-	0755	rm
lib2to3/	-	0755	rm
logging/	-	0755	rm
multiprocessing/	-	0755	rm
plat-linux2/	-	0755	rm
site-packages/	-	0755	rm
sqlite3/	-	0755	rm
test/	-	0755	rm
wsgiref/	-	0755	rm
xml/	-	0755	rm
abc.py	7034	0644	edit dl rm
abc.pyc	6049	0644	edit dl rm
abc.pyo	5991	0644	edit dl rm
aifc.py	33188	0644	edit dl rm
aifc.pyc	29424	0644	edit dl rm
aifc.pyo	29424	0644	edit dl rm
anydbm.py	2620	0644	edit dl rm
anydbm.pyc	2769	0644	edit dl rm
anydbm.pyo	2769	0644	edit dl rm
ast.py	11347	0644	edit dl rm
ast.pyc	12732	0644	edit dl rm
ast.pyo	12732	0644	edit dl rm
asynchat.py	11402	0644	edit dl rm
asynchat.pyc	8677	0644	edit dl rm
asynchat.pyo	8677	0644	edit dl rm
asyncore.py	20061	0644	edit dl rm
asyncore.pyc	18334	0644	edit dl rm
asyncore.pyo	18334	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	8483	0644	edit dl rm
audiodev.pyo	8483	0644	edit dl rm
base64.py	11335	0755	edit dl rm
base64.pyc	10967	0644	edit dl rm
base64.pyo	10967	0644	edit dl rm
BaseHTTPServer.py	21974	0644	edit dl rm
BaseHTTPServer.pyc	21535	0644	edit dl rm
BaseHTTPServer.pyo	21535	0644	edit dl rm
Bastion.py	5744	0644	edit dl rm
Bastion.pyc	6637	0644	edit dl rm
Bastion.pyo	6637	0644	edit dl rm
bdb.py	20597	0644	edit dl rm
bdb.pyc	18449	0644	edit dl rm
bdb.pyo	18449	0644	edit dl rm
binhex.py	14878	0644	edit dl rm
binhex.pyc	15773	0644	edit dl rm
binhex.pyo	15773	0644	edit dl rm
bisect.py	2662	0644	edit dl rm
bisect.pyc	3163	0644	edit dl rm
bisect.pyo	3163	0644	edit dl rm
calendar.py	23110	0644	edit dl rm
calendar.pyc	28007	0644	edit dl rm
calendar.pyo	28007	0644	edit dl rm
cgi.py	34478	0755	edit dl rm
cgi.pyc	32680	0644	edit dl rm
cgi.pyo	32680	0644	edit dl rm
CGIHTTPServer.py	12773	0644	edit dl rm
CGIHTTPServer.pyc	10794	0644	edit dl rm
CGIHTTPServer.pyo	10794	0644	edit dl rm
cgitb.py	12155	0644	edit dl rm
cgitb.pyc	12425	0644	edit dl rm
cgitb.pyo	12425	0644	edit dl rm
chunk.py	5372	0644	edit dl rm
chunk.pyc	5623	0644	edit dl rm
chunk.pyo	5623	0644	edit dl rm
cmd.py	14962	0644	edit dl rm
cmd.pyc	13914	0644	edit dl rm
cmd.pyo	13914	0644	edit dl rm
code.py	10217	0644	edit dl rm
code.pyc	10395	0644	edit dl rm
code.pyo	10395	0644	edit dl rm
codecs.py	35266	0644	edit dl rm
codecs.pyc	36533	0644	edit dl rm
codecs.pyo	36533	0644	edit dl rm
codeop.py	5999	0644	edit dl rm
codeop.pyc	6616	0644	edit dl rm
codeop.pyo	6616	0644	edit dl rm
collections.py	13730	0644	edit dl rm
collections.pyc	14392	0644	edit dl rm
collections.pyo	14339	0644	edit dl rm
colorsys.py	3459	0644	edit dl rm
colorsys.pyc	4025	0644	edit dl rm
colorsys.pyo	4025	0644	edit dl rm
commands.py	2543	0644	edit dl rm
commands.pyc	2477	0644	edit dl rm
commands.pyo	2477	0644	edit dl rm
compileall.py	5285	0644	edit dl rm
compileall.pyc	4989	0644	edit dl rm
compileall.pyo	4989	0644	edit dl rm
ConfigParser.py	25989	0644	edit dl rm
ConfigParser.pyc	23755	0644	edit dl rm
ConfigParser.pyo	23755	0644	edit dl rm
contextlib.py	4136	0644	edit dl rm
contextlib.pyc	4127	0644	edit dl rm
contextlib.pyo	4127	0644	edit dl rm
Cookie.py	25054	0644	edit dl rm
Cookie.pyc	22067	0644	edit dl rm
Cookie.pyo	22067	0644	edit dl rm
cookielib.py	64726	0644	edit dl rm
cookielib.pyc	55176	0644	edit dl rm
cookielib.pyo	54985	0644	edit dl rm
copy.py	11177	0644	edit dl rm
copy.pyc	11629	0644	edit dl rm
copy.pyo	11533	0644	edit dl rm
copy_reg.py	6800	0644	edit dl rm
copy_reg.pyc	5156	0644	edit dl rm
copy_reg.pyo	5110	0644	edit dl rm
cProfile.py	6337	0755	edit dl rm
cProfile.pyc	6211	0644	edit dl rm
cProfile.pyo	6211	0644	edit dl rm
crypt.py	2229	0644	edit dl rm
crypt.pyc	3043	0644	edit dl rm
crypt.pyo	3043	0644	edit dl rm
csv.py	15730	0644	edit dl rm
csv.pyc	13170	0644	edit dl rm
csv.pyo	13170	0644	edit dl rm
dbhash.py	535	0644	edit dl rm
dbhash.pyc	756	0644	edit dl rm
dbhash.pyo	756	0644	edit dl rm
decimal.py	199273	0644	edit dl rm
decimal.pyc	155185	0644	edit dl rm
decimal.pyo	155119	0644	edit dl rm
difflib.py	81080	0644	edit dl rm
difflib.pyc	61093	0644	edit dl rm
difflib.pyo	61039	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	6449	0644	edit dl rm
dis.pyc	6350	0644	edit dl rm
dis.pyo	6350	0644	edit dl rm
doctest.py	101516	0644	edit dl rm
doctest.pyc	80782	0644	edit dl rm
doctest.pyo	80494	0644	edit dl rm
DocXMLRPCServer.py	10599	0644	edit dl rm
DocXMLRPCServer.pyc	9921	0644	edit dl rm
DocXMLRPCServer.pyo	9813	0644	edit dl rm
dumbdbm.py	8820	0644	edit dl rm
dumbdbm.pyc	6547	0644	edit dl rm
dumbdbm.pyo	6547	0644	edit dl rm
dummy_thread.py	4418	0644	edit dl rm
dummy_thread.pyc	5383	0644	edit dl rm
dummy_thread.pyo	5383	0644	edit dl rm
dummy_threading.py	2804	0644	edit dl rm
dummy_threading.pyc	1295	0644	edit dl rm
dummy_threading.pyo	1295	0644	edit dl rm
filecmp.py	9470	0644	edit dl rm
filecmp.pyc	9592	0644	edit dl rm
filecmp.pyo	9592	0644	edit dl rm
fileinput.py	14143	0644	edit dl rm
fileinput.pyc	14870	0644	edit dl rm
fileinput.pyo	14870	0644	edit dl rm
fnmatch.py	3239	0644	edit dl rm
fnmatch.pyc	3567	0644	edit dl rm
fnmatch.pyo	3567	0644	edit dl rm
formatter.py	14911	0644	edit dl rm
formatter.pyc	19149	0644	edit dl rm
formatter.pyo	19149	0644	edit dl rm
fpformat.py	4699	0644	edit dl rm
fpformat.pyc	4719	0644	edit dl rm
fpformat.pyo	4719	0644	edit dl rm
fractions.py	20073	0644	edit dl rm
fractions.pyc	18041	0644	edit dl rm
fractions.pyo	18041	0644	edit dl rm
ftplib.py	29197	0644	edit dl rm
ftplib.pyc	28387	0644	edit dl rm
ftplib.pyo	28387	0644	edit dl rm
functools.py	2162	0644	edit dl rm
functools.pyc	1921	0644	edit dl rm
functools.pyo	1921	0644	edit dl rm
genericpath.py	3020	0644	edit dl rm
genericpath.pyc	3272	0644	edit dl rm
genericpath.pyo	3272	0644	edit dl rm
getopt.py	7328	0644	edit dl rm
getopt.pyc	6710	0644	edit dl rm
getopt.pyo	6663	0644	edit dl rm
getpass.py	5534	0644	edit dl rm
getpass.pyc	4740	0644	edit dl rm
getpass.pyo	4740	0644	edit dl rm
gettext.py	19968	0644	edit dl rm
gettext.pyc	15674	0644	edit dl rm
gettext.pyo	15674	0644	edit dl rm
glob.py	2249	0644	edit dl rm
glob.pyc	2395	0644	edit dl rm
glob.pyo	2395	0644	edit dl rm
gzip.py	16754	0644	edit dl rm
gzip.pyc	14322	0644	edit dl rm
gzip.pyo	14322	0644	edit dl rm
hashlib.py	4427	0644	edit dl rm
hashlib.pyc	3975	0644	edit dl rm
hashlib.pyo	3975	0644	edit dl rm
heapq.py	15995	0644	edit dl rm
heapq.pyc	12668	0644	edit dl rm
heapq.pyo	12668	0644	edit dl rm
hmac.py	4531	0644	edit dl rm
hmac.pyc	4489	0644	edit dl rm
hmac.pyo	4489	0644	edit dl rm
htmlentitydefs.py	18054	0644	edit dl rm
htmlentitydefs.pyc	6369	0644	edit dl rm
htmlentitydefs.pyo	6369	0644	edit dl rm
htmllib.py	12869	0644	edit dl rm
htmllib.pyc	20202	0644	edit dl rm
htmllib.pyo	20202	0644	edit dl rm
HTMLParser.py	13576	0644	edit dl rm
HTMLParser.pyc	12198	0644	edit dl rm
HTMLParser.pyo	11890	0644	edit dl rm
httplib.py	48797	0644	edit dl rm
httplib.pyc	37578	0644	edit dl rm
httplib.pyo	37382	0644	edit dl rm
ihooks.py	17452	0644	edit dl rm
ihooks.pyc	20699	0644	edit dl rm
ihooks.pyo	20620	0644	edit dl rm
imaplib.py	47771	0644	edit dl rm
imaplib.pyc	45027	0644	edit dl rm
imaplib.pyo	42287	0644	edit dl rm
imghdr.py	3544	0644	edit dl rm
imghdr.pyc	4873	0644	edit dl rm
imghdr.pyo	4873	0644	edit dl rm
imputil.py	26009	0644	edit dl rm
imputil.pyc	15959	0644	edit dl rm
imputil.pyo	15787	0644	edit dl rm
inspect.py	38189	0644	edit dl rm
inspect.pyc	37033	0644	edit dl rm
inspect.pyo	37033	0644	edit dl rm
io.py	66165	0644	edit dl rm
io.pyc	62712	0644	edit dl rm
io.pyo	62712	0644	edit dl rm
keyword.py	1997	0755	edit dl rm
keyword.pyc	2113	0644	edit dl rm
keyword.pyo	2113	0644	edit dl rm
linecache.py	4128	0644	edit dl rm
linecache.pyc	3256	0644	edit dl rm
linecache.pyo	3256	0644	edit dl rm
locale.py	82674	0644	edit dl rm
locale.pyc	46620	0644	edit dl rm
locale.pyo	46620	0644	edit dl rm
macpath.py	6253	0644	edit dl rm
macpath.pyc	7669	0644	edit dl rm
macpath.pyo	7669	0644	edit dl rm
macurl2path.py	3275	0644	edit dl rm
macurl2path.pyc	2815	0644	edit dl rm
macurl2path.pyo	2815	0644	edit dl rm
mailbox.py	75824	0644	edit dl rm
mailbox.pyc	75633	0644	edit dl rm
mailbox.pyo	75584	0644	edit dl rm
mailcap.py	8402	0644	edit dl rm
mailcap.pyc	8051	0644	edit dl rm
mailcap.pyo	8051	0644	edit dl rm
markupbase.py	14350	0644	edit dl rm
markupbase.pyc	9430	0644	edit dl rm
markupbase.pyo	9236	0644	edit dl rm
md5.py	410	0644	edit dl rm
md5.pyc	376	0644	edit dl rm
md5.pyo	376	0644	edit dl rm
mhlib.py	33434	0644	edit dl rm
mhlib.pyc	33981	0644	edit dl rm
mhlib.pyo	33981	0644	edit dl rm
mimetools.py	7168	0644	edit dl rm
mimetools.pyc	8280	0644	edit dl rm
mimetools.pyo	8280	0644	edit dl rm
mimetypes.py	18822	0644	edit dl rm
mimetypes.pyc	16838	0644	edit dl rm
mimetypes.pyo	16838	0644	edit dl rm
MimeWriter.py	6482	0644	edit dl rm
MimeWriter.pyc	7365	0644	edit dl rm
MimeWriter.pyo	7365	0644	edit dl rm
mimify.py	15024	0755	edit dl rm
mimify.pyc	12189	0644	edit dl rm
mimify.pyo	12189	0644	edit dl rm
modulefinder.py	24283	0644	edit dl rm
modulefinder.pyc	18939	0644	edit dl rm
modulefinder.pyo	18851	0644	edit dl rm
multifile.py	4820	0644	edit dl rm
multifile.pyc	5449	0644	edit dl rm
multifile.pyo	5405	0644	edit dl rm
mutex.py	1866	0644	edit dl rm
mutex.pyc	2512	0644	edit dl rm
mutex.pyo	2512	0644	edit dl rm
netrc.py	4111	0644	edit dl rm
netrc.pyc	3586	0644	edit dl rm
netrc.pyo	3586	0644	edit dl rm
new.py	706	0644	edit dl rm
new.pyc	908	0644	edit dl rm
new.pyo	908	0644	edit dl rm
nntplib.py	21470	0644	edit dl rm
nntplib.pyc	21091	0644	edit dl rm
nntplib.pyo	21091	0644	edit dl rm
ntpath.py	17752	0644	edit dl rm
ntpath.pyc	11582	0644	edit dl rm
ntpath.pyo	11535	0644	edit dl rm
nturl2path.py	2239	0644	edit dl rm
nturl2path.pyc	1771	0644	edit dl rm
nturl2path.pyo	1771	0644	edit dl rm
numbers.py	10271	0644	edit dl rm
numbers.pyc	13840	0644	edit dl rm
numbers.pyo	13840	0644	edit dl rm
opcode.py	5248	0644	edit dl rm
opcode.pyc	5907	0644	edit dl rm
opcode.pyo	5907	0644	edit dl rm
optparse.py	60849	0644	edit dl rm
optparse.pyc	53959	0644	edit dl rm
optparse.pyo	53877	0644	edit dl rm
ordereddict.py	36	0644	edit dl rm
ordereddict.pyc	183	0644	edit dl rm
ordereddict.pyo	183	0644	edit dl rm
os.py	25802	0644	edit dl rm
os.pyc	25702	0644	edit dl rm
os.pyo	25702	0644	edit dl rm
os2emxpath.py	4603	0644	edit dl rm
os2emxpath.pyc	4518	0644	edit dl rm
os2emxpath.pyo	4518	0644	edit dl rm
pdb.doc	7899	0644	edit dl rm
pdb.py	45333	0755	edit dl rm
pdb.pyc	43585	0644	edit dl rm
pdb.pyo	43585	0644	edit dl rm
pickle.py	44811	0644	edit dl rm
pickle.pyc	38437	0644	edit dl rm
pickle.pyo	38232	0644	edit dl rm
pickletools.py	74348	0644	edit dl rm
pickletools.pyc	57079	0644	edit dl rm
pickletools.pyo	56182	0644	edit dl rm
pipes.py	9647	0644	edit dl rm
pipes.pyc	9428	0644	edit dl rm
pipes.pyo	9428	0644	edit dl rm
pkgutil.py	20001	0644	edit dl rm
pkgutil.pyc	18954	0644	edit dl rm
pkgutil.pyo	18954	0644	edit dl rm
platform.py	52630	0755	edit dl rm
platform.pyc	38699	0644	edit dl rm
platform.pyo	38699	0644	edit dl rm
plistlib.py	15806	0644	edit dl rm
plistlib.pyc	19926	0644	edit dl rm
plistlib.pyo	19836	0644	edit dl rm
popen2.py	8416	0644	edit dl rm
popen2.pyc	9032	0644	edit dl rm
popen2.pyo	8988	0644	edit dl rm
poplib.py	12825	0644	edit dl rm
poplib.pyc	13352	0644	edit dl rm
poplib.pyo	13352	0644	edit dl rm
posixfile.py	8003	0644	edit dl rm
posixfile.pyc	7700	0644	edit dl rm
posixfile.pyo	7700	0644	edit dl rm
posixpath.py	13119	0644	edit dl rm
posixpath.pyc	11142	0644	edit dl rm
posixpath.pyo	11142	0644	edit dl rm
pprint.py	11932	0644	edit dl rm
pprint.pyc	10356	0644	edit dl rm
pprint.pyo	10181	0644	edit dl rm
profile.py	23510	0755	edit dl rm
profile.pyc	16600	0644	edit dl rm
profile.pyo	16355	0644	edit dl rm
pstats.py	27310	0644	edit dl rm
pstats.pyc	25212	0644	edit dl rm
pstats.pyo	25212	0644	edit dl rm
pty.py	4869	0644	edit dl rm
pty.pyc	4899	0644	edit dl rm
pty.pyo	4899	0644	edit dl rm
pyclbr.py	13282	0644	edit dl rm
pyclbr.pyc	9706	0644	edit dl rm
pyclbr.pyo	9706	0644	edit dl rm
pydoc.py	92432	0755	edit dl rm
pydoc.pyc	90662	0644	edit dl rm
pydoc.pyo	90594	0644	edit dl rm
pydoc_topics.py	423126	0644	edit dl rm
pydoc_topics.pyc	407586	0644	edit dl rm
pydoc_topics.pyo	407586	0644	edit dl rm
py_compile.py	5633	0644	edit dl rm
py_compile.pyc	6536	0644	edit dl rm
py_compile.pyo	6536	0644	edit dl rm
Queue.py	8574	0644	edit dl rm
Queue.pyc	9391	0644	edit dl rm
Queue.pyo	9391	0644	edit dl rm
quopri.py	6972	0755	edit dl rm
quopri.pyc	6666	0644	edit dl rm
quopri.pyo	6666	0644	edit dl rm
random.py	31966	0644	edit dl rm
random.pyc	25024	0644	edit dl rm
random.pyo	25024	0644	edit dl rm
re.py	12966	0644	edit dl rm
re.pyc	13122	0644	edit dl rm
re.pyo	13122	0644	edit dl rm
repr.py	4296	0644	edit dl rm
repr.pyc	5400	0644	edit dl rm
repr.pyo	5400	0644	edit dl rm
rexec.py	20152	0644	edit dl rm
rexec.pyc	24102	0644	edit dl rm
rexec.pyo	24102	0644	edit dl rm
rfc822.py	33295	0644	edit dl rm
rfc822.pyc	31990	0644	edit dl rm
rfc822.pyo	31990	0644	edit dl rm
rlcompleter.py	5866	0644	edit dl rm
rlcompleter.pyc	6057	0644	edit dl rm
rlcompleter.pyo	6057	0644	edit dl rm
robotparser.py	7014	0644	edit dl rm
robotparser.pyc	7804	0644	edit dl rm
robotparser.pyo	7804	0644	edit dl rm
runpy.py	5413	0644	edit dl rm
runpy.pyc	3965	0644	edit dl rm
runpy.pyo	3965	0644	edit dl rm
sched.py	5091	0644	edit dl rm
sched.pyc	4987	0644	edit dl rm
sched.pyo	4987	0644	edit dl rm
sets.py	19050	0644	edit dl rm
sets.pyc	16885	0644	edit dl rm
sets.pyo	16885	0644	edit dl rm
sgmllib.py	17884	0644	edit dl rm
sgmllib.pyc	15504	0644	edit dl rm
sgmllib.pyo	15504	0644	edit dl rm
sha.py	445	0644	edit dl rm
sha.pyc	419	0644	edit dl rm
sha.pyo	419	0644	edit dl rm
shelve.py	8078	0644	edit dl rm
shelve.pyc	10242	0644	edit dl rm
shelve.pyo	10242	0644	edit dl rm
shlex.py	11137	0644	edit dl rm
shlex.pyc	7684	0644	edit dl rm
shlex.pyo	7684	0644	edit dl rm
shutil.py	8632	0644	edit dl rm
shutil.pyc	9519	0644	edit dl rm
shutil.pyo	9519	0644	edit dl rm
SimpleHTTPServer.py	7422	0644	edit dl rm
SimpleHTTPServer.pyc	7744	0644	edit dl rm
SimpleHTTPServer.pyo	7744	0644	edit dl rm
SimpleXMLRPCServer.py	21992	0644	edit dl rm
SimpleXMLRPCServer.pyc	19575	0644	edit dl rm
SimpleXMLRPCServer.pyo	19575	0644	edit dl rm
site.py	18927	0644	edit dl rm
site.pyc	18663	0644	edit dl rm
site.pyo	18663	0644	edit dl rm
smtpd.py	18920	0755	edit dl rm
smtpd.pyc	16126	0644	edit dl rm
smtpd.pyo	16126	0644	edit dl rm
smtplib.py	30924	0755	edit dl rm
smtplib.pyc	29629	0644	edit dl rm
smtplib.pyo	29629	0644	edit dl rm
sndhdr.py	5973	0644	edit dl rm
sndhdr.pyc	7386	0644	edit dl rm
sndhdr.pyo	7386	0644	edit dl rm
socket.py	20149	0644	edit dl rm
socket.pyc	16067	0644	edit dl rm
socket.pyo	15982	0644	edit dl rm
SocketServer.py	22326	0644	edit dl rm
SocketServer.pyc	23035	0644	edit dl rm
SocketServer.pyo	23035	0644	edit dl rm
sre.py	384	0644	edit dl rm
sre.pyc	517	0644	edit dl rm
sre.pyo	517	0644	edit dl rm
sre_compile.py	16507	0644	edit dl rm
sre_compile.pyc	11455	0644	edit dl rm
sre_compile.pyo	11342	0644	edit dl rm
sre_constants.py	7137	0644	edit dl rm
sre_constants.pyc	6083	0644	edit dl rm
sre_constants.pyo	6083	0644	edit dl rm
sre_parse.py	26878	0644	edit dl rm
sre_parse.pyc	19622	0644	edit dl rm
sre_parse.pyo	19622	0644	edit dl rm
ssl.py	16677	0644	edit dl rm
ssl.pyc	14218	0644	edit dl rm
ssl.pyo	14218	0644	edit dl rm
stat.py	1718	0644	edit dl rm
stat.pyc	2683	0644	edit dl rm
stat.pyo	2683	0644	edit dl rm
statvfs.py	898	0644	edit dl rm
statvfs.pyc	618	0644	edit dl rm
statvfs.pyo	618	0644	edit dl rm
string.py	20745	0644	edit dl rm
string.pyc	19964	0644	edit dl rm
string.pyo	19964	0644	edit dl rm
StringIO.py	10621	0644	edit dl rm
StringIO.pyc	11494	0644	edit dl rm
StringIO.pyo	11494	0644	edit dl rm
stringold.py	12449	0644	edit dl rm
stringold.pyc	12539	0644	edit dl rm
stringold.pyo	12539	0644	edit dl rm
stringprep.py	13522	0644	edit dl rm
stringprep.pyc	14486	0644	edit dl rm
stringprep.pyo	14412	0644	edit dl rm
struct.py	82	0644	edit dl rm
struct.pyc	237	0644	edit dl rm
struct.pyo	237	0644	edit dl rm
subprocess.py	57945	0644	edit dl rm
subprocess.pyc	40975	0644	edit dl rm
subprocess.pyo	40918	0644	edit dl rm
sunau.py	16537	0644	edit dl rm
sunau.pyc	17976	0644	edit dl rm
sunau.pyo	17976	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	2050	0755	edit dl rm
symbol.pyc	3021	0644	edit dl rm
symbol.pyo	3021	0644	edit dl rm
symtable.py	7911	0644	edit dl rm
symtable.pyc	12503	0644	edit dl rm
symtable.pyo	12373	0644	edit dl rm
tabnanny.py	11339	0755	edit dl rm
tabnanny.pyc	8293	0644	edit dl rm
tabnanny.pyo	8293	0644	edit dl rm
tarfile.py	87786	0644	edit dl rm
tarfile.pyc	73596	0644	edit dl rm
tarfile.pyo	73596	0644	edit dl rm
telnetlib.py	21808	0644	edit dl rm
telnetlib.pyc	19855	0644	edit dl rm
telnetlib.pyo	19855	0644	edit dl rm
tempfile.py	17774	0644	edit dl rm
tempfile.pyc	19463	0644	edit dl rm
tempfile.pyo	19463	0644	edit dl rm
textwrap.py	16889	0644	edit dl rm
textwrap.pyc	11766	0644	edit dl rm
textwrap.pyo	11674	0644	edit dl rm
this.py	1002	0644	edit dl rm
this.pyc	1239	0644	edit dl rm
this.pyo	1239	0644	edit dl rm
threading.py	31808	0644	edit dl rm
threading.pyc	27956	0644	edit dl rm
threading.pyo	25884	0644	edit dl rm
timeit.py	12003	0644	edit dl rm
timeit.pyc	11801	0644	edit dl rm
timeit.pyo	11801	0644	edit dl rm
toaiff.py	3142	0644	edit dl rm
toaiff.pyc	3126	0644	edit dl rm
toaiff.pyo	3126	0644	edit dl rm
token.py	2947	0755	edit dl rm
token.pyc	3830	0644	edit dl rm
token.pyo	3830	0644	edit dl rm
tokenize.py	16326	0644	edit dl rm
tokenize.pyc	13986	0644	edit dl rm
tokenize.pyo	13893	0644	edit dl rm
trace.py	30325	0644	edit dl rm
trace.pyc	22989	0644	edit dl rm
trace.pyo	22927	0644	edit dl rm
traceback.py	11211	0644	edit dl rm
traceback.pyc	11637	0644	edit dl rm
traceback.pyo	11637	0644	edit dl rm
tty.py	879	0644	edit dl rm
tty.pyc	1311	0644	edit dl rm
tty.pyo	1311	0644	edit dl rm
types.py	2323	0644	edit dl rm
types.pyc	2608	0644	edit dl rm
types.pyo	2608	0644	edit dl rm
unittest.py	31157	0644	edit dl rm
unittest.pyc	34656	0644	edit dl rm
unittest.pyo	34656	0644	edit dl rm
urllib.py	59022	0644	edit dl rm
urllib.pyc	51142	0644	edit dl rm
urllib.pyo	51048	0644	edit dl rm
urllib2.py	50866	0644	edit dl rm
urllib2.pyc	45569	0644	edit dl rm
urllib2.pyo	45475	0644	edit dl rm
urlparse.py	15618	0644	edit dl rm
urlparse.pyc	14727	0644	edit dl rm
urlparse.pyo	14727	0644	edit dl rm
user.py	1627	0644	edit dl rm
user.pyc	1734	0644	edit dl rm
user.pyo	1734	0644	edit dl rm
UserDict.py	5778	0644	edit dl rm
UserDict.pyc	8802	0644	edit dl rm
UserDict.pyo	8802	0644	edit dl rm
UserList.py	3644	0644	edit dl rm
UserList.pyc	6535	0644	edit dl rm
UserList.pyo	6535	0644	edit dl rm
UserString.py	9691	0755	edit dl rm
UserString.pyc	14786	0644	edit dl rm
UserString.pyo	14786	0644	edit dl rm
uu.py	5942	0755	edit dl rm
uu.pyc	4227	0644	edit dl rm
uu.pyo	4227	0644	edit dl rm
uuid.py	20944	0644	edit dl rm
uuid.pyc	21205	0644	edit dl rm
uuid.pyo	21205	0644	edit dl rm
warnings.py	14172	0644	edit dl rm
warnings.pyc	12996	0644	edit dl rm
warnings.pyo	12159	0644	edit dl rm
wave.py	17952	0644	edit dl rm
wave.pyc	19336	0644	edit dl rm
wave.pyo	19336	0644	edit dl rm
weakref.py	10087	0644	edit dl rm
weakref.pyc	13277	0644	edit dl rm
weakref.pyo	13277	0644	edit dl rm
webbrowser.py	21073	0644	edit dl rm
webbrowser.pyc	18669	0644	edit dl rm
webbrowser.pyo	18622	0644	edit dl rm
whichdb.py	3353	0644	edit dl rm
whichdb.pyc	2243	0644	edit dl rm
whichdb.pyo	2243	0644	edit dl rm
xdrlib.py	5513	0644	edit dl rm
xdrlib.pyc	9079	0644	edit dl rm
xdrlib.pyo	9079	0644	edit dl rm
xmllib.py	34865	0644	edit dl rm
xmllib.pyc	27166	0644	edit dl rm
xmllib.pyo	27166	0644	edit dl rm
xmlrpclib.py	47775	0644	edit dl rm
xmlrpclib.pyc	41230	0644	edit dl rm
xmlrpclib.pyo	41047	0644	edit dl rm
zipfile.py	53092	0644	edit dl rm
zipfile.pyc	37547	0644	edit dl rm
zipfile.pyo	37547	0644	edit dl rm
_abcoll.py	14242	0644	edit dl rm
_abcoll.pyc	21395	0644	edit dl rm
_abcoll.pyo	21395	0644	edit dl rm
_LWPCookieJar.py	6553	0644	edit dl rm
_LWPCookieJar.pyc	5589	0644	edit dl rm
_LWPCookieJar.pyo	5589	0644	edit dl rm
_MozillaCookieJar.py	5809	0644	edit dl rm
_MozillaCookieJar.pyc	4509	0644	edit dl rm
_MozillaCookieJar.pyo	4468	0644	edit dl rm
_strptime.py	19754	0644	edit dl rm
_strptime.pyc	14926	0644	edit dl rm
_strptime.pyo	14926	0644	edit dl rm
_threading_local.py	7114	0644	edit dl rm
_threading_local.pyc	6367	0644	edit dl rm
_threading_local.pyo	6367	0644	edit dl rm
__future__.py	4380	0644	edit dl rm
__future__.pyc	4221	0644	edit dl rm
__future__.pyo	4221	0644	edit dl rm
__phello__.foo.py	64	0644	edit dl rm
__phello__.foo.pyc	123	0644	edit dl rm
__phello__.foo.pyo	123	0644	edit dl rm

Edit: /usr/lib/python2.6/subprocess.py (57945B)

# subprocess - Subprocesses with accessible I/O streams
#
# For more information about this module, see PEP 324.
#
# This module should remain compatible with Python 2.2, see PEP 291.
#
# Copyright (c) 2003-2005 by Peter Astrand <astrand@lysator.liu.se>
#
# Licensed to PSF under a Contributor Agreement.
# See http://www.python.org/2.4/license for licensing details.

r"""subprocess - Subprocesses with accessible I/O streams

This module allows you to spawn processes, connect to their
input/output/error pipes, and obtain their return codes.  This module
intends to replace several other, older modules and functions, like:

os.system
os.spawn*
os.popen*
popen2.*
commands.*

Information about how the subprocess module can be used to replace these
modules and functions can be found below.

Using the subprocess module
===========================
This module defines one class called Popen:

class Popen(args, bufsize=0, executable=None,
            stdin=None, stdout=None, stderr=None,
            preexec_fn=None, close_fds=False, shell=False,
            cwd=None, env=None, universal_newlines=False,
            startupinfo=None, creationflags=0):

Arguments are:

args should be a string, or a sequence of program arguments.  The
program to execute is normally the first item in the args sequence or
string, but can be explicitly set by using the executable argument.

On UNIX, with shell=False (default): In this case, the Popen class
uses os.execvp() to execute the child program.  args should normally
be a sequence.  A string will be treated as a sequence with the string
as the only item (the program to execute).

On UNIX, with shell=True: If args is a string, it specifies the
command string to execute through the shell.  If args is a sequence,
the first item specifies the command string, and any additional items
will be treated as additional shell arguments.

On Windows: the Popen class uses CreateProcess() to execute the child
program, which operates on strings.  If args is a sequence, it will be
converted to a string using the list2cmdline method.  Please note that
not all MS Windows applications interpret the command line the same
way: The list2cmdline is designed for applications using the same
rules as the MS C runtime.

bufsize, if given, has the same meaning as the corresponding argument
to the built-in open() function: 0 means unbuffered, 1 means line
buffered, any other positive value means use a buffer of
(approximately) that size.  A negative bufsize means to use the system
default, which usually means fully buffered.  The default value for
bufsize is 0 (unbuffered).

stdin, stdout and stderr specify the executed programs' standard
input, standard output and standard error file handles, respectively.
Valid values are PIPE, an existing file descriptor (a positive
integer), an existing file object, and None.  PIPE indicates that a
new pipe to the child should be created.  With None, no redirection
will occur; the child's file handles will be inherited from the
parent.  Additionally, stderr can be STDOUT, which indicates that the
stderr data from the applications should be captured into the same
file handle as for stdout.

If preexec_fn is set to a callable object, this object will be called
in the child process just before the child is executed.

If close_fds is true, all file descriptors except 0, 1 and 2 will be
closed before the child process is executed.

if shell is true, the specified command will be executed through the
shell.

If cwd is not None, the current directory will be changed to cwd
before the child is executed.

If env is not None, it defines the environment variables for the new
process.

If universal_newlines is true, the file objects stdout and stderr are
opened as a text files, but lines may be terminated by any of '\n',
the Unix end-of-line convention, '\r', the Macintosh convention or
'\r\n', the Windows convention.  All of these external representations
are seen as '\n' by the Python program.  Note: This feature is only
available if Python is built with universal newline support (the
default).  Also, the newlines attribute of the file objects stdout,
stdin and stderr are not updated by the communicate() method.

The startupinfo and creationflags, if given, will be passed to the
underlying CreateProcess() function.  They can specify things such as
appearance of the main window and priority for the new process.
(Windows only)

This module also defines two shortcut functions:

call(*popenargs, **kwargs):
    Run command with arguments.  Wait for command to complete, then
    return the returncode attribute.

The arguments are the same as for the Popen constructor.  Example:

retcode = call(["ls", "-l"])

check_call(*popenargs, **kwargs):
    Run command with arguments.  Wait for command to complete.  If the
    exit code was zero then return, otherwise raise
    CalledProcessError.  The CalledProcessError object will have the
    return code in the returncode attribute.

The arguments are the same as for the Popen constructor.  Example:

check_call(["ls", "-l"])

Exceptions
----------
Exceptions raised in the child process, before the new program has
started to execute, will be re-raised in the parent.  Additionally,
the exception object will have one extra attribute called
'child_traceback', which is a string containing traceback information
from the childs point of view.

The most common exception raised is OSError.  This occurs, for
example, when trying to execute a non-existent file.  Applications
should prepare for OSErrors.

A ValueError will be raised if Popen is called with invalid arguments.

check_call() will raise CalledProcessError, if the called process
returns a non-zero return code.

Security
--------
Unlike some other popen functions, this implementation will never call
/bin/sh implicitly.  This means that all characters, including shell
metacharacters, can safely be passed to child processes.

Popen objects
=============
Instances of the Popen class have the following methods:

poll()
    Check if child process has terminated.  Returns returncode
    attribute.

wait()
    Wait for child process to terminate.  Returns returncode attribute.

communicate(input=None)
    Interact with process: Send data to stdin.  Read data from stdout
    and stderr, until end-of-file is reached.  Wait for process to
    terminate.  The optional input argument should be a string to be
    sent to the child process, or None, if no data should be sent to
    the child.

communicate() returns a tuple (stdout, stderr).

Note: The data read is buffered in memory, so do not use this
    method if the data size is large or unlimited.

The following attributes are also available:

stdin
    If the stdin argument is PIPE, this attribute is a file object
    that provides input to the child process.  Otherwise, it is None.

stdout
    If the stdout argument is PIPE, this attribute is a file object
    that provides output from the child process.  Otherwise, it is
    None.

stderr
    If the stderr argument is PIPE, this attribute is file object that
    provides error output from the child process.  Otherwise, it is
    None.

pid
    The process ID of the child process.

returncode
    The child return code.  A None value indicates that the process
    hasn't terminated yet.  A negative value -N indicates that the
    child was terminated by signal N (UNIX only).

Replacing older functions with the subprocess module
====================================================
In this section, "a ==> b" means that b can be used as a replacement
for a.

Note: All functions in this section fail (more or less) silently if
the executed program cannot be found; this module raises an OSError
exception.

In the following examples, we assume that the subprocess module is
imported with "from subprocess import *".

Replacing /bin/sh shell backquote
---------------------------------
output=`mycmd myarg`
==>
output = Popen(["mycmd", "myarg"], stdout=PIPE).communicate()[0]

Replacing shell pipe line
-------------------------
output=`dmesg | grep hda`
==>
p1 = Popen(["dmesg"], stdout=PIPE)
p2 = Popen(["grep", "hda"], stdin=p1.stdout, stdout=PIPE)
output = p2.communicate()[0]

Replacing os.system()
---------------------
sts = os.system("mycmd" + " myarg")
==>
p = Popen("mycmd" + " myarg", shell=True)
pid, sts = os.waitpid(p.pid, 0)

Note:

* Calling the program through the shell is usually not required.

* It's easier to look at the returncode attribute than the
  exitstatus.

A more real-world example would look like this:

try:
    retcode = call("mycmd" + " myarg", shell=True)
    if retcode < 0:
        print >>sys.stderr, "Child was terminated by signal", -retcode
    else:
        print >>sys.stderr, "Child returned", retcode
except OSError, e:
    print >>sys.stderr, "Execution failed:", e

Replacing os.spawn*
-------------------
P_NOWAIT example:

pid = os.spawnlp(os.P_NOWAIT, "/bin/mycmd", "mycmd", "myarg")
==>
pid = Popen(["/bin/mycmd", "myarg"]).pid

P_WAIT example:

retcode = os.spawnlp(os.P_WAIT, "/bin/mycmd", "mycmd", "myarg")
==>
retcode = call(["/bin/mycmd", "myarg"])

Vector example:

os.spawnvp(os.P_NOWAIT, path, args)
==>
Popen([path] + args[1:])

Environment example:

os.spawnlpe(os.P_NOWAIT, "/bin/mycmd", "mycmd", "myarg", env)
==>
Popen(["/bin/mycmd", "myarg"], env={"PATH": "/usr/bin"})

Replacing os.popen*
-------------------
pipe = os.popen("cmd", mode='r', bufsize)
==>
pipe = Popen("cmd", shell=True, bufsize=bufsize, stdout=PIPE).stdout

pipe = os.popen("cmd", mode='w', bufsize)
==>
pipe = Popen("cmd", shell=True, bufsize=bufsize, stdin=PIPE).stdin

(child_stdin, child_stdout) = os.popen2("cmd", mode, bufsize)
==>
p = Popen("cmd", shell=True, bufsize=bufsize,
          stdin=PIPE, stdout=PIPE, close_fds=True)
(child_stdin, child_stdout) = (p.stdin, p.stdout)

(child_stdin,
 child_stdout,
 child_stderr) = os.popen3("cmd", mode, bufsize)
==>
p = Popen("cmd", shell=True, bufsize=bufsize,
          stdin=PIPE, stdout=PIPE, stderr=PIPE, close_fds=True)
(child_stdin,
 child_stdout,
 child_stderr) = (p.stdin, p.stdout, p.stderr)

(child_stdin, child_stdout_and_stderr) = os.popen4("cmd", mode,
                                                   bufsize)
==>
p = Popen("cmd", shell=True, bufsize=bufsize,
          stdin=PIPE, stdout=PIPE, stderr=STDOUT, close_fds=True)
(child_stdin, child_stdout_and_stderr) = (p.stdin, p.stdout)

On Unix, os.popen2, os.popen3 and os.popen4 also accept a sequence as
the command to execute, in which case arguments will be passed
directly to the program without shell intervention.  This usage can be
replaced as follows:

(child_stdin, child_stdout) = os.popen2(["/bin/ls", "-l"], mode,
                                        bufsize)
==>
p = Popen(["/bin/ls", "-l"], bufsize=bufsize, stdin=PIPE, stdout=PIPE)
(child_stdin, child_stdout) = (p.stdin, p.stdout)

Return code handling translates as follows:

pipe = os.popen("cmd", 'w')
...
rc = pipe.close()
if rc != None and rc % 256:
    print "There were some errors"
==>
process = Popen("cmd", 'w', shell=True, stdin=PIPE)
...
process.stdin.close()
if process.wait() != 0:
    print "There were some errors"

Replacing popen2.*
------------------
(child_stdout, child_stdin) = popen2.popen2("somestring", bufsize, mode)
==>
p = Popen(["somestring"], shell=True, bufsize=bufsize
          stdin=PIPE, stdout=PIPE, close_fds=True)
(child_stdout, child_stdin) = (p.stdout, p.stdin)

On Unix, popen2 also accepts a sequence as the command to execute, in
which case arguments will be passed directly to the program without
shell intervention.  This usage can be replaced as follows:

(child_stdout, child_stdin) = popen2.popen2(["mycmd", "myarg"], bufsize,
                                            mode)
==>
p = Popen(["mycmd", "myarg"], bufsize=bufsize,
          stdin=PIPE, stdout=PIPE, close_fds=True)
(child_stdout, child_stdin) = (p.stdout, p.stdin)

The popen2.Popen3 and popen2.Popen4 basically works as subprocess.Popen,
except that:

* subprocess.Popen raises an exception if the execution fails
* the capturestderr argument is replaced with the stderr argument.
* stdin=PIPE and stdout=PIPE must be specified.
* popen2 closes all filedescriptors by default, but you have to specify
  close_fds=True with subprocess.Popen.
"""

import sys
mswindows = (sys.platform == "win32")

import os
import types
import traceback
import gc
import signal
import errno
import time

# Exception classes used by this module.
class CalledProcessError(Exception):
    """This exception is raised when a process run by check_call() returns
    a non-zero exit status.  The exit status will be stored in the
    returncode attribute."""
    def __init__(self, returncode, cmd):
        self.returncode = returncode
        self.cmd = cmd
    def __str__(self):
        return "Command '%s' returned non-zero exit status %d" % (self.cmd, self.returncode)

class TimeoutExpired(Exception):
    """This exception is raised when the timeout expires while waiting for a
    child process.
    """

if mswindows:
    from _subprocess import CREATE_NEW_CONSOLE
    import threading
    import msvcrt
    import _subprocess
    class STARTUPINFO:
        dwFlags = 0
        hStdInput = None
        hStdOutput = None
        hStdError = None
        wShowWindow = 0
    class pywintypes:
        error = IOError
else:
    import select
    _has_poll = hasattr(select, 'poll')
    import fcntl
    import pickle

# When select or poll has indicated that the file is writable,
    # we can write up to _PIPE_BUF bytes without risk of blocking.
    # POSIX defines PIPE_BUF as >= 512.
    _PIPE_BUF = getattr(select, 'PIPE_BUF', 512)

__all__ = ["Popen", "PIPE", "STDOUT", "call", "check_call", "CalledProcessError"]

if mswindows:
    __all__.append("CREATE_NEW_CONSOLE")
try:
    MAXFD = os.sysconf("SC_OPEN_MAX")
except:
    MAXFD = 256

_active = []

def _cleanup():
    for inst in _active[:]:
        res = inst._internal_poll(_deadstate=sys.maxint)
        if res is not None and res >= 0:
            try:
                _active.remove(inst)
            except ValueError:
                # This can happen if two threads create a new Popen instance.
                # It's harmless that it was already removed, so ignore.
                pass

PIPE = -1
STDOUT = -2

def _eintr_retry_call(func, *args):
    while True:
        try:
            return func(*args)
        except (OSError, IOError) as e:
            if e.errno == errno.EINTR:
                continue
            raise

def call(*popenargs, **kwargs):
    """Run command with arguments.  Wait for command to complete or
    timeout, then return the returncode attribute.

The arguments are the same as for the Popen constructor.  Example:

retcode = call(["ls", "-l"])
    """
    timeout = kwargs.pop('timeout', None)
    p = Popen(*popenargs, **kwargs)
    try:
        if timeout == None:
            return p.wait()
        else:
            return p.wait(timeout=timeout)
    except TimeoutExpired:
        p.kill()
        p.wait()
        raise

def check_call(*popenargs, **kwargs):
    """Run command with arguments.  Wait for command to complete.  If
    the exit code was zero then return, otherwise raise
    CalledProcessError.  The CalledProcessError object will have the
    return code in the returncode attribute.

The arguments are the same as for the Popen constructor.  Example:

check_call(["ls", "-l"])
    """
    retcode = call(*popenargs, **kwargs)
    cmd = kwargs.get("args")
    if cmd is None:
        cmd = popenargs[0]
    if retcode:
        raise CalledProcessError(retcode, cmd)
    return retcode

def list2cmdline(seq):
    """
    Translate a sequence of arguments into a command line
    string, using the same rules as the MS C runtime:

1) Arguments are delimited by white space, which is either a
       space or a tab.

2) A string surrounded by double quotation marks is
       interpreted as a single argument, regardless of white space
       contained within.  A quoted string can be embedded in an
       argument.

3) A double quotation mark preceded by a backslash is
       interpreted as a literal double quotation mark.

4) Backslashes are interpreted literally, unless they
       immediately precede a double quotation mark.

5) If backslashes immediately precede a double quotation mark,
       every pair of backslashes is interpreted as a literal
       backslash.  If the number of backslashes is odd, the last
       backslash escapes the next double quotation mark as
       described in rule 3.
    """

# See
    # http://msdn.microsoft.com/en-us/library/17w5ykft.aspx
    # or search http://msdn.microsoft.com for
    # "Parsing C++ Command-Line Arguments"
    result = []
    needquote = False
    for arg in seq:
        bs_buf = []

# Add a space to separate this argument from the others
        if result:
            result.append(' ')

needquote = (" " in arg) or ("\t" in arg) or not arg
        if needquote:
            result.append('"')

for c in arg:
            if c == '\\':
                # Don't know if we need to double yet.
                bs_buf.append(c)
            elif c == '"':
                # Double backslashes.
                result.append('\\' * len(bs_buf)*2)
                bs_buf = []
                result.append('\\"')
            else:
                # Normal char
                if bs_buf:
                    result.extend(bs_buf)
                    bs_buf = []
                result.append(c)

# Add remaining backslashes, if any.
        if bs_buf:
            result.extend(bs_buf)

if needquote:
            result.extend(bs_buf)
            result.append('"')

return ''.join(result)

class Popen(object):
    def __init__(self, args, bufsize=0, executable=None,
                 stdin=None, stdout=None, stderr=None,
                 preexec_fn=None, close_fds=False, shell=False,
                 cwd=None, env=None, universal_newlines=False,
                 startupinfo=None, creationflags=0):
        """Create new Popen instance."""
        _cleanup()

self._child_created = False
        self._input = None
        self._communication_started = False
        if not isinstance(bufsize, (int, long)):
            raise TypeError("bufsize must be an integer")

if mswindows:
            if preexec_fn is not None:
                raise ValueError("preexec_fn is not supported on Windows "
                                 "platforms")
            if close_fds and (stdin is not None or stdout is not None or
                              stderr is not None):
                raise ValueError("close_fds is not supported on Windows "
                                 "platforms if you redirect stdin/stdout/stderr")
        else:
            # POSIX
            if startupinfo is not None:
                raise ValueError("startupinfo is only supported on Windows "
                                 "platforms")
            if creationflags != 0:
                raise ValueError("creationflags is only supported on Windows "
                                 "platforms")

self.stdin = None
        self.stdout = None
        self.stderr = None
        self.pid = None
        self.returncode = None
        self.universal_newlines = universal_newlines

# Input and output objects. The general principle is like
        # this:
        #
        # Parent                   Child
        # ------                   -----
        # p2cwrite   ---stdin--->  p2cread
        # c2pread    <--stdout---  c2pwrite
        # errread    <--stderr---  errwrite
        #
        # On POSIX, the child objects are file descriptors.  On
        # Windows, these are Windows file handles.  The parent objects
        # are file descriptors on both platforms.  The parent objects
        # are None when not using PIPEs. The child objects are None
        # when not redirecting.

(p2cread, p2cwrite,
         c2pread, c2pwrite,
         errread, errwrite) = self._get_handles(stdin, stdout, stderr)

self._execute_child(args, executable, preexec_fn, close_fds,
                            cwd, env, universal_newlines,
                            startupinfo, creationflags, shell,
                            p2cread, p2cwrite,
                            c2pread, c2pwrite,
                            errread, errwrite)

if mswindows:
            if p2cwrite is not None:
                p2cwrite = msvcrt.open_osfhandle(p2cwrite.Detach(), 0)
            if c2pread is not None:
                c2pread = msvcrt.open_osfhandle(c2pread.Detach(), 0)
            if errread is not None:
                errread = msvcrt.open_osfhandle(errread.Detach(), 0)

if p2cwrite is not None:
            self.stdin = os.fdopen(p2cwrite, 'wb', bufsize)
        if c2pread is not None:
            if universal_newlines:
                self.stdout = os.fdopen(c2pread, 'rU', bufsize)
            else:
                self.stdout = os.fdopen(c2pread, 'rb', bufsize)
        if errread is not None:
            if universal_newlines:
                self.stderr = os.fdopen(errread, 'rU', bufsize)
            else:
                self.stderr = os.fdopen(errread, 'rb', bufsize)

def _translate_newlines(self, data):
        data = data.replace("\r\n", "\n")
        data = data.replace("\r", "\n")
        return data

def __del__(self, _maxint=sys.maxint, _active=_active):
        if not self._child_created:
            # We didn't get to successfully create a child process.
            return
        # In case the child hasn't been waited on, check if it's done.
        self._internal_poll(_deadstate=_maxint)
        if self.returncode is None and _active is not None:
            # Child is still running, keep us alive until we can wait on it.
            _active.append(self)

def communicate(self, input=None, timeout=None):
        """Interact with process: Send data to stdin.  Read data from
        stdout and stderr, until end-of-file is reached.  Wait for
        process to terminate.  The optional input argument should be a
        string to be sent to the child process, or None, if no data
        should be sent to the child.

communicate() returns a tuple (stdout, stderr).
        
        The optional "timeout" argument is a non-standard addition to
        Python 2.6.  If supplied, it is a number of seconds, which can be an
        integer or a float (though there are no precision guarantees).  A
        TimeoutExpired exception will be raised after the given number of
        seconds elapses, if the call has not yet returned.
        """

if self._communication_started and input:
            raise ValueError("Cannot send input after starting communication")

if timeout is not None:
            endtime = time.time() + timeout
        else:
            endtime = None

# Optimization: If we are not worried about timeouts, we haven't
        # started communicating, and we have one or zero pipes, using select()
        # or threads is unnecessary.
        if (endtime is None and not self._communication_started and
            [self.stdin, self.stdout, self.stderr].count(None) >= 2):
            stdout = None
            stderr = None
            if self.stdin:
                if input:
                    try:
                        self.stdin.write(input)
                    except IOError as e:
                        if e.errno != errno.EPIPE and e.errno != errno.EINVAL:
                            raise
                self.stdin.close()
            elif self.stdout:
                stdout = _eintr_retry_call(self.stdout.read)
                self.stdout.close()
            elif self.stderr:
                stderr = _eintr_retry_call(self.stderr.read)
                self.stderr.close()
            self.wait()
            return (stdout, stderr)

try:
            stdout, stderr = self._communicate(input, endtime)
        finally:
            self._communication_started = True

# All data exchanged.  Translate lists into strings.
        if stdout is not None:
            stdout = ''.join(stdout)
        if stderr is not None:
            stderr = ''.join(stderr)

# Translate newlines, if requested.  We cannot let the file
        # object do the translation: It is based on stdio, which is
        # impossible to combine with select (unless forcing no
        # buffering).
        if self.universal_newlines and hasattr(file, 'newlines'):
            if stdout:
                stdout = self._translate_newlines(stdout)
            if stderr:
                stderr = self._translate_newlines(stderr)

if timeout == None:
            sts = self.wait()
        else:
            sts = self.wait(timeout=self._remaining_time(endtime))

return (stdout, stderr)

def poll(self):
        return self._internal_poll()

def _remaining_time(self, endtime):
        """Convenience for _communicate when computing timeouts."""
        if endtime is None:
            return None
        else:
            return endtime - time.time()

def _check_timeout(self, endtime):
        """Convenience for checking if a timeout has expired."""
        if endtime is None:
            return
        if time.time() > endtime:
            raise TimeoutExpired

if mswindows:
        #
        # Windows methods
        #
        def _get_handles(self, stdin, stdout, stderr):
            """Construct and return tupel with IO objects:
            p2cread, p2cwrite, c2pread, c2pwrite, errread, errwrite
            """
            if stdin is None and stdout is None and stderr is None:
                return (None, None, None, None, None, None)

p2cread, p2cwrite = None, None
            c2pread, c2pwrite = None, None
            errread, errwrite = None, None

if stdin is None:
                p2cread = _subprocess.GetStdHandle(_subprocess.STD_INPUT_HANDLE)
                if p2cread is None:
                    p2cread, _ = _subprocess.CreatePipe(None, 0)
            elif stdin == PIPE:
                p2cread, p2cwrite = _subprocess.CreatePipe(None, 0)
            elif isinstance(stdin, int):
                p2cread = msvcrt.get_osfhandle(stdin)
            else:
                # Assuming file-like object
                p2cread = msvcrt.get_osfhandle(stdin.fileno())
            p2cread = self._make_inheritable(p2cread)

if stdout is None:
                c2pwrite = _subprocess.GetStdHandle(_subprocess.STD_OUTPUT_HANDLE)
                if c2pwrite is None:
                    _, c2pwrite = _subprocess.CreatePipe(None, 0)
            elif stdout == PIPE:
                c2pread, c2pwrite = _subprocess.CreatePipe(None, 0)
            elif isinstance(stdout, int):
                c2pwrite = msvcrt.get_osfhandle(stdout)
            else:
                # Assuming file-like object
                c2pwrite = msvcrt.get_osfhandle(stdout.fileno())
            c2pwrite = self._make_inheritable(c2pwrite)

if stderr is None:
                errwrite = _subprocess.GetStdHandle(_subprocess.STD_ERROR_HANDLE)
                if errwrite is None:
                    _, errwrite = _subprocess.CreatePipe(None, 0)
            elif stderr == PIPE:
                errread, errwrite = _subprocess.CreatePipe(None, 0)
            elif stderr == STDOUT:
                errwrite = c2pwrite
            elif isinstance(stderr, int):
                errwrite = msvcrt.get_osfhandle(stderr)
            else:
                # Assuming file-like object
                errwrite = msvcrt.get_osfhandle(stderr.fileno())
            errwrite = self._make_inheritable(errwrite)

return (p2cread, p2cwrite,
                    c2pread, c2pwrite,
                    errread, errwrite)

def _make_inheritable(self, handle):
            """Return a duplicate of handle, which is inheritable"""
            return _subprocess.DuplicateHandle(_subprocess.GetCurrentProcess(),
                                handle, _subprocess.GetCurrentProcess(), 0, 1,
                                _subprocess.DUPLICATE_SAME_ACCESS)

def _find_w9xpopen(self):
            """Find and return absolut path to w9xpopen.exe"""
            w9xpopen = os.path.join(
                            os.path.dirname(_subprocess.GetModuleFileName(0)),
                                    "w9xpopen.exe")
            if not os.path.exists(w9xpopen):
                # Eeek - file-not-found - possibly an embedding
                # situation - see if we can locate it in sys.exec_prefix
                w9xpopen = os.path.join(os.path.dirname(sys.exec_prefix),
                                        "w9xpopen.exe")
                if not os.path.exists(w9xpopen):
                    raise RuntimeError("Cannot locate w9xpopen.exe, which is "
                                       "needed for Popen to work with your "
                                       "shell or platform.")
            return w9xpopen

def _execute_child(self, args, executable, preexec_fn, close_fds,
                           cwd, env, universal_newlines,
                           startupinfo, creationflags, shell,
                           p2cread, p2cwrite,
                           c2pread, c2pwrite,
                           errread, errwrite):
            """Execute program (MS Windows version)"""

if not isinstance(args, types.StringTypes):
                args = list2cmdline(args)

# Process startup details
            if startupinfo is None:
                startupinfo = STARTUPINFO()
            if None not in (p2cread, c2pwrite, errwrite):
                startupinfo.dwFlags |= _subprocess.STARTF_USESTDHANDLES
                startupinfo.hStdInput = p2cread
                startupinfo.hStdOutput = c2pwrite
                startupinfo.hStdError = errwrite

if shell:
                startupinfo.dwFlags |= _subprocess.STARTF_USESHOWWINDOW
                startupinfo.wShowWindow = _subprocess.SW_HIDE
                comspec = os.environ.get("COMSPEC", "cmd.exe")
                args = comspec + " /c " + args
                if (_subprocess.GetVersion() >= 0x80000000L or
                        os.path.basename(comspec).lower() == "command.com"):
                    # Win9x, or using command.com on NT. We need to
                    # use the w9xpopen intermediate program. For more
                    # information, see KB Q150956
                    # (http://web.archive.org/web/20011105084002/http://support.microsoft.com/support/kb/articles/Q150/9/56.asp)
                    w9xpopen = self._find_w9xpopen()
                    args = '"%s" %s' % (w9xpopen, args)
                    # Not passing CREATE_NEW_CONSOLE has been known to
                    # cause random failures on win9x.  Specifically a
                    # dialog: "Your program accessed mem currently in
                    # use at xxx" and a hopeful warning about the
                    # stability of your system.  Cost is Ctrl+C wont
                    # kill children.
                    creationflags |= _subprocess.CREATE_NEW_CONSOLE

# Start the process
            try:
                hp, ht, pid, tid = _subprocess.CreateProcess(executable, args,
                                         # no special security
                                         None, None,
                                         int(not close_fds),
                                         creationflags,
                                         env,
                                         cwd,
                                         startupinfo)
            except pywintypes.error, e:
                # Translate pywintypes.error to WindowsError, which is
                # a subclass of OSError.  FIXME: We should really
                # translate errno using _sys_errlist (or simliar), but
                # how can this be done from Python?
                raise WindowsError(*e.args)

# Retain the process handle, but close the thread handle
            self._child_created = True
            self._handle = hp
            self.pid = pid
            ht.Close()

# Child is launched. Close the parent's copy of those pipe
            # handles that only the child should have open.  You need
            # to make sure that no handles to the write end of the
            # output pipe are maintained in this process or else the
            # pipe will not close when the child process exits and the
            # ReadFile will hang.
            if p2cread is not None:
                p2cread.Close()
            if c2pwrite is not None:
                c2pwrite.Close()
            if errwrite is not None:
                errwrite.Close()

def _internal_poll(self, _deadstate=None,
                _WaitForSingleObject=_subprocess.WaitForSingleObject,
                _WAIT_OBJECT_0=_subprocess.WAIT_OBJECT_0,
                _GetExitCodeProcess=_subprocess.GetExitCodeProcess):
            """Check if child process has terminated.  Returns returncode
            attribute.

This method is called by __del__, so it can only refer to objects
            in its local scope.

"""
            if self.returncode is None:
                if _WaitForSingleObject(self._handle, 0) == _WAIT_OBJECT_0:
                    self.returncode = _GetExitCodeProcess(self._handle)
            return self.returncode

def wait(self, timeout=None):
            """Wait for child process to terminate.  Returns returncode
            attribute."""
            if timeout is None:
                timeout = _subprocess.INFINITE
            else:
                timeout = int(timeout * 1000)
            if self.returncode is None:
                result = _subprocess.WaitForSingleObject(self._handle, timeout)
                if result == _subprocess.WAIT_TIMEOUT:
                    raise TimeoutExpired
                self.returncode = _subprocess.GetExitCodeProcess(self._handle)
            return self.returncode

def _readerthread(self, fh, buffer):
            buffer.append(fh.read())

def _communicate(self, input, endtime):
            # Start reader threads feeding into a list hanging off of this
            # object, unless they've already been started.
            if self.stdout and not hasattr(self, "_stdout_buff"):
                self._stdout_buff = []
                self.stdout_thread = \
                        threading.Thread(target=self._readerthread,
                                         args=(self.stdout, self._stdout_buff))
                self.stdout_thread.setDaemon(True)
                self.stdout_thread.start()
            if self.stderr and not hasattr(self, "_stderr_buff"):
                self._stderr_buff = []
                self.stderr_thread = \
                        threading.Thread(target=self._readerthread,
                                         args=(self.stderr, self._stderr_buff))
                self.stderr_thread.setDaemon(True)
                self.stderr_thread.start()

if self.stdin:
                if input is not None:
                    try:
                        self.stdin.write(input)
                    except IOError as e:
                        if e.errno != errno.EPIPE:
                            raise
                self.stdin.close()

# Wait for the reader threads, or time out.  If we timeout, the
            # threads remain reading and the fds left open in case the user
            # calls communicate again.
            if self.stdout:
                self.stdout_thread.join(self._remaining_time(endtime))
                if self.stdout_thread.isAlive():
                    raise TimeoutExpired
            if self.stderr:
                self.stderr_thread.join(self._remaining_time(endtime))
                if self.stderr_thread.isAlive():
                    raise TimeoutExpired

# Collect the output from and close both pipes, now that we know
            # both have been read successfully.
            stdout = None
            stderr = None
            if self.stdout:
                stdout = self._stdout_buff
                self.stdout.close()
            if self.stderr:
                stderr = self._stderr_buff
                self.stderr.close()

return (stdout, stderr)

def send_signal(self, sig):
            """Send a signal to the process
            """
            if sig == signal.SIGTERM:
                self.terminate()
            else:
                raise ValueError("Only SIGTERM is supported on Windows")

def terminate(self):
            """Terminates the process
            """
            _subprocess.TerminateProcess(self._handle, 1)

kill = terminate

else:
        #
        # POSIX methods
        #
        def _get_handles(self, stdin, stdout, stderr):
            """Construct and return tupel with IO objects:
            p2cread, p2cwrite, c2pread, c2pwrite, errread, errwrite
            """
            p2cread, p2cwrite = None, None
            c2pread, c2pwrite = None, None
            errread, errwrite = None, None

if stdin is None:
                pass
            elif stdin == PIPE:
                p2cread, p2cwrite = os.pipe()
            elif isinstance(stdin, int):
                p2cread = stdin
            else:
                # Assuming file-like object
                p2cread = stdin.fileno()

if stdout is None:
                pass
            elif stdout == PIPE:
                c2pread, c2pwrite = os.pipe()
            elif isinstance(stdout, int):
                c2pwrite = stdout
            else:
                # Assuming file-like object
                c2pwrite = stdout.fileno()

if stderr is None:
                pass
            elif stderr == PIPE:
                errread, errwrite = os.pipe()
            elif stderr == STDOUT:
                errwrite = c2pwrite
            elif isinstance(stderr, int):
                errwrite = stderr
            else:
                # Assuming file-like object
                errwrite = stderr.fileno()

return (p2cread, p2cwrite,
                    c2pread, c2pwrite,
                    errread, errwrite)

def _set_cloexec_flag(self, fd):
            try:
                cloexec_flag = fcntl.FD_CLOEXEC
            except AttributeError:
                cloexec_flag = 1

old = fcntl.fcntl(fd, fcntl.F_GETFD)
            fcntl.fcntl(fd, fcntl.F_SETFD, old | cloexec_flag)

def _close_fds(self, but):
            os.closerange(3, but)
            os.closerange(but + 1, MAXFD)

if isinstance(args, types.StringTypes):
                args = [args]
            else:
                args = list(args)

if shell:
                args = ["/bin/sh", "-c"] + args
                if executable:
                    args[0] = executable

if executable is None:
                executable = args[0]

# For transferring possible exec failure from child to parent
            # The first char specifies the exception type: 0 means
            # OSError, 1 means some other error.
            errpipe_read, errpipe_write = os.pipe()
            try:
                try:
                    self._set_cloexec_flag(errpipe_write)

gc_was_enabled = gc.isenabled()
                    # Disable gc to avoid bug where gc -> file_dealloc ->
                    # write to stderr -> hang.  http://bugs.python.org/issue1336
                    gc.disable()
                    try:
                        self.pid = os.fork()
                    except:
                        if gc_was_enabled:
                            gc.enable()
                        raise
                    self._child_created = True
                    if self.pid == 0:
                        # Child
                        try:
                            # Close parent's pipe ends
                            if p2cwrite is not None:
                                os.close(p2cwrite)
                            if c2pread is not None:
                                os.close(c2pread)
                            if errread is not None:
                                os.close(errread)
                            os.close(errpipe_read)

# Dup fds for child
                            if p2cread is not None:
                                os.dup2(p2cread, 0)
                            if c2pwrite is not None:
                                os.dup2(c2pwrite, 1)
                            if errwrite is not None:
                                os.dup2(errwrite, 2)

# Close pipe fds.  Make sure we don't close the same
                            # fd more than once, or standard fds.
                            if p2cread is not None and p2cread not in (0,):
                                os.close(p2cread)
                            if c2pwrite is not None and c2pwrite not in (p2cread, 1):
                                os.close(c2pwrite)
                            if errwrite is not None and errwrite not in (p2cread, c2pwrite, 2):
                                os.close(errwrite)

# Close all other fds, if asked for
                            if close_fds:
                                self._close_fds(but=errpipe_write)

if cwd is not None:
                                os.chdir(cwd)

if preexec_fn:
                                preexec_fn()

if env is None:
                                os.execvp(executable, args)
                            else:
                                os.execvpe(executable, args, env)

except:
                            exc_type, exc_value, tb = sys.exc_info()
                            # Save the traceback and attach it to the exception object
                            exc_lines = traceback.format_exception(exc_type,
                                                                   exc_value,
                                                                   tb)
                            exc_value.child_traceback = ''.join(exc_lines)
                            os.write(errpipe_write, pickle.dumps(exc_value))

# This exitcode won't be reported to applications, so it
                        # really doesn't matter what we return.
                        os._exit(255)

# Parent
                    if gc_was_enabled:
                        gc.enable()
                finally:
                    # be sure the FD is closed no matter what
                    os.close(errpipe_write)

if p2cread is not None and p2cwrite is not None:
                    os.close(p2cread)
                if c2pwrite is not None and c2pread is not None:
                    os.close(c2pwrite)
                if errwrite is not None and errread is not None:
                    os.close(errwrite)

# Wait for exec to fail or succeed; possibly raising exception
                # Exception limited to 1M
                data = _eintr_retry_call(os.read, errpipe_read, 1048576)
            finally:
                # be sure the FD is closed no matter what
                os.close(errpipe_read)

if data != "":
                try:
                    _eintr_retry_call(os.waitpid, self.pid, 0)
                except OSError as e:
                    if e.errno != errno.ECHILD:
                        raise
                child_exception = pickle.loads(data)
                for fd in (p2cwrite, c2pread, errread):
                    if fd is not None:
                        os.close(fd)
                raise child_exception

def _handle_exitstatus(self, sts, _WIFSIGNALED=os.WIFSIGNALED,
                _WTERMSIG=os.WTERMSIG, _WIFEXITED=os.WIFEXITED,
                _WEXITSTATUS=os.WEXITSTATUS):
            # This method is called (indirectly) by __del__, so it cannot
            # refer to anything outside of its local scope."""
            if _WIFSIGNALED(sts):
                self.returncode = -_WTERMSIG(sts)
            elif _WIFEXITED(sts):
                self.returncode = _WEXITSTATUS(sts)
            else:
                # Should never happen
                raise RuntimeError("Unknown child exit status!")

def _internal_poll(self, _deadstate=None, _waitpid=os.waitpid,
                _WNOHANG=os.WNOHANG, _os_error=os.error):
            """Check if child process has terminated.  Returns returncode
            attribute.

This method is called by __del__, so it cannot reference anything
            outside of the local scope (nor can any methods it calls).

"""
            if self.returncode is None:
                try:
                    pid, sts = _waitpid(self.pid, _WNOHANG)
                    if pid == self.pid:
                        self._handle_exitstatus(sts)
                except _os_error:
                    if _deadstate is not None:
                        self.returncode = _deadstate
            return self.returncode

def wait(self, timeout=None, endtime=None):
            """Wait for child process to terminate.  Returns returncode
            attribute.

The optional "timeout" argument is a non-standard addition to
            Python 2.6.  If supplied, it is a number of seconds, which can be
            an integer or a float (though there are no precision guarantees).
            A TimeoutExpired exception will be raised after the given number of
            seconds elapses, if the call has not yet returned.
            """
            if self.returncode is not None:
                return self.returncode
            if timeout is not None:
                # Enter a busy loop if we have a timeout.  This busy
                # loop was cribbed from Lib/threading.py in
                # Thread.wait() at r71065.
                endtime = time.time() + timeout
                delay = 0.0005 # 500 us -> initial delay of 1 ms
                while True:
                    (pid, sts) = _eintr_retry_call(os.waitpid,
                                                   self.pid, os.WNOHANG)
                    assert pid == self.pid or pid == 0
                    if pid == self.pid:
                        self._handle_exitstatus(sts)
                        break
                    remaining = endtime - time.time()
                    if remaining <= 0:
                        raise TimeoutExpired
                    delay = min(delay * 2, remaining, .05)
                    time.sleep(delay)
            elif self.returncode is None:
                try:
                    pid, sts = _eintr_retry_call(os.waitpid, self.pid, 0)
                except OSError as e:
                    if e.errno != errno.ECHILD:
                        raise
                    # This happens if SIGCLD is set to be ignored or waiting
                    # for child processes has otherwise been disabled for our
                    # process.  This child is dead, we can't get the status.
                    sts = 0
                self._handle_exitstatus(sts)
            return self.returncode

def _communicate(self, input, endtime):
            if self.stdin and not self._communication_started:
                # Flush stdio buffer.  This might block, if the user has
                # been writing to .stdin in an uncontrolled fashion.
                self.stdin.flush()
                if not input:
                    self.stdin.close()

if _has_poll:
                stdout, stderr = self._communicate_with_poll(input, endtime)
            else:
                stdout, stderr = self._communicate_with_select(input, endtime)

# All data exchanged.  Translate lists into strings.
            if stdout is not None:
                stdout = ''.join(stdout)
            if stderr is not None:
                stderr = ''.join(stderr)

# Translate newlines, if requested.  We cannot let the file
            # object do the translation: It is based on stdio, which is
            # impossible to combine with select (unless forcing no
            # buffering).
            if self.universal_newlines and hasattr(file, 'newlines'):
                if stdout:
                    stdout = self._translate_newlines(stdout)
                if stderr:
                    stderr = self._translate_newlines(stderr)

# if timeout == None in calling function, we get endtime == None
            if endtime == None:
                self.wait()
            else:
                self.wait(timeout=self._remaining_time(endtime))
            return (stdout, stderr)

def _communicate_with_poll(self, input, endtime):
            stdout = None # Return
            stderr = None # Return

if not self._communication_started:
                self._fd2file = {}

poller = select.poll()
            def register_and_append(file_obj, eventmask):
                poller.register(file_obj.fileno(), eventmask)
                self._fd2file[file_obj.fileno()] = file_obj

def close_unregister_and_remove(fd):
                poller.unregister(fd)
                self._fd2file[fd].close()
                self._fd2file.pop(fd)

if self.stdin and input:
                register_and_append(self.stdin, select.POLLOUT)

# Only create this mapping if we haven't already.
            if not self._communication_started:
                self._fd2output = {}
                if self.stdout:
                    self._fd2output[self.stdout.fileno()] = []
                if self.stderr:
                    self._fd2output[self.stderr.fileno()] = []

select_POLLIN_POLLPRI = select.POLLIN | select.POLLPRI
            if self.stdout:
                register_and_append(self.stdout, select_POLLIN_POLLPRI)
                stdout = self._fd2output[self.stdout.fileno()]
            if self.stderr:
                register_and_append(self.stderr, select_POLLIN_POLLPRI)
                stderr = self._fd2output[self.stderr.fileno()]

# Save the input here so that if we time out while communicating,
            # we can continue sending input if we retry.
            if not self._input:
                self._input_offset = 0
                self._input = input

while self._fd2file:
                try:
                    ready = poller.poll(self._remaining_time(endtime))
                except select.error, e:
                    if e.args[0] == errno.EINTR:
                        continue
                    raise
                self._check_timeout(endtime)

for fd, mode in ready:
                    if mode & select.POLLOUT:
                        chunk = self._input[self._input_offset :
                                            self._input_offset + _PIPE_BUF]
                        try:
                            self._input_offset += os.write(fd, chunk)
                        except OSError as e:
                            if e.errno == errno.EPIPE:
                                close_unregister_and_remove(fd)
                            else:
                                raise
                        else:
                            if self._input_offset >= len(self._input):
                                close_unregister_and_remove(fd)
                    elif mode & select_POLLIN_POLLPRI:
                        data = os.read(fd, 4096)
                        if not data:
                            close_unregister_and_remove(fd)
                        self._fd2output[fd].append(data)
                    else:
                        # Ignore hang up or errors.
                        close_unregister_and_remove(fd)

return (stdout, stderr)

def _communicate_with_select(self, input, endtime):
            if not self._communication_started:
                self._read_set = []
                self._write_set = []
                if self.stdin and input:
                    self._write_set.append(self.stdin)
                if self.stdout:
                    self._read_set.append(self.stdout)
                if self.stderr:
                    self._read_set.append(self.stderr)

if not self._input:
                self._input = input
                self._input_offset = 0

stdout = None # Return
            stderr = None # Return

if self.stdout:
                if not self._communication_started:
                    self._stdout_buff = []
                stdout = self._stdout_buff
            if self.stderr:
                if not self._communication_started:
                    self._stderr_buff = []
                stderr = self._stderr_buff

while self._read_set or self._write_set:
                remaining = self._remaining_time(endtime)
                try:
                    rlist, wlist, xlist = select.select(self._read_set,
                                                        self._write_set, [],
                                                        remaining)
                except select.error, e:
                    if e.args[0] == errno.EINTR:
                        continue
                    raise
                self._check_timeout(endtime)

if not (rlist or wlist or xlist):
                    # According to the docs, returning three empty lists
                    # indicates that the timeout expired.
                    raise TimeoutExpired

if self.stdin in wlist:
                    chunk = self._input[self._input_offset :
                                  self._input_offset + _PIPE_BUF]
                    try:
                        bytes_written = os.write(self.stdin.fileno(), chunk)
                    except OSError as e:
                        if e.errno == errno.EPIPE:
                            self.stdin.close()
                            self._write_set.remove(self.stdin)
                        else:
                            raise
                    else:
                        self._input_offset += bytes_written
                        if self._input_offset >= len(self._input):
                            self.stdin.close()
                            self._write_set.remove(self.stdin)

if self.stdout in rlist:
                    data = os.read(self.stdout.fileno(), 1024)
                    if data == "":
                        self.stdout.close()
                        self._read_set.remove(self.stdout)
                    stdout.append(data)

if self.stderr in rlist:
                    data = os.read(self.stderr.fileno(), 1024)
                    if data == "":
                        self.stderr.close()
                        self._read_set.remove(self.stderr)
                    stderr.append(data)

return (stdout, stderr)

def send_signal(self, sig):
            """Send a signal to the process
            """
            os.kill(self.pid, sig)

def terminate(self):
            """Terminate the process with SIGTERM
            """
            self.send_signal(signal.SIGTERM)

def kill(self):
            """Kill the process with SIGKILL
            """
            self.send_signal(signal.SIGKILL)

def _demo_posix():
    #
    # Example 1: Simple redirection: Get process list
    #
    plist = Popen(["ps"], stdout=PIPE).communicate()[0]
    print "Process list:"
    print plist

#
    # Example 2: Change uid before executing child
    #
    if os.getuid() == 0:
        p = Popen(["id"], preexec_fn=lambda: os.setuid(100))
        p.wait()

#
    # Example 3: Connecting several subprocesses
    #
    print "Looking for 'hda'..."
    p1 = Popen(["dmesg"], stdout=PIPE)
    p2 = Popen(["grep", "hda"], stdin=p1.stdout, stdout=PIPE)
    print repr(p2.communicate()[0])

#
    # Example 4: Catch execution error
    #
    print
    print "Trying a weird file..."
    try:
        print Popen(["/this/path/does/not/exist"]).communicate()
    except OSError, e:
        if e.errno == errno.ENOENT:
            print "The file didn't exist.  I thought so..."
            print "Child traceback:"
            print e.child_traceback
        else:
            print "Error", e.errno
    else:
        print >>sys.stderr, "Gosh.  No error."

def _demo_windows():
    #
    # Example 1: Connecting several subprocesses
    #
    print "Looking for 'PROMPT' in set output..."
    p1 = Popen("set", stdout=PIPE, shell=True)
    p2 = Popen('find "PROMPT"', stdin=p1.stdout, stdout=PIPE)
    print repr(p2.communicate()[0])

#
    # Example 2: Simple execution of program
    #
    print "Executing calc..."
    p = Popen("calc")
    p.wait()

if __name__ == "__main__":
    if mswindows:
        _demo_windows()
    else:
        _demo_posix()

cmd: