Skip to content

generic

Classes:

ClipLengthError

Bases: CustomOverflowError

Raised when a generic clip length error occurs.

FormatsMismatchError

FormatsMismatchError(
    func: FuncExceptT,
    formats: Iterable[VideoFormatT | HoldsVideoFormatT],
    message: SupportsString = "All specified formats must be equal!",
    **kwargs: Any
)

Bases: MismatchError

Raised when clips with different formats are given.

Methods:

Source code
222
223
224
225
226
227
228
229
def __init__(
    self,
    func: FuncExceptT,
    formats: Iterable[VideoFormatT | HoldsVideoFormatT],
    message: SupportsString = "All specified formats must be equal!",
    **kwargs: Any,
) -> None:
    super().__init__(func, formats, message, **kwargs)

check classmethod

check(
    func: FuncExceptT,
    /,
    *formats: VideoFormatT | HoldsVideoFormatT,
    **kwargs: Any,
) -> None
Source code
233
234
@classmethod
def check(cls, func: FuncExceptT, /, *formats: VideoFormatT | HoldsVideoFormatT, **kwargs: Any) -> None: ...

FormatsRefClipMismatchError

FormatsRefClipMismatchError(
    func: FuncExceptT,
    clip: VideoFormatT | HoldsVideoFormatT,
    ref: VideoFormatT | HoldsVideoFormatT,
    message: SupportsString = "The format of ref and main clip must be equal!",
    **kwargs: Any
)

Bases: MismatchRefError, FormatsMismatchError

Raised when a ref clip and the main clip have different formats.

Methods:

Source code
242
243
244
245
246
247
248
249
250
def __init__(
    self,
    func: FuncExceptT,
    clip: VideoFormatT | HoldsVideoFormatT,
    ref: VideoFormatT | HoldsVideoFormatT,
    message: SupportsString = "The format of ref and main clip must be equal!",
    **kwargs: Any,
) -> None:
    super().__init__(func, clip, ref, message, **kwargs)

check classmethod

check(
    func: FuncExceptT,
    clip: VideoFormatT | HoldsVideoFormatT,
    ref: VideoFormatT | HoldsVideoFormatT,
    /,
    **kwargs: Any,
) -> None
Source code
254
255
256
257
258
259
260
261
262
@classmethod
def check(  # type: ignore[override]
    cls,
    func: FuncExceptT,
    clip: VideoFormatT | HoldsVideoFormatT,
    ref: VideoFormatT | HoldsVideoFormatT,
    /,
    **kwargs: Any,
) -> None: ...

FramePropError

FramePropError(
    func: FuncExceptT,
    key: str,
    message: SupportsString = 'Error while trying to get frame prop "{key}"!',
    **kwargs: Any
)

Bases: CustomKeyError

Raised when there is an error with the frame props.

Source code
422
423
424
425
426
427
428
429
def __init__(
    self,
    func: FuncExceptT,
    key: str,
    message: SupportsString = 'Error while trying to get frame prop "{key}"!',
    **kwargs: Any,
) -> None:
    super().__init__(message, func, key=key, **kwargs)

FramerateMismatchError

FramerateMismatchError(
    func: FuncExceptT,
    framerates: Iterable[VideoNode | Fraction | tuple[int, int] | float],
    message: SupportsString = "All the framerates must be equal!",
    **kwargs: Any
)

Bases: MismatchError

Raised when clips with a different framerate are given.

Methods:

Source code
372
373
374
375
376
377
378
379
def __init__(
    self,
    func: FuncExceptT,
    framerates: Iterable[vs.VideoNode | Fraction | tuple[int, int] | float],
    message: SupportsString = "All the framerates must be equal!",
    **kwargs: Any,
) -> None:
    super().__init__(func, framerates, message, **kwargs)

check classmethod

check(
    func: FuncExceptT,
    /,
    *framerates: VideoNode | Fraction | tuple[int, int] | float,
    **kwargs: Any,
) -> None
Source code
383
384
385
386
@classmethod
def check(
    cls, func: FuncExceptT, /, *framerates: vs.VideoNode | Fraction | tuple[int, int] | float, **kwargs: Any
) -> None: ...

