Update app.py

app.py

@@ -7,62 +7,143 @@ import base64
 import sys
 import shutil
 import re
+import logging
+import platform
 from streamlit_ace import st_ace
 
+# Set up logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger('blender_app')
+
 st.set_page_config(page_title="Blender 3D Viewer", layout="wide")
 st.title("🌍 Blender Script → 3D Viewer")
 
-# Find Blender executable
+# Detect environment
+IS_HUGGINGFACE = os.environ.get('SPACE_ID') is not None
+if IS_HUGGINGFACE:
+    st.info("Running in Hugging Face Spaces environment")
+
+# Find Blender executable with enhanced detection for Hugging Face
 def find_blender():
-    # Common paths to check
+    # Common paths to check, expanded for Hugging Face environment
     paths_to_check = [
         "blender",  # default PATH
         "/usr/bin/blender",
-        "/opt/blender/blender"
+        "/opt/blender/blender",
+        "/app/bin/blender",  # Common in Docker containers
+        "/usr/local/bin/blender",
+        os.path.join(os.path.expanduser("~"), "blender/blender")
     ]
     
+    # On HF, Blender might be installed in a custom location
+    if IS_HUGGINGFACE:
+        # Check if Blender was installed via apt.txt
+        hf_paths = [
+            "/opt/conda/bin/blender",
+            "/home/user/blender/blender"
+        ]
+        paths_to_check = hf_paths + paths_to_check
+    
+    # On Windows systems
+    if platform.system() == "Windows":
+        program_files = os.environ.get("ProgramFiles", "C:\\Program Files")
+        paths_to_check.append(os.path.join(program_files, "Blender Foundation", "Blender", "blender.exe"))
+    
     for path in paths_to_check:
         try:
+            logger.info(f"Checking Blender at: {path}")
             result = subprocess.run([path, "--version"], 
                                    capture_output=True, 
                                    text=True,
-                                   timeout=5)
+                                   timeout=10)
             if result.returncode == 0:
                 st.success(f"Found Blender: {result.stdout.strip()}")
+                logger.info(f"Blender found at {path}: {result.stdout.strip()}")
                 return path
-        except:
+        except Exception as e:
+            logger.debug(f"Failed to find Blender at {path}: {str(e)}")
             continue
     
+    # If not found, try using the 'which' command on Unix-like systems
+    if platform.system() != "Windows":
+        try:
+            result = subprocess.run(["which", "blender"], 
+                                    capture_output=True, 
+                                    text=True,
+                                    timeout=5)
+            if result.returncode == 0 and result.stdout.strip():
+                path = result.stdout.strip()
+                st.success(f"Found Blender using 'which': {path}")
+                logger.info(f"Blender found using 'which': {path}")
+                return path
+        except Exception as e:
+            logger.debug(f"Failed to use 'which' to find Blender: {str(e)}")
+    
     return None
 
-# Preprocess script to ensure it has necessary imports and path handling
+# Enhanced script preprocessor to ensure reliable .blend file saving
 def preprocess_script(script_text, tmp_dir):
-    # Check if 'import os' exists in the script
-    if 'import os' not in script_text:
-        script_text = 'import os\n' + script_text
+    logger.info("Preprocessing script...")
+    
+    # Check if necessary imports exist in the script
+    required_imports = {
+        'import bpy': 'import bpy',
+        'import os': 'import os',
+        'import math': 'import math' if 'math.' in script_text else None,
+        'import sys': 'import sys'
+    }
+    
+    for import_check, import_statement in required_imports.items():
+        if import_statement and import_check not in script_text:
+            script_text = import_statement + '\n' + script_text
+            logger.info(f"Added {import_statement} to script")
     
-    # Check if 'import math' exists in the script (commonly needed)
-    if 'import math' not in script_text and 'math.' in script_text:
-        script_text = 'import math\n' + script_text
+    # Ensure absolute paths for file operations in Hugging Face environment
+    absolute_tmp_dir = os.path.abspath(tmp_dir)
+    logger.info(f"Using absolute temp directory: {absolute_tmp_dir}")
     
-    # Check if script already has file saving code
+    # More robust file saving code with error handling
     if 'bpy.ops.wm.save_as_mainfile' not in script_text:
