Spaces:

rayochoajr
/

Test12

Runtime error

App Files Files Community

rayochoajr commited on Oct 1, 2023

Commit

42cae27

1 Parent(s): 437c1c8

Update app.py

Browse files

Files changed (1) hide show

app.py +80 -254

app.py CHANGED Viewed

@@ -1,260 +1,86 @@
-import sys
-import subprocess
-import threading
-import http.server
-import socketserver
-from urllib.parse import urlencode, parse_qs, urlencode
 import gradio as gr
-import json
-# Global variable initialization
-counter = 0
-slider_radius = 100
-slider_x = 250
-slider_y = 250
-# Define Input and Output Groupings
-input_mode_switch = gr.inputs.Radio(choices=["Normal", "Switch Mode"], label="Mode Switch", default="Normal")
-input_radius = gr.inputs.Slider(minimum=50, maximum=200, step=10, default=100, label="Radius")
-input_x = gr.inputs.Slider(minimum=100, maximum=400, step=10, default=250, label="X-coordinate")
-input_y = gr.inputs.Slider(minimum=100, maximum=400, step=10, default=250, label="Y-coordinate")
-input_counter = gr.inputs.Number(default=0, label="Counter Value")
-parameter1 = "number"
-parameter2 = "number"
-parameter3 = "number"
-output_counter = "number"
-def write_d3_to_file():
-    d3_content = '''
-    <!DOCTYPE html>
-    <html>
-    <head>
-      <title>D3.js with Gradio</title>
-      <script src="https://d3js.org/d3.v6.min.js"></script>
-    </head>
-    <body>
-      <div>
-        <label for="radiusSlider">Radius:</label>
-        <input type="range" min="50" max="200" step="10" id="radiusSlider" value="100">
-        <input type="text" id="radiusText" value="100">
-      </div>
-      <div>
-        <label for="xSlider">X-coordinate:</label>
-        <input type="range" min="100" max="400" step="10" id="xSlider" value="250">
-        <input type="text" id="xText" value="250">
-      </div>
-      <div>
-        <label for="ySlider">Y-coordinate:</label>
-        <input type="range" min="100" max="400" step="10" id="ySlider" value="250">
-        <input type="text" id="yText" value="250">
-      </div>
-      <script>
-        var counter = 0;
-        var svg = d3.select("body").append("svg")
-          .attr("width", 500)
-          .attr("height", 500);
-        var circle = svg.append("circle")
-          .attr("cx", 250)
-          .attr("cy", 250)
-          .attr("r", 100)
-          .attr("fill", "red");
-        var text = svg.append("text")
-          .attr("x", 250)
-          .attr("y", 250)
-          .attr("dy", ".35em")
-          .attr("text-anchor", "middle")
-          .style("fill", "white")
-          .text(counter);
-        // Function to update circle attributes based on slider values
-        function updateCircleAttributes() {
-          var radius = document.getElementById("radiusSlider").value;
-          var x = document.getElementById("xSlider").value;
-          var y = document.getElementById("ySlider").value;
-          circle.attr("r", radius)
-            .attr("cx", x)
-            .attr("cy", y);
-          // Update text values
-          document.getElementById("radiusText").value = radius;
-          document.getElementById("xText").value = x;
-          document.getElementById("yText").value = y;
-        }
-        // Add event listeners to sliders
-        document.getElementById("radiusSlider").addEventListener("input", updateCircleAttributes);
-        document.getElementById("xSlider").addEventListener("input", updateCircleAttributes);
-        document.getElementById("ySlider").addEventListener("input", updateCircleAttributes);
-        function sendUpdatesToBackend() {
-            var radius = document.getElementById("radiusSlider").value;
-            var x = document.getElementById("xSlider").value;
-            var y = document.getElementById("ySlider").value;
-            fetch('/update', {
-                method: 'POST',
-                headers: {
-                  'Content-Type': 'application/x-www-form-urlencoded',
-                },
-                body: `radius=${radius}&x=${x}&y=${y}`
-            });
-        }
-        document.getElementById("radiusSlider").addEventListener("input", function() {
-            updateCircleAttributes();
-            sendUpdatesToBackend();
-        });
-        document.getElementById("xSlider").addEventListener("input", function() {
-            updateCircleAttributes();
-            sendUpdatesToBackend();
-        });
-        document.getElementById("ySlider").addEventListener("input", function() {
-            updateCircleAttributes();
-            sendUpdatesToBackend();
-        });
-        circle.on("click", function() {
-          counter++;
-          text.text(counter);
-          circle.attr("fill", "darkred");
-          setTimeout(() => circle.attr("fill", "red"), 300);
-          // AJAX call to update the backend
-          fetch('/increment', {
-            method: 'POST',
-            headers: {
-              'Content-Type': 'application/x-www-form-urlencoded',
-            },
-            body: `counter=${counter}`
-          });
-        });
-      </script>
-    </body>
-    </html>
-    '''
-    with open("index.html", "w") as f:
-        f.write(d3_content)
-class CustomHandler(http.server.SimpleHTTPRequestHandler):
-    def do_POST(self):
-        global counter, slider_radius, slider_x, slider_y
-        content_length = int(self.headers['Content-Length'])
-        post_data = self.rfile.read(content_length).decode('utf-8')
-        parsed_data = parse_qs(post_data)
-        if 'counter' in parsed_data:
-            counter = int(parsed_data['counter'][0])
-        if 'radius' in parsed_data:
-            slider_radius = int(parsed_data['radius'][0])
-        if 'x' in parsed_data:
-            slider_x = int(parsed_data['x'][0])
-        if 'y' in parsed_data:
-            slider_y = int(parsed_data['y'][0])
-        self.send_response(200)
-        self.end_headers()
-def run_d3_server():
-    Handler = CustomHandler
-    with socketserver.TCPServer(("", 8001), Handler) as httpd:
-        print("serving D3.js at port 8001")
-        httpd.serve_forever()
-def update_from_gradio(parsed_data):
-    global slider_radius, slider_x, slider_y
-    slider_radius = int(parsed_data['radius'][0])
-    slider_x = int(parsed_data['x'][0])
-    slider_y = int(parsed_data['y'][0])
-# Function to update values from Gradio or JavaScript
-def update_values(parsed_data):
-    global slider_radius, slider_x, slider_y, counter
-    if 'counter' in parsed_data:
-        counter_str = parsed_data['counter'][0]
-        # Convert the counter value to an integer, handling the possibility of a decimal point.
-        try:
-            counter = int(float(counter_str))
-        except ValueError:
-            # Handle the case where the counter value cannot be converted to an integer.
-            print(f"Invalid counter value: {counter_str}")
-    if 'radius' in parsed_data:
-        slider_radius = int(parsed_data['radius'][0])
-    if 'x' in parsed_data:
-        slider_x = int(parsed_data['x'][0])
-    if 'y' in parsed_data:
-        slider_y = int(parsed_data['y'][0])
-def process_inputs_gradio(input_mode_switch, input_radius_gradio, input_x_gradio, input_y_gradio, input_counter_gradio):
-    global slider_radius, slider_x, slider_y, counter
-    if input_mode_switch == "Switch Mode":
-        # This block is executed whenever the mode switch radio option is selected.
-        _, slider_radius, slider_x, slider_y = fetch_updated_values()
     else:
