# Events

SimPy includes an extensive set of event types for various purposes. All of them inherit `simpy.events.Event`. The listing below shows the hierarchy of events built into SimPy:

    events.Event
    |
    +— events.Timeout
    |
    +— events.Initialize
    |
    +— events.Process
    |
    +— events.Condition
    |  |
    |  +— events.AllOf
    |  |
    |  +— events.AnyOf
    .
    .
    .

This is the set of basic events. Events are extensible and resources, for example, define additional events. In this guide, we’ll focus on the events in the `simpy.events` module. The guide to resources describes the various resource events.

## Event basics

SimPy events are very similar – if not identical — to deferreds, futures or promises. Instances of the class `Event` are used to describe any kind of events. Events can be in one of the following states. An event

- might happen (not triggered),

- is going to happen (triggered) or

- has happened (processed).

They traverse these states exactly once in that order. Events are also tightly bound to time and time causes events to advance their state.

Initially, events are not triggered and just objects in memory.

If an event gets triggered, it is scheduled at a given time and inserted into SimPy’s event queue. The property `Event.triggered` becomes `True`.

As long as the event is not processed, you can add callbacks to an event. Callbacks are callables that accept an event as parameter and are stored in the `Event.callbacks` list.

An event becomes processed when SimPy pops it from the event queue and calls all of its callbacks. It is now no longer possible to add callbacks. The property `Event.processed` becomes `True`.

Events also have a value. The value can be set before or when the event is triggered and can be retrieved via `Event.value` or, within a process, by yielding the event (`value = yield event`).

### Adding callbacks to an event

“What? Callbacks? I’ve never seen no callbacks!”, you might think if you have worked your way through the tutorial.

That’s on purpose. The most common way to add a callback to an event is yielding it from your process function (`yield event`). This will add the process’ _resume() method as a callback. That’s how your process gets resumed when it yielded an event.

However, you can add any callable object (function) to the list of callbacks as long as it accepts an event instance as its single parameter:

    >>> import simpy
    >>>
    >>> def my_callback(event):
    ...     print('Called back from', event)
    ...
    >>> env = simpy.Environment()
    >>> event = env.event()
    >>> event.callbacks.append(my_callback)
    >>> event.callbacks
    [<function my_callback at 0x...>]

If an event has been processed, all of its `Event.callbacks` have been executed and the attribute is set to `None`. This is to prevent you from adding more callbacks – these would of course never get called because the event has already happened.

Processes are smart about this, though. If you yield a processed event, _resume() will immediately resume your process with the value of the event (because there is nothing to wait for).

### Triggering events

When events are triggered, they can either succeed or fail. For example, if an event is to be triggered at the end of a computation and everything works out fine, the event will succeed. If an exception occurs during that computation, the event will fail.

To trigger an event and mark it as successful, you can use `Event.succeed(value=None)`. You can optionally pass a value to it (e.g., the results of a computation).

To trigger an event and mark it as failed, call `Event.fail(exception)` and pass an `Exception` instance to it (e.g., the exception you caught during your failed computation).

There is also a generic way to trigger an event: `Event.trigger(event)`. This will take the value and outcome (success or failure) of the event passed to it.

`Event.succeed()` and `Event.fail()` methods return the event instance they are bound to. This allows you to do things like `yield Event(env).succeed()`.

`Event.trigger()` returns None.

## Example usages for `Event`

The simple mechanics outlined above provide a great flexibility in the way events (even the basic `Event`) can be used.

One example for this is that events can be shared. They can be created by a process or outside of the context of a process. They can be passed to other processes and chained:

    >>> class School:
    ...     def __init__(self, env):
    ...         self.env = env
    ...         self.class_ends = env.event()
    ...         self.pupil_procs = [env.process(self.pupil()) for i in range(3)]
    ...         self.bell_proc = env.process(self.bell())
    ...
    ...     def bell(self):
    ...         for i in range(2):
    ...             yield self.env.timeout(45)
    ...             self.class_ends.succeed()
    ...             self.class_ends = self.env.event()
    ...             print()
    ...
    ...     def pupil(self):
    ...         for i in range(2):
    ...             print(r' \o/', end='')
    ...             yield self.class_ends
    ...
    >>> school = School(env)
    >>> env.run()
     \o/ \o/ \o/
     \o/ \o/ \o/