-        # Add file saving code at the end
+        # Add enhanced file saving code at the end with detailed error handling
         script_text += f'''
 
-# Save the .blend file
-output_dir = os.environ.get('BLENDER_OUTPUT_DIR', os.getcwd())
-blend_file_path = os.path.join(output_dir, "scene.blend")
-bpy.ops.wm.save_as_mainfile(filepath=blend_file_path)
-print(f"Saved blend file to: {{blend_file_path}}")
+# Save the .blend file with error handling
+try:
+    # Ensure the output directory exists
+    output_dir = os.environ.get('BLENDER_OUTPUT_DIR', '{absolute_tmp_dir}')
+    os.makedirs(output_dir, exist_ok=True)
+    
+    # Use absolute path for the blend file
+    blend_file_path = os.path.abspath(os.path.join(output_dir, "scene.blend"))
+    
+    # Print debug info for troubleshooting
+    print(f"Attempting to save blend file to: {{blend_file_path}}")
+    print(f"Current working directory: {{os.getcwd()}}")
+    
+    # Save the file with absolute path - using both filepath and check_existing parameters
+    bpy.ops.wm.save_as_mainfile(filepath=blend_file_path, check_existing=False)
+    
+    # Verify the file was saved
+    if os.path.exists(blend_file_path):
+        print(f"Successfully saved blend file to: {{blend_file_path}}")
+    else:
+        print(f"ERROR: Failed to save blend file - file does not exist after save operation")
+except Exception as e:
+    print(f"ERROR saving .blend file: {{str(e)}}")
+    import traceback
+    traceback.print_exc()
 '''
+        logger.info("Added enhanced file saving code to script")
     else:
-        # Make sure existing save code uses absolute paths correctly
-        script_text = re.sub(
-            r'bpy\.ops\.wm\.save_as_mainfile\s*\(\s*filepath\s*=\s*["\']([^"\']+)["\']',
-            'bpy.ops.wm.save_as_mainfile(filepath=os.path.join(os.environ.get("BLENDER_OUTPUT_DIR", os.getcwd()), "scene.blend")',
-            script_text
-        )
+        # Make sure existing save code uses absolute paths correctly and has error handling
+        save_pattern = r'bpy\.ops\.wm\.save_as_mainfile\s*\(\s*filepath\s*=\s*["\']([^"\']+)["\']'
+        if re.search(save_pattern, script_text):
+            script_text = re.sub(
+                save_pattern,
+                f'bpy.ops.wm.save_as_mainfile(filepath=os.path.abspath(os.path.join(os.environ.get("BLENDER_OUTPUT_DIR", "{absolute_tmp_dir}"), "scene.blend")), check_existing=False',
+                script_text
+            )
+            logger.info("Modified existing save code to use absolute paths")
     
     return script_text
 
@@ -70,13 +151,20 @@ print(f"Saved blend file to: {{blend_file_path}}")
 blender_path = find_blender()
 if not blender_path:
     st.error("❌ Blender not found! The app requires Blender to be installed.")
-    st.info("Please check the Spaces configuration for proper apt.txt setup.")
+    if IS_HUGGINGFACE:
+        st.info("For Hugging Face Spaces, make sure to include 'blender' in your apt.txt file to install Blender.")
+        st.code("blender", language="text")
+    else:
+        st.info("Please install Blender and make sure it's in your PATH.")
     # Continue anyway to show the interface
 
 # Hardcoded default texture URLs (with fallbacks)
 DEFAULT_TEXTURE_URLS = [
     "https://eoimages.gsfc.nasa.gov/images/imagerecords/57000/57730/land_ocean_ice_2048.jpg",
-    "https://svs.gsfc.nasa.gov/vis/a000000/a002900/a002915/bluemarble-2048.png"
+    "https://svs.gsfc.nasa.gov/vis/a000000/a002900/a002915/bluemarble-2048.png",
+    # Additional fallbacks
+    "https://upload.wikimedia.org/wikipedia/commons/thumb/c/cd/Blue_Marble_2007_East.jpg/600px-Blue_Marble_2007_East.jpg",
+    "https://www.solarsystemscope.com/textures/download/2k_earth_daymap.jpg"
 ]
 
 # Sidebar: Blender script editor with example script
