Upload 37 files

neutral_prompt_patched/.gitignore

@@ -0,0 +1 @@
+__pycache__/

neutral_prompt_patched/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 ljleb
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

neutral_prompt_patched/README.md

@@ -0,0 +1,99 @@
+# sd-webui-neutral-prompt — Ultimate Edition
+
+> **Unified merge of the main experimental branches.**  
+> Most features from all branches are merged and work simultaneously.  
+> Some `life`/dev-only tooling (debug visualisations, mask images) was intentionally not carried over — only the production-safe subset is included.
+
+---
+
+## What's inside
+
+| Feature | Origin branch | Keyword / setting |
+|---|---|---|
+| Perpendicular projection | `main` | `AND_PERP` |
+| Saliency-guided mask | `main` | `AND_SALT` |
+| Semantic guidance top-k | `main` | `AND_TOPK` |
+| CFG rescale (mean-preserving) | `main` | CFG rescale φ slider |
+| XYZ-grid CFG rescale axis | `main` | XYZ-grid option |
+| External API override | `main` / `export_rescale_factor` | `override_cfg_rescale()` |
+| CFG rescale factor export | `export_rescale_factor` | `get_last_cfg_rescale_factor()` |
+| Affine spatial transforms | `affine` | `ROTATE / SLIDE / SCALE / SHEAR` prefix |
+| Soft alignment blend | `alignment_blend` | `AND_ALIGN_D_S` |
+| Binary alignment mask | `alignment_mask` | `AND_MASK_ALIGN_D_S` |
+| Sharpened saliency maps (k=20) | `life` (production-safe subset) | used automatically by `AND_SALT` |
+
+---
+
+## Prompt syntax
+
+```
+positive prompt text
+AND_PERP  negative-direction text :0.8
+AND_SALT  competing concept :1.0
+AND_TOPK  fine detail tweak :0.5
+AND_ALIGN_4_8  style blend :0.6
+AND_MASK_ALIGN_4_8  structure-preserving style :0.6
+AND_PERP ROTATE[0.125]  rotated perpendicular concept :1.0
+ROTATE[0.125] AND_PERP  rotated perpendicular concept :1.0
+AND_SALT SLIDE[0.05,0]  spatially shifted concept :1.0
+```
+
+### Affine transform keywords
+Affine keywords are supported in **either order** relative to the conciliation keyword:
+
+```
+AND_PERP ROTATE[0.125] vivid colors :0.8   ← affine after keyword
+ROTATE[0.125] AND_PERP vivid colors :0.8   ← affine before keyword (both work)
+```
+
+| Keyword | Parameter | Effect |
+|---|---|---|
+| `ROTATE[angle]` | angle in turns (0–1) | Rotate latent contribution |
+| `SLIDE[x,y]` | normalised offset | Translate latent contribution |
+| `SCALE[x,y]` | scale factors | Scale latent contribution |
+| `SHEAR[x,y]` | shear in turns | Shear latent contribution |
+
+Multiple transforms can be chained: `ROTATE[0.125] SLIDE[0.1,0]`
+
+### AND_ALIGN_D_S / AND_MASK_ALIGN_D_S
+- **D** = detail kernel size (small → fine detail)  
+- **S** = structure kernel size (large → global composition)  
+- The child prompt is blended in proportionally to how much it alters detail *without* changing structure.  
+- `AND_ALIGN` uses a soft weight; `AND_MASK_ALIGN` uses a binary 0/1 mask.  
+- Supported range: D, S ∈ [2, 32], D ≠ S.
+
+---
+
+## External API
+
+```python
+# In another extension or script:
+from lib_neutral_prompt.external_code import override_cfg_rescale, get_last_cfg_rescale_factor
+
+override_cfg_rescale(0.7)          # override for next step only
+factor = get_last_cfg_rescale_factor()  # read after generation
+```
+
+---
+
+## Installation
+
+1. Clone / copy this folder into `stable-diffusion-webui/extensions/`.
+2. Restart the webui.
+
+---
+
+## CFG Rescale φ
+
+When set to a value > 0 the extension rescales the CFG output to have the
+same mean and a partially rescaled standard deviation as the raw predicted x0.
+This reduces colour over-saturation at high CFG values without affecting
+prompt adherence as much as simply lowering CFG.
+
+The formula used is the **mean-preserving** variant from the `main` branch:
+
+```
+rescaled = rescale_mean + (cfg_cond − cfg_cond_mean) × rescale_factor
+```
+
+where `rescale_factor = φ × (std(cond)/std(cfg_cond) − 1) + 1`.

neutral_prompt_patched/lib_neutral_prompt/__init__.py

@@ -0,0 +1 @@
+# lib_neutral_prompt package

neutral_prompt_patched/lib_neutral_prompt/affine_transform.py

@@ -0,0 +1,83 @@
+"""
+Affine spatial transform utilities for latent tensors.
+Extracted from the `affine` branch so that cfg_denoiser_hijack can stay lean.
+
+Provides:
+  apply_affine_transform()        – apply a 2×3 affine grid to a C×H×W tensor
+  apply_masked_transform()        – apply affine + cosine-feathered mask blending
+  create_cosine_feathered_mask()  – smooth circular weight mask
+"""
+
+from typing import Tuple
+
+import torch
+import torch.nn.functional as F
+
+
+def apply_affine_transform(
+    tensor: torch.Tensor,
+    affine: torch.Tensor,
+    mode: str = 'bilinear',
+) -> torch.Tensor:
+    """
+    Apply a 2×3 affine transform to a C×H×W tensor, preserving aspect ratio.
+
+    :param tensor: Input tensor of shape [C, H, W].
+    :param affine: 2×3 float32 affine matrix.
+    :param mode: Interpolation mode for grid_sample ('bilinear' default).
+                 The original affine branch used bilinear for the pre-noise
+                 inverse path (smoother) and nearest for post-combine.
+                 Bilinear is the better default for both.
+    :return: Transformed tensor of shape [C, H, W].
+    """
+    affine = affine.clone().to(tensor.device)
+    aspect_ratio = tensor.shape[-2] / tensor.shape[-1]
+    affine[0, 1] *= aspect_ratio
+    affine[1, 0] /= aspect_ratio
+
+    grid = F.affine_grid(affine.unsqueeze(0), tensor.unsqueeze(0).size(), align_corners=False)
+    return F.grid_sample(tensor.unsqueeze(0), grid, mode=mode, align_corners=False).squeeze(0)
+
+
+def apply_masked_transform(
+    tensor: torch.Tensor,
+    affine: torch.Tensor,
+    weight: float,
+) -> Tuple[torch.Tensor, torch.Tensor]:
+    """
+    Apply an affine transform with a cosine-feathered spatial weight mask.
+
+    The mask channel is appended to the tensor before transformation so that
+    the same spatial warp is applied to both content and mask consistently.
+
+    :param tensor: C×H×W latent tensor.
+    :param affine: 2×3 affine matrix.
+    :param weight: Global scalar weight for the mask.
+    :return: (transformed_content [C, H, W], transformed_mask [H, W])
+    """
+    mask = create_cosine_feathered_mask(tensor.shape[-2:], weight).unsqueeze(0).to(tensor.device)
+    tensor_with_mask = torch.cat([tensor, mask], dim=0)          # [C+1, H, W]
+    transformed = apply_affine_transform(tensor_with_mask, affine)
+    return transformed[:-1], transformed[-1]                      # content, mask
+
+
+def create_cosine_feathered_mask(size: Tuple[int, int], weight: float) -> torch.Tensor:
+    """
+    Create a circularly-clipped cosine-feathered mask of shape [H, W].
+
+    Values at the centre approach `weight`; values outside the unit circle
+    are exactly 0, with a smooth cosine fall-off in between.
+
+    :param size: (H, W) tuple.
+    :param weight: Peak mask value at the centre.
+    :return: Float32 mask tensor of shape [H, W].
+    """
+    y, x = torch.meshgrid(
+        torch.linspace(-1, 1, size[0]),
+        torch.linspace(-1, 1, size[1]),
+        indexing='ij',
+    )
+    dist = torch.sqrt(x ** 2 + y ** 2)
+    mask = 0.5 * (1.0 + torch.cos(torch.pi * dist))
+    mask[dist > 1] = 0.0
+    return mask.float() * weight

neutral_prompt_patched/lib_neutral_prompt/cfg_denoiser_hijack.py

