""" This module was created to get information available in the interpreter, such as libraries, paths, etc. what is what: sys.builtin_module_names: contains the builtin modules embeeded in python (rigth now, we specify all manually). sys.prefix: A string giving the site-specific directory prefix where the platform independent Python files are installed format is something as EXECUTABLE:python.exe|libs@compiled_dlls$builtin_mods all internal are separated by | """ import sys try: import os.path def fully_normalize_path(path): """fixes the path so that the format of the path really reflects the directories in the system""" return os.path.normpath(path) join = os.path.join except: # ImportError or AttributeError. # See: http://stackoverflow.com/questions/10254353/error-while-installing-jython-for-pydev def fully_normalize_path(path): """fixes the path so that the format of the path really reflects the directories in the system""" return path def join(a, b): if a.endswith("/") or a.endswith("\\"): return a + b return a + "/" + b IS_PYTHON_3_ONWARDS = 0 try: IS_PYTHON_3_ONWARDS = sys.version_info[0] >= 3 except: # That's OK, not all versions of python have sys.version_info pass try: # Just check if False and True are defined (depends on version, not whether it's jython/python) False True except: exec("True, False = 1,0") # An exec is used so that python 3k does not give a syntax error if sys.platform == "cygwin": import ctypes def native_path(path): MAX_PATH = 512 # On cygwin NT, its 260 lately, but just need BIG ENOUGH buffer """Get the native form of the path, like c:\\Foo for /cygdrive/c/Foo""" retval = ctypes.create_string_buffer(MAX_PATH) path = fully_normalize_path(path) path = tobytes(path) CCP_POSIX_TO_WIN_A = 0 cygwin1dll = ctypes.cdll.LoadLibrary("cygwin1.dll") cygwin1dll.cygwin_conv_path(CCP_POSIX_TO_WIN_A, path, retval, MAX_PATH) return retval.value else: def native_path(path): return fully_normalize_path(path) def __getfilesystemencoding(): """ Note: there's a copy of this method in _pydev_filesystem_encoding.py """ try: ret = sys.getfilesystemencoding() if not ret: raise RuntimeError("Unable to get encoding.") return ret except: try: # Handle Jython from java.lang import System # @UnresolvedImport env = System.getProperty("os.name").lower() if env.find("win") != -1: return "ISO-8859-1" # mbcs does not work on Jython, so, use a (hopefully) suitable replacement return "utf-8" except: pass # Only available from 2.3 onwards. if sys.platform == "win32": return "mbcs" return "utf-8" def getfilesystemencoding(): try: ret = __getfilesystemencoding() # Check if the encoding is actually there to be used! if hasattr("", "encode"): "".encode(ret) if hasattr("", "decode"): "".decode(ret) return ret except: return "utf-8" file_system_encoding = getfilesystemencoding() if IS_PYTHON_3_ONWARDS: unicode_type = str bytes_type = bytes else: unicode_type = unicode bytes_type = str def tounicode(s): if hasattr(s, "decode"): if not isinstance(s, unicode_type): # Depending on the platform variant we may have decode on string or not. return s.decode(file_system_encoding) return s def tobytes(s): if hasattr(s, "encode"): if not isinstance(s, bytes_type): return s.encode(file_system_encoding) return s def toasciimxl(s): # output for xml without a declared encoding # As the output is xml, we have to encode chars (< and > are ok as they're not accepted in the filesystem name -- # if it was allowed, we'd have to do things more selectively so that < and > don't get wrongly replaced). s = s.replace("&", "&") try: ret = s.encode("ascii", "xmlcharrefreplace") except: # use workaround ret = "" for c in s: try: ret += c.encode("ascii") except: try: # Python 2: unicode is a valid identifier ret += unicode("&#%d;") % ord(c) except: # Python 3: a string is already unicode, so, just doing it directly should work. ret += "&#%d;" % ord(c) return ret if __name__ == "__main__": try: # just give some time to get the reading threads attached (just in case) import time time.sleep(0.1) except: pass try: executable = tounicode(native_path(sys.executable)) except: executable = tounicode(sys.executable) if sys.platform == "cygwin" and not executable.endswith(tounicode(".exe")): executable += tounicode(".exe") try: major = str(sys.version_info[0]) minor = str(sys.version_info[1]) except AttributeError: # older versions of python don't have version_info import string s = string.split(sys.version, " ")[0] s = string.split(s, ".") major = s[0] minor = s[1] s = tounicode("%s.%s") % (tounicode(major), tounicode(minor)) contents = [tounicode("")] contents.append(tounicode("%s") % (tounicode(s),)) contents.append(tounicode("%s") % tounicode(executable)) # this is the new implementation to get the system folders # (still need to check if it works in linux) # (previously, we were getting the executable dir, but that is not always correct...) prefix = tounicode(native_path(sys.prefix)) # print_ 'prefix is', prefix result = [] path_used = sys.path try: path_used = path_used[1:] # Use a copy (and don't include the directory of this script as a path.) except: pass # just ignore it... for p in path_used: p = tounicode(native_path(p)) try: import string # to be compatible with older versions if string.find(p, prefix) == 0: # was startswith result.append((p, True)) else: result.append((p, False)) except (ImportError, AttributeError): # python 3k also does not have it # jython may not have it (depending on how are things configured) if p.startswith(prefix): # was startswith result.append((p, True)) else: result.append((p, False)) for p, b in result: if b: contents.append(tounicode('%s') % (p,)) else: contents.append(tounicode('%s') % (p,)) # no compiled libs # nor forced libs for builtinMod in sys.builtin_module_names: contents.append(tounicode("%s") % tounicode(builtinMod)) contents.append(tounicode("")) unic = tounicode("\n").join(contents) inasciixml = toasciimxl(unic) if IS_PYTHON_3_ONWARDS: # This is the 'official' way of writing binary output in Py3K (see: http://bugs.python.org/issue4571) sys.stdout.buffer.write(inasciixml) else: sys.stdout.write(inasciixml) sys.stdout.flush() sys.stderr.flush()