Update app.py

app.py

@@ -9,6 +9,7 @@ import time
 from pathlib import Path
 import tempfile
 import glob
+import traceback
 
 def ensure_dir(dir_path):
     """Ensure directory exists"""
@@ -18,6 +19,14 @@ def check_dependencies():
     """Check if required dependencies are available"""
     missing_deps = []
     
+    # Check for nuitka first
+    try:
+        result = subprocess.run([sys.executable, "-m", "nuitka", "--version"], capture_output=True, text=True)
+        if result.returncode != 0:
+            missing_deps.append("nuitka")
+    except:
+        missing_deps.append("nuitka")
+    
     # Check for patchelf (usually available in HF Spaces)
     result = subprocess.run(["which", "patchelf"], capture_output=True)
     if result.returncode != 0:
@@ -61,11 +70,32 @@ def get_nuitka_version():
             # Extract version number from output like "Nuitka 2.5.0"
             version = version_line.split()[-1]
             return version
-        return "unknown"
+        return "not installed"
     except:
-        return "unknown"
+        return "not installed"
 
-def install_system_packages(packages_content, progress=gr.Progress()):
+def create_progress_bar(progress, status_text="", show_percentage=True):
+    """Create an HTML progress bar"""
+    percentage = max(0, min(100, progress * 100))
+    
+    color = "bg-green-500" if percentage == 100 else ("bg-yellow-500" if percentage > 50 else "bg-blue-500")
+    
+    html = f"""
+    <div style="width: 100%; background-color: #f0f0f0; border-radius: 10px; padding: 3px; box-shadow: inset 0 2px 4px rgba(0,0,0,0.1);">
+        <div style="width: {percentage}%; background: linear-gradient(90deg, #4CAF50 0%, #45a049 100%); 
+                    height: 25px; border-radius: 8px; transition: width 0.3s ease-in-out; display: flex; align-items: center; justify-content: center;">
+            <span style="color: white; font-weight: bold; font-size: 12px;">
+                {f'{percentage:.1f}%' if show_percentage else ''}
+            </span>
+        </div>
+    </div>
+    <div style="margin-top: 8px; text-align: center; color: #333; font-size: 14px; font-weight: 500;">
+        {status_text}
+    </div>
+    """
+    return html
+
+def install_system_packages(packages_content, progress_callback=None):
     """Note about system packages in HF Spaces - they cannot be installed"""
     if not packages_content.strip():
         return "No system packages specified."
@@ -78,6 +108,26 @@ def install_system_packages(packages_content, progress=gr.Progress()):
         return f"❌ System packages cannot be installed in Hugging Face Spaces:\n{', '.join(packages_list)}\n\nℹ️ HF Spaces runs in a containerized environment without sudo access.\nThese packages need to be pre-installed in the Docker image or available as Python packages."
     return "No system packages specified."
 
+def install_nuitka_if_missing():
+    """Try to install Nuitka if it's missing"""
+    try:
+        # Check if nuitka is already installed
+        result = subprocess.run([sys.executable, "-m", "nuitka", "--version"], capture_output=True)
+        if result.returncode == 0:
+            return True, "Nuitka is already installed"
+        
+        # Try to install nuitka
+        print("Installing Nuitka...")
+        result = subprocess.run([sys.executable, "-m", "pip", "install", "nuitka"], 
+                              capture_output=True, text=True)
+        
+        if result.returncode == 0:
+            return True, "Nuitka installed successfully"
+        else:
+            return False, f"Failed to install Nuitka: {result.stderr}"
+    except Exception as e:
+        return False, f"Error installing Nuitka: {str(e)}"
+
 def find_compiled_binary(output_dir, output_filename):
     """Find the compiled binary, checking different possible paths"""
     # Try direct path first
@@ -105,65 +155,94 @@ def find_compiled_binary(output_dir, output_filename):
     
     return None
 
-def compile_with_nuitka(code, requirements, packages, compilation_mode, output_extension, progress=gr.Progress()):
+def compile_with_nuitka(code, requirements, packages, compilation_mode, output_extension, progress_callback=None):
     """Compile Python code with Nuitka"""
