Triggering txt2img generation in extension script

[MNeMoNiCuZ]

I'm working on an extension that creates manages checkpoint thumbnails, and I have everything that I need for my extension sorted out to a basic level.

My current issue is that I'm using the API to trigger the thumbnail generation. I would like to switch this to just trigger the generation without routing it via an API call.

Most of my code is generated with ChatGPT, but I've bashed my head against it for hours now trying to switch to local generation, and I can't find the right example for me to use for local inference triggered in the script.

Note that the 'set_data" and related values like "current_set_name" are unrelated to the SD code, these are to load the right values from my json-files containing the settings.

Here's the code I use for generation using the API:

# Generate thumbnails
def generate_thumbnail_for_model(model_name, suffix):
    url = "http://127.0.0.1:7860"
    global current_set_name

    # Extract the base model name (without file extension) for API calls
    base_model_name = Path(model_name).stem

    # Fetch set data
    set_data = get_set_data(current_set_name)
    print(f"Retrieved set data for '{current_set_name}': {set_data}")
    
    if set_data is None:
        print(f"Set '{current_set_name}' not found. Using default settings.")
        set_data = {}  # Use an empty dictionary for default settings

    # Payload with settings from the set or default values
    payload = {
        "prompt": set_data.get("prompt", "A beautiful crystal gem, diamond, masterpiece, best quality"),
        "negative_prompt": set_data.get("negativePrompt", "ugly"),
        "sampler": set_data.get("sampler", "Euler-a"),
        "steps": set_data.get("steps", 25),
        "width": set_data.get("width", 420),
        "height": set_data.get("height", 640),
        "cfg_scale": set_data.get("cfgScale", 6),
        "seed": set_data.get("seed", -1),
        "do_not_save_samples": False,
        "do_not_save_grid": False,
        "override_settings": {"sd_model_checkpoint": base_model_name}
    }

    # Attempt to switch model by calling the options API endpoint first
    options_payload = {"sd_model_checkpoint": base_model_name}
    options_response = requests.post(url=f'{url}/sdapi/v1/options', json=options_payload)
    if options_response.status_code != 200:
        print(f"Failed to switch model. Status Code: {options_response.status_code}")
        print(options_response.json())
        return

    # Sending the request to the API for thumbnail generation
    response = requests.post(url=f'{url}/sdapi/v1/txt2img', json=payload)
    if response.status_code != 200:
        print(f"Failed to generate thumbnail. Status Code: {response.status_code}")
        print(response.json())
        return

    # Processing the response to get the image
    r = response.json()
    image = Image.open(io.BytesIO(base64.b64decode(r['images'][0])))

    # Model path
    model_file_path = find_model_file_path(model_name)
    if model_file_path is None:
        print(f"Model file for {model_name} not found or is blocklisted.")
        return

    # Save the image
    output_directory = model_file_path.parent
    suffix_str = f".{suffix}" if suffix and not suffix.startswith(".") else suffix
    output_filename = f"{base_model_name}{suffix_str}.png"
    output_path = output_directory / output_filename
    image.save(output_path)
    print(f"Thumbnail generated and saved as {output_path}")

If someone could point me in the right direction on how to use txt2img in a similar fashion, it'd help a lot :)
Thank you for your time!

[MNeMoNiCuZ]

A friend was able to figure it out and help me out. In case someone is trying to figure out how to generate an image with txt2img from inside Automatic1111, here's the code:

`# Generate thumbnails
def generate_thumbnail_for_model(model_name, suffix):
# Initialize processed to None
processed = None

# Fetch set data
set_data = get_set_data(current_set_name)
print(f"Retrieved set data for '{current_set_name}': {set_data}")

try:
    # Set up processing parameters
    p = processing.StableDiffusionProcessingTxt2Img(
        sd_model=shared.sd_model,
        outpath_samples="",
        outpath_grids="",
        prompt=set_data.get("prompt", "Default Prompt"),
        negative_prompt=set_data.get("negativePrompt", ""),
        steps=int(set_data.get("steps", 25)),
        cfg_scale=float(set_data.get("cfgScale", 6.0)),
        sampler_name=set_data.get("sampler", "Default Sampler"),
        width=int(set_data.get("width", 420)),
        height=int(set_data.get("height", 640)),
        seed=int(set_data.get("seed", -1)),
        override_settings={"sd_model_checkpoint": model_name}
    )

    print (f"Generating with {model_name}")

    # Perform any necessary pre-processing or initialization
    p.init(["A beautiful crystal gem, diamond, masterpiece, best quality"],[-1],[-1])
    
    # Process the image
    with closing(p):
        if processed is None:
            processed = processing.process_images(p)

    # Ensure that images were generated
    if not processed or not processed.images:
        raise ValueError("No images were generated.")

    # Extract the first image
    image = processed.images[0]

    # Ensure the image is a PIL Image
    if not isinstance(image, Image.Image):
        raise TypeError("The generated image is not a PIL Image.")

    # Save the image
    model_file_path = find_model_file_path(model_name)
    if model_file_path is None:
        raise FileNotFoundError(f"Model file for {model_name} not found or is blocklisted.")
    
    output_directory = model_file_path.parent
    suffix_str = f".{suffix}" if suffix and not suffix.startswith(".") else suffix
    output_filename = f"{Path(model_name).stem}{suffix_str}.png"
    output_path = output_directory / output_filename
    image.save(output_path)
    print(f"Thumbnail generated and saved as {output_path}")

except Exception as e:
    print(f"Error in generating thumbnail for {model_name}: {e}")
    traceback.print_exc()`

Again, keeping in mind that the "get_set_data" function is where I load my data from a json file.