-        # This block is executed for other interactions.
-        slider_radius = input_radius_gradio
-        slider_x = input_x_gradio
-        slider_y = input_y_gradio
-        counter = input_counter_gradio
-    return f'Radius: {slider_radius}, X: {slider_x}, Y: {slider_y}', slider_radius, slider_x, slider_y, counter
-def process_inputs_javascript(input_action_js, input_radius_js, input_x_js, input_y_js, input_counter_js):
-    if input_action_js == "Update from Gradio":
-        _, slider_radius_js, slider_x_js, slider_y_js = fetch_updated_values()
-    elif input_action_js == "Update from JavaScript":
-        update_data = urlencode({
-            'radius': input_radius_js,
-            'x': input_x_js,
-            'y': input_y_js,
-            'counter': input_counter_js
-        })
-        update_values(parse_qs(update_data))
-    return f'Radius: {slider_radius_js}, X: {slider_x_js}, Y: {slider_y_js}', slider_radius_js, slider_x_js, slider_y_js, counter
-def fetch_updated_values():
-    global counter, slider_radius, slider_x, slider_y
-    return f'Counter value is {counter}', slider_radius, slider_x, slider_y
-def process_inputs(input_action, input_radius, input_x, input_y, input_counter):
-    global slider_radius, slider_x, slider_y, counter
-    if input_action == "Update from Gradio":
-        update_data = urlencode({
-            'radius': input_radius,
-            'x': input_x,
-            'y': input_y,
-            'counter': input_counter
-        })
-        # Simulate sending data to server (in reality, use an HTTP request)
-        update_from_gradio(parse_qs(update_data))
-    elif input_action == "Update from JavaScript":
-        _, slider_radius, slider_x, slider_y = fetch_updated_values()
-    return f'Radius: {slider_radius}, X: {slider_x}, Y: {slider_y}', slider_radius, slider_x, slider_y, f'Counter value is {counter}'
-if __name__ == "__main__":
-    write_d3_to_file()
-    d3_thread = threading.Thread(target=run_d3_server)
-    d3_thread.daemon = True
-    d3_thread.start()
-    iface = gr.Interface(
-    fn=process_inputs_gradio,
     inputs=[
-        input_mode_switch,
-        input_radius,
-        input_x,
-        input_y,
-        input_counter
     ],
     outputs=[
-        parameter1,
-        parameter2,
-        parameter3,
-        output_counter
-    ],
-    description='<iframe src="http://localhost:8001" width="500" height="500"></iframe>'
 )
