| ''' | |
| Entry-point module to start the code-completion server for PyDev. | |
| @author Fabio Zadrozny | |
| ''' | |
| import sys | |
| IS_PYTHON_3_ONWARDS = sys.version_info[0] >= 3 | |
| if not IS_PYTHON_3_ONWARDS: | |
| import __builtin__ | |
| else: | |
| import builtins as __builtin__ # Python 3.0 | |
| from _pydevd_bundle.pydevd_constants import IS_JYTHON | |
| if IS_JYTHON: | |
| import java.lang # @UnresolvedImport | |
| SERVER_NAME = 'jycompletionserver' | |
| from _pydev_bundle import _pydev_jy_imports_tipper | |
| _pydev_imports_tipper = _pydev_jy_imports_tipper | |
| else: | |
| # it is python | |
| SERVER_NAME = 'pycompletionserver' | |
| from _pydev_bundle import _pydev_imports_tipper | |
| from _pydev_imps._pydev_saved_modules import socket | |
| import sys | |
| if sys.platform == "darwin": | |
| # See: https://sourceforge.net/projects/pydev/forums/forum/293649/topic/3454227 | |
| try: | |
| import _CF # Don't fail if it doesn't work -- do it because it must be loaded on the main thread! @UnresolvedImport @UnusedImport | |
| except: | |
| pass | |
| # initial sys.path | |
| _sys_path = [] | |
| for p in sys.path: | |
| # changed to be compatible with 1.5 | |
| _sys_path.append(p) | |
| # initial sys.modules | |
| _sys_modules = {} | |
| for name, mod in sys.modules.items(): | |
| _sys_modules[name] = mod | |
| import traceback | |
| from _pydev_imps._pydev_saved_modules import time | |
| try: | |
| import StringIO | |
| except: | |
| import io as StringIO #Python 3.0 | |
| try: | |
| from urllib import quote_plus, unquote_plus | |
| except ImportError: | |
| from urllib.parse import quote_plus, unquote_plus #Python 3.0 | |
| INFO1 = 1 | |
| INFO2 = 2 | |
| WARN = 4 | |
| ERROR = 8 | |
| DEBUG = INFO1 | ERROR | |
| def dbg(s, prior): | |
| if prior & DEBUG != 0: | |
| sys.stdout.write('%s\n' % (s,)) | |
| # f = open('c:/temp/test.txt', 'a') | |
| # print_ >> f, s | |
| # f.close() | |
| from _pydev_bundle import pydev_localhost | |
| HOST = pydev_localhost.get_localhost() # Symbolic name meaning the local host | |
| MSG_KILL_SERVER = '@@KILL_SERVER_END@@' | |
| MSG_COMPLETIONS = '@@COMPLETIONS' | |
| MSG_END = 'END@@' | |
| MSG_INVALID_REQUEST = '@@INVALID_REQUEST' | |
| MSG_JYTHON_INVALID_REQUEST = '@@JYTHON_INVALID_REQUEST' | |
| MSG_CHANGE_DIR = '@@CHANGE_DIR:' | |
| MSG_OK = '@@MSG_OK_END@@' | |
| MSG_IMPORTS = '@@IMPORTS:' | |
| MSG_PYTHONPATH = '@@PYTHONPATH_END@@' | |
| MSG_CHANGE_PYTHONPATH = '@@CHANGE_PYTHONPATH:' | |
| MSG_JEDI = '@@MSG_JEDI:' | |
| MSG_SEARCH = '@@SEARCH' | |
| BUFFER_SIZE = 1024 | |
| currDirModule = None | |
| def complete_from_dir(directory): | |
| ''' | |
| This is necessary so that we get the imports from the same directory where the file | |
| we are completing is located. | |
| ''' | |
| global currDirModule | |
| if currDirModule is not None: | |
| if len(sys.path) > 0 and sys.path[0] == currDirModule: | |
| del sys.path[0] | |
| currDirModule = directory | |
| sys.path.insert(0, directory) | |
| def change_python_path(pythonpath): | |
| '''Changes the pythonpath (clears all the previous pythonpath) | |
| @param pythonpath: string with paths separated by | | |
| ''' | |
| split = pythonpath.split('|') | |
| sys.path = [] | |
| for path in split: | |
| path = path.strip() | |
| if len(path) > 0: | |
| sys.path.append(path) | |
| class Processor: | |
| def __init__(self): | |
| # nothing to do | |
| return | |
| def remove_invalid_chars(self, msg): | |
| try: | |
| msg = str(msg) | |
| except UnicodeDecodeError: | |
| pass | |
| if msg: | |
| try: | |
| return quote_plus(msg) | |
| except: | |
| sys.stdout.write('error making quote plus in %s\n' % (msg,)) | |
| raise | |
| return ' ' | |
| def format_completion_message(self, defFile, completionsList): | |
| ''' | |
| Format the completions suggestions in the following format: | |
| @@COMPLETIONS(modFile(token,description),(token,description),(token,description))END@@ | |
| ''' | |
| compMsg = [] | |
| compMsg.append('%s' % defFile) | |
| for tup in completionsList: | |
| compMsg.append(',') | |
| compMsg.append('(') | |
| compMsg.append(str(self.remove_invalid_chars(tup[0]))) # token | |
| compMsg.append(',') | |
| compMsg.append(self.remove_invalid_chars(tup[1])) # description | |
| if(len(tup) > 2): | |
| compMsg.append(',') | |
| compMsg.append(self.remove_invalid_chars(tup[2])) # args - only if function. | |
| if(len(tup) > 3): | |
| compMsg.append(',') | |
| compMsg.append(self.remove_invalid_chars(tup[3])) # TYPE | |
| compMsg.append(')') | |
| return '%s(%s)%s' % (MSG_COMPLETIONS, ''.join(compMsg), MSG_END) | |
| class Exit(Exception): | |
| pass | |
| class CompletionServer: | |
| def __init__(self, port): | |
| self.ended = False | |
| self.port = port | |
| self.socket = None # socket to send messages. | |
| self.exit_process_on_kill = True | |
| self.processor = Processor() | |
| def connect_to_server(self): | |
| from _pydev_imps._pydev_saved_modules import socket | |
| self.socket = s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) | |
| try: | |
| s.connect((HOST, self.port)) | |
| except: | |
| sys.stderr.write('Error on connect_to_server with parameters: host: %s port: %s\n' % (HOST, self.port)) | |
| raise | |
| def get_completions_message(self, defFile, completionsList): | |
| ''' | |
| get message with completions. | |
| ''' | |
| return self.processor.format_completion_message(defFile, completionsList) | |
| def get_token_and_data(self, data): | |
| ''' | |
| When we receive this, we have 'token):data' | |
| ''' | |
| token = '' | |
| for c in data: | |
| if c != ')': | |
| token = token + c | |
| else: | |
| break; | |
| return token, data.lstrip(token + '):') | |
| def emulated_sendall(self, msg): | |
| MSGLEN = 1024 * 20 | |
| totalsent = 0 | |
| while totalsent < MSGLEN: | |
| sent = self.socket.send(msg[totalsent:]) | |
| if sent == 0: | |
| return | |
| totalsent = totalsent + sent | |
| def send(self, msg): | |
| if not hasattr(self.socket, 'sendall'): | |
| #Older versions (jython 2.1) | |
| self.emulated_sendall(msg) | |
| else: | |
| if IS_PYTHON_3_ONWARDS: | |
| self.socket.sendall(bytearray(msg, 'utf-8')) | |
| else: | |
| self.socket.sendall(msg) | |
| def run(self): | |
| # Echo server program | |
| try: | |
| from _pydev_bundle import _pydev_log | |
| log = _pydev_log.Log() | |
| dbg(SERVER_NAME + ' connecting to java server on %s (%s)' % (HOST, self.port) , INFO1) | |
| # after being connected, create a socket as a client. | |
| self.connect_to_server() | |
| dbg(SERVER_NAME + ' Connected to java server', INFO1) | |
| while not self.ended: | |
| data = '' | |
| while data.find(MSG_END) == -1: | |
| received = self.socket.recv(BUFFER_SIZE) | |
| if len(received) == 0: | |
| raise Exit() # ok, connection ended | |
| if IS_PYTHON_3_ONWARDS: | |
| data = data + received.decode('utf-8') | |
| else: | |
| data = data + received | |
| try: | |
| try: | |
| if data.find(MSG_KILL_SERVER) != -1: | |
| dbg(SERVER_NAME + ' kill message received', INFO1) | |
| # break if we received kill message. | |
| self.ended = True | |
| raise Exit() | |
| dbg(SERVER_NAME + ' starting keep alive thread', INFO2) | |
| if data.find(MSG_PYTHONPATH) != -1: | |
| comps = [] | |
| for p in _sys_path: | |
| comps.append((p, ' ')) | |
| self.send(self.get_completions_message(None, comps)) | |
| else: | |
| data = data[:data.rfind(MSG_END)] | |
| if data.startswith(MSG_IMPORTS): | |
| data = data[len(MSG_IMPORTS):] | |
| data = unquote_plus(data) | |
| defFile, comps = _pydev_imports_tipper.generate_tip(data, log) | |
| self.send(self.get_completions_message(defFile, comps)) | |
| elif data.startswith(MSG_CHANGE_PYTHONPATH): | |
| data = data[len(MSG_CHANGE_PYTHONPATH):] | |
| data = unquote_plus(data) | |
| change_python_path(data) | |
| self.send(MSG_OK) | |
| elif data.startswith(MSG_JEDI): | |
| data = data[len(MSG_JEDI):] | |
| data = unquote_plus(data) | |
| line, column, encoding, path, source = data.split('|', 4) | |
| try: | |
| import jedi # @UnresolvedImport | |
| except: | |
| self.send(self.get_completions_message(None, [('Error on import jedi', 'Error importing jedi', '')])) | |
| else: | |
| script = jedi.Script( | |
| # Line +1 because it expects lines 1-based (and col 0-based) | |
| source=source, | |
| line=int(line) + 1, | |
| column=int(column), | |
| source_encoding=encoding, | |
| path=path, | |
| ) | |
| lst = [] | |
| for completion in script.completions(): | |
| t = completion.type | |
| if t == 'class': | |
| t = '1' | |
| elif t == 'function': | |
| t = '2' | |
| elif t == 'import': | |
| t = '0' | |
| elif t == 'keyword': | |
| continue # Keywords are already handled in PyDev | |
| elif t == 'statement': | |
| t = '3' | |
| else: | |
| t = '-1' | |
| # gen list(tuple(name, doc, args, type)) | |
| lst.append((completion.name, '', '', t)) | |
| self.send(self.get_completions_message('empty', lst)) | |
| elif data.startswith(MSG_SEARCH): | |
| data = data[len(MSG_SEARCH):] | |
| data = unquote_plus(data) | |
| (f, line, col), foundAs = _pydev_imports_tipper.search_definition(data) | |
| self.send(self.get_completions_message(f, [(line, col, foundAs)])) | |
| elif data.startswith(MSG_CHANGE_DIR): | |
| data = data[len(MSG_CHANGE_DIR):] | |
| data = unquote_plus(data) | |
| complete_from_dir(data) | |
| self.send(MSG_OK) | |
| else: | |
| self.send(MSG_INVALID_REQUEST) | |
| except Exit: | |
| e = sys.exc_info()[1] | |
| msg = self.get_completions_message(None, [('Exit:', 'SystemExit', '')]) | |
| try: | |
| self.send(msg) | |
| except socket.error: | |
| pass # Ok, may be closed already | |
| raise e # raise original error. | |
| except: | |
| dbg(SERVER_NAME + ' exception occurred', ERROR) | |
| s = StringIO.StringIO() | |
| traceback.print_exc(file=s) | |
| err = s.getvalue() | |
| dbg(SERVER_NAME + ' received error: ' + str(err), ERROR) | |
| msg = self.get_completions_message(None, [('ERROR:', '%s\nLog:%s' % (err, log.get_contents()), '')]) | |
| try: | |
| self.send(msg) | |
| except socket.error: | |
| pass # Ok, may be closed already | |
| finally: | |
| log.clear_log() | |
| self.socket.close() | |
| self.ended = True | |
| raise Exit() # connection broken | |
| except Exit: | |
| if self.exit_process_on_kill: | |
| sys.exit(0) | |
| # No need to log SystemExit error | |
| except: | |
| s = StringIO.StringIO() | |
| exc_info = sys.exc_info() | |
| traceback.print_exception(exc_info[0], exc_info[1], exc_info[2], limit=None, file=s) | |
| err = s.getvalue() | |
| dbg(SERVER_NAME + ' received error: ' + str(err), ERROR) | |
| raise | |
| if __name__ == '__main__': | |
| port = int(sys.argv[1]) # this is from where we want to receive messages. | |
| t = CompletionServer(port) | |
| dbg(SERVER_NAME + ' will start', INFO1) | |
| t.run() |