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

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

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

z-sd-webui-neutral-prompt-workYEAH4/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-workYEAH4/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-workYEAH4/lib_neutral_prompt/cfg_denoiser_hijack.py

@@ -0,0 +1,440 @@
+# 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
+import sys
+import textwrap
+
+
+# -----------------------------
+# Utils / warnings
+# -----------------------------
+
+def console_warn(message: str):
+    if not getattr(global_state, "verbose", False):
+        return
+    print(
+        f"\n[sd-webui-neutral-prompt] WARNING: {textwrap.dedent(message)}\n"
+        f"Please check for conflicts with other prompt-parsing extensions or report at "
+        f"https://github.com/ljleb/sd-webui-neutral-prompt/issues",
+        file=sys.stderr,
+    )
+
+
+def warn_unsupported_sampler():
+    console_warn(
+        """
+        Neutral Prompt composition via AND is unsupported by DDIM / PLMS / UniPC in webui.
+        The sampler will NOT be patched — falling back to original combine_denoised...
+        """
+    )
+
+
+def warn_projection_not_found():
+    console_warn(
+        """
+        Could not find a stable projection for one or more AND_PERP prompts.
+        Those prompts will NOT be made perpendicular at the very first steps.
+        """
+    )
+
+
+# -----------------------------
+# 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:
+    # пропускаем только самые большие по модулю компоненты
+    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) -> torch.Tensor:
+    # проецируем vector на подпространство, перпендикулярное normal
+    if (normal == 0).all():
+        # на первых шагам проекция может быть нулевой — не шумим логом чаще одного раза в начало семплинга
+        if getattr(shared.state, "sampling_step", 0) <= 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]]) -> torch.Tensor:
+    # пиксельно выбираем «самый заметный» вектор; складываем дельты относительно 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())
+        if base_size != len(cond_indices) and getattr(global_state, "verbose", False):
+            console_warn(
+                f"BaseSize({base_size}) != cond_indices({len(cond_indices)}) at batch {batch_i}. "
+                f"Another extension may also modify parsing."
+            )
+
+        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]
+        if that.weight != cond_info[1] and getattr(global_state, "verbose", False):
+            console_warn(
+                f"""
+                An unexpected noise weight was encountered at prompt #{index}
+                Expected: {that.weight}, but got: {cond_info[1]}
+                This may happen if another extension monkey-patches combine_denoised.
+                """
+            )
+        # разница между 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)
+
+            # композиционные стратегии, влияющие на сложение delta
+            cs = getattr(that, "conciliation", None)
+            if cs in (
+                neutral_prompt_parser.ConciliationStrategy.ALTERNATE,
+                neutral_prompt_parser.ConciliationStrategy.ALTERNATE1,
+                neutral_prompt_parser.ConciliationStrategy.ALTERNATE2,
+                neutral_prompt_parser.ConciliationStrategy.SEQUENCE,
+                neutral_prompt_parser.ConciliationStrategy.NESTED_SEQUENCE,
+                neutral_prompt_parser.ConciliationStrategy.TOP_LEVEL_SEQUENCE,
+            ):
+                cond_delta += child_cond_delta
+            elif cs == neutral_prompt_parser.ConciliationStrategy.SALIENCE_MASK:
+                cond_delta += salient_blend(cond_delta, [(child_cond_delta, child.weight)])
+            else:
+                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)
+                elif child.conciliation in (
+                    neutral_prompt_parser.ConciliationStrategy.ALTERNATE,
+                    neutral_prompt_parser.ConciliationStrategy.ALTERNATE1,
+                    neutral_prompt_parser.ConciliationStrategy.ALTERNATE2,
+                    neutral_prompt_parser.ConciliationStrategy.SEQUENCE,
+                    neutral_prompt_parser.ConciliationStrategy.NESTED_SEQUENCE,
+                    neutral_prompt_parser.ConciliationStrategy.TOP_LEVEL_SEQUENCE,
+                ):
+                    aux_cond_delta += child_cond_delta
+
+            # шаг только по БАЗОВЫМ листьям
+            index += child.accept(BaseSizeVisitor())
+
+        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-workYEAH4/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-workYEAH4/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-workYEAH4/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 = True
+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-workYEAH4/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-workYEAH4/lib_neutral_prompt/neutral_prompt_parser.py