@@ -256,6 +344,34 @@ bpy.context.scene.cycles.device = 'CPU'
 print('Solar system animation setup complete.')"""
 }
 
+# Add a simple script example that's lightweight for testing
+script_examples["Simple Cube (Test)"] = """import bpy
+
+# Clear the scene
+bpy.ops.object.select_all(action='SELECT')
+bpy.ops.object.delete()
+
+# Create a cube
+bpy.ops.mesh.primitive_cube_add(size=1, location=(0, 0, 0))
+cube = bpy.context.active_object
+cube.name = 'TestCube'
+
+# Add animation
+cube.rotation_euler = (0, 0, 0)
+cube.keyframe_insert(data_path="rotation_euler", frame=1)
+cube.rotation_euler = (0, math.radians(360), 0)
+cube.keyframe_insert(data_path="rotation_euler", frame=100)
+
+# Setup camera
+bpy.ops.object.camera_add(location=(0, -3, 0))
+camera = bpy.context.active_object
+camera.rotation_euler = (math.radians(90), 0, 0)
+bpy.context.scene.camera = camera
+
+# Setup lighting
+bpy.ops.object.light_add(type='SUN', location=(5, -5, 5))
+"""
+
 # Add example selector
 selected_example = st.sidebar.selectbox(
     "Load example script:",
@@ -287,6 +403,19 @@ custom_packages = st.sidebar.text_area(
     height=100
 )
 
+# Add options specific to troubleshooting in Hugging Face
+if IS_HUGGINGFACE:
+    st.sidebar.header("Hugging Face Options")
+    debug_mode = st.sidebar.checkbox("Enable Debug Mode", value=False)
+    if debug_mode:
+        log_level = st.sidebar.selectbox(
+            "Log Level", 
+            options=["INFO", "DEBUG"], 
+            index=0
+        )
+        if log_level == "DEBUG":
+            logger.setLevel(logging.DEBUG)
+
 # Main action
 if st.sidebar.button("Run & Export GLB"):
     if not blender_path:
@@ -300,12 +429,15 @@ if st.sidebar.button("Run & Export GLB"):
     with st.spinner("Processing your 3D scene..."):
         # Use a more robust temporary directory approach
         tmp_dir = tempfile.mkdtemp(prefix="blender_app_")
+        logger.info(f"Created temporary directory: {tmp_dir}")
+        
         try:
             # 1) Preprocess and save user script
             processed_script = preprocess_script(script_text, tmp_dir)
             script_path = os.path.join(tmp_dir, "user_script.py")
             with open(script_path, "w") as f:
                 f.write(processed_script)
+            logger.info(f"Saved processed script to: {script_path}")
 
             # 2) Collect textures
             texture_paths = []
@@ -316,20 +448,23 @@ if st.sidebar.button("Run & Export GLB"):
                     with open(path, "wb") as tf:
                         tf.write(upload.read())
                     texture_paths.append(path)
+                logger.info(f"Saved {len(texture_paths)} uploaded textures")
             else:
                 # Try multiple default textures if some fail
                 for url in DEFAULT_TEXTURE_URLS:
                     try:
-                        r = requests.get(url, timeout=10)
+                        r = requests.get(url, timeout=15)
                         r.raise_for_status()
                         ext = os.path.splitext(url)[-1] or ".jpg"
                         path = os.path.join(tmp_dir, f"default{ext}")
                         with open(path, "wb") as tf:
                             tf.write(r.content)
                         texture_paths.append(path)
+                        logger.info(f"Downloaded texture from {url}")
                         # If we got one texture successfully, that's enough
                         break
                     except Exception as e:
+                        logger.warning(f"Could not download texture {url}: {str(e)}")
                         st.warning(f"Could not download texture {url}: {str(e)}")
 
             # Display texture file information
@@ -337,14 +472,17 @@ if st.sidebar.button("Run & Export GLB"):
                 st.subheader("Texture Files")
                 for tp in texture_paths:
                     st.code(os.path.basename(tp))
+                    logger.info(f"Using texture: {tp}")
             else:
                 st.warning("No textures were loaded. Your 3D model may appear without textures.")
+                logger.warning("No textures were loaded")
 
             # 3) Install custom Python libraries if specified
             if custom_packages and custom_packages.strip():
                 pkgs = [l.strip() for l in custom_packages.splitlines() if l.strip()]
                 if pkgs:
                     st.info(f"Installing: {', '.join(pkgs)}")
+                    logger.info(f"Installing packages: {', '.join(pkgs)}")
                     try:
                         # Use Python executable from current environment for pip
                         pip_cmd = [sys.executable, "-m", "pip", "install", "--user"] + pkgs
@@ -353,52 +491,123 @@ if st.sidebar.button("Run & Export GLB"):
                             check=True,
                             capture_output=True,
                             text=True,
-                            timeout=120  # 2 minute timeout
+                            timeout=180  # 3 minute timeout
                         )
                         st.text_area("pip install output", pip_res.stdout + pip_res.stderr, height=100)
+                        logger.info(f"Pip install result: {pip_res.returncode}")
                     except Exception as e:
                         st.warning(f"pip install failed: {str(e)}")
+                        logger.error(f"pip install failed: {str(e)}")
 
             # 4) Prepare environment with necessary variables
             env = os.environ.copy()
             env["TEXTURE_PATHS"] = ",".join(texture_paths)
             env["BLENDER_OUTPUT_DIR"] = tmp_dir  # Pass the tmp_dir to the Blender script
+            logger.info(f"Set environment variable BLENDER_OUTPUT_DIR={tmp_dir}")
             
-            # 5) Run Blender to build .blend file
+            # 5) Run Blender to build .blend file with enhanced error handling and retry
             blend_path = os.path.join(tmp_dir, "scene.blend")
             
-            with st.status("Running Blender to create scene...") as status:
-                cmd1 = [blender_path, "--background", "--python", script_path]
+            max_retries = 3
+            for attempt in range(1, max_retries + 1):
+                with st.status(f"Running Blender to create scene (attempt {attempt}/{max_retries})...") as status:
+                    cmd1 = [blender_path, "--background", "--python", script_path]
+                    logger.info(f"Running Blender command: {' '.join(cmd1)}")
+                    
+                    try:
+                        r1 = subprocess.run(
+                            cmd1,
+                            cwd=tmp_dir,
+                            env=env,
+                            check=True,
+                            capture_output=True,
+                            text=True,
+                            timeout=300  # 5 minute timeout
+                        )
+                        status.update(label=f"Blender scene created successfully (attempt {attempt})", state="complete")
+                        st.text_area("Blender output", r1.stdout + r1.stderr, height=150)
+                        logger.info("Blender script execution completed successfully")
+                        break
+                    except subprocess.TimeoutExpired:
+                        st.error(f"Blender process timed out after 5 minutes (attempt {attempt}/{max_retries}).")
+                        logger.error(f"Blender timeout on attempt {attempt}")
+                        if attempt == max_retries:
+                            st.stop()
+                    except subprocess.CalledProcessError as e:
+                        st.error(f"Blender build failed with error code {e.returncode} (attempt {attempt}/{max_retries})")
+                        st.text_area("Error details", e.stdout + e.stderr, height=150)
+                        logger.error(f"Blender error on attempt {attempt}: {e.returncode}")
+                        logger.debug(f"Blender stderr: {e.stderr}")
+                        
+                        # If it's the last attempt, stop execution
+                        if attempt == max_retries:
+                            st.stop()
+                    except Exception as e:
+                        st.error(f"Blender build failed: {str(e)} (attempt {attempt}/{max_retries})")
+                        logger.error(f"Unexpected error on attempt {attempt}: {str(e)}")
+                        if attempt == max_retries:
+                            st.stop()
+            
+            # Check if blend file was created with better diagnostics
+            if not os.path.exists(blend_path):
+                st.error("Blender did not create the expected scene.blend file.")
+                logger.error(f"Blend file not found at {blend_path}")
+                
+                # Check directory contents for troubleshooting
+                dir_contents = os.listdir(tmp_dir)
+                logger.info(f"Temporary directory contents: {dir_contents}")
+                st.info(f"Temporary directory contents: {', '.join(dir_contents)}")
+                
+                # Try an alternative approach by writing a minimal script just to save a file
+                st.warning("Attempting alternative approach to create .blend file...")
+                logger.info("Trying alternative approach with minimal script")
+                
+                minimal_script_path = os.path.join(tmp_dir, "minimal_save.py")
+                with open(minimal_script_path, "w") as f:
+                    f.write(f"""
+import bpy
+import os
+
+# Make sure the directory exists
+os.makedirs(r'{tmp_dir}', exist_ok=True)
+
+# Create a simple cube
+bpy.ops.mesh.primitive_cube_add(size=1, location=(0, 0, 0))
+
+# Save the file
+blend_path = r'{blend_path}'
+print(f"Saving to {{blend_path}}")
+bpy.ops.wm.save_as_mainfile(filepath=blend_path, check_existing=False)
+print(f"Save operation completed, checking if file exists: {{os.path.exists(blend_path)}}")
+""")
+                
                 try:
-                    r1 = subprocess.run(
-                        cmd1,
+                    cmd_min = [blender_path, "--background", "--python", minimal_script_path]
+                    r_min = subprocess.run(
+                        cmd_min,
                         cwd=tmp_dir,
                         env=env,
                         check=True,
                         capture_output=True,
                         text=True,
-                        timeout=180  # 3 minute timeout
+                        timeout=120
                     )
-                    status.update(label="Blender scene created successfully", state="complete")
-                    st.text_area("Blender output", r1.stdout + r1.stderr, height=150)
-                except subprocess.TimeoutExpired:
-                    st.error("Blender process timed out after 3 minutes.")
-                    st.stop()
-                except subprocess.CalledProcessError as e:
-                    st.error(f"Blender build failed with error code {e.returncode}")
-                    st.text_area("Error details", e.stdout + e.stderr, height=150)
-                    st.stop()
+                    st.text_area("Minimal script output", r_min.stdout + r_min.stderr, height=150)
+                    logger.info("Minimal script execution completed")
+                    
+                    if os.path.exists(blend_path):
+                        st.success("Alternative approach created a .blend file successfully!")
+                        logger.info("Alternative approach succeeded")
+                    else:
+                        st.error("Alternative approach also failed to create .blend file.")
+                        logger.error("Alternative approach failed")
+                        st.stop()
                 except Exception as e:
-                    st.error(f"Blender build failed: {str(e)}")
+                    st.error(f"Alternative approach failed: {str(e)}")
+                    logger.error(f"Alternative approach error: {str(e)}")
                     st.stop()
-            
-            # Check if blend file was created
-            if not os.path.exists(blend_path):
-                st.error("Blender did not create the expected scene.blend file.")
-                st.info("This might be due to an issue with the script or Blender configuration.")
-                st.stop()
                 
-            # 6) Export GLB with animation
+            # 6) Export GLB with animation - enhanced error handling
             glb_path = os.path.join(tmp_dir, "animation.glb")
             
             with st.status("Exporting to GLB format...") as status:
@@ -408,19 +617,57 @@ if st.sidebar.button("Run & Export GLB"):
                     f.write(f"""
 import bpy
 import os