@@ -0,0 +1,684 @@
+"""
+Unified CFG Denoiser Hijack
+===========================
+Combines features from all sd-webui-neutral-prompt branches:
+
+  • Core PERP / SALT / TOPK strategies            (main branch)
+  • cfg_rescale with mean-preserving formula       (main branch – better than multiplicative)
+  • cfg_rescale_override (XYZ-grid / API support)  (main branch)
+  • CFGRescaleFactorSingleton export               (export_rescale_factor branch)
+  • Affine spatial transforms per-prompt           (affine branch)
+  • AND_ALIGN_D_S  – soft alignment blend          (alignment_blend branch)
+  • AND_MASK_ALIGN_D_S – binary alignment mask     (alignment_mask branch)
+  • Improved salience with sharpness parameter k   (life branch – production-safe subset)
+"""
+
+from __future__ import annotations
+
+import dataclasses
+import functools
+import re
+import sys
+import textwrap
+from typing import Dict, List, Tuple
+
+import torch
+import torch.nn.functional as F
+
+from lib_neutral_prompt import affine_transform as affine_mod
+from lib_neutral_prompt import global_state, hijacker, neutral_prompt_parser
+from modules import script_callbacks, sd_samplers, shared
+
+
+# ---------------------------------------------------------------------------
+# Pre-noise affine hook  (affine branch)
+#
+# Applied BEFORE each CFG denoising step: the noisy latent slice for every
+# cond prompt is warped by the INVERSE of that prompt's affine transform.
+# This means the UNet sees the latent in the "locally-rotated" frame of each
+# prompt.  combine_denoised then applies the FORWARD transform to the
+# resulting cond delta, restoring it to the global frame.
+# ---------------------------------------------------------------------------
+
+@dataclasses.dataclass
+class _PreNoiseArgs:
+    x: torch.Tensor
+    cond_indices: List[Tuple[int, float]]
+
+
+class _GlobalToLocalAffineVisitor:
+    """Build a {cond_index: inverse_affine} dict for every leaf prompt."""
+
+    def visit_leaf_prompt(
+        self,
+        that: neutral_prompt_parser.LeafPrompt,
+        args: _PreNoiseArgs,
+        index: int,
+    ) -> Dict[int, torch.Tensor]:
+        cond_index = args.cond_indices[index][0]
+        if that.local_transform is not None:
+            # 2×3 → 3×3 → invert → back to 2×3
+            m3 = torch.vstack([that.local_transform,
+                               torch.tensor([0.0, 0.0, 1.0])])
+            inv = torch.linalg.inv(m3)[:-1]
+        else:
+            inv = torch.eye(3)[:-1]
+        return {cond_index: inv}
+
+    def visit_composite_prompt(
+        self,
+        that: neutral_prompt_parser.CompositePrompt,
+        args: _PreNoiseArgs,
+        index: int,
+    ) -> Dict[int, torch.Tensor]:
+        inv_transforms: Dict[int, torch.Tensor] = {}
+
+        for child in that.children:
+            inv_transforms.update(child.accept(_GlobalToLocalAffineVisitor(), args, index))
+            index += child.accept(neutral_prompt_parser.FlatSizeVisitor())
+
+        # Compose parent transform on top of all children
+        if that.local_transform is not None:
+            m3 = torch.vstack([that.local_transform,
+                               torch.tensor([0.0, 0.0, 1.0])])
+            parent_inv = torch.linalg.inv(m3)
+            for inv in inv_transforms.values():
+                # inv is 2×3; extend to 3×3, multiply, trim back
+                inv3 = torch.vstack([inv, torch.tensor([0.0, 0.0, 1.0])])
+                inv[:] = (parent_inv @ inv3)[:-1]
+
+        return inv_transforms
+
+
+def _on_cfg_denoiser(params: script_callbacks.CFGDenoiserParams) -> None:
+    """Pre-noise hook: warp each cond latent slice by the inverse affine."""
+    if not global_state.is_enabled:
+        return
+
+    if not _batch_is_compatible(global_state.prompt_exprs, global_state.batch_cond_indices):
+        return
+
+    for prompt, cond_indices in zip(global_state.prompt_exprs,
+                                    global_state.batch_cond_indices):
+        args = _PreNoiseArgs(params.x, cond_indices)
+        inv_transforms = prompt.accept(_GlobalToLocalAffineVisitor(), args, 0)
+        for cond_index, _ in cond_indices:
+            params.x[cond_index] = affine_mod.apply_affine_transform(
+                params.x[cond_index], inv_transforms[cond_index]
+            )
+
+
+script_callbacks.on_cfg_denoiser(_on_cfg_denoiser)
+
+
+
+def _flat_size(prompt: neutral_prompt_parser.PromptExpr) -> int:
+    return prompt.accept(neutral_prompt_parser.FlatSizeVisitor())
+
+
+def _batch_is_compatible(
+    prompts: List[neutral_prompt_parser.PromptExpr],
+    batch_cond_indices: List[List[Tuple[int, float]]],
+) -> bool:
+    if len(prompts) != len(batch_cond_indices):
+        _console_warn(f'''
+            Neutral Prompt batch mismatch:
+            prompt_exprs={len(prompts)} vs batch_cond_indices={len(batch_cond_indices)}
+            Falling back to original A1111 behavior for this step.
+        ''')
+        return False
+
+    for i, (prompt, cond_indices) in enumerate(zip(prompts, batch_cond_indices)):
+        need = _flat_size(prompt)
+        got = len(cond_indices)
+        if need != got:
+            _console_warn(f'''
+                Neutral Prompt branch mismatch at prompt #{i}:
+                expected {need} branches, got {got}
+                This usually means another extension replaced prompt parsing hooks.
+                Falling back to original A1111 behavior for this step.
+            ''')
+            return False
+
+    return True
+
+
+# ---------------------------------------------------------------------------
+# Public entry point
+# ---------------------------------------------------------------------------
+
+def combine_denoised_hijack(
+    x_out: torch.Tensor,
+    batch_cond_indices: List[List[Tuple[int, float]]],
+    text_uncond: torch.Tensor,
+    cond_scale: float,
+    original_function,
+) -> torch.Tensor:
+    if not global_state.is_enabled:
+        return original_function(x_out, batch_cond_indices, text_uncond, cond_scale)
+
+    if not _batch_is_compatible(global_state.prompt_exprs, batch_cond_indices):
+        return original_function(x_out, batch_cond_indices, text_uncond, cond_scale)
+
+    denoised = _get_webui_denoised(x_out, batch_cond_indices, text_uncond, cond_scale, original_function)
+    uncond = x_out[-text_uncond.shape[0]:]
+
+    for batch_i, (prompt, cond_indices) in enumerate(zip(global_state.prompt_exprs, batch_cond_indices)):
+        args = _DenoiseArgs(x_out, uncond[batch_i], cond_indices)
+        cond_delta = prompt.accept(_CondDeltaVisitor(), args, 0)
+        aux_cond_delta = prompt.accept(_AuxCondDeltaVisitor(), args, cond_delta, 0)
+
+        # Apply per-prompt affine transform to both deltas (affine branch)
+        if prompt.local_transform is not None:
+            cond_delta = affine_mod.apply_affine_transform(cond_delta, prompt.local_transform)
+            aux_cond_delta = affine_mod.apply_affine_transform(aux_cond_delta, prompt.local_transform)
+
+        cfg_cond = denoised[batch_i] + aux_cond_delta * cond_scale
+        denoised[batch_i] = _cfg_rescale(cfg_cond, uncond[batch_i] + cond_delta + aux_cond_delta)
+
+    return denoised
+
+
+# ---------------------------------------------------------------------------
+# Internal helpers
+# ---------------------------------------------------------------------------
+
+def _get_webui_denoised(
+    x_out: torch.Tensor,
+    batch_cond_indices: List[List[Tuple[int, float]]],
+    text_uncond: torch.Tensor,
+    cond_scale: float,
+    original_function,
+) -> torch.Tensor:
+    uncond = x_out[-text_uncond.shape[0]:]
+    sliced_batch_x_out: List[torch.Tensor] = []
+    sliced_batch_cond_indices: List[List[Tuple[int, float]]] = []
+
+    for batch_i, (prompt, cond_indices) in enumerate(zip(global_state.prompt_exprs, batch_cond_indices)):
+        args = _DenoiseArgs(x_out, uncond[batch_i], cond_indices)
+        sliced_x_out, sliced_indices = _gather_webui_conds(prompt, args, 0, len(sliced_batch_x_out))
+        if sliced_indices:
+            sliced_batch_cond_indices.append(sliced_indices)
+        sliced_batch_x_out.extend(sliced_x_out)
+
+    sliced_batch_x_out += list(uncond)
+    return original_function(
+        torch.stack(sliced_batch_x_out, dim=0),
+        sliced_batch_cond_indices,
+        text_uncond,
+        cond_scale,
+    )
+
+
+def _cfg_rescale(cfg_cond: torch.Tensor, cond: torch.Tensor) -> torch.Tensor:
+    """
+    Mean-preserving CFG rescale (main branch formula).
+    Override is applied first so XYZ-grid / external API overrides are never silently skipped.
+    Also stores the computed rescale factor in CFGRescaleFactorSingleton.
+    """
+    # Clear last step's factor so get() returns None if rescaling is skipped
+    # this step (stale value bug fix).
+    global_state.CFGRescaleFactorSingleton.clear()
+
+    # Apply one-shot override BEFORE the early-exit check, otherwise a 0→nonzero
+    # override (from the external API) would be silently discarded.
+    global_state.apply_and_clear_cfg_rescale_override()
+
+    if global_state.cfg_rescale == 0:
+        return cfg_cond
+
+    cfg_std = cfg_cond.std()
+    if cfg_std == 0:
+        # Degenerate case: constant tensor – rescaling is a no-op.
+        return cfg_cond
+
+    cfg_cond_mean = cfg_cond.mean()
+    rescale_mean = (
+        (1 - global_state.cfg_rescale) * cfg_cond_mean
+        + global_state.cfg_rescale * cond.mean()
+    )
+    rescale_factor = global_state.cfg_rescale * (cond.std() / cfg_std - 1) + 1
+
+    # Export for external consumers (export_rescale_factor branch)
+    global_state.CFGRescaleFactorSingleton.set(
+        rescale_factor.item() if isinstance(rescale_factor, torch.Tensor) else float(rescale_factor)
+    )
+
+    return rescale_mean + (cfg_cond - cfg_cond_mean) * rescale_factor
+
+
+@dataclasses.dataclass
+class _DenoiseArgs:
+    x_out: torch.Tensor
+    uncond: torch.Tensor
+    cond_indices: List[Tuple[int, float]]
+
+
+# ---------------------------------------------------------------------------
+# Gather webui-style conditions (needed for the webui's own CFG path)
+# ---------------------------------------------------------------------------
+
+def _gather_webui_conds(
+    prompt: neutral_prompt_parser.CompositePrompt,
+    args: _DenoiseArgs,
+    index_in: int,
+    index_out: int,
+) -> Tuple[List[torch.Tensor], List[Tuple[int, float]]]:
+    sliced_x_out: List[torch.Tensor] = []
+    sliced_cond_indices: List[Tuple[int, float]] = []
+
+    for child in prompt.children:
+        if child.conciliation is None:
+            if isinstance(child, neutral_prompt_parser.LeafPrompt) and child.local_transform is None:
+                child_x_out = args.x_out[args.cond_indices[index_in][0]]
+                child_weight = child.weight
+            else:
+                child_x_out, child_weight = _get_cond_delta_and_weight(child, args, index_in)
+                child_x_out = child_x_out + args.uncond
+
+            index_offset = index_out + len(sliced_x_out)
+            sliced_x_out.append(child_x_out)
+            sliced_cond_indices.append((index_offset, child_weight))
+
+        index_in += child.accept(neutral_prompt_parser.FlatSizeVisitor())
+
+    return sliced_x_out, sliced_cond_indices
+
+
+def _get_cond_delta_and_weight(
+    prompt: neutral_prompt_parser.PromptExpr,
+    args: _DenoiseArgs,
+    index: int,
+) -> Tuple[torch.Tensor, float]:
+    """Compute cond delta and effective weight, applying affine transform if present."""
+    cond_delta = prompt.accept(_CondDeltaVisitor(), args, index)
+    cond_delta = cond_delta + prompt.accept(_AuxCondDeltaVisitor(), args, cond_delta, index)
+    weight = prompt.weight
+
+    if prompt.local_transform is not None:
+        transformed, weight_tensor = affine_mod.apply_masked_transform(
+            cond_delta + args.uncond,
+            prompt.local_transform,
+            prompt.weight,
+        )
+        cond_delta = transformed - args.uncond
+        weight = weight_tensor  # type: ignore[assignment]
+
+    return cond_delta, weight
+
+
+# ---------------------------------------------------------------------------
+# Visitor: CondDelta  – weighted sum of leaf cond − uncond
+# ---------------------------------------------------------------------------
+
+class _CondDeltaVisitor:
+    def visit_leaf_prompt(
+        self,
+        that: neutral_prompt_parser.LeafPrompt,
+        args: _DenoiseArgs,
+        index: int,
+    ) -> torch.Tensor:
+        cond_info = args.cond_indices[index]
+        if that.weight != cond_info[1]:
+            _console_warn(f'''
+                An unexpected noise weight was encountered at prompt #{index}
+                Expected :{that.weight}, but got :{cond_info[1]}
+                This is likely due to another extension also monkey patching `combine_denoised`.
+                Please open a bug report: https://github.com/ljleb/sd-webui-neutral-prompt/issues
+            ''')
+        return args.x_out[cond_info[0]] - args.uncond
+
+    def visit_composite_prompt(
+        self,
+        that: neutral_prompt_parser.CompositePrompt,
+        args: _DenoiseArgs,
+        index: int,
+    ) -> torch.Tensor:
+        cond_delta = torch.zeros_like(args.x_out[0])
+        for child in that.children:
+            if child.conciliation is None:
+                child_delta, child_weight = _get_cond_delta_and_weight(child, args, index)
+                cond_delta = cond_delta + child_weight * child_delta
+            index += child.accept(neutral_prompt_parser.FlatSizeVisitor())
+        return cond_delta
+
+
+# ---------------------------------------------------------------------------
+# Visitor: AuxCondDelta – all conciliation strategies
+# ---------------------------------------------------------------------------
+
+class _AuxCondDeltaVisitor:
+    def visit_leaf_prompt(
+        self,
+        that: neutral_prompt_parser.LeafPrompt,
+        args: _DenoiseArgs,
+        cond_delta: torch.Tensor,
+        index: int,
+    ) -> torch.Tensor:
+        return torch.zeros_like(args.x_out[0])
+
+    def visit_composite_prompt(
+        self,
+        that: neutral_prompt_parser.CompositePrompt,
+        args: _DenoiseArgs,
+        cond_delta: torch.Tensor,
+        index: int,
+    ) -> torch.Tensor:
+        aux_cond_delta = torch.zeros_like(args.x_out[0])
+        salient_cond_deltas: List[Tuple[torch.Tensor, float]] = []        # AND_SALT  k=20
+        salient_wide_deltas: List[Tuple[torch.Tensor, float]] = []        # AND_SALT_WIDE k=1
+        salient_blob_deltas: List[Tuple[torch.Tensor, float]] = []        # AND_SALT_BLOB k=20 + morphology
+        align_blend_deltas: List[Tuple[torch.Tensor, float, int, int]] = []
+        mask_align_deltas: List[Tuple[torch.Tensor, float, int, int]] = []
+
+        for child in that.children:
+            if child.conciliation is not None:
+                child_delta, child_weight = _get_cond_delta_and_weight(child, args, index)
+                strat = child.conciliation
+
+                if strat == neutral_prompt_parser.ConciliationStrategy.PERPENDICULAR:
+                    aux_cond_delta = aux_cond_delta + child_weight * _get_perpendicular_component(cond_delta, child_delta)
+
+                elif strat == neutral_prompt_parser.ConciliationStrategy.SALIENCE_MASK:
+                    salient_cond_deltas.append((child_delta, child_weight))
+
+                elif strat == neutral_prompt_parser.ConciliationStrategy.SALIENCE_MASK_WIDE:
+                    salient_wide_deltas.append((child_delta, child_weight))
+
+                elif strat == neutral_prompt_parser.ConciliationStrategy.SALIENCE_MASK_BLOB:
+                    salient_blob_deltas.append((child_delta, child_weight))
+
+                elif strat == neutral_prompt_parser.ConciliationStrategy.SEMANTIC_GUIDANCE:
+                    aux_cond_delta = aux_cond_delta + child_weight * _filter_abs_top_k(child_delta, 0.05)
+
+                else:
+                    # AND_ALIGN_D_S  (soft alignment blend)
+                    m = re.match(r'AND_ALIGN_(\d+)_(\d+)', strat.value)
+                    if m:
+                        align_blend_deltas.append((child_delta, child_weight, int(m.group(1)), int(m.group(2))))
+                    else:
+                        # AND_MASK_ALIGN_D_S  (binary alignment mask)
+                        m = re.match(r'AND_MASK_ALIGN_(\d+)_(\d+)', strat.value)
+                        if m:
+                            mask_align_deltas.append((child_delta, child_weight, int(m.group(1)), int(m.group(2))))
+
+            index += child.accept(neutral_prompt_parser.FlatSizeVisitor())
+
+        aux_cond_delta = aux_cond_delta + _salient_blend(cond_delta, salient_cond_deltas, child_k=20)
+        aux_cond_delta = aux_cond_delta + _salient_blend(cond_delta, salient_wide_deltas,  child_k=1)
+        aux_cond_delta = aux_cond_delta + _salient_blend_blob(cond_delta, salient_blob_deltas)
+        aux_cond_delta = aux_cond_delta + _alignment_blend(cond_delta, align_blend_deltas)
+        aux_cond_delta = aux_cond_delta + _alignment_mask_blend(cond_delta, mask_align_deltas)
+        return aux_cond_delta
+
+
+# ---------------------------------------------------------------------------
+# Strategy implementations
+# ---------------------------------------------------------------------------
+
+def _get_perpendicular_component(normal: torch.Tensor, vector: torch.Tensor) -> torch.Tensor:
+    if (normal == 0).all():
+        if shared.state.sampling_step <= 0:
+            _warn_projection_not_found()
+        return vector
+    return vector - normal * torch.sum(normal * vector) / torch.norm(normal) ** 2
+
+
+def _salient_blend(
+    normal: torch.Tensor,
+    vectors: List[Tuple[torch.Tensor, float]],
+    child_k: float = 20.0,
+) -> torch.Tensor:
+    """
+    Saliency-guided blend: each child prompt wins in the latent regions
+    where its absolute activation magnitude is strongest.
+
+    child_k controls how sharp/selective the child salience mask is:
+      child_k=20  → very sharp, 1-2 peak pixels  (AND_SALT  — life-branch style)
+      child_k=1   → broad, ~55% of pixels        (AND_SALT_WIDE — original main-branch)
+    Parent always uses k=1 (diffuse reference).
+    """
+    if not vectors:
+        return torch.zeros_like(normal)
+
+    salience_maps = [_get_salience(normal, k=1)] + [_get_salience(v, k=child_k) for v, _ in vectors]
+    mask = torch.argmax(torch.stack(salience_maps, dim=0), dim=0)
+
+    result = torch.zeros_like(normal)
+    for mask_i, (vector, weight) in enumerate(vectors, start=1):
+        vector_mask = (mask == mask_i).float()
+        result = result + weight * vector_mask * (vector - normal)
+    return result
+
+
+def _salient_blend_blob(
+    normal: torch.Tensor,
+    vectors: List[Tuple[torch.Tensor, float]],
+) -> torch.Tensor:
+    """
+    AND_SALT_BLOB: life-branch dev.py algorithm (cleaned of debug scaffolding).
+
+    Pipeline per child:
+      1. k=20 softmax → very sharp salience seed (1-2 pixels)
+      2. _life_erode  ×6 → erode to spatially dense core
+      3. _life_thickify ×2 → grow outward into a smooth blob
+      4. result += weight × blob_mask × (child − parent)
+
+    This is what the life-branch author was iterating toward in dev.py.
+    """
+    if not vectors:
+        return torch.zeros_like(normal)
+
+    salience_maps = [_get_salience(normal, k=1)] + [_get_salience(v, k=20) for v, _ in vectors]
+    mask = torch.argmax(torch.stack(salience_maps, dim=0), dim=0)
+
+    result = torch.zeros_like(normal)
+    for mask_i, (vector, weight) in enumerate(vectors, start=1):
+        vector_mask = (mask == mask_i).float()
+        for _ in range(6):
+            vector_mask = _life_step(vector_mask, _erode_rule)
+        for _ in range(2):
+            vector_mask = _life_step(vector_mask, _thickify_rule)
+        result = result + weight * vector_mask * (vector - normal)
+    return result
+
+
+def _life_step(board: torch.Tensor, rule) -> torch.Tensor:
+    """
+    One step of a cellular-automaton morphology on a C×H×W binary mask.
+
+    The conv3d trick from dev.py: concatenate [board, board[:-1]] along the
+    channel axis so a single 3-D convolution simultaneously sums the 3×3
+    spatial neighbourhood across *all* C channels.  This keeps the operation
+    GPU-friendly and avoids an explicit loop over channels.
+
+    neighbors[c,h,w] = Σ_{dc,dh,dw} board_padded[c+dc, h+dh, w+dw]
+                       minus the center pixel itself (board is subtracted).
+    """
+    C = board.shape[0]
+    kernel = torch.ones((C, 3, 3), dtype=board.dtype, device=board.device)
+    kernel = kernel.unsqueeze(0).unsqueeze(0)   # [1, 1, C, 3, 3]
+
+    # Pad spatially (left/right/top/bottom) but not along channel axis
+    padded = torch.cat([board.clone(), board[:-1].clone()], dim=0)          # [2C-1, H, W]
+    padded = torch.nn.functional.pad(padded, (1, 1, 1, 1, 0, 0), value=0)  # [2C-1, H+2, W+2]
+
+    neighbors = torch.nn.functional.conv3d(
+        padded.unsqueeze(0).unsqueeze(0),   # [1, 1, 2C-1, H+2, W+2]
+        kernel,                              # [1, 1,    C,   3,   3]
+        padding=0,
+    ).squeeze(0).squeeze(0)                 # [C, H, W]
+
+    neighbors = neighbors - board           # subtract center pixel
+    return rule(board, neighbors).float()
+
+
+def _erode_rule(board: torch.Tensor, neighbors: torch.Tensor) -> torch.Tensor:
+    """Keep a pixel only if it is set AND its C-channel neighbourhood is dense.
+    Threshold C*5 matches dev.py: for C=4 that means ≥20 out of 36 possible."""
+    C = board.shape[0]
+    return (board == 1) & (neighbors >= C * 5)
+
+
+def _thickify_rule(board: torch.Tensor, neighbors: torch.Tensor) -> torch.Tensor:
+    """Grow: keep existing pixels OR add any pixel adjacent to the core.
+    population ≥ 4 ensures only pixels touching at least one set neighbour grow."""
+    population = board + neighbors
+    return (board == 1) | (population >= 4)
+
+
+def _get_salience(vector: torch.Tensor, k: float = 1.0) -> torch.Tensor:
+    """Softmax-based salience map.  k > 1 → sharper, more selective mask."""
+    return torch.softmax(k * torch.abs(vector).flatten(), dim=0).reshape_as(vector)
+
+
+def _filter_abs_top_k(vector: torch.Tensor, k_ratio: float) -> torch.Tensor:
+    """Keep only the top k_ratio fraction of activations by absolute value."""
+    k = int(torch.numel(vector) * (1 - k_ratio))
+    k = max(1, k)  # kthvalue requires k >= 1
+    threshold, _ = torch.kthvalue(torch.abs(vector.flatten()), k)
+    return vector * (torch.abs(vector) >= threshold).to(vector.dtype)
+
+
+# ---------------------------------------------------------------------------
+# Alignment blend  (alignment_blend branch)
+# ---------------------------------------------------------------------------
+
+def _compute_subregion_similarity_map(
+    child_vector: torch.Tensor,
+    parent_vector: torch.Tensor,
+    region_size: int = 2,
+) -> torch.Tensor:
+    """
+    Compute local average cosine similarity of (region_size × region_size) regions.
+    Returns a map of shape [C, H, W] with values in [-1, 1].
+    """
+    C, H, W = child_vector.shape
+    parent = parent_vector.unsqueeze(0)   # [1, C, H, W]
+    child  = child_vector.unsqueeze(0)
+
+    region_radius = region_size // 2
+    if region_size % 2 == 1:
+        pad_size = (region_radius,) * 4
+    else:
+        pad_size = (region_radius - 1, region_radius) * 2
+
+    parent_reg = F.unfold(F.pad(parent, pad_size, 'constant', 0), kernel_size=region_size)
+    child_reg  = F.unfold(F.pad(child,  pad_size, 'constant', 0), kernel_size=region_size)
+
+    # [H*W, C, region_size, region_size]
+    # .contiguous() is required before .view() because .permute() produces a
+    # non-contiguous tensor and .view() raises RuntimeError on non-contiguous input.
+    parent_reg = parent_reg.view(1, C, region_size**2, H*W).permute(3, 1, 2, 0).contiguous().view(H*W, C, region_size, region_size)
+    child_reg  = child_reg.view( 1, C, region_size**2, H*W).permute(3, 1, 2, 0).contiguous().view(H*W, C, region_size, region_size)
+
+    unfold2 = torch.nn.Unfold(kernel_size=2)
+    parent_sub = unfold2(parent_reg).view(H*W, C, 4, (region_size - 1)**2)
+    child_sub  = unfold2(child_reg ).view(H*W, C, 4, (region_size - 1)**2)
+
+    parent_sub = F.normalize(parent_sub, p=2, dim=2)
+    child_sub  = F.normalize(child_sub,  p=2, dim=2)
+    sim = (parent_sub * child_sub).sum(dim=2)                        # [H*W, C, (r-1)^2]
+    return sim.mean(dim=2).permute(1, 0).contiguous().view(C, H, W) # [C, H, W]
+
+
+def _alignment_blend(
+    parent: torch.Tensor,
+    children: List[Tuple[torch.Tensor, float, int, int]],
+) -> torch.Tensor:
+    """
+    Soft alignment blend (AND_ALIGN_D_S).
+    Child contribution is weighted by max(0, structure_alignment − detail_alignment).
+    High weight where child changes detail without breaking structure.
+    """
+    result = torch.zeros_like(parent)
+    for child, weight, detail_size, structure_size in children:
+        detail_sim    = _compute_subregion_similarity_map(child, parent, detail_size)
+        structure_sim = _compute_subregion_similarity_map(child, parent, structure_size)
+
+        # Normalise by absolute max so that all-negative maps (anti-correlated prompts
+        # such as 'black' vs 'white') don't blow up to ±1e7 and clamp incorrectly to 1.
+        # Dividing by positive max would invert the sign ordering when all values are
+        # negative; dividing by abs-max preserves relative ordering in both cases.
+        d_abs_max = detail_sim.abs().max().clamp(min=1e-8)
+        s_abs_max = structure_sim.abs().max().clamp(min=1e-8)
+        detail_sim    = detail_sim    / d_abs_max
+        structure_sim = structure_sim / s_abs_max
+
+        alignment_weight = torch.clamp(structure_sim - detail_sim, min=0.0, max=1.0)
+        result = result + (child - parent) * weight * alignment_weight
+    return result
+
+
+def _alignment_mask_blend(
+    parent: torch.Tensor,
+    children: List[Tuple[torch.Tensor, float, int, int]],
+) -> torch.Tensor:
+    """
+    Binary alignment mask (AND_MASK_ALIGN_D_S).
+    Child receives full weight where structure_alignment > detail_alignment, zero elsewhere.
+    """
+    result = torch.zeros_like(parent)
+    for child, weight, detail_size, structure_size in children:
+        detail_sim    = _compute_subregion_similarity_map(child, parent, detail_size)
+        structure_sim = _compute_subregion_similarity_map(child, parent, structure_size)
+
+        d_abs_max = detail_sim.abs().max().clamp(min=1e-8)
+        s_abs_max = structure_sim.abs().max().clamp(min=1e-8)
+        detail_sim    = detail_sim    / d_abs_max
+        structure_sim = structure_sim / s_abs_max
+
+        alignment_mask = (structure_sim > detail_sim).to(child)
+        result = result + (child - parent) * weight * alignment_mask
+    return result
+
+
+# ---------------------------------------------------------------------------
+# Sampler hijack
+# ---------------------------------------------------------------------------
+
+sd_samplers_hijacker = hijacker.ModuleHijacker.install_or_get(
+    module=sd_samplers,
+    hijacker_attribute='__neutral_prompt_hijacker',
+    on_uninstall=script_callbacks.on_script_unloaded,
+)
+
+
+@sd_samplers_hijacker.hijack('create_sampler')
+def create_sampler_hijack(name: str, model, original_function):
+    sampler = original_function(name, model)
+    if not hasattr(sampler, 'model_wrap_cfg') or not hasattr(sampler.model_wrap_cfg, 'combine_denoised'):
+        if global_state.is_enabled:
+            _warn_unsupported_sampler()
+        return sampler
+
+    sampler.model_wrap_cfg.combine_denoised = functools.partial(
+        combine_denoised_hijack,
+        original_function=sampler.model_wrap_cfg.combine_denoised,
+    )
+    return sampler
+
+
+# ---------------------------------------------------------------------------
+# Warnings / logging
+# ---------------------------------------------------------------------------
+
+def _warn_unsupported_sampler() -> None:
+    _console_warn('''
+        Neutral prompt relies on composition via AND, which the webui does not support
+        when using any of the DDIM, PLMS and UniPC samplers.
+        The sampler will NOT be patched – falling back on the original implementation.
+    ''')
+
+
+def _warn_projection_not_found() -> None:
+    _console_warn('''
+        Could not find a projection for one or more AND_PERP prompts.
+        These prompts will NOT be made perpendicular.
+    ''')
+
+
+def _console_warn(message: str) -> None:
+    if not global_state.verbose:
+        return
+    print(f'\n[sd-webui-neutral-prompt]{textwrap.dedent(message)}', file=sys.stderr)

neutral_prompt_patched/lib_neutral_prompt/external_code/__init__.py

@@ -0,0 +1,23 @@
+import contextlib
+
+
+@contextlib.contextmanager
+def fix_path():
+    import sys
+    from pathlib import Path
+
+    extension_path = str(Path(__file__).parent.parent.parent)
+    added = False
+    if extension_path not in sys.path:
+        sys.path.insert(0, extension_path)
+        added = True
+
+    yield
+
+    if added:
+        sys.path.remove(extension_path)
+
+
+with fix_path():
+    del fix_path, contextlib
+    from .api import *

neutral_prompt_patched/lib_neutral_prompt/external_code/api.py

@@ -0,0 +1,27 @@
+"""
+External API for sd-webui-neutral-prompt.
+
+Provides thin helpers that external extensions / scripts can import via:
+
+    from lib_neutral_prompt.external_code import override_cfg_rescale, get_last_cfg_rescale_factor
+"""
+
+from typing import Optional
+
+from lib_neutral_prompt import global_state
+
+
+def override_cfg_rescale(cfg_rescale: float) -> None:
+    """
+    Override the CFG rescale value for the *next* generation step only.
+    After the step runs the value is automatically cleared.
+    """
+    global_state.cfg_rescale_override = cfg_rescale
+
+
+def get_last_cfg_rescale_factor() -> Optional[float]:
+    """
+    Return the CFG rescale factor computed during the most recent denoising
+    step, or None if rescaling was not active.
+    """
+    return global_state.CFGRescaleFactorSingleton.get()

neutral_prompt_patched/lib_neutral_prompt/global_state.py

@@ -0,0 +1,75 @@
+"""
+Global mutable state shared across the extension.
+
+Combines:
+  - is_enabled / prompt_exprs / verbose  (all branches)
+  - cfg_rescale + cfg_rescale_override mechanism  (main branch)
+  - batch_cond_indices  (affine branch – needed by on_cfg_denoiser pre-noise hook)
+  - CFGRescaleFactorSingleton – exposes the last computed rescale factor
+    to external callers / API users  (export_rescale_factor branch)
+"""
+
+import threading
+from typing import List, Optional, Tuple
+from lib_neutral_prompt import neutral_prompt_parser
+
+
+# ---------------------------------------------------------------------------
+# Runtime state
+# ---------------------------------------------------------------------------
+
+is_enabled: bool = False
+prompt_exprs: List[neutral_prompt_parser.PromptExpr] = []
+# Populated by reconstruct_multicond_batch hook; used by the pre-noise
+# affine transform hook (on_cfg_denoiser) to know which latent slices
+# correspond to which prompt child.
+batch_cond_indices: List[List[Tuple[int, float]]] = []
+cfg_rescale: float = 0.0
+verbose: bool = False  # matches UI default; UI syncs this on settings load
+
+# Set to a float value by XYZ-grid or external API to override cfg_rescale
+# for a single generation step, then auto-cleared.
+cfg_rescale_override: Optional[float] = None
+
+
+def apply_and_clear_cfg_rescale_override() -> None:
+    """Apply a one-shot cfg_rescale override and immediately clear it."""
+    global cfg_rescale, cfg_rescale_override
+    if cfg_rescale_override is not None:
+        cfg_rescale = cfg_rescale_override
+        cfg_rescale_override = None
+
+
+# ---------------------------------------------------------------------------
+# CFG Rescale Factor Singleton  (export_rescale_factor branch)
+#
+# Stores the last computed rescale factor so that external tools / scripts
+# can read it without re-deriving it.
+#
+# Uses threading.local() so concurrent API workers each get their own slot.
+# clear() must be called at the start of every _cfg_rescale() call so that
+# get() correctly returns None when rescaling was skipped this step.
+# ---------------------------------------------------------------------------
+
+class CFGRescaleFactorSingleton:
+    """Thread-local store for the most recently computed CFG rescale factor.
+
+    Lifecycle per denoising step:
+      1. _cfg_rescale() calls clear() at entry — value becomes None.
+      2. If rescaling is active, set() stores the computed factor.
+      3. External code calls get() after the step; receives the factor or None.
+    """
+
+    _state = threading.local()
+
+    @classmethod
+    def set(cls, value: float) -> None:
+        cls._state.cfg_rescale_factor = value
+
+    @classmethod
+    def get(cls) -> Optional[float]:
+        return getattr(cls._state, 'cfg_rescale_factor', None)
+
+    @classmethod
+    def clear(cls) -> None:
+        cls._state.cfg_rescale_factor = None

neutral_prompt_patched/lib_neutral_prompt/hijacker.py

@@ -0,0 +1,34 @@
+import functools
+
+
+class ModuleHijacker:
+    def __init__(self, module):
+        self.__module = module
+        self.__original_functions = dict()
+
+    def hijack(self, attribute):
+        if attribute not in self.__original_functions:
+            self.__original_functions[attribute] = getattr(self.__module, attribute)
+
+        def decorator(function):
+            setattr(self.__module, attribute, functools.partial(function, original_function=self.__original_functions[attribute]))
+            return function
+
+        return decorator
+
+    def reset_module(self):
+        for attribute, original_function in self.__original_functions.items():
+            setattr(self.__module, attribute, original_function)
+
+        self.__original_functions.clear()
+
+    @staticmethod
+    def install_or_get(module, hijacker_attribute, on_uninstall=lambda _callback: None):
+        if not hasattr(module, hijacker_attribute):
+            module_hijacker = ModuleHijacker(module)
+            setattr(module, hijacker_attribute, module_hijacker)
+            on_uninstall(lambda: delattr(module, hijacker_attribute))
+            on_uninstall(module_hijacker.reset_module)
+            return module_hijacker
+        else:
+            return getattr(module, hijacker_attribute)

neutral_prompt_patched/lib_neutral_prompt/neutral_prompt_parser.py