@@ -0,0 +1,225 @@
+import abc
+import dataclasses
+import re
+from enum import Enum
+from typing import List, Tuple, Any, Optional
+
+class PromptKeyword(Enum):
+    AND = 'AND'
+    AND_PERP = 'AND_PERP'
+    AND_SALT = 'AND_SALT'
+    AND_TOPK = 'AND_TOPK'
+    ALTERNATE = '|'
+    AND_RULE = '&'
+    GROUPED = '{'
+    SEQUENCE = '::'
+    ALTERNATE1 = 'alternate1'
+    ALTERNATE2 = 'alternate2'
+    TOP_LEVEL_SEQUENCE = 'top_level_sequence'
+    NESTED_SEQUENCE = 'nested_sequence'
+
+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
+    ALTERNATE = PromptKeyword.ALTERNATE.value
+    AND_RULE = PromptKeyword.AND_RULE.value
+    GROUPED = PromptKeyword.GROUPED.value
+    SEQUENCE = PromptKeyword.SEQUENCE.value
+    ALTERNATE1 = PromptKeyword.ALTERNATE1.value
+    ALTERNATE2 = PromptKeyword.ALTERNATE2.value
+    TOP_LEVEL_SEQUENCE = PromptKeyword.TOP_LEVEL_SEQUENCE.value
+    NESTED_SEQUENCE = PromptKeyword.NESTED_SEQUENCE.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:
+        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
+
+def parse_root(string: str) -> CompositePrompt:
+    tokens = tokenize(string)
+    prompts = parse_prompts(tokens)
+    return CompositePrompt(1.0, None, prompts)
+
+def parse_prompts(tokens: List[str], *, nested: bool = False) -> List[PromptExpr]:
+    prompts = []
+    while tokens:
+        if nested and tokens[0] in [']', '}']:
+            break
+        prompts.append(parse_prompt(tokens, first=len(prompts) == 0, nested=nested))
+    return prompts
+
+def parse_prompt(tokens: List[str], *, first: bool, nested: bool = False) -> PromptExpr:
+    if not first and tokens[0] in prompt_keywords:
+        prompt_type = tokens.pop(0)
+    else:
+        prompt_type = PromptKeyword.AND.value
+
+    tokens_copy = tokens.copy()
+    # Поддержка [prompt1|prompt2] и [prompt1:prompt2:step]
+    if tokens_copy and tokens_copy[0] == '[':
+        tokens_copy.pop(0)
+
+        # 🔧 ВАЖНО: дефолтное значение, иначе UnboundLocalError
+        conciliation = None
+
+        prompts = [parse_prompt(tokens_copy, first=True, nested=True)]
+        if tokens_copy and tokens_copy[0] == '|':  # [a|b]
+            tokens_copy.pop(0)
+            prompts.append(parse_prompt(tokens_copy, first=False, nested=True))
+            conciliation = ConciliationStrategy.ALTERNATE
+            if tokens_copy and tokens_copy[0] == '!':  # [a|b!]
+                tokens_copy.pop(0)
+                conciliation = ConciliationStrategy.ALTERNATE1
+
+        elif tokens_copy and tokens_copy[0] == ':':  # [a:b(:step)]
+            tokens_copy.pop(0)
+            prompts.append(parse_prompt(tokens_copy, first=False, nested=True))
+            if tokens_copy and tokens_copy[0] == ':':
+                tokens_copy.pop(0)
+                if tokens_copy and is_float(tokens_copy[0]):
+                    tokens_copy.pop(0)  # step игнорим на этом уровне
+
+        if tokens_copy and tokens_copy[0] == ']':
+            tokens_copy.pop(0)
+
+        tokens[:] = tokens_copy
+        weight = parse_weight(tokens)
+        return CompositePrompt(weight, conciliation, prompts)
+
+    
+    # Поддержка (prompt:weight)
+    if tokens_copy and tokens_copy[0] == '(':
+        tokens_copy.pop(0)
+        prompt_text, weight = parse_prompt_text(tokens_copy, nested=True)
+        if tokens_copy and tokens_copy[0] == ':':
+            tokens_copy.pop(0)
+            if tokens_copy and is_float(tokens_copy[0]):
+                weight = float(tokens_copy.pop(0))
+        if tokens_copy and tokens_copy[0] == ')':
+            tokens_copy.pop(0)
+        tokens[:] = tokens_copy
+        return LeafPrompt(weight, None, prompt_text)
+    
+    # Поддержка {grouped}
+    if tokens_copy and tokens_copy[0] == '{':
+        tokens_copy.pop(0)
+        prompts = parse_prompts(tokens_copy, nested=True)
+        if tokens_copy and tokens_copy[0] == '}':
+            tokens_copy.pop(0)
+        tokens[:] = tokens_copy
+        weight = parse_weight(tokens)
+        return CompositePrompt(weight, ConciliationStrategy.GROUPED, prompts)
+    
+    # Поддержка & и ::
+    if tokens_copy and tokens_copy[0] in ['&', '::']:
+        op = tokens_copy.pop(0)
+        prompts = parse_prompts(tokens_copy, nested=True)
+        tokens[:] = tokens_copy
+        weight = parse_weight(tokens)
+        conciliation = ConciliationStrategy.AND_RULE if op == '&' else ConciliationStrategy.SEQUENCE
+        return CompositePrompt(weight, conciliation, prompts)
+    
+    # Поддержка top_level_sequence и nested_sequence
+    if tokens_copy and tokens_copy[0] == '::' and tokens_copy[-1] in ['!', ';']:
+        tokens_copy.pop(0)
+        prompts = parse_prompts(tokens_copy, nested=True)
+        if tokens_copy and tokens_copy[0] in ['!', ';']:
+            tokens_copy.pop(0)
+        tokens[:] = tokens_copy
+        weight = parse_weight(tokens)
+        return CompositePrompt(weight, ConciliationStrategy.NESTED_SEQUENCE, prompts)
+    
+    if tokens_copy and '!!' in tokens_copy:
+        idx = tokens_copy.index('!!')
+        owner = parse_prompt(tokens_copy[:idx], first=True, nested=nested)
+        tokens_copy = tokens_copy[idx+1:]
+        prompts = [owner] + parse_prompts(tokens_copy, nested=True)
+        tokens[:] = tokens_copy
+        weight = parse_weight(tokens)
+        return CompositePrompt(weight, ConciliationStrategy.TOP_LEVEL_SEQUENCE, prompts)
+
+    prompt_text, weight = parse_prompt_text(tokens, nested=nested)
+    return LeafPrompt(weight, ConciliationStrategy(prompt_type) if prompt_type in conciliation_strategies else None, prompt_text)
+
+def parse_prompt_text(tokens: List[str], *, nested: bool = False) -> Tuple[str, float]:
+    text = ''
+    depth = 0
+    weight = 1.0
+    while tokens:
+        if tokens[0] in [']', '}'] and depth == 0 and nested:
+            break
+        elif tokens[0] in ['[', '{', '(']:
+            depth += 1
+        elif tokens[0] in [')', ']']:
+            depth -= 1
+        elif tokens[0] == ':' and len(tokens) >= 2 and is_float(tokens[1].strip()):
+            if len(tokens) < 3 or tokens[2] in prompt_keywords or tokens[2] in [']', ')', '}'] and depth == 0:
+                tokens.pop(0)
+                weight = float(tokens.pop(0).strip())
+                break
+        elif tokens[0] in prompt_keywords and depth == 0:
+            break
+        text += tokens.pop(0)
+    return text, weight
+
+def parse_weight(tokens: List[str]) -> float:
+    weight = 1.0
+    if len(tokens) >= 2 and tokens[0] == ':' and is_float(tokens[1]):
+        tokens.pop(0)
+        weight = float(tokens.pop(0))
+    return weight
+
+def tokenize(s: str):
+    prompt_keywords_regex = '|'.join(r'\b' + re.escape(keyword) + r'\b' for keyword in prompt_keywords)
+    pattern = r'(\[|\]|\(|\)|:|\{|\}|&|\||' + prompt_keywords_regex + r')'
+    return [s for s in re.split(pattern, s) if s.strip()]
+
+def is_float(string: str) -> bool:
+    try:
+        float(string)
+        return True
+    except ValueError:
+        return False
+
+if __name__ == '__main__':
+    res = parse_root('''
+    hello
+    AND_PERP [
+        arst
+        AND defg : 2
+        AND_SALT [
+            very nested huh? what do you say :.0
+        ]
+    ]
+    ''')
+    pass

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

