File Manager

X7ROOT File Manager

Current Path: /usr/lib64/python2.7

?? ..
?? BaseHTTPServer.py(22.21 KB)
?? BaseHTTPServer.pyc(21.21 KB)
?? BaseHTTPServer.pyo(21.21 KB)
?? Bastion.py(5.61 KB)
?? Bastion.pyc(6.5 KB)
?? Bastion.pyo(6.5 KB)
?? CGIHTTPServer.py(12.78 KB)
?? CGIHTTPServer.pyc(10.76 KB)
?? CGIHTTPServer.pyo(10.76 KB)
?? ConfigParser.py(27.1 KB)
?? ConfigParser.pyc(24.62 KB)
?? ConfigParser.pyo(24.62 KB)
?? Cookie.py(25.92 KB)
?? Cookie.pyc(22.13 KB)
?? Cookie.pyo(22.13 KB)
?? Demo
?? Doc
?? DocXMLRPCServer.py(10.52 KB)
?? DocXMLRPCServer.pyc(9.96 KB)
?? DocXMLRPCServer.pyo(9.85 KB)
?? HTMLParser.py(16.77 KB)
?? HTMLParser.pyc(13.41 KB)
?? HTMLParser.pyo(13.11 KB)
?? MimeWriter.py(6.33 KB)
?? MimeWriter.pyc(7.19 KB)
?? MimeWriter.pyo(7.19 KB)
?? Queue.py(8.38 KB)
?? Queue.pyc(9.2 KB)
?? Queue.pyo(9.2 KB)
?? SimpleHTTPServer.py(7.81 KB)
?? SimpleHTTPServer.pyc(7.82 KB)
?? SimpleHTTPServer.pyo(7.82 KB)
?? SimpleXMLRPCServer.py(25.21 KB)
?? SimpleXMLRPCServer.pyc(22.33 KB)
?? SimpleXMLRPCServer.pyo(22.33 KB)
?? SocketServer.py(23.39 KB)
?? SocketServer.pyc(23.52 KB)
?? SocketServer.pyo(23.52 KB)
?? StringIO.py(10.41 KB)
?? StringIO.pyc(11.21 KB)
?? StringIO.pyo(11.21 KB)
?? Tools
?? UserDict.py(6.89 KB)
?? UserDict.pyc(9.48 KB)
?? UserDict.pyo(9.48 KB)
?? UserList.py(3.56 KB)
?? UserList.pyc(6.42 KB)
?? UserList.pyo(6.42 KB)
?? UserString.py(9.46 KB)
?? UserString.pyc(14.52 KB)
?? UserString.pyo(14.52 KB)
?? _LWPCookieJar.py(6.4 KB)
?? _LWPCookieJar.pyc(5.31 KB)
?? _LWPCookieJar.pyo(5.31 KB)
?? _MozillaCookieJar.py(5.66 KB)
?? _MozillaCookieJar.pyc(4.36 KB)
?? _MozillaCookieJar.pyo(4.32 KB)
?? __future__.py(4.28 KB)
?? __future__.pyc(4.12 KB)
?? __future__.pyo(4.12 KB)
?? __phello__.foo.py(64 B)
?? __phello__.foo.pyc(125 B)
?? __phello__.foo.pyo(125 B)
?? _abcoll.py(18.18 KB)
?? _abcoll.pyc(25.08 KB)
?? _abcoll.pyo(25.08 KB)
?? _osx_support.py(18.65 KB)
?? _osx_support.pyc(11.48 KB)
?? _osx_support.pyo(11.48 KB)
?? _pyio.py(68 KB)
?? _pyio.pyc(63.18 KB)
?? _pyio.pyo(63.18 KB)
?? _strptime.py(20.24 KB)
?? _strptime.pyc(14.82 KB)
?? _strptime.pyo(14.82 KB)
?? _sysconfigdata.py(19.27 KB)
?? _sysconfigdata.pyc(22.43 KB)
?? _sysconfigdata.pyo(22.43 KB)
?? _threading_local.py(7.09 KB)
?? _threading_local.pyc(6.22 KB)
?? _threading_local.pyo(6.22 KB)
?? _weakrefset.py(5.77 KB)
?? _weakrefset.pyc(9.45 KB)
?? _weakrefset.pyo(9.45 KB)
?? abc.py(6.98 KB)
?? abc.pyc(6 KB)
?? abc.pyo(5.94 KB)
?? aifc.py(33.77 KB)
?? aifc.pyc(29.75 KB)
?? aifc.pyo(29.75 KB)
?? antigravity.py(60 B)
?? antigravity.pyc(203 B)
?? antigravity.pyo(203 B)
?? anydbm.py(2.6 KB)
?? anydbm.pyc(2.73 KB)
?? anydbm.pyo(2.73 KB)
?? argparse.py(87.14 KB)
?? argparse.pyc(62.86 KB)
?? argparse.pyo(62.7 KB)
?? ast.py(11.53 KB)
?? ast.pyc(12.63 KB)
?? ast.pyo(12.63 KB)
?? asynchat.py(11.31 KB)
?? asynchat.pyc(8.6 KB)
?? asynchat.pyo(8.6 KB)
?? asyncore.py(20.45 KB)
?? asyncore.pyc(18.45 KB)
?? asyncore.pyo(18.45 KB)
?? atexit.py(1.67 KB)
?? atexit.pyc(2.15 KB)
?? atexit.pyo(2.15 KB)
?? audiodev.py(7.42 KB)
?? audiodev.pyc(8.27 KB)
?? audiodev.pyo(8.27 KB)
?? base64.py(11.53 KB)
?? base64.pyc(11.03 KB)
?? base64.pyo(11.03 KB)
?? bdb.py(21.21 KB)
?? bdb.pyc(18.65 KB)
?? bdb.pyo(18.65 KB)
?? binhex.py(14.35 KB)
?? binhex.pyc(15.1 KB)
?? binhex.pyo(15.1 KB)
?? bisect.py(2.53 KB)
?? bisect.pyc(3 KB)
?? bisect.pyo(3 KB)
?? bsddb
?? cProfile.py(6.42 KB)
?? cProfile.pyc(6.25 KB)
?? cProfile.pyo(6.25 KB)
?? calendar.py(22.84 KB)
?? calendar.pyc(27.26 KB)
?? calendar.pyo(27.26 KB)
?? cgi.py(35.46 KB)
?? cgi.pyc(32.58 KB)
?? cgi.pyo(32.58 KB)
?? cgitb.py(11.89 KB)
?? cgitb.pyc(11.85 KB)
?? cgitb.pyo(11.85 KB)
?? chunk.py(5.29 KB)
?? chunk.pyc(5.47 KB)
?? chunk.pyo(5.47 KB)
?? cmd.py(14.67 KB)
?? cmd.pyc(13.71 KB)
?? cmd.pyo(13.71 KB)
?? code.py(9.95 KB)
?? code.pyc(10.09 KB)
?? code.pyo(10.09 KB)
?? codecs.py(35.3 KB)
?? codecs.pyc(35.96 KB)
?? codecs.pyo(35.96 KB)
?? codeop.py(5.86 KB)
?? codeop.pyc(6.44 KB)
?? codeop.pyo(6.44 KB)
?? collections.py(27.15 KB)
?? collections.pyc(25.55 KB)
?? collections.pyo(25.5 KB)
?? colorsys.py(3.6 KB)
?? colorsys.pyc(3.9 KB)
?? colorsys.pyo(3.9 KB)
?? commands.py(2.49 KB)
?? commands.pyc(2.41 KB)
?? commands.pyo(2.41 KB)
?? compileall.py(7.58 KB)
?? compileall.pyc(6.85 KB)
?? compileall.pyo(6.85 KB)
?? compiler
?? config
?? contextlib.py(4.32 KB)
?? contextlib.pyc(4.35 KB)
?? contextlib.pyo(4.35 KB)
?? cookielib.py(63.95 KB)
?? cookielib.pyc(53.44 KB)
?? cookielib.pyo(53.26 KB)
?? copy.py(11.26 KB)
?? copy.pyc(11.88 KB)
?? copy.pyo(11.79 KB)
?? copy_reg.py(6.81 KB)
?? copy_reg.pyc(5.05 KB)
?? copy_reg.pyo(5 KB)
?? crypt.py(2.24 KB)
?? crypt.pyc(2.89 KB)
?? crypt.pyo(2.89 KB)
?? csv.py(16.32 KB)
?? csv.pyc(13.19 KB)
?? csv.pyo(13.19 KB)
?? ctypes
?? curses
?? dbhash.py(498 B)
?? dbhash.pyc(718 B)
?? dbhash.pyo(718 B)
?? decimal.py(216.73 KB)
?? decimal.pyc(168.12 KB)
?? decimal.pyo(168.12 KB)
?? difflib.py(80.4 KB)
?? difflib.pyc(60.45 KB)
?? difflib.pyo(60.4 KB)
?? dircache.py(1.1 KB)
?? dircache.pyc(1.54 KB)
?? dircache.pyo(1.54 KB)
?? dis.py(6.35 KB)
?? dis.pyc(6.08 KB)
?? dis.pyo(6.08 KB)
?? distutils
?? doctest.py(102.63 KB)
?? doctest.pyc(81.68 KB)
?? doctest.pyo(81.4 KB)
?? dumbdbm.py(8.93 KB)
?? dumbdbm.pyc(6.59 KB)
?? dumbdbm.pyo(6.59 KB)
?? dummy_thread.py(4.31 KB)
?? dummy_thread.pyc(5.27 KB)
?? dummy_thread.pyo(5.27 KB)
?? dummy_threading.py(2.74 KB)
?? dummy_threading.pyc(1.25 KB)
?? dummy_threading.pyo(1.25 KB)
?? email
?? encodings
?? ensurepip
?? filecmp.py(9.36 KB)
?? filecmp.pyc(9.4 KB)
?? filecmp.pyo(9.4 KB)
?? fileinput.py(13.42 KB)
?? fileinput.pyc(14.16 KB)
?? fileinput.pyo(14.16 KB)
?? fnmatch.py(3.24 KB)
?? fnmatch.pyc(3.53 KB)
?? fnmatch.pyo(3.53 KB)
?? formatter.py(14.56 KB)
?? formatter.pyc(18.73 KB)
?? formatter.pyo(18.73 KB)
?? fpformat.py(4.62 KB)
?? fpformat.pyc(4.59 KB)
?? fpformat.pyo(4.59 KB)
?? fractions.py(21.87 KB)
?? fractions.pyc(19.25 KB)
?? fractions.pyo(19.25 KB)
?? ftplib.py(37.65 KB)
?? ftplib.pyc(34.12 KB)
?? ftplib.pyo(34.12 KB)
?? functools.py(4.69 KB)
?? functools.pyc(6.47 KB)
?? functools.pyo(6.47 KB)
?? genericpath.py(3.13 KB)
?? genericpath.pyc(3.43 KB)
?? genericpath.pyo(3.43 KB)
?? getopt.py(7.15 KB)
?? getopt.pyc(6.5 KB)
?? getopt.pyo(6.45 KB)
?? getpass.py(5.43 KB)
?? getpass.pyc(4.63 KB)
?? getpass.pyo(4.63 KB)
?? gettext.py(22.13 KB)
?? gettext.pyc(17.58 KB)
?? gettext.pyo(17.58 KB)
?? glob.py(3.04 KB)
?? glob.pyc(2.87 KB)
?? glob.pyo(2.87 KB)
?? gzip.py(18.58 KB)
?? gzip.pyc(14.88 KB)
?? gzip.pyo(14.88 KB)
?? hashlib.py(7.66 KB)
?? hashlib.pyc(6.76 KB)
?? hashlib.pyo(6.76 KB)
?? heapq.py(17.87 KB)
?? heapq.pyc(14.22 KB)
?? heapq.pyo(14.22 KB)
?? hmac.py(4.48 KB)
?? hmac.pyc(4.44 KB)
?? hmac.pyo(4.44 KB)
?? hotshot
?? htmlentitydefs.py(17.63 KB)
?? htmlentitydefs.pyc(6.22 KB)
?? htmlentitydefs.pyo(6.22 KB)
?? htmllib.py(12.57 KB)
?? htmllib.pyc(19.83 KB)
?? htmllib.pyo(19.83 KB)
?? httplib.py(52.06 KB)
?? httplib.pyc(37.82 KB)
?? httplib.pyo(37.64 KB)
?? idlelib
?? ihooks.py(18.54 KB)
?? ihooks.pyc(20.87 KB)
?? ihooks.pyo(20.87 KB)
?? imaplib.py(47.23 KB)
?? imaplib.pyc(43.96 KB)
?? imaplib.pyo(41.32 KB)
?? imghdr.py(3.46 KB)
?? imghdr.pyc(4.72 KB)
?? imghdr.pyo(4.72 KB)
?? importlib
?? imputil.py(25.16 KB)
?? imputil.pyc(15.26 KB)
?? imputil.pyo(15.08 KB)
?? inspect.py(42 KB)
?? inspect.pyc(39.29 KB)
?? inspect.pyo(39.29 KB)
?? io.py(3.24 KB)
?? io.pyc(3.5 KB)
?? io.pyo(3.5 KB)
?? json
?? keyword.py(1.95 KB)
?? keyword.pyc(2.06 KB)
?? keyword.pyo(2.06 KB)
?? lib-dynload
?? lib-tk
?? lib2to3
?? linecache.py(3.93 KB)
?? linecache.pyc(3.2 KB)
?? linecache.pyo(3.2 KB)
?? locale.py(100.42 KB)
?? locale.pyc(55.28 KB)
?? locale.pyo(55.28 KB)
?? logging
?? macpath.py(6.14 KB)
?? macpath.pyc(7.5 KB)
?? macpath.pyo(7.5 KB)
?? macurl2path.py(2.67 KB)
?? macurl2path.pyc(2.19 KB)
?? macurl2path.pyo(2.19 KB)
?? mailbox.py(79.34 KB)
?? mailbox.pyc(74.92 KB)
?? mailbox.pyo(74.87 KB)
?? mailcap.py(8.21 KB)
?? mailcap.pyc(7.77 KB)
?? mailcap.pyo(7.77 KB)
?? markupbase.py(14.3 KB)
?? markupbase.pyc(9.05 KB)
?? markupbase.pyo(8.86 KB)
?? md5.py(358 B)
?? md5.pyc(378 B)
?? md5.pyo(378 B)
?? mhlib.py(32.65 KB)
?? mhlib.pyc(32.99 KB)
?? mhlib.pyo(32.99 KB)
?? mimetools.py(7 KB)
?? mimetools.pyc(8.01 KB)
?? mimetools.pyo(8.01 KB)
?? mimetypes.py(20.54 KB)
?? mimetypes.pyc(18.06 KB)
?? mimetypes.pyo(18.06 KB)
?? mimify.py(14.67 KB)
?? mimify.pyc(11.72 KB)
?? mimify.pyo(11.72 KB)
?? modulefinder.py(23.89 KB)
?? modulefinder.pyc(18.68 KB)
?? modulefinder.pyo(18.6 KB)
?? multifile.py(4.71 KB)
?? multifile.pyc(5.29 KB)
?? multifile.pyo(5.25 KB)
?? multiprocessing
?? mutex.py(1.83 KB)
?? mutex.pyc(2.46 KB)
?? mutex.pyo(2.46 KB)
?? netrc.py(5.75 KB)
?? netrc.pyc(4.6 KB)
?? netrc.pyo(4.6 KB)
?? new.py(610 B)
?? new.pyc(862 B)
?? new.pyo(862 B)
?? nntplib.py(20.97 KB)
?? nntplib.pyc(20.55 KB)
?? nntplib.pyo(20.55 KB)
?? ntpath.py(18.97 KB)
?? ntpath.pyc(12.82 KB)
?? ntpath.pyo(12.82 KB)
?? nturl2path.py(2.36 KB)
?? nturl2path.pyc(1.77 KB)
?? nturl2path.pyo(1.77 KB)
?? numbers.py(10.08 KB)
?? numbers.pyc(13.68 KB)
?? numbers.pyo(13.68 KB)
?? opcode.py(5.35 KB)
?? opcode.pyc(6 KB)
?? opcode.pyo(6 KB)
?? optparse.py(59.77 KB)
?? optparse.pyc(52.63 KB)
?? optparse.pyo(52.55 KB)
?? os.py(25.3 KB)
?? os.pyc(25.09 KB)
?? os.pyo(25.09 KB)
?? os2emxpath.py(4.53 KB)
?? os2emxpath.pyc(4.42 KB)
?? os2emxpath.pyo(4.42 KB)
?? pdb.doc(7.73 KB)
?? pdb.py(45.02 KB)
?? pdb.pyc(42.65 KB)
?? pdb.pyo(42.65 KB)
?? pickle.py(44.42 KB)
?? pickle.pyc(37.66 KB)
?? pickle.pyo(37.46 KB)
?? pickletools.py(72.78 KB)
?? pickletools.pyc(55.7 KB)
?? pickletools.pyo(54.85 KB)
?? pipes.py(9.36 KB)
?? pipes.pyc(9.09 KB)
?? pipes.pyo(9.09 KB)
?? pkgutil.py(19.77 KB)
?? pkgutil.pyc(18.51 KB)
?? pkgutil.pyo(18.51 KB)
?? plat-linux2
?? platform.py(51.56 KB)
?? platform.pyc(37.08 KB)
?? platform.pyo(37.08 KB)
?? plistlib.py(15.44 KB)
?? plistlib.pyc(19.5 KB)
?? plistlib.pyo(19.41 KB)
?? popen2.py(8.22 KB)
?? popen2.pyc(8.81 KB)
?? popen2.pyo(8.77 KB)
?? poplib.py(12.52 KB)
?? poplib.pyc(13.03 KB)
?? poplib.pyo(13.03 KB)
?? posixfile.py(7.82 KB)
?? posixfile.pyc(7.47 KB)
?? posixfile.pyo(7.47 KB)
?? posixpath.py(13.96 KB)
?? posixpath.pyc(11.19 KB)
?? posixpath.pyo(11.19 KB)
?? pprint.py(11.5 KB)
?? pprint.pyc(9.96 KB)
?? pprint.pyo(9.78 KB)
?? profile.py(22.25 KB)
?? profile.pyc(16.07 KB)
?? profile.pyo(15.83 KB)
?? pstats.py(26.09 KB)
?? pstats.pyc(24.43 KB)
?? pstats.pyo(24.43 KB)
?? pty.py(4.94 KB)
?? pty.pyc(4.85 KB)
?? pty.pyo(4.85 KB)
?? py_compile.py(5.8 KB)
?? py_compile.pyc(6.28 KB)
?? py_compile.pyo(6.28 KB)
?? pyclbr.py(13.07 KB)
?? pyclbr.pyc(9.42 KB)
?? pyclbr.pyo(9.42 KB)
?? pydoc.py(93.5 KB)
?? pydoc.pyc(90.18 KB)
?? pydoc.pyo(90.12 KB)
?? pydoc_data
?? quopri.py(6.8 KB)
?? quopri.pyc(6.42 KB)
?? quopri.pyo(6.42 KB)
?? random.py(31.7 KB)
?? random.pyc(25.1 KB)
?? random.pyo(25.1 KB)
?? re.py(13.11 KB)
?? re.pyc(13.1 KB)
?? re.pyo(13.1 KB)
?? repr.py(4.2 KB)
?? repr.pyc(5.26 KB)
?? repr.pyo(5.26 KB)
?? rexec.py(19.68 KB)
?? rexec.pyc(23.25 KB)
?? rexec.pyo(23.25 KB)
?? rfc822.py(32.76 KB)
?? rfc822.pyc(31.07 KB)
?? rfc822.pyo(31.07 KB)
?? rlcompleter.py(5.85 KB)
?? rlcompleter.pyc(5.94 KB)
?? rlcompleter.pyo(5.94 KB)
?? robotparser.py(7.51 KB)
?? robotparser.pyc(7.82 KB)
?? robotparser.pyo(7.82 KB)
?? runpy.py(10.82 KB)
?? runpy.pyc(8.6 KB)
?? runpy.pyo(8.6 KB)
?? sched.py(4.97 KB)
?? sched.pyc(4.88 KB)
?? sched.pyo(4.88 KB)
?? sets.py(18.6 KB)
?? sets.pyc(16.5 KB)
?? sets.pyo(16.5 KB)
?? sgmllib.py(17.46 KB)
?? sgmllib.pyc(15.07 KB)
?? sgmllib.pyo(15.07 KB)
?? sha.py(393 B)
?? sha.pyc(421 B)
?? sha.pyo(421 B)
?? shelve.py(7.99 KB)
?? shelve.pyc(10.02 KB)
?? shelve.pyo(10.02 KB)
?? shlex.py(10.9 KB)
?? shlex.pyc(7.38 KB)
?? shlex.pyo(7.38 KB)
?? shutil.py(19.41 KB)
?? shutil.pyc(18.81 KB)
?? shutil.pyo(18.81 KB)
?? site-packages
?? site.py(20.8 KB)
?? site.pyc(20.3 KB)
?? site.pyo(20.3 KB)
?? smtpd.py(18.11 KB)
?? smtpd.pyc(15.51 KB)
?? smtpd.pyo(15.51 KB)
?? smtplib.py(31.38 KB)
?? smtplib.pyc(29.59 KB)
?? smtplib.pyo(29.59 KB)
?? sndhdr.py(5.83 KB)
?? sndhdr.pyc(7.19 KB)
?? sndhdr.pyo(7.19 KB)
?? socket.py(20.13 KB)
?? socket.pyc(15.77 KB)
?? socket.pyo(15.69 KB)
?? sqlite3
?? sre.py(384 B)
?? sre.pyc(519 B)
?? sre.pyo(519 B)
?? sre_compile.py(19.36 KB)
?? sre_compile.pyc(12.27 KB)
?? sre_compile.pyo(12.11 KB)
?? sre_constants.py(7.03 KB)
?? sre_constants.pyc(6.05 KB)
?? sre_constants.pyo(6.05 KB)
?? sre_parse.py(29.98 KB)
?? sre_parse.pyc(20.66 KB)
?? sre_parse.pyo(20.66 KB)
?? ssl.py(38.39 KB)
?? ssl.pyc(31.95 KB)
?? ssl.pyo(31.95 KB)
?? stat.py(1.8 KB)
?? stat.pyc(2.69 KB)
?? stat.pyo(2.69 KB)
?? statvfs.py(898 B)
?? statvfs.pyc(620 B)
?? statvfs.pyo(620 B)
?? string.py(21.04 KB)
?? string.pyc(19.98 KB)
?? string.pyo(19.98 KB)
?? stringold.py(12.16 KB)
?? stringold.pyc(12.25 KB)
?? stringold.pyo(12.25 KB)
?? stringprep.py(13.21 KB)
?? stringprep.pyc(14.15 KB)
?? stringprep.pyo(14.08 KB)
?? struct.py(82 B)
?? struct.pyc(239 B)
?? struct.pyo(239 B)
?? subprocess.py(49.34 KB)
?? subprocess.pyc(31.64 KB)
?? subprocess.pyo(31.64 KB)
?? sunau.py(16.82 KB)
?? sunau.pyc(17.96 KB)
?? sunau.pyo(17.96 KB)
?? sunaudio.py(1.37 KB)
?? sunaudio.pyc(1.94 KB)
?? sunaudio.pyo(1.94 KB)
?? symbol.py(2.01 KB)
?? symbol.pyc(2.96 KB)
?? symbol.pyo(2.96 KB)
?? symtable.py(7.26 KB)
?? symtable.pyc(11.51 KB)
?? symtable.pyo(11.38 KB)
?? sysconfig.py(22.32 KB)
?? sysconfig.pyc(17.4 KB)
?? sysconfig.pyo(17.4 KB)
?? tabnanny.py(11.07 KB)
?? tabnanny.pyc(8.05 KB)
?? tabnanny.pyo(8.05 KB)
?? tarfile.py(88.53 KB)
?? tarfile.pyc(74.41 KB)
?? tarfile.pyo(74.41 KB)
?? telnetlib.py(26.4 KB)
?? telnetlib.pyc(22.61 KB)
?? telnetlib.pyo(22.61 KB)
?? tempfile.py(19.09 KB)
?? tempfile.pyc(19.87 KB)
?? tempfile.pyo(19.87 KB)
?? test
?? textwrap.py(16.88 KB)
?? textwrap.pyc(11.81 KB)
?? textwrap.pyo(11.72 KB)
?? this.py(1002 B)
?? this.pyc(1.19 KB)
?? this.pyo(1.19 KB)
?? threading.py(46.27 KB)
?? threading.pyc(41.72 KB)
?? threading.pyo(39.6 KB)
?? timeit.py(12.49 KB)
?? timeit.pyc(11.9 KB)
?? timeit.pyo(11.9 KB)
?? toaiff.py(3.07 KB)
?? toaiff.pyc(3.03 KB)
?? toaiff.pyo(3.03 KB)
?? token.py(2.85 KB)
?? token.pyc(3.73 KB)
?? token.pyo(3.73 KB)
?? tokenize.py(17.07 KB)
?? tokenize.pyc(14.17 KB)
?? tokenize.pyo(14.11 KB)
?? trace.py(29.19 KB)
?? trace.pyc(22.26 KB)
?? trace.pyo(22.2 KB)
?? traceback.py(11.02 KB)
?? traceback.pyc(11.41 KB)
?? traceback.pyo(11.41 KB)
?? tty.py(879 B)
?? tty.pyc(1.29 KB)
?? tty.pyo(1.29 KB)
?? types.py(2.04 KB)
?? types.pyc(2.66 KB)
?? types.pyo(2.66 KB)
?? unittest
?? urllib.py(58.82 KB)
?? urllib.pyc(50.04 KB)
?? urllib.pyo(49.95 KB)
?? urllib2.py(51.31 KB)
?? urllib2.pyc(46.19 KB)
?? urllib2.pyo(46.1 KB)
?? urlparse.py(19.98 KB)
?? urlparse.pyc(17.59 KB)
?? urlparse.pyo(17.59 KB)
?? user.py(1.59 KB)
?? user.pyc(1.68 KB)
?? user.pyo(1.68 KB)
?? uu.py(6.54 KB)
?? uu.pyc(4.29 KB)
?? uu.pyo(4.29 KB)
?? uuid.py(22.98 KB)
?? uuid.pyc(22.82 KB)
?? uuid.pyo(22.71 KB)
?? warnings.py(14.48 KB)
?? warnings.pyc(13.19 KB)
?? warnings.pyo(12.42 KB)
?? wave.py(18.15 KB)
?? wave.pyc(19.54 KB)
?? wave.pyo(19.4 KB)
?? weakref.py(14.48 KB)
?? weakref.pyc(16.06 KB)
?? weakref.pyo(16.06 KB)
?? webbrowser.py(22.19 KB)
?? webbrowser.pyc(19.29 KB)
?? webbrowser.pyo(19.24 KB)
?? whichdb.py(3.3 KB)
?? whichdb.pyc(2.19 KB)
?? whichdb.pyo(2.19 KB)
?? wsgiref
?? wsgiref.egg-info(187 B)
?? xdrlib.py(5.93 KB)
?? xdrlib.pyc(9.67 KB)
?? xdrlib.pyo(9.67 KB)
?? xml
?? xmllib.py(34.05 KB)
?? xmllib.pyc(26.22 KB)
?? xmllib.pyo(26.22 KB)
?? xmlrpclib.py(50.91 KB)
?? xmlrpclib.pyc(43.07 KB)
?? xmlrpclib.pyo(42.89 KB)
?? zipfile.py(58.08 KB)
?? zipfile.pyc(41.15 KB)
?? zipfile.pyo(41.15 KB)