@@ -0,0 +1,382 @@
+"""
+Unified Neutral Prompt Parser
+Combines:
+  - Core AND / AND_PERP / AND_SALT / AND_TOPK strategies (main branch)
+  - Affine spatial transforms: ROTATE / SLIDE / SCALE / SHEAR (affine branch)
+  - Local alignment blend: AND_ALIGN_D_S / AND_MASK_ALIGN_D_S  (alignment_blend branch)
+"""
+
+import abc
+import dataclasses
+import math
+import re
+from enum import Enum
+from itertools import product
+from typing import Any, List, Optional, Tuple
+
+import torch
+
+
+# ---------------------------------------------------------------------------
+# Keyword registry
+# ---------------------------------------------------------------------------
+
+# Base conciliation keywords
+_BASE_KEYWORD_MAP = {
+    'AND_PERP':      'PERPENDICULAR',
+    'AND_SALT':      'SALIENCE_MASK',       # k=20 sharp mask  (life-branch style)
+    'AND_SALT_WIDE': 'SALIENCE_MASK_WIDE',  # k=1  broad mask  (original main-branch behaviour)
+    'AND_SALT_BLOB': 'SALIENCE_MASK_BLOB',  # k=20 + erode + thickify → smooth blob (dev.py intent)
+    'AND_TOPK':      'SEMANTIC_GUIDANCE',
+}
+
+# Alignment blend: AND_ALIGN_D_S  (soft weight, structure > detail)
+_ALIGN_KEYWORD_MAP = {
+    f'AND_ALIGN_{i}_{j}': f'ALIGNMENT_BLEND_{i}_{j}'
+    for i, j in product(range(2, 33), repeat=2) if i != j
+}
+
+# Alignment mask: AND_MASK_ALIGN_D_S  (binary mask, structure > detail)
+_MASK_ALIGN_KEYWORD_MAP = {
+    f'AND_MASK_ALIGN_{i}_{j}': f'ALIGNMENT_MASK_BLEND_{i}_{j}'
+    for i, j in product(range(2, 33), repeat=2) if i != j
+}
+
+keyword_mapping = _BASE_KEYWORD_MAP | _ALIGN_KEYWORD_MAP | _MASK_ALIGN_KEYWORD_MAP
+
+PromptKeyword = Enum('PromptKeyword', {'AND': 'AND', **{k: k for k in keyword_mapping}})
+ConciliationStrategy = Enum('ConciliationStrategy', {v: k for k, v in keyword_mapping.items()})
+
+# Lists kept for ordered iteration (tokenize uses list order for regex priority)
+prompt_keywords = [e.value for e in PromptKeyword]
+conciliation_strategies = [e.value for e in ConciliationStrategy]
+
+# Sets for O(1) membership checks in parser hot-loops (1864-item list = 230x slower)
+_prompt_keywords_set = frozenset(prompt_keywords)
+_conciliation_strategies_set = frozenset(conciliation_strategies)
+
+
+# ---------------------------------------------------------------------------
+# Affine transform definitions  (from affine branch)
+# ---------------------------------------------------------------------------
+
+affine_transforms = {
+    'ROTATE': lambda t, angle=0, *_: t @ torch.tensor([
+        [math.cos(angle * 2 * math.pi), -math.sin(angle * 2 * math.pi), 0],
+        [math.sin(angle * 2 * math.pi),  math.cos(angle * 2 * math.pi), 0],
+        [0, 0, 1],
+    ], dtype=torch.float32),
+    'SLIDE': lambda t, x=0, y=0, *_: t @ torch.tensor([
+        [1, 0, float(x)],
+        [0, 1, float(y)],
+        [0, 0, 1],
+    ], dtype=torch.float32),
+    'SCALE': lambda t, x=1, y=None, *_: t @ torch.tensor([
+        [float(x), 0, 0],
+        [0, float(y) if y is not None else float(x), 0],
+        [0, 0, 1],
+    ], dtype=torch.float32),
+    'SHEAR': lambda t, x=0, y=None, *_: t @ torch.tensor([
+        [1, math.tan(float(x) * 2 * math.pi), 0],
+        [math.tan(float(y if y is not None else x) * 2 * math.pi), 1, 0],
+        [0, 0, 1],
+    ], dtype=torch.float32),
+}
+
+
+# ---------------------------------------------------------------------------
+# AST node types
+# ---------------------------------------------------------------------------
+
+@dataclasses.dataclass
+class PromptExpr(abc.ABC):
+    weight: float
+    conciliation: Optional[ConciliationStrategy]
+    local_transform: Optional[torch.Tensor]  # 2×3 affine tensor or None
+
+    @abc.abstractmethod
+    def accept(self, visitor, *args, **kwargs) -> Any:
+        pass
+
+
+@dataclasses.dataclass
+class LeafPrompt(PromptExpr):
+    prompt: str
+
+    def accept(self, visitor, *args, **kwargs):
+        return visitor.visit_leaf_prompt(self, *args, **kwargs)
+
+
+@dataclasses.dataclass
+class CompositePrompt(PromptExpr):
+    children: List[PromptExpr]
+
+    def accept(self, visitor, *args, **kwargs):
+        return visitor.visit_composite_prompt(self, *args, **kwargs)
+
+
+class FlatSizeVisitor:
+    def visit_leaf_prompt(self, that: LeafPrompt) -> int:
+        return 1
+
+    def visit_composite_prompt(self, that: CompositePrompt) -> int:
+        return sum(child.accept(self) for child in that.children) if that.children else 0
+
+
+# ---------------------------------------------------------------------------
+# Parser
+# ---------------------------------------------------------------------------
+
+def parse_root(string: str) -> CompositePrompt:
+    tokens = tokenize(string)
+    prompts = parse_prompts(tokens)
+    return CompositePrompt(1.0, None, None, prompts)
+
+
+def parse_prompts(tokens: List[str], *, nested: bool = False) -> List[PromptExpr]:
+    prompts = [parse_prompt(tokens, first=True, nested=nested)]
+    while tokens:
+        if nested and tokens[0] == ']':
+            break
+        prompts.append(parse_prompt(tokens, first=False, nested=nested))
+    return prompts
+
+
+def _compose_affine(
+    a: Optional[torch.Tensor],
+    b: Optional[torch.Tensor],
+) -> Optional[torch.Tensor]:
+    """
+    Compose two 2×3 affine matrices (a applied first, then b).
+    Returns None if both are None; returns the non-None one if only one exists.
+    """
+    if a is None:
+        return b
+    if b is None:
+        return a
+    # Lift to 3×3, multiply, trim back to 2×3
+    a3 = torch.vstack([a, torch.tensor([0.0, 0.0, 1.0], dtype=torch.float32)])
+    b3 = torch.vstack([b, torch.tensor([0.0, 0.0, 1.0], dtype=torch.float32)])
+    return (b3 @ a3)[:-1]
+
+
+def _looks_like_leading_affine_prompt(tokens: List[str]) -> bool:
+    """
+    Return True if `tokens` starts with one or more affine keywords followed
+    immediately by a prompt keyword, e.g.:
+        ROTATE[0.125] AND_PERP ...
+        SLIDE[0.05,0] AND_SALT ...
+        ROTATE[0.125] SLIDE[0.05,0] AND_PERP ...
+
+    This is a pure structural scan — it does NOT compute any affine matrices,
+    so it is safe to call as a look-ahead probe without mock-torch issues.
+
+    Used in two places:
+      - parse_prompt()         → consume leading affine before keyword
+      - _parse_prompt_text()   → stop current segment before this boundary
+    """
+    pos = 0
+    n = len(tokens)
+    # skip a leading whitespace-only token
+    if pos < n and not tokens[pos].strip():
+        pos += 1
+    # must start with an affine keyword
+    if pos >= n or tokens[pos] not in affine_transforms:
+        return False
+    # consume one or more  KEYWORD [ args ] blocks
+    while pos < n and tokens[pos] in affine_transforms:
+        pos += 1                          # skip keyword
+        if pos >= n or tokens[pos] != '[':
+            return False
+        pos += 1                          # skip '['
+        if pos < n and tokens[pos] != ']':
+            pos += 1                      # skip args (may contain commas)
+        if pos >= n or tokens[pos] != ']':
+            return False
+        pos += 1                          # skip ']'
+        if pos < n and not tokens[pos].strip():
+            pos += 1                      # skip optional whitespace
+    # the very next token must be a prompt keyword
+    return pos < n and tokens[pos] in _prompt_keywords_set
+
+
+def parse_prompt(tokens: List[str], *, first: bool, nested: bool = False) -> PromptExpr:
+    # Support two affine-keyword orderings:
+    #   (A) AND_PERP ROTATE[0.25] text   ← trailing affine (original syntax)
+    #   (B) ROTATE[0.25] AND_PERP text   ← leading affine (documented syntax)
+    #
+    # Note: we check _looks_like_leading_affine_prompt unconditionally (not
+    # gated on `not first`) so that a prompt starting with e.g.
+    # "ROTATE[0.125] AND_PERP text" is handled correctly even as the first
+    # segment.
+    leading_affine: Optional[torch.Tensor] = None
+    if _looks_like_leading_affine_prompt(tokens):
+        probe = tokens.copy()
+        leading_affine = _parse_affine_transform(probe)
+        tokens[:] = probe
+
+    # After consuming a leading affine the next token is a keyword; accept it.
+    # We also accept a keyword as the very first token (first=True) without a
+    # leading affine — e.g. "AND_PERP vivid" at the start of a string should
+    # produce a single PERP child, not an empty default child followed by a PERP
+    # child.  The original `not first` guard was an artefact of earlier grammar;
+    # all existing tests pass without it.
+    if tokens and tokens[0] in _prompt_keywords_set:
+        prompt_type = tokens.pop(0)
+    else:
+        prompt_type = PromptKeyword.AND.value
+
+    conciliation = ConciliationStrategy(prompt_type) if prompt_type in _conciliation_strategies_set else None
+
+    # Parse optional trailing affine transform chain (original syntax)
+    trailing_affine = _parse_affine_transform(tokens)
+    affine_transform = _compose_affine(leading_affine, trailing_affine)
+
+    # Try composite (bracketed) form
+    tokens_copy = tokens.copy()
+    if tokens_copy and tokens_copy[0] == '[':
+        tokens_copy.pop(0)
+        prompts = parse_prompts(tokens_copy, nested=True)
+        if tokens_copy:
+            assert tokens_copy.pop(0) == ']'
+        if len(prompts) > 1:
+            tokens[:] = tokens_copy
+            weight = _parse_weight(tokens)
+            return CompositePrompt(weight, conciliation, affine_transform, prompts)
+
+    prompt_text, weight = _parse_prompt_text(tokens, nested=nested)
+    return LeafPrompt(weight, conciliation, affine_transform, prompt_text)
+
+
+def _parse_prompt_text(tokens: List[str], *, nested: bool = False) -> Tuple[str, float]:
+    text = ''
+    depth = 0
+    weight = 1.0
+    while tokens:
+        tok = tokens[0]
+        if tok == ']':
+            if depth == 0:
+                if nested:
+                    break
+            else:
+                depth -= 1
+        elif tok == '[':
+            depth += 1
+        elif tok == ':':
+            if len(tokens) >= 2 and _is_float(tokens[1].strip()):
+                if len(tokens) < 3 or tokens[2] in _prompt_keywords_set or (tokens[2] == ']' and depth == 0):
+                    tokens.pop(0)
+                    weight = float(tokens.pop(0).strip())
+                    break
+        elif tok in _prompt_keywords_set:
+            break
+        # Stop before a leading-affine-then-keyword boundary, e.g.
+        #   ROTATE[0.125] AND_PERP text
+        # so the affine is consumed by the *next* parse_prompt call, not
+        # swallowed as raw text by the current segment.
+        elif depth == 0 and _looks_like_leading_affine_prompt(tokens):
+            break
+        text += tokens.pop(0)
+    return text, weight
+
+
+def _parse_affine_transform(tokens: List[str]) -> Optional[torch.Tensor]:
+    """
+    Consume optional affine keywords like ROTATE[0.25] SLIDE[0.1,0] from the token stream.
+    Returns a 2×3 float32 tensor, or None if no affine tokens were found.
+    """
+    tokens_copy = tokens.copy()
+    if tokens_copy and not tokens_copy[0].strip():
+        tokens_copy.pop(0)
+
+    affine_funcs = []
+
+    while tokens_copy and tokens_copy[0] in affine_transforms:
+        func = affine_transforms[tokens_copy.pop(0)]
+        args: List[float] = []
+
+        if not (tokens_copy and tokens_copy[0] == '['):
+            break
+        tokens_copy.pop(0)  # consume '['
+
+        if tokens_copy and tokens_copy[0] != ']':
+            if tokens_copy[0].strip():
+                try:
+                    args = [float(a.strip()) for a in tokens_copy.pop(0).split(',')]
+                except ValueError:
+                    break
+            else:
+                tokens_copy.pop(0)
+
+        if not (tokens_copy and tokens_copy[0] == ']'):
+            break
+        tokens_copy.pop(0)  # consume ']'
+
+        affine_funcs.append(lambda t, f=func, a=args: f(t, *a))
+        if tokens_copy and not tokens_copy[0].strip():
+            tokens_copy.pop(0)
+        tokens[:] = tokens_copy
+
+    if not affine_funcs:
+        return None
+
+    transform = torch.eye(3, dtype=torch.float32)[:-1]  # 2×3
+    for fn in reversed(affine_funcs):
+        transform = fn(transform)
+    return transform
+
+
+def _parse_weight(tokens: List[str]) -> float:
+    if len(tokens) >= 2 and tokens[0] == ':' and _is_float(tokens[1]):
+        tokens.pop(0)
+        return float(tokens.pop(0))
+    return 1.0
+
+
+def tokenize(s: str) -> List[str]:
+    # Use general patterns for AND_ALIGN / AND_MASK_ALIGN families instead of
+    # enumerating all 1800+ combinations - that regex is 41k chars and 500x slower.
+    # Order matters: longer/more-specific patterns must come first.
+    # Use (?<!\w) / (?!\w) instead of \b because _ counts as \w in Python's \b,
+    # which would cause 'AND' to match inside 'XAND' (no boundary between \w chars).
+    affine_kw_pattern = '|'.join(
+        rf'(?<!\w){kw}(?!\w)' for kw in affine_transforms
+    )
+    keyword_pattern = (
+        r'(?<!\w)AND_MASK_ALIGN_\d+_\d+(?!\w)'   # must come before AND_ALIGN and AND
+        r'|(?<!\w)AND_ALIGN_\d+_\d+(?!\w)'
+        r'|(?<!\w)AND_PERP(?!\w)'
+        r'|(?<!\w)AND_SALT_WIDE(?!\w)'            # must come before AND_SALT
+        r'|(?<!\w)AND_SALT_BLOB(?!\w)'            # must come before AND_SALT
+        r'|(?<!\w)AND_SALT(?!\w)'
+        r'|(?<!\w)AND_TOPK(?!\w)'
+        r'|(?<!\w)AND(?!\w)'
+    )
+    return [t for t in re.split(rf'(\[|\]|:|{keyword_pattern}|{affine_kw_pattern})', s) if t.strip()]
+
+
+def _is_float(s: str) -> bool:
+    try:
+        float(s)
+        return True
+    except ValueError:
+        return False
+
+
+# ---------------------------------------------------------------------------
+# Quick smoke-test
+# ---------------------------------------------------------------------------
+if __name__ == '__main__':
+    res = parse_root('''
+    hello
+    AND_PERP [
+        arst
+        AND defg : 2
+        AND_SALT [
+            very nested huh? what do you say :.0
+        ]
+    ]
+    AND_ALIGN_4_8 watercolor style :0.5
+    ROTATE[0.125] AND_PERP vibrant colors
+    ''')
+    print(res)

neutral_prompt_patched/lib_neutral_prompt/prompt_parser_hijack.py

@@ -0,0 +1,134 @@
+import re
+import logging
+from typing import List
+
+from lib_neutral_prompt import hijacker, global_state, neutral_prompt_parser
+from modules import script_callbacks, prompt_parser
+
+# ---------------------------------------------------------------------------
+# Fix: prompt_parser_fixed escapes standalone '&' as a multicond separator.
+# neutral_prompt_parser does NOT treat '&' as AND — it keeps it as literal text.
+# So a leaf like  "cat & dog"  transpiles to  "cat & dog :1.0",
+# and the patched prompt_parser splits that into 3 multicond branches instead of 1,
+# which shifts all batch_cond_indices and breaks PERP/SALT/affine.
+#
+# Solution: escape any standalone '&' inside leaf text with '\&' before handing
+# the string to the webui parser. The patched prompt_parser correctly unescapes
+# '\&' back to '&' during conditioning, so the model sees the original text.
+# ---------------------------------------------------------------------------
+
+_STANDALONE_AMP = re.compile(r'(?<!\\)(?<!\S)&(?!\S)')
+
+# ── debug logging ──────────────────────────────────────────────────────────
+# Set env variable NP_DEBUG=1 to enable verbose output in the A1111 console.
+# Example (Linux/Mac):   NP_DEBUG=1 python launch.py
+# Example (Windows cmd): set NP_DEBUG=1 && python launch.py
+import os as _os
+_DEBUG = _os.getenv("NP_DEBUG", "0").strip() not in ("0", "", "false", "no", "off")
+_log = logging.getLogger("neutral_prompt.hijack")
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def _escape_leaf_ampersands(text: str) -> str:
+    """Escape standalone '&' so patched prompt_parser doesn't split a single
+    Neutral Prompt leaf into extra multicond branches.
+      "cat & dog"  ->  "cat \\& dog"
+      "R&D"        ->  "R&D"           (unchanged — not standalone)
+      "\\&"        ->  "\\&"           (unchanged — already escaped)
+    """
+    if not text or '&' not in text:
+        return text
+    return _STANDALONE_AMP.sub(r'\\&', text)
+
+
+prompt_parser_hijacker = hijacker.ModuleHijacker.install_or_get(
+    module=prompt_parser,
+    hijacker_attribute='__neutral_prompt_hijacker',
+    on_uninstall=script_callbacks.on_script_unloaded,
+)
+
+
+@prompt_parser_hijacker.hijack('get_multicond_prompt_list')
+def get_multicond_prompt_list_hijack(prompts, original_function):
+    if not global_state.is_enabled:
+        return original_function(prompts)
+
+    global_state.prompt_exprs = parse_prompts(prompts)
+    webui_prompts = transpile_exprs(global_state.prompt_exprs)
+
+    # ── debug: transpiled strings ──────────────────────────────────────────
+    if _DEBUG:
+        for i, (orig, transp) in enumerate(zip(prompts, webui_prompts)):
+            _log.warning(
+                "[NP_DEBUG] prompt[%d]\n"
+                "  original   : %r\n"
+                "  transpiled : %r\n"
+                "  branches   : %d",
+                i, orig, transp,
+                # count multicond splits the same way prompt_parser_fixed does
+                len(re.split(r'(?:\bAND\b|(?<!\S)&(?!\S))(?!_PERP|_SALT|_TOPK)', transp))
+            )
+    # ──────────────────────────────────────────────────────────────────────
+
+    if isinstance(prompts, getattr(prompt_parser, 'SdConditioning', type(None))):
+        webui_prompts = prompt_parser.SdConditioning(webui_prompts, copy_from=prompts)
+
+    result = original_function(webui_prompts)
+
+    # ── debug: multicond parts ─────────────────────────────────────────────
+    if _DEBUG:
+        conds_list, prompt_flat_list, prompt_indexes = result
+        _log.warning(
+            "[NP_DEBUG] get_multicond_prompt_list result\n"
+            "  prompt_flat_list : %r\n"
+            "  prompt_indexes   : %r\n"
+            "  conds_list       : %r",
+            list(prompt_flat_list),
+            dict(prompt_indexes),
+            conds_list,
+        )
+    # ──────────────────────────────────────────────────────────────────────
+
+    return result
+
+
+def parse_prompts(prompts: List[str]) -> List[neutral_prompt_parser.PromptExpr]:
+    exprs = []
+    for prompt in prompts:
+        expr = neutral_prompt_parser.parse_root(prompt)
+        exprs.append(expr)
+    return exprs
+
+
+def transpile_exprs(exprs: neutral_prompt_parser.PromptExpr):
+    webui_prompts = []
+    for expr in exprs:
+        webui_prompts.append(expr.accept(WebuiPromptVisitor()))
+    return webui_prompts
+
+
+class WebuiPromptVisitor:
+    def visit_leaf_prompt(self, that: neutral_prompt_parser.LeafPrompt) -> str:
+        prompt = _escape_leaf_ampersands(that.prompt)
+        return f'{prompt} :{that.weight}'
+
+    def visit_composite_prompt(self, that: neutral_prompt_parser.CompositePrompt) -> str:
+        return ' AND '.join(child.accept(self) for child in that.children)
+
+
+@prompt_parser_hijacker.hijack('reconstruct_multicond_batch')
+def reconstruct_multicond_batch_hijack(*args, original_function, **kwargs):
+    """Store batch_cond_indices for the pre-noise affine hook (affine branch)."""
+    res = original_function(*args, **kwargs)
+    global_state.batch_cond_indices = res[0]
+
+    # ── debug: batch_cond_indices ──────────────────────────────────────────
+    if _DEBUG:
+        _log.warning(
+            "[NP_DEBUG] reconstruct_multicond_batch\n"
+            "  batch_cond_indices : %r",
+            res[0],
+        )
+    # ──────────────────────────────────────────────────────────────────────
+
+    return res

neutral_prompt_patched/lib_neutral_prompt/ui.py

