eric: comparison src/eric7/JediInterface/JediClient.py

-:e9e7eca7efee
+:bf71ee032bb4
 import contextlib
 import sys
 SuppressedException = Exception
-modulePath = sys.argv[-1]   # it is always the last parameter
+modulePath = sys.argv[-1]  # it is always the last parameter
 sys.path.insert(1, modulePath)
 try:
 import jedi
 except ImportError:
 class JediClient(EricJsonClient):
 """
 Class implementing the Jedi client of eric7.
 """
 def __init__(self, host, port, idString):
 """
 Constructor
 @param host ip address the background service is listening
 @type str
 @param port port of the background service
 @type int
 @param idString assigned client id to be sent back to the server in
 order to identify the connection
 @type str
 """
 super().__init__(host, port, idString)
 self.__methodMapping = {
 "openProject": self.__openProject,
 "closeProject": self.__closeProject,
 "getCompletions": self.__getCompletions,
 "getCallTips": self.__getCallTips,
 "getDocumentation": self.__getDocumentation,
 "hoverHelp": self.__getHoverHelp,
 "gotoDefinition": self.__getAssignment,
 "gotoReferences": self.__getReferences,
 "renameVariable": self.__renameVariable,
 "extractVariable": self.__extractVariable,
 "inlineVariable": self.__inlineVariable,
 "extractFunction": self.__extractFunction,
 "applyRefactoring": self.__applyRefactoring,
 "cancelRefactoring": self.__cancelRefactoring,
 }
 self.__id = idString
 self.__project = None
 self.__refactorings = {}
 def handleCall(self, method, params):
 """
 Public method to handle a method call from the server.
 @param method requested method name
 @type str
 @param params dictionary with method specific parameters
 @type dict
 """
 self.__methodMapping[method](params)
 def __handleError(self, err):
 """
 Private method to process an error.
 @param err exception object
 @type Exception or Warning
 @return dictionary containing the error information
 @rtype dict
 """
 error = str(type(err)).split()[-1]
-error = error[1:-2].split('.')[-1]
+error = error[1:-2].split(".")[-1]
 errorDict = {
 "Error": error,
 "ErrorString": str(err),
 }
 return errorDict
 def __openProject(self, params):
 """
 Private method to create a jedi project and load its saved data.
 @param params dictionary containing the method parameters
 @type dict
 """
 projectPath = params["ProjectPath"]
 self.__project = jedi.Project(projectPath)
 def __closeProject(self, params):
 """
 Private method to save a jedi project's data.
 @param params dictionary containing the method parameters
 @type dict
 """
 if self.__project is not None:
 self.__project.save()
 def __completionType(self, completion):
 """
 Private method to assemble the completion type depending on the
 visibility indicated by the completion name.
 @param completion reference to the completion object
 @type jedi.api.classes.Completion
 @return modified completion type
 @rtype str
 """
