Delete neutral_prompt_patched

neutral_prompt_patched/.gitignore

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

neutral_prompt_patched/LICENSE

@@ -1,21 +0,0 @@
-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

@@ -1,99 +0,0 @@
-# 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

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

neutral_prompt_patched/lib_neutral_prompt/affine_transform.py

@@ -1,83 +0,0 @@
-"""
-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

@@ -1,646 +0,0 @@
-"""
-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
-
-    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)
-
-
-# ---------------------------------------------------------------------------
-# 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)
-
-    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

@@ -1,23 +0,0 @@
-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

@@ -1,27 +0,0 @@
-"""
-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

@@ -1,75 +0,0 @@
-"""
-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

@@ -1,34 +0,0 @@
-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

@@ -1,382 +0,0 @@
-"""
-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

@@ -1,86 +0,0 @@
-import re
-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 &" = surrounded by whitespace (or at start/end of string).
-# Examples:
-#   "cat & dog"  ->  "cat \& dog"     <- was splitting, now safe
-#   "R&D"        ->  "R&D"            <- was NOT splitting, unchanged
-#   "\&"         ->  "\&"             <- already escaped, not double-escaped
-# ---------------------------------------------------------------------------
-_STANDALONE_AMP = re.compile(r'(?<!\\)(?<!\S)&(?!\S)')
-
-
-def _escape_leaf_ampersands(text: str) -> str:
-    """Escape standalone '&' in a leaf prompt so patched prompt_parser
-    does not treat it as a multicond AND separator."""
-    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)
-    if isinstance(prompts, getattr(prompt_parser, 'SdConditioning', type(None))):
-        webui_prompts = prompt_parser.SdConditioning(webui_prompts, copy_from=prompts)
-
-    return original_function(webui_prompts)
-
-
-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:
-        # Escape standalone '&' so patched prompt_parser doesn't split the leaf
-        # into extra multicond branches. '\&' is correctly unescaped downstream.
-        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]
-    return res

neutral_prompt_patched/lib_neutral_prompt/ui.py

@@ -1,196 +0,0 @@
-"""
-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

@@ -1,42 +0,0 @@
-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

@@ -1,94 +0,0 @@
-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

@@ -1,133 +0,0 @@
-"""
-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

@@ -1,217 +0,0 @@
-"""
-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

@@ -1,122 +0,0 @@
-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

@@ -1,182 +0,0 @@
-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()