(self, k: str | dict, default=None)

(self, *args: list, copy: bool = False, **kwargs: dict)

(self)

( n_in: int, n_out: int, *, kernel_size: int = 3, stride: int = 1, padding: int = 1,

(self)

(a, b, t)

(*args: Any, **kwargs: Any)

(self, state: dict)

( self, op_key: str | None, t: torch.Tensor, *, sigma: float )

(self, *, f=_Empty, preserve_kwargs=True, **kwargs: dict)

(val: _V | _D, default: _D = None)

( a: torch.Tensor, b: torch.Tensor, t: torch.Tensor | float, *, blend_mode: str | Callable

(fun, dest=None)

(n: int, *, count: int = 3, **kwargs: Any)

( model: object, x: torch.Tensor, sigmas: torch.Tensor, *args: list[Any],

(self, obj)

(self, n_f, stride)

( t: torch.Tensor, *, mode: str = "svd", **kwargs: Any, )

(cls, val)

( *, orig_attn, sageattn_function: str = "sageattn", **kwargs: dict, )

( samples, width, height, *, mode="bicubic", mode_h=None, antialias_size=0, po

( t: torch.Tensor, min_val: torch.Tensor | float = 0.0, max_val: torch.Tensor | float = 1.0, *

( self, batch_size: int, width: int, height: int, )

(self, *args: list, **kwargs: dict)

(yaml_parameters: str | None = None)

( yl: torch.Tensor, yh: Sequence[torch.Tensor], offset_yl: float | torch.Tensor | None

()

(self, state: dict)

(self, sigma)

(self, frames: tuple | Image, frame_duration: int = 250)

(self, conds=(), ops=(), matched=(), nomatched=())

( self, *, strides: tuple[int, ...], scale_factors: tuple[int, ...], m

( self, frames: tuple[Image, ...], *, format: str | None, # noqa: A002

( left: tuple[torch.Tensor, torch.Tensor, torch.Tensor], right: tuple[torch.Tensor, torch.Tens

(x, antialias_size)

( self, x: torch.Tensor, *, decode=True, parallel=True, show_p

( self, cond1: list, cond2: list, blend_func: Callable, *, str

(typ: str | OpType, *args: list)

( cls, *, attn_function: str | Callable | None = None, blend_mode: str | None

(self, batch_size: int, *, is_video=False)

(self, sigma: torch.Tensor)

(module, *, memo: dict | None = None)

( self, samples: torch.Tensor, cols: int, rows: int, *, video_

(t: torch.Tensor, amode: str | None)

( # noqa: PLR0911 x, name, scale=1.0, sigma=None, *, skip_multiplier=1, adjust_sc

()

(self, model_options)

( self, cond: torch.Tensor, uncond: torch.Tensor, )

(self, x0: torch.Tensor, *, quiet=False)

(x, threshold, scale, scales=None, strength=1.0)

( self, t: torch.Tensor, *, forward_function: Callable | None = None, )

(cls, s: str)

(length_old, length_new, device)

(self, cond_list: list, t_start: float, t_end: float)

(meta_dict: dict)

(filename)

( module: torch.nn.Module, )

(self, model_options)

(self, model_options)

(model: object)

( *, rank: int, size: float, offset: float = -1, )

( cls, latent_type: str, )

(model: object)

(self, pt, state, key=None)

( t: torch.Tensor, *, mean: torch.Tensor | None = None, std: torch.Tensor | No

(self, sigma: torch.Tensor, ndim: int)

( self, x0: torch.Tensor, *, frames_to_batch=True, )

( self, x0: torch.Tensor, *, img_width: int | None = None, img_height:

( self, t: torch.Tensor, other_t: torch.Tensor, *, orig_t1: torch.Tens

( self, value: int, min_value: int, /, max_options: int = 1, )

(self, t, *, rescale_dims=_Empty)

( source: torch.Tensor, *, reference: torch.Tensor | None = None, # Default MAD if the referen

(self, model_options, val)

( a: torch.Tensor, b: torch.Tensor, t: torch.Tensor, *, symmetric_strength: float = 1.0,

( self, *, image_bytes: bytes, content_type: str, stamp: float | None

(self)

(cls)

( self, a: torch.Tensor, b: torch.Tensor, t: torch.Tensor | float, *,

(self, guider, **kwargs: Any)

(self, transformer_options: dict)

( self, a: torch.Tensor, b: torch.Tensor, t: torch.Tensor, *,

( self, *, strides: tuple[int, ...], memblock_kwargs: dict[str, Any] | None =

(self, patches, *args: list[Any])

(cls, key, patches, *args: list[Any])

(self, x0: torch.Tensor)

(self, x0: torch.Tensor)

( self, *, time_level: int = 3, space_level: int = 3, )

( self, *, time_level: int = 3, space_level: int = 3, )

( self, *, time_level: int = 3, )

( v0: FloatTensor, v1: FloatTensor, t: float | FloatTensor, *, dot_threshold=0.9995, d

( cls, x: torch.Tensor, model: nn.Module, *, show_progress=False,

(samples, width, height, mode="bislerp", mode_h=None)

()

(self)

(self, extra_options)

(self)

( a: torch.Tensor, b: torch.Tensor, t: float | torch.Tensor = 1.0, *, a_blend: float = 1.0

( a: torch.Tensor, b: torch.Tensor, t: float | torch.Tensor, *args: Any, backend=DEFAULT_C

(self, x0: torch.Tensor)