@@ -0,0 +1,207 @@
+from __future__ import annotations
+from typing import List
+import logging
+import lark
+
+from lib_neutral_prompt import hijacker, global_state, neutral_prompt_parser
+from modules import script_callbacks, prompt_parser
+from modules.prompt_parser import schedule_parser, resolve_tree
+
+logging.basicConfig(level=logging.WARNING)
+logger = logging.getLogger(__name__)
+
+prompt_parser_hijacker = hijacker.ModuleHijacker.install_or_get(
+    module=prompt_parser,
+    hijacker_attribute='__neutral_prompt_hijacker',
+    on_uninstall=script_callbacks.on_script_unloaded,
+)
+
+def convert_to_prompt_expr(prompts: List[str], conds_list=None):
+    exprs: List[neutral_prompt_parser.PromptExpr] = []
+    if conds_list:  # берём индексы/веса из оригинального парсера, если он их дал
+        for batch_conds in conds_list:
+            for idx, weight in batch_conds:
+                prompt_text = prompts[idx] if 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
+
+    # fallback — разбираем сами деревом
+    for prompt in prompts:
+        try:
+            tree = schedule_parser.parse(prompt)
+            expr = tree_to_prompt_expr(tree)
+            exprs.append(expr)
+        except lark.exceptions.LarkError as e:
+            logger.warning("Failed to parse prompt '%s': %s", prompt, e)
+            exprs.append(
+                neutral_prompt_parser.LeafPrompt(
+                    weight=1.0, conciliation=None, prompt=prompt
+                )
+            )
+    return exprs
+
+
+def tree_to_prompt_expr(tree: lark.Tree | lark.Token) -> neutral_prompt_parser.PromptExpr:
+    """Преобразует lark.Tree в PromptExpr Neutral Prompt."""
+    # Листовой токен
+    if isinstance(tree, lark.Token):
+        return neutral_prompt_parser.LeafPrompt(weight=1.0, conciliation=None, prompt=str(tree))
+
+    data = getattr(tree, "data", None)
+
+    if data == "plain":
+        # plain всегда Token внутри грамматики
+        return neutral_prompt_parser.LeafPrompt(weight=1.0, conciliation=None, prompt=tree.children[0].value)
+
+    elif data in ("alternate", "alternate1", "alternate2"):
+        # фильтруем пробелы безопасно
+        children = [
+            tree_to_prompt_expr(child)
+            for child in tree.children
+            if not (isinstance(child, lark.Token) and child.type == "WHITESPACE")
+        ]
+        # Храним как один тип ALTERNATE — выбор сделает визитор при транспиляции
+        return neutral_prompt_parser.CompositePrompt(
+            weight=1.0,
+            conciliation=neutral_prompt_parser.ConciliationStrategy.ALTERNATE,
+            children=children
+        )
+
+    elif data == "grouped":
+        children = [
+            tree_to_prompt_expr(child)
+            for child in tree.children
+            if not (isinstance(child, lark.Token) and child.type == "WHITESPACE")
+        ]
+        return neutral_prompt_parser.CompositePrompt(
+            weight=1.0,
+            conciliation=neutral_prompt_parser.ConciliationStrategy.GROUPED,
+            children=children
+        )
+
+    elif data == "and_rule":
+        children = [
+            tree_to_prompt_expr(child)
+            for child in tree.children
+            if not (isinstance(child, lark.Token) and child.type == "WHITESPACE")
+        ]
+        return neutral_prompt_parser.CompositePrompt(
+            weight=1.0,
+            conciliation=neutral_prompt_parser.ConciliationStrategy.AND_RULE,
+            children=children
+        )
+
+    elif data == "sequence":
+        children = [
+            tree_to_prompt_expr(child)
+            for child in tree.children
+            if not (isinstance(child, lark.Token) and child.type == "WHITESPACE")
+        ]
+        return neutral_prompt_parser.CompositePrompt(
+            weight=1.0,
+            conciliation=neutral_prompt_parser.ConciliationStrategy.SEQUENCE,
+            children=children
+        )
+
+    elif data == "emphasized":
+        # безопасно читаем вес: второй элемент может быть Token/Tree/отсутствовать
+        prompt_expr = tree_to_prompt_expr(tree.children[0])
+        w = 1.1
+        if len(tree.children) > 1 and isinstance(tree.children[1], lark.Token) and tree.children[1].type == "NUMBER":
+            try:
+                w = float(tree.children[1])
+            except (ValueError, TypeError):
+                w = 1.0
+        prompt_expr.weight = w
+        return prompt_expr
+
+    elif data == "numbered":
+        quantity = int(tree.children[0])
+        distinct = (str(tree.children[1]) == "!") if len(tree.children) > 1 else False  # корректная проверка
+        target = tree_to_prompt_expr(tree.children[-1])
+
+        # В текущей модели PromptExpr нет «мешка выбора», просто дублируем target.
+        # (Если нужно «distinct», это можно отразить внутри transpile в будущем.)
+        return neutral_prompt_parser.CompositePrompt(
+            weight=1.0,
+            conciliation=None,
+            children=[target] * quantity
+        )
+
+    # по умолчанию — разворачиваем дерево в строку
+    return neutral_prompt_parser.LeafPrompt(weight=1.0, conciliation=None, prompt=resolve_tree(tree))
+
+
+@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)
+
+    # Если это уже SdConditioning — разворачиваем в строки совместимые с webui
+    if isinstance(prompts, prompt_parser.SdConditioning):
+        webui_prompts = [prompt_parser.resolve_tree(p, keep_spacing=True) for p in prompts]
+    else:
+        webui_prompts = prompts
+
+    # Совместимость: оригинал может вернуть 2 или 3 элемента; нам нужен только первый (indexes/weights)
+    original_result = original_function(webui_prompts)
+    if isinstance(original_result, tuple) and len(original_result) >= 1:
+        conds_list = original_result[0]
+        global_state.prompt_exprs = convert_to_prompt_expr(webui_prompts, conds_list)
+    else:
+        global_state.prompt_exprs = convert_to_prompt_expr(webui_prompts)
+
+    transformed_prompts = transpile_exprs(global_state.prompt_exprs)
+    if isinstance(prompts, prompt_parser.SdConditioning):
+        transformed_prompts = prompt_parser.SdConditioning(transformed_prompts, copy_from=prompts)
+
+    return original_function(transformed_prompts)
+
+
+def transpile_exprs(exprs: List[neutral_prompt_parser.PromptExpr]) -> List[str]:
+    return [expr.accept(WebuiPromptVisitor()) for expr in exprs]
+
+
+class WebuiPromptVisitor:
+    # LeafPrompt -> "text:1.2" если weight != 1.0
+    def visit_leaf_prompt(self, that: neutral_prompt_parser.LeafPrompt) -> str:
+        return f"{that.prompt}:{that.weight}" if that.weight != 1.0 else that.prompt
+
+    def visit_composite_prompt(self, that: neutral_prompt_parser.CompositePrompt) -> str:
+        children_rendered = [child.accept(self) for child in that.children]
+
+        cs = that.conciliation
+        if cs == neutral_prompt_parser.ConciliationStrategy.ALTERNATE:
+            # используем стандартный синтаксис webui: [a|b|c]
+            return "[" + "|".join(children_rendered) + "]"
+
+        if cs == neutral_prompt_parser.ConciliationStrategy.SEQUENCE:
+            # owner :: d1, d2, d3
+            if not children_rendered:
+                return ""
+            owner = children_rendered[0]
+            tail = ", ".join(children_rendered[1:]) if len(children_rendered) > 1 else ""
+            return f"{owner}::{tail}" if tail else owner
+
+        if cs == neutral_prompt_parser.ConciliationStrategy.AND_RULE:
+            # a & b & c
+            return " & ".join(children_rendered)
+
+        if cs == neutral_prompt_parser.ConciliationStrategy.GROUPED:
+            # {a, b, c}
+            return "{" + ", ".join(children_rendered) + "}"
+
+        # неизвестная стратегия — вернём просто перечисление
+        return ", ".join(children_rendered)
+
+
+# простой экспорт, если где-то вызывают prompt_parser_hijack.parse_prompts(...)
+def parse_prompts(prompts: List[str]) -> List[str]:
+    exprs = convert_to_prompt_expr(prompts)
+    return transpile_exprs(exprs)

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