@@ -0,0 +1,196 @@
+"""
+Gradio UI for sd-webui-neutral-prompt (unified).
+
+Combines:
+  - Core prompt types + tooltip             (main branch)
+  - AND_ALIGN / AND_MASK_ALIGN entries      (alignment_blend branch)
+  - elem_id on dropdown                     (main branch)
+  - CFG Rescale infotext / paste support    (all branches)
+  - Affine-transform hint in tooltip        (affine branch)
+"""
+
+from __future__ import annotations
+
+from itertools import product
+from typing import Callable, Dict, List, Tuple
+
+import dataclasses
+import gradio as gr
+
+from lib_neutral_prompt import global_state, neutral_prompt_parser
+from modules import script_callbacks, shared
+
+
+txt2img_prompt_textbox = None
+img2img_prompt_textbox = None
+
+
+# ---------------------------------------------------------------------------
+# Prompt-type registry shown in the UI dropdown
+# ---------------------------------------------------------------------------
+
+prompt_types: Dict[str, str] = {
+    'Perpendicular (AND_PERP)':               neutral_prompt_parser.PromptKeyword.AND_PERP.value,
+    'Saliency sharp (AND_SALT)':              neutral_prompt_parser.PromptKeyword.AND_SALT.value,
+    'Saliency blob (AND_SALT_BLOB)':          neutral_prompt_parser.PromptKeyword.AND_SALT_BLOB.value,
+    'Saliency wide / classic (AND_SALT_WIDE)':neutral_prompt_parser.PromptKeyword.AND_SALT_WIDE.value,
+    'Semantic guidance top-k (AND_TOPK)':     neutral_prompt_parser.PromptKeyword.AND_TOPK.value,
+}
+
+# Add AND_ALIGN_D_S entries for commonly-used kernel size pairs
+for _d, _s in ((2, 4), (2, 8), (4, 8), (4, 16), (8, 16), (8, 32)):
+    _key = f'Alignment blend  detail={_d}  structure={_s}  (AND_ALIGN_{_d}_{_s})'
+    prompt_types[_key] = getattr(neutral_prompt_parser.PromptKeyword, f'AND_ALIGN_{_d}_{_s}').value
+
+# Add AND_MASK_ALIGN_D_S entries
+for _d, _s in ((2, 4), (2, 8), (4, 8), (4, 16), (8, 16), (8, 32)):
+    _key = f'Alignment mask   detail={_d}  structure={_s}  (AND_MASK_ALIGN_{_d}_{_s})'
+    prompt_types[_key] = getattr(neutral_prompt_parser.PromptKeyword, f'AND_MASK_ALIGN_{_d}_{_s}').value
+
+prompt_types_tooltip = '\n'.join([
+    'AND               – add all prompt features equally (webui built-in)',
+    'AND_PERP          – reduce contradicting prompt features via perpendicular projection',
+    'AND_SALT          – sharp saliency mask: child wins only at its 1-2 peak pixels (surgical)',
+    'AND_SALT_BLOB     – blob saliency mask: peak pixels eroded to core, then grown to smooth blob',
+    'AND_SALT_WIDE     – broad saliency mask: child wins ~55% of pixels (classic main-branch)',
+    'AND_TOPK          – small targeted changes (semantic guidance top-k)',
+    'AND_ALIGN_D_S     – soft blend: child adds details without breaking structure',
+    'AND_MASK_ALIGN_D_S– binary mask blend: stricter version of AND_ALIGN',
+    '',
+    'Affine transforms (supported in either order for auxiliary segments):',
+    '  ROTATE[angle]  SLIDE[x,y]  SCALE[x,y]  SHEAR[x,y]',
+    '  e.g.:  ROTATE[0.125] AND_PERP vibrant colors :0.8',
+    '  e.g.:  AND_PERP ROTATE[0.125] vibrant colors :0.8',
+])
+
+
+# ---------------------------------------------------------------------------
+# UI component class
+# ---------------------------------------------------------------------------
+
+@dataclasses.dataclass
+class AccordionInterface:
+    get_elem_id: Callable[[str], str]
+
+    def __post_init__(self):
+        self.is_rendered = False
+
+        self.cfg_rescale = gr.Slider(
+            label='CFG rescale φ',
+            minimum=0, maximum=1, value=0,
+            info='0 = disabled. Rescales the CFG output towards the predicted x0 to reduce over-saturation.',
+        )
+        self.neutral_prompt = gr.Textbox(
+            label='Neutral prompt',
+            show_label=False,
+            lines=3,
+            placeholder=(
+                'Neutral / auxiliary prompt  '
+                '(press "Apply to prompt" to append with the chosen strategy keyword)'
+            ),
+        )
+        self.neutral_cond_scale = gr.Slider(
+            label='Prompt weight',
+            minimum=-3, maximum=3, value=1,
+        )
+        self.aux_prompt_type = gr.Dropdown(
+            label='Prompt type',
+            choices=list(prompt_types.keys()),
+            value=next(iter(prompt_types.keys())),
+            tooltip=prompt_types_tooltip,
+            elem_id=self.get_elem_id('formatter_prompt_type'),
+        )
+        self.append_to_prompt_button = gr.Button(value='Apply to prompt')
+
+    # ------------------------------------------------------------------
+
+    def arrange_components(self, is_img2img: bool) -> None:
+        if self.is_rendered:
+            return
+
+        with gr.Accordion(label='Neutral Prompt', open=False):
+            self.cfg_rescale.render()
+            with gr.Accordion(label='Prompt formatter', open=False):
+                self.neutral_prompt.render()
+                self.neutral_cond_scale.render()
+                self.aux_prompt_type.render()
+                self.append_to_prompt_button.render()
+
+    def connect_events(self, is_img2img: bool) -> None:
+        if self.is_rendered:
+            return
+
+        prompt_textbox = img2img_prompt_textbox if is_img2img else txt2img_prompt_textbox
+        self.append_to_prompt_button.click(
+            fn=lambda init_prompt, prompt, scale, prompt_type: (
+                f'{init_prompt}\n{prompt_types[prompt_type]} {prompt} :{scale}',
+                '',
+            ),
+            inputs=[prompt_textbox, self.neutral_prompt, self.neutral_cond_scale, self.aux_prompt_type],
+            outputs=[prompt_textbox, self.neutral_prompt],
+        )
+
+    def set_rendered(self, value: bool = True) -> None:
+        self.is_rendered = value
+
+    # ------------------------------------------------------------------
+    # Script interface (args / infotext / paste)
+
+    def get_components(self) -> Tuple[gr.components.Component, ...]:
+        return (self.cfg_rescale,)
+
+    def get_infotext_fields(self) -> Tuple[Tuple[gr.components.Component, str], ...]:
+        return tuple(zip(self.get_components(), ('CFG Rescale phi',)))
+
+    def get_paste_field_names(self) -> List[str]:
+        return ['CFG Rescale phi']
+
+    def get_extra_generation_params(self, args: Dict) -> Dict:
+        return {'CFG Rescale phi': args['cfg_rescale']}
+
+    def unpack_processing_args(self, cfg_rescale: float) -> Dict:
+        return {'cfg_rescale': cfg_rescale}
+
+
+# ---------------------------------------------------------------------------
+# Settings & callbacks
+# ---------------------------------------------------------------------------
+
+def on_ui_settings() -> None:
+    section = ('neutral_prompt', 'Neutral Prompt')
+    shared.opts.add_option(
+        'neutral_prompt_enabled',
+        shared.OptionInfo(True, 'Enable neutral-prompt extension', section=section),
+    )
+    global_state.is_enabled = shared.opts.data.get('neutral_prompt_enabled', True)
+    shared.opts.onchange('neutral_prompt_enabled', _update_enabled)
+
+    shared.opts.add_option(
+        'neutral_prompt_verbose',
+        shared.OptionInfo(False, 'Enable verbose debugging for neutral-prompt', section=section),
+    )
+    global_state.verbose = shared.opts.data.get('neutral_prompt_verbose', False)
+    shared.opts.onchange('neutral_prompt_verbose', _update_verbose)
+
+
+script_callbacks.on_ui_settings(on_ui_settings)
+
+
+def _update_enabled() -> None:
+    global_state.is_enabled = shared.opts.data.get('neutral_prompt_enabled', True)
+
+
+def _update_verbose() -> None:
+    global_state.verbose = shared.opts.data.get('neutral_prompt_verbose', False)
+
+
+def on_after_component(component, **_kwargs) -> None:
+    global txt2img_prompt_textbox, img2img_prompt_textbox
+    eid = getattr(component, 'elem_id', None)
+    if eid == 'txt2img_prompt':
+        txt2img_prompt_textbox = component
+    elif eid == 'img2img_prompt':
+        img2img_prompt_textbox = component
+
+
+script_callbacks.on_after_component(on_after_component)

neutral_prompt_patched/lib_neutral_prompt/xyz_grid.py

@@ -0,0 +1,42 @@
+import sys
+from types import ModuleType
+from typing import Optional
+from modules import scripts
+from lib_neutral_prompt import global_state
+
+
+def patch():
+    xyz_module = find_xyz_module()
+    if xyz_module is None:
+        print("[sd-webui-neutral-prompt]", "xyz_grid.py not found.", file=sys.stderr)
+        return
+
+    xyz_module.axis_options.extend([
+        xyz_module.AxisOption("[Neutral Prompt] CFG Rescale", int_or_float, apply_cfg_rescale()),
+    ])
+
+
+class XyzFloat(float):
+    is_xyz: bool = True
+
+
+def apply_cfg_rescale():
+    def callback(_p, v, _vs):
+        global_state.cfg_rescale = XyzFloat(v)
+
+    return callback
+
+
+def int_or_float(string):
+    try:
+        return int(string)
+    except ValueError:
+        return float(string)
+
+
+def find_xyz_module() -> Optional[ModuleType]:
+    for data in scripts.scripts_data:
+        if data.script_class.__module__ in {"xyz_grid.py", "xy_grid.py"} and hasattr(data, "module"):
+            return data.module
+
+    return None

neutral_prompt_patched/scripts/neutral_prompt.py

@@ -0,0 +1,94 @@
+from lib_neutral_prompt import global_state, hijacker, neutral_prompt_parser, prompt_parser_hijack, cfg_denoiser_hijack, ui, xyz_grid
+from modules import scripts, processing, shared
+from typing import Dict
+import functools
+
+
+class NeutralPromptScript(scripts.Script):
+    def __init__(self):
+        self.accordion_interface = None
+        self._is_img2img = False
+
+    @property
+    def is_img2img(self):
+        return self._is_img2img
+
+    @is_img2img.setter
+    def is_img2img(self, is_img2img):
+        self._is_img2img = is_img2img
+        if self.accordion_interface is None:
+            self.accordion_interface = ui.AccordionInterface(self.elem_id)
+
+    def title(self) -> str:
+        return "Neutral Prompt"
+
+    def show(self, is_img2img: bool):
+        return scripts.AlwaysVisible
+
+    def ui(self, is_img2img: bool):
+        self.hijack_composable_lora(is_img2img)
+
+        self.accordion_interface.arrange_components(is_img2img)
+        self.accordion_interface.connect_events(is_img2img)
+        self.infotext_fields = self.accordion_interface.get_infotext_fields()
+        self.paste_field_names = self.accordion_interface.get_paste_field_names()
+        self.accordion_interface.set_rendered()
+        return self.accordion_interface.get_components()
+
+    def process(self, p: processing.StableDiffusionProcessing, *args):
+        args = self.accordion_interface.unpack_processing_args(*args)
+
+        self.update_global_state(args)
+        if global_state.is_enabled:
+            p.extra_generation_params.update(self.accordion_interface.get_extra_generation_params(args))
+
+    def update_global_state(self, args: Dict):
+        if shared.state.job_no == 0:
+            global_state.is_enabled = shared.opts.data.get('neutral_prompt_enabled', True)
+
+        for k, v in args.items():
+            try:
+                getattr(global_state, k)
+            except AttributeError:
+                continue
+
+            if getattr(getattr(global_state, k), 'is_xyz', False):
+                xyz_attr = getattr(global_state, k)
+                xyz_attr.is_xyz = False
+                args[k] = xyz_attr
+                continue
+
+            if shared.state.job_no > 0:
+                continue
+
+            setattr(global_state, k, v)
+
+    def hijack_composable_lora(self, is_img2img):
+        if self.accordion_interface.is_rendered:
+            return
+
+        lora_script = None
+        script_runner = scripts.scripts_img2img if is_img2img else scripts.scripts_txt2img
+
+        for script in script_runner.alwayson_scripts:
+            if script.title().lower() == "composable lora":
+                lora_script = script
+                break
+
+        if lora_script is not None:
+            lora_script.process = functools.partial(composable_lora_process_hijack, original_function=lora_script.process)
+
+
+def composable_lora_process_hijack(p: processing.StableDiffusionProcessing, *args, original_function, **kwargs):
+    if not global_state.is_enabled:
+        return original_function(p, *args, **kwargs)
+
+    exprs = prompt_parser_hijack.parse_prompts(p.all_prompts)
+    all_prompts, p.all_prompts = p.all_prompts, prompt_parser_hijack.transpile_exprs(exprs)
+    res = original_function(p, *args, **kwargs)
+    # restore original prompts
+    p.all_prompts = all_prompts
+    return res
+
+
+xyz_grid.patch()

neutral_prompt_patched/test/perp_parser/test_affine_keyword_order.py

@@ -0,0 +1,133 @@
+"""
+Tests for affine-keyword ordering in parse_prompt.
+
+Both orderings must work correctly:
+  (A) AND_PERP ROTATE[0.125] vivid colors   ← trailing affine (original)
+  (B) ROTATE[0.125] AND_PERP vivid colors   ← leading affine  (documented)
+"""
+import unittest
+
+from lib_neutral_prompt import neutral_prompt_parser as p
+from lib_neutral_prompt.neutral_prompt_parser import ConciliationStrategy
+
+
+class TestAffineKeywordOrder(unittest.TestCase):
+
+    # ------------------------------------------------------------------ #
+    # trailing affine  (AND_PERP ROTATE[...] text)                        #
+    # ------------------------------------------------------------------ #
+
+    def test_trailing_affine_basic(self):
+        root = p.parse_root("base AND_PERP ROTATE[0.125] vivid colors :0.8")
+        self.assertEqual(len(root.children), 2)
+        self.assertEqual(root.children[0].prompt.strip(), "base")
+        self.assertIsNone(root.children[0].local_transform)
+        self.assertIsNotNone(root.children[1].local_transform)
+        self.assertEqual(root.children[1].conciliation, ConciliationStrategy.PERPENDICULAR)
+        self.assertAlmostEqual(root.children[1].weight, 0.8)
+
+    # ------------------------------------------------------------------ #
+    # leading affine  (ROTATE[...] AND_PERP text)                         #
+    # ------------------------------------------------------------------ #
+
+    def test_leading_affine_mid_prompt(self):
+        """ROTATE[...] AND_PERP must NOT be consumed into the previous prompt's text."""
+        root = p.parse_root("base ROTATE[0.125] AND_PERP vivid colors :0.8")
+        self.assertEqual(len(root.children), 2,
+            f"Expected 2 children, got {len(root.children)}: "
+            f"{[getattr(c,'prompt','composite') for c in root.children]}")
+        first, second = root.children
+        # first segment = "base " with no transform
+        self.assertIn("base", first.prompt)
+        self.assertNotIn("ROTATE", first.prompt)
+        self.assertIsNone(first.local_transform)
+        # second segment gets the transform
+        self.assertIsNotNone(second.local_transform)
+        self.assertEqual(second.conciliation, ConciliationStrategy.PERPENDICULAR)
+        self.assertAlmostEqual(second.weight, 0.8)
+
+    def test_leading_affine_at_start(self):
+        """ROTATE[...] AND_PERP as first (and only non-AND) segment."""
+        root = p.parse_root("ROTATE[0.125] AND_PERP vivid colors :0.8")
+        self.assertEqual(len(root.children), 1)
+        child = root.children[0]
+        self.assertIsNotNone(child.local_transform)
+        self.assertEqual(child.conciliation, ConciliationStrategy.PERPENDICULAR)
+        self.assertIn("vivid", child.prompt)
+        self.assertNotIn("ROTATE", child.prompt)
+
+    def test_leading_affine_with_and_salt(self):
+        root = p.parse_root("portrait SLIDE[0.05,0] AND_SALT vibrant :1.2")
+        self.assertEqual(len(root.children), 2)
+        second = root.children[1]
+        self.assertIsNotNone(second.local_transform)
+        self.assertEqual(second.conciliation, ConciliationStrategy.SALIENCE_MASK)
+
+    # ------------------------------------------------------------------ #
+    # Composed / chained affine                                            #
+    # ------------------------------------------------------------------ #
+
+    def test_leading_and_trailing_compose(self):
+        """ROTATE[a] AND_PERP SCALE[b,b] text — both affines composed."""
+        root = p.parse_root("base AND_PERP ROTATE[0.125] AND_PERP SCALE[1.5,1.5] vivid")
+        # Just check no crash and all children parse
+        self.assertGreaterEqual(len(root.children), 1)
+
+    # ------------------------------------------------------------------ #
+    # CFGRescaleFactorSingleton lifecycle                                   #
+    # ------------------------------------------------------------------ #
+
+    def test_cfg_rescale_singleton_clear(self):
+        from lib_neutral_prompt.global_state import CFGRescaleFactorSingleton as S
+        S.clear()
+        self.assertIsNone(S.get())
+        S.set(1.23)
+        self.assertAlmostEqual(S.get(), 1.23)
+        S.clear()
+        self.assertIsNone(S.get())
+
+    def test_cfg_rescale_singleton_thread_local(self):
+        import threading
+        from lib_neutral_prompt.global_state import CFGRescaleFactorSingleton as S
+        results = {}
+        def worker(val, key):
+            S.clear()
+            S.set(val)
+            import time; time.sleep(0.01)
+            results[key] = S.get()
+        threads = [threading.Thread(target=worker, args=(i * 10.0, i)) for i in range(3)]
+        for t in threads: t.start()
+        for t in threads: t.join()
+        for i in range(3):
+            self.assertAlmostEqual(results[i], i * 10.0,
+                msg=f"Thread {i} got {results[i]} expected {i*10.0}")
+
+    # ------------------------------------------------------------------ #
+    # New AND_SALT variants parse correctly                                #
+    # ------------------------------------------------------------------ #
+
+    def test_and_salt_wide_parsed(self):
+        root = p.parse_root("base AND_SALT_WIDE vivid")
+        self.assertEqual(len(root.children), 2)
+        self.assertEqual(root.children[1].conciliation,
+                         p.ConciliationStrategy.SALIENCE_MASK_WIDE)
+
+    def test_and_salt_blob_parsed(self):
+        root = p.parse_root("base AND_SALT_BLOB vivid")
+        self.assertEqual(len(root.children), 2)
+        self.assertEqual(root.children[1].conciliation,
+                         p.ConciliationStrategy.SALIENCE_MASK_BLOB)
+
+    def test_and_align_parsed(self):
+        root = p.parse_root("base AND_ALIGN_4_8 vivid")
+        self.assertEqual(len(root.children), 2)
+        self.assertIn('AND_ALIGN_4_8', root.children[1].conciliation.value)
+
+    def test_and_mask_align_parsed(self):
+        root = p.parse_root("base AND_MASK_ALIGN_4_8 vivid")
+        self.assertEqual(len(root.children), 2)
+        self.assertIn('AND_MASK_ALIGN_4_8', root.children[1].conciliation.value)
+
+
+if __name__ == '__main__':
+    unittest.main()

neutral_prompt_patched/test/perp_parser/test_affine_pipeline.py

@@ -0,0 +1,217 @@
+"""
+Integration smoke tests for the pre-noise affine pipeline.
+
+Requires PyTorch.  If torch is not installed the entire module is skipped via
+``unittest.skipUnless``, so ``unittest discover`` still exits cleanly.
+
+Mocked: A1111 modules only (modules.script_callbacks, modules.sd_samplers,
+        modules.shared).  torch itself is real — no sys.modules replacement.
+
+Tests:
+  1. Hook is a no-op when global_state.is_enabled = False.
+  2. Identity transform (angle=0) leaves x numerically unchanged.
+  3. Non-identity transform calls apply_affine_transform (verified by spy).
+  4. Prompts with no affine leave x unchanged.
+  5. Empty state does not crash.
+  6. Batch with multiple prompts does not crash.
+"""
+
+import dataclasses
+import importlib
+import math
+import sys
+import types
+import unittest
+
+# ---------------------------------------------------------------------------
+# Detect torch availability — skip the whole module if absent
+# ---------------------------------------------------------------------------
+try:
+    import importlib.util as _ilu
+    _spec = _ilu.find_spec('torch')
+    _TORCH_AVAILABLE = _spec is not None and getattr(_spec, 'origin', None) is not None
+except (ValueError, ModuleNotFoundError):
+    _TORCH_AVAILABLE = False
+
+
+# ---------------------------------------------------------------------------
+# A1111 module stubs  (installed unconditionally so cfg_denoiser_hijack can
+# be imported even when running the skip path)
+# ---------------------------------------------------------------------------
+
+def _stub(name):
+    m = types.ModuleType(name)
+    sys.modules.setdefault(name, m)
+    return sys.modules[name]
+
+for _mod_name in ('modules', 'modules.script_callbacks', 'modules.sd_samplers',
+                  'modules.shared', 'modules.prompt_parser', 'gradio'):
+    _stub(_mod_name)
+
+import modules.script_callbacks as _sc
+if not hasattr(_sc, 'on_cfg_denoiser'):
+    _sc.on_cfg_denoiser    = lambda fn: None
+if not hasattr(_sc, 'on_script_unloaded'):
+    _sc.on_script_unloaded = lambda fn: None
+
+import modules.shared as _sh
+if not hasattr(_sh, 'opts'):
+    _sh.opts = types.SimpleNamespace(
+        data={},
+        add_option=lambda *a, **k: None,
+        onchange=lambda *a, **k: None,
+        OptionInfo=lambda *a, **k: None,
+    )
+
+import modules.sd_samplers as _ss
+if not hasattr(_ss, 'cfg_denoiser'):
+    _ss.cfg_denoiser   = None
+# cfg_denoiser_hijack installs a hijack on create_sampler at import time
+if not hasattr(_ss, 'create_sampler'):
+    _ss.create_sampler = lambda *a, **k: None
+
+
+# ---------------------------------------------------------------------------
+# Repo root on sys.path
+# ---------------------------------------------------------------------------
+
+from pathlib import Path
+_REPO_ROOT = Path(__file__).resolve().parents[2]
+if str(_REPO_ROOT) not in sys.path:
+    sys.path.insert(0, str(_REPO_ROOT))
+
+
+# ---------------------------------------------------------------------------
+# Conditional imports (only when torch is available)
+# ---------------------------------------------------------------------------
+
+if _TORCH_AVAILABLE:
+    import torch
+    from lib_neutral_prompt import global_state, neutral_prompt_parser
+    from lib_neutral_prompt.cfg_denoiser_hijack import _on_cfg_denoiser
+    import lib_neutral_prompt.affine_transform as _at_mod
+
+    # -----------------------------------------------------------------------
+    # Helpers
+    # -----------------------------------------------------------------------
+
+    def _leaf(text, angle=None):
+        """LeafPrompt, optionally with a ROTATE affine (angle in turns)."""
+        transform = None
+        if angle is not None:
+            c = math.cos(angle * 2 * math.pi)
+            s = math.sin(angle * 2 * math.pi)
+            transform = torch.tensor([[c, -s, 0.0], [s, c, 0.0]])
+        return neutral_prompt_parser.LeafPrompt(1.0, None, transform, text)
+
+    def _comp(*children):
+        return neutral_prompt_parser.CompositePrompt(1.0, None, None, list(children))
+
+    @dataclasses.dataclass
+    class _FakeParams:
+        x: torch.Tensor
+
+
+# ---------------------------------------------------------------------------
+# Test class
+# ---------------------------------------------------------------------------
+
+@unittest.skipUnless(_TORCH_AVAILABLE, 'PyTorch is not installed — skipping pipeline tests')
+class TestOnCfgDenoiserSmokeTest(unittest.TestCase):
+
+    def setUp(self):
+        global_state.is_enabled = True
+        global_state.prompt_exprs = []
+        global_state.batch_cond_indices = []
+
+    def tearDown(self):
+        global_state.is_enabled = False
+        global_state.prompt_exprs = []
+        global_state.batch_cond_indices = []
+
+    # 1. disabled → x untouched
+    def test_disabled_leaves_x_unchanged(self):
+        global_state.is_enabled = False
+        x = torch.zeros(2, 4, 8, 8)
+        x[0] = 1.0
+        orig = x.clone()
+        params = _FakeParams(x=x.clone())
+        global_state.prompt_exprs        = [_comp(_leaf("base"), _leaf("perp", 0.125))]
+        global_state.batch_cond_indices  = [[(0, 1.0), (1, 1.0)]]
+        _on_cfg_denoiser(params)
+        self.assertTrue(torch.equal(params.x, orig), "Disabled hook must not modify x")
+
+    # 2. identity transform → x numerically unchanged
+    def test_identity_transform_no_change(self):
+        x = torch.randn(2, 4, 8, 8)
+        orig = x.clone()
+        params = _FakeParams(x=x.clone())
+        global_state.prompt_exprs        = [_comp(_leaf("base"), _leaf("perp", 0))]
+        global_state.batch_cond_indices  = [[(0, 1.0), (1, 1.0)]]
+        _on_cfg_denoiser(params)
+        self.assertTrue(torch.allclose(params.x, orig, atol=1e-5),
+                        "Identity affine must not change x")
+
+    # 3. non-identity → apply_affine_transform is called (spy)
+    def test_nonidentity_calls_apply_affine_transform(self):
+        x = torch.zeros(2, 4, 8, 8)
+        x[1] = torch.randn(4, 8, 8)
+        params = _FakeParams(x=x.clone())
+        global_state.prompt_exprs        = [_comp(_leaf("base"), _leaf("perp", 0.25))]
+        global_state.batch_cond_indices  = [[(0, 1.0), (1, 1.0)]]
+
+        _real = _at_mod.apply_affine_transform
+        calls = []
+        def _spy(tensor, affine, mode='bilinear'):
+            calls.append(True)
+            return _real(tensor, affine, mode)
+
+        _at_mod.apply_affine_transform = _spy
+        try:
+            _on_cfg_denoiser(params)
+        finally:
+            _at_mod.apply_affine_transform = _real
+
+        self.assertGreater(len(calls), 0,
+                           "apply_affine_transform must be called for non-identity transform")
+
+    # 4. no affine on any child → x unchanged
+    def test_no_affine_no_change(self):
+        x = torch.randn(2, 4, 8, 8)
+        orig = x.clone()
+        params = _FakeParams(x=x.clone())
+        global_state.prompt_exprs        = [_comp(_leaf("base"), _leaf("perp"))]
+        global_state.batch_cond_indices  = [[(0, 1.0), (1, 1.0)]]
+        _on_cfg_denoiser(params)
+        self.assertTrue(torch.allclose(params.x, orig, atol=1e-5),
+                        "No affine → x must not change")
+
+    # 5. empty state → no crash
+    def test_empty_state_no_crash(self):
+        params = _FakeParams(x=torch.randn(1, 4, 8, 8))
+        global_state.prompt_exprs = []
+        global_state.batch_cond_indices = []
+        try:
+            _on_cfg_denoiser(params)
+        except Exception as e:
+            self.fail(f"_on_cfg_denoiser raised with empty state: {e}")
+
+    # 6. two batch entries → no crash
+    def test_batch_multiple_prompts_no_crash(self):
+        params = _FakeParams(x=torch.zeros(4, 4, 8, 8))
+        global_state.prompt_exprs = [
+            _comp(_leaf("base_a"), _leaf("perp_a", 0.25)),
+            _comp(_leaf("base_b"), _leaf("perp_b", 0.125)),
+        ]
+        global_state.batch_cond_indices = [
+            [(0, 1.0), (1, 1.0)],
+            [(2, 1.0), (3, 1.0)],
+        ]
+        try:
+            _on_cfg_denoiser(params)
+        except Exception as e:
+            self.fail(f"Multi-prompt batch raised: {e}")
+
+
+if __name__ == '__main__':
+    unittest.main()