FramerateRefClipMismatchError

FramerateRefClipMismatchError(
    func: FuncExceptT,
    clip: VideoNode | Fraction | tuple[int, int] | float,
    ref: VideoNode | Fraction | tuple[int, int] | float,
    message: SupportsString = "The framerate of the ref and main clip must be equal!",
    **kwargs: Any
)

Bases: MismatchRefError, FramerateMismatchError

Raised when a ref clip and the main clip have a different framerate.

Methods:

Source code
394
395
396
397
398
399
400
401
402
def __init__(
    self,
    func: FuncExceptT,
    clip: vs.VideoNode | Fraction | tuple[int, int] | float,
    ref: vs.VideoNode | Fraction | tuple[int, int] | float,
    message: SupportsString = "The framerate of the ref and main clip must be equal!",
    **kwargs: Any,
) -> None:
    super().__init__(func, clip, ref, message, **kwargs)

check classmethod

check(
    func: FuncExceptT,
    clip: VideoNode | Fraction | tuple[int, int] | float,
    ref: VideoNode | Fraction | tuple[int, int] | float,
    /,
    **kwargs: Any,
) -> None
Source code
406
407
408
409
410
411
412
413
414
@classmethod
def check(  # type: ignore[override]
    cls,
    func: FuncExceptT,
    clip: vs.VideoNode | Fraction | tuple[int, int] | float,
    ref: vs.VideoNode | Fraction | tuple[int, int] | float,
    /,
    **kwargs: Any,
) -> None: ...

FramesLengthError

FramesLengthError(
    func: FuncExceptT,
    var_name: str,
    message: SupportsString = '"{var_name}" can\'t be greater than the clip length!',
    **kwargs: Any
)

Bases: CustomOverflowError

Source code
52
53
54
55
56
57
58
59
def __init__(
    self,
    func: FuncExceptT,
    var_name: str,
    message: SupportsString = '"{var_name}" can\'t be greater than the clip length!',
    **kwargs: Any,
) -> None:
    super().__init__(message, func, var_name=var_name, **kwargs)

InvalidColorFamilyError

InvalidColorFamilyError(
    func: FuncExceptT | None,
    wrong: VideoFormatT | HoldsVideoFormatT | ColorFamily,
    correct: (
        VideoFormatT
        | HoldsVideoFormatT
        | ColorFamily
        | Iterable[VideoFormatT | HoldsVideoFormatT | ColorFamily]
    ) = YUV,
    message: SupportsString = "Input clip must be of {correct} color family, not {wrong}!",
    **kwargs: Any
)

Bases: CustomValueError

Raised when the given clip uses an invalid format.

Methods:

  • check

    Check whether the given values are correct, and if not, throw this exception.

Source code
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
def __init__(
    self,
    func: FuncExceptT | None,
    wrong: VideoFormatT | HoldsVideoFormatT | vs.ColorFamily,
    correct: VideoFormatT
    | HoldsVideoFormatT
    | vs.ColorFamily
    | Iterable[VideoFormatT | HoldsVideoFormatT | vs.ColorFamily] = vs.YUV,
    message: SupportsString = "Input clip must be of {correct} color family, not {wrong}!",
    **kwargs: Any,
) -> None:
    from ..functions import to_arr
    from ..utils import get_color_family

    wrong_str = get_color_family(wrong).name

    super().__init__(
        message,
        func,
        wrong=wrong_str,
        correct=iter({get_color_family(c).name for c in to_arr(correct)}),  # type: ignore[arg-type]
        **kwargs,
    )

check staticmethod

check(
    to_check: VideoFormatT | HoldsVideoFormatT | ColorFamily,
    correct: (
        VideoFormatT
        | HoldsVideoFormatT
        | ColorFamily
        | Iterable[VideoFormatT | HoldsVideoFormatT | ColorFamily]
    ),
    func: FuncExceptT | None = None,
    message: SupportsString | None = None,
    **kwargs: Any
) -> None