@@ -0,0 +1,109 @@
+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,
+    'Alternate': neutral_prompt_parser.PromptKeyword.ALTERNATE.value,
+    'And Rule': neutral_prompt_parser.PromptKeyword.AND_RULE.value,
+    'Grouped': neutral_prompt_parser.PromptKeyword.GROUPED.value,
+    'Sequence': neutral_prompt_parser.PromptKeyword.SEQUENCE.value,
+}
+prompt_types_tooltip = '\n'.join([
+    'AND - add all prompt features equally (webui builtin)',
+    'Perpendicular - reduce the impact of contradicting prompt features',
+    'Saliency-aware - strongest prompt features win',
+    'Semantic guidance top-k - small targeted changes',
+    'Alternate - select one option from a list (e.g., [cat|dog])',
+    'And Rule - combine prompts with & (e.g., cat & dog)',
+    'Grouped - group prompts together (e.g., {cat,dog})',
+    'Sequence - sequential prompt application (e.g., cat::dog)',
+])
+
+@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 (click on apply below to append this to the positive prompt textbox)')
+        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):
+        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):
+        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):
+        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 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}
+
+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-workYEAH4/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-workYEAH4/scripts/neutral_prompt.py

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

z-sd-webui-neutral-prompt-workYEAH4/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-workYEAH4/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()