+import sys
 
-# Load the blend file
-bpy.ops.wm.open_mainfile(filepath=r'{blend_path}')
-
-# Export to GLB
-bpy.ops.export_scene.gltf(
-    filepath=r'{glb_path}',
-    export_format='GLB',
-    export_animations=True
-)
+# Print debug info
+print(f"Python version: {{sys.version}}")
+print(f"Blender version: {{bpy.app.version_string}}")
+print(f"Attempting to load blend file: {blend_path}")
+print(f"Current working directory: {{os.getcwd()}}")
+print(f"File exists check: {{os.path.exists(r'{blend_path}')}}") 
+
+try:
+    # Load the blend file
+    bpy.ops.wm.open_mainfile(filepath=r'{blend_path}')
+    print("Blend file loaded successfully")
+    
+    # Export to GLB
+    glb_path = r'{glb_path}'
+    print(f"Exporting to GLB: {{glb_path}}")
+    
+    # Check if glTF export is available
+    if hasattr(bpy.ops.export_scene, 'gltf'):
+        bpy.ops.export_scene.gltf(
+            filepath=glb_path,
+            export_format='GLB',
+            export_animations=True
+        )
+        print(f"GLB export completed, file exists: {{os.path.exists(glb_path)}}")
+    else:
+        print("ERROR: glTF export operator not available. Check if the add-on is enabled.")
+        # Try to enable the addon
+        bpy.ops.preferences.addon_enable(module='io_scene_gltf2')
+        print("Attempted to enable glTF add-on")
+        
+        # Try export again
+        if hasattr(bpy.ops.export_scene, 'gltf'):
+            bpy.ops.export_scene.gltf(
+                filepath=glb_path,
+                export_format='GLB',
+                export_animations=True
+            )
+            print(f"GLB export completed after enabling add-on")
+        else:
+            print("ERROR: Could not enable glTF export add-on")
+except Exception as e:
+    print(f"ERROR during export: {{str(e)}}")
+    import traceback
+    traceback.print_exc()
 """)
                 
                 cmd2 = [blender_path, "--background", "--python", export_script]
+                logger.info(f"Running GLB export command: {' '.join(cmd2)}")
+                
                 try:
                     r2 = subprocess.run(
                         cmd2,
@@ -429,12 +676,14 @@ bpy.ops.export_scene.gltf(
                         check=True,
                         capture_output=True,
                         text=True,
-                        timeout=120  # 2 minute timeout
+                        timeout=180  # 3 minute timeout
                     )
                     status.update(label="GLB export completed successfully", state="complete")
                     st.text_area("Export output", r2.stdout + r2.stderr, height=100)
+                    logger.info("GLB export completed successfully")
                 except Exception as e:
                     st.error(f"GLB export failed: {str(e)}")
+                    logger.error(f"GLB export error: {str(e)}")
                     st.stop()
 
             # 7) Embed GLB inline if it exists
@@ -444,10 +693,12 @@ bpy.ops.export_scene.gltf(
                 
                 file_size = len(data) / (1024 * 1024)  # Size in MB
                 st.success(f"Successfully created GLB file ({file_size:.1f} MB)")
+                logger.info(f"Created GLB file, size: {file_size:.1f} MB")
                 
                 # Check if file isn't too large for embedding
                 if file_size > 50:
                     st.warning("The GLB file is quite large. The viewer might be slow to load.")
+                    logger.warning(f"Large GLB file: {file_size:.1f} MB")
                 
                 b64 = base64.b64encode(data).decode()
                 
@@ -476,15 +727,24 @@ bpy.ops.export_scene.gltf(
                 )
             else:
                 st.error("GLB file was not generated successfully.")
+                logger.error(f"GLB file not found at {glb_path}")
+                
                 if os.path.exists(blend_path):
                     st.info("The Blender file was created, but the GLB export failed.")
+                    logger.info("Blend file exists but GLB export failed")
                 
         finally:
-            # Clean up - remove temporary directory
-            try:
-                shutil.rmtree(tmp_dir, ignore_errors=True)
-            except Exception as e:
-                st.warning(f"Failed to clean up temporary files: {str(e)}")
+            # Clean up - remove temporary directory if not in debug mode
+            if IS_HUGGINGFACE and debug_mode:
+                st.info(f"Debug mode: Temporary files kept at {tmp_dir}")
+                logger.info(f"Keeping temp files for debugging: {tmp_dir}")
+            else:
+                try:
+                    shutil.rmtree(tmp_dir, ignore_errors=True)
+                    logger.info(f"Cleaned up temporary directory: {tmp_dir}")
+                except Exception as e:
+                    st.warning(f"Failed to clean up temporary files: {str(e)}")
+                    logger.error(f"Cleanup error: {str(e)}")
 
 # Add helpful information at the bottom
 st.divider()
@@ -497,8 +757,11 @@ with st.expander("About this app"):
     - Generate and visualize 3D models with animations
     - Download the results as GLB files for use in other applications
     
-    The app automatically adds necessary imports (`import os`) and file saving code to your scripts,
+    The app automatically adds necessary imports and file saving code to your scripts,
     so you can focus on creating 3D content without worrying about environment details.
+    
+    Running on Hugging Face Spaces: This app requires Blender to be installed. Make sure
+    your Space includes 'blender' in the apt.txt file.
     """)
     
 with st.expander("Script Tips"):
