Update app.py

app.py

@@ -1,132 +1,93 @@
 import streamlit as st
-import requests
-import base64
-from io import BytesIO
-from PIL import Image
-import time
+import streamlit.components.v1 as components
+import urllib.parse
 
 # Streamlit app title and description
-st.title("LoraTheExplorer Image Generation Wrapper")
+st.title("LoraTheExplorer Gradio App Wrapper")
 st.markdown("""
-    This Streamlit app wraps the MultimodalArt LoraTheExplorer Gradio app to generate images from text prompts.
-    Enter a prompt and adjust settings to create images. Note: Adjust settings based on the Gradio app's capabilities.
+    This Streamlit app embeds the MultimodalArt LoraTheExplorer Gradio app in an iframe.
+    Use the controls below to interact with the app or prefill prompts (if supported).
 """)
 
-# Backend URL of the Gradio app (assumed API endpoint)
-BACKEND_URL = "https://multimodalart-loratheexplorer.hf.space/api/predict/"
+# Gradio app URL
+GRADIO_URL = "https://multimodalart-loratheexplorer.hf.space"
 
-# Placeholder style options (assuming a text-to-image model with style support)
-STYLE_OPTIONS = [
-    "(No style)", "Cinematic", "Anime", "Digital Art", "Fantasy Art"
-]
+# Function to generate iframe HTML
+def render_gradio_iframe(url, width=850, height=600):
+    iframe_html = f"""
+    <iframe
+        src="{url}"
+        frameborder="0"
+        width="{width}"
+        height="{height}"
+        style="border: none;"
+    ></iframe>
+    """
+    return iframe_html
 
-# Function to apply style (generic, to be adjusted based on actual Gradio app)
-def apply_style(style_name, prompt, negative):
-    style_dict = {
-        "(No style)": ("{prompt}", ""),
-        "Cinematic": (
-            "cinematic still {prompt}, highly detailed, moody, epic",
-            "blurry, low quality, cartoon"
-        ),
-        "Anime": (
-            "anime artwork {prompt}, vibrant, studio anime, highly detailed",
-            "photo, realism, blurry"
-        ),
-        "Digital Art": (
-            "digital artwork {prompt}, illustrative, painterly, highly detailed",
-            "photo, low quality"
-        ),
-        "Fantasy Art": (
-            "fantasy concept art of {prompt}, ethereal, epic, magical",
-            "realistic, blurry, text"
-        )
-    }
-    positive, neg = style_dict.get(style_name, style_dict["(No style)"])
-    return positive.replace("{prompt}", prompt), neg + (negative or "")
-
-# Function to call the Gradio backend
-def generate_images(prompt, negative_prompt, guidance_scale, style_name):
-    try:
-        # Apply style to prompt and negative prompt
-        styled_prompt, styled_negative = apply_style(style_name, prompt, negative_prompt)
-
-        # Prepare payload (based on typical Gradio API structure)
-        payload = {
-            "data": [
-                styled_prompt,
-                styled_negative,
-                guidance_scale,
-                style_name
-            ]
-        }
-
-        # Send request to Gradio backend
-        start_time = time.time()
-        response = requests.post(BACKEND_URL, json=payload, timeout=60)
-        elapsed_time = time.time() - start_time
+# Function to attempt to prefill prompt via URL parameters (if Gradio app supports it)
+def generate_url_with_prompt(base_url, prompt):
+    # URL-encode the prompt
+    encoded_prompt = urllib.parse.quote(prompt)
+    # Append as a query parameter (assumption: Gradio app might accept ?prompt=...)
+    # This is speculative; adjust based on actual app behavior
+    return f"{base_url}?prompt={encoded_prompt}"
 
-        # Check response
-        if response.status_code != 200:
-            st.error(f"Error: Received status code {response.status_code}")
-            return None
+# Sidebar for controls
+st.sidebar.header("Controls")
+prompt = st.sidebar.text_input(
+    "Enter a prompt",
+    placeholder="A magical forest with glowing creatures",
+    help="Enter a prompt to prefill in the Gradio app (if supported)."
+)
+apply_prompt = st.sidebar.button("Apply Prompt")
 