Check whether the given values are correct, and if not, throw this exception.

Parameters:

  • to_check

    (VideoFormatT | HoldsVideoFormatT | ColorFamily) –

    Value to check. Must be either a ColorFamily value, or a value a ColorFamily can be derived from such as VideoFormat.

  • correct

    (VideoFormatT | HoldsVideoFormatT | ColorFamily | Iterable[VideoFormatT | HoldsVideoFormatT | ColorFamily]) –

    A correct value or an array of correct color families.

  • func

    (FuncExceptT | None, default: None ) –

    Function returned for custom error handling. This should only be set by VS package developers.

  • message

    (SupportsString | None, default: None ) –

    Message to print when throwing the exception. The message will be formatted to display the correct and wrong values ({correct} and {wrong} respectively).

  • **kwargs

    (Any, default: {} ) –

    Keyword arguments to pass on to the exception.

Raises:

Source code
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
@staticmethod
def check(
    to_check: VideoFormatT | HoldsVideoFormatT | vs.ColorFamily,
    correct: VideoFormatT
    | HoldsVideoFormatT
    | vs.ColorFamily
    | Iterable[VideoFormatT | HoldsVideoFormatT | vs.ColorFamily],
    func: FuncExceptT | None = None,
    message: SupportsString | None = None,
    **kwargs: Any,
) -> None:
    """
    Check whether the given values are correct, and if not, throw this exception.

    Args:
        to_check: Value to check. Must be either a ColorFamily value, or a value a ColorFamily can be derived from
            such as VideoFormat.
        correct: A correct value or an array of correct color families.
        func: Function returned for custom error handling. This should only be set by VS package developers.
        message: Message to print when throwing the exception. The message will be formatted to display the correct
            and wrong values (`{correct}` and `{wrong}` respectively).
        **kwargs: Keyword arguments to pass on to the exception.

    Raises:
        InvalidColorFamilyError: Given color family is not in list of correct color families.
    """
    from ..functions import to_arr
    from ..utils import get_color_family

    to_check = get_color_family(to_check)
    correct_list = [get_color_family(c) for c in to_arr(correct)]  # type: ignore[arg-type]

    if to_check not in correct_list:
        if message is not None:
            kwargs.update(message=message)
        raise InvalidColorFamilyError(func, to_check, correct_list, **kwargs)

InvalidFramerateError

InvalidFramerateError(
    func: FuncExceptT,
    clip: VideoNode | Fraction,
    message: SupportsString = "{fps} clips are not allowed!",
    **kwargs: Any
)

Bases: CustomValueError

Raised when the given clip has an invalid framerate.

Methods:

  • check

    Check whether the given values are correct, and if not, throw this exception.

Source code
448
449
450
451
452
453
454
455
def __init__(
    self,
    func: FuncExceptT,
    clip: vs.VideoNode | Fraction,
    message: SupportsString = "{fps} clips are not allowed!",
    **kwargs: Any,
) -> None:
    super().__init__(message, func, fps=clip.fps if isinstance(clip, vs.VideoNode) else clip, **kwargs)

check staticmethod

check(
    func: FuncExceptT,
    to_check: VideoNode | Fraction | tuple[int, int] | float,
    correct: (
        VideoNode
        | Fraction
        | tuple[int, int]
        | float
        | Iterable[VideoNode | Fraction | tuple[int, int] | float]
    ),
    message: SupportsString = "Input clip must have {correct} framerate, not {wrong}!",
    **kwargs: Any
) -> None

Check whether the given values are correct, and if not, throw this exception.

Parameters:

  • to_check

    (VideoNode | Fraction | tuple[int, int] | float) –

    Value to check. Must be either a VideoNode holding the correct framerate, a Fraction, a tuple representing a fraction, or a float.

  • correct

    (VideoNode | Fraction | tuple[int, int] | float | Iterable[VideoNode | Fraction | tuple[int, int] | float]) –

    A correct value or an array of correct values.

  • func

    (FuncExceptT) –

    Function returned for custom error handling. This should only be set by VS package developers.

  • message

    (SupportsString, default: 'Input clip must have {correct} framerate, not {wrong}!' ) –

    Message to print when throwing the exception. The message will be formatted to display the correct and wrong values ({correct} and {wrong} respectively).

  • **kwargs

    (Any, default: {} ) –

    Keyword arguments to pass on to the exception.

