Python EventEmitter.emit方法代码示例

# 需要导入模块: from pyee import EventEmitter [as 别名]
# 或者: from pyee.EventEmitter import emit [as 别名]
class PendingPacket():

    def __init__(self, packet, packet_sender):
        print 'Init PendingPacket'

        self.ee = EventEmitter()

        self._packet_sender = packet_sender
        self._packet = packet

    def send(self):
        def packet_send():
            self._packetSender.send(self._packet)

        self._intervalID = helpers.set_interval(
            packet_send,
            constants.TIMEOUT
        )
        self._packet_sender.send(self._packet)

    def get_sequence_number(self):
        return self._packet.get_sequence_number()

    def acknowledge(self):
        self._intervalID.cancel()
        self.ee.emit('acknowledge')

# 需要导入模块: from pyee import EventEmitter [as 别名]
# 或者: from pyee.EventEmitter import emit [as 别名]
class InterceptEmitter(object):
    """
    This class intercepts and allows emitting events between the
    skill_tester and the skill being tested.
    When a test is running emitted communication is intercepted for analysis
    """

    def __init__(self):
        self.emitter = EventEmitter()
        self.q = None

    def on(self, event, f):
        # run all events
        print("Event: ", event)
        self.emitter.on(event, f)

    def emit(self, event, *args, **kwargs):
        event_name = event.type
        if self.q:
            self.q.put(event)
        self.emitter.emit(event_name, event, *args, **kwargs)

    def once(self, event, f):
        self.emitter.once(event, f)

    def remove(self, event_name, func):
        pass

    def remove_all_listeners(self, event_name):
        pass

# 需要导入模块: from pyee import EventEmitter [as 别名]
# 或者: from pyee.EventEmitter import emit [as 别名]
class Runner(object):
    def __init__(self, client, make_request):
        self.client = client
        self.make_request = make_request
        self._pending = []
        self.events = EventEmitter()

    def _on_request_finished(self, _):
        """
        Start the next waiting request if possible.

        """
        if len(self.client.active) < self.client.max_clients:
            self._start_request()

    def _start_request(self):
        """
        Start a request and add callbacks to its future.

        Most notably, the completion of the requests's future will also trigger
        the completion of a future we had prepared earlier.

        """
        request = self.make_request(streaming_callback=lambda c: None)
        future = concurrent.Future()

        self.events.emit("request_ready", future, request)
        self.client.fetch(request, callback=future.set_result)
        self.events.emit("request_started", future)

        self._pending.append(future)
        future.add_done_callback(lambda f: self.events.emit("request_finished", f))
        future.add_done_callback(self._pending.remove)
        future.add_done_callback(self._on_request_finished)

# 需要导入模块: from pyee import EventEmitter [as 别名]
# 或者: from pyee.EventEmitter import emit [as 别名]
def test_asyncio_error():
    """Test that event_emitters can handle errors when wrapping coroutines as
    used with asyncio.
    """
    loop = new_event_loop()
    ee = EventEmitter(loop=loop)

    should_call = Future(loop=loop)

    @ee.on('event')
    async def event_handler():
        raise PyeeTestError()

    @ee.on('error')
    def handle_error(exc):
        should_call.set_result(exc)

    async def create_timeout(loop=loop):
        await sleep(0.1, loop=loop)
        if not should_call.done():
            raise Exception('should_call timed out!')
            return should_call.cancel()

    timeout = create_timeout(loop=loop)

    @should_call.add_done_callback
    def _done(result):
        assert isinstance(result, PyeeTestError)

    ee.emit('event')

    loop.run_until_complete(gather(should_call, timeout, loop=loop))

    loop.close()

# 需要导入模块: from pyee import EventEmitter [as 别名]
# 或者: from pyee.EventEmitter import emit [as 别名]
class RegistrationOnlyEmitter(object):
    def __init__(self):
        self.emitter = EventEmitter()

    def on(self, event, f):
        allow_events_to_execute = True

        if allow_events_to_execute:
            # don't filter events, just run them all
            print "Event: "+str(event)
            self.emitter.on(event, f)
        else:
            # filter to just the registration events,
            # preventing them from actually executing
            if event in [
                'register_intent',
                'register_vocab',
                'recognizer_loop:utterance'
            ]:
                print "Event: " + str(event)
                self.emitter.on(event, f)

    def emit(self, event, *args, **kwargs):
        event_name = event.type
        self.emitter.emit(event_name, event, *args, **kwargs)

    def once(self, event, f):
        self.emitter.once(event, f)

    def remove(self, event_name, func):
        pass

