# `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=0, factor=1.0, strict=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.

  `exit`(value=None)

    Stop the current process, optionally providing a `value`.

    This is a convenience function provided for Python versions prior to 3.3. From Python 3.3, you can instead use `return value` in a process.

  `schedule`(event, priority=1, delay=0)

    Schedule an event with a given priority and a delay.

  `peek`()

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

  `step`()

    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`()

    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=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.