Function common_behavior

python/pathway/stdlib/temporal/temporal_behavior.py:29–75

Creates an instance of ``CommonBehavior``, which contains a basic configuration of a behavior of temporal operators (like ``windowby`` or ``asof_join``). Each temporal operator tracks its own time (defined as a maximum time that arrived to the operator) and this configuration tells it th

(
    delay: IntervalType | None = None,
    cutoff: IntervalType | None = None,
    keep_results: bool = True,
)

def common_behavior(
    delay: IntervalType | None = None,
    cutoff: IntervalType | None = None,
    keep_results: bool = True,
) -> CommonBehavior:
    """Creates an instance of ``CommonBehavior``, which contains a basic configuration of
    a behavior of temporal operators (like ``windowby`` or ``asof_join``).
    Each temporal operator tracks its own time (defined as a maximum time that arrived to
    the operator) and this configuration tells it that some of its inputs or outputs may
    be delayed or ignored.
    The decisions are based on the current time of the operator and the time associated
    with an input/output entry. Additionally, it allows the operator to free up memory by
    removing parts of internal state that cannot interact with any future input entries.

    Remark: for the sake of temporal behavior, the current time of each operator is
    updated only after it processes all the data that arrived on input. In other words,
    if several new input entries arrived to the system simultaneously, each of those
    entries will be processed using last recorded time, and the recorded time is upda

    Args:
        delay:
            Optional.

            For windows, delays initial output by ``delay`` with respect to the
            beginning of the window. Setting it to ``None`` does not enable
            delaying mechanism.

            For interval joins and asof joins, it delays the time the record is joined by ``delay``.

            Using `delay` is useful when updates are too frequent.
        cutoff:
            Optional.

            For windows, stops updating windows which end earlier than maximal
            seen time minus ``cutoff``. Setting cutoff to ``None`` does not enable
            cutoff mechanism.

            For interval joins and asof joins, it ignores entries that are older
            than maximal seen time minus ``cutoff``. This parameter is also used to clear
            memory. It allows to release memory used by entries that won't change.

        keep_results: If set to True, keeps all results of the operator. If set to False,
            keeps only results that are newer than maximal seen time minus ``cutoff``.
            Can't be set to ``False``, when ``cutoff`` is ``None``.
    """
    assert not (cutoff is None and not keep_results)
    return CommonBehavior(delay, cutoff, keep_results)


@dataclass