@@ -525,4 +788,37 @@ with st.expander("Script Tips"):
     obj.rotation_euler = (0, 0, math.radians(360))
     obj.keyframe_insert(data_path="rotation_euler", frame=250)
     ```
+    
+    4. **Troubleshooting in Hugging Face**: If you're having issues with the app in Hugging Face Spaces:
+    
+    - Enable Debug Mode in the sidebar
+    - Check the error messages in the app output
+    - Make sure your apt.txt file includes 'blender'
+    - Try the "Simple Cube (Test)" example first to verify Blender is working
+    """)
+
+# Add a section at the bottom for Hugging Face Spaces setup
+with st.expander("Hugging Face Spaces Setup"):
+    st.markdown("""
+    ### Setting up this app on Hugging Face Spaces
+    
+    To ensure this app works correctly on Hugging Face:
+    
+    1. **Create an apt.txt file** in your repository with:
+    ```
+    blender
+    ```
+    
+    2. **Create a requirements.txt file** with:
+    ```
+    streamlit
+    streamlit-ace
+    requests
+    ```
+    
+    3. **Set the Space SDK** to "Streamlit" in the Space settings
+    
+    4. **Set resource allocation** to at least 2 CPU + 4GB RAM for better performance
+    
+    Troubleshooting: If you encounter "Blender not found" errors, check your apt.txt file and make sure Blender is being installed correctly.
     """)