fix: upgraded gradio version

Dockerfile

@@ -1,20 +1,26 @@
 FROM python:3.10-slim
 
-# Install system dependencies
+# Install dependencies
 RUN apt-get update && apt-get install -y git && rm -rf /var/lib/apt/lists/*
 
-# Set workdir
+# Set working directory
 WORKDIR /app
 
-# Copy requirements and install
+# Copy requirements
 COPY requirements.txt ./
+
+# Install dependencies
 RUN pip install --no-cache-dir -r requirements.txt
 
-# Copy all code
+# Copy application code
 COPY . .
 
-# Expose Gradio port
+# Expose port
 EXPOSE 7860
 
-# Run Gradio app
-CMD ["python", "faceforge_ui/app.py"] 
+# Set environment variables
+ENV PYTHONPATH="/app"
+ENV PYTHONUNBUFFERED=1
+
+# Start app (with the patch applied)
+CMD ["python", "main.py"] 

README.md

@@ -4,8 +4,8 @@ emoji: 🧑‍🎨
 colorFrom: indigo
 colorTo: pink
 sdk: gradio
-sdk_version: "4.27.0"
-app_file: faceforge_ui/app.py
+sdk_version: "4.44.1"
+app_file: main.py
 pinned: false
 ---
 
@@ -19,7 +19,7 @@ FaceForge is ready to run as a Gradio app on [Hugging Face Spaces](https://huggi
 1. **Push your code to a public GitHub repository.**
 2. **Create a new Space** at https://huggingface.co/spaces (choose the Gradio SDK or Docker SDK).
 3. **Add your `requirements.txt` and the provided `Dockerfile` to your repo.**
-4. **Set the entrypoint to `faceforge_ui/app.py`** (the Gradio app).
+4. **Set the entrypoint to `main.py`** (which handles both the API and UI components).
 5. **Deploy!** Your app will be live at `https://<your-username>.hf.space`.
 
 ### Example Dockerfile (already included):
@@ -31,7 +31,9 @@ COPY requirements.txt ./
 RUN pip install --no-cache-dir -r requirements.txt
 COPY . .
 EXPOSE 7860
-CMD ["python", "faceforge_ui/app.py"]
+ENV PYTHONPATH="/app"
+ENV PYTHONUNBUFFERED=1
+CMD ["python", "main.py"]
 ```
 
 ## Local Development (Optional)
@@ -40,7 +42,12 @@ You can still run FaceForge locally:
 
 ```bash
 pip install -r requirements.txt
-python faceforge_ui/app.py
+python main.py
+```
+
+To run in API-only mode:
+```bash
+FACEFORGE_MODE=api python main.py
 ```
 
 ## Features
@@ -62,6 +69,20 @@ Run all tests with:
 pytest tests/
 ```
 
+## Debugging
+
+If you encounter Gradio schema-related errors like:
+```
+TypeError: argument of type 'bool' is not iterable
+```
+
+The application includes a patch that should fix the issue automatically. This patch addresses a known issue with schema processing in older Gradio versions.
+
+Recommended steps to diagnose UI issues:
+1. Check the logs for detailed error information
+2. Ensure you're using Gradio version 4.44.1 or newer (`pip install --upgrade gradio==4.44.1`)
+3. Try running in API-only mode to isolate the issue
+
 ## Notes
 - The backend and frontend are fully integrated for Spaces.
 - For custom model integration, edit the core and backend modules as needed.

app.py

@@ -1,6 +1,12 @@
+#!/usr/bin/env python3
+"""
+Main entry point for Hugging Face Spaces deployment
+"""
+
 import os
-import sys
 import logging
+import sys
+import traceback
 
 # Configure logging
 logging.basicConfig(
@@ -8,22 +14,39 @@ logging.basicConfig(
     format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
     handlers=[logging.StreamHandler(sys.stdout)]
 )
-logger = logging.getLogger("faceforge_app")
 
-# Add the project root to the Python path
-sys.path.insert(0, os.path.abspath(os.path.dirname(__file__)))
+logger = logging.getLogger("faceforge")
+
+def main():
+    """Main function to start the FaceForge application."""
+    try:
+        # Apply the patch for Gradio
+        logger.info("Applying Gradio patch...")
+        try:
+            from patch_gradio_utils import apply_patch
+            if apply_patch():
+                logger.info("Gradio patch applied successfully.")
+            else:
+                logger.warning("Failed to apply Gradio patch. The app may encounter errors.")
+        except Exception as e:
+            logger.warning(f"Error applying Gradio patch: {e}")
+            logger.debug(traceback.format_exc())
+        
+        # Import and run the UI app by default for HF Spaces
+        logger.info("Starting in UI mode for Hugging Face Spaces")
+        from faceforge_ui.app import create_demo
+        demo = create_demo()
+        demo.launch(server_name="0.0.0.0", share=False)
+            
+    except ImportError as e:
+        logger.critical(f"Import error: {e}. Please check your dependencies.")
+        logger.debug(traceback.format_exc())
+        sys.exit(1)
+    except Exception as e:
+        logger.critical(f"Unexpected error: {e}")
+        logger.debug(traceback.format_exc())
+        sys.exit(1)
 
-try:
-    logger.info("Starting FaceForge app")
-    # Import the demo from the UI module
-    from faceforge_ui.app import demo
-    
-    # Launch the app
-    if __name__ == "__main__":
-        logger.info("Launching Gradio interface")
-        demo.launch(server_name="0.0.0.0")
-except Exception as e:
-    logger.critical(f"Failed to start app: {e}")
-    import traceback
-    logger.debug(traceback.format_exc())
-    raise 
+# This module is imported by Hugging Face Spaces
+if __name__ == "__main__":
+    main() 

faceforge_api/main.py

@@ -1,8 +1,8 @@
 from fastapi import FastAPI, HTTPException, Request
 from fastapi.responses import JSONResponse
 from fastapi.middleware.cors import CORSMiddleware
-from pydantic import BaseModel
-from typing import List, Optional
+from pydantic import BaseModel, Field
+from typing import List, Optional, Dict, Any
 import numpy as np
 import base64
 import logging
@@ -10,6 +10,7 @@ import sys
 import traceback
 import io
 from PIL import Image
+import json
 
 from faceforge_core.latent_explorer import LatentSpaceExplorer
 from faceforge_core.attribute_directions import LatentDirectionFinder
@@ -27,14 +28,14 @@ logger = logging.getLogger("faceforge_api")
 
 class PointIn(BaseModel):
     text: str
-    encoding: Optional[List[float]] = None
-    xy_pos: Optional[List[float]] = None
+    encoding: Optional[List[float]] = Field(None)
+    xy_pos: Optional[List[float]] = Field(None)
 
 class GenerateRequest(BaseModel):
     prompts: List[str]
-    positions: Optional[List[List[float]]] = None
+    positions: Optional[List[List[float]]] = Field(None)
     mode: str = "distance"
-    player_pos: Optional[List[float]] = None
+    player_pos: Optional[List[float]] = Field(None)
 
 class ManipulateRequest(BaseModel):
     encoding: List[float]
@@ -43,7 +44,7 @@ class ManipulateRequest(BaseModel):
 
 class AttributeDirectionRequest(BaseModel):
     latents: List[List[float]]
-    labels: Optional[List[int]] = None
+    labels: Optional[List[int]] = Field(None)
     n_components: Optional[int] = 10
 
 # --- FastAPI app ---
@@ -81,9 +82,12 @@ def read_root():
     return {"message": "FaceForge API is running"}
 
 @app.post("/generate")
-def generate_image(req: GenerateRequest):
+async def generate_image(req: GenerateRequest):
     try:
-        logger.debug(f"Generate image request: {req}")
+        logger.debug(f"Generate image request: {json.dumps(req.dict(), default=str)}")
+        
+        # Log request schema for debugging
+        logger.debug(f"Request schema: {GenerateRequest.schema_json()}")
         
         # Clear existing points
         explorer.points = []
@@ -123,8 +127,13 @@ def generate_image(req: GenerateRequest):
         pil_img.save(buffer, format="PNG")
         img_b64 = base64.b64encode(buffer.getvalue()).decode("utf-8")
         
+        # Prepare response
+        response = {"status": "success", "image": img_b64}
+        logger.debug(f"Response structure: {list(response.keys())}")
+        logger.debug(f"Image base64 length: {len(img_b64)}")
+        
         logger.debug("Image generated successfully")
-        return {"status": "success", "image": img_b64}
+        return response
         
     except Exception as e:
         logger.error(f"Error in generate_image: {str(e)}")
@@ -134,7 +143,7 @@ def generate_image(req: GenerateRequest):
 @app.post("/manipulate")
 def manipulate(req: ManipulateRequest):
     try:
-        logger.debug(f"Manipulate request: {req}")
+        logger.debug(f"Manipulate request: {json.dumps(req.dict(), default=str)}")
         encoding = np.array(req.encoding)
         direction = np.array(req.direction)
         manipulated = encoding + req.alpha * direction
@@ -148,7 +157,7 @@ def manipulate(req: ManipulateRequest):
 @app.post("/attribute_direction")
 def attribute_direction(req: AttributeDirectionRequest):
     try:
-        logger.debug(f"Attribute direction request: {req}")
+        logger.debug(f"Attribute direction request: {json.dumps(req.dict(), default=str)}")
         latents = np.array(req.latents)
         finder = LatentDirectionFinder(latents)
         

faceforge_ui/app.py

@@ -8,6 +8,7 @@ import logging
 import sys
 import traceback
 import os
+import json
 
 # Configure logging
 logging.basicConfig(
@@ -17,6 +18,10 @@ logging.basicConfig(
 )
 logger = logging.getLogger("faceforge_ui")
 
+# Add more debug loggers for gradio internals
+logging.getLogger("gradio").setLevel(logging.DEBUG)
+logging.getLogger("gradio_client").setLevel(logging.DEBUG)
+
 # API configuration
 API_URL = os.environ.get("API_URL", "http://localhost:8000")
 logger.info(f"Using API URL: {API_URL}")
@@ -39,32 +44,47 @@ def generate_image(prompts, mode, player_x, player_y):
             "player_pos": [float(player_x), float(player_y)]
         }
         
+        logger.debug(f"Request payload: {json.dumps(req)}")
+        
         # Make API call
         try:
             resp = requests.post(f"{API_URL}/generate", json=req, timeout=30)
+            logger.debug(f"API response status: {resp.status_code}")
             
             if resp.ok:
-                data = resp.json()
-                
-                if "image" in data:
-                    img_b64 = data["image"]
-                    img_bytes = base64.b64decode(img_b64)
+                try:
+                    data = resp.json()
+                    logger.debug(f"API response structure: {list(data.keys())}")
                     
-                    try:
-                        # For testing, create a simple colored image if decode fails
+                    if "image" in data:
+                        img_b64 = data["image"]
+                        logger.debug(f"Image base64 length: {len(img_b64)}")
+                        img_bytes = base64.b64decode(img_b64)
+                        
                         try:
-                            img = Image.frombytes("RGB", (256, 256), img_bytes)
-                        except:
-                            # Fallback to create a test image
-                            img = Image.new("RGB", (256, 256), (int(player_x*128)+128, 100, int(player_y*128)+128))
-                            
-                        return img, "Image generated successfully"
-                    except Exception as e:
-                        logger.error(f"Error decoding image: {e}")
-                        return None, f"Error decoding image: {str(e)}"
-                else:
-                    return None, "No image in API response"
+                            # For testing, create a simple colored image if decode fails
+                            try:
+                                img = Image.open(io.BytesIO(img_bytes))
+                                logger.debug(f"Image decoded successfully: {img.size} {img.mode}")
+                            except Exception as e:
+                                logger.error(f"Failed to decode image from bytes: {e}, creating test image")
+                                # Fallback to create a test image
+                                img = Image.new("RGB", (256, 256), (int(player_x*128)+128, 100, int(player_y*128)+128))
+                                
+                            return img, "Image generated successfully"
+                        except Exception as e:
+                            logger.error(f"Error processing image: {e}")
+                            logger.debug(traceback.format_exc())
+                            return None, f"Error processing image: {str(e)}"
+                    else:
+                        logger.warning("No image field in API response")
+                        return None, "No image in API response"
+                except Exception as e:
+                    logger.error(f"Error parsing API response: {e}")
+                    logger.debug(f"Raw response: {resp.text[:500]}")
+                    return None, f"Error parsing API response: {str(e)}"
             else:
+                logger.error(f"API error: {resp.status_code}, {resp.text[:500]}")
                 return None, f"API error: {resp.status_code}"
                 
         except requests.exceptions.RequestException as e:
@@ -73,29 +93,67 @@ def generate_image(prompts, mode, player_x, player_y):
             
     except Exception as e:
         logger.error(f"Unexpected error: {e}")
+        logger.debug(traceback.format_exc())
         return None, f"Error: {str(e)}"
 
 # Create a simplified Gradio interface to avoid schema issues
-demo = gr.Interface(
-    fn=generate_image,
-    inputs=[
-        gr.Textbox(label="Prompts (comma-separated)", value="A photo of a cat, A photo of a dog"),
-        gr.Radio(["distance", "circle"], value="distance", label="Sampling Mode"),
-        gr.Slider(-1.0, 1.0, value=0.0, label="Player X"),
-        gr.Slider(-1.0, 1.0, value=0.0, label="Player Y")
-    ],
-    outputs=[
-        gr.Image(label="Generated Image", type="pil"),
-        gr.Textbox(label="Status")
-    ],
-    title="FaceForge Latent Space Explorer",
-    description="Interactively explore and edit faces in latent space.",
-    allow_flagging="never"
-)
+# Use basic components without custom schemas
+def create_demo():
+    with gr.Blocks(title="FaceForge Latent Space Explorer") as demo:
+        gr.Markdown("# FaceForge Latent Space Explorer")
+        gr.Markdown("Interactively explore and edit faces in latent space.")
+        
+        with gr.Row():
+            with gr.Column(scale=3):
+                prompts_input = gr.Textbox(
+                    label="Prompts (comma-separated)", 
+                    value="A photo of a cat, A photo of a dog",
+                    lines=2
+                )
+                mode_input = gr.Radio(
+                    choices=["distance", "circle"],
+                    value="distance",
+                    label="Sampling Mode"
+                )
+                player_x_input = gr.Slider(
+                    minimum=-1.0,
+                    maximum=1.0,
+                    value=0.0,
+                    step=0.1,
+                    label="Player X"
+                )
+                player_y_input = gr.Slider(
+                    minimum=-1.0,
+                    maximum=1.0,
+                    value=0.0,
+                    step=0.1,
+                    label="Player Y"
+                )
+                
+                generate_btn = gr.Button("Generate")
+                
+            with gr.Column(scale=5):
+                output_image = gr.Image(label="Generated Image")
+                output_status = gr.Textbox(label="Status")
+                
+        generate_btn.click(
+            fn=generate_image,
+            inputs=[prompts_input, mode_input, player_x_input, player_y_input],
+            outputs=[output_image, output_status]
+        )
+        
+    return demo
 
+# Only start if this file is run directly, not when imported
 if __name__ == "__main__":
-    logger.info("Starting Gradio app")
+    logger.info("Starting Gradio app directly from app.py")
     try:
+        # Print Gradio version for debugging
+        logger.info(f"Gradio version: {gr.__version__}")
+        
+        # Create demo
+        demo = create_demo()
+        
         # Check if we're running in Hugging Face Spaces
         if "SPACE_ID" in os.environ:
             logger.info("Running in Hugging Face Space")

main.py

@@ -1,20 +1,57 @@
-from latent_space_explorer import GameConfig, LatentSpaceExplorer
+#!/usr/bin/env python3
+"""
+Main entry point for FaceForge application
+"""
 
-if __name__ == "__main__":
-    config = GameConfig(
-        call_every = 100
-    )
+import os
+import logging
+import sys
+import traceback
+
+# Configure logging
+logging.basicConfig(
+    level=logging.DEBUG,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[logging.StreamHandler(sys.stdout)]
+)
 
-    explorer = LatentSpaceExplorer(config)
+logger = logging.getLogger("faceforge")
 
-    explorer.set_prompts(
-        [
-            "A photo of a cat",
-            "A space-aged ferrari",
-            "artwork of the titanic hitting an iceberg",
-            "a photo of a dog"
-        ]
-    )
+def main():
+    """Main function to start the FaceForge application."""
+    try:
+        # Apply the patch for Gradio
+        logger.info("Applying Gradio patch...")
+        try:
+            from patch_gradio_utils import apply_patch
+            if apply_patch():
+                logger.info("Gradio patch applied successfully.")
+            else:
+                logger.warning("Failed to apply Gradio patch. The app may encounter errors.")
+        except Exception as e:
+            logger.warning(f"Error applying Gradio patch: {e}")
+            logger.debug(traceback.format_exc())
+        
+        # Import and run the appropriate app
+        if os.environ.get("FACEFORGE_MODE", "ui").lower() == "api":
+            logger.info("Starting in API mode")
+            from faceforge_api.main import app
+            import uvicorn
+            uvicorn.run(app, host="0.0.0.0", port=8000)
+        else:
+            logger.info("Starting in UI mode")
+            from faceforge_ui.app import create_demo
+            demo = create_demo()
+            demo.launch(server_name="0.0.0.0", share=False)
+            
+    except ImportError as e:
+        logger.critical(f"Import error: {e}. Please check your dependencies.")
+        logger.debug(traceback.format_exc())
+        sys.exit(1)
+    except Exception as e:
+        logger.critical(f"Unexpected error: {e}")
+        logger.debug(traceback.format_exc())
+        sys.exit(1)
 
-    while True:
-        explorer.update()
+if __name__ == "__main__":
+    main()

patch_gradio_utils.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+"""
+Patch for gradio_client.utils._json_schema_to_python_type function
+to handle boolean schema values properly.
+
+This patch adds a check for boolean schema values before trying to access them as dictionaries.
+"""
+
+import importlib
+import logging
+
+logger = logging.getLogger(__name__)
+
+def apply_patch():
+    """Apply the monkey patch to fix the TypeError in gradio_client.utils._json_schema_to_python_type."""
+    try:
+        # Import the module
+        import gradio_client.utils as utils
+        
+        # Store the original function
+        original_func = utils._json_schema_to_python_type
+        
+        # Define the patched function
+        def patched_json_schema_to_python_type(schema, defs=None):
+            """Patched version that handles boolean schemas."""
+            if schema is None:
+                return "None"
+            
+            # Handle boolean schema values
+            if isinstance(schema, bool):
+                return str(schema).lower()
+                
+            # Continue with the original function for non-boolean schemas
+            return original_func(schema, defs)
+        
+        # Apply the patch
+        utils._json_schema_to_python_type = patched_json_schema_to_python_type
+        
+        # Also patch the get_type function
+        original_get_type = utils.get_type
+        
+        def patched_get_type(schema):
+            """Patched version of get_type that handles boolean schemas."""
+            if isinstance(schema, bool):
+                return "bool"
+            return original_get_type(schema)
+        
+        utils.get_type = patched_get_type
+        
+        logger.info("Successfully applied patch to gradio_client.utils._json_schema_to_python_type")
+        return True
+    except Exception as e:
+        logger.error(f"Failed to apply patch: {e}")
+        import traceback
+        logger.debug(traceback.format_exc())
+        return False
+
+if __name__ == "__main__":
+    # Set up logging
+    logging.basicConfig(level=logging.DEBUG)
+    
+    # Apply the patch
+    if apply_patch():
+        print("Patch applied successfully.")
+    else:
+        print("Failed to apply patch.") 

requirements.txt

@@ -3,6 +3,6 @@ pygame
 torch
 torchvision
 fastapi
-gradio
+gradio==4.44.1
 pytest
 scikit-learn