This can also be used like the passivate / reactivate known from SimPy 2. The pupils passivate when class begins and are reactivated when the bell rings.

## Let time pass by: the `Timeout`

To actually let time pass in a simulation, there is the timeout event. A timeout has two parameters: a delay and an optional value: `Timeout(delay, value=None)`. It triggers itself during its creation and schedules itself at `now + delay`. Thus, the `succeed()` and `fail()` methods cannot be called again and you have to pass the event value to it when you create the timeout.

The delay can be any kind of number, usually an int or float as long as it supports comparison and addition.

## Processes are events, too

SimPy processes (as created by `Process` or `env.process()`) have the nice property of being events, too.

That means, that a process can yield another process. It will then be resumed when the other process ends. The event’s value will be the return value of that process:

    >>> def sub(env):
    ...     yield env.timeout(1)
    ...     return 23
    ...
    >>> def parent(env):
    ...     ret = yield env.process(sub(env))
    ...     return ret
    ...
    >>> env.run(env.process(parent(env)))
    23

When a process is created, it schedules an `Initialize` event which will start the execution of the process when triggered. You usually won’t have to deal with this type of event.

If you don’t want a process to start immediately but after a certain delay, you can use `simpy.util.start_delayed()`. This method returns a helper process that uses a timeout before actually starting a process.

The example from above, but with a delayed start of `sub()`:

    >>> from simpy.util import start_delayed
    >>>
    >>> def sub(env):
    ...     yield env.timeout(1)
    ...     return 23
    ...
    >>> def parent(env):
    ...     sub_proc = yield start_delayed(env, sub(env), delay=3)
    ...     ret = yield sub_proc
    ...     return ret
    ...
    >>> env.run(env.process(parent(env)))
    23

Pay attention to the additional `yield` needed for the helper process.

## Waiting for multiple events at once

Sometimes, you want to wait for more than one event at the same time. For example, you may want to wait for a resource, but not for an unlimited amount of time. Or you may want to wait until a set of events has happened.

SimPy therefore offers the `AnyOf` and `AllOf` events which both are a `Condition` event.

Both take a list of events as an argument and are triggered when any (at least one) or all of them are triggered.

    >>> from simpy.events import AnyOf, AllOf, Event
    >>> events = [Event(env) for i in range(3)]
    >>> a = AnyOf(env, events)  # Triggers if at least one of "events" is triggered.
    >>> b = AllOf(env, events)  # Triggers if all each of "events" is triggered.

The value of a condition event is an ordered dictionary with an entry for every triggered event. In the case of `AllOf`, the size of that dictionary will always be the same as the length of the event list. The value dict of `AnyOf` will have at least one entry. In both cases, the event instances are used as keys and the event values will be the values.

As a shorthand for `AllOf` and `AnyOf`, you can also use the logical operators `&` (and) and `|` (or):

    >>> def test_condition(env):
    ...     t1, t2 = env.timeout(1, value='spam'), env.timeout(2, value='eggs')
    ...     ret = yield t1 | t2
    ...     assert ret == {t1: 'spam'}
    ...
    ...     t1, t2 = env.timeout(1, value='spam'), env.timeout(2, value='eggs')
    ...     ret = yield t1 & t2
    ...     assert ret == {t1: 'spam', t2: 'eggs'}
    ...
    ...     # You can also concatenate & and |
    ...     e1, e2, e3 = [env.timeout(i) for i in range(3)]
    ...     yield (e1 | e2) & e3
    ...     assert all(e.processed for e in [e1, e2, e3])
    ...
    >>> proc = env.process(test_condition(env))
    >>> env.run()

The order of condition results is identical to the order in which the condition events were specified. This allows the following idiom for conveniently fetching the values of multiple events specified in an and condition (including `AllOf`):

    >>> def fetch_values_of_multiple_events(env):
    ...     t1, t2 = env.timeout(1, value='spam'), env.timeout(2, value='eggs')
    ...     r1, r2 = (yield t1 & t2).values()
    ...     assert r1 == 'spam' and r2 == 'eggs'
    ...
    >>> proc = env.process(fetch_values_of_multiple_events(env))
    >>> env.run()