app.py

import gradio as gr
import requests
import io
from PIL import Image
import json
from image_processing import downscale_image, limit_colors, convert_to_grayscale, convert_to_black_and_white
import logging

class SomeClass:
    def __init__(self):
        self.images = []

with open('loras.json', 'r') as f:
    loras = json.load(f)

def update_selection(selected_state: gr.SelectData):
    logging.debug(f"Inside update_selection, selected_state: {selected_state}")
    selected_lora_index = selected_state.index
    selected_lora = loras[selected_lora_index]
    new_placeholder = f"Type a prompt for {selected_lora['title']}"
    lora_repo = selected_lora["repo"]
    updated_text = f"### Selected: [{lora_repo}](https://huggingface.co/{lora_repo}) ✨"
    return (
        gr.update(placeholder=new_placeholder),
        updated_text,
        selected_state
    )

def run_lora(prompt, selected_state, progress=gr.Progress(track_tqdm=True)):
    selected_lora_index = selected_state.index
    selected_lora = loras[selected_lora_index]
    api_url = f"https://api-inference.huggingface.co/models/{selected_lora['repo']}"
    payload = {"inputs": f"{prompt} {selected_lora['trigger_word']}", "parameters": {"negative_prompt": "bad art, ugly, watermark, deformed"}}
    response = requests.post(api_url, json=payload)
    if response.status_code == 200:
        original_image = Image.open(io.BytesIO(response.content))
        processed = SomeClass()
        processed.images = [original_image]
        refined_image = processed.images[-1]
        return original_image, refined_image

def apply_post_processing(image, downscale, limit_colors, grayscale, black_and_white):
    processed_image = image.copy()
    if downscale > 1:
        processed_image = downscale_image(processed_image, downscale)
    if limit_colors:
        processed_image = limit_colors(processed_image)
    if grayscale:
        processed_image = convert_to_grayscale(processed_image)
    if black_and_white:
        processed_image = convert_to_black_and_white(processed_image)
    return processed_image

with gr.Blocks() as app:
    title = gr.Markdown("# artificialguybr LoRA portfolio")
    description = gr.Markdown("### This is a Pixel Art Generator using SD Loras.")
    selected_state = gr.State()
    
    with gr.Row():
        gallery = gr.Gallery([(item["image"], item["title"]) for item in loras], label="LoRA Gallery", allow_preview=False, columns=3)
        
        with gr.Column():
            prompt_title = gr.Markdown("### Click on a LoRA in the gallery to create with it")
            selected_info = gr.Markdown("")
            
            with gr.Row():
                prompt = gr.Textbox(label="Prompt", show_label=False, lines=1, max_lines=1, placeholder="Type a prompt after selecting a LoRA")
                button = gr.Button("Run")
            
            result = gr.Image(interactive=False, label="Generated Image")
            refined_result = gr.Image(interactive=False, label="Refined Generated Image")
            post_processed_result = gr.Image(interactive=False, label="Post-Processed Image")

    # Post-Processing Options Above Tabs
    enable_post_processing = gr.Checkbox(label="Enable Post-Processing", value=False)
    downscale_slider = gr.Slider(label="Downscale", minimum=1, maximum=31, step=1, value=1)
    rescale_to_original = gr.Checkbox(label="Rescale to Original Size", value=True)
    
    with gr.Tabs():
        with gr.TabItem("Color"):
            enable_color_limit = gr.Checkbox(label="Enable", value=False)
            palette_size_color = gr.Slider(label="Palette Size", minimum=1, maximum=256, step=1, value=16)
            quantization_methods_color = gr.Radio(choices=["Median Cut", "Maximum Coverage", "Fast Octree"], label="Colors Quantization Method")
            dither_methods_color = gr.Radio(choices=["None", "Floyd-Steinberg"], label="Colors Dither Method")
            k_means_color = gr.Checkbox(label="Enable k-means for color quantization", value=True)
        
        with gr.TabItem("Grayscale"):
            enable_grayscale = gr.Checkbox(label="Enable", value=False)
            palette_size_gray = gr.Slider(label="Palette Size", minimum=1, maximum=256, step=1, value=16)
            quantization_methods_gray = gr.Radio(choices=["Median Cut", "Maximum Coverage", "Fast Octree"], label="Colors Quantization Method")
            dither_methods_gray = gr.Radio(choices=["None", "Floyd-Steinberg"], label="Colors Dither Method")
            k_means_gray = gr.Checkbox(label="Enable k-means for color quantization", value=True)
        
        with gr.TabItem("Black and white"):
            enable_black_and_white = gr.Checkbox(label="Enable", value=False)
            inverse_black_and_white = gr.Checkbox(label="Inverse", value=False)
            threshold_black_and_white = gr.Slider(label="Threshold", minimum=1, maximum=256, step=1, value=128)
        
        with gr.TabItem("Custom color palette"):
            enable_custom_palette = gr.Checkbox(label="Enable", value=False)
            palette_image = gr.Image(label="Color palette image", type="pil")
            palette_size_custom = gr.Slider(label="Palette Size", minimum=1, maximum=256, step=1, value=16)
            dither_methods_custom = gr.Radio(choices=["None", "Floyd-Steinberg"], label="Colors Dither Method")
            
            post_process_button = gr.Button("Apply Post-Processing")
    
    gallery.select(update_selection, outputs=[prompt, selected_info, selected_state])
    prompt.submit(fn=run_lora, inputs=[prompt, selected_state], outputs=[result, refined_result])
    post_process_button.click(fn=apply_post_processing, inputs=[refined_result, downscale_slider, limit_colors, grayscale, black_and_white], outputs=[post_processed_result])

app.queue(max_size=20, concurrency_count=5)
app.launch()