Update app.py

app.py

@@ -1,21 +1,32 @@
-from flask import Flask, request, render_template, send_file
+from flask import Flask, request, render_template, send_file, Response
 import ast
 import io
 import zipfile
 from datetime import datetime
+import subprocess
+import time
+import os
+import threading
 
 app = Flask(__name__)
 
-# Mapping of Gradio components to Flask-compatible HTML inputs
+# Expanded mapping of Gradio components to Flask-compatible HTML inputs
 COMPONENT_MAP = {
     'gr.Textbox': {'html_type': 'input', 'attributes': {'type': 'text', 'class': 'form-control'}},
-    'gr.Slider': {'html_type': 'input', 'attributes': {'type': 'range', 'class': 'form-range'}},
+    'gr.Slider': {'html_type': 'input', 'attributes': {'type': 'range', 'class': 'form-range', 'min': '0', 'max': '100'}},
     'gr.Image': {'html_type': 'input', 'attributes': {'type': 'file', 'accept': 'image/*', 'class': 'form-control'}},
     'gr.Dropdown': {'html_type': 'select', 'attributes': {'class': 'form-select'}},
     'gr.Checkbox': {'html_type': 'input', 'attributes': {'type': 'checkbox', 'class': 'form-check-input'}},
     'gr.Radio': {'html_type': 'input', 'attributes': {'type': 'radio', 'class': 'form-check-input'}},
     'gr.Label': {'html_type': 'div', 'attributes': {'class': 'output-label'}},
-    # Add more mappings as needed for other Gradio components
+    'gr.Audio': {'html_type': 'input', 'attributes': {'type': 'file', 'accept': 'audio/*', 'class': 'form-control'}},
+    'gr.Video': {'html_type': 'input', 'attributes': {'type': 'file', 'accept': 'video/*', 'class': 'form-control'}},
+    'gr.File': {'html_type': 'input', 'attributes': {'type': 'file', 'class': 'form-control'}},
+    'gr.Number': {'html_type': 'input', 'attributes': {'type': 'number', 'class': 'form-control'}},
+    'gr.ColorPicker': {'html_type': 'input', 'attributes': {'type': 'color', 'class': 'form-control'}},
+    'gr.Markdown': {'html_type': 'div', 'attributes': {'class': 'markdown-output'}},  # For static text output
+    'gr.Dataframe': {'html_type': 'textarea', 'attributes': {'class': 'form-control', 'readonly': 'true'}},  # Simplified output
+    # Add more components as needed
 }
 
 def parse_gradio_script(script):
@@ -25,7 +36,6 @@ def parse_gradio_script(script):
     
     for node in ast.walk(tree):
         if isinstance(node, ast.Call) and hasattr(node.func, 'attr'):
-            # Detect Interface or Blocks
             if node.func.attr == 'Interface':
                 components['is_blocks'] = False
                 for kw in node.keywords:
@@ -43,8 +53,6 @@ def parse_gradio_script(script):
                             components['outputs'] = [ast.unparse(kw.value)]
             elif node.func.attr == 'Blocks':
                 components['is_blocks'] = True
-                # For Blocks, we'll need to parse the context (simplified here)
-                # This assumes inputs/outputs are defined in event listeners
                 for subnode in ast.walk(node):
                     if isinstance(subnode, ast.Call) and hasattr(subnode.func, 'attr') and subnode.func.attr == 'click':
                         components['function'] = ast.unparse(subnode.args[0])
@@ -59,6 +67,7 @@ def generate_flask_app(script, components):
 import io
 from PIL import Image
 import base64
+import pandas as pd
 
 app = Flask(__name__)
 
@@ -82,6 +91,20 @@ def index():
         if file:
             img = Image.open(file)
             inputs.append(img)
+"""
+        elif comp_type == 'gr.Audio' or comp_type == 'gr.Video' or comp_type == 'gr.File':
+            flask_code += f"""
+        file = request.files.get('input_{i}')
+        if file:
+            inputs.append(file.read())
+"""
+        elif comp_type == 'gr.Checkbox':
+            flask_code += f"""
+        inputs.append(request.form.get('input_{i}') == 'on')
+"""
+        elif comp_type == 'gr.Number':
+            flask_code += f"""
+        inputs.append(float(request.form.get('input_{i}', 0)))
 """
         else:
             flask_code += f"""
