eric: comparison Cooperation/Connection.py

-:177b1858245f
+:cd4e2cab7eb2
 """
 Class representing a peer connection.
 @signal readyForUse() emitted when the connection is ready for use
 @signal newMessage(user, message) emitted after a new message has
 arrived (string, string)
-@signal getParticipants() emitted after a get participants message has arrived
+@signal getParticipants() emitted after a get participants message has
-@signal participants(participants) emitted after the list of participants has
+arrived
-arrived (list of strings of "host:port")
+@signal participants(participants) emitted after the list of participants
+has arrived (list of strings of "host:port")
 """
 WaitingForGreeting = 0
 ReadingGreeting = 1
 ReadyForUse = 2
 if self.__state == Connection.ReadingGreeting:
 if not self.__hasEnoughData():
 return
-self.__buffer = QByteArray(self.read(self.__numBytesForCurrentDataType))
+self.__buffer = QByteArray(
+self.read(self.__numBytesForCurrentDataType))
 if self.__buffer.size() != self.__numBytesForCurrentDataType:
 self.abort()
 return
 try:
-user, serverPort = str(self.__buffer, encoding="utf-8").split(":")
+user, serverPort = \
+str(self.__buffer, encoding="utf-8").split(":")
 except ValueError:
 self.abort()
 return
 self.__serverPort = int(serverPort)
 user,
 hostInfo.hostName(),
 )
 Preferences.syncPreferences()
 if bannedName in Preferences.getCooperation("BannedUsers"):
-self.rejected.emit(
+self.rejected.emit(self.trUtf8(
-self.trUtf8("* Connection attempted by banned user '{0}'.")\
+"* Connection attempted by banned user '{0}'.")
 .format(bannedName))
 self.abort()
 return
 if self.__serverPort != self.peerPort() and \
 not Preferences.getCooperation("AutoAcceptConnections"):
 return
 if self.__client is not None:
 chatWidget = self.__client.chatWidget()
 if chatWidget is not None and not chatWidget.isVisible():
-e5App().getObject("UserInterface").activateCooperationViewer()
+e5App().getObject(
+"UserInterface").activateCooperationViewer()
 if not self.__isGreetingMessageSent:
 self.__sendGreetingMessage()
 self.__pingTimer.start()
 """
 if self.__pongTime.elapsed() > PongTimeout:
 self.abort()
 return
-self.write("{0}{1}1{1}p".format(Connection.ProtocolPing, SeparatorToken))
+self.write("{0}{1}1{1}p".format(
+Connection.ProtocolPing, SeparatorToken))
 def __sendGreetingMessage(self):
 """
 Private slot to send a greeting message.
 """
 greeting = QByteArray(self.__greetingMessage.encode("utf-8"))
 data = QByteArray("{0}{1}{2}{1}".format(
-Connection.ProtocolGreeting, SeparatorToken, greeting.size())) + greeting
+Connection.ProtocolGreeting, SeparatorToken, greeting.size())) + \
+greeting
 if self.write(data) == data.size():
 self.__isGreetingMessageSent = True
 def __readDataIntoBuffer(self, maxSize=MaxBufferSize):
 """
 self.__currentDataType = Connection.Undefined
 self.abort()
 return False
 self.__buffer.clear()
-self.__numBytesForCurrentDataType = self.__dataLengthForCurrentDataType()
+self.__numBytesForCurrentDataType = \
+self.__dataLengthForCurrentDataType()
 return True
 def __hasEnoughData(self):
 """
 Private method to check, if enough data is available.
 if self.__transferTimerId:
 self.killTimer(self.__transferTimerId)
 self.__transferTimerId = 0
 if self.__numBytesForCurrentDataType <= 0:
-self.__numBytesForCurrentDataType = self.__dataLengthForCurrentDataType()
+self.__numBytesForCurrentDataType = \
+self.__dataLengthForCurrentDataType()
 if self.bytesAvailable() < self.__numBytesForCurrentDataType or \
 self.__numBytesForCurrentDataType <= 0:
 self.__transferTimerId = self.startTimer(TransferTimeout)
 return False
 def __processData(self):
 """
 Private method to process the received data.
 """
-self.__buffer = QByteArray(self.read(self.__numBytesForCurrentDataType))
+self.__buffer = QByteArray(
+self.read(self.__numBytesForCurrentDataType))
 if self.__buffer.size() != self.__numBytesForCurrentDataType:
 self.abort()
 return
 if self.__currentDataType == Connection.PlainText:
-self.newMessage.emit(self.__username, str(self.__buffer, encoding="utf-8"))
+self.newMessage.emit(
+self.__username, str(self.__buffer, encoding="utf-8"))
 elif self.__currentDataType == Connection.Ping:
-self.write("{0}{1}1{1}p".format(Connection.ProtocolPong, SeparatorToken))
+self.write("{0}{1}1{1}p".format(
+Connection.ProtocolPong, SeparatorToken))
 elif self.__currentDataType == Connection.Pong:
 self.__pongTime.restart()
 elif self.__currentDataType == Connection.GetParticipants:
 self.getParticipants.emit()
 elif self.__currentDataType == Connection.Participants:
 participantsList = []
 else:
 participantsList = msg.split(SeparatorToken)
 self.participants.emit(participantsList[:])
 elif self.__currentDataType == Connection.Editor:
-hash, fn, msg = str(self.__buffer, encoding="utf-8").split(SeparatorToken)
+hash, fn, msg = \
+str(self.__buffer, encoding="utf-8").split(SeparatorToken)
 self.editorCommand.emit(hash, fn, msg)
 self.__currentDataType = Connection.Undefined
 self.__numBytesForCurrentDataType = 0
 self.__buffer.clear()
 def sendGetParticipants(self):
 """
 Public method to request a list of participants.
 """
 self.write(
-"{0}{1}1{1}l".format(Connection.ProtocolGetParticipants, SeparatorToken)
+"{0}{1}1{1}l".format(
+Connection.ProtocolGetParticipants, SeparatorToken)
 )
 def sendParticipants(self, participants):
 """
 Public method to send the list of participants.
-@param participants list of participants (list of strings of "host:port")
+@param participants list of participants (list of strings of
+"host:port")
 """
 if participants:
 message = SeparatorToken.join(participants)
 else:
 message = "<empty>"
 """
 Private slot to handle the connection being dropped.
 """
 self.__pingTimer.stop()
 if self.__state == Connection.WaitingForGreeting:
-self.rejected.emit(self.trUtf8("* Connection to {0}:{1} refused.").format(
+self.rejected.emit(self.trUtf8(
+"* Connection to {0}:{1} refused.").format(
 self.peerName(), self.peerPort()))

Mercurial Repositories > eric / file comparison

comparison: Cooperation/Connection.py

Cooperation/Connection.py