Raises:

Source code
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
@staticmethod
def check(
    func: FuncExceptT,
    to_check: vs.VideoNode | Fraction | tuple[int, int] | float,
    correct: vs.VideoNode
    | Fraction
    | tuple[int, int]
    | float
    | Iterable[vs.VideoNode | Fraction | tuple[int, int] | float],
    message: SupportsString = "Input clip must have {correct} framerate, not {wrong}!",
    **kwargs: Any,
) -> None:
    """
    Check whether the given values are correct, and if not, throw this exception.

    Args:
        to_check: Value to check. Must be either a VideoNode holding the correct framerate, a Fraction, a tuple
            representing a fraction, or a float.
        correct: A correct value or an array of correct values.
        func: Function returned for custom error handling. This should only be set by VS package developers.
        message: Message to print when throwing the exception. The message will be formatted to display the correct
            and wrong values (`{correct}` and `{wrong}` respectively).
        **kwargs: Keyword arguments to pass on to the exception.

    Raises:
        InvalidFramerateError: Given framerate is not in list of correct framerates.
    """
    from ..utils import get_framerate

    to_check = get_framerate(to_check)

    def _resolve_correct(val: Any) -> Iterable[vs.VideoNode | Fraction | tuple[int, int] | float]:
        if isinstance(val, Iterable):
            if isinstance(val, tuple) and len(val) == 2 and all(isinstance(x, int) for x in val):
                return [val]
            return val
        return [val]

    correct_list = [get_framerate(c) for c in _resolve_correct(correct)]

    if to_check not in correct_list:
        raise InvalidFramerateError(
            func, to_check, message, wrong=to_check, correct=iter(set(correct_list)), **kwargs
        )

InvalidSubsamplingError

InvalidSubsamplingError(
    func: FuncExceptT,
    subsampling: str | VideoFormatT | HoldsVideoFormatT,
    message: SupportsString = "The subsampling {subsampling} is not supported!",
    **kwargs: Any
)

Bases: CustomValueError

Raised when the given clip has invalid subsampling.

Source code
197
198
199
200
201
202
203
204
205
206
207
208
def __init__(
    self,
    func: FuncExceptT,
    subsampling: str | VideoFormatT | HoldsVideoFormatT,
    message: SupportsString = "The subsampling {subsampling} is not supported!",
    **kwargs: Any,
) -> None:
    from ..utils import get_video_format

    subsampling = subsampling if isinstance(subsampling, str) else get_video_format(subsampling).name

    super().__init__(message, func, subsampling=subsampling, **kwargs)

InvalidTimecodeVersionError

InvalidTimecodeVersionError(
    func: FuncExceptT,
    version: int,
    message: SupportsString = "{version} is not a valid timecodes version!",
    **kwargs: Any
)

Bases: CustomValueError

Raised when an invalid timecode version is passed.

Methods:

  • check

    Check whether the given values are correct, and if not, throw this exception.

Source code
508
509
510
511
512
513
514
515
def __init__(
    self,
    func: FuncExceptT,
    version: int,
    message: SupportsString = "{version} is not a valid timecodes version!",
    **kwargs: Any,
) -> None:
    super().__init__(message, func, version=version, **kwargs)

check staticmethod

check(
    func: FuncExceptT,
    to_check: int,
    correct: int | Iterable[int] = [1, 2],
    message: SupportsString = "Timecodes version be in {correct}, not {wrong}!",
    **kwargs: Any
) -> None

Check whether the given values are correct, and if not, throw this exception.

