Rope Refactoring: comparison RefactoringRope/CodeAssistServer.py

-:a92b3272f4c1
+:f740b50380df
 import os
 import sys
 import contextlib
-from PyQt5.QtCore import (
+from PyQt6.QtCore import (
 pyqtSlot, QCoreApplication, QTimer
 )
-from E5Gui.E5Application import e5App
+from EricWidgets.EricApplication import ericApp
-from E5Gui import E5MessageBox
+from EricWidgets import EricMessageBox
+from EricNetwork.EricJsonServer import EricJsonServer
 from QScintilla.Editor import Editor
-try:
-from E5Network.E5JsonServer import E5JsonServer
-except ImportError:
-# TODO: delete JsonServer once ported to eric7
-from .JsonServer import JsonServer as E5JsonServer
 import Globals
 import Preferences
-class CodeAssistServer(E5JsonServer):
+class CodeAssistServer(EricJsonServer):
 """
 Class implementing the autocompletion interface to rope.
 """
 IdProject = "Project"
 super().__init__(
 "CodeAssistServer", multiplex=True, parent=parent)
 self.__plugin = plugin
 self.__ui = parent
-self.__vm = e5App().getObject("ViewManager")
+self.__vm = ericApp().getObject("ViewManager")
-self.__e5project = e5App().getObject("Project")
+self.__e5project = ericApp().getObject("Project")
 self.__editorLanguageMapping = {}
 self.__clientConfigs = {}
 self.__editors = {}
-self.__asyncCompletions = False
 self.__documentationViewer = None
 # attributes to store the resuls of the client side
 self.__completions = None
 }
 # Python 3
 self.__ensureActive("Python3")
-def setAsyncCompletions(self, asynchronous):
-"""
-Public method to set the asynchronous completions flag.
-@param asynchronous flag indicating asynchronous completions
-@type bool
-"""
-self.__asyncCompletions = asynchronous
 def __updateEditorLanguageMapping(self):
 """
 Private method to update the editor language to connection mapping.
 """
 self.__editorLanguageMapping = {}
 self.__editorLanguageMapping.update({
 "Python3": "Python3",
 "MicroPython": "Python3",
 "Pygments|Python": "Python3",
 "Pygments|Python 2.x": "Python3",
+"Cython": "Python3",
 })
 def isSupportedLanguage(self, language):
 """
 Public method to check, if the given language is supported.
 def __idString(self, editor):
 """
 Private method to determine the ID string for the back-end.
 @param editor reference to the editor to determine the ID string for
-@type QScintilla.Editor
+@type Editor
 @return ID string
 @rtype str
 """
 idString = ""
 editor.editorSaved.connect(
 lambda: self.__configChanged(idString))
 self.__editors[idString] = editor
 return
 else:
-E5MessageBox.critical(
+EricMessageBox.critical(
 self.__ui,
 self.tr("Configure Rope"),
 self.tr("""The Rope configuration file '{0}' does"""
 """ not exist.""").format(configfile))
-def getCompletions(self, editor, context):
+def requestCompletions(self, editor, context, acText):
 """
-Public method to calculate the possible completions.
+Public method to request a list of possible completions.
-Note: This is the synchronous variant for eric6 before 17.11.
 @param editor reference to the editor object, that called this method