Editing: sysconfig.py

"""Provide access to Python's configuration information.

"""
import sys
import os
from os.path import pardir, realpath

_INSTALL_SCHEMES = {
    'posix_prefix': {
        'stdlib': '{base}/lib64/python{py_version_short}',
        'platstdlib': '{platbase}/lib64/python{py_version_short}',
        'purelib': '{base}/lib/python{py_version_short}/site-packages',
        'platlib': '{platbase}/lib64/python{py_version_short}/site-packages',
        'include': '{base}/include/python{py_version_short}',
        'platinclude': '{platbase}/include/python{py_version_short}',
        'scripts': '{base}/bin',
        'data': '{base}',
        },
    'posix_home': {
        'stdlib': '{base}/lib64/python',
        'platstdlib': '{base}/lib64/python',
        'purelib': '{base}/lib/python',
        'platlib': '{base}/lib64/python',
        'include': '{base}/include/python',
        'platinclude': '{base}/include/python',
        'scripts': '{base}/bin',
        'data'   : '{base}',
        },
    'nt': {
        'stdlib': '{base}/Lib',
        'platstdlib': '{base}/Lib',
        'purelib': '{base}/Lib/site-packages',
        'platlib': '{base}/Lib/site-packages',
        'include': '{base}/Include',
        'platinclude': '{base}/Include',
        'scripts': '{base}/Scripts',
        'data'   : '{base}',
        },
    'os2': {
        'stdlib': '{base}/Lib',
        'platstdlib': '{base}/Lib',
        'purelib': '{base}/Lib/site-packages',
        'platlib': '{base}/Lib/site-packages',
        'include': '{base}/Include',
        'platinclude': '{base}/Include',
        'scripts': '{base}/Scripts',
        'data'   : '{base}',
        },
    'os2_home': {
        'stdlib': '{userbase}/lib/python{py_version_short}',
        'platstdlib': '{userbase}/lib/python{py_version_short}',
        'purelib': '{userbase}/lib/python{py_version_short}/site-packages',
        'platlib': '{userbase}/lib/python{py_version_short}/site-packages',
        'include': '{userbase}/include/python{py_version_short}',
        'scripts': '{userbase}/bin',
        'data'   : '{userbase}',
        },
    'nt_user': {
        'stdlib': '{userbase}/Python{py_version_nodot}',
        'platstdlib': '{userbase}/Python{py_version_nodot}',
        'purelib': '{userbase}/Python{py_version_nodot}/site-packages',
        'platlib': '{userbase}/Python{py_version_nodot}/site-packages',
        'include': '{userbase}/Python{py_version_nodot}/Include',
        'scripts': '{userbase}/Scripts',
        'data'   : '{userbase}',
        },
    'posix_user': {
        'stdlib': '{userbase}/lib64/python{py_version_short}',
        'platstdlib': '{userbase}/lib64/python{py_version_short}',
        'purelib': '{userbase}/lib/python{py_version_short}/site-packages',
        'platlib': '{userbase}/lib64/python{py_version_short}/site-packages',
        'include': '{userbase}/include/python{py_version_short}',
        'scripts': '{userbase}/bin',
        'data'   : '{userbase}',
        },
    'osx_framework_user': {
        'stdlib': '{userbase}/lib/python',
        'platstdlib': '{userbase}/lib/python',
        'purelib': '{userbase}/lib/python/site-packages',
        'platlib': '{userbase}/lib/python/site-packages',
        'include': '{userbase}/include',
        'scripts': '{userbase}/bin',
        'data'   : '{userbase}',
        },
    }

