Upload z-sd-webui-neutral-prompt-workYEAH8 using SD-Hub

z-sd-webui-neutral-prompt-workYEAH8/.gitignore

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

z-sd-webui-neutral-prompt-workYEAH8/LICENSE

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

z-sd-webui-neutral-prompt-workYEAH8/README.md

@@ -0,0 +1,113 @@
+# Neutral Prompt
+
+Neutral prompt is an a1111 webui extension that adds alternative composable diffusion keywords to the prompt language. It enhances the original implementation using more recent research.
+
+## Features
+
+- [Perp-Neg](https://perp-neg.github.io/) orthogonal prompts, invoked using the `AND_PERP` keyword
+- saliency-aware noise blending, invoked using the `AND_SALT` keyword (credits to [Magic Fusion](https://magicfusion.github.io/) for the algorithm used to determine SNB maps from epsilons)
+- semantic guidance top-k filtering, invoked using the `AND_TOPK` keyword (reference: https://arxiv.org/abs/2301.12247)
+- standard deviation based CFG rescaling (Reference: https://arxiv.org/abs/2305.08891, section 3.4)
+
+## Usage
+
+*Disclaimer: some sections of the readme have been generated by GPT-4. If anything is unclear, feel free to ask for clarifications in the [discussions](https://github.com/ljleb/sd-webui-neutral-prompt/discussions).*
+
+### Keyword `AND_PERP`
+
+The `AND_PERP` keyword, standing for "PERPendicular `AND`", integrates the orthogonalization process described in the Perp-Neg paper. Essentially, `AND_PERP` allows for prompting concepts that highly overlap with regular prompts, by negating contradicting concepts.
+
+You could visualize it as such: if `AND` prompts are "greedy" (taking as much space as possible in the output), `AND_PERP` prompts are opposite, relinquishing control as soon as there is a disagreement in the generated output.
+
+### Keyword `AND_SALT`
+
+Saliency-aware blending is made possible using the `AND_SALT` keyword, shorthand for "SALienT `AND`". In essence, `AND_SALT` keeps the highest activation pixels at each denoising step.
+
+Think of it as a territorial dispute: the image generated by the `AND` prompts is one country, and the images generated by `AND_SALT` prompts represent neighbouring nations. They're all vying for the same land - whoever strikes the strongest at a given time (denoising step) and location (latent pixel) claims it.
+
+### Keyword `AND_TOPK`
+
+The `AND_TOPK` keyword refers to "TOP-K filtering". It keeps only the "k" highest activation latent pixels in the noise map and discards the rest. It works similarly to `AND_SALT`, except that the high-activation regions are simply added instead of replacing previous content.
+
+Currently, k is constantly 5% of all latent pixels, meaning 95% of the weakest latent pixel values at each step are discarded.
+
+Top-k filtering is useful when you want to have a more targeted effect on the generated image. It should work best with smaller objects and details.
+
+## Examples
+
+### Using the `AND_PERP` Keyword
+
+Here is an example to illustrate one use case of the `AND_PREP` keyword. Prompt:
+
+`beautiful castle landscape AND monster house castle :-1`
+
+This is an XY grid with prompt S/R `AND, AND_PERP`:
+
+![image](https://github.com/ljleb/sd-webui-neutral-prompt/assets/32277961/29f3cf34-2ed4-45d2-b73a-b6fadec21d61)
+
+Key observations:
+
+- The `AND_PERP` images exhibit a higher dynamic range compared to the `AND` images.
+- Since the prompts have a lot of overlap, the `AND` images sometimes struggle to depict a castle. This isn't a problem for the `AND_PERP` images.
+- The `AND` images tend to lean towards a purple color, because this was the path of least resistance between the two opposing prompts during generation. In contrast, the `AND_PERP` images, free from this tug-of-war, present a clearer representation.
+
+### Using the `AND_SALT` Keyword
+
+The `AND_SALT` keyword can be used to invoke saliency-aware blending. It spotlights and accentuates areas of high-activation in the output.
+
+Consider this example prompt utilizing `AND_SALT`:
+
+```
+a vibrant rainforest with lush green foliage
+AND_SALT the glimmering rays of a golden sunset piercing through the trees
+```
+
+In this case, the extension identifies and isolates the most salient regions in the sunset prompt. Then, the extension applies this marsked image to the rainforest prompt. Only the portions of the rainforest prompt that coincide with the salient areas of the sunset prompt are affected. These areas are replaced by pixels from the sunset prompt.
+
+This is an XY grid with prompt S/R `AND_SALT, AND, AND_PERP`:
+
+![xyz_grid-0008-1564977627-a vibrant rainforest with lush green foliage_AND_SALT the glimmering rays of a golden sunset piercing through the trees](https://github.com/ljleb/sd-webui-neutral-prompt/assets/32277961/2404f20b-47f6-457f-b4c5-76b9fd919345)
+
+Key observations:
+
+- `AND_SALT` behaves more diplomatically, enhancing areas where its impact makes the most sense and aligning with high activity regions in the output
+- `AND` gives equal weight to both prompts, creating a blended result
+- `AND_PERP` will find its way through anything not blocked by the regular prompt
+
+## Advanced Features
+
+### Nesting prompts
+
+The extension supports nesting of all prompt keywords including `AND`, allowing greater flexibility and control over the final output. Here's an example of how these keywords can be combined:
+
+```
+magical tree forests, eternal city
+AND_PERP [
+    electrical pole voyage
+    AND_SALT small nocturne companion
+]
+AND_SALT [
+    electrical tornado
+    AND_SALT electric arcs, bzzz, sparks
+]
+```
+
+To generate the final image from the diffusion model:
+
+1. The extension first processes the root `AND` prompts. In this case, it's just `magical tree forests, eternal city`
+2. It then processes the `AND_SALT` prompt `small nocturne companion` in the context of `electrical pole voyage`. This enhances salient features in the `electrical pole voyage` image
+3. This new image is orthogonalized with the image from `magical tree forests, eternal city`, blending the details of the 'electrical pole voyage' into the main scene without creating conflicts
+4. The extension then turns to the second `AND_SALT` group. It processes `electric arcs, bzzz, sparks` in the context of `electrical tornado`, amplifying salient features in the electrical tornado image
+5. The image from this `AND_SALT` group is then combined with the `magical tree forests, eternal city` image. The final output retains the strongest features from both the `electrical tornado` (enhanced by 'electric arcs, bzzz, sparks') and the earlier 'magical tree forests, eternal city' scene influenced by the 'electrical pole voyage'
+
+Each keyword can define a distinct denoising space within its square brackets `[...]`. Prompts inside it merge into a single image before further processing down the prompt tree.
+
+While there's no strict limit on the depth of nesting, experimental evidence suggests that going beyond a depth of 2 is generally unnecessary. We're still exploring the added precision from deeper nesting. If you discover innovative ways of controlling the generations using nested prompts, please share in the discussions!
+
+![image](https://github.com/ljleb/sd-webui-neutral-prompt/assets/32277961/f16587fe-2244-4832-a253-98f819a9e2e0)
+
+## Special Mentions
+
+Special thanks to these people for helping make this extension possible:
+
+- [Ai-Casanova](https://github.com/AI-Casanova) : for sharing mathematical knowledge, time, and conducting proof-testing to enhance the robustness of this extension

z-sd-webui-neutral-prompt-workYEAH8/lib_neutral_prompt/cfg_denoiser_hijack.py

@@ -0,0 +1,388 @@
+# lib_neutral_prompt/cfg_denoiser_hijack.py
+
+from lib_neutral_prompt import hijacker, global_state, neutral_prompt_parser
+from lib_neutral_prompt.prompt_parser_hijack import WebuiPromptVisitor
+from modules import script_callbacks, sd_samplers, shared, prompt_parser
+from typing import Tuple, List
+import dataclasses
+import functools
+import torch
+
+
+# -----------------------------
+# Quiet warnings (no-op)
+# -----------------------------
+
+def warn_unsupported_sampler():
+    # Тихо пропускаем (без вывода в консоль)
+    return
+
+
+def warn_projection_not_found():
+    # Тихо пропускаем (без вывода в консоль)
+    return
+
+
+# -----------------------------
+# Math helpers used by visitors
+# -----------------------------
+
+def get_salience(vector: torch.Tensor) -> torch.Tensor:
+    # softmax по абсолютным значениям; возвращаем «карту заметности» формы vector
+    return torch.softmax(torch.abs(vector).flatten(), dim=0).reshape_as(vector)
+
+
+def filter_abs_top_k(vector: torch.Tensor, k_ratio: float) -> torch.Tensor:
+    # пропускаем только самые большие по модулю компоненты (top-(1 - k_ratio))
+    k = int(torch.numel(vector) * (1 - k_ratio))
+    top_k, _ = torch.kthvalue(torch.abs(torch.flatten(vector)), max(k, 1))
+    return vector * (torch.abs(vector) >= top_k).to(vector.dtype)
+
+
+def get_perpendicular_component(normal: torch.Tensor, vector: torch.Tensor, eps: float = 1e-8) -> torch.Tensor:
+    # проецируем vector на подпространство, перпендикулярное normal
+    denom = torch.clamp(torch.sum(normal * normal), min=eps)
+    if denom <= eps:
+        warn_projection_not_found()
+        return vector
+    return vector - normal * torch.sum(normal * vector) / denom
+
+
+def salient_blend(normal: torch.Tensor, vectors: List[Tuple[torch.Tensor, float]]) -> torch.Tensor:
+    # пиксельно выбираем «самый заметный» вектор; складываем дельты относительно normal
+    if not vectors:
+        return torch.zeros_like(normal)
+    salience_maps = [get_salience(normal)] + [get_salience(v) 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 += weight * vector_mask * (vector - normal)
+    return result
+
+
+# -----------------------------
+# Glue with webui
+# -----------------------------
+
+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)
+    # только те, у кого есть model_wrap_cfg.combine_denoised
+    if not hasattr(sampler, "model_wrap_cfg") or not hasattr(sampler.model_wrap_cfg, "combine_denoised"):
+        if getattr(global_state, "is_enabled", False):
+            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
+
+
+# -----------------------------
+# Scheduling helpers
+# -----------------------------
+
+def convert_to_prompt_expr_from_multicond(c, prompts):
+    # fallback: когда global_state.prompt_exprs ещё пуст, а webui уже дал индексы/веса
+    exprs = []
+    for batch_conds in c:
+        for idx, weight in batch_conds:
+            prompt_text = prompts[idx] if prompts and idx < len(prompts) else f"prompt_{idx}"
+            exprs.append(
+                neutral_prompt_parser.LeafPrompt(
+                    weight=float(weight) if isinstance(weight, (int, float)) else 1.0,
+                    conciliation=None,
+                    prompt=prompt_text,
+                )
+            )
+    return exprs
+
+
+def get_active_prompt(schedule, current_step):
+    # выбираем активный текст по текущему шагу
+    for end_step, text in schedule:
+        if current_step <= end_step:
+            return text
+    return schedule[-1][1] if schedule else "empty_prompt"
+
+
+# -----------------------------
+# Main entry
+# -----------------------------
+
+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:
+    """
+    Патчим combine_denoised так, чтобы он поддерживал Neutral Prompt-композиции.
+    """
+    if not getattr(global_state, "is_enabled", False):
+        return original_function(x_out, batch_cond_indices, text_uncond, cond_scale)
+
+    # если кто-то вызвал раньше, а exprs ещё нет — построим из webui conds
+    if not getattr(global_state, "prompt_exprs", []) and batch_cond_indices:
+        global_state.prompt_exprs = convert_to_prompt_expr_from_multicond(batch_cond_indices, [])
+
+    # поддержка расписаний webui (prompt travel / динамика по шагам)
+    prompt_schedules = prompt_parser.get_learned_conditioning_prompt_schedules(
+        getattr(global_state, "raw_prompts", [expr.accept(WebuiPromptVisitor()) for expr in global_state.prompt_exprs]),
+        shared.state.sampling_steps,
+    )
+    active_prompts = [get_active_prompt(s, shared.state.sampling_step) for s in prompt_schedules]
+    global_state.prompt_exprs = [neutral_prompt_parser.parse_root(p) for p in active_prompts]
+
+    # считаем «чистый» denoised от webui на переупакованном батче
+    denoised = get_webui_denoised(x_out, batch_cond_indices, text_uncond, cond_scale, original_function)
+
+    # затем добавим наши корректировки (aux_cond_delta) и CFG-rescale
+    uncond = x_out[-text_uncond.shape[0] :]
+
+    for batch_i, (prompt, cond_indices) in enumerate(zip(global_state.prompt_exprs, batch_cond_indices)):
+        args = CombineDenoiseArgs(x_out=x_out, uncond=uncond[batch_i], cond_indices=cond_indices)
+        cond_delta = prompt.accept(CondDeltaVisitor(), args, 0)
+        aux_cond_delta = prompt.accept(AuxCondDeltaVisitor(), args, cond_delta, 0)
+
+        # добавляем только aux часть в cfg_cond (основанный на webui результате)
+        cfg_cond = denoised[batch_i] + aux_cond_delta * cond_scale
+        # а rescale делаем относительно полной «цели»: uncond + cond_delta + aux_cond_delta
+        denoised[batch_i] = cfg_rescale(cfg_cond, uncond[batch_i] + cond_delta + aux_cond_delta)
+
+    return denoised
+
+
+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:
+    """
+    Переупаковываем батч под оригинальный combine_denoised:
+    - строим список «условных срезов» (с учётом сложных композиций)
+    - отдаём webui оригинальные индексы/веса, но уже на наш переупакованный батч
+    - webui вернёт по одному denoised на картинку (а не на срез!)
+    """
+    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 = CombineDenoiseArgs(x_out=x_out, uncond=uncond[batch_i], cond_indices=cond_indices)
+
+        # sanity-check: число базовых листьев должно совпадать с количеством webui cond_indices
+        base_size = prompt.accept(BaseSizeVisitor())
+        # предупреждения отключены по требованию — просто не шумим
+
+        sliced_x_out, sliced_cond_indices = gather_webui_conds(prompt, args, 0, len(sliced_batch_x_out))
+        if sliced_cond_indices:
+            sliced_batch_cond_indices.append(sliced_cond_indices)
+        sliced_batch_x_out.extend(sliced_x_out)
+
+    # добавляем uncond-часть всего батча (webui ожидает её в хвосте)
+    sliced_batch_x_out += list(uncond)
+    sliced_batch_x_out = torch.stack(sliced_batch_x_out, dim=0)
+
+    # вызвать оригинальный combine_denoised на нашем переупакованном батче
+    return original_function(sliced_batch_x_out, sliced_batch_cond_indices, text_uncond, cond_scale)
+
+
+def cfg_rescale(cfg_cond: torch.Tensor, cond: torch.Tensor) -> torch.Tensor:
+    """
+    CFG Rescale (как в SDXL/SD WebUI) — нормируем дисперсию cond к cond, но сохраняем среднее в смеси.
+    """
+    if getattr(global_state, "cfg_rescale", 0) == 0:
+        return cfg_cond
+
+    global_state.apply_and_clear_cfg_rescale_override()
+    cfg_cond_mean = cfg_cond.mean()
+    cfg_rescale_mean = (1 - global_state.cfg_rescale) * cfg_cond_mean + global_state.cfg_rescale * cond.mean()
+    cfg_rescale_factor = global_state.cfg_rescale * (cond.std() / (cfg_cond.std() + 1e-8) - 1) + 1
+    return cfg_rescale_mean + (cfg_cond - cfg_cond_mean) * cfg_rescale_factor
+
+
+# -----------------------------
+# Data passed around visitors
+# -----------------------------
+
+@dataclasses.dataclass
+class CombineDenoiseArgs:
+    x_out: torch.Tensor
+    uncond: torch.Tensor
+    cond_indices: List[Tuple[int, float]]  # (index_in_x_out, weight_from_webui)
+
+
+# -----------------------------
+# Size visitor for REAL webui indices
+# -----------------------------
+
+class BaseSizeVisitor:
+    """
+    Считает ТОЛЬКО базовые листья (conciliation is None), т.е. столько,
+    сколько webui реально выдаёт cond_indices.
+    """
+    def visit_leaf_prompt(self, that: neutral_prompt_parser.LeafPrompt) -> int:
+        return 1 if getattr(that, "conciliation", None) is None else 0
+
+    def visit_composite_prompt(self, that: neutral_prompt_parser.CompositePrompt) -> int:
+        if not getattr(that, "children", None):
+            return 0
+        return sum(child.accept(self) for child in that.children)
+
+
+# -----------------------------
+# Visitors producing deltas
+# -----------------------------
+
+class CondDeltaVisitor:
+    def visit_leaf_prompt(
+        self,
+        that: neutral_prompt_parser.LeafPrompt,
+        args: CombineDenoiseArgs,
+        index: int,
+    ) -> torch.Tensor:
+        # индекс тратится ТОЛЬКО на базовых листьях; подстрахуемся от выхода за границу
+        if index >= len(args.cond_indices):
+            return torch.zeros_like(args.x_out[0])
+
+        cond_info = args.cond_indices[index]
+        # предупреждения про несоответствие весов убраны по требованию
+
+        # разница между cond и uncond (базовая CFG-дельта)
+        return args.x_out[cond_info[0]] - args.uncond
+
+    def visit_composite_prompt(
+        self,
+        that: neutral_prompt_parser.CompositePrompt,
+        args: CombineDenoiseArgs,
+        index: int,
+    ) -> torch.Tensor:
+        cond_delta = torch.zeros_like(args.x_out[0])
+
+        for child in that.children:
+            child_cond_delta = child.accept(self, args, index)
+            # базовая логика — взвешенная сумма; SALIENCE применим на Aux-этапе
+            cond_delta += child.weight * child_cond_delta
+
+            # шаг по количеству БАЗОВЫХ листьев внутри ребёнка
+            index += child.accept(BaseSizeVisitor())
+
+        return cond_delta
+
+
+class AuxCondDeltaVisitor:
+    def visit_leaf_prompt(
+        self,
+        that: neutral_prompt_parser.LeafPrompt,
+        args: CombineDenoiseArgs,
+        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: CombineDenoiseArgs,
+        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]] = []
+
+        for child in that.children:
+            if getattr(child, "conciliation", None) is not None:
+                # рекурсивно собираем child deltas
+                child_cond_delta = child.accept(CondDeltaVisitor(), args, index)
+                child_cond_delta += child.accept(self, args, child_cond_delta, index)
+
+                if child.conciliation == neutral_prompt_parser.ConciliationStrategy.PERPENDICULAR:
+                    aux_cond_delta += child.weight * get_perpendicular_component(cond_delta, child_cond_delta)
+                elif child.conciliation == neutral_prompt_parser.ConciliationStrategy.SALIENCE_MASK:
+                    salient_cond_deltas.append((child_cond_delta, child.weight))
+                elif child.conciliation == neutral_prompt_parser.ConciliationStrategy.SEMANTIC_GUIDANCE:
+                    aux_cond_delta += child.weight * filter_abs_top_k(child_cond_delta, 0.05)
+
+            # шаг только по БАЗОВЫМ листьям
+            index += child.accept(BaseSizeVisitor())
+
+        # финальное «солёное» смешивание для узла, где встречались SALIENCE-дети
+        aux_cond_delta += salient_blend(cond_delta, salient_cond_deltas)
+        return aux_cond_delta
+
+
+# -----------------------------
+# Slice builder for webui call
+# -----------------------------
+
+def gather_webui_conds(
+    prompt: neutral_prompt_parser.PromptExpr,
+    args: CombineDenoiseArgs,
+    index_in: int,
+    index_out: int,
+) -> Tuple[List[torch.Tensor], List[Tuple[int, float]]]:
+    """
+    Формируем список «условных срезов» (x_out) и соответствующие пары (index, weight),
+    которые поймёт оригинальный webui combine_denoised.
+    - Для базовых листьев берём реальные webui cond_indices (и тратим индекс)
+    - Для «вторичных» листьев и композитов синтезируем канал: uncond + (cond_delta + aux_delta)
+    """
+    sliced_x_out: List[torch.Tensor] = []
+    sliced_cond_indices: List[Tuple[int, float]] = []
+
+    # Лист
+    if isinstance(prompt, neutral_prompt_parser.LeafPrompt):
+        if getattr(prompt, "conciliation", None) is None:
+            # базовый лист — берём реальный cond канал из x_out по webui индексу
+            if index_in >= len(args.cond_indices):
+                return sliced_x_out, sliced_cond_indices
+            real_idx, _w = args.cond_indices[index_in]
+            child_x_out = args.x_out[real_idx]
+        else:
+            # вторичный лист — синтезируем «условный канал»
+            child_cond = prompt.accept(CondDeltaVisitor(), args, index_in)
+            child_cond += prompt.accept(AuxCondDeltaVisitor(), args, child_cond, index_in)
+            child_x_out = args.uncond + child_cond
+
+        index_offset = index_out + len(sliced_x_out)
+        sliced_x_out.append(child_x_out)
+        sliced_cond_indices.append((index_offset, prompt.weight))
+        return sliced_x_out, sliced_cond_indices
+
+    # Композит
+    if isinstance(prompt, neutral_prompt_parser.CompositePrompt):
+        for child in prompt.children:
+            if isinstance(child, neutral_prompt_parser.LeafPrompt) and getattr(child, "conciliation", None) is None:
+                # базовый лист — реальный индекс webui
+                if index_in >= len(args.cond_indices):
+                    break
+                real_idx, _w = args.cond_indices[index_in]
+                child_x_out = args.x_out[real_idx]
+            else:
+                # всё остальное — синтезируем канал
+                child_cond = child.accept(CondDeltaVisitor(), args, index_in)
+                child_cond += child.accept(AuxCondDeltaVisitor(), args, child_cond, index_in)
+                child_x_out = args.uncond + child_cond
+
+            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(BaseSizeVisitor())
+
+    return sliced_x_out, sliced_cond_indices

z-sd-webui-neutral-prompt-workYEAH8/lib_neutral_prompt/external_code/__init__.py

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

z-sd-webui-neutral-prompt-workYEAH8/lib_neutral_prompt/external_code/api.py

@@ -0,0 +1,5 @@
+from lib_neutral_prompt import global_state
+
+
+def override_cfg_rescale(cfg_rescale: float):
+    global_state.cfg_rescale_override = cfg_rescale

z-sd-webui-neutral-prompt-workYEAH8/lib_neutral_prompt/external_code/ui (16).py

@@ -0,0 +1,255 @@
+# lib_neutral_prompt/ui.py
+from lib_neutral_prompt import global_state, neutral_prompt_parser
+from modules import script_callbacks, shared
+from typing import Dict, Tuple, List, Callable
+import gradio as gr
+import dataclasses
+
+txt2img_prompt_textbox = None
+img2img_prompt_textbox = None
+
+# Только поддерживаемые типы
+prompt_types = {
+    'Perpendicular': neutral_prompt_parser.PromptKeyword.AND_PERP.value,
+    'Saliency-aware': neutral_prompt_parser.PromptKeyword.AND_SALT.value,
+    'Semantic guidance top-k': neutral_prompt_parser.PromptKeyword.AND_TOPK.value,
+}
+
+prompt_types_tooltip = '\n'.join([
+    'AND — базовое сложение фич (встроено в WebUI, режим по умолчанию)',
+    'Perpendicular (AND_PERP) — подавляет противоречащие фичи',
+    'Saliency-aware (AND_SALT) — побеждают самые «заметные» фичи',
+    'Semantic guidance top-k (AND_TOPK) — таргетные точечные изменения',
+])
+
+GUIDE_MD = """
+### Neutral Prompt — Guide & Examples
+
+**Как это работает**
+- `AND` — обычная сумма фич. Пишется напрямую в промпте: `a AND (b:1.2)`
+- Расширенные режимы оформляются ключевыми словами и **квадратными скобками**:
+  - `AND_PERP [ ... ] : w` — *перпендикулярная* компонента. Помогает «убрать конфликтующее».
+  - `AND_SALT [ ... ] : w` — *saliency-aware*. Смешивает в пользу «самых заметных» участков.
+  - `AND_TOPK [ ... ] : w` — *semantic top-k*. Оставляет только самые сильные (по модулю) изменения.
+
+**Веса**
+- Внутри скобок: `(text:0.8)` — классика WebUI.
+- В плоском виде: `text:0.8` — тоже поддерживается.
+- Вес группы: `AND_SALT [ a AND (b:0.7) ] : 0.5` — общий вес умножится на вклад детей.
+
+**Быстрые примеры**
+```text
+# Базовый AND
+a cinematic portrait AND (dramatic lighting:1.2)
+
+# Perpendicular: добавь деталь, не ломая основной стиль
+AND_PERP [ cinematic lighting AND (sharp details:1.1) ] : 0.6
+
+# Saliency-aware: усили неон и отблески
+AND_SALT [ neon AND reflections:0.7 ] : 0.5
+
+# Semantic top-k: точечные правки лица
+AND_TOPK [ add freckles AND brighten eyes ] : 0.4
+```
+
+**Комбо-примеры**
+```text
+# Комбинация SALT + PERP
+a rainy street at night
+AND_SALT [ neon signs AND wet asphalt reflections:0.8 ] : 0.5
+AND_PERP [ remove fog AND (crisp edges:1.1) ] : 0.4
+
+# Комбинация TOPK + AND
+a studio headshot
+AND_TOPK [ enhance iris detail AND subtle skin texture ] : 0.35
+AND (soft key light:1.15)
+```
+
+**Расписания (prompt travel) — делает сам WebUI**
+- Используй стандартный синтаксис WebUI, например:
+```text
+a sunset over city [a sunrise over city: 18]
+```
+- Наше расширение берёт **исходный текст** (raw prompt) для расписаний, поэтому просто пиши как обычно.
+- Расширенные блоки тоже можно комбинировать с расписанием (WebUI решит активный текст на каждом шаге).
+
+**Советы**
+- Пиши «расширенные» блоки ближе к концу промпта и увеличивай вес постепенно (`0.3 → 0.6`).
+- Если что-то «перетягивает одеяло», снизь вес блока или листьев внутри него.
+- Не злоупотребляй количеством расширенных блоков: один-два аккуратных блока обычно лучше.
+"""
+
+# Готовые примеры для кнопок вставки
+EXAMPLE_BASE_AND = "a cinematic portrait AND (dramatic lighting:1.2)"
+EXAMPLE_PERP = "AND_PERP [ cinematic lighting AND (sharp details:1.1) ] : 0.6"
+EXAMPLE_SALT = "AND_SALT [ neon AND reflections:0.7 ] : 0.5"
+EXAMPLE_TOPK = "AND_TOPK [ add freckles AND brighten eyes ] : 0.4"
+EXAMPLE_COMBO = """a rainy street at night
+AND_SALT [ neon signs AND wet asphalt reflections:0.8 ] : 0.5
+AND_PERP [ remove fog AND (crisp edges:1.1) ] : 0.4"""
+EXAMPLE_SCHEDULE = "a sunset over city [a sunrise over city: 18]"
+
+@dataclasses.dataclass
+class AccordionInterface:
+    get_elem_id: Callable
+
+    def __post_init__(self):
+        self.is_rendered = False
+
+        # Верхний слайдер
+        self.cfg_rescale = gr.Slider(
+            label='CFG rescale',
+            minimum=0, maximum=1, value=0
+        )
+
+        # Форматтер
+        self.neutral_prompt = gr.Textbox(
+            label='Neutral prompt',
+            show_label=False,
+            lines=3,
+            placeholder='Neutral prompt (нажмите Apply, чтобы добавить в позитивный промпт)'
+        )
+        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')
+
+        # Гайд и кнопки вставки примеров
+        self.docs_md = gr.Markdown(value=GUIDE_MD)
+        self.btn_ins_base = gr.Button(value='Вставить пример: AND')
+        self.btn_ins_perp = gr.Button(value='Вставить пример: AND_PERP')
+        self.btn_ins_salt = gr.Button(value='Вставить пример: AND_SALT')
+        self.btn_ins_topk = gr.Button(value='Вставить пример: AND_TOPK')
+        self.btn_ins_combo = gr.Button(value='Вставить пример: Комбо')
+        self.btn_ins_schedule = gr.Button(value='Вставить пример: Расписание')
+
+    def arrange_components(self, is_img2img: bool):
+        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()
+            with gr.Accordion(label='Guide & Examples', open=False):
+                self.docs_md.render()
+                with gr.Row():
+                    self.btn_ins_base.render()
+                    self.btn_ins_perp.render()
+                with gr.Row():
+                    self.btn_ins_salt.render()
+                    self.btn_ins_topk.render()
+                with gr.Row():
+                    self.btn_ins_combo.render()
+                    self.btn_ins_schedule.render()
+
+    def connect_events(self, is_img2img: bool):
+        if self.is_rendered:
+            return
+        prompt_textbox = img2img_prompt_textbox if is_img2img else txt2img_prompt_textbox
+
+        def _append(init_prompt: str, prompt: str, scale: float, prompt_type: str):
+            base = (init_prompt or '').rstrip()
+            sep = '\n' if base else ''
+            return f"{base}{sep}{prompt_types[prompt_type]} {prompt} :{scale}", ""
+
+        def _append_example(init_prompt: str, snippet: str):
+            base = (init_prompt or '').rstrip()
+            sep = '\n' if base else ''
+            return f"{base}{sep}{snippet}"
+
+        # Кнопка «Apply to prompt» (форматтер)
+        self.append_to_prompt_button.click(
+            fn=_append,
+            inputs=[prompt_textbox, self.neutral_prompt, self.neutral_cond_scale, self.aux_prompt_type],
+            outputs=[prompt_textbox, self.neutral_prompt]
+        )
+
+        # Кнопки вставки примеров
+        self.btn_ins_base.click(
+            fn=_append_example,
+            inputs=[prompt_textbox, gr.State(EXAMPLE_BASE_AND)],
+            outputs=prompt_textbox
+        )
+        self.btn_ins_perp.click(
+            fn=_append_example,
+            inputs=[prompt_textbox, gr.State(EXAMPLE_PERP)],
+            outputs=prompt_textbox
+        )
+        self.btn_ins_salt.click(
+            fn=_append_example,
+            inputs=[prompt_textbox, gr.State(EXAMPLE_SALT)],
+            outputs=prompt_textbox
+        )
+        self.btn_ins_topk.click(
+            fn=_append_example,
+            inputs=[prompt_textbox, gr.State(EXAMPLE_TOPK)],
+            outputs=prompt_textbox
+        )
+        self.btn_ins_combo.click(
+            fn=_append_example,
+            inputs=[prompt_textbox, gr.State(EXAMPLE_COMBO)],
+            outputs=prompt_textbox
+        )
+        self.btn_ins_schedule.click(
+            fn=_append_example,
+            inputs=[prompt_textbox, gr.State(EXAMPLE_SCHEDULE)],
+            outputs=prompt_textbox
+        )
+
+    def set_rendered(self, value: bool = True):
+        self.is_rendered = value
+
+    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',)))
+
+    def get_paste_field_names(self) -> List[str]:
+        return ['CFG Rescale']
+
+    def get_extra_generation_params(self, args: Dict) -> Dict:
+        return {'CFG Rescale': args['cfg_rescale']}
+
+    def unpack_processing_args(self, cfg_rescale: float) -> Dict:
+        return {'cfg_rescale': cfg_rescale}
+
+def on_ui_settings():
+    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.add_option(
+        'neutral_prompt_verbose',
+        shared.OptionInfo(False, 'Enable verbose debugging for neutral-prompt', section=section)
+    )
+    shared.opts.onchange('neutral_prompt_verbose', update_verbose)
+
+script_callbacks.on_ui_settings(on_ui_settings)
+
+def update_verbose():
+    global_state.verbose = shared.opts.data.get('neutral_prompt_verbose', False)
+
+def on_after_component(component, **_kwargs):
+    if getattr(component, 'elem_id', None) == 'txt2img_prompt':
+        global txt2img_prompt_textbox
+        txt2img_prompt_textbox = component
+    if getattr(component, 'elem_id', None) == 'img2img_prompt':
+        global img2img_prompt_textbox
+        img2img_prompt_textbox = component
+
+script_callbacks.on_after_component(on_after_component)

z-sd-webui-neutral-prompt-workYEAH8/lib_neutral_prompt/global_state.py

@@ -0,0 +1,16 @@
+from typing import List, Optional
+from lib_neutral_prompt import neutral_prompt_parser
+
+
+is_enabled: bool = False
+prompt_exprs: List[neutral_prompt_parser.PromptExpr] = []
+cfg_rescale: float = 0.0
+verbose: bool = False
+cfg_rescale_override: Optional[float] = None
+
+
+def apply_and_clear_cfg_rescale_override():
+    global cfg_rescale, cfg_rescale_override
+    if cfg_rescale_override is not None:
+        cfg_rescale = cfg_rescale_override
+        cfg_rescale_override = None

z-sd-webui-neutral-prompt-workYEAH8/lib_neutral_prompt/hijacker.py

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

z-sd-webui-neutral-prompt-workYEAH8/lib_neutral_prompt/neutral_prompt_parser.py

@@ -0,0 +1,162 @@
+# neutral_prompt_parser.py
+import abc
+import dataclasses
+from enum import Enum
+from typing import List, Tuple, Any, Optional
+import re
+
+class PromptKeyword(Enum):
+    AND = 'AND'
+    AND_PERP = 'AND_PERP'
+    AND_SALT = 'AND_SALT'
+    AND_TOPK = 'AND_TOPK'
+
+prompt_keywords = [e.value for e in PromptKeyword]
+
+class ConciliationStrategy(Enum):
+    PERPENDICULAR = PromptKeyword.AND_PERP.value
+    SALIENCE_MASK = PromptKeyword.AND_SALT.value
+    SEMANTIC_GUIDANCE = PromptKeyword.AND_TOPK.value
+
+conciliation_strategies = [e.value for e in ConciliationStrategy]
+
+@dataclasses.dataclass
+class PromptExpr(abc.ABC):
+    weight: float
+    conciliation: Optional[ConciliationStrategy]
+
+    @abc.abstractmethod
+    def accept(self, visitor, *args, **kwargs) -> Any:
+        ...
+
+@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
+
+def parse_root(string: str) -> CompositePrompt:
+    tokens = tokenize(string)
+    skip_leading_ws(tokens)
+    prompts = parse_prompts(tokens)
+    return CompositePrompt(1.0, None, prompts)
+
+def parse_prompts(tokens: List[str], *, nested: bool = False, closing_token: Optional[str] = None) -> List[PromptExpr]:
+    prompts: List[PromptExpr] = []
+    while tokens:
+        # если задали явный закрывающий токен (например, ']') — останавливаемся ровно на нём
+        if nested and closing_token and tokens[0] == closing_token:
+            break
+        # обратная совместимость: если closing_token не задан, но мы внутри — выходим на первой закрывающей
+        if nested and not closing_token and tokens[0] in [']', ')']:
+            break
+        prompts.append(parse_prompt(tokens, first=(len(prompts) == 0)))
+        skip_leading_ws(tokens)
+    return prompts
+
+def skip_leading_ws(tokens: List[str]):
+    while tokens and tokens[0].strip() == '':
+        tokens.pop(0)
+
+def parse_prompt(tokens: List[str], *, first: bool) -> PromptExpr:
+    skip_leading_ws(tokens)
+
+    # ключевое слово допускается и в начале
+    conc: Optional[ConciliationStrategy] = None
+    if tokens and tokens[0] in prompt_keywords:
+        op = tokens.pop(0)
+        conc = ConciliationStrategy(op) if op in conciliation_strategies else None
+        skip_leading_ws(tokens)
+
+    # [ ... ] : weight   → CompositePrompt
+    if tokens and tokens[0] == '[':
+        tokens.pop(0)
+        children = parse_prompts(tokens, nested=True, closing_token=']')
+        if tokens and tokens[0] == ']':
+            tokens.pop(0)  # <<< consume ']'
+        skip_leading_ws(tokens)
+        weight = 1.0
+        if tokens and tokens[0] == ':':
+            tokens.pop(0); skip_leading_ws(tokens)
+            if tokens and is_float(tokens[0]):
+                weight = float(tokens.pop(0))
+        return CompositePrompt(weight, conc, children)
+
+    # ( text : weight ) → LeafPrompt
+    if tokens and tokens[0] == '(':
+        tokens.pop(0)
+        text, weight = parse_prompt_text(tokens, nested=True)
+        if tokens and tokens[0] == ':':
+            tokens.pop(0); skip_leading_ws(tokens)
+            if tokens and is_float(tokens[0]):
+                weight = float(tokens.pop(0))
+        if tokens and tokens[0] == ')':
+            tokens.pop(0)  # <<< consume ')'
+        return LeafPrompt(weight, conc, text.strip())
+
+    # plain text (может оканчиваться на ": float")
+    text, weight = parse_prompt_text(tokens, nested=False)
+    m = re.match(r'^(.*?)(?:\s*:\s*)([-+]?\d+(?:\.\d+)?\s*)$', text)
+    if m:
+        text = m.group(1).strip()
+        try:
+            weight = float(m.group(2))
+        except Exception:
+            weight = 1.0
+    return LeafPrompt(weight, conc, text.strip())
+
+def parse_prompt_text(tokens: List[str], *, nested: bool) -> Tuple[str, float]:
+    # собираем текст, НЕ поедая закрывающие скобки верхнего уровня
+    parts: List[str] = []
+    weight = 1.0
+    depth = 0
+    while tokens:
+        t = tokens[0]
+        if nested and depth == 0:
+            # стоп на закрывающей верхнего уровня — не съедаем её (пусть родитель снимет)
+            if t in [')', ']']:
+                break
+            # стоп перед шаблоном ": <float> )|]" — вес заберёт родитель
+            if t == ':' and len(tokens) >= 3 and is_float(tokens[1]) and tokens[2].strip() in [')', ']']:
+                break
+        # стоп на ключевом слове на верхнем уровне
+        if t in prompt_keywords and depth == 0:
+            break
+        if t in ('(', '['):
+            depth += 1
+        elif t in (')', ']'):
+            if depth == 0:
+                break
+            depth -= 1
+        parts.append(tokens.pop(0))
+    text = ''.join(parts).strip()
+    # post: если сразу после текста идёт ": <float>" (для плоского случая)
+    if len(tokens) >= 2 and tokens[0] == ':' and is_float(tokens[1]):
+        tokens.pop(0)
+        weight = float(tokens.pop(0))
+    return text, weight
+
+def tokenize(s: str) -> List[str]:
+    # режем по (), [], :, и ключевым словам; пробелы сохраняем отдельными токенами
+    kw_regex = '|'.join(r'\b' + re.escape(k) + r'\b' for k in prompt_keywords)
+    pattern = r'(\(|\)|\[|\]|:|' + kw_regex + r')'
+    return [x for x in re.split(pattern, s) if x != '']
+
+def is_float(x: str) -> bool:
+    try:
+        float(x)
+        return True
+    except Exception:
+        return False

z-sd-webui-neutral-prompt-workYEAH8/lib_neutral_prompt/prompt_parser_hijack.py

@@ -0,0 +1,88 @@
+# lib_neutral_prompt/prompt_parser_hijack.py
+import lark  # оставим импорт, если webui его уже тянет
+from modules import prompt_parser, script_callbacks
+from . import neutral_prompt_parser, hijacker, global_state
+
+class WebuiPromptVisitor:
+    """Транспилирует наше дерево в webui-совместимую строку:
+       - лист:  (text:weight)
+       - составной: child1 AND child2 ...
+    """
+    def visit_leaf_prompt(self, that: neutral_prompt_parser.LeafPrompt) -> str:
+        text = str(getattr(that, "prompt", "")).strip()
+        w = float(getattr(that, "weight", 1.0) or 1.0)
+        return f"({text}:{w})" if text else ""
+
+    def visit_composite_prompt(self, that: neutral_prompt_parser.CompositePrompt) -> str:
+        parts = [child.accept(self) for child in getattr(that, "children", [])]
+        parts = [p for p in parts if p]
+        return " AND ".join(parts)
+
+# ✅ создаём хижакер с обязательным hijacker_attribute (как в cfg_denoiser_hijack)
+prompt_parser_hijacker = hijacker.ModuleHijacker.install_or_get(
+    module=prompt_parser,
+    hijacker_attribute="__neutral_prompt_hijacker",
+    on_uninstall=script_callbacks.on_script_unloaded,
+)
+
+def parse_prompts(prompts):
+    """
+    Принимает: строку, список/кортеж строк, или prompt_parser.SdConditioning.
+    Возвращает: List[str] — вебуишные строки вида "(text:weight) AND (...)".
+    Параллельно сохраняет raw_prompts и разобранные expr'ы в global_state.
+    """
+    # 1) Нормализуем вход к List[str]
+    SdConditioning = getattr(prompt_parser, "SdConditioning", None)
+
+    if SdConditioning is not None and isinstance(prompts, SdConditioning):
+        # SdConditioning может быть итерируемым набором саб-промптов
+        try:
+            webui_prompts = [str(p) for p in prompts]
+        except Exception:
+            webui_prompts = list(prompts)
+    elif isinstance(prompts, (list, tuple)):
+        webui_prompts = ["" if p is None else str(p) for p in prompts]
+    elif prompts is None:
+        webui_prompts = [""]
+    else:
+        webui_prompts = [str(prompts)]
+
+    # 2) Сохраняем «сырые» промпты для расписаний WebUI
+    global_state.raw_prompts = webui_prompts[:]
+
+    # 3) Парсим в expr-деревья и кладём в глобальное состояние
+    exprs = [neutral_prompt_parser.parse_root(p) for p in webui_prompts]
+    global_state.prompt_exprs = exprs
+
+    # 4) Транспилируем expr -> webui-строки совместимые с get_multicond_prompt_list
+    visitor = WebuiPromptVisitor()
+    return [expr.accept(visitor) for expr in exprs]
+
+@prompt_parser_hijacker.hijack("get_multicond_prompt_list")
+def get_multicond_prompt_list_hijack(prompts, original_function):
+    if not getattr(global_state, "is_enabled", False):
+        return original_function(prompts)
+
+    # 1) Нормализуем вход в список строк
+    SdCond = getattr(prompt_parser, "SdConditioning", None)
+    if SdCond and isinstance(prompts, SdCond):
+        try:
+            webui_prompts = [str(p) for p in prompts]  # у вас SdConditioning — итерируемый список строк
+        except Exception:
+            webui_prompts = list(prompts)
+    elif isinstance(prompts, list):
+        webui_prompts = [str(p) for p in prompts]
+    else:
+        webui_prompts = [str(prompts)]
+
+    # 2) Сохраняем «сырые» промпты для webui-расписаний
+    global_state.raw_prompts = webui_prompts[:]
+
+    # 3) Строим expr'ы и держим их в глобальном состоянии
+    exprs = [neutral_prompt_parser.parse_root(p) for p in webui_prompts]
+    global_state.prompt_exprs = exprs
+
+    # 4) Возвращаем webui-совместимые строки (AND и (text:weight))
+    visitor = WebuiPromptVisitor()
+    transpiled = [expr.accept(visitor) for expr in exprs]
+    return original_function(transpiled)

z-sd-webui-neutral-prompt-workYEAH8/lib_neutral_prompt/ui.py

@@ -0,0 +1,255 @@
+# lib_neutral_prompt/ui.py
+from lib_neutral_prompt import global_state, neutral_prompt_parser
+from modules import script_callbacks, shared
+from typing import Dict, Tuple, List, Callable
+import gradio as gr
+import dataclasses
+
+txt2img_prompt_textbox = None
+img2img_prompt_textbox = None
+
+# Только поддерживаемые типы
+prompt_types = {
+    'Perpendicular': neutral_prompt_parser.PromptKeyword.AND_PERP.value,
+    'Saliency-aware': neutral_prompt_parser.PromptKeyword.AND_SALT.value,
+    'Semantic guidance top-k': neutral_prompt_parser.PromptKeyword.AND_TOPK.value,
+}
+
+prompt_types_tooltip = '\n'.join([
+    'AND — базовое сложение фич (встроено в WebUI, режим по умолчанию)',
+    'Perpendicular (AND_PERP) — подавляет противоречащие фичи',
+    'Saliency-aware (AND_SALT) — побеждают самые «заметные» фичи',
+    'Semantic guidance top-k (AND_TOPK) — таргетные точечные изменения',
+])
+
+GUIDE_MD = """
+### Neutral z prompt — Guide & Examples
+
+**Как это работает**
+- `AND` — обычная сумма фич. Пишется напрямую в промпте: `a AND (b:1.2)`
+- Расширенные режимы оформляются ключевыми словами и **квадратными скобками**:
+  - `AND_PERP [ ... ] : w` — *перпендикулярная* компонента. Помогает «убрать конфликтующее».
+  - `AND_SALT [ ... ] : w` — *saliency-aware*. Смешивает в пользу «самых заметных» участков.
+  - `AND_TOPK [ ... ] : w` — *semantic top-k*. Оставляет только самые сильные (по модулю) изменения.
+
+**Веса**
+- Внутри скобок: `(text:0.8)` — классика WebUI.
+- В плоском виде: `text:0.8` — тоже поддерживается.
+- Вес группы: `AND_SALT [ a AND (b:0.7) ] : 0.5` — общий вес умножится на вклад детей.
+
+**Быстрые примеры**
+```text
+# Базовый AND
+a cinematic portrait AND (dramatic lighting:1.2)
+
+# Perpendicular: добавь деталь, не ломая основной стиль
+AND_PERP [ cinematic lighting AND (sharp details:1.1) ] : 0.6
+
+# Saliency-aware: усили неон и отблески
+AND_SALT [ neon AND reflections:0.7 ] : 0.5
+
+# Semantic top-k: точечные правки лица
+AND_TOPK [ add freckles AND brighten eyes ] : 0.4
+```
+
+**Комбо-примеры**
+```text
+# Комбинация SALT + PERP
+a rainy street at night
+AND_SALT [ neon signs AND wet asphalt reflections:0.8 ] : 0.5
+AND_PERP [ remove fog AND (crisp edges:1.1) ] : 0.4
+
+# Комбинация TOPK + AND
+a studio headshot
+AND_TOPK [ enhance iris detail AND subtle skin texture ] : 0.35
+AND (soft key light:1.15)
+```
+
+**Расписания (prompt travel) — делает сам WebUI**
+- Используй стандартный синтаксис WebUI, например:
+```text
+a sunset over city [a sunrise over city: 18]
+```
+- Наше расширение берёт **исходный текст** (raw prompt) для расписаний, поэтому просто пиши как обычно.
+- Расширенные блоки тоже можно комбинировать с расписанием (WebUI решит активный текст на каждом шаге).
+
+**Советы**
+- Пиши «расширенные» блоки ближе к концу промпта и увеличивай вес постепенно (`0.3 → 0.6`).
+- Если что-то «перетягивает одеяло», снизь вес блока или листьев внутри него.
+- Не злоупотребляй количеством расширенных блоков: один-два аккуратных блока обычно лучше.
+"""
+
+# Готовые примеры для кнопок вставки
+EXAMPLE_BASE_AND = "a cinematic portrait AND (dramatic lighting:1.2)"
+EXAMPLE_PERP = "AND_PERP [ cinematic lighting AND (sharp details:1.1) ] : 0.6"
+EXAMPLE_SALT = "AND_SALT [ neon AND reflections:0.7 ] : 0.5"
+EXAMPLE_TOPK = "AND_TOPK [ add freckles AND brighten eyes ] : 0.4"
+EXAMPLE_COMBO = """a rainy street at night
+AND_SALT [ neon signs AND wet asphalt reflections:0.8 ] : 0.5
+AND_PERP [ remove fog AND (crisp edges:1.1) ] : 0.4"""
+EXAMPLE_SCHEDULE = "a sunset over city [a sunrise over city: 18]"
+
+@dataclasses.dataclass
+class AccordionInterface:
+    get_elem_id: Callable
+
+    def __post_init__(self):
+        self.is_rendered = False
+
+        # Верхний слайдер
+        self.cfg_rescale = gr.Slider(
+            label='CFG rescale',
+            minimum=0, maximum=1, value=0
+        )
+
+        # Форматтер
+        self.neutral_prompt = gr.Textbox(
+            label='Neutral z prompt',
+            show_label=False,
+            lines=3,
+            placeholder='Neutral z prompt (нажмите Apply, чтобы добавить в позитивный промпт)'
+        )
+        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')
+
+        # Гайд и кнопки вставки примеров
+        self.docs_md = gr.Markdown(value=GUIDE_MD)
+        self.btn_ins_base = gr.Button(value='Вставить пример: AND')
+        self.btn_ins_perp = gr.Button(value='Вставить пример: AND_PERP')
+        self.btn_ins_salt = gr.Button(value='Вставить пример: AND_SALT')
+        self.btn_ins_topk = gr.Button(value='Вставить пример: AND_TOPK')
+        self.btn_ins_combo = gr.Button(value='Вставить пример: Комбо')
+        self.btn_ins_schedule = gr.Button(value='Вставить пример: Расписание')
+
+    def arrange_components(self, is_img2img: bool):
+        if self.is_rendered:
+            return
+        with gr.Accordion(label='Neutral z 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()
+            with gr.Accordion(label='Guide & Examples', open=False):
+                self.docs_md.render()
+                with gr.Row():
+                    self.btn_ins_base.render()
+                    self.btn_ins_perp.render()
+                with gr.Row():
+                    self.btn_ins_salt.render()
+                    self.btn_ins_topk.render()
+                with gr.Row():
+                    self.btn_ins_combo.render()
+                    self.btn_ins_schedule.render()
+
+    def connect_events(self, is_img2img: bool):
+        if self.is_rendered:
+            return
+        prompt_textbox = img2img_prompt_textbox if is_img2img else txt2img_prompt_textbox
+
+        def _append(init_prompt: str, prompt: str, scale: float, prompt_type: str):
+            base = (init_prompt or '').rstrip()
+            sep = '\n' if base else ''
+            return f"{base}{sep}{prompt_types[prompt_type]} {prompt} :{scale}", ""
+
+        def _append_example(init_prompt: str, snippet: str):
+            base = (init_prompt or '').rstrip()
+            sep = '\n' if base else ''
+            return f"{base}{sep}{snippet}"
+
+        # Кнопка «Apply to prompt» (форматтер)
+        self.append_to_prompt_button.click(
+            fn=_append,
+            inputs=[prompt_textbox, self.neutral_prompt, self.neutral_cond_scale, self.aux_prompt_type],
+            outputs=[prompt_textbox, self.neutral_prompt]
+        )
+
+        # Кнопки вставки примеров
+        self.btn_ins_base.click(
+            fn=_append_example,
+            inputs=[prompt_textbox, gr.State(EXAMPLE_BASE_AND)],
+            outputs=prompt_textbox
+        )
+        self.btn_ins_perp.click(
+            fn=_append_example,
+            inputs=[prompt_textbox, gr.State(EXAMPLE_PERP)],
+            outputs=prompt_textbox
+        )
+        self.btn_ins_salt.click(
+            fn=_append_example,
+            inputs=[prompt_textbox, gr.State(EXAMPLE_SALT)],
+            outputs=prompt_textbox
+        )
+        self.btn_ins_topk.click(
+            fn=_append_example,
+            inputs=[prompt_textbox, gr.State(EXAMPLE_TOPK)],
+            outputs=prompt_textbox
+        )
+        self.btn_ins_combo.click(
+            fn=_append_example,
+            inputs=[prompt_textbox, gr.State(EXAMPLE_COMBO)],
+            outputs=prompt_textbox
+        )
+        self.btn_ins_schedule.click(
+            fn=_append_example,
+            inputs=[prompt_textbox, gr.State(EXAMPLE_SCHEDULE)],
+            outputs=prompt_textbox
+        )
+
+    def set_rendered(self, value: bool = True):
+        self.is_rendered = value
+
+    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',)))
+
+    def get_paste_field_names(self) -> List[str]:
+        return ['CFG Rescale']
+
+    def get_extra_generation_params(self, args: Dict) -> Dict:
+        return {'CFG Rescale': args['cfg_rescale']}
+
+    def unpack_processing_args(self, cfg_rescale: float) -> Dict:
+        return {'cfg_rescale': cfg_rescale}
+
+def on_ui_settings():
+    section = ('neutral_prompt', 'Neutral z prompt')
+    shared.opts.add_option(
+        'neutral_prompt_enabled',
+        shared.OptionInfo(True, 'Enable neutral-z-prompt extension', section=section)
+    )
+    global_state.is_enabled = shared.opts.data.get('neutral_prompt_enabled', True)
+
+    shared.opts.add_option(
+        'neutral_prompt_verbose',
+        shared.OptionInfo(False, 'Enable verbose debugging for neutral-z-prompt', section=section)
+    )
+    shared.opts.onchange('neutral_prompt_verbose', update_verbose)
+
+script_callbacks.on_ui_settings(on_ui_settings)
+
+def update_verbose():
+    global_state.verbose = shared.opts.data.get('neutral_prompt_verbose', False)
+
+def on_after_component(component, **_kwargs):
+    if getattr(component, 'elem_id', None) == 'txt2img_prompt':
+        global txt2img_prompt_textbox
+        txt2img_prompt_textbox = component
+    if getattr(component, 'elem_id', None) == 'img2img_prompt':
+        global img2img_prompt_textbox
+        img2img_prompt_textbox = component
+
+script_callbacks.on_after_component(on_after_component)

z-sd-webui-neutral-prompt-workYEAH8/lib_neutral_prompt/xyz_grid.py

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

z-sd-webui-neutral-prompt-workYEAH8/scripts/neutral_prompt.py

@@ -0,0 +1,99 @@
+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 Z 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_z_prompt_enabled', True)
+
+        for k, v in args.items():
+            try:
+                getattr(global_state, k)
+            except AttributeError:
+                continue
+
+            # Значение пришло из X/Y Grid и помечено подклассом float.
+            current = getattr(global_state, k)
+            if getattr(type(current), 'is_xyz', False):
+                # применяем только на этот прогон; в global_state не записываем
+                args[k] = float(current)
+                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)
+
+    # parse_prompts уже возвращает List[str]
+    transformed_prompts = prompt_parser_hijack.parse_prompts(p.all_prompts)
+    all_prompts, p.all_prompts = p.all_prompts, transformed_prompts
+    try:
+        res = original_function(p, *args, **kwargs)
+    finally:
+        # обязательно вернуть исходные промпты
+        p.all_prompts = all_prompts
+    return res
+
+
+
+xyz_grid.patch()

z-sd-webui-neutral-prompt-workYEAH8/test/perp_parser/basic_test.py

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

z-sd-webui-neutral-prompt-workYEAH8/test/perp_parser/malicious_test.py

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