quick-syntax for multirandom, for #196

Author: mcmonkey4eva

docs/Basic Usage.md

@@ -80,6 +80,12 @@ Prompting is, primarily, just text input. However, there are some special option
     - This random is seeded by the main seed - so if you have a static seed, this won't change.
     - You can use `,` to separate the entries, or `|`, or `||`. Whichever is most unique gets used - so if you want random options with `,` in them, just use `|` as a separator, and `,` will be ignored (eg `<random:red|blue|purple>`).
     - An entry can contain the syntax of eg `1-5` to automatically select a number from 1 to 5. For example, `<random:1-3, blue>` will give back any of: `1`, `2`, `3`, or `blue`.
+    - You can repeat random choices via `<random[1-3]:red, blue, purple>` which might return for example `red blue` or `red blue purple` or `blue`.
+        - You can use a comma at the end like `random[1-3,]` to specify the output should have a comma eg `red, blue`.
+- You can use the syntax `<wildcard:my/wildcard/name>` to randomly select from a wildcard file, which is basically a pre-saved text file of random options, 1 per line.
+    - Edit these in the UI at the bottom in the "Wildcards" tab.
+    - You can also import wildcard files from other UIs (ie text file collections) by just adding them into `Data/Wildcards` folder.
+    - This supports the same syntax as `random` to get multiple, for example `<wildcard[1-3]:animals>` might return `cat dog` or `elephant leopard dog`.
 - You can use the syntax `<repeat:3, cat>` to get the word "cat" 3 times in a row (`cat cat cat`).
     - You can use for example like `<repeat:1-3, <random:cat, dog>>` to get between 1 and 3 copies of either `cat` or `dog`, for example it might return `cat dog cat`.
 - You can use `<embed:filename>` to use a Textual Inversion embedding anywhere.

src/Text2Image/T2IParamInput.cs

@@ -24,6 +24,9 @@ public class PromptTagContext
 
         public int Depth = 0;
 
+        /// <summary>If the current syntax usage has a pre-data block, it will be here. This will be null otherwise.</summary>
+        public string PreData;
+
         public string Parse(string text)
         {
             if (Depth > 1000)
@@ -76,26 +79,63 @@ public static bool TryInterpretNumberRange(string inputVal, out string number)
         return null;
     }
 
