Update app.py

app.py

@@ -323,4 +323,392 @@ def compile_with_nuitka(code, requirements, packages, compilation_mode, output_e
 **Python Requirements**: {install_result}
 
 ## Binary Information:
-{binary_info}
+{binary_info}
+
+## 🚀 Portability Notes:
+- This binary was compiled with maximum compatibility settings
+- Using --onefile for single-file distribution
+- Added --assume-yes-for-downloads for automatic dependency resolution
+- Used --python-flag=no_site to reduce system dependencies
+- Should work on most compatible Linux systems
+
+## 📋 Usage Instructions:
+```bash
+chmod +x {binary_basename}
+./{binary_basename}
+```
+
+## ⚠️ HF Spaces Notice:
+This binary was compiled in a Hugging Face Spaces environment. For best results:
+1. Download the binary to your local system
+2. Make it executable: `chmod +x filename`
+3. Run it in a compatible Linux environment"""
+            
+            progress(1.0, desc="Compilation successful!")
+            return result_summary, binary_path, compile_output, True
+        else:
+            error_summary = f"""# ❌ Compilation Failed
+
+## Error Details:
+- **Exit Code**: {process.returncode}
+- **Mode Attempted**: {mode_name}
+
+## Environment Results:
+**System Packages**: {packages_result}
+**Python Requirements**: {install_result}
+
+## Possible Solutions:
+1. Check your code for syntax errors
+2. Ensure all imports are available
+3. Try a different compilation mode
+4. Review the compilation logs below
+
+## Missing Dependencies:
+{', '.join(missing_deps) if missing_deps else 'None detected'}"""
+            return error_summary, None, compile_output, False
+        
+    except Exception as e:
+        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
+
+def run_compiled_binary(binary_path):
+    """Run the compiled binary and return the output"""
+    if not binary_path or not os.path.exists(binary_path):
+        return "❌ No binary available to run."
+    
+    try:
+        # Make the binary executable
+        os.chmod(binary_path, 0o755)
+        
+        # Run the binary with timeout
+        process = subprocess.run(
+            [binary_path],
+            capture_output=True,
+            text=True,
+            timeout=30,  # Increased timeout for HF Spaces
+            cwd=os.path.dirname(binary_path)  # Run in binary's directory
+        )
+        
+        output = ""
+        if process.stdout:
+            output += f"## [STDOUT]\n```\n{process.stdout}\n```\n"
+        if process.stderr:
+            output += f"## [STDERR]\n```\n{process.stderr}\n```\n"
+        if process.returncode != 0:
+            output += f"## [EXIT CODE]\n{process.returncode}\n"
+        
+        if not output:
+            output = "✅ Binary executed successfully with no output."
+        else:
+            output = "## 🧪 Execution Results\n" + output
+            
+        return output
+    except subprocess.TimeoutExpired:
+        return "⏱️ **Execution timed out after 30 seconds.**\n\nThis might indicate:\n- The program is waiting for input\n- An infinite loop\n- Long-running computation"
+    except Exception as e:
+        return f"❌ **Error running the binary:**\n\n```\n{str(e)}\n```"
+
+# Create Gradio interface
+with gr.Blocks(title="Nuitka Python Compiler for HF Spaces", theme=gr.themes.Soft()) as app:
+    gr.Markdown("# 🚀 Nuitka Python Compiler (HF Spaces Edition)")
+    gr.Markdown("Convert your Python code into portable executables using Nuitka, optimized for Hugging Face Spaces.")
+    
+    # Check environment status
+    has_static = check_static_libpython()
+    missing_deps = check_dependencies()
+    
+    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)}")
+    else:
+        gr.Markdown("✅ **All required dependencies available!**")
+    
+    # HF Spaces specific notice
+    gr.Markdown("""
+    > ℹ️ **Running in Hugging Face Spaces**: System packages cannot be installed. 
+    > All required dependencies should be pre-installed in the environment.
+    """)
+    
+    with gr.Tabs():
+        with gr.TabItem("🔧 Compiler"):
+            with gr.Row():
+                with gr.Column(scale=2):
+                    code_input = gr.Code(
+                        value="""# Your Python code here
+print('Hello from compiled Python!')
+print('This is a smart-compiled binary!')
+
+# This will work with automatic compatibility detection
+import os, sys
+print(f'Running from: {os.getcwd()}')
+print(f'Python executable: {sys.executable}')
+print('Compilation was optimized for your environment!')
+
+# Simple example with user input
+name = input('What is your name? ')
+print(f'Hello, {name}!')""",
+                        language="python",
+                        label="Your Python Code",
+                        lines=20
+                    )
+                
+                with gr.Column(scale=1):
+                    with gr.Tabs():
+                        with gr.TabItem("Python Requirements"):
+                            requirements_input = gr.Textbox(
+                                placeholder="""# Add your Python dependencies here
+# Example:
+# numpy==1.24.0
+# pandas==2.0.0
+# requests>=2.28.0
+# matplotlib
+# pillow""",
+                                lines=8,
+                                label="requirements.txt content"
+                            )
+                        
+                        with gr.TabItem("System Packages"):
+                            gr.Markdown("⚠️ **System packages cannot be installed in HF Spaces**")
+                            packages_input = gr.Textbox(
+                                placeholder="""# System packages (for reference only)
+# These cannot be installed in HF Spaces
+# build-essential
+# libssl-dev
+# ffmpeg""",
+                                lines=8,
+                                label="packages.txt content (Reference Only)",
+                                interactive=True
+                            )
+                    
+                    # Fixed dropdown choices
+                    compilation_mode = gr.Dropdown(
+                        choices=[
+                            "Maximum Compatibility (Recommended)",
+                            "Portable Binary",
+                            "Standalone Binary"
+                        ],
+                        value="Maximum Compatibility (Recommended)",
+                        label="Compilation Mode"
+                    )
+                    
+                    output_extension = gr.Dropdown(
+                        choices=[".bin", ".sh"],
+                        value=".bin",
+                        label="Output File Extension"
+                    )
+                    
+                    gr.Markdown(f"📍 **Compiling with Python {get_current_python_version()}**")
+                    if check_static_libpython():
+                        gr.Markdown("🔗 **Static libpython will be used!**")
+                    else:
+                        gr.Markdown("🔧 **Using portable compilation flags**")
+                    
+                    compile_btn = gr.Button("🚀 Compile with Nuitka", variant="primary")
+            
+            # Results section
+            with gr.Column(visible=False) as results_section:
+                with gr.Accordion("📊 Compilation Results", open=True):
+                    result_summary = gr.Markdown()
+                with gr.Accordion("📜 Compilation Logs", open=False):
+                    compile_logs = gr.Textbox(label="Detailed Compilation Output", lines=15)
+                download_file = gr.File(label="📥 Download Compiled Binary")
+                
+                # Test run section
+                with gr.Row():
+                    run_btn = gr.Button("🧪 Test Run Binary", variant="secondary")
+                    run_output = gr.Markdown(label="Execution Output")
+            
+            # Variables to store state
+            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)
+                    
+                    return (
+                        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
+                    )
+                else:
+                    return (
+                        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 state
+                        False  # compilation_success state
+                    )
+            
+            def handle_run(binary_path):
+                if binary_path:
+                    output = run_compiled_binary(binary_path)
+                    return gr.update(value=output)
+                else:
+                    return gr.update(value="❌ No binary available to run.")
+            
+            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]
+            )
+            
+            run_btn.click(
+                handle_run,
+                inputs=[current_binary_path],
+                outputs=[run_output]
+            )
+        
+        with gr.TabItem("📖 How to Use"):
+            gr.Markdown("""
+            ## 🎯 Smart Compilation in HF Spaces
+            
+            **Automatic Environment Detection**
+            
+            This app automatically detects your Python environment and chooses the best compilation strategy:
+            - Uses static libpython if available (maximum portability)
+            - Falls back to highly portable alternatives if not
+            - Automatically handles missing dependencies
+            - Optimized specifically for Hugging Face Spaces environment
+            
+            ## 📋 Usage Instructions
+            
+            ### 1. Write Your Code
+            - Enter your Python code in the code editor
+            - Add any Python package requirements in the requirements tab
+            
+            ### 2. Choose Compilation Mode
+            - **Maximum Compatibility**: Best for most use cases (recommended)
+            - **Portable Binary**: Smaller size, may need Python runtime
+            - **Standalone Binary**: Includes all dependencies (larger)
+            
+            ### 3. Compile
+            - Click "Compile with Nuitka"
+            - Wait for the compilation to complete
+            - Download the resulting binary
+            
+            ### 4. Run Your Binary
+            
+            ```bash
+            # On Linux (including WSL)
+            chmod +x compiled_program.bin
+            ./compiled_program.bin
+            
+            # In WSL, copy to Linux filesystem first
+            cp /mnt/c/Users/username/Downloads/compiled_program.bin ~/
+            cd ~
+            chmod +x compiled_program.bin
+            ./compiled_program.bin
+            ```
+            
+            ## ⚠️ HF Spaces Limitations
+            
+            - **System packages cannot be installed** (no apt-get access)
+            - All required system dependencies must be pre-installed
+            - Compilation happens in a containerized environment
+            - Binary execution may have resource limits
+            
+            ## 📊 Compilation Modes Comparison
+            
+            | Mode | Size | Portability | Speed | Best For |
+            |------|------|-------------|--------|----------|
+            | Maximum Compatibility | Medium | Highest | Fast | Distribution |
+            | Portable Binary | Small | High | Fastest | Quick testing |
+            | Standalone Binary | Large | Highest | Medium | Isolated deployment |
+            """)
+        
+        with gr.TabItem("ℹ️ About"):
+            gr.Markdown(f"""
+            ## 🧠 Smart Compilation Technology
+            
+            **How it works:**
+            
+            1. **Environment Detection**: Checks if static libpython is available
+            2. **Adaptive Options**: Uses the best available compilation flags
+            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
+            
+            This approach maximizes compatibility across different Python environments while working within HF Spaces constraints.
+            
+            ## ✅ What This Solves
+            
+            **Problems addressed:**
+            
+            - ✅ Static libpython not available error
+            - ✅ Python version mismatches
+            - ✅ HF Spaces environment limitations
+            - ✅ WSL compatibility issues
+            - ✅ Dependency resolution
+            - ✅ Cross-environment portability
+            
+            ## ☁️ Current Environment Status
+            
+            ```
+            Platform: {platform.platform()}
+            Architecture: {platform.architecture()[0]}
+            Machine: {platform.machine()}
+            Python Version: {get_current_python_version()}
+            Nuitka Version: {get_nuitka_version()}
+            Static Libpython: {'✅ Available' if check_static_libpython() else '❌ Not Available'}
+            Environment: Hugging Face Spaces
+            ```
+            
+            ## 📋 Best Practices
+            
+            **Recommendations:**
+            
+            1. ✅ Always use "Maximum Compatibility" mode
+            2. ✅ Test with simple scripts first
+            3. ✅ Copy binaries to Linux filesystem in WSL
+            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
+            
+            ## 🔧 Troubleshooting
+            
+            **Common Issues:**
+            
+            - **Import errors**: Check that all packages are in requirements.txt
+            - **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
+            
+            ## 🚀 Future Improvements
+            
+            - Support for more compilation targets
+            - Better error messages and diagnostics
+            - Automatic dependency detection
+            - Cross-platform compilation support
+            """)
+    
+    gr.Markdown("---")
+    gr.Markdown("🤖 Created by Claude 3.7 Sonnet | 🚀 Powered by Nuitka with Smart Compilation | ☁️ Optimized for HF Spaces")
+
+if __name__ == "__main__":
+    # Create necessary directories on startup
+    ensure_dir("user_code")
+    ensure_dir("compiled_output")
+    app.launch()