-if completion.name.startswith('__'):
+if completion.name.startswith("__"):
-compType = '__' + completion.type
+compType = "__" + completion.type
-elif completion.name.startswith('_'):
+elif completion.name.startswith("_"):
-compType = '_' + completion.type
+compType = "_" + completion.type
 else:
 compType = completion.type
 return compType
 def __completionFullName(self, completion):
 """
 Private method to extract the full completion name.
 @param completion reference to the completion object
 @type jedi.api.classes.Completion
 @return full completion name
 @rtype str
 """
 fullName = completion.full_name
 fullName = (
 fullName.replace("__main__", completion.module_name)
-if fullName else
+if fullName
-completion.module_name
+else completion.module_name
 )
 return fullName
 def __getCompletions(self, params):
 """
 Private method to calculate possible completions.
 @param params dictionary containing the method parameters
 @type dict
 """
 filename = params["FileName"]
 source = params["Source"]
 line = params["Line"]
 index = params["Index"]
 fuzzy = params["Fuzzy"]
 errorDict = {}
 response = []
 script = jedi.Script(source, path=filename, project=self.__project)
 try:
 completions = script.complete(line, index, fuzzy=fuzzy)
 response = [
 {
-'ModulePath': str(completion.module_path),
+"ModulePath": str(completion.module_path),
-'Name': completion.name,
+"Name": completion.name,
-'FullName': self.__completionFullName(completion),
+"FullName": self.__completionFullName(completion),
-'CompletionType': self.__completionType(completion),
+"CompletionType": self.__completionType(completion),
-} for completion in completions
+}
-if not (completion.name.startswith("__") and
+for completion in completions
-completion.name.endswith("__"))
+if not (
+completion.name.startswith("__") and completion.name.endswith("__")
+)
 ]
 except SuppressedException as err:
 errorDict = self.__handleError(err)
 result = {
 "Completions": response,
 "CompletionText": params["CompletionText"],
 "FileName": filename,
 }
 result.update(errorDict)
 self.sendJson("CompletionsResult", result)
 def __getCallTips(self, params):
 """
 Private method to calculate possible calltips.
 @param params dictionary containing the method parameters
 @type dict
 """
 filename = params["FileName"]
 source = params["Source"]
 line = params["Line"]
 index = params["Index"]
 errorDict = {}
 calltips = []
 script = jedi.Script(source, path=filename, project=self.__project)
 try:
 signatures = script.get_signatures(line, index)
 for signature in signatures:
 name = signature.name
 params = self.__extractParameters(signature)
 calltips.append("{0}{1}".format(name, params))
 except SuppressedException as err:
 errorDict = self.__handleError(err)
 result = {
 "CallTips": calltips,
 }
 result.update(errorDict)
 self.sendJson("CallTipsResult", result)
 def __extractParameters(self, signature):
 """
 Private method to extract the call parameter descriptions.
 @param signature a jedi signature object
 @type object
 @return a string with comma seperated parameter names and default
 values
 @rtype str
 """
 try:
-params = ", ".join([param.description.split('param ', 1)[-1]
+params = ", ".join(
-for param in signature.params])
+[param.description.split("param ", 1)[-1] for param in signature.params]
+)
 return "({0})".format(params)
 except AttributeError:
 # Empty strings as argspec suppress display of "definition"
-return ' '
+return " "
 def __getDocumentation(self, params):
 """
 Private method to get some source code documentation.
 @param params dictionary containing the method parameters
 @type dict
 """
 filename = params["FileName"]
 source = params["Source"]
 line = params["Line"]
 index = params["Index"]
 errorDict = {}
 docu = {}
 script = jedi.Script(source, path=filename, project=self.__project)
 try:
 definitions = script.infer(line, index)