@@ -110,6 +133,7 @@ def index():
         .form-group { margin-bottom: 20px; }
         .btn-submit { width: 100%; }
         .output { margin-top: 20px; padding: 15px; background: #e9ecef; border-radius: 5px; }
+        .markdown-output { white-space: pre-wrap; }
     </style>
 </head>
 <body>
@@ -129,11 +153,14 @@ def index():
                 <{comp_info['html_type']} name="input_{i}" id="input_{i}" {attrs}>
 """
         if comp_type == 'gr.Dropdown':
-            # Simplified dropdown options (could be parsed from script)
             html_template += """
                     <option value="option1">Option 1</option>
                     <option value="option2">Option 2</option>
                 </select>
+"""
+        elif comp_type == 'gr.Radio':
+            html_template += f"""
+                </{comp_info['html_type']}> <label class="form-check-label" for="input_{i}">Option</label>
 """
         else:
             html_template += f"""
@@ -162,6 +189,24 @@ def index():
                 {% if result %}
                     <img src="data:image/png;base64,{{ result|to_base64 }}" alt="Output Image" class="img-fluid">
                 {% endif %}
+"""
+            elif comp_type == 'gr.Audio':
+                html_template += """
+                {% if result %}
+                    <audio controls><source src="data:audio/wav;base64,{{ result|to_base64 }}" type="audio/wav"></audio>
+                {% endif %}
+"""
+            elif comp_type == 'gr.Video':
+                html_template += """
+                {% if result %}
+                    <video controls><source src="data:video/mp4;base64,{{ result|to_base64 }}" type="video/mp4"></video>
+                {% endif %}
+"""
+            elif comp_type == 'gr.Dataframe':
+                html_template += """
+                {% if result %}
+                    <pre>{{ result.to_html() if result.__class__.__name__ == 'DataFrame' else result }}</pre>
+                {% endif %}
 """
             else:
                 html_template += """
@@ -179,42 +224,91 @@ def index():
 </html>
 """
 
-    # Add a filter for base64 encoding of images
+    # Add filters for base64 encoding
     flask_code += """
 @app.template_filter('to_base64')
-def to_base64(img):
-    if isinstance(img, Image.Image):
+def to_base64(data):
+    if isinstance(data, Image.Image):
         buffered = io.BytesIO()
-        img.save(buffered, format="PNG")
+        data.save(buffered, format="PNG")
         return base64.b64encode(buffered.getvalue()).decode('utf-8')
-    return str(img)
+    elif isinstance(data, bytes):
+        return base64.b64encode(data).decode('utf-8')
+    return str(data)
 """
 
-    # Create a ZIP file with the Flask app
-    buffer = io.BytesIO()
-    with zipfile.ZipFile(buffer, 'w', zipfile.ZIP_DEFLATED) as zip_file:
-        zip_file.writestr('app.py', flask_code)
-        zip_file.writestr('templates/index.html', html_template)
-        zip_file.writestr('requirements.txt', 'flask\npillow')
-    buffer.seek(0)
-    return buffer
+    requirements = "flask\npillow\npandas\n"
+
+    return flask_code, html_template, requirements
+
+def run_preview(flask_code, port=5001):
+    """Run the generated Flask app in a subprocess for preview."""
+    with open('temp_app.py', 'w') as f:
+        f.write(flask_code)
+    os.makedirs('templates', exist_ok=True)
+    with open('templates/index.html', 'w') as f:
+        f.write(html_template)
+    
+    proc = subprocess.Popen(['python', 'temp_app.py', str(port)], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    time.sleep(2)  # Give it time to start
+    return proc, f'http://localhost:{port}'
 
 @app.route('/', methods=['GET', 'POST'])
 def convert_gradio():
+    global preview_process
+    preview_process = None
+    
     if request.method == 'POST':
         gradio_script = request.form['gradio_script']
         try:
             components = parse_gradio_script(gradio_script)
-            flask_app_zip = generate_flask_app(gradio_script, components)
-            return send_file(
-                flask_app_zip,
-                mimetype='application/zip',
-                as_attachment=True,
-                download_name=f'flask_app_{datetime.now().strftime("%Y%m%d_%H%M%S")}.zip'
+            flask_code, html_template, requirements = generate_flask_app(gradio_script, components)
+            
+            # Create ZIP file
+            buffer = io.BytesIO()
+            with zipfile.ZipFile(buffer, 'w', zipfile.ZIP_DEFLATED) as zip_file:
+                zip_file.writestr('app.py', flask_code)
+                zip_file.writestr('templates/index.html', html_template)
+                zip_file.writestr('requirements.txt', requirements)
+            buffer.seek(0)
+
+            # Start preview in a subprocess
+            preview_process, preview_url = run_preview(flask_code)
+            
+            return render_template(
+                'result.html',
+                flask_code=flask_code,
+                html_template=html_template,
+                requirements=requirements,
+                zip_buffer=buffer.getvalue(),
+                preview_url=preview_url
             )
         except Exception as e:
             return render_template('index.html', error=str(e))
     return render_template('index.html')
 
+@app.route('/download/<filename>')
+def download_file(filename):
+    if filename == 'app.py':
+        content = request.args.get('content')
+        return Response(content, mimetype='text/plain', headers={"Content-Disposition": f"attachment;filename={filename}"})
+    elif filename == 'index.html':
+        content = request.args.get('content')
+        return Response(content, mimetype='text/html', headers={"Content-Disposition": f"attachment;filename={filename}"})
+    elif filename == 'requirements.txt':
+        content = request.args.get('content')
+        return Response(content, mimetype='text/plain', headers={"Content-Disposition": f"attachment;filename={filename}"})
+    elif filename == 'zip':
+        buffer = io.BytesIO(request.args.get('content').encode())
+        buffer.seek(0)
+        return send_file(buffer, mimetype='application/zip', as_attachment=True, download_name=f'flask_app_{datetime.now().strftime("%Y%m%d_%H%M%S")}.zip')
+    return "File not found", 404
+
+@app.teardown_appcontext
+def cleanup(exc):
+    global preview_process
+    if preview_process:
+        preview_process.terminate()
+
 if __name__ == '__main__':
     app.run(host="0.0.0.0", port=7860, debug=True)