-        # Parse response
-        json_data = response.json()
-        if "data" not in json_data or not json_data["data"]:
-            st.error("Error: No images returned from the backend.")
-            return None
+# Handle prompt application
+if apply_prompt and prompt:
+    # Attempt to modify URL with prompt
+    modified_url = generate_url_with_prompt(GRADIO_URL, prompt)
+    st.sidebar.info(f"Attempting to load with prompt: {prompt}")
+else:
+    modified_url = GRADIO_URL
 
-        # Extract images (assuming base64 strings or URLs)
-        images = []
-        for img_data in json_data["data"]:  # Adjust based on actual response
-            if isinstance(img_data, str):
-                if img_data.startswith("data:image"):
-                    img_base64 = img_data.split(",")[1]
-                    img_bytes = base64.b64decode(img_base64)
-                    img = Image.open(BytesIO(img_bytes))
-                    images.append(img)
-                elif img_data.startswith("http"):
-                    response = requests.get(img_data, timeout=5)
-                    img = Image.open(BytesIO(response.content))
-                    images.append(img)
-                else:
-                    st.warning(f"Unexpected image data format: {img_data}")
-            else:
-                st.warning("Unexpected image data type.")
+# Embed Gradio app
+st.subheader("Gradio App")
+components.html(
+    render_gradio_iframe(modified_url),
+    height=600,
+    scrolling=True
+)
 
-        if images:
-            st.success(f"Images generated in {elapsed_time:.2f} seconds!")
-        return images
-
-    except requests.exceptions.RequestException as e:
-        st.error(f"Network error: {str(e)}")
-        return None
-    except ValueError as e:
-        st.error(f"Error decoding response: {str(e)}")
-        return None
-    except Exception as e:
-        st.error(f"Unexpected error: {str(e)}")
-        return None
+# JavaScript injection to set prompt (alternative approach, may be blocked by CORS)
+st.markdown("""
+    <script>
+    function setPrompt(prompt) {
+        try {
+            const iframe = document.querySelector('iframe');
+            iframe.contentWindow.postMessage({
+                type: 'set_prompt',
+                prompt: prompt
+            }, '*');
+        } catch (e) {
+            console.error('Error sending prompt:', e);
+        }
+    }
+    </script>
+""", unsafe_allow_html=True)
 
-# Streamlit UI components
-with st.form(key="input_form"):
-    prompt = st.text_input("Enter your prompt", placeholder="A magical forest with glowing creatures")
-    negative_prompt = st.text_input("Negative prompt (optional)", placeholder="blurry, low quality")
-    guidance_scale = st.slider("Guidance Scale", min_value=0.0, max_value=50.0, value=7.5, step=0.1)
-    style_name = st.selectbox("Image Style", options=STYLE_OPTIONS, index=0)
-    submit_button = st.form_submit_button("Generate Images")
+if prompt and apply_prompt:
+    # Attempt to send prompt via JavaScript (requires Gradio app to listen for postMessage)
+    st.markdown(f"""
+        <script>
+        setPrompt("{prompt}");
+        </script>
+    """, unsafe_allow_html=True)
 
-# Handle form submission
-if submit_button:
-    if not prompt:
-        st.error("Please enter a prompt.")
-    else:
-        with st.spinner("Generating images..."):
-            images = generate_images(prompt, negative_prompt, guidance_scale, style_name)
-            if images:
-                # Display images in a gallery
-                st.subheader("Generated Images")
-                cols = st.columns(min(len(images), 3))
-                for idx, img in enumerate(images):
-                    with cols[idx % 3]:
-                        st.image(img, use_column_width=True)
+# Notes and limitations
+st.markdown("""
+    **Notes:**
+    - The Gradio app is embedded in an iframe, preserving its original interface.
+    - Prefilling prompts via URL parameters or JavaScript may not work if the Gradio app doesn't support these methods.
+    - If the app doesn't respond to the prompt, interact directly with the iframe below.
+    - To fully control the app, the Gradio app's API or source code would need to be inspected for supported endpoints.
+""")