# 需要导入模块: from pyee import EventEmitter [as 别名]
# 或者: from pyee.EventEmitter import emit [as 别名]
class IncomingMessage(object):
    def __init__(self, im_id, size):
        self.log = logging.getLogger(
            '%s' % self.__class__.__name__
        )

        self.log.debug('New IncomingMessage Created')

        self.im_id = im_id
        self.size = size

        self.ee = EventEmitter()

        self.synced = False
        self._next_sequence_number = 0
        self._sync_sequence_number = None
        self._packets = SortedList()

        self.body = ''
        self.waiting = False

    def add_to_body(self, payload):
        if payload in self.body:
            self.log.debug('This content is already in the body.')
            return
        else:
            self.body += payload


    def reset(self):
        self.log.debug('IncomingMessage Reset')
        self.log.debug('Self Packets: %s', self._packets)

        self._packets.clear()
        self.synced = False
        self._next_sequence_number = 0
        self._sync_sequence_number = None

        try:
            self.log.debug('Downloaded (%s) | Total Size (%s)', len(self.body), self.size)

            if len(self.body) >= int(self.size):
                self.log.debug('Download Complete')
                if len(self.body) > int(self.size):
                    self.log.debug('Oversized Message')
                self.ee.emit('complete', {'body': self.body})
                return
            else:
                # print self._message, self._message_size
                self.log.debug('Still downloading...')
                self.waiting = True

        except Exception as e:
            self.log.debug('Problem with resetting IncomingMessage: %s', e)

# 需要导入模块: from pyee import EventEmitter [as 别名]
# 或者: from pyee.EventEmitter import emit [as 别名]
def test_emit_return():
    ee = EventEmitter()
    
    # make sure emission without callback retruns False
    nt.assert_false(ee.emit('data'))

    # add a callback
    ee.on('data')(lambda: None)

    # should return true now
    nt.assert_true(ee.emit('data'))

# 需要导入模块: from pyee import EventEmitter [as 别名]
# 或者: from pyee.EventEmitter import emit [as 别名]
class RegistrationOnlyEmitter(object):
    def __init__(self):
        self.emitter = EventEmitter()

    def on(self, event, f):
        if event in ['register_intent', 'register_vocab', 'recognizer_loop:utterance']:
            self.emitter.on(event, f)

    def emit(self, event, *args, **kwargs):
        event_name = event.message_type
        self.emitter.emit(event_name, event, *args, **kwargs)

# 需要导入模块: from pyee import EventEmitter [as 别名]
# 或者: from pyee.EventEmitter import emit [as 别名]
def test_emit_error():
    ee = EventEmitter()
    
    with nt.assert_raises(Exception):
        ee.emit('error')

    @ee.on('error')
    def onError():
        pass
        
    # No longer raises and error instead return True indicating handled
    nt.assert_true(ee.emit('error'))

# 需要导入模块: from pyee import EventEmitter [as 别名]
# 或者: from pyee.EventEmitter import emit [as 别名]
def test_shorter_pattern():
    """Tests correct behaviour with shorter patterns"""

    ee = EventEmitter()

    @ee.on('#')
    def event_handler(ev):
        raise ItWorkedException

    with nt.assert_raises(ItWorkedException) as it_worked:
        ee.emit('a/b/c')

    with nt.assert_raises(ItWorkedException) as it_worked:
        ee.emit('cool')

# 需要导入模块: from pyee import EventEmitter [as 别名]
# 或者: from pyee.EventEmitter import emit [as 别名]
def test_twisted_emit():
    """Test that event_emitters can handle wrapping coroutines when using
    twisted and ensureDeferred.
    """
    ee = EventEmitter(scheduler=ensureDeferred)

    should_call = Mock()

    @ee.on('event')
    async def event_handler():
        should_call(True)

    ee.emit('event')

    should_call.assert_called_once()