_SCHEME_KEYS = ('stdlib', 'platstdlib', 'purelib', 'platlib', 'include',
                'scripts', 'data')
_PY_VERSION = sys.version.split()[0]
_PY_VERSION_SHORT = sys.version[:3]
_PY_VERSION_SHORT_NO_DOT = _PY_VERSION[0] + _PY_VERSION[2]
_PREFIX = os.path.normpath(sys.prefix)
_EXEC_PREFIX = os.path.normpath(sys.exec_prefix)
_CONFIG_VARS = None
_USER_BASE = None

def _safe_realpath(path):
    try:
        return realpath(path)
    except OSError:
        return path

if sys.executable:
    _PROJECT_BASE = os.path.dirname(_safe_realpath(sys.executable))
else:
    # sys.executable can be empty if argv[0] has been changed and Python is
    # unable to retrieve the real program name
    _PROJECT_BASE = _safe_realpath(os.getcwd())

if os.name == "nt" and "pcbuild" in _PROJECT_BASE[-8:].lower():
    _PROJECT_BASE = _safe_realpath(os.path.join(_PROJECT_BASE, pardir))
# PC/VS7.1
if os.name == "nt" and "\\pc\\v" in _PROJECT_BASE[-10:].lower():
    _PROJECT_BASE = _safe_realpath(os.path.join(_PROJECT_BASE, pardir, pardir))
