mirror of
https://gitflic.ru/project/openide/openide.git
synced 2026-01-04 00:20:55 +07:00
265 lines
11 KiB
Python
265 lines
11 KiB
Python
'''
|
|
This module will:
|
|
- change the input() and raw_input() commands to change \r\n or \r into \n
|
|
- execute the user site customize -- if available
|
|
- change raw_input() and input() to also remove any trailing \r
|
|
|
|
Up to PyDev 3.4 it also was setting the default encoding, but it was removed because of differences when
|
|
running from a shell (i.e.: now we just set the PYTHONIOENCODING related to that -- which is properly
|
|
treated on Py 2.7 onwards).
|
|
'''
|
|
DEBUG = 0 #0 or 1 because of jython
|
|
|
|
import sys
|
|
encoding = None
|
|
|
|
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
|
|
if DEBUG:
|
|
import traceback;traceback.print_exc() #@Reimport
|
|
|
|
#-----------------------------------------------------------------------------------------------------------------------
|
|
#Line buffering
|
|
if IS_PYTHON_3_ONWARDS:
|
|
#Python 3 has a bug (http://bugs.python.org/issue4705) in which -u doesn't properly make output/input unbuffered
|
|
#so, we need to enable that ourselves here.
|
|
try:
|
|
sys.stdout._line_buffering = True
|
|
except:
|
|
pass
|
|
try:
|
|
sys.stderr._line_buffering = True
|
|
except:
|
|
pass
|
|
try:
|
|
sys.stdin._line_buffering = True
|
|
except:
|
|
pass
|
|
|
|
|
|
try:
|
|
import org.python.core.PyDictionary #@UnresolvedImport @UnusedImport -- just to check if it could be valid
|
|
def dict_contains(d, key):
|
|
return d.has_key(key)
|
|
except:
|
|
try:
|
|
#Py3k does not have has_key anymore, and older versions don't have __contains__
|
|
dict_contains = dict.__contains__
|
|
except:
|
|
try:
|
|
dict_contains = dict.has_key
|
|
except NameError:
|
|
def dict_contains(d, key):
|
|
return d.has_key(key)
|
|
|
|
def install_breakpointhook():
|
|
def custom_sitecustomize_breakpointhook(*args, **kwargs):
|
|
import os
|
|
hookname = os.getenv('PYTHONBREAKPOINT')
|
|
if (
|
|
hookname is not None
|
|
and len(hookname) > 0
|
|
and hasattr(sys, '__breakpointhook__')
|
|
and sys.__breakpointhook__ != custom_sitecustomize_breakpointhook
|
|
):
|
|
sys.__breakpointhook__(*args, **kwargs)
|
|
else:
|
|
sys.path.append(os.path.dirname(os.path.dirname(__file__)))
|
|
import pydevd
|
|
kwargs.setdefault('stop_at_frame', sys._getframe().f_back)
|
|
pydevd.settrace(*args, **kwargs)
|
|
|
|
if sys.version_info[0:2] >= (3, 7):
|
|
# There are some choices on how to provide the breakpoint hook. Namely, we can provide a
|
|
# PYTHONBREAKPOINT which provides the import path for a method to be executed or we
|
|
# can override sys.breakpointhook.
|
|
# pydevd overrides sys.breakpointhook instead of providing an environment variable because
|
|
# it's possible that the debugger starts the user program but is not available in the
|
|
# PYTHONPATH (and would thus fail to be imported if PYTHONBREAKPOINT was set to pydevd.settrace).
|
|
# Note that the implementation still takes PYTHONBREAKPOINT in account (so, if it was provided
|
|
# by someone else, it'd still work).
|
|
sys.breakpointhook = custom_sitecustomize_breakpointhook
|
|
else:
|
|
if sys.version_info[0] >= 3:
|
|
import builtins as __builtin__ # Py3
|
|
else:
|
|
import __builtin__
|
|
|
|
# In older versions, breakpoint() isn't really available, so, install the hook directly
|
|
# in the builtins.
|
|
__builtin__.breakpoint = custom_sitecustomize_breakpointhook
|
|
sys.__breakpointhook__ = custom_sitecustomize_breakpointhook
|
|
|
|
# Install the breakpoint hook at import time.
|
|
install_breakpointhook()
|
|
|
|
def install_breakpointhook():
|
|
def custom_sitecustomize_breakpointhook(*args, **kwargs):
|
|
import os
|
|
hookname = os.getenv('PYTHONBREAKPOINT')
|
|
if hookname is not None and len(hookname) > 0 and hasattr(sys, '__breakpointhook__'):
|
|
sys.__breakpointhook__(*args, **kwargs)
|
|
else:
|
|
sys.path.append(os.path.dirname(os.path.dirname(__file__)))
|
|
import pydevd
|
|
kwargs.setdefault('stop_at_frame', sys._getframe().f_back)
|
|
pydevd.settrace(*args, **kwargs)
|
|
|
|
if sys.version_info >= (3, 7):
|
|
# There are some choices on how to provide the breakpoint hook. Namely, we can provide a
|
|
# PYTHONBREAKPOINT which provides the import path for a method to be executed or we
|
|
# can override sys.breakpointhook.
|
|
# pydevd overrides sys.breakpointhook instead of providing an environment variable because
|
|
# it's possible that the debugger starts the user program but is not available in the
|
|
# PYTHONPATH (and would thus fail to be imported if PYTHONBREAKPOINT was set to pydevd.settrace).
|
|
# Note that the implementation still takes PYTHONBREAKPOINT in account (so, if it was provided
|
|
# by someone else, it'd still work).
|
|
sys.breakpointhook = custom_sitecustomize_breakpointhook
|
|
|
|
|
|
# Install the breakpoint hook at import time.
|
|
install_breakpointhook()
|
|
|
|
#-----------------------------------------------------------------------------------------------------------------------
|
|
#now that we've finished the needed pydev sitecustomize, let's run the default one (if available)
|
|
|
|
#Ok, some weirdness going on in Python 3k: when removing this module from the sys.module to import the 'real'
|
|
#sitecustomize, all the variables in this scope become None (as if it was garbage-collected), so, the the reference
|
|
#below is now being kept to create a cyclic reference so that it neven dies)
|
|
__pydev_sitecustomize_module__ = sys.modules.get('sitecustomize') #A ref to this module
|
|
|
|
|
|
#remove the pydev site customize (and the pythonpath for it)
|
|
paths_removed = []
|
|
try:
|
|
for c in sys.path[:]:
|
|
#Pydev controls the whole classpath in Jython already, so, we don't want a a duplicate for
|
|
#what we've already added there (this is needed to support Jython 2.5b1 onwards -- otherwise, as
|
|
#we added the sitecustomize to the pythonpath and to the classpath, we'd have to remove it from the
|
|
#classpath too -- and I don't think there's a way to do that... or not?)
|
|
if c.find('pydev_sitecustomize') != -1 or c == '__classpath__' or c == '__pyclasspath__' or \
|
|
c == '__classpath__/' or c == '__pyclasspath__/' or c == '__classpath__\\' or c == '__pyclasspath__\\':
|
|
sys.path.remove(c)
|
|
if c.find('pydev_sitecustomize') == -1:
|
|
#We'll re-add any paths removed but the pydev_sitecustomize we added from pydev.
|
|
paths_removed.append(c)
|
|
|
|
if dict_contains(sys.modules, 'sitecustomize'):
|
|
del sys.modules['sitecustomize'] #this module
|
|
except:
|
|
#print the error... should never happen (so, always show, and not only on debug)!
|
|
import traceback;traceback.print_exc() #@Reimport
|
|
else:
|
|
#Now, execute the default sitecustomize
|
|
try:
|
|
import sitecustomize #@UnusedImport
|
|
sitecustomize.__pydev_sitecustomize_module__ = __pydev_sitecustomize_module__
|
|
except:
|
|
pass
|
|
|
|
if not dict_contains(sys.modules, 'sitecustomize'):
|
|
#If there was no sitecustomize, re-add the pydev sitecustomize (pypy gives a KeyError if it's not there)
|
|
sys.modules['sitecustomize'] = __pydev_sitecustomize_module__
|
|
|
|
try:
|
|
if paths_removed:
|
|
if sys is None:
|
|
import sys
|
|
if sys is not None:
|
|
#And after executing the default sitecustomize, restore the paths (if we didn't remove it before,
|
|
#the import sitecustomize would recurse).
|
|
sys.path.extend(paths_removed)
|
|
except:
|
|
#print the error... should never happen (so, always show, and not only on debug)!
|
|
import traceback;traceback.print_exc() #@Reimport
|
|
|
|
|
|
|
|
|
|
if sys.version_info[0] < 3:
|
|
try:
|
|
#Redefine input and raw_input only after the original sitecustomize was executed
|
|
#(because otherwise, the original raw_input and input would still not be defined)
|
|
import __builtin__
|
|
original_raw_input = __builtin__.raw_input
|
|
original_input = __builtin__.input
|
|
|
|
|
|
def raw_input(prompt=''):
|
|
#the original raw_input would only remove a trailing \n, so, at
|
|
#this point if we had a \r\n the \r would remain (which is valid for eclipse)
|
|
#so, let's remove the remaining \r which python didn't expect.
|
|
ret = original_raw_input(prompt)
|
|
|
|
if ret.endswith('\r'):
|
|
return ret[:-1]
|
|
|
|
return ret
|
|
raw_input.__doc__ = original_raw_input.__doc__
|
|
|
|
def input(prompt=''):
|
|
#input must also be rebinded for using the new raw_input defined
|
|
return eval(raw_input(prompt))
|
|
input.__doc__ = original_input.__doc__
|
|
|
|
|
|
__builtin__.raw_input = raw_input
|
|
__builtin__.input = input
|
|
|
|
except:
|
|
#Don't report errors at this stage
|
|
if DEBUG:
|
|
import traceback;traceback.print_exc() #@Reimport
|
|
|
|
else:
|
|
try:
|
|
import builtins #Python 3.0 does not have the __builtin__ module @UnresolvedImport
|
|
original_input = builtins.input
|
|
def input(prompt=''):
|
|
#the original input would only remove a trailing \n, so, at
|
|
#this point if we had a \r\n the \r would remain (which is valid for eclipse)
|
|
#so, let's remove the remaining \r which python didn't expect.
|
|
ret = original_input(prompt)
|
|
|
|
if ret.endswith('\r'):
|
|
return ret[:-1]
|
|
|
|
return ret
|
|
input.__doc__ = original_input.__doc__
|
|
builtins.input = input
|
|
except:
|
|
#Don't report errors at this stage
|
|
if DEBUG:
|
|
import traceback;traceback.print_exc() #@Reimport
|
|
|
|
|
|
|
|
try:
|
|
#The original getpass doesn't work from the eclipse console, so, let's put a replacement
|
|
#here (note that it'll not go into echo mode in the console, so, what' the user writes
|
|
#will actually be seen)
|
|
#Note: same thing from the fix_getpass module -- but we don't want to import it in this
|
|
#custom sitecustomize.
|
|
def fix_get_pass():
|
|
try:
|
|
import getpass
|
|
except ImportError:
|
|
return #If we can't import it, we can't fix it
|
|
import warnings
|
|
fallback = getattr(getpass, 'fallback_getpass', None) # >= 2.6
|
|
if not fallback:
|
|
fallback = getpass.default_getpass # <= 2.5
|
|
getpass.getpass = fallback
|
|
if hasattr(getpass, 'GetPassWarning'):
|
|
warnings.simplefilter("ignore", category=getpass.GetPassWarning)
|
|
fix_get_pass()
|
|
|
|
except:
|
|
#Don't report errors at this stage
|
|
if DEBUG:
|
|
import traceback;traceback.print_exc() #@Reimport
|