-definition = definitions[0]     # use the first one only
+definition = definitions[0]  # use the first one only
 docu = {
 "name": definition.full_name,
 "module": definition.module_name,
 "argspec": self.__extractParameters(definition),
 "docstring": definition.docstring(),
 }
 except SuppressedException as err:
 errorDict = self.__handleError(err)
 result = {
 "DocumentationDict": docu,
 }
 result.update(errorDict)
 self.sendJson("DocumentationResult", result)
 def __getHoverHelp(self, params):
 """
 Private method to get some source code documentation.
 @param params dictionary containing the method parameters
 @type dict
 """
 filename = params["FileName"]
 source = params["Source"]
 line = params["Line"]
 index = params["Index"]
 uid = params["Uuid"]
 script = jedi.Script(source, path=filename, project=self.__project)
 errorDict = {}
 helpText = ""
 try:
 helpText = script.help(line, index)[0].docstring()
 except SuppressedException as err:
 errorDict = self.__handleError(err)
 result = {
 "Line": line,
 "Index": index,
 "HoverHelp": helpText,
 "Uuid": uid,
 }
 result.update(errorDict)
 self.sendJson("HoverHelpResult", result)
 def __getAssignment(self, params):
 """
 Private method to get the place a parameter is defined.
 @param params dictionary containing the method parameters
 @type dict
 """
 filename = params["FileName"]
 source = params["Source"]
 line = params["Line"]
 index = params["Index"]
 uid = params["Uuid"]
 errorDict = {}
 gotoDefinition = {}
 script = jedi.Script(source, path=filename, project=self.__project)
 try:
 assignments = script.goto(
-line, index, follow_imports=True, follow_builtin_imports=True)
+line, index, follow_imports=True, follow_builtin_imports=True
+)
 for assignment in assignments:
 if bool(assignment.module_path):
 gotoDefinition = {
-'ModulePath': str(assignment.module_path),
+"ModulePath": str(assignment.module_path),
-'Line': (0 if assignment.line is None else
+"Line": (0 if assignment.line is None else assignment.line),
-assignment.line),
+"Column": assignment.column,
-'Column': assignment.column,
 }
 if (
-gotoDefinition["ModulePath"] == filename and
+gotoDefinition["ModulePath"] == filename
-gotoDefinition["Line"] == line
+and gotoDefinition["Line"] == line
 ):
 # user called for the definition itself
 # => send the references instead
 self.__getReferences(params)
 return
 break
 except SuppressedException as err:
 errorDict = self.__handleError(err)
 result = {
 "GotoDefinitionDict": gotoDefinition,
 "Uuid": uid,
 }
 result.update(errorDict)
 self.sendJson("GotoDefinitionResult", result)
 def __getReferences(self, params):
 """
 Private method to get the places a parameter is referenced.
 @param params dictionary containing the method parameters
 @type dict
 """
 filename = params["FileName"]
 source = params["Source"]
 line = params["Line"]
 index = params["Index"]
 uid = params["Uuid"]
 errorDict = {}
 gotoReferences = []
 script = jedi.Script(source, path=filename, project=self.__project)
 try:
-references = script.get_references(line, index,
+references = script.get_references(line, index, include_builtins=False)
-include_builtins=False)
 for reference in references:
 if bool(reference.module_path):
 if (
-reference.line == line and
+reference.line == line
-str(reference.module_path) == filename
+and str(reference.module_path) == filename
 ):
 continue