# PC/VS9.0/amd64
if (os.name == "nt"
   and os.path.basename(os.path.dirname(os.path.dirname(_PROJECT_BASE))).lower() == "pc"
   and os.path.basename(os.path.dirname(_PROJECT_BASE)).lower() == "vs9.0"):
    _PROJECT_BASE = _safe_realpath(os.path.join(_PROJECT_BASE, pardir, pardir, pardir))
# PC/AMD64
if os.name == "nt" and "\\pcbuild\\amd64" in _PROJECT_BASE[-14:].lower():
    _PROJECT_BASE = _safe_realpath(os.path.join(_PROJECT_BASE, pardir, pardir))

# set for cross builds
if "_PYTHON_PROJECT_BASE" in os.environ:
    # the build directory for posix builds
    _PROJECT_BASE = os.path.normpath(os.path.abspath("."))
def is_python_build():
    for fn in ("Setup.dist", "Setup.local"):
        if os.path.isfile(os.path.join(_PROJECT_BASE, "Modules", fn)):
            return True
    return False

_PYTHON_BUILD = is_python_build()

if _PYTHON_BUILD:
    for scheme in ('posix_prefix', 'posix_home'):
        _INSTALL_SCHEMES[scheme]['include'] = '{projectbase}/Include'
        _INSTALL_SCHEMES[scheme]['platinclude'] = '{srcdir}'

