New feature for X/Y Plot: comparison of 3rd party models with activation tokens

[system1system2]

Right now, the X/Y Plot script for AUTOMATIC1111 can already compare multiple models with the Checkpoint name type.
It works well if you are comparing models that have no activation tokens (e.g.: SD 1.4 vs 1.5 vs 2.0).

But it doesn't work well if, for example, you want to compare classicAnim-v1.ckpt vs moDi-v1-pruned.ckpt vs robo-diffusion-v1.ckpt, etc. And that's because these checkpoint need an activation token: classic disney style, modern disney style, nousr robot, etc.

You could theoretically use Checkpoint name for the X type and Prompt S/R for the Y type, but it would produce a lot of unnecessary outputs.

It would be much better if the X/Y Plot script could associate an activation token to each checkpoint in the X type.

[angrysky56]

So I am not a coder but trying to work out some script changes with the notorious chatGPT myself. I want to populate lists for a dropdown menu and increase the number of options that can be ran at once. This seems like a super powerful tool that is a great sequencer concept. You could populate a list of embeddings or tokens or templates or whatever too.-

The code defines two functions, "apply_sampler" and "confirm_samplers". The "apply_sampler" function takes in three arguments, "p", "x", and "xs". It uses the "get()" method to check if the lowercase version of "x" exists in a dictionary called "samplers_map". If it does not exist, it raises a "RuntimeError" with the message "Unknown sampler: {x}". If it does exist, it sets the "sampler_name" attribute of the "p" object to the value of "sampler_name".

The "confirm_samplers" function takes in two arguments, "p" and "xs". It iterates through each item "x" in "xs" and checks if the lowercase version of "x" exists in the "samplers_map" dictionary. If it does not, it raises a "RuntimeError" with the message "Unknown sampler: {x}". This function is likely used to confirm that all items in "xs" are valid entries in the "samplers_map" dictionary.

i'd like to be able to populate the list of samplers from a folder location
You can use the os and importlib modules to accomplish this. Here is an example of how you might populate a list of samplers from a folder location:

Copy code
import os
import importlib

def populate_samplers_list(folder_path):
samplers = []
for file_name in os.listdir(folder_path):
if file_name.endswith(".py") and not file_name.startswith("__"):
module_name = file_name[:-3]
module = importlib.import_module(module_name)
samplers.append(module)
return samplers

samplers_list = populate_samplers_list("path/to/folder")
This function takes in a single argument, a string representing the path to the folder containing the sampler modules. It uses the os.listdir() function to get a list of all files in the folder. It then iterates through the list, checking if the file is a Python file (ends with ".py") and if it is not a special file (does not start with "__"). If these conditions are met, it imports the module using importlib.import_module() and appends it to the samplers list. The function then returns the samplers list.

You can then use this list in the confirm_samplers function to check if the sampler is valid or not.

Copy code
def confirm_samplers(p, xs,samplers_list):
for x in xs:
if x.lower() not in samplers_list:
raise RuntimeError(f"Unknown sampler: {x}")
You can also use this list in the apply_sampler function to set the sampler_name attribute of the p object.

Copy code
def apply_sampler(p, x, samplers_list):
sampler_name = [s.name for s in samplers_list if s.name.lower() == x.lower()][0]
if not sampler_name:
raise RuntimeError(f"Unknown sampler: {x}")
p.sampler_name = sampler_name
Please note that this is just an example, you will have to adjust it to your specific use case.

for a dropdown menu too instead of having to type the names in sorry
If you want to use a dropdown menu to select the sampler, you will need to use a GUI library such as Tkinter, PyQt, or wxPython.

Here is an example of how you might implement a dropdown menu using Tkinter:

Copy code
import tkinter as tk

def select_sampler(samplers_list):
# Create a new Tkinter window
root = tk.Tk()

# Create a StringVar to store the selected sampler
selected_sampler = tk.StringVar()

# Create a dropdown menu
sampler_menu = tk.OptionMenu(root, selected_sampler, *samplers_list)
sampler_menu.pack()

# Create a button to confirm the selection
confirm_button = tk.Button(root, text="Confirm", command=root.destroy)
confirm_button.pack()

# Run the Tkinter event loop
root.mainloop()

return selected_sampler.get()

samplers_list = populate_samplers_list("path/to/folder")
selected_sampler = select_sampler(samplers_list)
confirm_samplers(p, [selected_sampler],samplers_list)
apply_sampler(p, selected_sampler, samplers_list)
This function creates a new Tkinter window with a dropdown menu populated with the samplers from the samplers_list, and a "Confirm" button. When the user selects a sampler from the menu and clicks the "Confirm" button, the function closes the window and returns the selected sampler. you can then use this selected_sampler as input to confirm_samplers and apply_sampler functions.

Please note that this is just an example, you will have to adjust it to your specific use case and also you will have to import the tkinter module and install it if not already installed.

does this help to figure out how to properly write that?
from collections import namedtuple
from copy import copy
from itertools import permutations, chain
import random
import csv
from io import StringIO
from PIL import Image
import numpy as np

import modules.scripts as scripts
import gradio as gr

