Performance benchmarks:

I am open to considering this PR, but I fail to see a clear use case for it. So can you give some examples of when this might be useful?

The main situation I had in mind is when a recurring process exists in the model but becomes temporarily inactive because of state changes.

For example, an agent might have some recurring behavior that runs every few ticks. If the agent becomes inactive for a while the user might want to suspend that behavior and later resume it when the agent becomes active again.

In that case stop() feels too final because it removes the generator entirely and the user would need to recreate it later. pause() keeps the generator part of the model lifecycle but cancels the currently scheduled event so nothing fires while it’s paused. When resume() is called, it just schedules the next execution again using the normal interval logic.

So the idea is mainly to model processes that temporarily stop due to state changes but are expected to continue later, rather than being permanently terminated.

I've been thinking about a few example use cases and here's what i came up with. One example comes from the Boltzmann Wealth model. Agents repeatedly move and exchange wealth. If expressed as a recurring process instead of the step() loop, an agent could temporarily stop participating in exchanges when it has no wealth and resume once it receives wealth again.

self.trade_process = EventGenerator(
    model,
    self.trade,
    Schedule(interval=1.0),
).start()

def trade(self):
    self.move()

    if self.wealth <= 0:
        self.trade_process.pause()
        return

    self.give_money()

def receive_money(self):
    self.wealth += 1
    if self.trade_process.is_paused:
        self.trade_process.resume()

Another example is the Wolf–Sheep model. Sheep and wolves lose energy every step and eventually die if their energy becomes negative. If this were expressed as a recurring process instead of a step() loop, an agent might pause its recurring behavior when it dies and resume if it later becomes active again.

self.behavior = EventGenerator(
    model,
    self.step_behavior,
    Schedule(interval=1.0),
).start()

def step_behavior(self):
    self.move()
    self.energy -= 1

    if self.energy < 0:
        self.behavior.pause()
        return

    self.feed()

In both situations the process is temporarily inactive due to state changes but expected to continue later, so pause() and resume() avoids having to destroy and recreate the generator with stop() and start().

Thanks for this. I have been thinking about this myself a bit as well. I actually think that a better use case is some random arrival process. Say we have a Poisson arrival process for some supermarket. This arrival process is only active when the store is open, but during off-hours, we might want to pause it (and schedule its reactivation for the next day).

@quaquel can you tag me as a reviewer on PRs related to time and events?