# 需要导入模块: from pyee import EventEmitter [as 别名]
# 或者: from pyee.EventEmitter import emit [as 别名]
def test_longer_pattern():
    """Tests correct behaviour with longer patterns"""

    ee = EventEmitter()

    @ee.on('a/b/#')
    def event_handler(ev):
        raise ItWorkedException

    ee.emit('c')

    @ee.on('+/a/b')
    def event_handler(ev):
        raise ItWorkedException('c and #/a/b')

    ee.emit('c')

# 需要导入模块: from pyee import EventEmitter [as 别名]
# 或者: from pyee.EventEmitter import emit [as 别名]
class PendingPacket(object):

    def __init__(self, packet, packet_sender):
        self.loop = ioloop.IOLoop.current()
        self.event_emitter = EventEmitter()

        self._packet_sender = packet_sender
        self._packet = packet
        self._interval_id = None
        self._sending = False
        self._sending_count = 0

        self.log = logging.getLogger(
            '%s' % self.__class__.__name__
        )

        self.log.info('Init PendingPacket')

    def send(self):

        self._sending = True

        self.log.debug('Sending Packet #%s: %s', self._packet.get_sequence_number(), self._sending)
        self._packet_sender.send(self._packet)

        # self._interval_id = rudp.helpers.set_interval(
        #     packet_send,
        #     rudp.constants.TIMEOUT
        # )

        # self.log.debug('Packet %s sent %d times', self._packet.get_sequence_number(), self._sending_count)

    def get_sequence_number(self):
        return self._packet.get_sequence_number()

    def acknowledge(self):
        self.log.debug('Pending Packet Acknowledged: %s', self._packet.get_sequence_number())
        self._sending = None

        if self._interval_id:
            self._interval_id.cancel()
            self._interval_id = None

        self.event_emitter.emit('acknowledge')

# 需要导入模块: from pyee import EventEmitter [as 别名]
# 或者: from pyee.EventEmitter import emit [as 别名]
class Tracker(object):
    def __init__(self, runner=None):
        self.events = EventEmitter()
        self.started = None
        self.finished = None
        self.requests = 0
        self._pending = {}
        self._records = []

        if runner:
            self._attach_to(runner)

    def _attach_to(self, runner):
        runner.events.on("tests_started", self.tests_started)
        runner.events.on("tests_finished", self.tests_finished)
        runner.events.on("request_ready", self.request_ready)
        runner.events.on("request_started", self.request_started)
        runner.events.on("request_finished", self.request_finished)

    def get_records(self):
        return self._records

    def tests_started(self):
        self.started = time.time()

    def tests_finished(self):
        self.finished = time.time()
        self.events.emit("tests_finished", self)

    def request_ready(self, future, request):
        record = Record()
        request.streaming_callback = record.on_received
        self._pending[future] = record
        self._records.append(record)

    def request_started(self, future):
        self._pending[future].start()

    def request_finished(self, future):
        record = self._pending.pop(future)
        record.complete(future)
        self.events.emit("request_finished", record)

# 需要导入模块: from pyee import EventEmitter [as 别名]
# 或者: from pyee.EventEmitter import emit [as 别名]
class AckTimeoutRegister:

    def __init__(self, client, topic, timeout_duration):
        self._client = client
        self._topic = topic
        self._timeout_duration = timeout_duration
        self._register = {}
        self._emitter = EventEmitter()

    def add(self, name, action):
        """
        Adds an action to the registry with a timeout. If the timeout happens
        the register emits an error.

        :param name: Name of the occurrence to add to the registry
        :param action: Type of action it is (event etc)
        """
        '''
        unique_name = action + "-" + name if action is not None else name
        '''
        unique_name = name
        if unique_name in self._register:
            self.clear({"data": [unique_name]})
        self._register[unique_name] = Timer(self._timeout_duration, self._on_timeout, args=(unique_name,))
        self._register[unique_name].start()

    def clear(self, event_data):
        name = event_data['data'][1]
        timeout = self._register[name]
        if timeout is not None:
            timeout.cancel()
        else:
            self._client._on_error(self._topic, C.EVENT_UNSOLICITED_MESSAGE, event_data)

    def _on_timeout(self, event_name):
        self._register.pop(event_name)
        msg = 'No ACK message received in time for ' + event_name
        self._client._on_error(self._topic, C.EVENT_ACK_TIMEOUT, msg)
        self._emitter.emit('timeout', event_name)