def _subst_vars(s, local_vars):
    try:
        return s.format(**local_vars)
    except KeyError:
        try:
            return s.format(**os.environ)
        except KeyError, var:
            raise AttributeError('{%s}' % var)

def _extend_dict(target_dict, other_dict):
    target_keys = target_dict.keys()
    for key, value in other_dict.items():
        if key in target_keys:
            continue
        target_dict[key] = value

def _expand_vars(scheme, vars):
    res = {}
    if vars is None:
        vars = {}
    _extend_dict(vars, get_config_vars())

for key, value in _INSTALL_SCHEMES[scheme].items():
        if os.name in ('posix', 'nt'):
            value = os.path.expanduser(value)
        res[key] = os.path.normpath(_subst_vars(value, vars))
    return res

def _get_default_scheme():
    if os.name == 'posix':
        # the default scheme for posix is posix_prefix
        return 'posix_prefix'
    return os.name

def _getuserbase():
    env_base = os.environ.get("PYTHONUSERBASE", None)
    def joinuser(*args):
        return os.path.expanduser(os.path.join(*args))

# what about 'os2emx', 'riscos' ?
    if os.name == "nt":
        base = os.environ.get("APPDATA") or "~"
        return env_base if env_base else joinuser(base, "Python")

if sys.platform == "darwin":
        framework = get_config_var("PYTHONFRAMEWORK")
        if framework:
            return env_base if env_base else \
                               joinuser("~", "Library", framework, "%d.%d"
                                            % (sys.version_info[:2]))