-    progress(0, desc="Starting compilation process...")
-    
-    # Check Nuitka version
-    nuitka_version = get_nuitka_version()
-    
-    # Check if static libpython is available
-    has_static_libpython = check_static_libpython()
-    
-    # Check dependencies first
-    missing_deps = check_dependencies()
-    
-    # Create unique ID for this compilation
-    job_id = str(uuid.uuid4())
-    base_dir = os.path.join(os.getcwd(), "user_code")
-    job_dir = os.path.join(base_dir, job_id)
-    output_dir = os.path.join(os.getcwd(), "compiled_output", job_id)
-    
-    # Create directories
-    ensure_dir(job_dir)
-    ensure_dir(output_dir)
-    
-    progress(0.1, desc="Processing packages...")
-    
-    # Handle system packages (just log them, can't install in HF Spaces)
-    packages_result = install_system_packages(packages, progress)
-    
-    # Write code to a Python file
-    script_path = os.path.join(job_dir, "user_script.py")
-    with open(script_path, "w") as f:
-        f.write(code)
-    
-    # Handle requirements
-    install_result = "No Python requirements specified."
-    if requirements.strip():
-        req_path = os.path.join(job_dir, "requirements.txt")
-        with open(req_path, "w") as f:
-            f.write(requirements)
-        
-        try:
-            progress(0.2, desc="Installing Python requirements...")
-            install_process = subprocess.run(
-                [sys.executable, "-m", "pip", "install", "--no-cache-dir", "-r", req_path],
-                capture_output=True,
-                text=True
-            )
-            
-            if install_process.returncode == 0:
-                install_result = "✅ Python requirements installed successfully."
-            else:
-                install_result = f"⚠️ Installation completed with warnings. Return code: {install_process.returncode}\n{install_process.stderr}"
-        except Exception as e:
-            install_result = f"❌ Error installing requirements: {str(e)}"
-            return install_result, None, f"Error: {str(e)}", False
-    
-    # Compilation
     try:
-        progress(0.3, desc="Starting compilation...")
+        # Initialize progress
+        if progress_callback:
+            progress_callback(0, "Starting compilation process...")
+        
+        # Check if Nuitka is installed
+        nuitka_installed, nuitka_msg = install_nuitka_if_missing()
+        if not nuitka_installed:
+            error_summary = f"""# ❌ Nuitka Not Available
+
+## Error:
+{nuitka_msg}
+
+## Solution:
+Nuitka needs to be installed first. In Hugging Face Spaces, this should be done in the requirements.txt file:
+
+```
+nuitka
+```
+
+Add this to your requirements.txt and redeploy the space."""
+            return error_summary, None, nuitka_msg, False
+        
+        if progress_callback:
+            progress_callback(0.05, "Checking environment...")
+        
+        # Check Nuitka version
+        nuitka_version = get_nuitka_version()
+        
+        # Check if static libpython is available
+        has_static_libpython = check_static_libpython()
+        
+        # Check dependencies first
+        missing_deps = check_dependencies()
+        
+        if progress_callback:
+            progress_callback(0.1, "Setting up compilation directories...")
+        
+        # Create unique ID for this compilation
+        job_id = str(uuid.uuid4())
+        base_dir = os.path.join(os.getcwd(), "user_code")
+        job_dir = os.path.join(base_dir, job_id)
+        output_dir = os.path.join(os.getcwd(), "compiled_output", job_id)
+        
+        # Create directories
+        ensure_dir(job_dir)
+        ensure_dir(output_dir)
+        
+        if progress_callback:
+            progress_callback(0.15, "Processing packages...")
+        
+        # Handle system packages (just log them, can't install in HF Spaces)
+        packages_result = install_system_packages(packages)
+        
+        # Write code to a Python file
+        script_path = os.path.join(job_dir, "user_script.py")
+        with open(script_path, "w") as f:
+            f.write(code)
+        
+        if progress_callback:
+            progress_callback(0.2, "Installing Python requirements...")
+        
+        # Handle requirements
+        install_result = "No Python requirements specified."
+        if requirements.strip():
+            req_path = os.path.join(job_dir, "requirements.txt")
+            with open(req_path, "w") as f:
+                f.write(requirements)
+            
+            try:
+                install_process = subprocess.run(
+                    [sys.executable, "-m", "pip", "install", "--no-cache-dir", "-r", req_path],
+                    capture_output=True,
+                    text=True
+                )
+                
+                if install_process.returncode == 0:
+                    install_result = "✅ Python requirements installed successfully."
+                else:
+                    install_result = f"⚠️ Installation completed with warnings. Return code: {install_process.returncode}\n{install_process.stderr}"
+            except Exception as e:
+                install_result = f"❌ Error installing requirements: {str(e)}"
+                return install_result, None, f"Error: {str(e)}", False
+        
+        if progress_callback:
+            progress_callback(0.3, "Building compilation command...")
         
         # Build compilation command based on mode
         if compilation_mode == "Maximum Compatibility (Recommended)":