Parameters:

  • func

    (FuncExceptT) –

    Function returned for custom error handling. This should only be set by VS package developers.

  • to_check

    (int) –

    Value to check. Must be an integer representing the timecodes version.

  • correct

    (int | Iterable[int], default: [1, 2] ) –

    A correct value or an array of correct values. Defaults to [1, 2] (V1, V2).

  • message

    (SupportsString, default: 'Timecodes version be in {correct}, not {wrong}!' ) –

    Message to print when throwing the exception. The message will be formatted to display the correct and wrong values ({correct} and {wrong} respectively).

  • **kwargs

    (Any, default: {} ) –

    Keyword arguments to pass on to the exception.

Raises:

Source code
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
@staticmethod
def check(
    func: FuncExceptT,
    to_check: int,
    correct: int | Iterable[int] = [1, 2],
    message: SupportsString = "Timecodes version be in {correct}, not {wrong}!",
    **kwargs: Any,
) -> None:
    """
    Check whether the given values are correct, and if not, throw this exception.

    Args:
        func: Function returned for custom error handling. This should only be set by VS package developers.
        to_check: Value to check. Must be an integer representing the timecodes version.
        correct: A correct value or an array of correct values. Defaults to [1, 2] (V1, V2).
        message: Message to print when throwing the exception. The message will be formatted to display the correct
            and wrong values (`{correct}` and `{wrong}` respectively).
        **kwargs: Keyword arguments to pass on to the exception.

    Raises:
        InvalidTimecodeVersionError: Given timecodes version is not in list of correct versions.
    """
    from ..functions import to_arr

    correct_list = to_arr(correct)

    if to_check not in correct_list:
        raise InvalidTimecodeVersionError(
            func, to_check, message, wrong=to_check, correct=iter(set(correct_list)), **kwargs
        )

InvalidVideoFormatError

InvalidVideoFormatError(
    func: FuncExceptT,
    format: VideoFormatT | HoldsVideoFormatT,
    message: SupportsString = "The format {format.name} is not supported!",
    **kwargs: Any
)

Bases: CustomValueError

Raised when the given clip has an invalid format.

Source code
101
102
103
104
105
106
107
108
109
110
def __init__(
    self,
    func: FuncExceptT,
    format: VideoFormatT | HoldsVideoFormatT,
    message: SupportsString = "The format {format.name} is not supported!",
    **kwargs: Any,
) -> None:
    from ..utils import get_video_format

    super().__init__(message, func, format=get_video_format(format), **kwargs)

LengthMismatchError

LengthMismatchError(
    func: FuncExceptT,
    lengths: Iterable[int | Sized],
    message: SupportsString = "All the lengths must be equal!",
    **kwargs: Any
)

Bases: MismatchError

Raised when clips with a different number of total frames are given.

Methods:

Source code
323
324
325
326
327
328
329
330
def __init__(
    self,
    func: FuncExceptT,
    lengths: Iterable[int | Sized],
    message: SupportsString = "All the lengths must be equal!",
    **kwargs: Any,
) -> None:
    super().__init__(func, lengths, message, iter(map(self._item_to_name, lengths)), **kwargs)

check classmethod

check(func: FuncExceptT, /, *lengths: int | Sized, **kwargs: Any) -> None
Source code
334
335
@classmethod
def check(cls, func: FuncExceptT, /, *lengths: int | Sized, **kwargs: Any) -> None: ...

LengthRefClipMismatchError

LengthRefClipMismatchError(
    func: FuncExceptT,
    clip: int | RawNode,
    ref: int | RawNode,
    message: SupportsString = "The main clip and ref clip length must be equal!",
    **kwargs: Any
)

Bases: MismatchRefError, LengthMismatchError

Raised when a ref clip and the main clip have a different number of total frames.

Methods:

Source code
343
344
345
346
347
348
349
350
351
def __init__(
    self,
    func: FuncExceptT,
    clip: int | vs.RawNode,
    ref: int | vs.RawNode,
    message: SupportsString = "The main clip and ref clip length must be equal!",
    **kwargs: Any,
) -> None:
    super().__init__(func, clip, ref, message, **kwargs)

check classmethod