-gotoReferences.append({
+gotoReferences.append(
-'ModulePath': str(reference.module_path),
+{
-'Line': (0 if reference.line is None else
+"ModulePath": str(reference.module_path),
-reference.line),
+"Line": (0 if reference.line is None else reference.line),
-'Column': reference.column,
+"Column": reference.column,
-'Code': reference.get_line_code(),
+"Code": reference.get_line_code(),
-})
+}
-except SuppressedException as err:
+)
-errorDict = self.__handleError(err)
+except SuppressedException as err:
+errorDict = self.__handleError(err)
 result = {
 "GotoReferencesList": gotoReferences,
 "Uuid": uid,
 }
 result.update(errorDict)
 self.sendJson("GotoReferencesResult", result)
 def __renameVariable(self, params):
 """
 Private method to rename the variable under the cursor.
 @param params dictionary containing the method parameters
 @type dict
 """
 filename = params["FileName"]
 source = params["Source"]
 line = params["Line"]
 index = params["Index"]
 uid = params["Uuid"]
 newName = params["NewName"]
 errorDict = {}
 diff = ""
 script = jedi.Script(source, path=filename, project=self.__project)
 try:
 refactoring = script.rename(line, index, new_name=newName)
 self.__refactorings[uid] = refactoring
 diff = refactoring.get_diff()
 except SuppressedException as err:
 errorDict = self.__handleError(err)
 result = {
 "Diff": diff,
 "Uuid": uid,
 }
 result.update(errorDict)
 self.sendJson("RefactoringDiff", result)
 def __extractVariable(self, params):
 """
 Private method to extract a statement to a new variable.
 @param params dictionary containing the method parameters
 @type dict
 """
 filename = params["FileName"]
 source = params["Source"]
 index = params["Index"]
 endLine = params["EndLine"]
 endIndex = params["EndIndex"]
 uid = params["Uuid"]
 newName = params["NewName"]
 errorDict = {}
 diff = ""
 script = jedi.Script(source, path=filename, project=self.__project)
 try:
 refactoring = script.extract_variable(
-line, index, new_name=newName,
+line, index, new_name=newName, until_line=endLine, until_column=endIndex
-until_line=endLine, until_column=endIndex
 )
 self.__refactorings[uid] = refactoring
 diff = refactoring.get_diff()
 except SuppressedException as err:
 errorDict = self.__handleError(err)
 result = {
 "Diff": diff,
 "Uuid": uid,
 }
 result.update(errorDict)
 self.sendJson("RefactoringDiff", result)
 def __inlineVariable(self, params):
 """
 Private method to inline a variable statement.
 @param params dictionary containing the method parameters
 @type dict
 """
 filename = params["FileName"]
 source = params["Source"]
 line = params["Line"]
 index = params["Index"]
 uid = params["Uuid"]
 errorDict = {}
 diff = ""
 script = jedi.Script(source, path=filename, project=self.__project)
 try:
 refactoring = script.inline(line, index)
 self.__refactorings[uid] = refactoring
 diff = refactoring.get_diff()
 except SuppressedException as err:
 errorDict = self.__handleError(err)
 result = {
 "Diff": diff,
 "Uuid": uid,
 }
 result.update(errorDict)
 self.sendJson("RefactoringDiff", result)
 def __extractFunction(self, params):
 """
 Private method to extract an expression to a new function.
 @param params dictionary containing the method parameters
 @type dict
 """
 filename = params["FileName"]
 source = params["Source"]
 index = params["Index"]
 endLine = params["EndLine"]
 endIndex = params["EndIndex"]
 uid = params["Uuid"]
 newName = params["NewName"]
 errorDict = {}
 diff = ""
 script = jedi.Script(source, path=filename, project=self.__project)
 try:
 refactoring = script.extract_function(
-line, index, new_name=newName,
+line, index, new_name=newName, until_line=endLine, until_column=endIndex
-until_line=endLine, until_column=endIndex
 )
 self.__refactorings[uid] = refactoring
 diff = refactoring.get_diff()
 except SuppressedException as err:
 errorDict = self.__handleError(err)
 result = {
 "Diff": diff,
 "Uuid": uid,
 }
 result.update(errorDict)
 self.sendJson("RefactoringDiff", result)
 def __applyRefactoring(self, params):
 """
 Private method to apply a refactoring.
 @param params dictionary containing the method parameters
 @type dict
 """
 uid = params["Uuid"]
 errorDict = {}
 try:
 refactoring = self.__refactorings[uid]
 refactoring.apply()
 ok = True
 except KeyError:
 ok = False
 except SuppressedException as err:
 errorDict = self.__handleError(err)
 result = {
 "result": ok,
 }
 result.update(errorDict)
 self.sendJson("RefactoringApplyResult", result)
 with contextlib.suppress(KeyError):
 del self.__refactorings[uid]
 def __cancelRefactoring(self, params):
 """
 Private method to cancel a refactoring.
 @param params dictionary containing the method parameters
 @type dict
 """
 uid = params["Uuid"]
 with contextlib.suppress(KeyError):
 del self.__refactorings[uid]
-if __name__ == '__main__':
+if __name__ == "__main__":
 if len(sys.argv) != 5:
-print('Host, port, id and module path parameters are missing.'
+print("Host, port, id and module path parameters are missing." " Abort.")
-' Abort.')
 sys.exit(1)
 host, port, idString = sys.argv[1:-1]
 client = JediClient(host, int(port), idString)
 # Start the main loop
 client.run()
 sys.exit(0)
 #
 # eflag: noqa = M801

Mercurial Repositories > eric / file comparison

comparison: src/eric7/JediInterface/JediClient.py

src/eric7/JediInterface/JediClient.py