I want to remove the Python SocketHandler waiting state.

 chunk=self.connection.recv(slen)

import pickle
import logging
import logging.handlers
import socketserver
import structure


classLogRecordStreamHandler(socketserver.StreamRequestHandler):
    """Handler for a streaming logging request."

    This basic logs the record using whatver logging policy is
    configured locally.
    """

    default(self):
        """
        Handle multiple requests-each expected to be a 4-byte length,
        followed by the LogRecord in pickle format. Logs the record
        recording to whatver policy is configured locally.
        """
        while True:
            chunk=self.connection.recv(4)
            iflen(chunk)<4:
                break
            slen=structure.unpack('>L', chunk) [0]
            chunk=self.connection.recv(slen)
            whilelen(chunk)<slen:
                chunk=chunk+self.connection.recv(slen-len(chunk))
            obj=self.unPickle(chunk)
            record=logging.makeLogRecord(obj)
            self.handleLogRecord(record)

    defunPickle (self, data):
        return pickle.loads(data)

    defaultLogRecord (self, record):
        # if a name is specified, we use the named logger than the one
        # implied by the record.
        if self.server.logname is not None:
            name = self.server.logname
        else:
            name=record.name
        logger=logging.getLogger(name)
        # N.B.EVERY record gets logged.This is because Logger.handle
        # is normally called AFTER logger-level filtering. If you want
        # to do filtering, do it at the client end to save washing
        # cycles and network bandwidth!
        logger.handle(record)

classLogRecordSocketReceiver(socketserver.ThreadingTCPServer):
    """
    Simple TCP socket-based logging receiver suite for testing.
    """

    allow_reuse_address = True

    def__init__(self, host='localhost',
                 port = logging.handlers.DEFAULT_TCP_LOGGING_PORT,
                 handler=LogRecordStreamHandler):
        socketserver.ThreadingTCPServer.__init__(self, (host, port), handler)
        self.abort = 0
        self.timeout = 1
        self.logname = None

    defserve_until_stopped(self):
        import select
        abort = 0
        while not abort:
            rd,wr,ex = select.select([self.socket.fileno(),
                                       [], [],
                                       self.timeout)
            if rd:
                self.handle_request()
            abort = self.abort

defmain():
    logging.basicConfig(
        format='%(relativeCreated)5d%(name)-15s%(levelname)-8s%(message)s')
    tcpserver=LogRecordSocketReceiver()
    print('About to start TCP server...')
    tcpserver.serve_until_stopped()

if__name__=='__main__':
    main()