return env_base if env_base else joinuser("~", ".local")

def _parse_makefile(filename, vars=None):
    """Parse a Makefile-style file.

A dictionary containing name/value pairs is returned.  If an
    optional dictionary is passed in as the second argument, it is
    used instead of a new dictionary.
    """
    import re
    # Regexes needed for parsing Makefile (and similar syntaxes,
    # like old-style Setup files).
    _variable_rx = re.compile("([a-zA-Z][a-zA-Z0-9_]+)\s*=\s*(.*)")
    _findvar1_rx = re.compile(r"\$$([A-Za-z][A-Za-z0-9_]*)$")
    _findvar2_rx = re.compile(r"\${([A-Za-z][A-Za-z0-9_]*)}")

if vars is None:
        vars = {}
    done = {}
    notdone = {}

with open(filename) as f:
        lines = f.readlines()

for line in lines:
        if line.startswith('#') or line.strip() == '':
            continue
        m = _variable_rx.match(line)
        if m:
            n, v = m.group(1, 2)
            v = v.strip()
            # `$$' is a literal `$' in make
            tmpv = v.replace('$$', '')

if "$" in tmpv:
                notdone[n] = v
            else:
                try:
                    v = int(v)
                except ValueError:
                    # insert literal `$'
                    done[n] = v.replace('$$', '$')
                else:
                    done[n] = v

# do variable interpolation here
    while notdone:
        for name in notdone.keys():
            value = notdone[name]
            m = _findvar1_rx.search(value) or _findvar2_rx.search(value)
            if m:
                n = m.group(1)
                found = True
                if n in done:
                    item = str(done[n])
                elif n in notdone:
                    # get it on a subsequent round
                    found = False
                elif n in os.environ:
                    # do it like make: fall back to environment
                    item = os.environ[n]
                else:
                    done[n] = item = ""
                if found:
                    after = value[m.end():]
                    value = value[:m.start()] + item + after
                    if "$" in after:
                        notdone[name] = value
                    else:
                        try: value = int(value)
                        except ValueError:
                            done[name] = value.strip()
                        else:
                            done[name] = value
                        del notdone[name]
            else:
                # bogus variable reference; just drop it since we can't deal
                del notdone[name]
    # strip spurious spaces
    for k, v in done.items():
        if isinstance(v, str):
            done[k] = v.strip()

# save the results in the global dictionary
    vars.update(done)
    return vars

