Update app.py

app.py

@@ -2,97 +2,54 @@ import gradio as gr
 import os
 import zipfile
 from pathlib import Path
+import shutil
 import urllib.parse
 
 # Define paths
 ZIP_FILE = "nes.zip"
-EXTRACTED_FOLDER = "nes"  # Directory to serve extracted ROMs
+EXTRACTED_FOLDER = "extracted_nes"
+PUBLIC_FOLDER = "public/roms"  # <-- Important!
 
-# Ensure extraction directory exists
-os.makedirs(EXTRACTED_FOLDER, exist_ok=True)
+# Ensure public ROM folder exists
+os.makedirs(PUBLIC_FOLDER, exist_ok=True)
 
 def extract_roms():
     """
-    Extract ROM files from a zip archive into an extracted folder.
-    
-    Raises:
-        FileNotFoundError: If the zip file is missing or not found in the current directory.
-        PermissionError: When attempting to write data somewhere without sufficient permissions.
-        
-    Returns:
-        list: A list of paths for extracted ROMs.
+    Extract ROM files from the uploaded zip and move them into public/roms/ folder.
     """
     try:
         if os.path.exists(ZIP_FILE):
             with zipfile.ZipFile(ZIP_FILE, 'r') as zip_ref:
-                for file in zip_ref.namelist():
-                    # Ignore special files that do not contain actual data
-                    if not file.startswith("__MACOSX/"):
-                        zip_ref.extract(file, EXTRACTED_FOLDER)
-                        extracted_path = os.path.join(EXTRACTED_FOLDER, file)
-                        print(f"Extracted: {extracted_path}")  
+                zip_ref.extractall(EXTRACTED_FOLDER)
+                print(f"Extracted into {EXTRACTED_FOLDER}")
+
+            # Move all .nes files into public/roms/
+            for root, dirs, files in os.walk(EXTRACTED_FOLDER):
+                for file in files:
+                    if file.lower().endswith(".nes"):
+                        source_path = os.path.join(root, file)
+                        target_path = os.path.join(PUBLIC_FOLDER, file)
+                        shutil.move(source_path, target_path)
+                        print(f"Moved ROM: {file} -> {target_path}")
         else:
-            raise FileNotFoundError("Error: `nes.zip` is missing. Please upload it to the root directory.")
-    
+            raise FileNotFoundError("`nes.zip` not found. Please upload it.")
     except PermissionError as e:
-        # Handle permission errors gracefully
-        print(f"Permission error encountered while extracting ROMs - {e}")
-        
-    return [str(extracted_path) for extracted_path in os.listdir(EXTRACTED_FOLDER)]
-
-def list_roms():
-    """
-    List all available ROM files and construct a dropdown menu with the file paths.
-    
-    Returns:
-        list: A list of paths to extracted ROMs, which are used as options for Gradio's dropdown input.
-        
-    Raises:
-        FileNotFoundError: If the directory containing extracted files does not exist or if `nes.zip` is missing.
-    """
-    try:
-        # Check that a directory exists where our data will be stored and download from 'nes' zip archive
-        rom_files = extract_roms()
-    
-    except FileNotFoundError as e:
-        print(f"Error: ROM folder has been removed. The program should not continue with this action - {e}")
-        
-    return [str(rom) for rom in rom_files]
-
-# Function to extract nested zip files (ROM zips)
-def extract_nested_zip(nested_zip_path):
-    with zipfile.ZipFile(nested_zip_path, 'r') as nested_zip:
-        nested_folder = os.path.splitext(nested_zip_path)[0]
-        os.makedirs(nested_folder, exist_ok=True)
-        nested_zip.extractall(nested_folder)
-        os.remove(nested_zip_path)
-        print(f"Extracted nested zip: {nested_zip_path}")
-
-# Ensure ROMs are extracted on startup
-extract_roms()
+        print(f"Permission error: {e}")
 
 # Function to list available ROMs
 def list_roms():
-    if not os.path.exists(EXTRACTED_FOLDER):
-        print("ROM folder missing.")
+    if not os.path.exists(PUBLIC_FOLDER):
+        print("No ROMs found.")
         return []