check(
    func: FuncExceptT, clip: int | RawNode, ref: int | RawNode, /, **kwargs: Any
) -> None
Source code
355
356
357
358
@classmethod
def check(  # type: ignore[override]
    cls, func: FuncExceptT, clip: int | vs.RawNode, ref: int | vs.RawNode, /, **kwargs: Any
) -> None: ...

ResolutionsMismatchError

ResolutionsMismatchError(
    func: FuncExceptT,
    resolutions: Iterable[Resolution | VideoNode],
    message: SupportsString = "All the resolutions must be equal!",
    **kwargs: Any
)

Bases: MismatchError

Raised when clips with different resolutions are given.

Methods:

Source code
276
277
278
279
280
281
282
283
def __init__(
    self,
    func: FuncExceptT,
    resolutions: Iterable[Resolution | vs.VideoNode],
    message: SupportsString = "All the resolutions must be equal!",
    **kwargs: Any,
) -> None:
    super().__init__(func, resolutions, message, **kwargs)

check classmethod

check(
    func: FuncExceptT, /, *resolutions: Resolution | VideoNode, **kwargs: Any
) -> None
Source code
287
288
@classmethod
def check(cls, func: FuncExceptT, /, *resolutions: Resolution | vs.VideoNode, **kwargs: Any) -> None: ...

ResolutionsRefClipMismatchError

ResolutionsRefClipMismatchError(
    func: FuncExceptT,
    clip: Resolution | VideoNode,
    ref: Resolution | VideoNode,
    message: SupportsString = "The resolution of ref and main clip must be equal!",
    **kwargs: Any
)

Bases: MismatchRefError, ResolutionsMismatchError

Raised when a ref clip and the main clip have different resolutions.

Methods:

Source code
296
297
298
299
300
301
302
303
304
def __init__(
    self,
    func: FuncExceptT,
    clip: Resolution | vs.VideoNode,
    ref: Resolution | vs.VideoNode,
    message: SupportsString = "The resolution of ref and main clip must be equal!",
    **kwargs: Any,
) -> None:
    super().__init__(func, clip, ref, message, **kwargs)

check classmethod

check(
    func: FuncExceptT,
    clip: Resolution | VideoNode,
    ref: Resolution | VideoNode,
    /,
    **kwargs: Any,
) -> None
Source code
308
309
310
311
@classmethod
def check(  # type: ignore[override]
    cls, func: FuncExceptT, clip: Resolution | vs.VideoNode, ref: Resolution | vs.VideoNode, /, **kwargs: Any
) -> None: ...

TopFieldFirstError

TopFieldFirstError(
    func: FuncExceptT,
    message: SupportsString = "You must set `tff` for this clip!",
    **kwargs: Any
)

Bases: CustomValueError

Raised when the user must pass a TFF argument.

Source code
437
438
439
440
def __init__(
    self, func: FuncExceptT, message: SupportsString = "You must set `tff` for this clip!", **kwargs: Any
) -> None:
    super().__init__(message, func, **kwargs)

UnsupportedColorFamilyError

Bases: CustomValueError

Raised when an undefined color family value is passed.

UnsupportedSubsamplingError

Bases: CustomValueError

Raised when an undefined subsampling value is passed.

UnsupportedVideoFormatError

Bases: CustomValueError

Raised when an undefined video format value is passed.

VariableFormatError

VariableFormatError(
    func: FuncExceptT,
    message: SupportsString = "Variable-format clips not supported!",
    **kwargs: Any
)

Bases: CustomValueError

Raised when clip is of a variable format.

Source code
73
74
75
76
def __init__(
    self, func: FuncExceptT, message: SupportsString = "Variable-format clips not supported!", **kwargs: Any
) -> None:
    super().__init__(message, func, **kwargs)

VariableResolutionError

VariableResolutionError(
    func: FuncExceptT,
    message: SupportsString = "Variable-resolution clips not supported!",
    **kwargs: Any
)

Bases: CustomValueError

Raised when clip is of a variable resolution.

Source code
84
85
86
87
def __init__(
    self, func: FuncExceptT, message: SupportsString = "Variable-resolution clips not supported!", **kwargs: Any
) -> None:
    super().__init__(message, func, **kwargs)