-@type QScintilla.Editor.Editor
+@type Editor
-@param context flag indicating to autocomplete a context
-@type bool
-@return list of possible completions
-@rtype list of str
-"""
-if not self.__plugin.getPreferences("CodeAssistEnabled"):
-return []
-# reset the completions buffer
-self.__completions = None
-if not self.__idString(editor):
-return []
-self.requestCompletions(editor, context, "")
-# emulate the synchronous behaviour
-timer = QTimer()
-timer.setSingleShot(True)
-timer.start(5000)           # 5s timeout
-while self.__completions is None and timer.isActive():
-QCoreApplication.processEvents()
-return [] if self.__completions is None else self.__completions
-def requestCompletions(self, editor, context, acText):
-"""
-Public method to request a list of possible completions.
-Note: This is part of the asynchronous variant for eric6 17.11 and
-later.
-@param editor reference to the editor object, that called this method
-@type QScintilla.Editor.Editor
 @param context flag indicating to autocomplete a context
 @type bool
 @param acText text to be completed
 @type str
 """
 name += CodeAssistServer.PictureIDs.get(
 completion['CompletionType'], '')
 names.append(name)
-if self.__asyncCompletions:
+if "Error" not in result:
-# asynchronous variant for eric6 17.11 and later
+editor = self.__vm.getOpenEditor(result["FileName"])
-if "Error" not in result:
+if editor is not None:
-editor = self.__vm.getOpenEditor(result["FileName"])
+editor.completionsListReady(names,
-if editor is not None:
+result["CompletionText"])
-editor.completionsListReady(names,
-result["CompletionText"])
-else:
-# synchronous variant for eric6 before 17.11
-if "Error" in result:
-self.__completions = []
-else:
-self.__completions = result["Completions"]
 def getCallTips(self, editor, pos, commas):
 """
 Public method to calculate calltips.
 @param editor reference to the editor object, that called this method
-@type QScintilla.Editor.Editor
+@type Editor
 @param pos position in the text for the calltip
 @type int
 @param commas minimum number of commas contained in the calltip
 @type int
 @return list of possible calltips
 Public method to request source code documentation for the given
 editor.
 @param editor reference to the editor to get source code documentation
 for
-@type QScintilla.Editor.Editor
+@type Editor
 """
 if self.__documentationViewer is None:
 return
 idString = self.__idString(editor)
 and go to it.
 Note: This is executed upon a mouse click sequence.
 @param editor reference to the calling editor
-@type QScintilla.Editor.Editor
+@type Editor
 """
 if not self.__plugin.getPreferences("MouseClickEnabled"):
 return
 idString = self.__idString(editor)
 location = result["Location"]
 self.__vm.openSourceFile(location["ModulePath"],
 location["Line"],
 addNext=True)
 else:
-e5App().getObject("UserInterface").statusBar().showMessage(
+ericApp().getObject("UserInterface").statusBar().showMessage(
 self.tr('Code Assist: No definition found'), 5000)
 #######################################################################
 ## Methods below handle the network connection
 #######################################################################
 client = os.path.join(os.path.dirname(__file__),
 "CodeAssistClient.py")
 ok, exitCode = self.startClient(
 interpreter, client,
-clientArgs=[configDir, Globals.getPythonModulesDirectory()],
+clientArgs=[configDir, Globals.getPythonLibraryDirectory()],
 idString=idString, environment=clientEnv)
 if not ok:
 if exitCode == 42:
 self.__ui.appendToStderr("CodeAssistServer: " + self.tr(
 "The rope refactoring library is not installed.\n"
 interpreter = ""
 venvName = ""
 clientEnv = os.environ.copy()
 if "PATH" in clientEnv:
 clientEnv["PATH"] = self.__ui.getOriginalPathString()
-venvManager = e5App().getObject("VirtualEnvManager")
+venvManager = ericApp().getObject("VirtualEnvManager")
 if idString == "Python3":
 venvName = Preferences.getDebugger("Python3VirtualEnv")
 if not venvName:
 venvName, _ = venvManager.getDefaultEnvironment()
 if venvName:
 clientEnv = os.environ.copy()
 if "PATH" in clientEnv:
 clientEnv["PATH"] = self.__ui.getOriginalPathString()
 if projectLanguage.startswith("Python"):
-venvManager = e5App().getObject("VirtualEnvManager")
+venvManager = ericApp().getObject("VirtualEnvManager")
 # get virtual environment from project first
 venvName = self.__e5project.getDebugProperty("VIRTUALENV")
 if not venvName:
 # get it from debugger settings next

Mercurial Repositories > Rope Refactoring / file comparison

comparison: RefactoringRope/CodeAssistServer.py

RefactoringRope/CodeAssistServer.py