neutral_prompt_patched/test/perp_parser/test_basic_parser.py

@@ -0,0 +1,122 @@
+import unittest
+import pathlib
+import sys
+sys.path.append(str(pathlib.Path(__file__).parent.parent.parent))
+from lib_neutral_prompt import neutral_prompt_parser
+
+
+class TestPromptParser(unittest.TestCase):
+    def setUp(self):
+        self.simple_prompt = neutral_prompt_parser.parse_root("hello :1.0")
+        self.and_prompt = neutral_prompt_parser.parse_root("hello AND goodbye :2.0")
+        self.and_perp_prompt = neutral_prompt_parser.parse_root("hello :1.0 AND_PERP goodbye :2.0")
+        self.and_salt_prompt = neutral_prompt_parser.parse_root("hello :1.0 AND_SALT goodbye :2.0")
+        self.nested_and_perp_prompt = neutral_prompt_parser.parse_root("hello :1.0 AND_PERP [goodbye :2.0 AND_PERP welcome :3.0]")
+        self.nested_and_salt_prompt = neutral_prompt_parser.parse_root("hello :1.0 AND_SALT [goodbye :2.0 AND_SALT welcome :3.0]")
+        self.invalid_weight = neutral_prompt_parser.parse_root("hello :not_a_float")
+
+    def test_simple_prompt_child_count(self):
+        self.assertEqual(len(self.simple_prompt.children), 1)
+
+    def test_simple_prompt_child_weight(self):
+        self.assertEqual(self.simple_prompt.children[0].weight, 1.0)
+
+    def test_simple_prompt_child_prompt(self):
+        self.assertEqual(self.simple_prompt.children[0].prompt, "hello ")
+
+    def test_square_weight_prompt(self):
+        prompt = "a [b c d e : f g h :1.5]"
+        parsed = neutral_prompt_parser.parse_root(prompt)
+        self.assertEqual(parsed.children[0].prompt, prompt)
+
+        composed_prompt = f"{prompt} AND_PERP other prompt"
+        parsed = neutral_prompt_parser.parse_root(composed_prompt)
+        self.assertEqual(parsed.children[0].prompt, prompt)
+
+    def test_and_prompt_child_count(self):
+        self.assertEqual(len(self.and_prompt.children), 2)
+
+    def test_and_prompt_child_weights_and_prompts(self):
+        self.assertEqual(self.and_prompt.children[0].weight, 1.0)
+        self.assertEqual(self.and_prompt.children[0].prompt, "hello ")
+        self.assertEqual(self.and_prompt.children[1].weight, 2.0)
+        self.assertEqual(self.and_prompt.children[1].prompt, " goodbye ")
+
+    def test_and_perp_prompt_child_count(self):
+        self.assertEqual(len(self.and_perp_prompt.children), 2)
+
+    def test_and_perp_prompt_child_types(self):
+        self.assertIsInstance(self.and_perp_prompt.children[0], neutral_prompt_parser.LeafPrompt)
+        self.assertIsInstance(self.and_perp_prompt.children[1], neutral_prompt_parser.LeafPrompt)
+
+    def test_and_perp_prompt_nested_child(self):
+        nested_child = self.and_perp_prompt.children[1]
+        self.assertEqual(nested_child.weight, 2.0)
+        self.assertEqual(nested_child.prompt.strip(), "goodbye")
+
+    def test_nested_and_perp_prompt_child_count(self):
+        self.assertEqual(len(self.nested_and_perp_prompt.children), 2)
+
+    def test_nested_and_perp_prompt_child_types(self):
+        self.assertIsInstance(self.nested_and_perp_prompt.children[0], neutral_prompt_parser.LeafPrompt)
+        self.assertIsInstance(self.nested_and_perp_prompt.children[1], neutral_prompt_parser.CompositePrompt)
+
+    def test_nested_and_perp_prompt_nested_child_types(self):
+        nested_child = self.nested_and_perp_prompt.children[1].children[0]
+        self.assertIsInstance(nested_child, neutral_prompt_parser.LeafPrompt)
+        nested_child = self.nested_and_perp_prompt.children[1].children[1]
+        self.assertIsInstance(nested_child, neutral_prompt_parser.LeafPrompt)
+
+    def test_nested_and_perp_prompt_nested_child(self):
+        nested_child = self.nested_and_perp_prompt.children[1].children[1]
+        self.assertEqual(nested_child.weight, 3.0)
+        self.assertEqual(nested_child.prompt.strip(), "welcome")
+
+    def test_invalid_weight_child_count(self):
+        self.assertEqual(len(self.invalid_weight.children), 1)
+
+    def test_invalid_weight_child_weight(self):
+        self.assertEqual(self.invalid_weight.children[0].weight, 1.0)
+
+    def test_invalid_weight_child_prompt(self):
+        self.assertEqual(self.invalid_weight.children[0].prompt, "hello :not_a_float")
+
+    def test_and_salt_prompt_child_count(self):
+        self.assertEqual(len(self.and_salt_prompt.children), 2)
+
+    def test_and_salt_prompt_child_types(self):
+        self.assertIsInstance(self.and_salt_prompt.children[0], neutral_prompt_parser.LeafPrompt)
+        self.assertIsInstance(self.and_salt_prompt.children[1], neutral_prompt_parser.LeafPrompt)
+
+    def test_and_salt_prompt_nested_child(self):
+        nested_child = self.and_salt_prompt.children[1]
+        self.assertEqual(nested_child.weight, 2.0)
+        self.assertEqual(nested_child.prompt.strip(), "goodbye")
+
+    def test_nested_and_salt_prompt_child_count(self):
+        self.assertEqual(len(self.nested_and_salt_prompt.children), 2)
+
+    def test_nested_and_salt_prompt_child_types(self):
+        self.assertIsInstance(self.nested_and_salt_prompt.children[0], neutral_prompt_parser.LeafPrompt)
+        self.assertIsInstance(self.nested_and_salt_prompt.children[1], neutral_prompt_parser.CompositePrompt)
+
+    def test_nested_and_salt_prompt_nested_child_types(self):
+        nested_child = self.nested_and_salt_prompt.children[1].children[0]
+        self.assertIsInstance(nested_child, neutral_prompt_parser.LeafPrompt)
+        nested_child = self.nested_and_salt_prompt.children[1].children[1]
+        self.assertIsInstance(nested_child, neutral_prompt_parser.LeafPrompt)
+
+    def test_nested_and_salt_prompt_nested_child(self):
+        nested_child = self.nested_and_salt_prompt.children[1].children[1]
+        self.assertEqual(nested_child.weight, 3.0)
+        self.assertEqual(nested_child.prompt.strip(), "welcome")
+
+    def test_start_with_prompt_editing(self):
+        prompt = "[(long shot:1.2):0.1] detail.."
+        res = neutral_prompt_parser.parse_root(prompt)
+        self.assertEqual(res.children[0].weight, 1.0)
+        self.assertEqual(res.children[0].prompt, prompt)
+
+
+if __name__ == '__main__':
+    unittest.main()

neutral_prompt_patched/test/perp_parser/test_malicious_parser.py

@@ -0,0 +1,182 @@
+import unittest
+import pathlib
+import sys
+sys.path.append(str(pathlib.Path(__file__).parent.parent.parent))
+from lib_neutral_prompt import neutral_prompt_parser
+
+
+class TestMaliciousPromptParser(unittest.TestCase):
+    def setUp(self):
+        self.parser = neutral_prompt_parser
+
+    def test_empty(self):
+        result = self.parser.parse_root("")
+        self.assertEqual(result.children[0].prompt, "")
+        self.assertEqual(result.children[0].weight, 1.0)
+
+    def test_zero_weight(self):
+        result = self.parser.parse_root("hello :0.0")
+        self.assertEqual(result.children[0].weight, 0.0)
+
+    def test_mixed_positive_and_negative_weights(self):
+        result = self.parser.parse_root("hello :1.0 AND goodbye :-2.0")
+        self.assertEqual(result.children[0].weight, 1.0)
+        self.assertEqual(result.children[1].weight, -2.0)
+
+    def test_debalanced_square_brackets(self):
+        prompt = "a [ b " * 100
+        result = self.parser.parse_root(prompt)
+        self.assertEqual(result.children[0].prompt, prompt)
+
+        prompt = "a ] b " * 100
+        result = self.parser.parse_root(prompt)
+        self.assertEqual(result.children[0].prompt, prompt)
+
+        repeats = 10
+        prompt = "a [ [ b AND c ] " * repeats
+        result = self.parser.parse_root(prompt)
+        self.assertEqual([x.prompt for x in result.children], ["a [[ b ", *[" c ] a [[ b "] * (repeats - 1), " c ]"])
+
+        repeats = 10
+        prompt = "a [ b AND c ] ] " * repeats
+        result = self.parser.parse_root(prompt)
+        self.assertEqual([x.prompt for x in result.children], ["a [ b ", *[" c ]] a [ b "] * (repeats - 1), " c ]]"])
+
+    def test_erroneous_syntax(self):
+        result = self.parser.parse_root("hello :1.0 AND_PERP [goodbye :2.0")
+        self.assertEqual(result.children[0].weight, 1.0)
+        self.assertEqual(result.children[1].prompt, "[goodbye ")
+        self.assertEqual(result.children[1].weight, 2.0)
+
+        result = self.parser.parse_root("hello :1.0 AND_PERP goodbye :2.0]")
+        self.assertEqual(result.children[0].weight, 1.0)
+        self.assertEqual(result.children[1].prompt, " goodbye ")
+
+        result = self.parser.parse_root("hello :1.0 AND_PERP goodbye] :2.0")
+        self.assertEqual(result.children[1].prompt, " goodbye]")
+        self.assertEqual(result.children[1].weight, 2.0)
+
+        result = self.parser.parse_root("hello :1.0 AND_PERP a [ goodbye :2.0")
+        self.assertEqual(result.children[1].weight, 2.0)
+        self.assertEqual(result.children[1].prompt, " a [ goodbye ")
+
+        result = self.parser.parse_root("hello :1.0 AND_PERP AND goodbye :2.0")
+        self.assertEqual(result.children[0].weight, 1.0)
+        self.assertEqual(result.children[2].prompt, " goodbye ")
+
+    def test_huge_number_of_prompt_parts(self):
+        result = self.parser.parse_root(" AND ".join(f"hello{i} :{i}" for i in range(10**4)))
+        self.assertEqual(len(result.children), 10**4)
+
+    def test_prompt_ending_with_weight(self):
+        result = self.parser.parse_root("hello :1.0 AND :2.0")
+        self.assertEqual(result.children[0].weight, 1.0)
+        self.assertEqual(result.children[1].prompt, "")
+        self.assertEqual(result.children[1].weight, 2.0)
+
+    def test_huge_input_string(self):
+        big_string = "hello :1.0 AND " * 10**4
+        result = self.parser.parse_root(big_string)
+        self.assertEqual(len(result.children), 10**4 + 1)
+
+    def test_deeply_nested_prompt(self):
+        deeply_nested_prompt = "hello :1.0" + " AND_PERP [goodbye :2.0" * 100 + "]" * 100
+        result = self.parser.parse_root(deeply_nested_prompt)
+        self.assertIsInstance(result.children[1], neutral_prompt_parser.CompositePrompt)
+
+    def test_complex_nested_prompts(self):
+        complex_prompt = "hello :1.0 AND goodbye :2.0 AND_PERP [welcome :3.0 AND farewell :4.0 AND_PERP greetings:5.0]"
+        result = self.parser.parse_root(complex_prompt)
+        self.assertEqual(result.children[0].weight, 1.0)
+        self.assertEqual(result.children[1].weight, 2.0)
+        self.assertEqual(result.children[2].children[0].weight, 3.0)
+        self.assertEqual(result.children[2].children[1].weight, 4.0)
+        self.assertEqual(result.children[2].children[2].weight, 5.0)
+
+    def test_string_with_random_characters(self):
+        random_chars = "ASDFGHJKL:@#$/.,|}{><~`12[3]456AND_PERP7890"
+        try:
+            self.parser.parse_root(random_chars)
+        except Exception:
+            self.fail("parse_root couldn't handle a string with random characters.")
+
+    def test_string_with_unexpected_symbols(self):
+        unexpected_symbols = "hello :1.0 AND $%^&*()goodbye :2.0"
+        try:
+            self.parser.parse_root(unexpected_symbols)
+        except Exception:
+            self.fail("parse_root couldn't handle a string with unexpected symbols.")
+
+    def test_string_with_unconventional_structure(self):
+        unconventional_structure = "hello :1.0 AND_PERP :2.0 AND [goodbye]"
+        try:
+            self.parser.parse_root(unconventional_structure)
+        except Exception:
+            self.fail("parse_root couldn't handle a string with unconventional structure.")
+
+    def test_string_with_mixed_alphabets_and_numbers(self):
+        mixed_alphabets_and_numbers = "123hello :1.0 AND goodbye456 :2.0"
+        try:
+            self.parser.parse_root(mixed_alphabets_and_numbers)
+        except Exception:
+            self.fail("parse_root couldn't handle a string with mixed alphabets and numbers.")
+
+    def test_string_with_nested_brackets(self):
+        nested_brackets = "hello :1.0 AND [goodbye :2.0 AND [[welcome :3.0]]]"
+        try:
+            self.parser.parse_root(nested_brackets)
+        except Exception:
+            self.fail("parse_root couldn't handle a string with nested brackets.")
+
+    def test_unmatched_opening_braces(self):
+        unmatched_opening_braces = "hello [[[[[[[[[ :1.0 AND_PERP goodbye :2.0"
+        try:
+            self.parser.parse_root(unmatched_opening_braces)
+        except Exception:
+            self.fail("parse_root couldn't handle a string with unmatched opening braces.")
+
+    def test_unmatched_closing_braces(self):
+        unmatched_closing_braces = "hello :1.0 AND_PERP goodbye ]]]]]]]]] :2.0"
+        try:
+            self.parser.parse_root(unmatched_closing_braces)
+        except Exception:
+            self.fail("parse_root couldn't handle a string with unmatched closing braces.")
+
+    def test_repeating_colons(self):
+        repeating_colons = "hello ::::::: :1.0 AND_PERP goodbye :::: :2.0"
+        try:
+            self.parser.parse_root(repeating_colons)
+        except Exception:
+            self.fail("parse_root couldn't handle a string with repeating colons.")
+
+    def test_excessive_whitespace(self):
+        excessive_whitespace = "hello    :1.0  AND_PERP     goodbye  :2.0"
+        try:
+            self.parser.parse_root(excessive_whitespace)
+        except Exception:
+            self.fail("parse_root couldn't handle a string with excessive whitespace.")
+
+    def test_repeating_AND_keyword(self):
+        repeating_AND_keyword = "hello :1.0 AND AND AND AND AND goodbye :2.0"
+        try:
+            self.parser.parse_root(repeating_AND_keyword)
+        except Exception:
+            self.fail("parse_root couldn't handle a string with repeating AND keyword.")
+
+    def test_repeating_AND_PERP_keyword(self):
+        repeating_AND_PERP_keyword = "hello :1.0 AND_PERP AND_PERP AND_PERP AND_PERP goodbye :2.0"
+        try:
+            self.parser.parse_root(repeating_AND_PERP_keyword)
+        except Exception:
+            self.fail("parse_root couldn't handle a string with repeating AND_PERP keyword.")
+
+    def test_square_weight_prompt(self):
+        prompt = "AND_PERP [weighted] you thought it was the end"
+        try:
+            self.parser.parse_root(prompt)
+        except Exception:
+            self.fail("parse_root couldn't handle a string starting with a square-weighted sub-prompt.")
+
+
+if __name__ == '__main__':
+    unittest.main()

prompt-fusion-extension-main/.gitignore

@@ -0,0 +1,3 @@
+/venv/
+/.idea/
+__pycache__/

prompt-fusion-extension-main/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2003
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

prompt-fusion-extension-main/lib_prompt_fusion/ast_nodes.py