+    public static (int, string) InterpretPredataForRandom(string prefix, string preData, string data)
+    {
+        int count = 1;
+        string separator = " ";
+        if (preData is not null)
+        {
+            if (preData.EndsWithFast(','))
+            {
+                separator = ", ";
+                preData = preData[0..^1];
+            }
+            double? countVal = InterpretNumber(preData);
+            if (!countVal.HasValue)
+            {
+                Logs.Warning($"Random input '{prefix}[{preData}:{data}' has invalid predata count (not a number) and will be ignored.");
+                return (0, null);
+            }
+            count = (int)countVal.Value;
+        }
+        return (count, separator);
+    }
+
     static T2IParamInput()
     {
         PromptTagProcessors["random"] = (data, context) =>
         {
+            (int count, string partSeparator) = InterpretPredataForRandom("random", context.PreData, data);
+            if (partSeparator is null)
+            {
+                return null;
+            }
             string separator = data.Contains("||") ? "||" : (data.Contains('|') ? "|" : ",");
             string[] vals = data.Split(separator, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
             if (vals.Length == 0)
             {
                 Logs.Warning($"Random input '{data}' is empty and will be ignored.");
                 return null;
             }
-            string choice = vals[context.Random.Next(vals.Length)];
-            if (TryInterpretNumberRange(choice, out string number))
+            string result = "";
+            for (int i = 0; i < count; i++)
             {
-                return number;
+                string choice = vals[context.Random.Next(vals.Length)];
+                if (TryInterpretNumberRange(choice, out string number))
+                {
+                    return number;
+                }
+                result += context.Parse(choice).Trim() + partSeparator;
             }
-            return context.Parse(choice);
+            return result.Trim();
         };
         PromptTagProcessors["wildcard"] = (data, context) =>
         {
+            (int count, string partSeparator) = InterpretPredataForRandom("random", context.PreData, data);
+            if (partSeparator is null)
+            {
+                return null;
+            }
             string card = T2IParamTypes.GetBestInList(data, WildcardsHelper.ListFiles);
             if (card is null)
             {
@@ -104,8 +144,13 @@ static T2IParamInput()
             }
             List<string> usedWildcards = context.Input.ExtraMeta.GetOrCreate("used_wildcards", () => new List<string>()) as List<string>;
             usedWildcards.Add(card);
-            string choice = WildcardsHelper.PickRandom(card, context.Random);
-            return context.Parse(choice);
+            string result = "";
+            for (int i = 0; i < count; i++)
+            {
+                string choice = WildcardsHelper.PickRandom(card, context.Random);
+                result += context.Parse(choice).Trim() + partSeparator;
+            }
+            return result.Trim();
         };
         PromptTagProcessors["repeat"] = (data, context) =>
         {
@@ -410,6 +455,12 @@ void processSet(Dictionary<string, Func<string, PromptTagContext, string>> set)
             val = StringConversionHelper.QuickSimpleTagFiller(val, "<", ">", tag =>
             {
                 (string prefix, string data) = tag.BeforeAndAfter(':');
+                string preData = null;
+                if (prefix.EndsWith(']') && prefix.Contains('['))
+                {
+                    (prefix, preData) = prefix.BeforeLast(']').BeforeAndAfter('[');
+                }
+                context.PreData = preData;
                 if (!string.IsNullOrWhiteSpace(data) && set.TryGetValue(prefix, out Func<string, PromptTagContext, string> proc))
                 {
                     string result = proc(data, context);

src/wwwroot/js/genpage/params.js

@@ -1007,13 +1007,20 @@ class PromptTabCompleteClass {
         this.registerPrefix('random', 'Select from a set of random words to include', (prefix) => {
             return ['\nSpecify a comma-separated list of words to choose from, like "<random:cat,dog,elephant>". You can use "||" instead of "," if you need to include commas in your values. You can use eg "1-5" to pick a random number in a range.'];
         });
-        this.registerPrefix('repeat', 'Repeat a value several times', (prefix) => {
-            return ['\nUse for example like "<repeat:3,very> big" to get "very very very big", or "<repeat:1-3,very>" to get randomly between 1 to 3 "very"s, or <repeat:3,<random:cat,dog>>" to get "cat" or "dog" 3 times in a row eg "cat dog cat".'];
+        this.registerPrefix('random[2-4]', 'Selects multiple options from a set of random words to include', (prefix) => {
+            return ['\nSpecify a comma-separated list of words to choose from, like "<random[2]:cat,dog,elephant>". You can use "||" instead of "," if you need to include commas in your values. You can use eg "1-5" to pick a random number in a range. Put a comma in the input (eg "random[2,]:") to make the output have commas too.'];
         });
         this.registerPrefix('wildcard', 'Select a random line from a wildcard file (presaved list of options)', (prefix) => {
             let prefixLow = prefix.toLowerCase();
             return allWildcards.filter(w => w.toLowerCase().startsWith(prefixLow));
         });
+        this.registerPrefix('wildcard[2-4]', 'Select multiple random lines from a wildcard file (presaved list of options) (works same as "random" but for wildcards)', (prefix) => {
+            let prefixLow = prefix.toLowerCase();
+            return allWildcards.filter(w => w.toLowerCase().startsWith(prefixLow));
+        });
+        this.registerPrefix('repeat', 'Repeat a value several times', (prefix) => {
+            return ['\nUse for example like "<repeat:3,very> big" to get "very very very big", or "<repeat:1-3,very>" to get randomly between 1 to 3 "very"s, or <repeat:3,<random:cat,dog>>" to get "cat" or "dog" 3 times in a row eg "cat dog cat".'];
+        });
         this.registerPrefix('preset', 'Forcibly apply a preset onto the current generation (useful eg inside wildcards or other automatic inclusions - normally use the Presets UI tab)', (prefix) => {
             let prefixLow = prefix.toLowerCase();
             return allPresets.filter(p => p.title.toLowerCase().startsWith(prefixLow)).map(p => p.title);