eric: comparison Plugins/VcsPlugins/vcsMercurial/HgClient.py

-:9986ec0e559a
+:10516539f238
 pass
 import struct
 import io
-from PyQt4.QtCore import QProcess, QObject, QByteArray, QCoreApplication, QThread
+from PyQt4.QtCore import QProcess, QObject, QByteArray, QCoreApplication, \
+QThread
 from PyQt4.QtGui import QDialog
 from .HgUtilities import prepareProcess
 import Preferences
 if not res:
 self.__server.kill()
 self.__server.waitForFinished(3000)
 self.__started = False
-##            self.__server.finished.disconnect(self.__serverFinished)
 self.__server.deleteLater()
 self.__server = None
 def restartServer(self):
 """
 return False, self.trUtf8("Received data on unexpected channel.")
 msg = msg.split("\n")
 if not msg[0].startswith("capabilities: "):
-return False, self.trUtf8("Bad 'hello' message, expected 'capabilities: '"
+return False, self.trUtf8(
-" but got '{0}'.").format(msg[0])
+"Bad 'hello' message, expected 'capabilities: '"
+" but got '{0}'.").format(msg[0])
 self.__capabilities = msg[0][len('capabilities: '):]
 if not self.__capabilities:
 return False, self.trUtf8("'capabilities' message did not contain"
 " any capability.")
 self.__capabilities = set(self.__capabilities.split())
 if "runcommand" not in self.__capabilities:
 return False, "'capabilities' did not contain 'runcommand'."
 if not msg[1].startswith("encoding: "):
-return False, self.trUtf8("Bad 'hello' message, expected 'encoding: '"
+return False, self.trUtf8(
-" but got '{0}'.").format(msg[1])
+"Bad 'hello' message, expected 'encoding: '"
+" but got '{0}'.").format(msg[1])
 encoding = msg[1][len('encoding: '):]
 if not encoding:
 return False, self.trUtf8("'encoding' message did not contain"
 " any encoding.")
 self.__encoding = encoding
 @param data data to be sent (string)
 """
 if not isinstance(data, bytes):
 data = data.encode(self.__encoding)
-self.__server.write(QByteArray(struct.pack(HgClient.InputFormat, len(data))))
+self.__server.write(
+QByteArray(struct.pack(HgClient.InputFormat, len(data))))
 self.__server.write(QByteArray(data))
 self.__server.waitForBytesWritten()
 def __runcommand(self, args, inputChannels, outputChannels):
 """
 Private method to run a command in the server (low level).
 @param args list of arguments for the command (list of string)
 @param inputChannels dictionary of input channels. The dictionary must
-have the keys 'I' and 'L' and each entry must be a function receiving
+have the keys 'I' and 'L' and each entry must be a function
-the number of bytes to write.
+receiving the number of bytes to write.
-@param outputChannels dictionary of output channels. The dictionary must
+@param outputChannels dictionary of output channels. The dictionary
-have the keys 'o' and 'e' and each entry must be a function receiving
+must have the keys 'o' and 'e' and each entry must be a function
-the data.
+receiving the data.
-@return result code of the command, -1 if the command server wasn't started or
+@return result code of the command, -1 if the command server wasn't
--10, if the command was canceled (integer)
+started or -10, if the command was canceled (integer)
+@exception RuntimeError raised to indicate an unexpected command
+channel
 """
 if not self.__started:
 return -1
 self.__server.write(QByteArray(b'runcommand\n'))
 """
 Private method to prompt the user for some input.
 @param size maximum length of the requested input (integer)
 @param message message sent by the server (string)
+@return data entered by the user (string)
 """
 from .HgClientPromptDialog import HgClientPromptDialog
 input = ""
 dlg = HgClientPromptDialog(size, message)
 if dlg.exec_() == QDialog.Accepted:
 input = dlg.getInput() + '\n'
 return input
-def runcommand(self, args, prompt=None, input=None, output=None, error=None):
+def runcommand(self, args, prompt=None, input=None, output=None,
+error=None):
 """
 Public method to execute a command via the command server.
 @param args list of arguments for the command (list of string)
 @keyparam prompt function to reply to prompts by the server. It
 of the output channel received so far.
 @keyparam input function to reply to bulk data requests by the server.
 It receives the max number of bytes to return.
 @keyparam output function receiving the data from the server (string).
 If a prompt function is given, this parameter will be ignored.
-@keyparam error function receiving error messages from the server (string)
+@keyparam error function receiving error messages from the server
-@return output and errors of the command server (string). In case output
+(string)
-and/or error functions were given, the respective return value will
+@return output and errors of the command server (string). In case
-be an empty string.
+output and/or error functions were given, the respective return
+value will be an empty string.
 """
 self.__commandRunning = True
 outputChannels = {}
 outputBuffer = None
 errorBuffer = None
 self.restartServer()
 def wasCanceled(self):
 """
 Public method to check, if the last command was canceled.
+@return flag indicating the cancel state (boolean)
 """
 return self.__cancel
 def isExecuting(self):
 """
 Public method to check, if the server is executing a command.
 @return flag indicating the execution of a command (boolean)
 """
+return self.__commandRunning

Mercurial Repositories > eric / file comparison

comparison: Plugins/VcsPlugins/vcsMercurial/HgClient.py

Plugins/VcsPlugins/vcsMercurial/HgClient.py