( self, latent_format: latent_formats.LatentFormat, *, dtype: torch.dtype,

( self, *, dtype: torch.dtype, device: torch.device, height_factor: in

( self, *, taesd: torch.nn.Module | None = None, latent_format: latent_formats

(self, seed: int, seed_offset: int = 1)

( self, *, size_mismatch_strategy: str = "zero", size_mismatch_alignment_mode:

( self, name, nresult=1, )

(self)

( # noqa: PLR0917 self, model_default, model_matched, start_percent: float =

(self, typ: str, value)

(self, typ: str, value)

(self, conds)

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

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

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

(self, rules)

( # noqa: PLR0917 self, model, seed, tile_size, swap_size, ma

(self, items: tuple[BlockCFGItem, ...])

(self, orig_forward)

(self, model: object, model_call: Callable)

(self, idx: int = 0, max_idx: int = -1)

(self, other: dict | object)

(self)

(self, _unused)

(self, other: dict | object)

(self)

(self)

(self)

(self)

(self)

(self)

(self, k: str, v)

( self, *args: Any, memblock_kwargs: dict[str, Any] | None = None, **kwargs: A

(cls, patches, apply_model, opts)

(cls, patches, opts)

(cls, patches, opts)

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

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

( self, *, time_level: int = 3, # noqa: ARG002 )

()

( config: AdvancedAttnConfig, model: object, x: torch.Tensor, sigmas: torch.Tensor, **kwar

(self, x: torch.Tensor, *, show_progress=False)

(tensor, primary_offset)

(tensor: torch.Tensor, primary_offset: int)

( # noqa: PLR0914 q: torch.Tensor, k: torch.Tensor, v: torch.Tensor, heads: int, mask=Non

( comfy_orig_attn: Callable, *args: list, _bleh_outer_kwargs=outer_kwargs,

(self, q, k, v, extra_options)

(self, out, _extra_options)

( self, sigma: float, currattncall: CurrAttnCall, old_override: Callable | Non

()

( device, latent_format: latent_formats.LatentFormat, *args: Any, **kwargs: Any, )

( preset_idx, model, x, sigmas, *args: list, **kwargs: dict, )

( a: torch.Tensor, b: torch.Tensor, t: float | torch.Tensor, *, blend_mode_a: str = "lerp"

( cond1: list, cond2: list, strength: float, *, ne

(typ, h, topts: dict)

( self, sampler: object | None = None, steps: int = 0, sampler_chain_opt: Samp

( cls, *, rules=(), time_mode: str | TimeMode | None = None, call_inde

( a: torch.Tensor, b: torch.Tensor, *args: Any, chain_iterations: int = 1, chain_blend_mod

(block_list, transformer_options)

(sigma)

( a: torch.Tensor, b: torch.Tensor, t: float | torch.Tensor, *, backend=DEFAULT_COSINE_SIM

( # noqa: PLR0914 a: torch.Tensor, b: torch.Tensor, ratio: float, *, dim: int = -1, e

( b: torch.Tensor, a: torch.Tensor, ratio: float | torch.Tensor, *, dim: int = -1, eps

( # noqa: PLR0914 a: torch.Tensor, b: torch.Tensor, ratio: float, *, dim: int = -1, e

( a: torch.Tensor, b: torch.Tensor, t: float | torch.Tensor, *, start_dim=0, end_dim=1

( self, preview_format: str, x0: torch.Tensor, )

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

(self, state: dict)

(self, state, toplevel=False)

( a: torch.Tensor, b: torch.Tensor, t: torch.Tensor | float, *, fft_dims: Sequence[int] =

(cls, x: torch.Tensor)

(self, x: torch.Tensor, past: torch.Tensor)

(self, x: torch.Tensor)

(self, x: torch.Tensor)

(self, x: torch.Tensor)

(self, x: torch.Tensor)

(self, x: torch.Tensor)

(self, latent)

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

(self)

(self)

(self, model_options)

(topts)

(t_right: torch.Tensor, t_left: torch.Tensor)

(cls, enabled: bool, sigmas: torch.Tensor)

( cls, noise_seed: int, seed_offset: int | None = 1, )

(cls)

(cls, *, any_input)

( cls, *, start_index: int, mode: str, order: str, commasep_si

(cls, *, any_input)

(cls, *, image: torch.Tensor, rescale: bool)

( cls, *, latent: dict, values_mode: str, channels_into_batch: bool,

(cls, model)

(cls, *, model, latent: dict)

(cls, *, model, latent: dict)

( cls, *, guider, fps_override: float | None = None, prefer_previewer:

( cls, *, conditioning_1: list, conditioning_2: list, blend_mode: str,

( cls, *, model, patch_mode: str = "pre_cfg", force_uncond_generation:

(self, sampler: object, seed_offset: int | None = 1)

( cls, *, sampler, any_input, preset, discard_penultimate_sigm

( self, *, sampler: object, steps: float, mode: str, )