normalize

flatten

flatten(items: T | Iterable[T | Iterable[T | Iterable[T]]]) -> Iterable[T]

flatten(items: T | Iterable[T | Iterable[T]]) -> Iterable[T]

flatten(items: T | Iterable[T]) -> Iterable[T]

flatten(items: Any) -> Any

Flatten an array of values, clips and frames included.

Source code

def flatten(items: Any) -> Any:
    """Flatten an array of values, clips and frames included."""

    if isinstance(items, (vs.RawNode, vs.RawFrame)):
        yield items
    else:
        yield from stg_flatten(items)

flatten_vnodes

flatten_vnodes(
    *clips: VideoNodeIterable | tuple[VideoNodeIterable, ...],
    split_planes: bool = False
) -> list[VideoNode]

Flatten an array of VideoNodes.

Parameters:

• clips

  (VideoNodeIterable | tuple[VideoNodeIterable, ...], default: () ) –

  An array of clips to flatten into a list.

• split_planes

  (bool, default: False ) –

  Optionally split the VideoNodes into their individual planes as well. Default: False.

Returns:

• list[VideoNode] –

  Flattened list of VideoNodes.

Source code

def flatten_vnodes(
    *clips: VideoNodeIterable | tuple[VideoNodeIterable, ...], split_planes: bool = False
) -> list[vs.VideoNode]:
    """
    Flatten an array of VideoNodes.

    :param clips:           An array of clips to flatten into a list.
    :param split_planes:    Optionally split the VideoNodes into their individual planes as well.
                            Default: False.

    :return:                Flattened list of VideoNodes.
    """

    from .utils import split

    nodes = list[vs.VideoNode](flatten(clips))

    if not split_planes:
        return nodes

    return sum(map(split, nodes), list[vs.VideoNode]())

invert_ranges

invert_ranges(
    clipa: VideoNode,
    clipb: VideoNode | None,
    ranges: FrameRangeN | FrameRangesN,
) -> list[tuple[int, int]]

Invert FrameRanges.

Example:

.. code-block:: python

>>> franges = [(100, 200), 600, (1200, 2400)]
>>> invert_ranges(core.std.BlankClip(length=10000), core.std.BlankClip(length=10000), franges)
[(0, 99), (201, 599), (601, 1199), (2401, 9999)]

Parameters:

• clipa

  (VideoNode) –

  Original clip.

• clipb

  (VideoNode | None) –

  Replacement clip.

• ranges

  (FrameRangeN | FrameRangesN) –

  Ranges to replace clipa (original clip) with clipb (replacement clip). These ranges will be inverted. For more info, see replace_ranges.

Returns:

• list[tuple[int, int]] –

  A list of inverted frame ranges.

Source code

def invert_ranges(
    clipa: vs.VideoNode, clipb: vs.VideoNode | None, ranges: FrameRangeN | FrameRangesN
) -> list[tuple[int, int]]:
    """
    Invert FrameRanges.

    Example:

    .. code-block:: python

        >>> franges = [(100, 200), 600, (1200, 2400)]
        >>> invert_ranges(core.std.BlankClip(length=10000), core.std.BlankClip(length=10000), franges)
        [(0, 99), (201, 599), (601, 1199), (2401, 9999)]

    :param clipa:          Original clip.
    :param clipb:          Replacement clip.
    :param ranges:         Ranges to replace clipa (original clip) with clipb (replacement clip).
                           These ranges will be inverted. For more info, see `replace_ranges`.

    :return:                A list of inverted frame ranges.
    """

    return stg_invert_ranges(ranges, clipa.num_frames, None if clipb is None else clipb.num_frames)

normalize_planes

normalize_planes(clip: VideoNode, planes: PlanesT = None) -> list[int]

Normalize a sequence of planes.

Parameters:

• clip

  (VideoNode) –

  Input clip.

• planes

  (PlanesT, default: None ) –

  Array of planes. If None, returns all planes of the input clip's format. Default: None.

• pad

  –

  Whether to pad the output list. Default: False.

Returns:

• list[int] –

  Sorted list of planes.

Source code

def normalize_planes(clip: vs.VideoNode, planes: PlanesT = None) -> list[int]:
    """
    Normalize a sequence of planes.

    :param clip:        Input clip.
    :param planes:      Array of planes. If None, returns all planes of the input clip's format.
                        Default: None.
    :param pad:         Whether to pad the output list.
                        Default: False.

    :return:            Sorted list of planes.
    """

    assert clip.format

    if planes is None or planes == 4:
        planes = list(range(clip.format.num_planes))
    else:
        planes = to_arr(planes, sub=True)

    return list(sorted(set(planes).intersection(range(clip.format.num_planes))))

normalize_ranges

normalize_ranges(
    clip: VideoNode, ranges: FrameRangeN | FrameRangesN
) -> list[tuple[int, int]]

Normalize ranges to a list of positive ranges.

Frame ranges can include None and negative values. None will be converted to either 0 if it's the first value in a FrameRange, or the clip's length if it's the second item. Negative values will be subtracted from the clip's length.

Examples:

.. code-block:: python

>>> clip.num_frames
1000
>>> normalize_ranges(clip, (None, None))
[(0, 999)]
>>> normalize_ranges(clip, (24, -24))
[(24, 975)]
>>> normalize_ranges(clip, [(24, 100), (80, 150)])
[(24, 150)]

Parameters:

• clip

  (VideoNode) –

  Input clip.

• franges

  –

  Frame range or list of frame ranges.

Returns:

• list[tuple[int, int]] –

  List of positive frame ranges.

Source code

def normalize_ranges(clip: vs.VideoNode, ranges: FrameRangeN | FrameRangesN) -> list[tuple[int, int]]:
    """
    Normalize ranges to a list of positive ranges.

    Frame ranges can include `None` and negative values.
    None will be converted to either 0 if it's the first value in a FrameRange,
    or the clip's length if it's the second item.
    Negative values will be subtracted from the clip's length.

    Examples:

    .. code-block:: python

        >>> clip.num_frames
        1000
        >>> normalize_ranges(clip, (None, None))
        [(0, 999)]
        >>> normalize_ranges(clip, (24, -24))
        [(24, 975)]
        >>> normalize_ranges(clip, [(24, 100), (80, 150)])
        [(24, 150)]


    :param clip:        Input clip.
    :param franges:     Frame range or list of frame ranges.

    :return:            List of positive frame ranges.
    """

    return stg_normalize_ranges(ranges, clip.num_frames)

normalize_seq

normalize_seq(val: Sequence[T], length: int = 3) -> list[T]

normalize_seq(val: T | Sequence[T], length: int = 3) -> list[T]

normalize_seq(val: T | Sequence[T], length: int = 3) -> list[T]

Normalize a sequence to the given length.

Source code

def normalize_seq(val: T | Sequence[T], length: int = 3) -> list[T]:
    """Normalize a sequence to the given length."""

    return stg_normalize_seq(val, length)