-    iface.launch()

 import gradio as gr
+import plotly.graph_objects as go
+import numpy as np
+import random
+import re
+# Predefined arrays
+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']
+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]
+def generate_axes(parameters):
+    return [{'angle': np.degrees((2 * np.pi / len(parameters)) * i - np.pi / 2), 'label': parameters[i]} for i in range(len(parameters))]
+def handle_randomize(num_parameters, values_list):
+    return random.sample(values_list, num_parameters)
+def generate_figure(r_values, theta_values, chart_title="Radar Chart"):
+    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.5])), showlegend=False, title=chart_title)
+    return fig
+def display_radar_chart(input_parameters=None, randomize_values=False, randomize_titles=False, chart_title="Radar Chart", param_count=5, param1=1.5, param2=1.2, param3=0.8, param4=1.0, param5=0.5):
+    if input_parameters:
+        parameters = re.split(r'\s*,\s*', input_parameters.strip())
+    elif randomize_titles:
+        parameters = handle_randomize(param_count, ALL_TITLES)
     else:
+        parameters = ALL_TITLES[:param_count]
+    # Create a temp array for text input parameters
+    text_input_parameters = []
+    if input_parameters:
+        text_input_parameters = re.split(r'\s*,\s*', input_parameters.strip())
+    # Randomize titles if the checkbox is selected
+    if randomize_titles:
+        parameters = handle_randomize(param_count, ALL_TITLES)
+    # Merge text input parameters into final array, only replacing what's necessary
+    for i in range(min(len(parameters), len(text_input_parameters))):
+        parameters[i] = text_input_parameters[i]
+    # Final output stage for cleanup
+    if len(parameters) != param_count:
+        parameters = parameters[:param_count]
+    # Randomize or set to default values to fill in any gaps.
+    if randomize_values:
+        r_values = handle_randomize(len(parameters), ALL_VALUES)
+    else:
+        r_values = [param1, param2, param3, param4, param5][:len(parameters)]
+    theta_values = [axis['label'] for axis in generate_axes(parameters)]
+    # Generate and return the radar chart figure
+    chart_figure = generate_figure(r_values, theta_values, chart_title)
+    # Generate text output for sliders
+    slider_labels = ", ".join([f"({parameters[i]}: {r_values[i]:.2f})" for i in range(len(r_values))])
+    return chart_figure, f"{slider_labels}"
+# Gr.Interface definition
+iface = gr.Interface(
+    fn=display_radar_chart,
     inputs=[
+        gr.Textbox(default=None, placeholder="Enter parameters, separated by commas", label="Parameters (Comma-separated)"),
+        gr.components.Checkbox(label="Randomize Values", default=False),
+        gr.components.Checkbox(label="Randomize Titles", default=False),
+        gr.Textbox(default="Radar Chart", label="Chart Title", value="Stable Diffusion Nodes"),
+        gr.Slider(3, 6, value=3, step=1, label="Parameter Count", info="Choose between 3 and 6"),
+        gr.inputs.Slider(minimum=-1.5, maximum=1.5, step=0.1, default=1.5, label="Parameter 1"),
+        gr.inputs.Slider(minimum=-1.5, maximum=1.5, step=0.1, default=1.2, label="Parameter 2"),
+        gr.inputs.Slider(minimum=-1.5, maximum=1.5, step=0.1, default=0.8, label="Parameter 3"),
+        gr.inputs.Slider(minimum=-1.5, maximum=1.5, step=0.1, default=1.0, label="Parameter 4"),
+        gr.inputs.Slider(minimum=-1.5, maximum=1.5, step=0.1, default=0.5, label="Parameter 5")
     ],
     outputs=[
+        gr.Plot(label="Radar Chart Display"),
+        gr.Textbox(label="Prompt: Slider Labels")  # "Prompt:" moved here
+    ]
 )
+# Launching the interface
+if __name__ == "__main__":
+    iface.launch()