+    
+    roms = [f for f in os.listdir(PUBLIC_FOLDER) if f.endswith(".nes")]
+    print("Available ROMs:", roms)
+    return roms
 
-    # Debugging output: List all files in the directory
-    print("Listing all files in extracted folder:")
-    for root, dirs, files in os.walk(EXTRACTED_FOLDER):
-        for file in files:
-            print(f"Found file: {file}")
-
-    # Look for .nes files in all directories
-    roms = [f for f in Path(EXTRACTED_FOLDER).rglob("*.nes")]
-    print("Found ROMs:", roms)  # Debugging output
-    return [str(rom.relative_to(EXTRACTED_FOLDER)) for rom in roms]
-
-# Function to generate HTML for playing the selected ROM
+# Function to generate EmulatorJS HTML
 def generate_rom_page(rom_name):
-    rom_path = os.path.join(EXTRACTED_FOLDER, rom_name)
-    rom_url = urllib.parse.quote(rom_path.replace("\\", "/"))
-
+    rom_url = f"/roms/{urllib.parse.quote(rom_name)}"
+    
     html_content = f"""
     <html>
         <head>
@@ -104,27 +61,7 @@ def generate_rom_page(rom_name):
                 EJS_core = "nes";
                 EJS_color = "#0064ff";
                 EJS_pathtodata = "https://cdn.emulatorjs.org/stable/data/";
-                EJS_gameUrl = "/{rom_url}";  // Serve directly from local folder
-            </script>
-            <script src="https://cdn.emulatorjs.org/stable/data/loader.js"></script>
-        </head>
-        <body>
-        </body>
-    </html>
-    """
-    return html_content
-
-    <html>
-        <head>
-            <div style='width:640px;height:480px;max-width:100%'>
-                <div id='game'></div>
-            </div>
-            <script>
-                EJS_player = "#game";
-                EJS_core = "nes";
-                EJS_color = "#0064ff";
-                EJS_pathtodata = "https://cdn.emulatorjs.org/stable/data/";
-                EJS_gameUrl = "https://sudo-soldier-nes.hf.space/RETRO/{rom_url}";  // Correct ROM URL
+                EJS_gameUrl = "{rom_url}";
             </script>
             <script src="https://cdn.emulatorjs.org/stable/data/loader.js"></script>
         </head>
@@ -137,28 +74,23 @@ def generate_rom_page(rom_name):
 # Gradio App
 def gradio_app():
     with gr.Blocks(css=".gradio-dropdown { max-height: 400px; overflow-y: auto; }") as app:
-        gr.Markdown("# 🎮 Retro ROM File Server")
+        gr.Markdown("# 🎮 Play NES ROMs in Browser!")
 
-        # List available ROMs and create a button for each
         rom_files = list_roms()
 
-        # Display the available ROM files
         with gr.Column():
-            # Create dropdown with a custom CSS class
-            rom_buttons = gr.Dropdown(choices=rom_files, label="Select a ROM to Play", interactive=True, elem_id="rom-dropdown")
-            
-            output_html = gr.HTML(value="Please select a ROM to play.")
-            
-            # When a ROM is selected from the dropdown, update the HTML display with the ROM content
-            rom_buttons.change(fn=generate_rom_page, inputs=rom_buttons, outputs=output_html)
+            rom_dropdown = gr.Dropdown(choices=rom_files, label="Select a ROM", interactive=True)
+            output_html = gr.HTML(value="Select a ROM to start playing!")
+
+            rom_dropdown.change(fn=generate_rom_page, inputs=rom_dropdown, outputs=output_html)
 
-            # Apply the content directly to the HTML
-            output_html.value = output_html.value
+    app.launch(server_name="0.0.0.0", server_port=7860)
 
-    app.launch(server_name="0.0.0.0", server_port=7860, share=True)
+# Run on startup
+if __name__ == "__main__":
+    extract_roms()
+    gradio_app()
 
-# Run Gradio app
-gradio_app()