@@ -216,6 +295,9 @@ def compile_with_nuitka(code, requirements, packages, compilation_mode, output_e
             mode_name = "Standalone Binary"
         
         # Run compilation
+        if progress_callback:
+            progress_callback(0.4, "Executing Nuitka compilation...")
+        
         process = subprocess.Popen(
             cmd,
             stdout=subprocess.PIPE,
@@ -235,15 +317,25 @@ def compile_with_nuitka(code, requirements, packages, compilation_mode, output_e
             line_count += 1
             
             # Update progress
-            progress_val = 0.3 + (min(line_count / 200, 0.69) * 0.7)
+            progress_val = 0.4 + (min(line_count / 200, 0.55) * 0.5)
+            status_text = "Compiling..."
+            
             if "INFO:" in line:
-                progress(progress_val, desc=f"Compiling: {line.strip()[:50]}...")
-            else:
-                progress(progress_val, desc="Compiling...")
+                status_text = f"INFO: {line.strip()[:60]}..."
+            elif "PROCESSING" in line:
+                status_text = f"Processing: {line.strip()[:60]}..."
+            elif "Optimizing" in line:
+                status_text = f"Optimizing: {line.strip()[:60]}..."
+            elif "Creating" in line:
+                status_text = f"Creating: {line.strip()[:60]}..."
+            
+            if progress_callback:
+                progress_callback(progress_val, status_text)
         
         process.wait()
         
-        progress(0.9, desc="Finalizing...")
+        if progress_callback:
+            progress_callback(0.9, "Finalizing compilation...")
         
         # Find the compiled binary
         output_filename = f"user_script{output_extension}"
@@ -305,7 +397,7 @@ def compile_with_nuitka(code, requirements, packages, compilation_mode, output_e
             file_size = os.path.getsize(binary_path) / 1024
             binary_basename = os.path.basename(binary_path)
             
-            # Create result summary without f-string to avoid syntax issues
+            # Create result summary
             result_summary = f"""# ✅ Compilation Successful!
 
 ## Compilation Details:
@@ -344,9 +436,11 @@ This binary was compiled in a Hugging Face Spaces environment. For best results:
 2. Make it executable: `chmod +x filename`
 3. Run it in a compatible Linux environment"""
             
-            progress(1.0, desc="Compilation successful!")
+            if progress_callback:
+                progress_callback(1.0, "Compilation successful! 🎉")
             return result_summary, binary_path, compile_output, True
         else:
+            # Add more detailed error information
             error_summary = f"""# ❌ Compilation Failed
 
 ## Error Details:
@@ -357,26 +451,54 @@ This binary was compiled in a Hugging Face Spaces environment. For best results:
 **System Packages**: {packages_result}
 **Python Requirements**: {install_result}
 
+## Compilation Output:
+```
+{compile_output}
+```
+
 ## Possible Solutions:
 1. Check your code for syntax errors
-2. Ensure all imports are available
+2. Ensure all imports are available in requirements.txt
 3. Try a different compilation mode
-4. Review the compilation logs below
+4. Review the compilation logs above
 
 ## Missing Dependencies:
-{', '.join(missing_deps) if missing_deps else 'None detected'}"""
+{', '.join(missing_deps) if missing_deps else 'None detected'}
+
+## Environment Info:
+- **Nuitka Version**: {nuitka_version}
+- **Python Version**: {current_python}
+- **Platform**: {platform.platform()}"""
+            if progress_callback:
+                progress_callback(1.0, "Compilation failed ❌")
             return error_summary, None, compile_output, False
         
     except Exception as e:
+        # Provide detailed error information
+        error_trace = traceback.format_exc()
         error_summary = f"""# ❌ Compilation Error
 
 ## Error:
 {str(e)}
 
-## Environment Results:
-**System Packages**: {packages_result}
-**Python Requirements**: {install_result}"""
-        return error_summary, None, f"Error: {str(e)}", False
+## Full Error Trace:
+```
+{error_trace}
+```
+
+## Environment Status:
+- **Nuitka Version**: {get_nuitka_version()}
+- **Python Version**: {get_current_python_version()}
+- **Working Directory**: {os.getcwd()}
+
+## Troubleshooting Steps:
+1. Check if Nuitka is properly installed
+2. Verify your code syntax
+3. Check available disk space
+4. Try with simpler code first"""
+        if progress_callback:
+            progress_callback(1.0, "Error occurred ❌")
+        return error_summary, None, f"Error: {str(e)}\n\n{error_trace}", False
 
 def run_compiled_binary(binary_path):
     """Run the compiled binary and return the output"""
@@ -424,13 +546,16 @@ with gr.Blocks(title="Nuitka Python Compiler for HF Spaces", theme=gr.themes.Sof
     has_static = check_static_libpython()
     missing_deps = check_dependencies()
     
+    if "nuitka" in missing_deps:
+        gr.Markdown("⚠️ **Nuitka is not installed!** Add 'nuitka' to your requirements.txt file.")
+    
     if has_static:
         gr.Markdown("🎯 **Static Libpython Available!** Maximum portability enabled.")
     else:
         gr.Markdown("🔧 **Using alternative portable options.** Static libpython not available.")
     
-    if missing_deps:
-        gr.Markdown(f"⚠️ **Missing dependencies:** {', '.join(missing_deps)}")
+    if [dep for dep in missing_deps if dep != "nuitka"]:
+        gr.Markdown(f"⚠️ **Missing dependencies:** {', '.join([dep for dep in missing_deps if dep != 'nuitka'])}")
     else:
         gr.Markdown("✅ **All required dependencies available!**")
     
@@ -509,6 +634,8 @@ print(f'Hello, {name}!')""",
                     )
                     
                     gr.Markdown(f"📍 **Compiling with Python {get_current_python_version()}**")
+                    gr.Markdown(f"🔧 **Nuitka Version**: {get_nuitka_version()}")
+                    
                     if check_static_libpython():
                         gr.Markdown("🔗 **Static libpython will be used!**")
                     else:
@@ -516,6 +643,11 @@ print(f'Hello, {name}!')""",
                     
                     compile_btn = gr.Button("🚀 Compile with Nuitka", variant="primary")
             
+            # Progress Bar Section
+            with gr.Column(visible=False) as progress_section:
+                gr.Markdown("### 📊 Compilation Progress")
+                progress_bar = gr.HTML(create_progress_bar(0, "Ready to compile..."))
+            
             # Results section
             with gr.Column(visible=False) as results_section:
                 with gr.Accordion("📊 Compilation Results", open=True):
@@ -533,33 +665,149 @@ print(f'Hello, {name}!')""",
             current_binary_path = gr.State(None)
             compilation_success = gr.State(False)
             
-            def handle_compilation(code, requirements, packages, mode, extension, progress=gr.Progress()):
-                summary, binary_path, logs, success = compile_with_nuitka(
-                    code, requirements, packages, mode, extension, progress
-                )
-                
-                if success and binary_path:
-                    # Create download file
-                    download_filename = f"compiled_program{extension}"
-                    download_path = os.path.join(os.path.dirname(binary_path), download_filename)
-                    shutil.copy2(binary_path, download_path)
+            def update_progress_display(progress, status):
+                """Update the progress bar display"""
+                return gr.update(value=create_progress_bar(progress, status))
+            
+            def handle_compilation(code, requirements, packages, mode, extension):
+                try:
+                    # Show progress section
+                    yield (
+                        gr.update(visible=True),  # progress_section
+                        gr.update(value=create_progress_bar(0, "Initializing compilation...")),  # progress_bar
+                        gr.update(visible=False),  # results_section (hide initially)
+                        gr.update(),  # result_summary
+                        gr.update(),  # compile_logs
+                        gr.update(visible=False),  # download_file
+                        None,  # current_binary_path
+                        False  # compilation_success
+                    )
+                    
+                    # Define progress callback
+                    def progress_callback(progress, status):
+                        # This will be called by compile_with_nuitka to update progress
+                        pass
+                    
+                    # Start compilation with manual progress updates
+                    compilation_started = False
+                    
+                    # Step 1: Initial checks
+                    yield (
+                        gr.update(visible=True),  # progress_section
+                        gr.update(value=create_progress_bar(0.1, "Checking Nuitka installation...")),  # progress_bar
+                        gr.update(visible=False),  # results_section
+                        gr.update(),  # result_summary
+                        gr.update(),  # compile_logs
+                        gr.update(visible=False),  # download_file
+                        None,  # current_binary_path
+                        False  # compilation_success
+                    )
                     
-                    return (
+                    # Step 2: Environment setup
+                    yield (
+                        gr.update(visible=True),  # progress_section
+                        gr.update(value=create_progress_bar(0.2, "Setting up environment...")),  # progress_bar
+                        gr.update(visible=False),  # results_section
+                        gr.update(),  # result_summary
+                        gr.update(),  # compile_logs
+                        gr.update(visible=False),  # download_file
+                        None,  # current_binary_path
+                        False  # compilation_success
+                    )
+                    
+                    # Step 3: Installing requirements
+                    yield (
+                        gr.update(visible=True),  # progress_section
+                        gr.update(value=create_progress_bar(0.3, "Installing requirements...")),  # progress_bar
+                        gr.update(visible=False),  # results_section
+                        gr.update(),  # result_summary
+                        gr.update(),  # compile_logs
+                        gr.update(visible=False),  # download_file
+                        None,  # current_binary_path
+                        False  # compilation_success
+                    )
+                    
+                    # Step 4: Compilation in progress
+                    for i in range(4, 9):
+                        yield (
+                            gr.update(visible=True),  # progress_section
+                            gr.update(value=create_progress_bar(i/10, "Compiling with Nuitka...")),  # progress_bar
+                            gr.update(visible=False),  # results_section
+                            gr.update(),  # result_summary
+                            gr.update(),  # compile_logs
+                            gr.update(visible=False),  # download_file
+                            None,  # current_binary_path
+                            False  # compilation_success
+                        )
+                        time.sleep(0.5)  # Small delay to show progress
+                    
+                    # Run the actual compilation
+                    summary, binary_path, logs, success = compile_with_nuitka(
+                        code, requirements, packages, mode, extension
+                    )
+                    
+                    # Final progress update
+                    yield (
+                        gr.update(visible=True),  # progress_section
+                        gr.update(value=create_progress_bar(1.0, "Compilation complete!" if success else "Compilation failed")),  # progress_bar
                         gr.update(visible=True),  # results_section
                         gr.update(value=summary),  # result_summary
-                        gr.update(value=logs),     # compile_logs
-                        gr.update(value=download_path),  # download_file
-                        binary_path,  # current_binary_path state
-                        True  # compilation_success state
+                        gr.update(value=logs),  # compile_logs
+                        gr.update(visible=False),  # download_file (initially hidden)
+                        None,  # current_binary_path
+                        False  # compilation_success
                     )
-                else:
-                    return (
+                    
+                    if success and binary_path:
+                        # Create download file
+                        download_filename = f"compiled_program{extension}"
+                        download_path = os.path.join(os.path.dirname(binary_path), download_filename)
+                        shutil.copy2(binary_path, download_path)
+                        
+                        # Final update with download file
+                        yield (
+                            gr.update(visible=True),  # progress_section
+                            gr.update(value=create_progress_bar(1.0, "✅ Compilation successful! Ready to download.")),  # progress_bar
+                            gr.update(visible=True),  # results_section
+                            gr.update(value=summary),  # result_summary
+                            gr.update(value=logs),  # compile_logs
+                            gr.update(value=download_path, visible=True),  # download_file
+                            binary_path,  # current_binary_path
+                            True  # compilation_success
+                        )
+                    else:
+                        # Final update for failure
+                        yield (
+                            gr.update(visible=True),  # progress_section
+                            gr.update(value=create_progress_bar(1.0, "❌ Compilation failed. Check logs for details.")),  # progress_bar
+                            gr.update(visible=True),  # results_section
+                            gr.update(value=summary),  # result_summary
+                            gr.update(value=logs),  # compile_logs
+                            gr.update(visible=False),  # download_file
+                            None,  # current_binary_path
+                            False  # compilation_success
+                        )
+                        
+                except Exception as e:
+                    error_trace = traceback.format_exc()
+                    error_summary = f"""# ❌ Unexpected Error in Compilation Handler
+
+## Error:
+{str(e)}
+
+## Full Trace:
+```
+{error_trace}
+```"""
+                    yield (
+                        gr.update(visible=True),  # progress_section
+                        gr.update(value=create_progress_bar(1.0, "❌ Error occurred during compilation")),  # progress_bar
                         gr.update(visible=True),  # results_section
-                        gr.update(value=summary),  # result_summary
-                        gr.update(value=logs),     # compile_logs
+                        gr.update(value=error_summary),  # result_summary
+                        gr.update(value=f"Error: {str(e)}"),  # compile_logs
                         gr.update(visible=False),  # download_file
-                        None,  # current_binary_path state
-                        False  # compilation_success state
+                        None,  # current_binary_path
+                        False  # compilation_success
                     )
             
             def handle_run(binary_path):
@@ -572,7 +820,7 @@ print(f'Hello, {name}!')""",
             compile_btn.click(
                 handle_compilation,
                 inputs=[code_input, requirements_input, packages_input, compilation_mode, output_extension],
-                outputs=[results_section, result_summary, compile_logs, download_file, current_binary_path, compilation_success]
+                outputs=[progress_section, progress_bar, results_section, result_summary, compile_logs, download_file, current_binary_path, compilation_success]
             )
             
             run_btn.click(
@@ -606,6 +854,7 @@ print(f'Hello, {name}!')""",
             
             ### 3. Compile
             - Click "Compile with Nuitka"
+            - Watch the progress bar for compilation status
             - Wait for the compilation to complete
             - Download the resulting binary
             
@@ -630,6 +879,14 @@ print(f'Hello, {name}!')""",
             - Compilation happens in a containerized environment
             - Binary execution may have resource limits
             
+            ## 📋 Important Requirements
+            
+            For this app to work in HF Spaces, ensure your `requirements.txt` includes:
+            ```
+            gradio
+            nuitka
+            ```
+            
             ## 📊 Compilation Modes Comparison
             
             | Mode | Size | Portability | Speed | Best For |
@@ -650,6 +907,7 @@ print(f'Hello, {name}!')""",
             3. **Fallback Strategy**: Ensures compilation succeeds even without static linking
             4. **Automatic Dependencies**: Resolves missing dependencies automatically
             5. **HF Spaces Optimization**: Adapted for Hugging Face Spaces environment
+            6. **Real-time Progress**: Shows compilation progress with a visual progress bar
             
             This approach maximizes compatibility across different Python environments while working within HF Spaces constraints.
             
@@ -663,6 +921,7 @@ print(f'Hello, {name}!')""",
             - ✅ WSL compatibility issues
             - ✅ Dependency resolution
             - ✅ Cross-environment portability
+            - ✅ Real-time compilation feedback
             
             ## ☁️ Current Environment Status
             
@@ -686,6 +945,8 @@ print(f'Hello, {name}!')""",
             4. ✅ Let the app automatically choose the best settings
             5. ✅ Check the compilation details for specific optimizations used
             6. ✅ Avoid system packages that require installation
+            7. ✅ Include 'nuitka' in your requirements.txt for HF Spaces
+            8. ✅ Watch the progress bar for compilation status
             
             ## 🔧 Troubleshooting
             
@@ -695,6 +956,8 @@ print(f'Hello, {name}!')""",
             - **Binary won't run**: Ensure you're on a compatible Linux system
             - **Permission denied**: Run `chmod +x filename` before execution
             - **Missing libraries**: Try "Maximum Compatibility" mode
+            - **Nothing happens on click**: Check that Nuitka is installed in requirements.txt
+            - **Compilation stuck**: Check the progress bar and logs for details
             
             ## 🚀 Future Improvements
             
@@ -702,6 +965,7 @@ print(f'Hello, {name}!')""",
             - Better error messages and diagnostics
             - Automatic dependency detection
             - Cross-platform compilation support
+            - Enhanced progress tracking
             """)
     
     gr.Markdown("---")
@@ -711,4 +975,9 @@ if __name__ == "__main__":
     # Create necessary directories on startup
     ensure_dir("user_code")
     ensure_dir("compiled_output")
+    
+    # Check if Nuitka is available
+    if "nuitka" in check_dependencies():
+        print("WARNING: Nuitka is not installed. Please add 'nuitka' to your requirements.txt file.")
+    
     app.launch()