( cls, *, samples: dict, rules: str, samples_hsp: dict | None = None,

( cls, *, samples1: dict, samples2: dict, samples2_percent=0.5,

(cls, *, latent, latent_type: str, parallel_mode: bool)

(cls, *, latent: dict, latent_type: str, parallel_mode: bool)

(cls, *, image: torch.Tensor, latent_type: str, parallel_mode: bool)

( cls, *, model: object, enabled: bool, yaml_parameters: str | None =

( cls, sampler: object, *, start_percent: float = 0.0, end_percent: fl

( cls, sampler: object, yaml_parameters: str, **kwargs: dict, )

( a: torch.Tensor, b: torch.Tensor, t: float | torch.Tensor, *, flatten_start_dim=1, s

( a: torch.Tensor, b: torch.Tensor, t: float | torch.Tensor, *, dim=-1, scaling_consta

( cls, _i: int, xt: torch.Tensor, b: nn.Module, )

( self, i: int, xt: torch.Tensor, b: nn.Module, )

( self, _i: int, xt: torch.Tensor, b: nn.Module, )

( self, i: int, xt: torch.Tensor, b: nn.Module, )

(*args: list[Any])

(a, b, t)

(a, b, t, *, sign_order=(1.0, -1.0), sign_threshold=0.5)

(**kwargs: Any)

(h, _transformer_options)

(h, transformer_options)

(t: torch.Tensor)

()

( a: torch.Tensor, b: torch.Tensor, t: torch.tensor | float, *, a_ratio=1.0, b_ratio=1

(typ: PatchType, topts: dict, h, hsp=None)

( model: object, x: torch.Tensor, sigma: torch.Tensor, **kwargs: dict[str],

(apply_model, args)

()

( a: torch.Tensor, b: torch.Tensor, *args: Any, blend_mode: str | Callable = torch.lerp, b

(h, transformer_options, *, block_list)

(latent, *, reference_latent=None, dim=(-3, -2, -1))

(latent, target_min=None, target_max=None, **_unused_kwargs: dict)

( latent: torch.Tensor, target_min: float, target_max: float, *, dim=(-3, -2, -1), eps

( t: torch.Tensor, *, centering_strength: float, centering_restore_strength: f

(self, t, _state)

(self, t, _state)

(self, t, state)

(self, t, state)

(self, t, _state)

(self, t, _state)

(self, t, _state)

(self, t, _state)

(self, t, state)

(self, t, _state)

(self, t, state)

(self, t, state)

(self, t, _state)

(self, t, state)

(cls, t, state)

(self, t, _state)

(self, _t, state)

(self, t, state)

( a: torch.Tensor, b: torch.Tensor, t: float | torch.Tensor, *, # One of leave, clamp, bsu

( a: torch.Tensor, b: torch.Tensor, b_t: torch.Tensor, *, output_blend

(h, hsp, _transformer_options)

(h, hsp, transformer_options: dict)

(h, hsp, transformer_options, *, block_list)

(h, hsp, transformer_options)

( cls, *, model_default, model_matched=None, start_percent: float = 0.

( cls, model, rules: str, sigmas_opt: torch.Tensor | None = None, )

( cls, *, model, seed, tile_size, swap_size, max_depth

( cls, *, model, commasep_block_numbers, scale, start_percent,

( cls, *, model, commasep_block_numbers, downscale_factor, sta

( # noqa: PLR0911 self, start_time: float, model: object, refiner_model: obje

( a: torch.Tensor, b: torch.Tensor, *args: Any, base_a: bool = True, diff_limit: float = 0

(args: dict)

(state, result)

(self, args: dict[str, Any])

(state)

(self, args: dict[str, Any])

( a: torch.Tensor, b: torch.Tensor, t: float | torch.Tensor, *, growth_power: float = 0.0,

()

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

( cls, a: torch.Tensor, b: torch.Tensor, # Negative values count from the end.

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

( a: torch.Tensor, b: torch.Tensor, t: float | torch.Tensor, *, # To only use magnitude, e

( config: SageAttnOptions, model: object, x: torch.Tensor, sigmas: torch.Tensor, # *,

(self, noise, latent_image, *args: Any, **kwargs: Any)

( cls, model, x, sigmas, *args: list[Any], disable=None,

( cls, model: object, x: torch.Tensor, *args: list[Any], extra_args: d

(self, model_options, val)

(self, model_options, val)

(self, model_options, val)

(state, sigma)

( self, blend_function: Callable, cond1: list, cond2: list, strength:

( a: torch.Tensor, b: torch.Tensor, t: float | torch.Tensor, *, flatten=True, dim=1,

( a: torch.Tensor, b: torch.Tensor, t: float | torch.Tensor, *, flatten: bool = True,

( a: torch.Tensor, b: torch.Tensor, t: torch.Tensor | float, *, period: float | None = 2.0

( a, b, t, *, cpu=False, fuzz=0.1, clamp_t: bool | tuple = True, blend=torch.l

(self, state: dict)

(self, state: dict)

( a: torch.Tensor, b: torch.Tensor, t: torch.Tensor | float, *, tiers_blend_mode: str | Ca

(apply_model, args)

( cls, *, samples: dict, method_horizontal: str, method_vertical: str,

( a: torch.Tensor, b: torch.Tensor, t: float | torch.Tensor, *, blend_mode_yl: str | Calla

( a: tuple, b: tuple, *, yl_factor: torch.Tensor | float, blend_function: Callable, yh

( yl: torch.Tensor, yh: Sequence[torch.Tensor], yl_scale: float | torch.Tensor, yh_scales: flo

()

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