code: def __read_line(self):
          
          ret = b""
          while True:
              try:
                  pos = self.__read_buffer.index(CRLF)
                  ret = self.__read_buffer[:pos]
                  self.__read_buffer = self.__read_buffer[pos + len(CRLF):]
                  break
              except ValueError:
                  pass
              try:
                  nval = self.sock.recv(self.read_size)
                  self.__dprint(nval)
                  if not len(nval):
                      break
                  self.__read_buffer += nval
              except (socket.timeout, ssl.SSLError):
                  raise Error("Failed to read data from the server")
  
          if len(ret):
              m = self.__size_expr.match(ret)
              if m:
                  raise Literal(int(m.group(1)))
  
              m = self.__respcode_expr.match(ret)
              if m:
                  if m.group(1) == b"BYE":
                      raise Error("Connection closed by server")
                  if m.group(1) == b"NO":
                      self.__parse_error(m.group(2))
                  raise Response(m.group(1), m.group(2))
          return ret
docs: Read one line from the server.
  
          An internal buffer is used to read data from the server
          (blocks of Client.read_size bytes). If the buffer
          is not empty, we try to find an entire line to return.
  
          If we failed, we try to read new content from the server for
          Client.read_timeout seconds. If no data can be
          retrieved, it is considered as a fatal error and an 'Error'
          exception is raised.
  
          :rtype: string
          :return: the read line