# `simpy.rt` — Real-time simulation

Execution environment for events that synchronizes passing of time with the real-time (aka wall-clock time).

class simpy.rt.RealtimeEnvironment(initial_time: int | float = 0, factor: float = 1.0, strict: bool = True)

  Execution environment for an event-based simulation which is synchronized with the real-time (also known as wall-clock time). A time step will take factor seconds of real time (one second by default). A step from `0` to `3` with a `factor=0.5` will, for example, take at least 1.5 seconds.

  The `step()` method will raise a `RuntimeError` if a time step took too long to compute. This behaviour can be disabled by setting strict to `False`.

  now

    The current simulation time.

  active_process

    The currently active process of the environment.

  factor

    Scaling factor of the real-time.

  strict

    Running mode of the environment. `step()` will raise a `RuntimeError` if this is set to `True` and the processing of events takes too long.

  process(generator)

    Create a new `Process` instance for generator.

  timeout(delay, value=None)

    Return a new `Timeout` event with a delay and, optionally, a value.

  event()

    Return a new `Event` instance. Yielding this event suspends a process until another process triggers the event.

  all_of(events)

    Return a new `AllOf` condition for a list of events.

  any_of(events)

    Return a new `AnyOf` condition for a list of events.

  schedule(event: Event, priority: EventPriority = 1, delay: int | float = 0) → None

    Schedule an event with a given priority and a delay.

  peek() → int | float

    Get the time of the next scheduled event. Return `Infinity` if there is no further event.

  step() → None

    Process the next event after enough real-time has passed for the event to happen.

    The delay is scaled according to the real-time `factor`. With `strict` mode enabled, a `RuntimeError` will be raised, if the event is processed too slowly.

  sync() → None

    Synchronize the internal time with the current wall-clock time.

    This can be useful to prevent `step()` from raising an error if a lot of time passes between creating the RealtimeEnvironment and calling `run()` or `step()`.

  run(until: int | float | Event | None = None) → Any | None

    Executes `step()` until the given criterion until is met.

    - If it is `None` (which is the default), this method will return when there are no further events to be processed.

    - If it is an `Event`, the method will continue stepping until this event has been triggered and will return its value. Raises a `RuntimeError` if there are no further events to be processed and the until event was not triggered.

    - If it is a number, the method will continue stepping until the environment’s time reaches until.