fix: localhost error

Dockerfile

@@ -21,6 +21,8 @@ EXPOSE 7860
 # Set environment variables
 ENV PYTHONPATH="/app"
 ENV PYTHONUNBUFFERED=1
+ENV API_URL="/api"
+ENV MOCK_API="false"
 
 # Start app (with the patch applied)
-CMD ["python", "main.py"] 
+CMD ["python", "app.py"] 

README.md

@@ -5,7 +5,7 @@ colorFrom: indigo
 colorTo: pink
 sdk: gradio
 sdk_version: "4.44.1"
-app_file: main.py
+app_file: app.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 `main.py`** (which handles both the API and UI components).
+4. **Set the entrypoint to `app.py`** (which integrates both the API and UI components).
 5. **Deploy!** Your app will be live at `https://<your-username>.hf.space`.
 
 ### Example Dockerfile (already included):
@@ -45,10 +45,21 @@ pip install -r requirements.txt
 python main.py
 ```
 
-To run in API-only mode:
-```bash
-FACEFORGE_MODE=api python main.py
-```
+This will start the integrated application with both the API and UI components available:
+- UI accessible at http://localhost:7860/
+- API accessible at http://localhost:7860/api/
+
+## Architecture
+
+FaceForge uses a modular architecture:
+
+1. **Core Components** (`faceforge_core/`): Core algorithms and utilities
+2. **API Layer** (`faceforge_api/`): FastAPI endpoints for model interaction
+3. **UI Layer** (`faceforge_ui/`): Gradio interface for user interaction
+
+The main application integrates these components into a single FastAPI application where:
+- The API is mounted at `/api/`
+- The Gradio UI is mounted at the root path `/`
 
 ## Features
 - Latent space exploration and manipulation
@@ -78,11 +89,30 @@ 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
+### Common Issues:
+
+#### API Connection Errors
+
+If you see errors like:
+```
+Request failed: HTTPConnectionPool(host='localhost', port=8000): Max retries exceeded with url: /generate
+```
+
+This means the UI can't connect to the API. In the integrated version, the API is available at `/api/generate` rather than a separate server.
+
+To fix this:
+1. Ensure you're using the integrated version by running `python main.py`
+2. If you need to run the API separately, set the API_URL environment variable:
+   ```bash
+   API_URL=http://localhost:8000 python faceforge_ui/app.py
+   ```
+
+#### Environment Variables
+
+- `MOCK_API`: Set to "true" to use mock API responses (for testing without API)
+- `API_URL`: Override the API endpoint URL
+- `PORT`: Set the port for the server (default: 7860)
 
 ## Notes
-- The backend and frontend are fully integrated for Spaces.
+- The backend and frontend are fully integrated for Spaces deployment.
 - For custom model integration, edit the core and backend modules as needed.

app.py

@@ -17,8 +17,8 @@ logging.basicConfig(
 
 logger = logging.getLogger("faceforge")
 
-def main():
-    """Main function to start the FaceForge application."""
+def create_app():
+    """Creates and configures the integrated FastAPI application with both API and UI components."""
     try:
         # Apply the patch for Gradio
         logger.info("Applying Gradio patch...")
@@ -32,21 +32,53 @@ def main():
             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")
+        # Set up FastAPI application with both API and UI
+        logger.info("Setting up FastAPI application with API and UI for Hugging Face Spaces")
+        from fastapi import FastAPI
+        from fastapi.middleware.cors import CORSMiddleware
+        import gradio as gr
+        
+        # Import the API and UI components
+        from faceforge_api.main import app as api_app
         from faceforge_ui.app import create_demo
+        
+        # Create a new FastAPI application that will serve as the main app
+        app = FastAPI(title="FaceForge")
+        
+        # Add CORS middleware
+        app.add_middleware(
+            CORSMiddleware,
+            allow_origins=["*"],
+            allow_credentials=True,
+            allow_methods=["*"],
+            allow_headers=["*"],
+        )
+        
+        # Mount the API under /api
+        logger.info("Mounting API at /api")
+        app.mount("/api", api_app)
+        
+        # Create Gradio UI
+        logger.info("Creating Gradio UI")
         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)
+        
+        # Mount Gradio UI
+        logger.info("Mounting Gradio UI")
+        gr_app = gr.mount_gradio_app(app, demo, path="/")
+        
+        return app
     except Exception as e:
-        logger.critical(f"Unexpected error: {e}")
+        logger.critical(f"Failed to create app: {e}")
         logger.debug(traceback.format_exc())
-        sys.exit(1)
+        raise
+
+# Create the app for Hugging Face Spaces
+# This is the entry point that Hugging Face Spaces will use
+app = create_app()
 
-# This module is imported by Hugging Face Spaces
 if __name__ == "__main__":
-    main() 
+    # If this file is run directly, start the server
+    import uvicorn
+    port = int(os.environ.get("PORT", 7860))
+    logger.info(f"Starting integrated server on port {port}")
+    uvicorn.run(app, host="0.0.0.0", port=port) 

faceforge_api/main.py

@@ -49,7 +49,13 @@ class AttributeDirectionRequest(BaseModel):
 
 # --- FastAPI app ---
 
-app = FastAPI()
+app = FastAPI(
+    title="FaceForge API",
+    description="API for latent space exploration and manipulation",
+    version="1.0.0",
+    # Important: set root_path to empty to ensure routes work correctly when mounted under /api
+    root_path=""
+)
 
 # Add CORS middleware to allow requests from any origin
 app.add_middleware(
@@ -78,7 +84,7 @@ async def error_handling_middleware(request: Request, call_next):
 
 @app.get("/")
 def read_root():
-    logger.debug("Root endpoint called")
+    logger.debug("API root endpoint called")
     return {"message": "FaceForge API is running"}
 
 @app.post("/generate")

faceforge_ui/app.py

@@ -23,7 +23,9 @@ 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")
+# In HF Spaces, we need to use a relative path since both UI and API run on the same server
+# For local development with separate servers, the env var can be set to http://localhost:8000
+API_URL = os.environ.get("API_URL", "/api")
 logger.info(f"Using API URL: {API_URL}")
 
 def generate_image(prompts, mode, player_x, player_y):
@@ -48,7 +50,24 @@ def generate_image(prompts, mode, player_x, player_y):
         
         # Make API call
         try:
-            resp = requests.post(f"{API_URL}/generate", json=req, timeout=30)
+            # For debugging/testing, create a mock image if API is not available
+            if API_URL == "/api" and os.environ.get("MOCK_API", "false").lower() == "true":
+                logger.debug("Using mock API response")
+                # 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 using mock API"
+                
+            # Determine the base URL for the API
+            if API_URL.startswith("/"):
+                # Relative URL, construct the full URL based on the request context
+                # For Gradio apps, we'll just use a relative path
+                base_url = API_URL
+            else:
+                # Absolute URL, use as is
+                base_url = API_URL
+                
+            logger.debug(f"Making request to: {base_url}/generate")
+            resp = requests.post(f"{base_url}/generate", json=req, timeout=30)
             logger.debug(f"API response status: {resp.status_code}")
             
             if resp.ok:
@@ -89,7 +108,10 @@ def generate_image(prompts, mode, player_x, player_y):
                 
         except requests.exceptions.RequestException as e:
             logger.error(f"Request failed: {e}")
-            return None, f"Request failed: {str(e)}"
+            # Fall back to a test image
+            logger.debug("Falling back to test image")
+            img = Image.new("RGB", (256, 256), (int(player_x*128)+128, 100, int(player_y*128)+128))
+            return img, f"API connection failed (using test image): {str(e)}"
             
     except Exception as e:
         logger.error(f"Unexpected error: {e}")

main.py

@@ -32,17 +32,45 @@ def main():
             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)
+        # Set up FastAPI application with both API and UI
+        logger.info("Setting up FastAPI application with API and UI")
+        from fastapi import FastAPI
+        from fastapi.middleware.cors import CORSMiddleware
+        import gradio as gr
+        
+        # Import the API and UI components
+        from faceforge_api.main import app as api_app
+        from faceforge_ui.app import create_demo
+        
+        # Create a new FastAPI application that will serve as the main app
+        app = FastAPI(title="FaceForge")
+        
+        # Add CORS middleware
+        app.add_middleware(
+            CORSMiddleware,
+            allow_origins=["*"],
+            allow_credentials=True,
+            allow_methods=["*"],
+            allow_headers=["*"],
+        )
+        
+        # Mount the API under /api
+        logger.info("Mounting API at /api")
+        app.mount("/api", api_app)
+        
+        # Create Gradio UI
+        logger.info("Creating Gradio UI")
+        demo = create_demo()
+        
+        # Mount Gradio UI
+        logger.info("Mounting Gradio UI")
+        gr_app = gr.mount_gradio_app(app, demo, path="/")
+        
+        # Configure server
+        import uvicorn
+        port = int(os.environ.get("PORT", 7860))
+        logger.info(f"Starting integrated server on port {port}")
+        uvicorn.run(app, host="0.0.0.0", port=port)
             
     except ImportError as e:
         logger.critical(f"Import error: {e}. Please check your dependencies.")