eric: comparison DebugClients/Python/AsyncFile.py

-:889ed5ff7a68
+:a094eee9f862
 debugger.
 """
 import socket
-from DebugProtocol import EOT
+from DebugUtilities import prepareJsonCommand
 def AsyncPendingWrite(file):
 """
 Module function to check for data to be written.
 @param sock the socket object being wrapped
 @param mode mode of this file (string)
 @param name name of this file (string)
 """
 # Initialise the attributes.
-self.closed = 0
+self.closed = False
 self.sock = sock
 self.mode = mode
 self.name = name
 self.nWriteErrors = 0
 self.encoding = "utf-8"
 @param n the number of bytes to be written (int)
 """
 if n:
 try:
-buf = "%s%s" % (self.wpending[:n], EOT)
+buf = self.wpending[:n]
 try:
-buf = buf.encode('utf-8')
+buf = buf.encode('utf-8', 'backslashreplace')
 except (UnicodeEncodeError, UnicodeDecodeError):
 pass
 self.sock.sendall(buf)
 self.wpending = self.wpending[n:]
 self.nWriteErrors = 0
 @return the number of bytes to be written (int)
 """
 return self.wpending.rfind('\n') + 1
-def close(self, closeit=0):
+def close(self, closeit=False):
 """
 Public method to close the file.
 @param closeit flag to indicate a close ordered by the debugger code
 (boolean)
 """
 if closeit and not self.closed:
 self.flush()
 self.sock.close()
-self.closed = 1
+self.closed = True
 def flush(self):
 """
 Public method to write all pending bytes.
 """
 """
 Public method to indicate whether a tty interface is supported.
 @return always false
 """
-return 0
+return False
 def fileno(self):
 """
 Public method returning the file number.
 try:
 return self.sock.fileno()
 except socket.error:
 return -1
+def readable(self):
+"""
+Public method to check, if the stream is readable.
+@return flag indicating a readable stream (boolean)
+"""
+return self.mode == "r"
 def read_p(self, size=-1):
 """
 Public method to read bytes from this file.
 @param size maximum number of bytes to be read (int)
 self.__checkMode('r')
 if size < 0:
 size = 20000
-return self.sock.recv(size).decode('utf8')
+return self.sock.recv(size).decode('utf8', 'backslashreplace')
 def read(self, size=-1):
 """
 Public method to read bytes from this file.
 # to the debugger relies on the two lines of the debugger command being
 # delivered as two separate events.  Therefore we make sure we only
 # read a line at a time.
 line = self.sock.recv(size, socket.MSG_PEEK)
-eol = line.find('\n')
+eol = line.find(b'\n')
 if eol >= 0:
 size = eol + 1
 else:
 size = len(line)
 # Now we know how big the line is, read it for real.
-return self.sock.recv(size).decode('utf8')
+return self.sock.recv(size).decode('utf8', 'backslashreplace')
 def readlines(self, sizehint=-1):
 """
 Public method to read all lines from this file.
 line = raw_input() + '\n'
 if sizehint >= 0:
 line = line[:sizehint]
 return line
+def seekable(self):
+"""
+Public method to check, if the stream is seekable.
+@return flag indicating a seekable stream (boolean)
+"""
+return False
 def seek(self, offset, whence=0):
 """
 Public method to move the filepointer.
 @param offset offset to seek for
 @exception IOError This method is not supported and always raises an
 IOError.
 """
 raise IOError('[Errno 29] Illegal seek')
+def writable(self):
+"""
+Public method to check, if a stream is writable.
+@return flag indicating a writable stream (boolean)
+"""
+return self.mode == "w"
 def write(self, s):
 """
 Public method to write a string to the file.
 @param s bytes to be written (string)
+"""
+self.__checkMode('w')
+cmd = prepareJsonCommand("ClientOutput", {
+"text": s,
+})
+self.write_p(cmd)
+def write_p(self, s):
+"""
+Public method to write a string to the file.
+@param s text to be written (string)
 @exception socket.error raised to indicate too many send attempts
 """
 self.__checkMode('w')
 tries = 0
 if not self.wpending:
 self.wpending = s
-elif type(self.wpending) != type(s) or \
+elif len(self.wpending) + len(s) > self.maxbuffersize:
-len(self.wpending) + len(s) > self.maxbuffersize:
+# flush wpending if it is too big
-# flush wpending so that different string types are not
-# concatenated
 while self.wpending:
 # if we have a persistent error in sending the data, an
 # exception will be raised in __nWrite
 self.flush()
 tries += 1
 self.wpending = s
 else:
 self.wpending += s
 self.__nWrite(self.pendingWrite())
-def writelines(self, list):
+def writelines(self, lines):
 """
 Public method to write a list of strings to the file.
-@param list the list to be written (list of string)
+@param lines list of texts to be written (list of string)
 """
-map(self.write, list)
+self.write("".join(lines))
 #
 # eflag: FileType = Python2
 # eflag: noqa = M601, M702

Mercurial Repositories > eric / file comparison

comparison: DebugClients/Python/AsyncFile.py

DebugClients/Python/AsyncFile.py