v2.0.1

You can escape it with \#

Fixes #105

.github/workflows/tests_with_comfy.yml

@@ -4,13 +4,17 @@ on:
   workflow_dispatch:
   push:
     paths:
+      - prompt_control/adv_encode.py
+      - prompt_control/attention_couple_ppm.py
       - prompt_control/nodes_lazy.py
+      - prompt_control/prompts.py
+      - prompt_control/parser.py
       - prompt_control/utils.py
 
 
 jobs:
   run-graph-tests:
-    name: Run graph tests
+    name: Run tests requiring ComfyUI
     runs-on: ubuntu-latest
     steps:
       - name: Check out code
@@ -23,6 +27,16 @@ jobs:
       - uses: actions/setup-python@v5
         with:
           python-version: '3.11'
-      - run: pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cpu
-      - run: pip install -r requirements.txt -r ComfyUI/requirements.txt
-      - run: PYTHONPATH=ComfyUI python -m prompt_control.test_graph
+          cache: pip
+      - name: install-torch
+        run: pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cpu
+      - name: install ComfyUI
+        run: pip install -r requirements.txt -r ComfyUI/requirements.txt
+      - name: Download clip_l.safetensors
+        run: curl -LO https://huggingface.co/comfyanonymous/flux_text_encoders/resolve/main/clip_l.safetensors
+      - name: Force Comfy to use the CPU
+        run: sed -i "s/^cpu_state = CPUState.GPU/cpu_state = CPUState.CPU/g" ComfyUI/comfy/model_management.py
+      - name: Run graph tests
+        run: PYTHONPATH=ComfyUI python -m prompt_control.test_graph
+      - name: Run encoder tests (clip_l only)
+        run: PYTHONPATH=ComfyUI python -m prompt_control.test_encode

Makefile

@@ -12,10 +12,10 @@ test_graph:
 	PYTHONPATH=../../ python -m prompt_control.test_graph
 
 test_encode:
-	PYTHONPATH=../../ python -m prompt_control.test_encode
+	PYTHONPATH=../../ python -m prompt_control.test_encode --verbose
 
 test_encode_both:
-	TEST_TE="clip_l t5" PYTHONPATH=../../ python -m prompt_control.test_encode
+	TEST_TE="clip_l t5" PYTHONPATH=../../ python -m prompt_control.test_encode --verbose
 
 test_heavy: test_graph test_encode_both
 

README.md

@@ -11,16 +11,16 @@ A `Basic Text to Image` template is included with the extension, and can be load
 You can use text prompts to control the following:
 
 - A1111-style prompt scheduling and filtering without noodle soup.
