Update app.py

app.py

@@ -1,433 +1,38 @@
 import gradio as gr
-import random
-from random import choice
-import requests
-import base64
-import io
-import re
-import plotly.graph_objects as go
-import numpy as np
-from PIL import Image, ImageDraw
-import random
-import re
-import os
-import shutil
-import gdown
-import pandas as pd
-import plotly.express as px
-import streamlit as st
-
-
-# Try to import plotly, if not installed, install it
-try:
-    import plotly
-except ImportError:
-    os.system('pip install plotly')
-
-# Define your inputs outside of the gr.Row() block
-# These are the inputs that will be used to generate the radar chart
-input_parameters = gr.Textbox(placeholder="Enter parameters, separated by commas", label="Parameters")
-randomize_values = gr.Checkbox(label="Randomize Values", value=True)
-randomize_titles = gr.Checkbox(label="Randomize Titles", value=True)
-randomize_param_count = gr.Checkbox(label="Randomize Parameter Count")
-chart_title = gr.Textbox(value="Radar Chart", label="Chart Title")
-param_count = gr.Slider(minimum=3, maximum=10, step=1, label="Parameter Count")
-param1 = gr.Slider(minimum=0, maximum=1.5, step=0.25, label="Parameter 1", value=.75)
-param2 = gr.Slider(minimum=0, maximum=1.5, step=0.25, label="Parameter 2", value=.75)
-param3 = gr.Slider(minimum=0, maximum=1.5, step=0.25, label="Parameter 3", value=.75)
-param4 = gr.Slider(minimum=0, maximum=1.5, step=0.25, label="Parameter 4", value=.75)
-param5 = gr.Slider(minimum=0, maximum=1.5, step=0.25, label="Parameter 5", value=.75)
-param6 = gr.Slider(minimum=0, maximum=1.5, step=0.25, label="Parameter 6", value=.75)
-param7 = gr.Slider(minimum=0, maximum=1.5, step=0.25, label="Parameter 7", value=.75)
-param8 = gr.Slider(minimum=0, maximum=1.5, step=0.25, label="Parameter 8", value=.75)
-param9 = gr.Slider(minimum=0, maximum=1.5, step=0.25, label="Parameter 9", value=.75)
-param10 = gr.Slider(minimum=0, maximum=1.5, step=0.25, label="Parameter 10", value=.75)
-prompt_input = gr.Textbox(lines=2, placeholder="Imagine something...", label="Prompt", value="__cars__")
-steps_input = gr.Slider(minimum=15, maximum=50, step=15, value=5, label="Steps")
-reset_seed_input = gr.Checkbox(label="Randomize Composition")
-increment_seed_input = gr.Checkbox(label="New Composition")
-img_output = gr.Image(label="Generated Image")
-radar_output = gr.Plot(label="Radar Chart")
-slider_labels_output = gr.Textbox(label="Prompt: Slider Labels")
-title1 = gr.Textbox(value='Minimalism', label="Title 1")
-title2 = gr.Textbox(value='Bauhaus', label="Title 2")
-title3 = gr.Textbox(value='Organic Design', label="Title 3")
-title4 = gr.Textbox(value='Brutalism', label="Title 4")
-title5 = gr.Textbox(value='Mid-century Modern', label="Title 5")
-title6 = gr.Textbox(value='Retro-Vintage', label="Title 6")
-title7 = gr.Textbox(value='Futurism', label="Title 7")
-title8 = gr.Textbox(value='Tesselated', label="Title 8")
-title9 = gr.Textbox(value='Streamlined', label="Title 9")
-title10 = gr.Textbox(value='Timeless', label="Title 10")
-
-# Define other inputs and outputs
-# These are the inputs and outputs that will be used to generate the image
-prompt_input = gr.Textbox(lines=2, placeholder="Imagine something...", label="Prompt", value="__cars__")
-steps_input = gr.Slider(minimum=15, maximum=50, step=5, value=15, label="Steps")
-img_output = gr.Image(label="Generated Image")
-prompt = "__cars__" 
-slider_labels = "concept art sketch"
-full_prompt = f"{prompt} {slider_labels}"
-prompt_input1 = title1
-prompt_input2 = title2
-prompt_input3 = title3
-
-
-# Global variables
-url = "http://73.255.78.150:7909/sdapi/v1/txt2img"
-session_seed = 1
-# Set a global variable for steps_input
-steps_input = 25
-last_session_seed = 2
-ALL_TITLES = [
-    'Minimalism', 'Bauhaus', 'Organic Design', 'Brutalism', 'Mid-century Modern',
-    'Retro-Vintage', 'Futurism', 'Tesselated', 'Streamlined', 'Timeless',
-    'Industrial Chic', 'Art Deco', 'Elegant', 'Biomorphic Design', 'High Contrast',
-    'Deconstructivism', 'Zen Design', 'Pop Art', 'Cyberpunk', 'Sustainable Design',
-    'Angular', 'Textured', 'Symmetric', 'Utilitarian', 'Dynamic Energy Flow',
-    'Less Extreme', 'Moderately Avant-Garde', 'Highly Avant-Garde'
-]
-ALL_VALUES = [
-    1.5, 1.2, 0.8, 1.0, 0.5, 1.0, 0.3, 0.5, 1.1, 0.7,
-    0.9, 1.3, 0.2, 1.3, 0.9, 1.1, 0.7, 0.6, 0.8, 0.4,
-    0.2, 0.1, 1.2, 0.0, 0.4
-]
-base_payload = {
-    "steps": 25,
-    "seed": 1,
-    "width": 768,
-    "height": 512,
-}
-
-# Function to change the global variable 'prompt'
-def change_prompt(new_prompt):
-    global prompt  # declare that we're using the global variable
-    prompt = new_prompt  # overwrite the global variable
-
-change_prompt("__trains__")
-print(prompt)  # will output "__trains__"
-
-def generate_image(prompt_input, steps, reset_seed, increment_seed):
-    global session_seed
-    global last_session_seed
-    global slider_labels
-    global prompt  # declare that we're using the global variable
-    prompt = prompt_input  # overwrite the global variable with the new input
-    if reset_seed:
-        if session_seed != -1:
-            last_session_seed = session_seed
-        session_seed = -1
-    elif not reset_seed and last_session_seed is not None:
-        session_seed = last_session_seed
-    elif session_seed is None:
-        session_seed = random.randint(0, 10000)
-    if increment_seed and session_seed != -1:
-        session_seed += 1
-        
-
-
-
-# Function definitions
-def generate_figure(r_values, theta_values, chart_title):
-    fig = go.Figure(data=go.Scatterpolar(
-        r=r_values, theta=theta_values, mode='lines+markers',
-        marker=dict(size=10), fill='toself')
-    )
-    fig.update_layout(
-        polar=dict(radialaxis=dict(visible=True, range=[-1.5, 1.75])),
-        showlegend=False, title=chart_title
-    )
-    return fig
-
-# Global variables to store the initial values
-initial_values = [("Textured", 0.75), ("Deconstructivism", 0.75), ("Utilitarian", 0.75)]
-
-# Global variables to store the temporary arrays
-temp_parameters = [title for title, value in initial_values]
-temp_array = [value for title, value in initial_values]
-temp_r_values = [value for title, value in initial_values]
-
-def display_radar_chart(input_parameters, randomize_values, randomize_titles, randomize_param_count, chart_title, param_count, *params):
-    global slider_labels  # Ensure this variable is available in your scope
-    global temp_parameters, temp_r_values  # Declare the global variables
-
-    print(f"Input Parameters: {input_parameters}")
-    print(f"Randomize Values: {randomize_values}")
-    print(f"Randomize Titles: {randomize_titles}")
-    print(f"Randomize Parameter Count: {randomize_param_count}")
-    print(f"Chart Title: {chart_title}")
-    print(f"Parameter Count: {param_count}")
-
-    if randomize_param_count:
-        param_count = random.randint(3, 10)
-    
-    # Create a temporary array from comma-separated input_parameters
-    if input_parameters:
-        temp_parameters = re.split(r'\s*,\s*', input_parameters.strip())
-        if len(temp_parameters) > param_count:
-            temp_parameters = temp_parameters[:param_count]
-    elif randomize_titles:
-        temp_parameters = random.sample(ALL_TITLES, param_count)
-    else:
-        temp_parameters = []
-
-    # Fill in missing parameters based on param_count
-    if len(temp_parameters) < param_count:
-        remaining_count = param_count - len(temp_parameters)
-        additional_params = random.sample(set(ALL_TITLES) - set(temp_parameters), remaining_count)
-        temp_parameters.extend(additional_params)
-
-    # Create a temporary array for values
-    if randomize_values:
-        temp_r_values = random.sample(ALL_VALUES, len(temp_parameters))
-    else:
-        temp_r_values = list(params[:len(temp_parameters)])
-    
-    chart_figure = generate_figure(temp_r_values, temp_parameters, chart_title)
-    slider_labels = ", ".join([f"({temp_parameters[i]}: {temp_r_values[i]:.2f})" for i in range(len(temp_r_values))])
-    
-    # Generate the radar chart
-    fig = generate_figure(temp_r_values, temp_parameters, chart_title)    
-    return fig, slider_labels
-
-def set_initial_state():
-    # Set default values for the form
-    input_parameters = ""
-    randomize_values = True
-    randomize_titles = True
-    randomize_param_count = False
-    chart_title = "Radar Chart"
-    param_count = 5
-    title1 = 'Minimalism'
-    param1 = 0.75
-    title2 = 'Bauhaus'
-    param2 = 0.75
-    title3 = 'Organic Design'
-    param3 = 0.75
-    title4 = 'Brutalism'
-    param4 = 0.75
-    title5 = 'Mid-century Modern'
-    param5 = 0.75
-    title6 = 'Retro-Vintage'
-    param6 = 0.75
-    title7 = 'Futurism'
-    param7 = 0.75
-    title8 = 'Tesselated'
-    param8 = 0.75
-    title9 = 'Streamlined'
-    param9 = 0.75
-    title10 = 'Timeless'
-    param10 = 0.75
-
-    
-
-    # Call display_radar_chart with default values
-    return display_radar_chart(input_parameters, randomize_values, randomize_titles, randomize_param_count, chart_title, param_count, title1, param1, title2, param2, title3, param3, title4, param4, title5, param5, title6, param6, title7, param7, title8, param8, title9, param9, title10, param10)
-
-# Call set_initial_state when the app is first loaded
-set_initial_state()
-
-def generate_image(prompt_input, steps_input, reset_seed_input, increment_seed_input):
-    global session_seed, last_session_seed, slider_labels
-    print(f"Prompt Input: {prompt_input}")
-    print(f"Steps Input: {steps_input}")
-    print(f"Reset Seed Input: {reset_seed_input}")
-    print(f"Increment Seed Input: {increment_seed_input}")
-
-    if reset_seed_input:
-        session_seed = random.randint(1, 10000)
-    elif increment_seed_input and last_session_seed is not None:
-        session_seed = last_session_seed + 1
-        last_session_seed = session_seed
-    # Update the base_payload with the new values
-    full_prompt = f"{prompt_input} inspired by {slider_labels}"
-    base_payload.update({
-        "prompt": full_prompt,
-        "steps": 25,
-        "seed": session_seed,
-        "negative_prompt": "",
-        "prompt_styles": ["RayOPunk"],
-        "sampler_index": "DPM++ 2M Karras",
-        "restore_faces": False,
-        "tiling": False,
-        "n_iter": 1,
-        "batch_size": 1,
-        "cfg_scale": 7.0,
-        "subseed": -1,
-        "subseed_strength": 0.0,
-        "seed_resize_from_h": -1,
-        "seed_resize_from_w": -1,
-        "seed_enable_extras": False,
-        "height": 768,
-        "width": 1024,
-        "enable_hr": False,
-        "denoising_strength": 0.0,
-        "hr_scale": 2.0,
-        "hr_upscaler": "Latent",
-        "hr_second_pass_steps": 0,
-        "hr_resize_x": 0,
-        "hr_resize_y": 0,
-        "hr_sampler_index": "",
-        "hr_prompt": "",
-        "hr_negative_prompt": "",
-        "override_settings_texts": ""
-    })
-    # Make the API call
-    response = requests.post(url, json=base_payload)
-
-    # Handle the response
-    response_data = response.json()
-    try:
-        # Decode the base64 image
-        img_data = base64.b64decode(response_data['images'][0])
-        img = Image.open(io.BytesIO(img_data))
-    except KeyError:
-        # Handle error in response
-        error_message = response_data.get('error', 'Unknown error')
-        error_image = Image.new('RGB', (512, 512), color=(73, 109, 137))
-        d = ImageDraw.Draw(error_image)
-        d.text((10, 10), f"Error: {error_message}", fill=(255, 255, 0))
-        img = error_image
-
-    return img
-
-def update_titles(title1, title2, title3, title4, title5, title6, title7, title8, title9, title10):
-    global slider_labels
-    slider_labels = ', '.join([title1, title2, title3, title4, title5, title6, title7, title8, title9, title10])
-    return slider_labels
-
-def radar_chart_fn(input_parameters, randomize_values, randomize_titles, randomize_param_count, chart_title, param_count, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, title1, title2, title3, title4, title5, title6, title7, title8, title9, title10):
-    # Generate the radar chart
-    radar_chart, slider_labels = display_radar_chart(input_parameters, randomize_values, randomize_titles, randomize_param_count, chart_title, param_count, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, title1, title2, title3, title4, title5, title6, title7, title8, title9, title10)
-    return radar_chart, slider_labels
-
-last_radar_chart = None
-last_slider_labels = None
-last_img = None
-
-def radar_chart_fn(input_parameters, randomize_values, randomize_titles, randomize_param_count, chart_title, param_count, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, title1, title2, title3, title4, title5, title6, title7, title8, title9, title10):
-    global last_radar_chart, last_slider_labels
-    # Generate the radar chart
-    last_radar_chart, last_slider_labels = display_radar_chart(input_parameters, randomize_values, randomize_titles, randomize_param_count, chart_title, param_count, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, title1, title2, title3, title4, title5, title6, title7, title8, title9, title10)
-    return last_radar_chart, last_slider_labels
-
-def image_fn(prompt_input, steps_input, reset_seed_input, increment_seed_input):
-    global last_img
-    # Generate the image
-    last_img = generate_image(prompt_input, steps_input, reset_seed_input, increment_seed_input)
-    return last_img
-
-def output_radar_chart_fn():
-    # Return the last generated radar chart
-    return last_radar_chart, last_slider_labels
-
-def output_image_fn():
-    # Return the last generated image
-    return last_img
-
-# Create the Gradio Interface for Radar Chart
-with gr.Blocks() as app:
-    gr.Markdown("# Radar Chart")
-
-    radar_interface = gr.Interface(
-        fn=radar_chart_fn,
-        inputs=[input_parameters, randomize_values, randomize_titles, randomize_param_count, chart_title, param_count, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, title1, title2, title3, title4, title5, title6, title7, title8, title9, title10],
-        outputs=[radar_output, slider_labels_output])
-
-
-def image_fn(prompt_input, steps_input, reset_seed_input, increment_seed_input):
-    # Generate the image
-    img = generate_image(prompt_input, steps_input, reset_seed_input, increment_seed_input)
-    return img
-
-def generate_and_display_image(prompt_input, title, param, steps_input):
-    full_prompt = f"{prompt_input} inspired by ({title}:{param})"
-    img = generate_image(full_prompt, steps_input, reset_seed_input=False, increment_seed_input=False)
-    return img
-
-
-def radar_chart_fn(input_parameters, randomize_values, randomize_titles, randomize_param_count, chart_title, param_count, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, title1, title2, title3, title4, title5, title6, title7, title8, title9, title10):
-    global last_radar_chart, last_slider_labels
-    # Generate the radar chart
-    last_radar_chart, last_slider_labels = display_radar_chart(input_parameters, randomize_values, randomize_titles, randomize_param_count, chart_title, param_count, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, title1, title2, title3, title4, title5, title6, title7, title8, title9, title10)
-    set_textbox_values(last_slider_labels)
-    return last_radar_chart, last_slider_labels
-
-def output_radar_chart_fn():
-    # Return the last generated radar chart
-    set_textbox_values(last_slider_labels)
-    return last_radar_chart, last_slider_labels
-
-with gr.Blocks() as app:
-    with gr.Accordion("Inputs and Outputs", collapsed=True):
-        radar_interface = gr.Interface(
-            fn=radar_chart_fn,
-            inputs=[input_parameters, randomize_values, randomize_titles, randomize_param_count, chart_title, param_count, param1, param2, param3],
-            outputs=[radar_output, slider_labels_output])
-        prompt_input = gr.Textbox(lines=2, placeholder="Imagine something...", label="Prompt", value="__cars__")
-        reset_seed_input = gr.Checkbox(label="Randomize Composition")
-        increment_seed_input = gr.Checkbox(label="New Composition")
-        img_output = gr.Image(label="Generated Image")
-        iface = gr.Interface(
-            fn=image_fn,
-            inputs=[prompt_input, reset_seed_input, increment_seed_input],
-            outputs=[img_output],
-            live=False
-        )
-    with gr.Row():
-        with gr.Column(scale=2):
-            output_image_interface = gr.Interface(
-                fn=output_image_fn,
-                inputs=[],
-                outputs=[img_output],
-                live=True
-            )
-        with gr.Column(scale=1):
-            output_radar_interface = gr.Interface(
-                fn=output_radar_chart_fn,
-                inputs=[],
-                outputs=[radar_output, slider_labels_output])
-
-        def set_textbox_values(slider_labels_output):
-            # Validate the input
-            if not slider_labels_output:
-                return
-            
-            # Split and parse the slider_labels_output
-            slider_data = slider_labels_output.split(', ')
-            
-            for i, data in enumerate(slider_data):
-                try:
-                    title, value = data.split(':')
-                    globals()[f'title{i+1}'].value = title.strip()
-                    globals()[f'param{i+1}'].value = float(value.strip())
-                except ValueError:
-                    print(f"Could not parse data for slider {i+1}")
-
-        # Example usage:
-        slider_labels_output = "title1: 0.5, title2: 0.8, title3: 0.2"
-        set_textbox_values(slider_labels_output)
-
-
-        # Call this function to update the textboxes and sliders before creating them
-        set_textbox_values(last_slider_labels)
-        # Assuming slider_labels_output is a string like "(title1: value1), (title2: value2), ..."
-        slider_labels_output = "(title1: 0.75), (title2: 0.5), (title3: 1.25)"
-        # Split the string into individual labels
-        labels = slider_labels_output.split(", ")
-
-        # Extract the values from each label and convert them to floats
-        initial_values = [float(label.split(": ")[1].strip(")")) for label in slider_labels_output.split(", ")]
-        
-    with gr.Row():
-        for i in range(1, len(initial_values) + 1):
-            with gr.Column(scale=1):
-                param = gr.Slider(minimum=0, maximum=1.5, step=0.25, label=f"Parameter {i}", value=temp_array[i-1])
-                title = gr.Textbox(value=temp_parameters[i-1], label=f"Inspiration Word {i}")
-                img = gr.Interface(fn=generate_and_display_image, inputs=[prompt_input, title, param], outputs="image")
-
-    # Add the slider_labels_output textbox to a new row
-    with gr.Row():
-        slider_labels_output = gr.Textbox(value=slider_labels_output, label="Slider Labels")
-# Launch the app
-app.launch(share=True)
+import threading
+import subprocess
+import time  # Import time module
+
+# Initial Gradio app code
+code = """import gradio as gr
+
+def greet(name):
+    return f"Hello {name}!"
+
+iface = gr.Interface(fn=greet, inputs="text", outputs="text")
+iface.launch(share=True)
+"""
+
+port = 7860  # Initial port
+
+def run_code(new_code, port):
+    with open("app.py", "w") as file:
+        file.write(new_code)
+    subprocess.run(["python", "app.py", f"--port={port + 1}"])  # Specify port
+
+def update_code(submitted_code):
+    global code, port
+    code = submitted_code
+    port += 1  # Increment port for each new Gradio interface
+    threading.Thread(target=run_code, args=(code, port)).start()
+    time.sleep(5)  # Add a delay of 5 seconds
+    return f'<iframe src="http://localhost:{port}/" width="100%" height="400"></iframe>'
+
+def main_ui():
+    code_input = gr.Textbox(lines=20, label="Code Editor", value=code)  # Corrected the import for Textbox
+    iframe_output = gr.HTML()  # Created HTML component for iframe output
+    iface = gr.Interface(fn=update_code, inputs=code_input, outputs=iframe_output, live=False, share=True)  # Included share=True
+    iface.launch()
+
+if __name__ == "__main__":
+    main_ui()