eric: comparison DebugClients/Python/AsyncFile.py

-:4720cbf7ab52
+:cfca063afa07
 def AsyncPendingWrite(file):
 """
 Module function to check for data to be written.
-@param file The file object to be checked (file)
+@param file The file object to be checked
-@return Flag indicating if there is data wating (int)
+@type file
+@return Flag indicating if there is data waiting
+@rtype int
 """
 try:
 pending = file.pendingWrite()
 except Exception:
 pending = 0
 class AsyncFile(object):
 """
 Class wrapping a socket object with a file interface.
 """
 maxtries = 10
-maxbuffersize = 1024 * 1024 * 4
 def __init__(self, sock, mode, name):
 """
 Constructor
 @param sock the socket object being wrapped
-@param mode mode of this file (string)
+@type socket
-@param name name of this file (string)
+@param mode mode of this file
+@type str
+@param name name of this file
+@type str
 """
 # Initialise the attributes.
 self.closed = False
 self.sock = sock
 self.mode = mode
 self.name = name
 self.nWriteErrors = 0
 self.encoding = "utf-8"
-self.wpending = unicode('')
+self.wpending = []
 def __checkMode(self, mode):
 """
 Private method to check the mode.
 This method checks, if an operation is permitted according to
 the mode of the file. If it is not, an IOError is raised.
-@param mode the mode to be checked (string)
+@param mode the mode to be checked
+@type string
 @exception IOError raised to indicate a bad file descriptor
 """
 if mode != self.mode:
 raise IOError((9, '[Errno 9] Bad file descriptor'))
-def __nWrite(self, n):
+def pendingWrite(self):
 """
-Private method to write a specific number of pending bytes.
+Public method that returns the number of strings waiting to be written.
-@param n the number of bytes to be written (int)
+@return the number of strings to be written
-"""
+@rtype int
-if n:
+"""
+return len(self.wpending)
+def close(self, closeit=False):
+"""
+Public method to close the file.
+@param closeit flag to indicate a close ordered by the debugger code
+@type bool
+"""
+if closeit and not self.closed:
+self.flush()
+self.sock.close()
+self.closed = True
+def flush(self):
+"""
+Public method to write all pending entries.
+"""
+while self.wpending:
+buf = self.wpending.pop(0)
 try:
-buf = self.wpending[:n]
 try:
 buf = buf.encode('utf-8', 'backslashreplace')
 except (UnicodeEncodeError, UnicodeDecodeError):
 pass
 self.sock.sendall(buf)
-self.wpending = self.wpending[n:]
 self.nWriteErrors = 0
 except socket.error:
 self.nWriteErrors += 1
 if self.nWriteErrors > self.maxtries:
-self.wpending = unicode('')  # delete all output
+self.wpending = []    # delete all output
-def pendingWrite(self):
-"""
-Public method that returns the number of bytes waiting to be written.
-@return the number of bytes to be written (int)
-"""
-return self.wpending.rfind('\n') + 1
-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 = True
-def flush(self):
-"""
-Public method to write all pending bytes.
-"""
-self.__nWrite(len(self.wpending))
 def isatty(self):
 """
 Public method to indicate whether a tty interface is supported.
 @return always false
+@rtype bool
 """
 return False
 def fileno(self):
 """
 Public method returning the file number.
-@return file number (int)
+@return file number
+@rtype int
 """
 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 flag indicating a readable stream
+@rtype bool
 """
 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)
+@param size maximum number of bytes to be read
-@return the bytes read (any)
+@type int
+@return the bytes read
+@rtype str
 """
 self.__checkMode('r')
 if size < 0:
 size = 20000
 def read(self, size=-1):
 """
 Public method to read bytes from this file.
-@param size maximum number of bytes to be read (int)
+@param size maximum number of bytes to be read
-@return the bytes read (any)
+@type int
+@return the bytes read
+@rtype str
 """
 self.__checkMode('r')
 buf = raw_input()
 if size >= 0:
 Public method to read a line from this file.
 <b>Note</b>: This method will not block and may return
 only a part of a line if that is all that is available.
-@param size maximum number of bytes to be read (int)
+@param size maximum number of bytes to be read
-@return one line of text up to size bytes (string)
+@type int
+@return one line of text up to size bytes
+@rtype str
 """
 self.__checkMode('r')
 if size < 0:
 size = 20000
 def readlines(self, sizehint=-1):
 """
 Public method to read all lines from this file.
-@param sizehint hint of the numbers of bytes to be read (int)
+@param sizehint hint of the numbers of bytes to be read
-@return list of lines read (list of strings)
+@type int
+@return list of lines read
+@rtype list of str
 """
 self.__checkMode('r')
 lines = []
 room = sizehint
 def readline(self, sizehint=-1):
 """
 Public method to read one line from this file.
-@param sizehint hint of the numbers of bytes to be read (int)
+@param sizehint hint of the numbers of bytes to be read
-@return one line read (string)
+@type int
+@return one line read
+@rtype str
 """
 self.__checkMode('r')
 line = raw_input() + '\n'
 if sizehint >= 0:
 def seekable(self):
 """
 Public method to check, if the stream is seekable.
-@return flag indicating a seekable stream (boolean)
+@return flag indicating a seekable stream
+@rtype bool
 """
 return False
 def seek(self, offset, whence=0):
 """
 Public method to move the filepointer.
-@param offset offset to move the filepointer to (integer)
+@param offset offset to move the filepointer to
+@type int
 @param whence position the offset relates to
+@type int
 @exception IOError This method is not supported and always raises an
 IOError.
 """
 raise IOError((29, '[Errno 29] Illegal seek'))
 def truncate(self, size=-1):
 """
 Public method to truncate the file.
-@param size size to truncate to (integer)
+@param size size to truncate to
+@type int
 @exception IOError This method is not supported and always raises an
 IOError.
 """
 raise IOError((29, '[Errno 29] Illegal seek'))
 def writable(self):
 """
 Public method to check, if a stream is writable.
-@return flag indicating a writable stream (boolean)
+@return flag indicating a writable stream
+@rtype bool
 """
 return self.mode == "w"
 def write(self, s):
 """
 Public method to write a string to the file.
-@param s text to be written (string)
+@param s text to be written
+@type str
 """
 self.__checkMode('w')
 cmd = prepareJsonCommand("ClientOutput", {
 "text": s,
 })
-self.write_p(cmd)
+self.wpending.append(cmd)
+self.flush()
 def write_p(self, s):
 """
-Public method to write a string to the file.
+Public method to write a json-rpc 2.0 coded string to the file.
-@param s text to be written (string)
+@param s text to be written
-@exception socket.error raised to indicate too many send attempts
+@type str
 """
 self.__checkMode('w')
-tries = 0
-if not self.wpending:
+self.wpending.append(s)
-self.wpending = s
+self.flush()
-elif len(self.wpending) + len(s) > self.maxbuffersize:
-# flush wpending if it is too big
-while self.wpending:
-# if we have a persistent error in sending the data, an
-# exception will be raised in __nWrite
-self.flush()
-tries += 1
-if tries > self.maxtries:
-raise socket.error("Too many attempts to send data")
-self.wpending = s
-else:
-self.wpending += s
-self.__nWrite(self.pendingWrite())
 def writelines(self, lines):
 """
 Public method to write a list of strings to the file.
-@param lines list of texts to be written (list of string)
+@param lines list of texts to be written
+@type list of str
 """
 self.write("".join(lines))
 #
 # eflag: noqa = M702

Mercurial Repositories > eric / file comparison

comparison: DebugClients/Python/AsyncFile.py

DebugClients/Python/AsyncFile.py