def get_makefile_filename():
    """Return the path of the Makefile."""
    if _PYTHON_BUILD:
        return os.path.join(_PROJECT_BASE, "Makefile")
    return os.path.join(get_path('platstdlib'), "config", "Makefile")

# Issue #22199: retain undocumented private name for compatibility
_get_makefile_filename = get_makefile_filename

def _generate_posix_vars():
    """Generate the Python module containing build-time variables."""
    import pprint
    vars = {}
    # load the installed Makefile:
    makefile = get_makefile_filename()
    try:
        _parse_makefile(makefile, vars)
    except IOError, e:
        msg = "invalid Python installation: unable to open %s" % makefile
        if hasattr(e, "strerror"):
            msg = msg + " (%s)" % e.strerror
        raise IOError(msg)

# load the installed pyconfig.h:
    config_h = get_config_h_filename()
    try:
        with open(config_h) as f:
            parse_config_h(f, vars)
    except IOError, e:
        msg = "invalid Python installation: unable to open %s" % config_h
        if hasattr(e, "strerror"):
            msg = msg + " (%s)" % e.strerror
        raise IOError(msg)

# On AIX, there are wrong paths to the linker scripts in the Makefile
    # -- these paths are relative to the Python source, but when installed
    # the scripts are in another directory.
    if _PYTHON_BUILD:
        vars['LDSHARED'] = vars['BLDSHARED']

# There's a chicken-and-egg situation on OS X with regards to the
    # _sysconfigdata module after the changes introduced by #15298:
    # get_config_vars() is called by get_platform() as part of the
    # `make pybuilddir.txt` target -- which is a precursor to the
    # _sysconfigdata.py module being constructed.  Unfortunately,
    # get_config_vars() eventually calls _init_posix(), which attempts
    # to import _sysconfigdata, which we won't have built yet.  In order
    # for _init_posix() to work, if we're on Darwin, just mock up the
    # _sysconfigdata module manually and populate it with the build vars.
    # This is more than sufficient for ensuring the subsequent call to
    # get_platform() succeeds.
    name = '_sysconfigdata'
    if 'darwin' in sys.platform:
        import imp
        module = imp.new_module(name)
        module.build_time_vars = vars
        sys.modules[name] = module

pybuilddir = 'build/lib.%s-%s' % (get_platform(), sys.version[:3])
    if hasattr(sys, "gettotalrefcount"):
        pybuilddir += '-pydebug'
    try:
        os.makedirs(pybuilddir)
    except OSError:
        pass
    destfile = os.path.join(pybuilddir, name + '.py')

with open(destfile, 'wb') as f:
        f.write('# system configuration generated and used by'
                ' the sysconfig module\n')
        f.write('build_time_vars = ')
        pprint.pprint(vars, stream=f)

# Create file used for sys.path fixup -- see Modules/getpath.c
    with open('pybuilddir.txt', 'w') as f:
        f.write(pybuilddir)

def _init_posix(vars):
    """Initialize the module as appropriate for POSIX systems."""
    # _sysconfigdata is generated at build time, see _generate_posix_vars()
    from _sysconfigdata import build_time_vars
    vars.update(build_time_vars)

def _init_non_posix(vars):
    """Initialize the module as appropriate for NT"""
    # set basic install directories
    vars['LIBDEST'] = get_path('stdlib')
    vars['BINLIBDEST'] = get_path('platstdlib')
    vars['INCLUDEPY'] = get_path('include')
    vars['SO'] = '.pyd'
    vars['EXE'] = '.exe'
    vars['VERSION'] = _PY_VERSION_SHORT_NO_DOT
    vars['BINDIR'] = os.path.dirname(_safe_realpath(sys.executable))

#
# public APIs
#

def parse_config_h(fp, vars=None):
    """Parse a config.h-style file.

A dictionary containing name/value pairs is returned.  If an
    optional dictionary is passed in as the second argument, it is
    used instead of a new dictionary.
    """
    import re
    if vars is None:
        vars = {}
    define_rx = re.compile("#define ([A-Z][A-Za-z0-9_]+) (.*)\n")
    undef_rx = re.compile("/[*] #undef ([A-Z][A-Za-z0-9_]+) [*]/\n")

while True:
        line = fp.readline()
        if not line:
            break
        m = define_rx.match(line)
        if m:
            n, v = m.group(1, 2)
            try: v = int(v)
            except ValueError: pass
            vars[n] = v
        else:
            m = undef_rx.match(line)
            if m:
                vars[m.group(1)] = 0
    return vars

def get_config_h_filename():
    """Returns the path of pyconfig.h."""
    if _PYTHON_BUILD:
        if os.name == "nt":
            inc_dir = os.path.join(_PROJECT_BASE, "PC")
        else:
            inc_dir = _PROJECT_BASE
    else:
        inc_dir = get_path('platinclude')
    return os.path.join(inc_dir, 'pyconfig-64.h')

def get_scheme_names():
    """Returns a tuple containing the schemes names."""
    schemes = _INSTALL_SCHEMES.keys()
    schemes.sort()
    return tuple(schemes)

def get_path_names():
    """Returns a tuple containing the paths names."""
    return _SCHEME_KEYS

def get_paths(scheme=_get_default_scheme(), vars=None, expand=True):
    """Returns a mapping containing an install scheme.

``scheme`` is the install scheme name. If not provided, it will
    return the default scheme for the current platform.
    """
    if expand:
        return _expand_vars(scheme, vars)
    else:
        return _INSTALL_SCHEMES[scheme]

def get_path(name, scheme=_get_default_scheme(), vars=None, expand=True):
    """Returns a path corresponding to the scheme.

``scheme`` is the install scheme name.
    """
    return get_paths(scheme, vars, expand)[name]

def get_config_vars(*args):
    """With no arguments, return a dictionary of all configuration
    variables relevant for the current platform.

On Unix, this means every variable defined in Python's installed Makefile;
    On Windows and Mac OS it's a much smaller set.

With arguments, return a list of values that result from looking up
    each argument in the configuration variable dictionary.
    """
    import re
    global _CONFIG_VARS
    if _CONFIG_VARS is None:
        _CONFIG_VARS = {}
        # Normalized versions of prefix and exec_prefix are handy to have;
        # in fact, these are the standard versions used most places in the
        # Distutils.
        _CONFIG_VARS['prefix'] = _PREFIX
        _CONFIG_VARS['exec_prefix'] = _EXEC_PREFIX
        _CONFIG_VARS['py_version'] = _PY_VERSION
        _CONFIG_VARS['py_version_short'] = _PY_VERSION_SHORT
        _CONFIG_VARS['py_version_nodot'] = _PY_VERSION[0] + _PY_VERSION[2]
        _CONFIG_VARS['base'] = _PREFIX
        _CONFIG_VARS['platbase'] = _EXEC_PREFIX
        _CONFIG_VARS['projectbase'] = _PROJECT_BASE

