Update app.py

app.py

@@ -1,214 +1,69 @@
-
-import gradio as gr
-from PIL import Image
-from gradio_imageslider import ImageSlider
-
 import requests
 import base64
-import numpy as np
-import random
 import io
+from PIL import Image
+import gradio as gr
+import json
 
-URL = "http://localhost:5000/predictions"
+# API and Schema URLs
+API_URL = "http://localhost:5000/predictions"
 SCHEMA_URL = "http://localhost:5000/openapi.json"
 
-def get_schema():
-    response = requests.get(SCHEMA_URL)
-    json_response = response.json()
-    print("The schema")
-    print(json_response)
-
-get_schema()
-
-HEADERS = {
-    "Content-Type": "application/json",
-}
-
-MAX_SEED = np.iinfo(np.int32).max
-
-
-def randomize_seed_fn(seed: int, randomize_seed: bool) -> int:
-    if randomize_seed:
-        seed = random.randint(0, MAX_SEED)
-    return seed
-
-
-def generate(
-    prompt: str,
-    input_image: Image,
-    negative_prompt: str = "",
-    seed: int = 0,
-    width: int = 1024,
-    height: int = 1024,
-    prior_num_inference_steps: int = 30,
-    # prior_timesteps: List[float] = None,
-    prior_guidance_scale: float = 4.0,
-    decoder_num_inference_steps: int = 12,
-    # decoder_timesteps: List[float] = None,
-    decoder_guidance_scale: float = 0.0,
-    num_images_per_prompt: int = 2,
-
-) -> Image:
-
-    payload = {
-        "input": {
-            "hdr": 0,
-            "image": "http://localhost:7860/file=" + input_image,
-            "steps": 20,
-            "prompt": prompt,
-            "scheduler": "DDIM",
-            "creativity": 0.25,
-            "guess_mode": False,
-            "resolution": "original",
-            "resemblance": 0.75,
-            "guidance_scale": 7,
-            "negative_prompt": negative_prompt,
+def fetch_api_spec(url):
+    response = requests.get(url)
+    return response.json()
+
+def create_gradio_app_from_api_spec(api_spec):
+    input_properties = api_spec['components']['schemas']['Input']['properties']
+    inputs = []
+    for prop, details in input_properties.items():
+        if 'enum' in details:
+            choices = details['enum']
+            inputs.append(gr.inputs.Dropdown(choices=choices, label=prop))
+        elif details['type'] == 'integer':
+            inputs.append(gr.inputs.Number(label=prop, default=details.get('default'), minimum=details.get('minimum'), maximum=details.get('maximum')))
+        elif details['type'] == 'number':
+            inputs.append(gr.inputs.Slider(minimum=details.get('minimum'), maximum=details.get('maximum'), default=details.get('default'), label=prop))
+        elif details['type'] == 'string' and 'format' in details and details['format'] == 'uri':
+            inputs.append(gr.inputs.Image(label=prop))
+        elif details['type'] == 'string':
+            inputs.append(gr.inputs.Textbox(label=prop, default=details.get('default')))
+        elif details['type'] == 'boolean':
+            inputs.append(gr.inputs.Checkbox(label=prop, default=details.get('default')))
+    
+    def predict_function(**kwargs):
+        # Adjust the input kwargs for image inputs to convert them to the expected format by the API if needed
+        payload = {
+            "input": kwargs
         }
-    }
-    print("\n\n PAYLOAD", payload)
-    response = requests.post(URL, headers=HEADERS, json=payload)
-    json_response = response.json()
-    if 'status' in json_response:
-        if json_response["status"] == "failed":
-            raise gr.Error("Failed to generate image")
-        base64_image = json_response["output"][0]
-        image_data = base64.b64decode(
-            base64_image.replace("data:image/png;base64,", ""))
-        image_stream = io.BytesIO(image_data)
-        return [Image.open(input_image), Image.open(image_stream)]
-    else:
-        raise gr.Error("Failed to generate image")
-
-
-examples = [
-    ["An astronaut riding a green horse", "examples/image2.png"],
-    ["A mecha robot in a favela by Tarsila do Amaral", "examples/image2.png"],
-    ["The sprirt of a Tamagotchi wandering in the city of Los Angeles",
-        "examples/image1.png"],
-    ["A delicious feijoada ramen dish", "examples/image0.png"],
-]
-
-with gr.Blocks() as demo:
-    with gr.Row():
-        with gr.Column():
-            input_image = gr.Image(type="filepath")
-            with gr.Group():
-                with gr.Row():
-                    prompt = gr.Text(
-                        label="Prompt",
-                        show_label=False,
-                        max_lines=1,
-                        placeholder="Enter your prompt",
-                        container=False,
-                    )
-                    run_button = gr.Button("Run", scale=0)
-        with gr.Column():
-            result = ImageSlider(label="Result", type="pil")
-    with gr.Accordion("Advanced options", open=False):
-        negative_prompt = gr.Text(
-            label="Negative prompt",
-            max_lines=1,
-            placeholder="Enter a Negative Prompt",
-        )
-
-        seed = gr.Slider(
-            label="Seed",
-            minimum=0,
-            maximum=MAX_SEED,
-            step=1,
-            value=0,
-        )
-        randomize_seed = gr.Checkbox(label="Randomize seed", value=True)
-        with gr.Row():
-            width = gr.Slider(
-                label="Width",
-                minimum=1024,
-                maximum=1024,
-                step=512,
-                value=1024,
-            )
-            height = gr.Slider(
-                label="Height",
-                minimum=1024,
-                maximum=1024,
-                step=512,
-                value=1024,
-            )
-            num_images_per_prompt = gr.Slider(
-                label="Number of Images",
-                minimum=1,
-                maximum=2,
-                step=1,
-                value=1,
-            )
-        with gr.Row():
-            prior_guidance_scale = gr.Slider(
-                label="Prior Guidance Scale",
-                minimum=0,
-                maximum=20,
-                step=0.1,
-                value=4.0,
-            )
-            prior_num_inference_steps = gr.Slider(
-                label="Prior Inference Steps",
-                minimum=10,
-                maximum=30,
-                step=1,
-                value=20,
-            )
-
-            decoder_guidance_scale = gr.Slider(
-                label="Decoder Guidance Scale",
-                minimum=0,
-                maximum=0,
-                step=0.1,
-                value=0.0,
-            )
-            decoder_num_inference_steps = gr.Slider(
-                label="Decoder Inference Steps",
-                minimum=4,
-                maximum=12,
-                step=1,
-                value=10,
-            )
-
-    gr.Examples(
-        examples=examples,
-        inputs=[prompt, input_image],
-        outputs=result,
-        fn=generate,
-        cache_examples=False,
-    )
-
-    inputs = [
-        prompt,
-        input_image,
-        negative_prompt,
-        seed,
-        width,
-        height,
-        prior_num_inference_steps,
-        # prior_timesteps,
-        prior_guidance_scale,
-        decoder_num_inference_steps,
-        # decoder_timesteps,
-        decoder_guidance_scale,
-        num_images_per_prompt,
-    ]
-    gr.on(
-        triggers=[prompt.submit, negative_prompt.submit, run_button.click],
-        fn=randomize_seed_fn,
-        inputs=[seed, randomize_seed],
-        outputs=seed,
-        queue=False,
-        api_name=False,
-    ).then(
-        fn=generate,
-        inputs=inputs,
-        outputs=result,
-        api_name="run",
-    )
+        response = requests.post(API_URL, headers={"Content-Type": "application/json"}, json=payload)
+        json_response = response.json()
 
+        if 'status' in json_response and json_response["status"] == "failed":
+            raise gr.Error("Failed to generate image")
 
-if __name__ == "__main__":
-    demo.queue(max_size=20).launch()
+        output_spec = api_spec['components']['schemas']['Output']
+        if output_spec['items']['type'] == 'string' and output_spec['items']['format'] == 'uri':
+            outputs = []
+            for uri in json_response["output"]:
+                if uri.startswith("data:image"):
+                    base64_image = uri.split(",")[1]  # Strip the prefix part
+                    image_data = base64.b64decode(base64_image)
+                    image_stream = io.BytesIO(image_data)
+                    image = Image.open(image_stream)
+                    outputs.append(image)
+                else:
+                    outputs.append(uri)
+            return outputs
+        else:
+            return json_response["output"]
+    
+    iface = gr.Interface(fn=predict_function, inputs=inputs, outputs=gr.outputs.Image(type="pil"), title=api_spec['info']['title'])
+    return iface
+
+# Fetch API Specification
+api_spec = fetch_api_spec(SCHEMA_URL)
+
+# Create and Launch Gradio App
+gradio_app = create_gradio_app_from_api_spec(api_spec)
+gradio_app.launch()