@@ -0,0 +1,307 @@
+import math
+from lib_prompt_fusion import interpolation_functions
+from lib_prompt_fusion.t_scaler import scale_t
+from lib_prompt_fusion import interpolation_tensor
+
+
+class ListExpression:
+    def __init__(self, expressions):
+        self.__expressions = expressions
+
+    def extend_tensor(self, tensor_builder, steps_range, total_steps, context, is_hires, use_old_scheduling):
+        if not self.__expressions:
+            return
+
+        def expr_extend_tensor(expr):
+            expr.extend_tensor(tensor_builder, steps_range, total_steps, context, is_hires, use_old_scheduling)
+
+        expr_extend_tensor(self.__expressions[0])
+        for expression in self.__expressions[1:]:
+            tensor_builder.append(' ')
+            expr_extend_tensor(expression)
+
+
+class InterpolationExpression:
+    @staticmethod
+    def create(exprs, steps, function_name):
+        if function_name == "mean":
+            return AverageExpression(exprs, steps)
+
+        max_len = min(len(exprs), len(steps))
+        exprs = exprs[:max_len]
+        steps = steps[:max_len]
+
+        return InterpolationExpression(exprs, steps, function_name)
+
+    def __init__(self, expressions, steps, function_name=None):
+        assert len(expressions) >= 2
+        assert len(steps) == len(expressions), 'the number of steps must be the same as the number of expressions'
+        self.__expressions = expressions
+        self.__steps = steps
+        self.__function_name = function_name if function_name is not None else 'linear'
+
+    def extend_tensor(self, tensor_builder, steps_range, total_steps, context, is_hires, use_old_scheduling):
+        def tensor_updater(expr):
+            return lambda t: expr.extend_tensor(t, steps_range, total_steps, context, is_hires, use_old_scheduling)
+
+        tensor_builder.extrude(
+            [tensor_updater(expr) for expr in self.__expressions],
+            self.get_interpolation_function(steps_range, total_steps, context, is_hires, use_old_scheduling))
+
+    def get_interpolation_function(self, steps_range, total_steps, context, is_hires, use_old_scheduling):
+        steps = list(self.__steps)
+        if steps[0] is None:
+            steps[0] = LiftExpression(str(steps_range[0] - 1))
+        if steps[-1] is None:
+            steps[-1] = LiftExpression(str(steps_range[1] - 1))
+
+        for i, step in enumerate(steps):
+            if step is None:
+                continue
+
+            step = _eval_int_or_float(step, steps_range, total_steps, context, is_hires, use_old_scheduling)
+
+            if use_old_scheduling and 0 < step < 1:
+                step *= total_steps
+            elif not use_old_scheduling and isinstance(step, float):
+                step = (step - int(is_hires)) * total_steps
+            else:
+                step += 1
+
+            steps[i] = int(step)
+
+        i = 1
+        while i < len(steps):
+            none_len = 0
+            while steps[i + none_len] is None:
+                none_len += 1
+
+            min_step, max_step = steps[i - 1], steps[i + none_len]
+
+            for j in range(none_len):
+                steps[i + j] = min_step + (max_step - min_step) * (j + 1) / (none_len + 1)
+
+            i += 1 + none_len
+
+        interpolation_function = {
+            'linear': interpolation_functions.compute_linear,
+            'bezier': interpolation_functions.compute_bezier,
+            'catmull': interpolation_functions.compute_catmull,
+        }[self.__function_name]
+
+        def steps_scale_t(conds, params: interpolation_tensor.InterpolationParams):
+            scaled_t = (params.t * total_steps - steps[0]) / max(1, steps[-1] - steps[0])
+            scaled_t = scale_t(scaled_t, steps)
+
+            new_params = interpolation_tensor.InterpolationParams(scaled_t, *params[1:])
+            return interpolation_function(conds, new_params)
+
+        return steps_scale_t
+
+
+class AverageExpression:
+    def __init__(self, expressions, weights):
+        if len(expressions) < len(weights):
+            raise ValueError
+
+        self.__expressions = expressions
+        self.__weights = weights
+
+    def extend_tensor(self, tensor_builder, steps_range, total_steps, context, is_hires, use_old_scheduling):
+        def tensor_updater(expr):
+            return lambda t: expr.extend_tensor(t, steps_range, total_steps, context, is_hires, use_old_scheduling)
+
+        tensor_builder.extrude(
+            [tensor_updater(expr) for expr in self.__expressions],
+            self.get_interpolation_function(steps_range, total_steps, context, is_hires, use_old_scheduling))
+
+    def get_interpolation_function(self, steps_range, total_steps, context, is_hires, use_old_scheduling):
+        weights = [
+            _eval_int_or_float(weight, steps_range, total_steps, context, is_hires, use_old_scheduling) if weight is not None else None
+            for weight in self.__weights
+        ]
+        explicit_weights = [weight for weight in weights if weight is not None]
+        weights = [
+            weight / sum(explicit_weights) * len(explicit_weights) / len(self.__expressions)
+            if weight is not None
+            else 1 / len(self.__expressions)
+            for weight in weights
+        ]
+        weights.extend(1 / len(self.__expressions) for _ in range(len(self.__expressions) - len(weights)))
+
+        def interpolation_function(conds, _params):
+            total = None
+            for cond, weight in zip(conds, weights):
+                cond *= weight
+                if total is None:
+                    total = cond
+                else:
+                    total += cond
+
+            return total
+
+        return interpolation_function
+
+
+class AlternationExpression:
+    def __init__(self, expressions, speed):
+        self.__expressions = expressions
+        self.__speed = speed
+
+    def extend_tensor(self, tensor_builder, steps_range, total_steps, context, is_hires, use_old_scheduling):
+        if self.__speed is None:
+            speed = None
+        else:
+            speed = _eval_int_or_float(self.__speed, steps_range, total_steps, context, is_hires, use_old_scheduling)
+
+        if speed is None:
+            tensor_builder.append('[')
+            for expr_i, expr in enumerate(self.__expressions):
+                if expr_i >= 1:
+                    tensor_builder.append('|')
+                expr.extend_tensor(tensor_builder, steps_range, total_steps, context, is_hires, use_old_scheduling)
+            tensor_builder.append(']')
+            return
+
+        def tensor_updater(expr):
+            return lambda t: expr.extend_tensor(t, steps_range, total_steps, context, is_hires, use_old_scheduling)
+
+        exprs = self.__expressions + [self.__expressions[0]]
+
+        tensor_builder.extrude(
+            [tensor_updater(expr) for expr in exprs],
+            self.get_interpolation_function(speed, exprs, steps_range, total_steps))
+
+    def get_interpolation_function(self, speed, exprs, steps_range, total_steps):
+        def compute_wrap(control_points, params: interpolation_tensor.InterpolationParams):
+            wrapped_t = math.fmod((params.t * total_steps - steps_range[0]) / (len(exprs) - 1) * speed, 1.0)
+            if wrapped_t < 0:
+                wrapped_t = wrapped_t + 1
+            new_params = interpolation_tensor.InterpolationParams(wrapped_t, *params[1:])
+            return interpolation_functions.compute_linear(control_points, new_params)
+
+        return compute_wrap
+
+
+class EditingExpression:
+    def __init__(self, expressions, step):
+        assert 1 <= len(expressions) <= 2
+        self.__expressions = expressions
+        self.__step = step
+
+    def extend_tensor(self, tensor_builder, steps_range, total_steps, context, is_hires, use_old_scheduling):
+        if self.__step is None:
+            tensor_builder.append('[')
+            for expr_i, expr in enumerate(self.__expressions):
+                expr.extend_tensor(tensor_builder, steps_range, total_steps, context, is_hires, use_old_scheduling)
+                tensor_builder.append(':')
+            tensor_builder.append(']')
+            return
+
+        step = _eval_int_or_float(self.__step, steps_range, total_steps, context, is_hires, use_old_scheduling)
+        step_int = step
+        if use_old_scheduling and 0 < step < 1:
+            step_int *= total_steps
+        elif not use_old_scheduling and isinstance(step, float):
+            step_int = (step_int - int(is_hires)) * total_steps
+        else:
+            step_int += 1
+
+        step_int = int(step_int)
+
+        tensor_builder.append('[')
+        for expr_i, expr in enumerate(self.__expressions):
+            expr_steps_range = (steps_range[0], step_int) if expr_i == 0 and len(self.__expressions) >= 2 else (step_int, steps_range[1])
+            expr.extend_tensor(tensor_builder, expr_steps_range, total_steps, context, is_hires, use_old_scheduling)
+            tensor_builder.append(':')
+
+        tensor_builder.append(f'{step}]')
+
+
+class WeightedExpression:
+    def __init__(self, nested, weight=None, positive=True):
+        self.__nested = nested
+        if not positive:
+            assert weight is None
+
+        self.__weight = weight
+        self.__positive = positive
+
+    def extend_tensor(self, tensor_builder, steps_range, total_steps, context, is_hires, use_old_scheduling):
+        open_bracket, close_bracket = ('(', ')') if self.__positive else ('[', ']')
+        tensor_builder.append(open_bracket)
+        self.__nested.extend_tensor(tensor_builder, steps_range, total_steps, context, is_hires, use_old_scheduling)
+
+        if self.__weight is not None:
+            tensor_builder.append(':')
+            self.__weight.extend_tensor(tensor_builder, steps_range, total_steps, context, is_hires, use_old_scheduling)
+
+        tensor_builder.append(close_bracket)
+
+
+class WeightInterpolationExpression:
+    def __init__(self, nested, weight_begin, weight_end):
+        self.__nested = nested
+        self.__weight_begin = weight_begin if weight_begin is not None else LiftExpression(str(1.))
+        self.__weight_end = weight_end if weight_end is not None else LiftExpression(str(1.))
+
+    def extend_tensor(self, tensor_builder, steps_range, total_steps, context, is_hires, use_old_scheduling):
+        steps_range_size = steps_range[1] - steps_range[0]
+
+        weight_begin = _eval_int_or_float(self.__weight_begin, steps_range, total_steps, context, is_hires, use_old_scheduling)
+        weight_end = _eval_int_or_float(self.__weight_end, steps_range, total_steps, context, is_hires, use_old_scheduling)
+
+        for i in range(steps_range_size):
+            step = i + steps_range[0]
+
+            weight = weight_begin + (weight_end - weight_begin) * (i / max(steps_range_size - 1, 1))
+            weight_step_expr = WeightedExpression(self.__nested, LiftExpression(str(weight)))
+            if step > steps_range[0]:
+                weight_step_expr = EditingExpression([weight_step_expr], LiftExpression(str(step - 1)))
+            if step + 1 < steps_range[1]:
+                weight_step_expr = EditingExpression([weight_step_expr, ListExpression([])], LiftExpression(str(step)))
+
+            weight_step_expr.extend_tensor(tensor_builder, steps_range, total_steps, context, is_hires, use_old_scheduling)
+
+
+class DeclarationExpression:
+    def __init__(self, symbol, parameters, value, target):
+        self.__symbol = symbol
+        self.__value = value
+        self.__target = target
+        self.__parameters = parameters
+
+    def extend_tensor(self, tensor_builder, steps_range, total_steps, context, is_hires, use_old_scheduling):
+        updated_context = dict(context)
+        updated_context[self.__symbol] = (self.__value, self.__parameters)
+        self.__target.extend_tensor(tensor_builder, steps_range, total_steps, updated_context, is_hires, use_old_scheduling)
+
+
+class SubstitutionExpression:
+    def __init__(self, symbol, arguments):
+        self.__symbol = symbol
+        self.__arguments = arguments
+
+    def extend_tensor(self, tensor_builder, steps_range, total_steps, context, is_hires, use_old_scheduling):
+        updated_context = dict(context)
+        nested, parameters = context[self.__symbol]
+        for argument, parameter in zip(self.__arguments, parameters):
+            updated_context[parameter] = argument, []
+        nested.extend_tensor(tensor_builder, steps_range, total_steps, updated_context, is_hires, use_old_scheduling)
+
+
+class LiftExpression:
+    def __init__(self, value):
+        self.__value = value
+
+    def extend_tensor(self, tensor_builder, *_args, **_kwargs):
+        tensor_builder.append(self.__value)
+
+
+def _eval_int_or_float(expression, steps_range, total_steps, context, is_hires, use_old_scheduling):
+    mock_database = ['']
+    expression.extend_tensor(interpolation_tensor.InterpolationTensorBuilder(prompt_database=mock_database), steps_range, total_steps, context, is_hires, use_old_scheduling)
+    try:
+        return int(mock_database[0])
+    except ValueError:
+        return float(mock_database[0])

prompt-fusion-extension-main/lib_prompt_fusion/empty_cond.py

@@ -0,0 +1,19 @@
+from lib_prompt_fusion import interpolation_tensor
+
+
+_empty_cond = None
+
+
+def get():
+    return _empty_cond
+
+
+def init(model):
+    global _empty_cond
+    cond = model.get_learned_conditioning([''])
+    if isinstance(cond, dict):
+        cond = interpolation_tensor.DictCondWrapper({k: v[0] for k, v in cond.items()})
+    else:
+        cond = interpolation_tensor.TensorCondWrapper(cond[0])
+
+    _empty_cond = cond

prompt-fusion-extension-main/lib_prompt_fusion/geometries.py

@@ -0,0 +1,33 @@
+import math
+import torch
+from lib_prompt_fusion import interpolation_tensor
+
+
+def slerp_geometry(control_points, params: interpolation_tensor.InterpolationParams):
+    p0, p1 = control_points
+    p0_norm = torch.linalg.norm(p0)
+    p1_norm = torch.linalg.norm(p1)
+
+    similarity = torch.sum((p0 / p0_norm) * (p1 / p1_norm))
+    similarity = min(1., max(-1., float(similarity)))
+    if similarity <= params.slerp_epsilon - 1 or similarity >= 1 - params.slerp_epsilon:
+        return linear_geometry(control_points, params)
+
+    angle = math.acos(float(similarity)) / 2
+
+    slerp_t = angle * (2 * params.t - 1)
+    slerp_t = math.tan(slerp_t) / math.tan(angle)
+    slerp_t = (slerp_t + 1) / 2
+
+    normalized_p1 = p1 / p1_norm * p0_norm
+    slerp_p = p0 + (normalized_p1 - p0) * slerp_t
+    slerp_p = slerp_p / torch.linalg.norm(slerp_p) * (p0_norm + (p1_norm - p0_norm) * params.t)
+
+    lerp_p = linear_geometry(control_points, params)
+    return lerp_p + (slerp_p - lerp_p) * params.slerp_scale
+
+
+def linear_geometry(control_points, params: interpolation_tensor.InterpolationParams):
+    p0, p1 = control_points
+    res = p0 + (p1 - p0) * params.t
+    return res

prompt-fusion-extension-main/lib_prompt_fusion/global_state.py

@@ -0,0 +1,28 @@
+from typing import List, Optional
+from modules import shared, prompt_parser
+from lib_prompt_fusion import empty_cond
+
+
+old_webui_is_negative: bool = False
+negative_schedules: Optional[List[prompt_parser.ScheduledPromptConditioning]] = None
+negative_schedules_hires: Optional[List[prompt_parser.ScheduledPromptConditioning]] = None
+
+
+def get_origin_cond_at(step: int, is_hires: bool = False):
+    fallback_schedules = negative_schedules_hires if is_hires else negative_schedules
+    if not fallback_schedules or not shared.opts.data.get('prompt_fusion_slerp_negative_origin', False):
+        return empty_cond.get()
+
+    for schedule in fallback_schedules:
+        if schedule.end_at_step >= step:
+            return schedule.cond
+
+    return empty_cond.get()
+
+
+def get_slerp_scale():
+    return shared.opts.data.get('prompt_fusion_slerp_scale', 0.0)
+
+
+def get_slerp_epsilon():
+    return shared.opts.data.get('prompt_fusion_slerp_epsilon', 0.0001)

prompt-fusion-extension-main/lib_prompt_fusion/hijacker.py

@@ -0,0 +1,34 @@
+class ModuleHijacker:
+    def __init__(self, module):
+        self.__module = module
+        self.__original_functions = dict()
+
+    def hijack(self, attribute):
+        if attribute not in self.__original_functions:
+            self.__original_functions[attribute] = getattr(self.__module, attribute)
+
+        def decorator(function):
+            def wrapper(*args, **kwargs):
+                return function(*args, **kwargs, original_function=self.__original_functions[attribute])
+
+            setattr(self.__module, attribute, wrapper)
+            return function
+
+        return decorator
+
+    def reset_module(self):
+        for attribute, original_function in self.__original_functions.items():
+            setattr(self.__module, attribute, original_function)
+
+        self.__original_functions.clear()
+
+    @staticmethod
+    def install_or_get(module, hijacker_attribute, register_uninstall=lambda _callback: None):
+        if not hasattr(module, hijacker_attribute):
+            module_hijacker = ModuleHijacker(module)
+            setattr(module, hijacker_attribute, module_hijacker)
+            register_uninstall(lambda: delattr(module, hijacker_attribute))
+            register_uninstall(module_hijacker.reset_module)
+            return module_hijacker
+        else:
+            return getattr(module, hijacker_attribute)

prompt-fusion-extension-main/lib_prompt_fusion/interpolation_functions.py

@@ -0,0 +1,87 @@
+import copy
+import math
+from lib_prompt_fusion import interpolation_tensor, geometries
+
+
+def compute_linear(control_points, params: interpolation_tensor.InterpolationParams):
+    if len(control_points) <= 2:
+        return geometries.slerp_geometry(control_points, params)
+    else:
+        target_curve = min(int(params.t * (len(control_points) - 1)), len(control_points) - 1)
+        cp0 = control_points[target_curve]
+        cp1 = control_points[target_curve + 1] if target_curve + 1 < len(control_points) else control_points[-1]
+        new_params = interpolation_tensor.InterpolationParams(math.fmod(params.t * (len(control_points) - 1), 1.), *params[1:])
+        return geometries.slerp_geometry([cp0, cp1], new_params)
+
+
+def compute_bezier(control_points, params: interpolation_tensor.InterpolationParams):
+    def compute_casteljau(ps, size):
+        for i in reversed(range(1, size)):
+            for j in range(i):
+                ps[j] = geometries.slerp_geometry([ps[j], ps[j+1]], params)
+
+        return ps[0]
+
+    if len(control_points) == 1:
+        return control_points[0]
+    elif len(control_points) == 2:
+        return geometries.slerp_geometry(control_points, params)
+    copied_control_points = copy.deepcopy(control_points)
+    return compute_casteljau(copied_control_points, len(copied_control_points))
+
+
+def compute_catmull(control_points, params: interpolation_tensor.InterpolationParams):
+    if len(control_points) <= 2:
+        return compute_linear(control_points, params)
+    else:
+        target_curve = min(int(params.t * (len(control_points) - 1)), len(control_points) - 1)
+        g0 = control_points[target_curve - 1] if target_curve > 0 else control_points[0] * 2 - control_points[1]
+        cp0 = control_points[target_curve]
+        cp1 = control_points[target_curve + 1] if target_curve + 1 < len(control_points) else control_points[-1]
+        g1 = control_points[target_curve + 2] if target_curve + 2 < len(control_points) else cp1 * 2 - cp0
+        ip0 = cp0 + (cp1 - g0)/6
+        ip1 = cp1 + (cp0 - g1)/6
+
+        new_params = interpolation_tensor.InterpolationParams(math.fmod(params.t * (len(control_points) - 1), 1.), *params[1:])
+        return compute_bezier([cp0, ip0, ip1, cp1], new_params)
+
+
+if __name__ == '__main__':
+    import turtle as tr
+    import torch
+    size = 60
+    turtle_tool = tr.Turtle()
+    turtle_tool.speed(10)
+    turtle_tool.up()
+
+    points = torch.Tensor([[-2., -2.], [2., 2.]])
+    origin = torch.Tensor([1.5, 1.6])
+
+    def sample(slerp_scale, color):
+        for i in range(size):
+            t = i / size
+            params = interpolation_tensor.InterpolationParams(t, i, size, slerp_scale, 0.0001)
+            point = origin + compute_linear(points - origin, params)
+            try:
+                turtle_tool.goto(tuple(float(p) * 100. for p in point))
+                turtle_tool.dot(5, color)
+                print(point)
+            except ValueError:
+                pass
+
+    sample(0, "black")
+    sample(1, "green")
+    sample(2, "blue")
+    sample(-1, "purple")
+    sample(-2, "orange")
+
+    for point in points:
+        turtle_tool.goto(tuple(float(p) * 100. for p in point))
+        turtle_tool.dot(5, "red")
+
+    turtle_tool.goto(tuple(float(p) * 100. for p in origin))
+    turtle_tool.dot(10, "red")
+
+    turtle_tool.goto(100000, 100000)
+    turtle_tool.dot()
+    tr.done()

prompt-fusion-extension-main/lib_prompt_fusion/interpolation_tensor.py