if os.name in ('nt', 'os2'):
            _init_non_posix(_CONFIG_VARS)
        if os.name == 'posix':
            _init_posix(_CONFIG_VARS)

# Setting 'userbase' is done below the call to the
        # init function to enable using 'get_config_var' in
        # the init-function.
        _CONFIG_VARS['userbase'] = _getuserbase()

if 'srcdir' not in _CONFIG_VARS:
            _CONFIG_VARS['srcdir'] = _PROJECT_BASE

# Convert srcdir into an absolute path if it appears necessary.
        # Normally it is relative to the build directory.  However, during
        # testing, for example, we might be running a non-installed python
        # from a different directory.
        if _PYTHON_BUILD and os.name == "posix":
            base = _PROJECT_BASE
            try:
                cwd = os.getcwd()
            except OSError:
                cwd = None
            if (not os.path.isabs(_CONFIG_VARS['srcdir']) and
                base != cwd):
                # srcdir is relative and we are not in the same directory
                # as the executable. Assume executable is in the build
                # directory and make srcdir absolute.
                srcdir = os.path.join(base, _CONFIG_VARS['srcdir'])
                _CONFIG_VARS['srcdir'] = os.path.normpath(srcdir)

# OS X platforms require special customization to handle
        # multi-architecture, multi-os-version installers
        if sys.platform == 'darwin':
            import _osx_support
            _osx_support.customize_config_vars(_CONFIG_VARS)

if args:
        vals = []
        for name in args:
            vals.append(_CONFIG_VARS.get(name))
        return vals
    else:
        return _CONFIG_VARS

def get_config_var(name):
    """Return the value of a single variable using the dictionary returned by
    'get_config_vars()'.

Equivalent to get_config_vars().get(name)
    """
    return get_config_vars().get(name)

def get_platform():
    """Return a string that identifies the current platform.

This is used mainly to distinguish platform-specific build directories and
    platform-specific built distributions.  Typically includes the OS name
    and version and the architecture (as supplied by 'os.uname()'),
    although the exact information included depends on the OS; eg. for IRIX
    the architecture isn't particularly important (IRIX only runs on SGI
    hardware), but for Linux the kernel version isn't particularly
    important.

Examples of returned values:
       linux-i586
       linux-alpha (?)
       solaris-2.6-sun4u
       irix-5.3
       irix64-6.2

Windows will return one of:
       win-amd64 (64bit Windows on AMD64 (aka x86_64, Intel64, EM64T, etc)
       win-ia64 (64bit Windows on Itanium)
       win32 (all others - specifically, sys.platform is returned)

For other non-POSIX platforms, currently just returns 'sys.platform'.
    """
    import re
    if os.name == 'nt':
        # sniff sys.version for architecture.
        prefix = " bit ("
        i = sys.version.find(prefix)
        if i == -1:
            return sys.platform
        j = sys.version.find(")", i)
        look = sys.version[i+len(prefix):j].lower()
        if look == 'amd64':
            return 'win-amd64'
        if look == 'itanium':
            return 'win-ia64'
        return sys.platform

# Set for cross builds explicitly
    if "_PYTHON_HOST_PLATFORM" in os.environ:
        return os.environ["_PYTHON_HOST_PLATFORM"]

if os.name != "posix" or not hasattr(os, 'uname'):
        # XXX what about the architecture? NT is Intel or Alpha,
        # Mac OS is M68k or PPC, etc.
        return sys.platform

# Try to distinguish various flavours of Unix
    osname, host, release, version, machine = os.uname()

# Convert the OS name to lowercase, remove '/' characters
    # (to accommodate BSD/OS), and translate spaces (for "Power Macintosh")
    osname = osname.lower().replace('/', '')
    machine = machine.replace(' ', '_')
    machine = machine.replace('/', '-')

if osname[:5] == "linux":
        # At least on Linux/Intel, 'machine' is the processor --
        # i386, etc.
        # XXX what about Alpha, SPARC, etc?
        return  "%s-%s" % (osname, machine)
    elif osname[:5] == "sunos":
        if release[0] >= "5":           # SunOS 5 == Solaris 2
            osname = "solaris"
            release = "%d.%s" % (int(release[0]) - 3, release[2:])
            # We can't use "platform.architecture()[0]" because a
            # bootstrap problem. We use a dict to get an error
            # if some suspicious happens.
            bitness = {2147483647:"32bit", 9223372036854775807:"64bit"}
            machine += ".%s" % bitness[sys.maxint]
        # fall through to standard osname-release-machine representation
    elif osname[:4] == "irix":              # could be "irix64"!
        return "%s-%s" % (osname, release)
    elif osname[:3] == "aix":
        return "%s-%s.%s" % (osname, version, release)
    elif osname[:6] == "cygwin":
        osname = "cygwin"
        rel_re = re.compile (r'[\d.]+')
        m = rel_re.match(release)
        if m:
            release = m.group()
    elif osname[:6] == "darwin":
        import _osx_support
        osname, release, machine = _osx_support.get_platform_osx(
                                            get_config_vars(),
                                            osname, release, machine)

return "%s-%s-%s" % (osname, release, machine)

def get_python_version():
    return _PY_VERSION_SHORT

def _print_dict(title, data):
    for index, (key, value) in enumerate(sorted(data.items())):
        if index == 0:
            print '%s: ' % (title)
        print '\t%s = "%s"' % (key, value)

def _main():
    """Display all information sysconfig detains."""
    if '--generate-posix-vars' in sys.argv:
        _generate_posix_vars()
        return
    print 'Platform: "%s"' % get_platform()
    print 'Python version: "%s"' % get_python_version()
    print 'Current installation scheme: "%s"' % _get_default_scheme()
    print
    _print_dict('Paths', get_paths())
    print
    _print_dict('Variables', get_config_vars())

if __name__ == '__main__':
    _main()

X7ROOT File Manager

Editing: sysconfig.py

Upload File

Create Folder