from modules import images, paths, sd_samplers, processing, sd_models, sd_vae
from modules.hypernetworks import hypernetwork
from modules.processing import process_images, Processed, StableDiffusionProcessingTxt2Img
from modules.shared import opts, cmd_opts, state
import modules.shared as shared
import modules.sd_samplers
import modules.sd_models
import modules.sd_vae
import glob
import os
import re

from modules.ui_components import ToolButton

fill_values_symbol = "\U0001f4d2" # 📒

def apply_field(field):
def fun(p, x, xs):
setattr(p, field, x)

return fun

This code appears to be part of a larger project that uses various modules, including gradio, PIL, numpy, csv, io, and itertools.

The apply_field function is defined, which takes in one argument, "field" and returns a nested function, "fun". The returned function takes in three arguments, "p", "x" and "xs" and it uses the setattr() function to set the attribute of "p" object to the value of "x" which is passed as an argument.

This function is likely being used to set specific attributes of an object "p" based on user input. The apply_field function allows to define a function that sets an attribute of an object, by passing the name of the attribute as an argument and it returns a new function that can be used to set that attribute.

The code also imports various modules, including modules.scripts, modules.images, modules.paths, modules.sd_samplers, modules.processing, modules.sd_models, modules.sd_vae, modules.hypernetworks, modules.processing, modules.shared, modules.sd_samplers, modules.sd_models, modules.sd_vae, modules.ui_components and glob, os, re .

It also defines a variable fill_values_symbol which is set to the Unicode character for a notebook. It is not clear how this variable is used in the larger context of the program.

I think the fill values is for tokenizing and translating text image prompt
I see, the fill_values_symbol is likely used as a placeholder for missing or unknown values in a text-image prompt. The purpose of this symbol is to indicate where the user needs to fill in information or input when prompted. This is known as tokenization.

It's used to replace certain parts of a text string with a symbol, such as fill_values_symbol, so that the user can easily identify the parts of the text that need to be filled in. This can be helpful for creating interactive prompts or forms, where the user needs to input specific information. The filled in values can then be translated into image with the help of libraries like PIL, numpy etc.

It's not clear from the provided code snippet how this variable is used in the larger context of the program, but it seems like it's related to the text-image prompt generation.

i'm just trying to populate those modules with a list from file locations in the program and create a buttons that drop down from the lists
Yes, it sounds like you're trying to dynamically load a list of modules from a specific file location and then create buttons in a GUI that will allow the user to select a module from the list.

You can use the glob module to dynamically find all the modules in a given folder location, and then use the importlib module to import those modules.

Here's an example of how you might do this:

Copy code
import glob
import importlib

def populate_modules_list(folder_path):
modules = []
for file_path in glob.glob(f"{folder_path}/*.py"):
module_name = os.path.basename(file_path)[:-3]
if not module_name.startswith("__"):
module = importlib.import_module(module_name)
modules.append(module)
return modules

modules_list = populate_modules_list("path/to/folder")
This function takes in a single argument, a string representing the path to the folder containing the modules. It uses the glob.glob() function to find all the Python files in the folder. It then iterates through the list, and imports the module using importlib.import_module(), and appends it to the modules list. The function then returns the modules list.

Then, you can use this list to create a dropdown menu in a GUI library such as Tkinter, PyQt, or wxPython, to allow the user to select a module from the list.

Here's an example of how you might create a dropdown menu using Tkinter:

Copy code
import tkinter as tk

def create_module_dropdown(modules_list):
root = tk.Tk()

# Create a StringVar to store the selected module
selected_module = tk.StringVar()

# Create a dropdown menu
module_menu = tk.OptionMenu(root, selected_module, *modules_list)
module_menu.pack()

# Create a button to confirm the selection
confirm_button = tk.Button(root, text="Confirm", command=root.destroy)
confirm_button.pack()

root.mainloop()

return selected_module.get()

modules_list = populate_modules_list("path/to/folder")
selected_module = create_module_dropdown(modules_list)
This function creates a new Tkinter window with a dropdown menu populated with the modules from the modules_list, and a "Confirm" button. When the user selects a module from the menu and clicks the "Confirm" button, the function closes the window and returns the selected module.

Please note that this is just an example, you will have to adjust it to your specific use case and also you will have to import the tkinter module and install it if not already installed.

[angrysky56]

so the yellow notebook icon does populate the list of samplers

[angrysky56]

this is pretty close just noticed lol.
https://github.com/mcmonkeyprojects/sd-infinity-grid-generator-script

[system1system2]

Thanks for the suggestion @angrysky56. ThePromptReplace command in this extension could help, in theory, but it would require the unpleasant convolution of adding a generic keyword like xyz123 and then crafting the replacement for every checkpoint.

I found something much better and much easier to use:
https://github.com/mix1009/model-keyword

This wonderful extension by @mix1009 stays active at all times and adds the right activation token for each checkpoint in every prompt you write.
This means that you can use the default X/Y Plot script without any extra steps. You simply define all checkpoints that you want in the axis you prefer, and Model Keyword will add the correct token to your prompt only where needed.