@@ -0,0 +1,249 @@
+import dataclasses
+import torch
+from modules import prompt_parser
+from typing import NamedTuple, Union
+
+
+class InterpolationParams(NamedTuple):
+    t: float
+    step: int
+    total_steps: int
+    slerp_scale: float
+    slerp_epsilon: float
+
+
+class InterpolationTensor:
+    def __init__(self, sub_tensors, interpolation_function):
+        self.__sub_tensors = sub_tensors
+        self.__interpolation_function = interpolation_function
+
+    def interpolate(self, params: InterpolationParams, origin_cond, empty_cond):
+        cond = self.interpolate_cond_rec(params, origin_cond, empty_cond)
+        if params.slerp_scale != 0:
+            cond = (cond + origin_cond.extend_like(cond, empty_cond)).to(dtype=origin_cond.dtype)
+        return cond
+
+    def interpolate_cond_rec(self, params: InterpolationParams, origin_cond, empty_cond):
+        if self.__interpolation_function is None:
+            return self.get_cond_point(params.step, origin_cond, empty_cond, params.slerp_scale)
+
+        control_points = [
+            sub_tensor.interpolate_cond_rec(params, origin_cond, empty_cond)
+            for sub_tensor in self.__sub_tensors
+        ]
+
+        CondWrapper, control_points_values = conds_to_cp_values(control_points)
+        return CondWrapper.from_cp_values(self.__interpolation_function(control_points, params) for control_points in control_points_values)
+
+    def get_cond_point(self, step, origin_cond, empty_cond, slerp_scale):
+        schedule = None
+        for schedule in self.__sub_tensors:
+            if schedule.end_at_step >= step:
+                break
+
+        res = schedule.cond.extend_like(origin_cond, empty_cond)
+        if slerp_scale != 0:
+            res = res.to(dtype=torch.float) - origin_cond.extend_like(schedule.cond, empty_cond).to(dtype=torch.float)
+        return res
+
+
+def conds_to_cp_values(conds):
+    CondWrapper = type(conds[0])
+    cp_values = [
+        cond.to_cp_values()
+        for cond in conds
+    ]
+    return CondWrapper, [
+        [v[i] for v in cp_values]
+        for i in range(len(cp_values[0]))
+    ]
+
+
+class InterpolationTensorBuilder:
+    def __init__(self, tensor=None, prompt_database=None, interpolation_functions=None):
+        self.__indices_tensor = tensor if tensor is not None else 0
+        self.__prompt_database = prompt_database if prompt_database is not None else ['']
+        self.__interpolation_functions = interpolation_functions if interpolation_functions is not None else []
+
+    def append(self, suffix):
+        for i in range(len(self.__prompt_database)):
+            self.__prompt_database[i] += suffix
+
+    def extrude(self, tensor_updaters, interpolation_function):
+        extruded_indices_tensor = []
+        extruded_prompt_database = []
+        extruded_interpolation_functions = []
+
+        for update_tensor in tensor_updaters:
+            nested_tensor_builder = InterpolationTensorBuilder(
+                self.__indices_tensor,
+                self.__prompt_database[:],
+                interpolation_functions=[])
+
+            update_tensor(nested_tensor_builder)
+
+            extruded_indices_tensor.append(InterpolationTensorBuilder.__offset_tensor(
+                tensor=nested_tensor_builder.__indices_tensor,
+                offset=len(extruded_prompt_database)))
+            extruded_prompt_database.extend(nested_tensor_builder.__prompt_database)
+            extruded_interpolation_functions.append(nested_tensor_builder.__interpolation_functions)
+
+        self.__indices_tensor = extruded_indices_tensor
+        self.__prompt_database[:] = extruded_prompt_database
+        self.__interpolation_functions.insert(0, (interpolation_function, extruded_interpolation_functions))
+
+    def get_prompt_database(self):
+        return self.__prompt_database
+
+    @staticmethod
+    def __offset_tensor(tensor, offset):
+        try:
+            return tensor + offset
+
+        except TypeError:
+            return [InterpolationTensorBuilder.__offset_tensor(e, offset) for e in tensor]
+
+    def build(self, conds, empty_cond):
+        max_cond_size = self.__max_cond_size(conds)
+        conds = self.__resize_uniformly(conds, max_cond_size, empty_cond)
+        return InterpolationTensorBuilder.__build_conditionings_tensor(self.__indices_tensor, self.__interpolation_functions, conds)
+
+    @staticmethod
+    def __build_conditionings_tensor(tensor, int_funcs, conds):
+        if type(tensor) is int:
+            return InterpolationTensor(conds[tensor], None)
+        else:
+            int_func, nested_int_funcs = int_funcs[0]
+            return InterpolationTensor(
+                [
+                    InterpolationTensorBuilder.__build_conditionings_tensor(sub_tensor, nested_int_funcs + int_funcs[1:], conds)
+                    for sub_tensor, nested_int_funcs in zip(tensor, nested_int_funcs)
+                ],
+                int_func,
+            )
+
+    def __resize_uniformly(self, conds, max_cond_size: int, empty_cond):
+        return [
+            [
+                prompt_parser.ScheduledPromptConditioning(
+                    cond=schedule.cond.resize_schedule(max_cond_size, empty_cond),
+                    end_at_step=schedule.end_at_step
+                )
+                for schedule in schedules
+            ]
+            for schedules in conds
+        ]
+
+    @staticmethod
+    def __max_cond_size(conds):
+        return max(schedule.cond.size(0)
+                   for schedules in conds
+                   for schedule in schedules)
+
+
+@dataclasses.dataclass
+class DictCondWrapper:
+    original_cond: dict
+
+    @staticmethod
+    def from_cp_values(cp_values):
+        return DictCondWrapper({
+            k: v
+            for k, v in zip(('crossattn', 'vector'), cp_values)
+        })
+
+    def size(self, *args, **kwargs):
+        return self.original_cond['crossattn'].size(*args, **kwargs)
+
+    def extend_like(self, that, empty):
+        missing_size = max(0, that.size(0) - self.size(0)) // 77
+        extended = DictCondWrapper(self.original_cond.copy())
+        extended.original_cond['crossattn'] = torch.concatenate([self.original_cond['crossattn']] + [empty.original_cond['crossattn']] * missing_size)
+        return extended
+
+    def resize_schedule(self, target_size, empty_cond):
+        cond_missing_size = (target_size - self.size(0)) // 77
+        if cond_missing_size <= 0:
+            return self
+
+        resized_cond = self.original_cond.copy()
+        resized_cond['crossattn'] = torch.concatenate([self.original_cond['crossattn']] + [empty_cond.original_cond['crossattn']] * cond_missing_size)
+        return DictCondWrapper(resized_cond)
+
+    def to_cp_values(self):
+        return list(self.original_cond.values())
+
+    def to(self, dtype: Union[dict, torch.dtype]):
+        if not isinstance(dtype, dict):
+            dtype = {
+                k: dtype
+                for k in self.original_cond.keys()
+            }
+        return DictCondWrapper({
+            k: v.to(dtype=dtype[k])
+            for k, v in self.original_cond.items()
+        })
+
+    @property
+    def dtype(self):
+        return {
+            k: v.dtype
+            for k, v in self.original_cond.items()
+        }
+
+    def __sub__(self, that):
+        return DictCondWrapper({
+            k: v - that.original_cond[k]
+            for k, v in self.original_cond.items()
+        })
+
+    def __add__(self, that):
+        return DictCondWrapper({
+            k: v + that.original_cond[k]
+            for k, v in self.original_cond.items()
+        })
+
+    def __eq__(self, that):
+        return all((self.original_cond[k] == that.original_cond[k]).all() for k in self.original_cond.keys())
+
+
+@dataclasses.dataclass
+class TensorCondWrapper:
+    original_cond: torch.Tensor
+
+    @staticmethod
+    def from_cp_values(cp_values):
+        return TensorCondWrapper(next(iter(cp_values)))
+
+    def size(self, *args, **kwargs):
+        return self.original_cond.size(*args, **kwargs)
+
+    def extend_like(self, that, empty):
+        missing_size = max(0, that.size(0) - self.original_cond.size(0)) // 77
+        return TensorCondWrapper(torch.concatenate([self.original_cond] + [empty.original_cond] * missing_size))
+
+    def resize_schedule(self, target_size, empty_cond):
+        cond_missing_size = (target_size - self.original_cond.size(0)) // 77
+        if cond_missing_size <= 0:
+            return self
+
+        return TensorCondWrapper(torch.concatenate([self.original_cond] + [empty_cond.original_cond] * cond_missing_size))
+
+    def to_cp_values(self):
+        return [self.original_cond]
+
+    def to(self, dtype: torch.dtype):
+        return TensorCondWrapper(self.original_cond.to(dtype=dtype))
+
+    @property
+    def dtype(self):
+        return self.original_cond.dtype
+
+    def __sub__(self, that):
+        return TensorCondWrapper(self.original_cond - that.original_cond)
+
+    def __add__(self, that):
+        return TensorCondWrapper(self.original_cond + that.original_cond)
+
+    def __eq__(self, that):
+        return (self.original_cond == that.original_cond).all()

prompt-fusion-extension-main/lib_prompt_fusion/prompt_parser.py

@@ -0,0 +1,378 @@
+import lib_prompt_fusion.ast_nodes as ast
+from collections import namedtuple
+import re
+
+
+ParseResult = namedtuple('ParseResult', ['prompt', 'expr'])
+
+
+def parse_prompt(prompt):
+    prompt = prompt.lstrip()
+    prompt, list_expr = parse_list_expression(prompt, set())
+    return list_expr
+
+
+def parse_list_expression(prompt, stoppers):
+    exprs = []
+    try:
+        while True:
+            prompt, expr = parse_expression(prompt, stoppers)
+            exprs.append(expr)
+    except ValueError:
+        return ParseResult(prompt=prompt, expr=ast.ListExpression(exprs))
+
+
+def parse_expression(prompt, stoppers):
+    for parse in _parsers():
+        try:
+            return parse(prompt, stoppers)
+        except ValueError:
+            pass
+
+    raise ValueError
+
+
+def _parsers():
+    return (
+        parse_text,
+        parse_declaration,
+        parse_substitution,
+        parse_positive_attention,
+        parse_negative_attention,
+        parse_editing,
+        parse_alternation,
+        parse_interpolation,
+        parse_unrestricted_text,
+    )
+
+
+def parse_text(prompt, stoppers):
+    return parse_unrestricted_text(prompt, set_concat(stoppers, {'[', '(', '$'}))
+
+
+def parse_unrestricted_text(prompt, stoppers):
+    escaped_stoppers = ''.join(re.escape(stopper) for stopper in stoppers)
+    regex = rf'(?:[^{escaped_stoppers}\\\s]|\$(?![a-zA-Z_])|\\.)+'
+    prompt, expr = parse_token(prompt, whitespace_tail_regex(regex, stoppers))
+    return ParseResult(prompt=prompt, expr=ast.LiftExpression(expr))
+
+
+def parse_substitution(prompt, stoppers):
+    prompt, symbol = parse_symbol(prompt, stoppers)
+    prompt, arguments = parse_arguments(prompt, stoppers)
+    return ParseResult(prompt=prompt, expr=ast.SubstitutionExpression(symbol, arguments))
+
+
+def parse_arguments(prompt, stoppers):
+    try:
+        prompt, _ = parse_open_paren(prompt, stoppers)
+        prompt, arguments = parse_inner_arguments(prompt, stoppers)
+        prompt, _ = parse_close_paren(prompt, stoppers)
+    except ValueError:
+        arguments = []
+    return ParseResult(prompt=prompt, expr=arguments)
+
+
+def parse_inner_arguments(prompt, stoppers):
+    arguments = []
+    try:
+        while True:
+            prompt, arg = parse_list_expression(prompt, {',', ')'})
+            arguments.append(arg)
+            prompt, _ = parse_comma(prompt, stoppers)
+    except ValueError:
+        pass
+
+    return ParseResult(prompt=prompt, expr=arguments)
+
+
+def parse_declaration(prompt, stoppers):
+    prompt, symbol = parse_symbol(prompt, stoppers)
+    prompt, parameters = parse_parameters(prompt, stoppers)
+    prompt, _ = parse_equals(prompt, stoppers)
+    prompt, value = parse_list_expression(prompt, set_concat(stoppers, '\n'))
+    prompt, _ = parse_newline(prompt, stoppers)
+    prompt, expr = parse_list_expression(prompt, stoppers)
+    return ParseResult(prompt=prompt, expr=ast.DeclarationExpression(symbol, parameters, value, expr))
+
+
+def parse_parameters(prompt, stoppers):
+    try:
+        prompt, _ = parse_open_paren(prompt, stoppers)
+        prompt, parameters = parse_inner_parameters(prompt, stoppers)
+        prompt, _ = parse_close_paren(prompt, stoppers)
+    except ValueError:
+        parameters = []
+    return ParseResult(prompt=prompt, expr=parameters)
+
+
+def parse_inner_parameters(prompt, stoppers):
+    parameters = []
+    try:
+        while True:
+            prompt, param = parse_symbol(prompt, stoppers)
+            parameters.append(param)
+            prompt, _ = parse_comma(prompt, stoppers)
+    except ValueError:
+        pass
+
+    return ParseResult(prompt=prompt, expr=parameters)
+
+
+def parse_interpolation(prompt, stoppers):
+    prompt, _ = parse_open_square(prompt, stoppers)
+    prompt, exprs = parse_interpolation_exprs(prompt, stoppers)
+    prompt, steps = parse_interpolation_steps(prompt, stoppers)
+    prompt, function_name = parse_interpolation_function_name(prompt, stoppers)
+    prompt, _ = parse_close_square(prompt, stoppers)
+    return ParseResult(prompt=prompt, expr=ast.InterpolationExpression.create(exprs, steps, function_name))
+
+
+def parse_interpolation_exprs(prompt, stoppers):
+    exprs = []
+
+    try:
+        while True:
+            prompt_tmp, expr = parse_list_expression(prompt, {':', ']'})
+            if parse_interpolation_function_name(prompt_tmp, stoppers).expr is not None:
+                raise ValueError
+
+            prompt, _ = parse_colon(prompt_tmp, stoppers)
+            exprs.append(expr)
+    except ValueError:
+        pass
+
+    return ParseResult(prompt=prompt, expr=exprs)
+
+
+def parse_interpolation_function_name(prompt, stoppers):
+    try:
+        prompt, _ = parse_colon(prompt, stoppers)
+        function_names = ('linear', 'catmull', 'bezier', 'mean')
+        return parse_token(prompt, whitespace_tail_regex('|'.join(function_names), stoppers))
+    except ValueError:
+        return ParseResult(prompt=prompt, expr=None)
+
+
+def parse_interpolation_steps(prompt, stoppers):
+    steps = []
+
+    try:
+        while True:
+            prompt, step = parse_interpolation_step(prompt, stoppers)
+            steps.append(step)
+            prompt, _ = parse_comma(prompt, stoppers)
+    except ValueError:
+        pass
+
+    return ParseResult(prompt=prompt, expr=steps)
+
+
+def parse_interpolation_step(prompt, stoppers):
+    try:
+        return parse_step(prompt, stoppers)
+    except ValueError:
+        pass
+
+    if prompt[0] in {',', ':', ']'}:
+        return ParseResult(prompt=prompt, expr=None)
+
+    raise ValueError
+
+
+def parse_alternation(prompt, stoppers):
+    prompt, _ = parse_open_square(prompt, stoppers)
+    prompt, exprs = parse_alternation_exprs(prompt, stoppers)
+    prompt, speed = parse_alternation_speed(prompt, stoppers)
+    prompt, _ = parse_close_square(prompt, stoppers)
+    return ParseResult(prompt=prompt, expr=ast.AlternationExpression(exprs, speed))
+
+
+def parse_alternation_exprs(prompt, stoppers):
+    exprs = []
+
+    try:
+        while True:
+            prompt, expr = parse_list_expression(prompt, {'|', ':', ']'})
+            exprs.append(expr)
+            prompt, _ = parse_vertical_bar(prompt, stoppers)
+    except ValueError:
+        if len(exprs) < 2:
+            raise
+
+    return ParseResult(prompt=prompt, expr=exprs)
+
+
+def parse_alternation_speed(prompt, stoppers):
+    try:
+        prompt, _ = parse_colon(prompt, stoppers)
+        prompt, speed = parse_step(prompt, stoppers)
+        return ParseResult(prompt=prompt, expr=speed)
+    except ValueError:
+        pass
+
+    return ParseResult(prompt=prompt, expr=None)
+
+
+def parse_editing(prompt, stoppers):
+    prompt, _ = parse_open_square(prompt, stoppers)
+    prompt, exprs = parse_editing_exprs(prompt, stoppers)
+    try:
+        prompt, step = parse_step(prompt, stoppers)
+    except ValueError:
+        step = None
+
+    prompt, _ = parse_close_square(prompt, stoppers)
+    return ParseResult(prompt=prompt, expr=ast.EditingExpression(exprs, step))
+
+
+def parse_editing_exprs(prompt, stoppers):
+    exprs = []
+
+    try:
+        for _ in range(2):
+            prompt_tmp, expr = parse_list_expression(prompt, {'|', ':', ']'})
+            prompt, _ = parse_colon(prompt_tmp, stoppers)
+            exprs.append(expr)
+    except ValueError:
+        pass
+
+    return ParseResult(prompt=prompt, expr=exprs)
+
+
+def parse_negative_attention(prompt, stoppers):
+    prompt, _ = parse_open_square(prompt, stoppers)
+    prompt, expr = parse_list_expression(prompt, set_concat(stoppers, {':', ']'}))
+    prompt, _ = parse_close_square(prompt, stoppers)
+    return ParseResult(prompt=prompt, expr=ast.WeightedExpression(expr, positive=False))
+
+
+def parse_positive_attention(prompt, stoppers):
+    prompt, _ = parse_open_paren(prompt, stoppers)
+    prompt, expr = parse_list_expression(prompt, {':', ')'})
+    prompt, weight_exprs = parse_attention_weights(prompt, stoppers)
+    prompt, _ = parse_close_paren(prompt, stoppers)
+    if len(weight_exprs) >= 2:
+        return ParseResult(prompt=prompt, expr=ast.WeightInterpolationExpression(expr, *weight_exprs[:2]))
+    else:
+        return ParseResult(prompt=prompt, expr=ast.WeightedExpression(expr, *weight_exprs[:1]))
+
+
+def parse_attention_weights(prompt, stoppers):
+    weights = []
+    try:
+        prompt, _ = parse_colon(prompt, stoppers)
+    except ValueError:
+        return ParseResult(prompt=prompt, expr=weights)
+
+    while True:
+        try:
+            prompt, weight_expr = parse_weight(prompt, stoppers)
+            weights.append(weight_expr)
+            prompt, _ = parse_comma(prompt, stoppers)
+        except ValueError:
+            return ParseResult(prompt=prompt, expr=weights)
+
+
+def parse_step(prompt, stoppers):
+    try:
+        prompt, step = parse_int_not_float(prompt, stoppers)
+        return ParseResult(prompt=prompt, expr=ast.LiftExpression(step))
+    except ValueError:
+        pass
+    try:
+        prompt, step = parse_float(prompt, stoppers)
+        return ParseResult(prompt=prompt, expr=ast.LiftExpression(step))
+    except ValueError:
+        pass
+
+    return parse_substitution(prompt, stoppers)
+
+
+def parse_weight(prompt, stoppers):
+    try:
+        prompt, step = parse_float(prompt, stoppers)
+        return ParseResult(prompt=prompt, expr=ast.LiftExpression(step))
+    except ValueError:
+        pass
+
+    return parse_substitution(prompt, stoppers)
+
+
+def parse_symbol(prompt, stoppers):
+    prompt, _ = parse_dollar(prompt)
+    return parse_symbol_text(prompt, stoppers)
+
+
+def parse_symbol_text(prompt, stoppers):
+    return parse_token(prompt, whitespace_tail_regex('[a-zA-Z_][a-zA-Z0-9_]*', stoppers))
+
+
+def parse_float(prompt, stoppers):
+    return parse_token(prompt, whitespace_tail_regex(r'[+-]?(?:\d+(?:\.\d*)?|\.\d+)', stoppers))
+
+
+def parse_int_not_float(prompt, stoppers):
+    return parse_token(prompt, whitespace_tail_regex(r'[+-]?\d+(?!\.)', stoppers))
+
+
+def parse_dollar(prompt):
+    dollar_sign = re.escape('$')
+    return parse_token(prompt, f'({dollar_sign})')
+
+
+def parse_equals(prompt, stoppers):
+    return parse_token(prompt, whitespace_tail_regex(re.escape('='), stoppers))
+
+
+def parse_comma(prompt, stoppers):
+    return parse_token(prompt, whitespace_tail_regex(re.escape(','), stoppers))
+
+
+def parse_colon(prompt, stoppers):
+    return parse_token(prompt, whitespace_tail_regex(re.escape(':'), stoppers))
+
+
+def parse_vertical_bar(prompt, stoppers):
+    return parse_token(prompt, whitespace_tail_regex(re.escape('|'), stoppers))
+
+
+def parse_open_square(prompt, stoppers):
+    return parse_token(prompt, whitespace_tail_regex(re.escape('['), stoppers))
+
+
+def parse_close_square(prompt, stoppers):
+    return parse_token(prompt, whitespace_tail_regex(re.escape(']'), stoppers))
+
+
+def parse_open_paren(prompt, stoppers):
+    return parse_token(prompt, whitespace_tail_regex(re.escape('('), stoppers))
+
+
+def parse_close_paren(prompt, stoppers):
+    return parse_token(prompt, whitespace_tail_regex(re.escape(')'), stoppers))
+
+
+def parse_newline(prompt, stoppers):
+    return parse_token(prompt, whitespace_tail_regex('\n|$', stoppers))
+
+
+def parse_token(prompt, regex):
+    match = re.match(regex, prompt)
+    if match is None:
+        raise ValueError
+
+    return ParseResult(prompt=prompt[len(match.group()):], expr=match.groups()[-1])
+
+
+def whitespace_tail_regex(regex, stoppers):
+    if '\n' in stoppers:
+        return rf'({regex})[ \t\f\r]*'
+
+    return rf'({regex})\s*'
+
+
+def set_concat(left, right):
+    result = set(left)
+    result.update(right)
+    return result

prompt-fusion-extension-main/lib_prompt_fusion/t_scaler.py

@@ -0,0 +1,38 @@
+def scale_t(t, positions):
+    if t >= 1.:
+        return 1.
+
+    if t <= 0.:
+        return 0.
+
+    distances = []
+    for i in range(len(positions)-1):
+        distances.append(positions[i+1] - positions[i])
+
+    total_distance = sum(distances)
+    for i in range(len(distances)):
+        distances[i] = distances[i]/total_distance
+
+    for i in range(len(distances)-1):
+        distances[i+1] = distances[i] + distances[i+1]
+
+    distances.insert(0, 0.0)
+
+    spline_index = 0
+    for i, distance in enumerate(distances):
+        if t > distance:
+            spline_index = i
+        else:
+            break
+
+    if spline_index >= len(distances) - 1:
+        return 1
+
+    local_ratio = (t - distances[spline_index]) / (distances[spline_index+1] - distances[spline_index])
+    return (spline_index + local_ratio)/(len(distances)-1)
+
+
+if __name__ == "__main__":
+    total_steps = 20
+    for i in range(total_steps):
+        print(i, scale_t(i/total_steps, [9, 10]))

prompt-fusion-extension-main/metadata.ini

@@ -0,0 +1,2 @@
+[Extension]
+Name = prompt-fusion

prompt-fusion-extension-main/readme.md