-- LoRA loading and scheduling via ComfyUI's hook system
-- Masking, composition and area control (regional prompting) with an implementation of [Attention Couple](/doc/attention_couple.md), also fully schedulable.
-- Per-encoder prompts for models with multiple text encoders, such as SDXL and Flux
-- Prompt combinators like `BREAK`, as well as `CAT`, `AVG()` and `AND` corresponding to ComfyUI's `ConditioningConcat`, `ConditioningAverage` and `ConditioningCombine` nodes.
-- Different weight interpretation types (ComfyUI, A1111, compel, etc.)
-- Prompt masking with an implementation of [cutoff](https://github.com/BlenderNeko/ComfyUI_Cutoff)
-- Simple prompt macros with `DEF`
-- And a bunch more
+- LoRA loading and [scheduling](/doc/schedules.md) via the prompt, using ComfyUI's hook system
+- Masking, composition and area control ([regional prompting](/doc/regional_prompts.md)) with an implementation of [Attention Couple](/doc/attention_couple.md), also fully schedulable.
+- [Advanced prompt encoding](/doc/basic.md)
+  - Per-encoder prompts for models with multiple text encoders, such as SDXL and Flux
+  - Prompt combinators like `BREAK`, as well as `CAT`, `AVG()` and `AND` corresponding to ComfyUI's `ConditioningConcat`, `ConditioningAverage` and `ConditioningCombine` nodes.
+  - Different weight interpretation types (ComfyUI, A1111, compel, etc.)
+  - Prompt masking with an implementation of [cutoff](https://github.com/BlenderNeko/ComfyUI_Cutoff)
+- Simple [prompt macros](/doc/macros.md) with `DEF`
 
-All features are fully schedulable unless otherwise stated. See the [syntax documentation](doc/syntax.md) for details on how to use each feature.
+All features are fully schedulable unless otherwise stated. See the [scheduling syntax documentation](doc/schedules.md) to get started.
 
 If you find prompt scheduling inconvenient for some reason, `PCTextEncode` can be used as a drop-in replacement for `CLIPTextEncode` to get everything else.
 
@@ -32,21 +32,6 @@ Prompt Control uses graph generation,  and tries to delegate functionality to co
 
 If you encounter issues as a user or if you're a node developer and Prompt Control somehow breaks something, feel free to file a bug report.
 
-## Prompt Control v2
-
-Prompt control has been almost completely rewritten. It now uses ComfyUI's lazy execution to build graphs from the text prompt at runtime. The generated graph is often exactly equivalent to a manually built workflow using native ComfyUI nodes. There are no more weird sampling hooks that could cause problems with other nodes
-
-### Removed features
-
-- Prompt interpolation syntax; it was too cumbersome to maintain
-- LoRA block weight integration; ditto, for now.
-
-### Everything broke, where are the old nodes?
-
-If you really need them, you can install the [legacy nodes](https://github.com/asagi4/comfyui-prompt-control-legacy). However, I will not fix bugs in those nodes, and I strongly recommend just migrating your workflows to the new nodes.
-
-You can have both installed at the same time; none of the nodes conflict.
-
 ## Requirements
 
 For LoRA scheduling to work, you'll need at least version 0.3.7 of ComfyUI (0.3.36 of ComfyUI desktop).
@@ -100,8 +85,4 @@ This node configures `PCTextEncode` default values for some functions by attachi
 
 - ComfyUI's caching mechanism has an issue that makes it unnecessarily invalidate caches for certain inputs; you'll still get some benefit from the lazy nodes, but changing inputs that shouldn't affect downstream nodes (especially if using filtering) will still cause them to be recomputed because ComfyUI doesn't realize the inputs haven't changed.
 
-If you want to enable a hack to fix this, set `PROMPTCONTROL_ENABLE_CACHE_HACK=1` in your environment. Unset it to disable.
-
-It's a purely optional performance optimization that allows Prompt Control nodes to override their cache keys in a way that should not interfere with other nodes. Note that the optimization only works if the text input to the lazy nodes is a constant (so either directly on the node or from a primitive); outputs from other nodes can't be optimized.
-
 - Cutoff does not work with models that use non-CLIP text encoders, like Flux. This might be fixable, but it's uncertain if cutoff even makes sense for those models.

__init__.py

@@ -23,12 +23,11 @@ if os.environ.get("PROMPTCONTROL_DEBUG"):
 else:
     log.setLevel(logging.INFO)
 
-cache_hack = importlib.import_module(".prompt_control.cache_hack", package=__name__)
-cache_hack.init()
-
 NODE_CLASS_MAPPINGS = {}
 NODE_DISPLAY_NAME_MAPPINGS = {}
 
+WEB_DIRECTORY = "web"
+
 nodes = ["base", "lazy", "tools", "hooks"]
 
 for node in nodes:

doc/basic.md

@@ -1,101 +1,6 @@
-# Prompt Control Syntax
+# Basic Prompt Syntax
 
-If you're viewing this on GitHub, I recommend opening the outline by clicking the button in the top right corner of the text view (it is annoyingly easy to miss).
-
-Scheduling syntax is similar to A1111, but only fractions are supported for steps. LoRAs are scheduled by including them in a scheduling expression.
-
-```
-a [large::0.1] [cat|dog:0.05] [<lora:somelora:0.5:0.6>::0.5]
-[in a park:in space:0.4]
-```
-
-## Scheduled prompts
-
-There are two forms of scheduled prompts.
-
-### Basic scheduling expressions
-Basic expressions take the form `[before:after:X]` where `X` is the switch point, a decimal number between 0.0 and 1.0 inclusive, representing 0 to 100% of timesteps. Either prompt can also be empty.
-For example:
-```
-a [red:blue:0.5] cat
-```
-switches from `a red cat` to `a blue cat` at 0.5. `before` and `after` can be arbitrary prompts (`after` can also be empty), including other scheduling expressions, allowing nesting:
-```
-a [red:[blue::0.7]:0.5] cat
-```
-
-switches from `a red cat` to `a blue cat` at 0.5 and to `a cat` at 0.7
-
-For convenience `[cat:0.5]` is equivalent to `[:cat:0.5]` meaning it switches from empty to `cat` at 0.5.
-
-### Range expressions
-
-The most general form of a schedule is a range expression: For example, in `[before:during:after:0.3,0.7]`, The prompt be `a before` until 0.3, `a during` until 0.7, and then `a after`. This form is equivalent to `[before:[during:after:0.7]:0.3]`
-
-For convenience, `[during:0.1,0.4]` is equivalent to `[:during::0.1,0.4]` and `[during:after:0.1,0.4]` is equivalent to `[:during:after:0.1,0.4]`.
-
-`[before:during:after:0.1]` is the same as `[before:during:after:0.1,1.0]` which is same as `[before:during:0.1]`
-
-
-### Using step numbers with the Advanced nodes
-
-If you provide a non-zero value to `num_steps` to the `Advanced` versions of the scheduling nodes, you will be able to use step numbers in prompts.
-
-For now, a value between 0 and 1.0 will be interpreted as a percentage if it contains a ., and as an absolute step otherwise.
-
-This is just syntactic sugar. Behind the scenes, the values are converted to percentages and have normal ComfyUI scheduling behaviour.
-
-## Tag selection
-Using the `FilterSchedule` node, in addition to step percentages, you can use a *tag* to select part of an input:
-```
-a large [dog:cat<lora:catlora:0.5>:SECOND_PASS]
-```
-Set the `tags` parameter in the `FilterSchedule` node to filter the prompt. If the tag matches any tag `tags` (comma-separated), the second option is returned (`cat`, in this case, with the LoRA). Otherwise, the first option is chosen (`dog`, without LoRA).
-
-the values in `tags` are case-insensitive, but the tags in the input **must** be uppercase A-Z and underscores only, or they won't be recognized. That is, `[dog:cat:hr]` will not work.
-
-For example, a prompt
-```
-a [black:blue:X] [cat:dog:Y] [walking:running:Z] in space
-```
-with `tags` `x,z` would result in the prompt `a blue cat running in space`
-
-The three prompt form `[a:b:c:TAG]` is parsed, but ignores `b` and is equivalent to `[a:c:TAG]`.
-
-## LoRA Scheduling
-When using the lazy graph building nodes, LoRAs can be scheduled by referring to them in a scheduling expression, like so:
-
-`<lora:fulllora:1> [<lora:partialora:1>::0.5]`
-
-This will schedule `fulllora` for the entire duration of the prompt and `partiallora` until half of sampling is complete.
-
-You can refer to LoRAs by using the filename without extension and subdirectories will also be searched. For example, `<lora:cats:1>`. will match both `cats.safetensors` and `sd15/animals/cats.safetensors`. If there are multiple LoRAs with the same name, the first match will be loaded.
-
-Alternatively, the name can include the full directory path relative to ComfyUI's search paths, without extension: `<lora:XL/sdxllora:0.5>`. In this case, the *full* path must match.
-
-If no match is found, the node will try to replace spaces with underscores and search again. That is, `<lora:cats and dogs:1>` will find `cats_and_dogs.safetensors`. This helps with some autocompletion scripts that replace underscores with spaces.
-
-Finally, you can give the exact path (including the extension) as shown in `LoRALoader`.
-
-
-## Alternating
-
-Alternating syntax is `[a|b:pct_steps]`, causing the prompt to alternate every `pct_steps`. `pct_steps` defaults to 0.1 if not specified. You can also have more than two options.
-
-
-## Sequences
-
-The syntax `[SEQ:a:N1:b:N2:c:N3]` is shorthand for `[a:[b:[c::N3]:N2]:N1]` ie. it switches from `a` to `b` to `c` to nothing at the specified points in sequence.
-
-Might be useful with Jinja templating (see https://github.com/asagi4/comfyui-utility-nodes). For example:
-```
-[SEQ<% for x in steps(0.1, 0.9, 0.1) %>:<lora:test:<= sin(x*pi) + 0.1 =>>:<= x =><% endfor %>]
-```
-generates a LoRA schedule based on a sinewave
-
-# Basic prompt syntax
-
-This syntax is also available in outside scheduled with the `PCTextEncode` node, where applicable.
+The syntax below documents the features of `PCTextEncode`
 
 ## Combining prompts
 
@@ -252,52 +157,9 @@ The function `NOISE(weight, seed)` adds some random noise into the cond tensor.
 
 The usefulness of this is questionable, but it wasn't difficult to implement, so here it is.
 
-
 ## Regional prompting
 
-See also [Attention Couple](#attention-couple) below
-
-### MASK, IMASK and AREA
-
-You can use `MASK(x1 x2, y1 y2, weight, op)` to specify a region mask for a prompt. The values are specified as a percentage with a float between `0` and `1`, or as absolute pixel values (these can't be mixed). `1` will be interpreted as a percentage instead of a pixel value.
-
-Multiple `MASK` or `IMASK` calls will be composited together using ComfyUI's `MaskComposite` node, using `op` as the `operation` parameter (defaulting to `multiply`).
-
-Similarly, you can use `AREA(x1 x2, y1 y2, weight)` to specify an area for the prompt (see ComfyUI's area composition examples). The area is calculated by ComfyUI relative to your latent size.
-
-### Custom masks: IMASK and `PCAddMaskToCLIP`
-
-You can attach custom masks to a `CLIP` with the `PC: Attach Mask` nodes and then refer to those masks in the prompt using `IMASK(index, weight, op)`. Indexing starts from zero, so 0 is the first attached mask etc. `PCSCheduleAddMasks` ignores empty inputs, so if you only add a mask to the `mask4` input, it will still have index 0.
-
-Applying the nodes multiple times *appends* masks rather than overriding existing ones, so if you need more than 4, you can just use it more than once.
-
-### Behaviour of masks
-If multiple `MASK`s are specified, they are combined together with ComfyUI's `MaskComposite` node, with `op` specifying the operation to use (default `multiply`). In this case, the combined mask weight can be set with `MASKW(weight)` (defaults to 1.0).
-
-Masks assume a size of `(512, 512)`, unless overridden with `PC: Configure PCTextEncode` and pixel values will be relative to that. ComfyUI will scale the mask to match the image resolution. You can change it manually by using `MASK_SIZE(width, height)` anywhere in the prompt,
-
-These are handled per `AND`-ed prompt, so in `prompt1 AND MASK(...) prompt2`, the mask will only affect prompt2.
-
-The default values are `MASK(0 1, 0 1, 1)` and you can omit unnecessary ones, that is, `MASK(0 0.5, 0.3)` is `MASK(0 0.5, 0.3 1, 1)`
-
-Note that because the default values are percentages, `MASK(0 256, 64 512)` is valid, but `MASK(0 200)` will raise an error.
-
-Masking does not affect LoRA scheduling unless you set unet weights to 0 for a LoRA.
-
-### FEATHER: Mask operations
-
-When you use `MASK` or `IMASK`, you can also call `FEATHER(left top right bottom)` to apply feathering using ComfyUI's `FeatherMask` node. The values are in pixels and default to `0`.
-
-If multiple masks are used, `FEATHER` is applied *before compositing* in the order they appear in the prompt, and any leftovers are applied to the combined mask. If you want to skip feathering a mask while compositing, just use `FEATHER()` with no arguments.
-
-For example:
-```
-MASK(1) MASK(2) MASK(3) FEATHER(1) FEATHER() FEATHER(3) weirdmask FEATHER(4)
-```
-
-gives you a mask that is a combination of 1, 2 and 3, where 1 and 3 are feathered before compositing and then `FEATHER(4)` is applied to the composite.
-
-The order of the `FEATHER` and `MASK` calls doesn't matter; you can have `FEATHER` before `MASK` or even interleave them.
+See [Regional prompting](/doc/regional_prompting.md)
 
 ## Cutoff
 
@@ -328,68 +190,8 @@ The parameters affect how the masked and unmasked prompts are combined to produc
 
 # Experimental features
 
-Experimental features are unstable and may disappear or change without warning.
-
-## DEF: Lightweight prompt macros
-
-You can define "prompt macros" by using `DEF`.  Macros are expanded before any other parsing takes place. The expansion continues until no further changes occur. Recursion will raise an error.
-
-`PCLazyTextEncode` and `PCLazyLoraLoader` expand macros, but `PCTextEncode` **does not**. If you need to expand macros for a single prompt, use `PCMacroExpand`
-
-```
-DEF(MYMACRO=this is a prompt)
-[(MYMACRO:0.6):(MYMACRO:1.1):0.5]
-```
-is equivalent to
-```
-[(this is a prompt:0.5):(this is a prompt:1.1):0.5]
-```
-### Macro parameters
-It's also possible to give parameters to a macro:
-```
-DEF(MYMACRO=[(prompt $1:$2):(prompt $1:$3):$4])
-MYMACRO(test; 1.1; 0.7; 0.2)
-```
-gives
-```
-[(prompt test:1.1):(prompt test:0.7):0.2]
-```
-in this form, the variables $N (where N is any number corresponding to a positional parameter) will be replaced with the given parameter. The parameters must be separated with a semicolon, and can be empty.
-
-You can also optionally specify default values:
-
-```
-DEF(MACRO(example; 0; 1)=[$1:$2,$3])
-MACRO MACRO(test; 0.2)
-```
-gives
-```
-[example:0,1] [test:0.2,1]
-```
-
-```
-DEF(MACRO() = [a:$1:0.5])
-```
-sets the default value of `$1` to an empty string.
-
-### Unspecified parameters in macros
-
-Unspecified parameters (either via defaults or explicitly given) will not be substituted. Compare:
-
-```
-DEF(mything=a "$1" b "$2")
-mything
-mything()
-mything(A)
-```
-
-gives
-
-```
-a "$1" b "$2"
-a "" b "$2"
-a "A" b "$2"
-```
+> [!WARN]
+> These features are may change or disappear without warning
 
 ## COUPLE: Attention couple
 

doc/macros.md

@@ -0,0 +1,60 @@
+## DEF: Lightweight prompt macros
+
+You can define "prompt macros" by using `DEF`.  Macros are expanded before any other parsing takes place. The expansion continues until no further changes occur. Recursion will raise an error.
+
+`PCLazyTextEncode` and `PCLazyLoraLoader` expand macros, but `PCTextEncode` **does not**. If you need to expand macros for a single prompt, use `PCMacroExpand`
+
+```
+DEF(MYMACRO=this is a prompt)
+[(MYMACRO:0.6):(MYMACRO:1.1):0.5]
+```
+is equivalent to
+```
+[(this is a prompt:0.5):(this is a prompt:1.1):0.5]
+```
+### Macro parameters
+It's also possible to give parameters to a macro:
+```
+DEF(MYMACRO=[(prompt $1:$2):(prompt $1:$3):$4])
+MYMACRO(test; 1.1; 0.7; 0.2)
+```
+gives
+```
+[(prompt test:1.1):(prompt test:0.7):0.2]
+```
+in this form, the variables $N (where N is any number corresponding to a positional parameter) will be replaced with the given parameter. The parameters must be separated with a semicolon, and can be empty.
+
+You can also optionally specify default values:
+
+```
+DEF(MACRO(example; 0; 1)=[$1:$2,$3])
+MACRO MACRO(test; 0.2)
+```
+gives
+```
+[example:0,1] [test:0.2,1]
+```
+
+```
+DEF(MACRO() = [a:$1:0.5])
+```
+sets the default value of `$1` to an empty string.
+
+### Unspecified parameters in macros
+
+Unspecified parameters (either via defaults or explicitly given) will not be substituted. Compare:
+
+```
+DEF(mything=a "$1" b "$2")
+mything
+mything()
+mything(A)
+```
+
+gives
+
+```
+a "$1" b "$2"
+a "" b "$2"
+a "A" b "$2"
+```

doc/regional_prompts.md

@@ -0,0 +1,63 @@
+# Regional prompting
+
+This section documents the masking functionality of `PCTextEncode`
+
+See also [Attention Couple](/doc/attention_couple.md)
+
+Remember that when using the lazy nodes, prompt scheduling applies to masks as well, so you can change or enable/disable regional prompts at any point during sampling.
+
+## Behaviour
+
+For each prompt separated by `AND`, you can specify either latent masks or an area.
+
+- When masked, ComfyUI generates the model output using the **full latent** as the input, and then applies the mask to the output before adding it to your latent for the next step.
+- When an area is specified, ComfyUI generates a separate model output using the **part of the latent specified by the area** and then composites it into the full latent afterwards.
+- You can have *both* an AREA and a MASK specified, in which case the mask is applied to the latent specified by the AREA.
+
+For example, consider a 1024 by 1024 (width x height) generation:
+
+- `cat MASK(0 0.5, 0 1) AND dog MASK(0.5 1, 0 1)` generates two outputs at 1024x1024 for "dog" and "cat", then masks half of them off and adds the results together. The following step still see both the dog and the cat from the previous step, so they may blend slightly.
+
+- `cat AREA(0 0.5, 0 1) AND dog AREA(0.5 1, 0 1)` generates two completely separate outputs at **512**x1024 and then composites them together into the 1024x1024 latent. Because the areas do not overlap, the generation for `cat` will not see the output of `dog` and vice versa in subsequent steps as long as the area restriction is in effect.
+
+## MASK, IMASK and AREA
+
+You can use `MASK(x1 x2, y1 y2, weight, op)` to specify a region mask for a prompt. The values are specified as a percentage with a float between `0` and `1`, or as absolute pixel values (these can't be mixed). `1` will be interpreted as a percentage instead of a pixel value.
+
+Multiple `MASK` or `IMASK` calls will be composited together using ComfyUI's `MaskComposite` node, using `op` as the `operation` parameter (defaulting to `multiply`).
+
+Similarly, you can use `AREA(x1 x2, y1 y2, weight)` to specify an area for the prompt (see ComfyUI's area composition examples). The area is calculated by ComfyUI relative to your latent size.
+
+### Custom masks: IMASK and `PCAddMaskToCLIP`
+
+You can attach custom masks to a `CLIP` with the `PC: Attach Mask` nodes and then refer to those masks in the prompt using `IMASK(index, weight, op)`. Indexing starts from zero, so 0 is the first attached mask etc. `PCSCheduleAddMasks` ignores empty inputs, so if you only add a mask to the `mask4` input, it will still have index 0.
+
+Applying the nodes multiple times *appends* masks rather than overriding existing ones, so if you need more than 4, you can just use it more than once.
+
+### Behaviour of multiple masks
+If multiple `MASK`s are specified, they are combined together with ComfyUI's `MaskComposite` node, with `op` specifying the operation to use (default `multiply`). In this case, the combined mask weight can be set with `MASKW(weight)` (defaults to 1.0).
+
+Masks assume a size of `(512, 512)`, unless overridden with `PC: Configure PCTextEncode` and pixel values will be relative to that. ComfyUI will scale the mask to match the image resolution. You can change it manually by using `MASK_SIZE(width, height)` anywhere in the prompt,
+
+These are handled per `AND`-ed prompt, so in `prompt1 AND MASK(...) prompt2`, the mask will only affect prompt2.
+
+The default values are `MASK(0 1, 0 1, 1)` and you can omit unnecessary ones, that is, `MASK(0 0.5, 0.3)` is `MASK(0 0.5, 0.3 1, 1)`
+
+Note that because the default values are percentages, `MASK(0 256, 64 512)` is valid, but `MASK(0 200)` will raise an error.
+
+Masking does not affect LoRA scheduling unless you set unet weights to 0 for a LoRA.
+
+## FEATHER: Mask operations
+
+When you use `MASK` or `IMASK`, you can also call `FEATHER(left top right bottom)` to apply feathering using ComfyUI's `FeatherMask` node. The values are in pixels and default to `0`.
+
+If multiple masks are used, `FEATHER` is applied *before compositing* in the order they appear in the prompt, and any leftovers are applied to the combined mask. If you want to skip feathering a mask while compositing, just use `FEATHER()` with no arguments.
+
+For example:
+```
+MASK(1) MASK(2) MASK(3) FEATHER(1) FEATHER() FEATHER(3) weirdmask FEATHER(4)
+```
+
+gives you a mask that is a combination of 1, 2 and 3, where 1 and 3 are feathered before compositing and then `FEATHER(4)` is applied to the composite.
+
+The order of the `FEATHER` and `MASK` calls doesn't matter; you can have `FEATHER` before `MASK` or even interleave them.

doc/schedules.md

@@ -0,0 +1,110 @@
+# Prompt Schedule Syntax
+
+> [!TIP]
+> If you're viewing this on GitHub, I recommend opening the outline by clicking the button in the top right corner of the text view (it is annoyingly easy to miss).
+
+> [!NOTE]
+> The syntax documented in this section is only available with the `PC: Schedule Prompt` and `PC: Schedule LoRAs` nodes and their advanced variants.
+
+Scheduling syntax is available with is similar to A1111, but only fractions are supported for steps. LoRAs are scheduled by including them in a scheduling expression.
+
+Besides the syntax documented below, the [basic syntax](/doc/basic.md) and [prompt macro](/doc/macros.md) features are also automatically available.
+
+```
+a [large::0.1] [cat|dog:0.05] [<lora:somelora:0.5:0.6>::0.5]
+[in a park:in space:0.4]
+```
+## Comments and escaping
+
+In schedules, any text on a line following a `#` is considered a comment and removed, including the `#` character.
+You can escape the following characters in places where they would otherwise conflict with syntax:
+
+- `#` with `\#`
+- `:` with `\:`
+- `\` with `\\`
+
+Escaping is only required if it would otherwise be considered syntax, that is `\o/` will be interpreted literally and the `\` does not need to be escaped, but in `[embedding:a:0.5]` you would need to escape the `:`.
+
+## Scheduled prompts
+
+There are two forms of scheduled prompts.
+
+### Basic scheduling expressions
+Basic expressions take the form `[before:after:X]` where `X` is the switch point, a decimal number between 0.0 and 1.0 inclusive, representing 0 to 100% of timesteps. Either prompt can also be empty.
+For example:
+```
+a [red:blue:0.5] cat
+```
+switches from `a red cat` to `a blue cat` at 0.5. `before` and `after` can be arbitrary prompts (`after` can also be empty), including other scheduling expressions, allowing nesting:
+```
+a [red:[blue::0.7]:0.5] cat
+```
+
+switches from `a red cat` to `a blue cat` at 0.5 and to `a cat` at 0.7
+
+For convenience `[cat:0.5]` is equivalent to `[:cat:0.5]` meaning it switches from empty to `cat` at 0.5.
+
+### Range expressions
+
+The most general form of a schedule is a range expression: For example, in `prompt [before:during:after:0.3,0.7]`, The prompt be `prompt before` until 0.3, `prompt during` until 0.7, and then `prompt after`. This form is equivalent to `prompt [before:[during:after:0.7]:0.3]`
+
+For convenience, `[during:0.1,0.4]` is equivalent to `[:during::0.1,0.4]` and `[during:after:0.1,0.4]` is equivalent to `[:during:after:0.1,0.4]`.
+
+`[before:during:after:0.1]` is the same as `[before:during:after:0.1,1.0]` which is same as `[before:during:0.1]`
+
+
+### Using step numbers with the Advanced nodes
+
+If you provide a non-zero value to `num_steps` to the `Advanced` versions of the scheduling nodes, you will be able to use step numbers in prompts.
+
+For now, a value between 0 and 1.0 will be interpreted as a percentage if it contains a ., and as an absolute step otherwise.
+
+This is just syntactic sugar. Behind the scenes, the values are converted to percentages and have normal ComfyUI scheduling behaviour.
+
+## Tag selection
+Using the `FilterSchedule` node, in addition to step percentages, you can use a *tag* to select part of an input:
+```
+a large [dog:cat<lora:catlora:0.5>:SECOND_PASS]
+```
+Set the `tags` parameter in the `FilterSchedule` node to filter the prompt. If the tag matches any tag `tags` (comma-separated), the second option is returned (`cat`, in this case, with the LoRA). Otherwise, the first option is chosen (`dog`, without LoRA).
+
+the values in `tags` are case-insensitive, but the tags in the input **must** be uppercase A-Z and underscores only, or they won't be recognized. That is, `[dog:cat:hr]` will not work.
+
+For example, a prompt
+```
+a [black:blue:X] [cat:dog:Y] [walking:running:Z] in space
+```
+with `tags` `x,z` would result in the prompt `a blue cat running in space`
+
+The three prompt form `[a:b:c:TAG]` is parsed, but ignores `b` and is equivalent to `[a:c:TAG]`.
+
+## LoRA Scheduling
+When using the lazy graph building nodes, LoRAs can be scheduled by referring to them in a scheduling expression, like so:
+
+`<lora:fulllora:1> [<lora:partialora:1>::0.5]`
+
+This will schedule `fulllora` for the entire duration of the prompt and `partiallora` until half of sampling is complete.
+
+You can refer to LoRAs by using the filename without extension and subdirectories will also be searched. For example, `<lora:cats:1>`. will match both `cats.safetensors` and `sd15/animals/cats.safetensors`. If there are multiple LoRAs with the same name, the first match will be loaded.
+
+Alternatively, the name can include the full directory path relative to ComfyUI's search paths, without extension: `<lora:XL/sdxllora:0.5>`. In this case, the *full* path must match.
+
+If no match is found, the node will try to replace spaces with underscores and search again. That is, `<lora:cats and dogs:1>` will find `cats_and_dogs.safetensors`. This helps with some autocompletion scripts that replace underscores with spaces.
+
+Finally, you can give the exact path (including the extension) as shown in `LoRALoader`.
+
+
+## Alternating
+
+Alternating syntax is `[a|b:pct_steps]`, causing the prompt to alternate every `pct_steps`. `pct_steps` defaults to 0.1 if not specified. You can also have more than two options.
+
+
+## Sequences
+
+The syntax `[SEQ:a:N1:b:N2:c:N3]` is shorthand for `[a:[b:[c::N3]:N2]:N1]` ie. it switches from `a` to `b` to `c` to nothing at the specified points in sequence.
+
+Might be useful with Jinja templating (see https://github.com/asagi4/comfyui-utility-nodes). For example:
+```
+[SEQ<% for x in steps(0.1, 0.9, 0.1) %>:<lora:test:<= sin(x*pi) + 0.1 =>>:<= x =><% endfor %>]
+```
+generates a LoRA schedule based on a sinewave

prompt_control/nodes_tools.py

@@ -1,10 +1,10 @@
 import logging
 from .parser import parse_prompt_schedules, expand_macros
 from .nodes_lazy import NODE_CLASS_MAPPINGS as LAZY_NODES
+from .utils import expand_graph
 import json
 import folder_paths
 from pathlib import Path
-from comfy_execution.graph_utils import is_link
 
 log = logging.getLogger("comfyui-prompt-control")
 
@@ -20,7 +20,7 @@ class PCSaveExpandedWorkflow:
                 "any": ("*", {}),
             },
             "hidden": {
-                "prompt": "DYNPROMPT",
+                "prompt": "PROMPT",
             },
         }
 
@@ -31,7 +31,7 @@ class PCSaveExpandedWorkflow:
     OUTPUT_NODE = True
     RETURN_TYPES = ()
     CATEGORY = "promptcontrol/tools"
-    DESCRIPTION = "Saves the current expanded dynamic prompt into a JSON file"
+    DESCRIPTION = "Expands lazy prompt control nodes in the prompt and saves the expanded prompt into a JSON file"
 
     FUNCTION = "apply"
 
@@ -39,29 +39,12 @@ class PCSaveExpandedWorkflow:
         full_output_folder, filename, counter, subfolder, prefix = folder_paths.get_save_image_path(
             "pc_workflow_debug", self.output_dir
         )
-        p = {}
-        input_replace_map = {}
-        for node in prompt.all_node_ids():
-            n = prompt.get_node(node)
-            t = n["class_type"]
-            if t in LAZY_NODES:
-                expanded_prompt = LAZY_NODES[t]().apply(**n["inputs"], unique_id=node)
-                for k in expanded_prompt["expand"]:
-                    p[k] = expanded_prompt["expand"][k]
-                for i, _ in enumerate(expanded_prompt["result"]):
-                    input_replace_map[(node, i)] = [k, i]
-            else:
-                p[node] = n
-        for k in p:
-            for ik in p[k]["inputs"]:
-                x = p[k]["inputs"][ik]
-                if is_link(x) and tuple(x) in input_replace_map:
-                    p[k]["inputs"][ik] = input_replace_map[tuple(x)]
+        expanded = expand_graph(LAZY_NODES, prompt)
         file = f"{filename}_{counter:05}_.json"
         full_path = Path(full_output_folder) / file
         with open(full_path, "w") as f:
             log.info(f"Saving workflow to {full_path}")
-            json.dump(p, f)
+            json.dump(expanded, f)
 
         return ()
 

prompt_control/parser.py

@@ -24,10 +24,40 @@ if lark.__version__ == "0.12.0":
     raise ImportError(x)
 
 
+ESCAPES = [
+    ("XxPCBackslashESCAPExX", "\\"),
+    ("XxPCColonESCAPExX", ":"),
+    ("XxPCCommentESCAPExX", "#"),
+]
+
+
+def escape_specials(string):
+    for ph, c in ESCAPES:
+        string = string.replace(rf"\{c}", ph)
+    return string
+
+
+def restore_escaped(string):
+    for ph, c in ESCAPES:
+        string = string.replace(ph, c)
+    return string
+
+
+def remove_comments(string):
+    r = []
+    for line in string.split("\n"):
+        comment = line.find("#")
+        if comment >= 0:
+            r.append(line[:comment])
+        else:
+            r.append(line)
+    return "\n".join(r)
+
+
 prompt_parser = lark.Lark(
     r"""
 !start: (prompt | /[][():|]/+)*
-prompt: (emphasized | embedding | scheduled | alternate | sequence | loraspec | PLAIN | /</ | />/ | WHITESPACE)+
+prompt: (emphasized | embedding | scheduled | alternate | sequence | loraspec | PLAIN | | /\\:/ | /</ | />/ | WHITESPACE)+
 !emphasized: "(" prompt? ")"
         | "(" prompt ":" prompt ")"
         | "[" prompt "]"
@@ -241,7 +271,7 @@ def at_step(step, filters, tree):
             return {"prompt": p, "loras": loraspecs}
 
         def PLAIN(self, args):
-            return args.replace("\\:", ":")
+            return restore_escaped(args)
 
         def FILENAME(self, value):
             return str(value)
@@ -284,7 +314,8 @@ class PromptSchedule(object):
         self.start = start
         self.end = end
         self.num_steps = num_steps
-        self.prompt = prompt.strip()
+        # placeholder is restored on parse
+        self.prompt = remove_comments(escape_specials(prompt.strip()))
         self.defaults = {}
         self.loaded_loras = {}
 
@@ -426,7 +457,7 @@ def substitute_def(text, search, replace):
 
 def substitute_defcall(text, search, replace):
     name, default_args = search
-    text, defns = get_function(text, name, defaults=None, placeholder=f"DEFNCALL{name}")
+    text, defns = get_function(text, name, defaults=None, placeholder=f"DEFNCALL{name}", require_args=False)
     for i, parameters in enumerate(defns):
         ph = f"\0DEFNCALL{name}{i}\0"
         paramvals = []

prompt_control/prompts.py

@@ -231,11 +231,11 @@ def encode_prompt_segment(
 
     # Chunks to ConditioningAverage:
 
-    text, averages = split_by_function(text, "AVG", ["0.5"])
+    text, averages = split_by_function(text, "AVG", ["0.5"], require_args=False)
     prompts_to_avg = []
     for avg in averages:
         w = safe_float(avg["args"][0], 0.5)
-        prompts_to_avg.append(text, w)
+        prompts_to_avg.append((text, w))
         text = avg["text"]
     prompts_to_avg.append((text, 1.0))
 
@@ -573,7 +573,7 @@ def encode_prompt(clip, text, start_pct, end_pct, defaults, masks):
         return f"MASK({args})"
 
     for prompt in prompts:
-        base_prompt, attn_couple_prompts = split_by_function(prompt, "COUPLE", defaults=None)
+        base_prompt, attn_couple_prompts = split_by_function(prompt, "COUPLE", defaults=None, require_args=False)
 
         prompts = [base_prompt] + [couple_mask(p["args"]) + p["text"] for p in attn_couple_prompts]
         encoded = []

prompt_control/test_encode.py

@@ -1,6 +1,10 @@
 import unittest
+import unittest.mock as mock
 import numpy.testing as npt
 from os import environ
+import nodes
+import comfy_extras.nodes_mask
+from .nodes_base import PCTextEncode
 
 clips = []
 
@@ -13,7 +17,36 @@ def run(f, *args):
     return getattr(f, f.FUNCTION)(*args)
 
 
+@mock.patch("torch.cuda.current_device", lambda: "cpu")
 class TestEncode(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        global clips
+        print("Loading ComfyUI")
+        from comfy.sd import load_clip
+        from pathlib import Path
+
+        to_test = environ.get("TEST_TE", "clip_l").split()
+        model_dir = environ.get("COMFYUI_TE_DIR", ".")
+
+        te_root = Path(model_dir).resolve()
+
+        if "clip_l" in to_test:
+            clip_l = load_clip(
+                ckpt_paths=[str(te_root / "clip_l.safetensors")], clip_type="stable_diffusion", model_options={}
+            )
+            clips.append(("clip_l", clip_l))
+
+        if "t5" in to_test:
+            dual = load_clip(
+                [str(te_root / "clip_l.safetensors"), str(te_root / "t5xxl_fp16.safetensors")],
+                clip_type="flux",
+                model_options={},
+            )
+            clips.append(("clip_l+t5", dual))
+
+        print("Starting tests")
+
     def tensorsEqual(self, t1, t2):
         npt.assert_equal(t1.detach().numpy(), t2.detach().numpy())
 
@@ -30,6 +63,7 @@ class TestEncode(unittest.TestCase):
         pc = PCTextEncode()
         comfy = nodes.CLIPTextEncode()
         combine = nodes.ConditioningCombine()
+        average = nodes.ConditioningAverage()
         concat = nodes.ConditioningConcat()
         zeroout = nodes.ConditioningZeroOut()
         for k, clip in clips:
@@ -46,6 +80,12 @@ class TestEncode(unittest.TestCase):
                     c = c2  # Used in later tests
                     self.condEqual(c1, c2)
 
+                with self.subTest("Function cornercase"):
+                    (c1,) = run(pc, clip, "test SDXL function")
+                    (c2,) = run(comfy, clip, "test SDXL function")
+                    (c3,) = run(pc, clip, "test SDXL() function")
+                    self.condEqual(c1, c2)
+
                 with self.subTest("Weights"):
                     (c1,) = run(pc, clip, "(test:1.2) (test:0.6)")
                     (c2,) = run(comfy, clip, "(test:1.2) (test:0.6)")
@@ -66,6 +106,25 @@ class TestEncode(unittest.TestCase):
                     (c2,) = run(zeroout, c)
                     self.condEqual(c1, c2)
 
+                with self.subTest("Average"):
+                    (c1,) = run(comfy, clip, "test1")
+                    (c2,) = run(comfy, clip, "test2")
+                    (c3,) = run(pc, clip, "test1 AVG() test2")
+                    (c4,) = run(pc, clip, "test1 AVG test2")
+                    (avg,) = run(average, c1, c2, 0.5)
+                    self.condEqual(avg, c3)
+                    self.condEqual(avg, c4)
+
+    @unittest.expectedFailure
+    def test_failure(self):
+        pc = PCTextEncode()
+        comfy = nodes.CLIPTextEncode()
+        for k, clip in clips:
+            with self.subTest(k):
+                (c1,) = run(comfy, clip, "test SDXL function")
+                (c2,) = run(pc, clip, "test SDXL() function")
+                self.condEqual(c1, c2)
+
     def test_weight(self):
         pc = PCTextEncode()
         comfy = nodes.CLIPTextEncode()
@@ -127,31 +186,4 @@ class TestEncode(unittest.TestCase):
 
 
 if __name__ == "__main__":
-    print("Loading ComfyUI")
-    from comfy.sd import load_clip
-    import nodes
-    import comfy_extras.nodes_mask
-    from .nodes_base import PCTextEncode
-    from pathlib import Path
-
-    to_test = environ.get("TEST_TE", "clip_l").split()
-    model_path = environ.get("COMFYUI_MODEL_ROOT", ".")
-
-    te_root = (Path(model_path) / "text_encoders").resolve()
-
-    if "clip_l" in to_test:
-        clip_l = load_clip(
-            ckpt_paths=[str(te_root / "clip_l.safetensors")], clip_type="stable_diffusion", model_options={}
-        )
-        clips.append(("clip_l", clip_l))
-
-    if "t5" in to_test:
-        dual = load_clip(
-            [str(te_root / "clip_l.safetensors"), str(te_root / "t5xxl_fp16.safetensors")],
-            clip_type="flux",
-            model_options={},
-        )
-        clips.append(("clip_l+t5", dual))
-
-    print("Starting tests")
     unittest.main()

prompt_control/test_encode_refactor.py

@@ -1,8 +1,8 @@
 import unittest
 import numpy.testing as npt
+from os import environ
 
-clip_l = None
-dual = None
+clips = []
 
 
 def run(f, *args):
@@ -24,7 +24,7 @@ class TestEncode(unittest.TestCase):
 
     def test_styles(self):
         pc = PCTextEncode()
-        for k, clip in [("l", clip_l), ("dual", dual)]:
+        for k, clip in clips:
             for style in ["comfy++", "A1111", "comfy++", "compel", "down_weight"]:
                 with self.subTest(f"TE {k} style {style} does not fail when encoding weights"):
                     for normalization in ["none", "mean", "length", "length+mean"]:
@@ -44,13 +44,28 @@ class TestEncode(unittest.TestCase):
 
 if __name__ == "__main__":
     print("Loading ComfyUI")
-    import main
-
-    id(main)  # get rid of flake warning
-    import nodes
+    from comfy.sd import load_clip
     from .nodes_base import PCTextEncode
+    from pathlib import Path
+
+    to_test = environ.get("TEST_TE", "clip_l").split()
+    model_path = environ.get("COMFYUI_MODEL_ROOT", ".")
+
+    te_root = (Path(model_path) / "text_encoders").resolve()
+
+    if "clip_l" in to_test:
+        clip_l = load_clip(
+            ckpt_paths=[str(te_root / "clip_l.safetensors")], clip_type="stable_diffusion", model_options={}
+        )
+        clips.append(("clip_l", clip_l))
+
+    if "t5" in to_test:
+        dual = load_clip(
+            [str(te_root / "clip_l.safetensors"), str(te_root / "t5xxl_fp16.safetensors")],
+            clip_type="flux",
+            model_options={},
+        )
+        clips.append(("clip_l+t5", dual))
 
-    (clip_l,) = nodes.CLIPLoader().load_clip("clip_l.safetensors")
-    (dual,) = nodes.DualCLIPLoader().load_clip("clip_l.safetensors", "clip_g.safetensors", "sdxl")
     print("Starting tests")
     unittest.main()

prompt_control/test_parser.py

@@ -156,6 +156,39 @@ class TestParser(unittest.TestCase):
             expand_macros("DEF(X=recurse Y) DEF(Y=recurse X) X")
         self.assertTrue("Unable to resolve DEFs" in str(c.exception))
 
+    def test_escapes(self):
+        p = parse(r"[a:\:a:0.5] :\[a:b:0.5]")
+        self.assertPrompt(p, 0, 0.5, r"a :\[a:b:0.5]")
+        self.assertPrompt(p, 0.55, 1, r":a :\[a:b:0.5]")
+
+        p = parse(r"[embedding\:a:embedding\:b:0.1,0.5]")
+        self.assertPrompt(p, 0.15, 0.5, r"embedding:a")
+        self.assertPrompt(p, 0.55, 1, r"embedding:b")
+
+        p = parse(r"[embedding\:a:embedding\:b:embedding\:c:0.1,0.5]")
+        self.assertPrompt(p, 0.0, 0.1, r"embedding:a")
+        self.assertPrompt(p, 0.15, 0.5, r"embedding:b")
+        self.assertPrompt(p, 0.55, 1, r"embedding:c")
+
+        p = parse(r"[a\:b\\:c:0.5]")
+        self.assertPrompt(p, 0.0, 0.5, "a:b\\")
+        self.assertPrompt(p, 0.55, 1, r"c")
+
+        p = parse(r"[a:\#b:0.5]")
+        self.assertPrompt(p, 0.0, 0.5, "a")
+        self.assertPrompt(p, 0.55, 1, "#b")
+
+    def test_comments(self):
+        p = parse("this is a # comment")
+        self.assertPrompt(p, 0, 1.0, "this is a ")
+        p = parse("this is a [comment#:scheduled:0.6]")
+        self.assertPrompt(p, 0, 1.0, "this is a [comment")
+        p = parse(r"this is a [comment\#:scheduled:0.6]")
+        self.assertPrompt(p, 0, 0.6, "this is a comment#")
+        self.assertPrompt(p, 0.65, 1.0, "this is a scheduled")
+        p = parse("#this is a comment\nthis is a prompt")
+        self.assertPrompt(p, 0, 1.0, "\nthis is a prompt")
+
     def test_misc(self):
         p = parse("[[a:c:0.5]:0.7]")
         p2 = parse("[:[a:c:0.5]:0.7]")

prompt_control/utils.py

@@ -1,6 +1,7 @@
 from pathlib import Path
 import re
 import logging
+import copy
 
 # Allow testing
 try:
@@ -87,14 +88,19 @@ def find_closing_paren(text, start):
     return len(text)
 
 
-def get_function(text, func, defaults, return_func_name=False, placeholder="", return_dict=False):
-    rex = re.compile(rf"\b{func}\b", re.MULTILINE)
+def get_function(text, func, defaults, return_func_name=False, placeholder="", return_dict=False, require_args=True):
+    if require_args:
+        rex = re.compile(rf"\b{func}\(", re.MULTILINE)
+    else:
+        rex = re.compile(rf"\b{func}\b", re.MULTILINE)
     instances = []
     match = rex.search(text)
     count = 0
     while match:
         # Match start, content start
         start, at_paren = match.span()
+        if require_args:
+            at_paren = at_paren - 1
         funcname = text[start:at_paren]
         after_first_paren = at_paren + 1
         if text[at_paren:after_first_paren] == "(":
@@ -103,7 +109,7 @@ def get_function(text, func, defaults, return_func_name=False, placeholder="", r
             end += 1
         else:
             end = at_paren
-            args = None
+            args = defaults
         ph = None
         if placeholder:
             ph = f"\0{placeholder}{count}\0"
@@ -130,11 +136,11 @@ def get_function(text, func, defaults, return_func_name=False, placeholder="", r
     return text, instances
 
 
-def split_by_function(text, func, defaults=None):
+def split_by_function(text, func, defaults=None, require_args=True):
     """
     Splits a string by function calls, returning the text preceding the first call and a list of dictionaries with a "text" key with the prompt before the next split or until hthe end of the text.
     """
-    text, functions = get_function(text, func, defaults, return_dict=True)
+    text, functions = get_function(text, func, defaults, return_dict=True, require_args=require_args)
     chunks = []
     prev = 0
     for f in functions:
@@ -195,3 +201,38 @@ def lora_name_to_file(name):
             if p.name == n or str(p) == n:
                 return f
     return None
+
+
+def map_inputs(input_map, inputs):
+    new_inputs = {}
+    for k in inputs:
+        key = inputs[k]
+        new_inputs[k] = key
+        if isinstance(key, list):
+            key = tuple(key)
+            x = input_map.get(key, inputs[k])
+            new_inputs[k] = x
+    return new_inputs
+
+
+def expand_graph(node_mappings, graph):
+    input_map = {}
+    new_graph = copy.deepcopy(graph)
+    for k in graph:
+        data = graph[k]
+        if not isinstance(data, dict) or "class_type" not in data or data["class_type"] not in node_mappings:
+            continue
+        node = node_mappings[data["class_type"]]()
+        inputs = map_inputs(input_map, data["inputs"].copy())
+        inputs["unique_id"] = k
+        fn = getattr(node, getattr(node, "FUNCTION"))
+        expansion = fn(**inputs)
+        for i, v in enumerate(expansion["result"]):
+            input_map[(k, i)] = v
+        del new_graph[k]
+        new_graph.update(expansion["expand"])
+
+    for k in new_graph:
+        data = new_graph[k]
+        data["inputs"] = map_inputs(input_map, data["inputs"])
+    return new_graph

pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "comfyui-prompt-control"
-description = "Nodes for convenient prompt editing, making many common operations prompt-controllable"
-version = "2.0.0-rc.8"
+description = "Provides nodes for prompt editing and LoRA scheduling, advanced regional prompting (including attention masking) and more, all controlled through your text prompt"
+version = "2.0.1"
 license = { file = "LICENSE" }
 # some lark versions older than 1.1.9 apparently have a bug that breaks things, see https://github.com/asagi4/comfyui-prompt-control/issues/35
 dependencies = ["lark >= 1.1.9"]

tools/expand_graph.py

@@ -0,0 +1,13 @@
+#!/usr/bin/env python3
+from prompt_control.utils import expand_graph
+from prompt_control.nodes_lazy import NODE_CLASS_MAPPINGS as LN
+import json
+import sys
+
+
+# Needs ComfyUI in Python path
+# Usage: PYTHONPATH=../..:. python tools/expand_graph < graph_in_api_format.json > out.json
+if __name__ == "__main__":
+    graph = json.load(sys.stdin)
+    new = expand_graph(LN, graph)
+    print(json.dumps(new))

web/docs/PCAddMaskToCLIP.md

@@ -0,0 +1,3 @@
+# PC: Attach Mask
+
+Attaches custom masks to a CLIP object so that they can be referred to in prompts using `PCTextEncode` or `PC: Schedule prompt`.

web/docs/PCAddMaskToCLIPMany.md

@@ -0,0 +1 @@
+PCAddMaskToCLIP.md

web/docs/PCAttentionCoupleBatchNegative.md

@@ -0,0 +1,7 @@
+# PC: Attention Couple (batch negative)
+
+This node applies an optimization that re-enables negative cond batching when Attention Couple is in use.
+
+It improves performance when negative prompts are not scheduled, but slightly affects outputs and is not required for Attention Couple to work.
+
+Simply add it to your workflow and pass in your positive and negative prompts. It is always safe to use, as it will not do anything when it detects that the optimization can't be applied (eg. when negative prompts contain schedules)

web/docs/PCLazyLoraLoader.md

@@ -0,0 +1,7 @@
+# PC: Schedule LoRAs
+
+This node is the core of Prompt Control. It evaluates a prompt schedule and dynamically expands into a scheduled workflow consisting of necessary calls to `LoRALoader` and `Create Hook LoRA` (for scheduled LoRAs).
+
+You can use it in place or in addition to your usual `LoRA Loader` nodes; just pass in a text prompt containing your LoRA schedule (it can be shared with `PC: Schedule Prompt`). Then connect your MODEL output as usual and the CLIP output to your `PC: Schedule Prompt` nodes.
+
+For documentation on syntax, for now see the [documentation on GitHub](https://github.com/asagi4/comfyui-prompt-control/blob/master/doc/schedules.md)

web/docs/PCLazyLoraLoaderAdvanced.md

@@ -0,0 +1 @@
+PCLazyLoraLoader.md

web/docs/PCLazyTextEncode.md

@@ -0,0 +1,7 @@
+# PC: Schedule Prompt
+
+This node is the core of Prompt Control. It evaluates a prompt schedule and dynamically expands into a scheduled workflow consisting of calls to `PCTextEncode`, `SetConditioningTimesteps` and other necessary nodes.
+
+To use it, simply replace your usual `CLIP Text Encode` nodes with `PC: Schedule Prompt` nodes. For LoRA Loading, you should use `PC: Schedule LoRAs` in place (or in addition to) of your usual LoRA Loader node.
+
+For documentation on syntax, for now see the [documentation on GitHub](https://github.com/asagi4/comfyui-prompt-control/blob/master/doc/schedules.md)

web/docs/PCLazyTextEncodeAdvanced.md

@@ -0,0 +1 @@
+PCLazyTextEncode.md

web/docs/PCLoraHooksFromText.md

@@ -0,0 +1,5 @@
+# PC: LoRA Hooks from Text (non-lazy)
+
+Creates cond hooks from a LoRA schedule, if you want to apply them manually for some reason.
+
+You should not need to use this. Use `PC: Schedule LoRAs`.

web/docs/PCMacroExpand.md

@@ -0,0 +1,5 @@
+# PC: Expand Macros
+
+Expands [prompt macros](https://github.com/asagi4/comfyui-prompt-control/blob/master/doc/macros.md)
+
+You should not need to use this directly. Use `PC: Schedule Prompt` instead.

web/docs/PCSetPCTextEncodeSettings.md

@@ -0,0 +1,7 @@
+# PC: Configure PCTextEncode
+
+Configures a CLIP object with new default values used by `PCTextEncode`. Apply it before everything else.
+
+This is needed if you want to do scheduling with steps instead of denoising percentages, but otherwise it's completely optional.
+
+Note that steps are simply syntactic sugar for percentages and may not correspond to actual steps depending on the scheduler used.

web/docs/PCTextEncode.md

@@ -0,0 +1,5 @@
+# PC: Text Encode (no scheduling)
+
+This node encodes text using some special syntax for advanced features. You should rarely need to use this node directly, and instead use `PC: Schedule Prompt` which uses this node under the hood.
+
+For documentation on syntax, see the [documentation on GitHub](https://github.com/asagi4/comfyui-prompt-control/blob/master/doc/basic.md)