@@ -0,0 +1,95 @@
+# Prompt Fusion
+
+Prompt Fusion is an [auto1111 webui extension](https://github.com/AUTOMATIC1111/stable-diffusion-webui/wiki/Developing-extensions) that adds more possibilities to the native prompt syntax. Among other additions, it allows to interpolate between the embeddings of different prompts, continuously:
+
+```
+# linear prompt interpolation
+[night light:magical forest: 5, 15]
+
+# catmull-rom curve prompt interpolation
+[night light:magical forest:norvegian territory: 5, 15, 25:catmull]
+
+# alternation interpolation
+[ufo|a strange sight:0.5]
+
+# linear attention interpolation
+(fire extinguisher: 1.0, 2.0)
+
+# prompt-editing-aware attention interpolation
+[(fire extinguisher: 1.0, 2.0)::5]
+
+# weighted sum of conditions
+[space station : kitchen mixer :: mean]
+
+# define functions and variables to simplify repeating patterns and use a consistent structure
+$prompt($style, $quality, $character, $background) = (
+    A detailed picture in the style of $style,
+    $quality,
+    $character lying back,
+    $background in the background
+:1)
+```
+
+## Features
+
+- [Prompt interpolation using a curve function](https://github.com/ljleb/prompt-fusion-extension/wiki/Prompt-Interpolation)
+- [Attention interpolation aware of contextual prompt editing](https://github.com/ljleb/prompt-fusion-extension/wiki/Attention-Interpolation)
+- [Alternation interpolation](https://github.com/ljleb/prompt-fusion-extension/wiki/Alternation-interpolation)
+- [Prompt weighted sum](https://github.com/ljleb/prompt-fusion-extension/wiki/Prompt-Average)
+- [Prompt variables and functions](https://github.com/ljleb/prompt-fusion-extension/wiki/Prompt-Variables)
+- Complete backwards compatibility with the builtin prompt syntax of the webui
+
+The prompt interpolation feature is similar to [Prompt Travel](https://github.com/Kahsolt/stable-diffusion-webui-prompt-travel), which allows to create videos of images generated by navigating the latent space iteratively. Unlike Prompt Travel however, instead of generating multiple images, Prompt Fusion allows you to travel during the sampling process of *a single image*. Also, instead of interpolating the latent space, it uses the embedding space to determine intermediate embeddings. 
+
+Prompt interpolation is also similar to [Prompt Blending](https://github.com/amotile/stable-diffusion-backend/tree/master/src/process/implementations/automatic1111_scripts). The main difference is that this extension calculates a new embedding for every step, as opposed to calculating it once and using that same one embedding for all the steps. 
+
+The attention interpolation feature is similar to [Shift Attention](https://github.com/yownas/shift-attention), which allows to generate multiple images with slight variations in the attention given to certain parts of the prompt. Unlike Shift Attention, instead of generating multiple images, Prompt Fusion allows to shift the attention of certain parts of a prompt during the sampling process of *a single image*.
+
+## Usage
+- Check the [wiki pages](https://github.com/ljleb/fusion/wiki) for the extension documentation.
+
+## Examples
+
+### 1. Influencing the beginning of the sampling process
+
+Interpolate linearly (by default) from `lion` (step 0) to `bird` (step 8) to `girl` (step 11), and stay at `girl` for the rest of the sampling steps:
+
+```
+[lion:bird:girl: , 7, 10]
+```
+
+![curve1](https://user-images.githubusercontent.com/32277961/214725976-b72bafc6-0c5d-4491-9c95-b73da41da082.gif)
+
+### 2. Influencing the middle of the sampling process
+
+Interpolate using a bezier curve from `fireball monster` (step 0) to `dragon monster` (step 12, because 30 steps * 0.4 = step 12), while using `seawater monster` as an intermediate control point to steer the curve away during interpolation and to get creative results:
+
+```
+[fireball:seawater:dragon: , .1, .4:bezier] monster
+```
+
+![curve2](https://user-images.githubusercontent.com/32277961/214941229-2dccad78-f856-42bb-ae6b-16b65b273cda.gif)
+
+## Webui supported releases
+
+The following webui releases are officially supported:
+- `v1.0.0-pre`
+- `master` (there may be a slight lag for issues arising during quick a1111 webui updates)
+
+## Installation
+1. Visit the **Extensions** tab of Automatic's WebUI.
+2. Visit the **Available** subtab.
+3. Look for **Prompt Fusion**.
+4. Press the **Install** button.
+5. Wait for the webui to finish downloading the extension.
+6. Visit the **Installed** subtab.
+7. click on **Apply and restart UI**.
+
+Alternatively, instead of steps 6 and 7, you can restart the webui completely.
+
+## Related Projects
+
+- Prompt Travel: https://github.com/Kahsolt/stable-diffusion-webui-prompt-travel
+- Shift Attention: https://github.com/yownas/shift-attention
+- Prompt Blending: https://github.com/amotile/stable-diffusion-backend/tree/master/src/process/implementations/automatic1111_scripts
+

prompt-fusion-extension-main/requirements.txt

@@ -0,0 +1 @@
+

prompt-fusion-extension-main/scripts/promptlang.py

@@ -0,0 +1,355 @@
+import gradio as gr
+import re
+from lib_prompt_fusion import hijacker, empty_cond, global_state, interpolation_tensor, prompt_parser as prompt_fusion_parser
+from modules import scripts, script_callbacks, prompt_parser, shared
+
+
+fusion_hijacker_attribute = '__fusion_hijacker'
+prompt_parser_hijacker = hijacker.ModuleHijacker.install_or_get(
+    module=prompt_parser,
+    hijacker_attribute=fusion_hijacker_attribute,
+    register_uninstall=script_callbacks.on_script_unloaded)
+
+
+def _neutral_prompt_enabled() -> bool:
+    try:
+        from lib_neutral_prompt import global_state as np_state
+        return bool(getattr(np_state, "is_enabled", False))
+    except Exception:
+        return False
+
+
+
+def on_ui_settings():
+    section = ('prompt-fusion', 'Prompt Fusion')
+    shared.opts.add_option('prompt_fusion_enabled', shared.OptionInfo(True, 'Enable prompt-fusion extension', section=section))
+    shared.opts.add_option('prompt_fusion_slerp_scale', shared.OptionInfo(0, 'Slerp scale (0 = linear geometry, 1 = slerp geometry)', component=gr.Number, section=section))
+    shared.opts.add_option('prompt_fusion_slerp_negative_origin', shared.OptionInfo(True, 'use negative prompt as slerp origin', section=section))
+    shared.opts.add_option('prompt_fusion_slerp_epsilon', shared.OptionInfo(0.0001, 'Slerp epsilon (fallback on linear geometry when conds are too similar. 0 = parallel, 1 = perpendicular)', component=gr.Number, section=section))
+
+
+script_callbacks.on_ui_settings(on_ui_settings)
+
+
+@prompt_parser_hijacker.hijack('get_learned_conditioning')
+def _hijacked_get_learned_conditioning(model, prompts, total_steps, *args, original_function, **kwargs):
+    if _neutral_prompt_enabled():
+        return original_function(model, prompts, total_steps, *args, **kwargs)
+
+    if not shared.opts.prompt_fusion_enabled:
+        return original_function(model, prompts, total_steps, *args, **kwargs)
+
+    hires_steps, use_old_scheduling, *_ = args if args else (None, True)
+    is_hires = hires_steps is not None
+    if is_hires:
+        real_total_steps = hires_steps
+    else:
+        real_total_steps = total_steps
+
+    if hasattr(prompts, 'is_negative_prompt'):
+        is_negative_prompt = prompts.is_negative_prompt
+    else:
+        is_negative_prompt = global_state.old_webui_is_negative
+
+    empty_cond.init(model)
+
+    tensor_builders = _parse_tensor_builders(prompts, real_total_steps, is_hires, use_old_scheduling)
+    if hasattr(prompt_parser, 'SdConditioning'):
+        empty_conditioning = prompt_parser.SdConditioning(prompts)
+        empty_conditioning.clear()
+    else:
+        empty_conditioning = []
+
+    flattened_prompts, consecutive_ranges = _get_flattened_prompts(tensor_builders, empty_conditioning)
+    flattened_schedules = original_function(model, flattened_prompts, total_steps, *args, **kwargs)
+
+    if isinstance(flattened_schedules[0][0].cond, dict): # sdxl
+        CondWrapper = interpolation_tensor.DictCondWrapper
+    else:
+        CondWrapper = interpolation_tensor.TensorCondWrapper
+
+    flattened_schedules = [
+        [
+            prompt_parser.ScheduledPromptConditioning(cond=CondWrapper(schedule.cond), end_at_step=schedule.end_at_step)
+            for schedule in subschedules
+        ]
+        for subschedules in flattened_schedules
+    ]
+
+    cond_tensors = (tensor_builder.build(flattened_schedules[begin:end], empty_cond.get())
+                    for begin, end, tensor_builder
+                    in zip(consecutive_ranges[:-1], consecutive_ranges[1:], tensor_builders))
+
+    schedules = [_sample_tensor_schedules(cond_tensor, real_total_steps, is_hires)
+                 for cond_tensor in cond_tensors]
+
+    if is_negative_prompt:
+        if hires_steps is not None:
+            global_state.negative_schedules_hires = schedules[0]
+        else:
+            global_state.negative_schedules = schedules[0]
+
+    schedules = [
+        [
+            prompt_parser.ScheduledPromptConditioning(cond=schedule.cond.original_cond, end_at_step=schedule.end_at_step)
+            for schedule in subschedules
+        ]
+        for subschedules in schedules
+    ]
+
+    return schedules
+
+
+@prompt_parser_hijacker.hijack('get_multicond_learned_conditioning')
+def _hijacked_get_multicond_learned_conditioning(model, prompts, total_steps, *args, original_function, **kwargs):
+    if _neutral_prompt_enabled():
+        try:
+            return original_function(model, prompts, total_steps, *args, **kwargs)
+        finally:
+            global_state.old_webui_is_negative = False
+
+    if not shared.opts.prompt_fusion_enabled:
+        try:
+            return original_function(model, prompts, total_steps, *args, **kwargs)
+        finally:
+            global_state.old_webui_is_negative = False
+
+    try:
+        hires_steps, use_old_scheduling, *_ = args if args else (None, True)
+
+        res_indexes, prompt_flat_list = _get_multicond_prompt_list(prompts)
+        learned_conditioning = prompt_parser.get_learned_conditioning(
+            model,
+            prompt_flat_list,
+            total_steps,
+            hires_steps,
+            use_old_scheduling,
+            **kwargs,
+        )
+
+        batch = [
+            [prompt_parser.ComposableScheduledPromptConditioning(learned_conditioning[i], weight)
+             for i, weight in indexes]
+            for indexes in res_indexes
+        ]
+
+        return prompt_parser.MulticondLearnedConditioning(
+            shape=_infer_multicond_shape(learned_conditioning),
+            batch=batch,
+        )
+    finally:
+        global_state.old_webui_is_negative = False
+
+
+def _parse_tensor_builders(prompts, total_steps, is_hires, use_old_scheduling):
+    tensor_builders = []
+
+    for prompt in prompts:
+        expr = prompt_fusion_parser.parse_prompt(prompt)
+        tensor_builder = interpolation_tensor.InterpolationTensorBuilder()
+        expr.extend_tensor(tensor_builder, (0, total_steps), total_steps, dict(), is_hires, use_old_scheduling)
+        tensor_builders.append(tensor_builder)
+
+    return tensor_builders
+
+
+def _get_flattened_prompts(tensor_builders, flattened_prompts=None):
+    if flattened_prompts is None:
+        flattened_prompts = []
+    consecutive_ranges = [0]
+
+    for tensor_builder in tensor_builders:
+        flattened_prompts.extend(tensor_builder.get_prompt_database())
+        consecutive_ranges.append(len(flattened_prompts))
+
+    return flattened_prompts, consecutive_ranges
+
+
+def _sample_tensor_schedules(tensor, steps, is_hires):
+    schedules = []
+
+    for step in range(steps):
+        origin_cond = global_state.get_origin_cond_at(step, is_hires)
+        params = interpolation_tensor.InterpolationParams(step / steps, step, steps, global_state.get_slerp_scale(), global_state.get_slerp_epsilon())
+        schedule_cond = tensor.interpolate(params, origin_cond, empty_cond.get())
+        if schedules and schedules[-1].cond == schedule_cond:
+            schedules[-1] = prompt_parser.ScheduledPromptConditioning(end_at_step=step, cond=schedules[-1].cond)
+        else:
+            schedules.append(prompt_parser.ScheduledPromptConditioning(end_at_step=step, cond=schedule_cond))
+
+    return schedules
+
+
+class PromptFusionScript(scripts.Script):
+    def title(self):
+        return 'Prompt Fusion'
+
+    def show(self, is_img2img):
+        return scripts.AlwaysVisible
+
+    def process(self, p, *args):
+        global_state.negative_schedules = None
+        global_state.old_webui_is_negative = True
+
+
+def _get_multicond_prompt_list(prompts):
+    prompt_indexes = {}
+    prompt_flat_list = prompt_parser.SdConditioning([], copy_from=prompts)
+    res_indexes = []
+
+    for prompt in prompts:
+        indexes = []
+        for text, weight in _split_multicond_prompt(prompt):
+            index = prompt_indexes.get(text)
+            if index is None:
+                index = len(prompt_flat_list)
+                prompt_flat_list.append(text)
+                prompt_indexes[text] = index
+            indexes.append((index, weight))
+        res_indexes.append(indexes)
+
+    return res_indexes, prompt_flat_list
+
+
+def _split_multicond_prompt(prompt):
+    parts = []
+    buf = []
+    depth_paren = depth_brack = depth_brace = 0
+    escaped = False
+    i = 0
+
+    while i < len(prompt):
+        ch = prompt[i]
+
+        if escaped:
+            buf.append(ch)
+            escaped = False
+            i += 1
+            continue
+
+        if ch == '\\':
+            buf.append(ch)
+            escaped = True
+            i += 1
+            continue
+
+        if ch == '(':
+            depth_paren += 1
+        elif ch == ')' and depth_paren > 0:
+            depth_paren -= 1
+        elif ch == '[':
+            depth_brack += 1
+        elif ch == ']' and depth_brack > 0:
+            depth_brack -= 1
+        elif ch == '{':
+            depth_brace += 1
+        elif ch == '}' and depth_brace > 0:
+            depth_brace -= 1
+
+        if depth_paren == 0 and depth_brack == 0 and depth_brace == 0:
+            if _matches_top_level_and(prompt, i):
+                _append_multicond_piece(parts, ''.join(buf))
+                buf = []
+                i += 3
+                continue
+
+            if _matches_top_level_amp(prompt, i):
+                _append_multicond_piece(parts, ''.join(buf))
+                buf = []
+                i += 1
+                continue
+
+        buf.append(ch)
+        i += 1
+
+    _append_multicond_piece(parts, ''.join(buf))
+
+    return parts or [('', 1.0)]
+
+
+def _append_multicond_piece(parts, piece):
+    text, weight = _split_tail_weight(piece)
+    parts.append((text, weight))
+
+
+def _split_tail_weight(piece):
+    piece = piece.strip()
+    if not piece:
+        return '', 1.0
+
+    depth_paren = depth_brack = depth_brace = 0
+    escaped = False
+    split_at = None
+
+    for i, ch in enumerate(piece):
+        if escaped:
+            escaped = False
+            continue
+
+        if ch == '\\':
+            escaped = True
+            continue
+
+        if ch == '(':
+            depth_paren += 1
+        elif ch == ')' and depth_paren > 0:
+            depth_paren -= 1
+        elif ch == '[':
+            depth_brack += 1
+        elif ch == ']' and depth_brack > 0:
+            depth_brack -= 1
+        elif ch == '{':
+            depth_brace += 1
+        elif ch == '}' and depth_brace > 0:
+            depth_brace -= 1
+        elif ch in ':：' and depth_paren == 0 and depth_brack == 0 and depth_brace == 0:
+            split_at = i
+
+    if split_at is None:
+        return piece, 1.0
+
+    suffix = piece[split_at + 1:].strip()
+    if not re.fullmatch(r'[-+]?(?:\d+\.?|\d*\.\d+)', suffix):
+        return piece, 1.0
+
+    text = piece[:split_at].rstrip()
+    if not text:
+        return piece, 1.0
+
+    return text, float(suffix)
+
+
+def _matches_top_level_and(prompt, index):
+    if prompt[index:index + 3] != 'AND':
+        return False
+
+    prev_ch = prompt[index - 1] if index > 0 else ''
+    next_ch = prompt[index + 3] if index + 3 < len(prompt) else ''
+
+    if (prev_ch.isalnum() or prev_ch == '_') or (next_ch.isalnum() or next_ch == '_'):
+        return False
+
+    return not any(prompt.startswith(f'AND{suffix}', index) for suffix in ('_PERP', '_SALT', '_TOPK'))
+
+
+def _matches_top_level_amp(prompt, index):
+    if prompt[index] != '&':
+        return False
+
+    prev_ch = prompt[index - 1] if index > 0 else ' '
+    next_ch = prompt[index + 1] if index + 1 < len(prompt) else ' '
+    return prev_ch.isspace() and next_ch.isspace()
+
+
+def _infer_multicond_shape(learned_conditioning):
+    if not learned_conditioning or not learned_conditioning[0]:
+        return (0,)
+
+    cond = learned_conditioning[0][0].cond
+    if isinstance(cond, dict):
+        crossattn = cond.get('crossattn')
+        if isinstance(crossattn, list) and crossattn:
+            return getattr(crossattn[0], 'shape', None) or (0,)
+        return getattr(crossattn, 'shape', None) or (0,)
+
+    return getattr(cond, 'shape', None) or (0,)

prompt-fusion-extension-main/test/parser_tests.py

@@ -0,0 +1,104 @@
+from lib_prompt_fusion.prompt_parser import parse_prompt
+from lib_prompt_fusion.interpolation_tensor import InterpolationTensorBuilder
+
+
+def run_functional_tests(total_steps=100):
+    for i, (given, expected) in enumerate(functional_parse_test_cases):
+        expr = parse_prompt(given)
+        tensor_builder = InterpolationTensorBuilder()
+        expr.extend_tensor(tensor_builder, (0, total_steps), total_steps, dict(), is_hires=False, use_old_scheduling=False)
+
+        actual = tensor_builder.get_prompt_database()
+
+        if type(expected) is set:
+            assert set(actual) == expected, f"{actual} != {expected}"
+        else:
+            assert len(actual) == 1 and actual[0] == expected, f"'{actual[0]}' != '{expected}'"
+
+
+functional_parse_test_cases = [
+    ('single',)*2,
+    ('some space separated text',)*2,
+    ('(legacy weighted prompt:-2.1)',)*2,
+    ('mixed (legacy weight:3.6) and text',)*2,
+    ('legacy [range begin:0] thingy',)*2,
+    ('legacy [range end::3] thingy',)*2,
+    ('legacy [[nested range::3]:2] thingy',)*2,
+    ('legacy [[nested range:2]::3] thingy',)*2,
+    ('sugar [range:,abc:3] thingy',)*2,
+    ('sugar [[(weight interpolation:0,12):0]::1] thingy', 'sugar [[(weight interpolation:0.0):0]::1] thingy'),
+    ('sugar [[(weight interpolation:0,12):0]::2] thingy', 'sugar [[[(weight interpolation:0.0)::1][(weight interpolation:12.0):1]:0]::2] thingy'),
+    ('sugar [[(weight interpolation:0,12):0]::3] thingy', 'sugar [[[(weight interpolation:0.0)::1][[(weight interpolation:6.0):1]::2][(weight interpolation:12.0):2]:0]::3] thingy'),
+    ('legacy [from:to:2] thingy',)*2,
+    ('legacy [negative weight]',)*2,
+    ('legacy (positive weight)',)*2,
+    ('[abc:1girl:2]',)*2,
+    ('[::]',)*2,
+    ('[a:b:]',)*2,
+    ('[[a:b:1,2]:b:]', {'[a:b:]', '[b:b:]'}),
+    ('1girl',)*2,
+    ('dashes-in-text',)*2,
+    ('text, separated with, comas',)*2,
+    ('{prompt}',)*2,
+    ('[abc|def ghi|jkl]',)*2,
+    ('merging this AND with this',)*2,
+    (':',)*2,
+    (r'portrait \(object\)',)*2,
+    (r'\[escaped square\]',)*2,
+    (r'\$var = abc',)*2,
+    (r'\\$ arst',)*2,
+    (r'$$ arst',)*2,
+    ('$var = abc', ''),
+    ('$a = prompt value\n$a', 'prompt value'),
+    ('$a = prompt value\n$b = $a\n$b', 'prompt value'),
+    ('$a = (multiline\nprompt\nvalue:1.0)\n$a', '(multiline prompt value:1.0)'),
+    ('$a = ($aa = nested variable\nmultiline\n$aa:1.0)\n$a', '(multiline nested variable:1.0)'),
+    ('a [b:c:-1, 10] d', {'a b d', 'a c d'}),
+    ('a [b:c:5, 6] d', {'a b d', 'a c d'}),
+    ('a [b:c:0.25, 0.5] d', {'a b d', 'a c d'}),
+    ('a [b:c:.25, .5] d', {'a b d', 'a c d'}),
+    ('a [b:c:,] d', {'a b d', 'a c d'}),
+    ('0[1.0:1.1:,]2[3.0:3.1:,]4', {
+        '0 1.0 2 3.0 4', '0 1.1 2 3.0 4',
+        '0 1.0 2 3.1 4', '0 1.1 2 3.1 4',
+    }),
+    ('0[1.0:1.1:1.2:,.5,]2[3.0:3.1:,]4', {
+        '0 1.0 2 3.0 4', '0 1.0 2 3.1 4',
+        '0 1.1 2 3.0 4', '0 1.1 2 3.1 4',
+        '0 1.2 2 3.0 4', '0 1.2 2 3.1 4',
+    }),
+    ('[0.0:0.1:,][1.0:1.1:,][2.0:2.1:,]', {
+        '0.0 1.0 2.0', '0.0 1.0 2.1',
+        '0.1 1.0 2.0', '0.1 1.0 2.1',
+        '0.0 1.1 2.0', '0.0 1.1 2.1',
+        '0.1 1.1 2.0', '0.1 1.1 2.1',
+    }),
+    ('[top level:interpolatin:lik a pro:1,3,5:linear]', {'top level', 'interpolatin', 'lik a pro'}),
+    ('[[nested:expr:,]:abc:,]', {'nested', 'expr', 'abc'}),
+    ('[(nested attention:2.0):abc:,]', {'(nested attention:2.0)', 'abc'}),
+    ('[[nested editing:15]:abc:,]', {'[nested editing:15]', 'abc'}),
+    ('[[nested interpolation:abc:,]:12]', {'[nested interpolation:12]', '[abc:12]'}),
+    ('[[nested interpolation:abc:,]::7]', {'[nested interpolation::7]', '[abc::7]'}),
+    ('$attention = 1.5\n(prompt:$attention)', '(prompt:1.5)'),
+    ('$a = 0\n$b = 12\n[[(prompt:$a,$b):0]::2]', '[[[(prompt:0.0)::1][(prompt:12.0):1]:0]::2]'),
+    ('$step = 5\n[legacy:editing:$step]', '[legacy:editing:5]'),
+    ('$begin = 2\n$end = 7\n[prompt:interpolation:$begin, $end]', {'prompt', 'interpolation'}),
+    ('$a($b, $c) = prompt with $b, prompt with $c\n$a(cat, dog)', 'prompt with cat , prompt with dog'),
+    ('$a($b) = prompt with $b\n$c($d) = yeay $a($d)\n$c(dog)', 'yeay prompt with dog'),
+    ('$a = a lot of animals\n$b($c) = I love $c\n$b($a)', 'I love a lot of animals'),
+    ('$a($b) = prompt with $b\n$c($d) = yeay $d\n$a($c(dog))', 'prompt with yeay dog'),
+    ('[a|b|c]', '[a|b|c]'),
+    ('[a|b|c:]', '[a|b|c]'),
+    ('[a|b|c:1]', {'a', 'b', 'c'}),
+    ('[a|b|c:2]', {'a', 'b', 'c'}),
+    ('[a|b|c:0.5]', {'a', 'b', 'c'}),
+    ('[a|b|c:1.1]', {'a', 'b', 'c'}),
+    ('[[[Imperial Yellow|Amber]:[Ruby|Plum|Bronze]:9]::39]',)*2,
+    ('[a:b:c::mean]', {'a', 'b', 'c'}),
+    ('[a:b:c:,,:mean]', {'a', 'b', 'c'}),
+    ('[a:b:c: 1, 2, 3:mean]', {'a', 'b', 'c'}),
+]
+
+
+def run_tests():
+    run_functional_tests()

prompt-fusion-extension-main/test/run_all.py

@@ -0,0 +1,7 @@
+import sys
+sys.path.append('..')
+import parser_tests
+
+
+if __name__ == '__main__':
+    parser_tests.run_tests()