Update app.py

app.py

@@ -18,12 +18,12 @@ def check_dependencies():
     """Check if required dependencies are available"""
     missing_deps = []
     
-    # Check for patchelf
+    # Check for patchelf (usually available in HF Spaces)
     result = subprocess.run(["which", "patchelf"], capture_output=True)
     if result.returncode != 0:
         missing_deps.append("patchelf")
     
-    # Check for gcc
+    # Check for gcc (usually available in HF Spaces)
     result = subprocess.run(["which", "gcc"], capture_output=True)
     if result.returncode != 0:
         missing_deps.append("gcc")
@@ -66,72 +66,23 @@ def get_nuitka_version():
         return "unknown"
 
 def install_system_packages(packages_content, progress=gr.Progress()):
-    """Install system packages from packages.txt content"""
+    """Note about system packages in HF Spaces - they cannot be installed"""
     if not packages_content.strip():
         return "No system packages specified."
     
-    progress(0, desc="Starting package installation...")
+    # In HF Spaces, we can't install system packages
+    packages_list = [line.strip() for line in packages_content.strip().split('\n') 
+                     if line.strip() and not line.strip().startswith('#')]
     
-    # Create temporary file
-    fd, temp_path = tempfile.mkstemp(suffix='.txt')
-    try:
-        with os.fdopen(fd, 'w') as tmp:
-            tmp.write(packages_content)
-        
-        # Install packages line by line
-        install_log = ""
-        failed_packages = []
-        successful_packages = []
-        
-        lines = packages_content.strip().split('\n')
-        total_packages = len([line for line in lines if line.strip() and not line.strip().startswith('#')])
-        current_package = 0
-        
-        with open(temp_path, 'r') as f:
-            for line in f:
-                line = line.strip()
-                # Skip empty lines and comments
-                if not line or line.startswith('#'):
-                    continue
-                
-                current_package += 1
-                progress(current_package / total_packages, desc=f"Installing: {line}")
-                
-                # Try to install package (Note: this might not work in HF Spaces)
-                install_process = subprocess.run(
-                    ["apt-get", "update", "-qq"],
-                    capture_output=True,
-                    text=True
-                )
-                
-                install_process = subprocess.run(
-                    ["apt-get", "install", "-y", line],
-                    capture_output=True,
-                    text=True
-                )
-                
-                if install_process.returncode == 0:
-                    successful_packages.append(line)
-                    install_log += f"✅ Successfully installed: {line}\n"
-                else:
-                    failed_packages.append(line)
-                    install_log += f"❌ Failed to install: {line}\n"
-        
-        summary = f"""
-System Packages Summary:
-✅ Successful: {', '.join(successful_packages)}
-❌ Failed: {', '.join(failed_packages)}
+    if packages_list:
+        return f"""
+❌ System packages cannot be installed in Hugging Face Spaces:
+{', '.join(packages_list)}
+
+ℹ️ HF Spaces runs in a containerized environment without sudo access.
+These packages need to be pre-installed in the Docker image or available as Python packages.
 """
-        return summary + "\n" + install_log
-    
-    except Exception as e:
-        error_msg = f"Error installing system packages: {str(e)}"
-        return error_msg
-    
-    finally:
-        # Clean up
-        if os.path.exists(temp_path):
-            os.unlink(temp_path)
+    return "No system packages specified."
 
 def find_compiled_binary(output_dir, output_filename):
     """Find the compiled binary, checking different possible paths"""
@@ -172,8 +123,6 @@ def compile_with_nuitka(code, requirements, packages, compilation_mode, output_e
     
     # Check dependencies first
     missing_deps = check_dependencies()
-    if missing_deps:
-        return f"Required dependencies are missing: {', '.join(missing_deps)}", None, None, False
     
     # Create unique ID for this compilation
     job_id = str(uuid.uuid4())
@@ -185,12 +134,10 @@ def compile_with_nuitka(code, requirements, packages, compilation_mode, output_e
     ensure_dir(job_dir)
     ensure_dir(output_dir)
     
-    progress(0.1, desc="Installing dependencies...")
+    progress(0.1, desc="Processing packages...")
     
-    # Install system packages if specified
-    packages_result = "No system packages specified."
-    if packages.strip():
-        packages_result = install_system_packages(packages, progress)
+    # 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")
@@ -213,26 +160,20 @@ def compile_with_nuitka(code, requirements, packages, compilation_mode, output_e
             )
             
             if install_process.returncode == 0:
-                install_result = "Python requirements installed successfully."
+                install_result = "✅ Python requirements installed successfully."
             else:
-                install_result = f"Installation completed with return code: {install_process.returncode}\n{install_process.stderr}"
+                install_result = f"⚠️ Installation completed with warnings. Return code: {install_process.returncode}\n{install_process.stderr}"
         except Exception as e:
-            install_result = f"Error: {str(e)}"
-            return str(e), None, None, False
+            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...")
         
-        # Define compilation options with adaptive static linking
-        def build_cmd(base_cmd, use_static=False):
-            if use_static and has_static_libpython:
-                base_cmd.append("--static-libpython=yes")
-            return base_cmd
-        
-        # Map compilation mode strings to actual configurations
+        # Build compilation command based on mode
         if compilation_mode == "Maximum Compatibility (Recommended)":
-            cmd = build_cmd([
+            cmd = [
                 sys.executable, "-m", "nuitka",
                 "--standalone",
                 "--onefile",  # Single portable file
@@ -241,23 +182,32 @@ def compile_with_nuitka(code, requirements, packages, compilation_mode, output_e
                 "--follow-imports",
                 "--assume-yes-for-downloads",  # Auto-download missing dependencies
                 "--python-flag=no_site",  # Reduce dependencies
+                "--python-flag=no_warnings",  # Reduce warnings
                 script_path,
                 f"--output-dir={output_dir}"
-            ], use_static=True)
+            ]
+            
+            # Add static linking if available
+            if has_static_libpython:
+                cmd.append("--static-libpython=yes")
+                
             mode_name = "Maximum Compatibility Binary"
+            
         elif compilation_mode == "Portable Binary":
-            cmd = build_cmd([
+            cmd = [
                 sys.executable, "-m", "nuitka",
                 "--show-progress",
                 "--remove-output",
                 "--assume-yes-for-downloads",
                 "--python-flag=no_site",
+                "--python-flag=no_warnings",
                 script_path,
                 f"--output-dir={output_dir}"
-            ], use_static=True)
+            ]
             mode_name = "Portable Non-Standalone"
+            
         else:  # Standalone Binary
-            cmd = build_cmd([
+            cmd = [
                 sys.executable, "-m", "nuitka",
                 "--standalone",
                 "--onefile",
@@ -265,9 +215,10 @@ def compile_with_nuitka(code, requirements, packages, compilation_mode, output_e
                 "--remove-output",
                 "--assume-yes-for-downloads",
                 "--python-flag=no_site",
+                "--python-flag=no_warnings",
                 script_path,
                 f"--output-dir={output_dir}"
-            ], use_static=True)
+            ]
             mode_name = "Standalone Binary"
         
         # Run compilation
@@ -291,7 +242,10 @@ def compile_with_nuitka(code, requirements, packages, compilation_mode, output_e
             
             # Update progress
             progress_val = 0.3 + (min(line_count / 200, 0.69) * 0.7)
-            progress(progress_val, desc="Compiling...")
+            if "INFO:" in line:
+                progress(progress_val, desc=f"Compiling: {line.strip()[:50]}...")
+            else:
+                progress(progress_val, desc="Compiling...")
         
         process.wait()
         
@@ -319,20 +273,26 @@ def compile_with_nuitka(code, requirements, packages, compilation_mode, output_e
         
         if process.returncode == 0 and binary_path:
             # Check if it's really a binary file
-            file_process = subprocess.run(["file", binary_path], capture_output=True, text=True)
-            binary_info = file_process.stdout
+            try:
+                file_process = subprocess.run(["file", binary_path], capture_output=True, text=True)
+                binary_info = file_process.stdout
+            except:
+                binary_info = "Binary file (unable to get detailed info)"
             
             # Check linking type
-            ldd_process = subprocess.run(["ldd", binary_path], capture_output=True, text=True)
-            if "not a dynamic executable" in ldd_process.stderr or "statically linked" in ldd_process.stdout:
-                linking_info = "✅ Statically linked - fully portable!"
-            else:
-                # Check what dynamic libraries are required
-                if ldd_process.returncode == 0:
-                    libs = ldd_process.stdout.count("=>")
-                    linking_info = f"🔗 Dynamically linked ({libs} libraries) - designed for maximum compatibility"
+            try:
+                ldd_process = subprocess.run(["ldd", binary_path], capture_output=True, text=True)
+                if "not a dynamic executable" in ldd_process.stderr or "statically linked" in ldd_process.stdout:
+                    linking_info = "✅ Statically linked - fully portable!"
                 else:
-                    linking_info = "ℹ️ Compiled binary - should work on compatible systems"
+                    # Check what dynamic libraries are required
+                    if ldd_process.returncode == 0:
+                        libs = ldd_process.stdout.count("=>")
+                        linking_info = f"🔗 Dynamically linked ({libs} libraries) - designed for maximum compatibility"
+                    else:
+                        linking_info = "ℹ️ Compiled binary - should work on compatible systems"
+            except:
+                linking_info = "ℹ️ Compiled binary created successfully"
             
             # Rename to desired extension
             if output_extension in ['.bin', '.sh'] and not binary_path.endswith(output_extension):
@@ -348,301 +308,33 @@ def compile_with_nuitka(code, requirements, packages, compilation_mode, output_e
             
             # Add system info to result
             result_summary = f"""
-Compilation Details:
-- Mode: {mode_name}
-- Nuitka Version: {nuitka_version}
-- Exit Code: {process.returncode}
-- Output Path: {binary_path}
-- File Size: {os.path.getsize(binary_path) / 1024:.2f} KB
-- Compiled with Python: {current_python}
-- Static Libpython Available: {'Yes' if has_static_libpython else 'No'}
-- Linking: {linking_info}
+# ✅ Compilation Successful!
+
+## Compilation Details:
+- **Mode**: {mode_name}
+- **Nuitka Version**: {nuitka_version}
+- **Exit Code**: {process.returncode}
+- **Output Path**: {binary_path}
+- **File Size**: {os.path.getsize(binary_path) / 1024:.2f} KB
+- **Compiled with Python**: {current_python}
+- **Static Libpython Available**: {'Yes' if has_static_libpython else 'No'}
+- **Linking**: {linking_info}
 
-System Packages: {packages_result}
-Python Requirements: {install_result}
+## Environment Results:
+**System Packages**: {packages_result}
+**Python Requirements**: {install_result}
 
-Binary Information: {binary_info}
+## Binary Information:
+{binary_info}
 
-PORTABILITY NOTES:
+## 🚀 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
-"""
-            
-            progress(1.0, desc="Compilation successful!")
-            return result_summary, binary_path, compile_output, True
-        else:
-            return f"Compilation failed.\n\nSystem Packages: {packages_result}\nPython Requirements: {install_result}", None, compile_output, False
-        
-    except Exception as e:
-        return f"Compilation error: {str(e)}", 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=10
-        )
-        
-        output = ""
-        if process.stdout:
-            output += f"[STDOUT]\n{process.stdout}\n"
-        if process.stderr:
-            output += f"[STDERR]\n{process.stderr}\n"
-        if process.returncode != 0:
-            output += f"[EXIT CODE] {process.returncode}\n"
-        
-        return output if output else "No output."
-    except subprocess.TimeoutExpired:
-        return "Execution timed out after 10 seconds."
-    except Exception as e:
-        return f"Error running the binary: {str(e)}"
-
-# Create Gradio interface
-with gr.Blocks(title="Nuitka Python Compiler", theme=gr.themes.Soft()) as app:
-    gr.Markdown("# 🚀 Nuitka Python Compiler (Smart Compilation)")
-    gr.Markdown("Convert your Python code into portable executables using Nuitka with smart compatibility detection.")
-    
-    # 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!**")
-    
-    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!')""",
-                        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""",
-                                lines=8,
-                                label="requirements.txt content"
-                            )
-                        
-                        with gr.TabItem("System Packages"):
-                            packages_input = gr.Textbox(
-                                placeholder="""# Add system packages here (one per line)
-# Example:
-# build-essential
-# libssl-dev
-# ffmpeg
-# imagemagick""",
-                                lines=8,
-                                label="packages.txt content"
-                            )
-                    
-                    # 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:
-                result_summary = gr.Textbox(label="Compilation Results", lines=10)
-                compile_logs = gr.Textbox(label="Compilation Logs", lines=10)
-                download_file = gr.File(label="Download Compiled Binary")
-                
-                # Test run section
-                with gr.Row():
-                    run_btn = gr.Button("🧪 Test Run")
-                    run_output = gr.Textbox(label="Execution Output", lines=8)
-            
-            # 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
-            
-            **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
-            - Optimizes for your specific environment
-            
-            ## 📋 General Instructions
-            
-            ```bash
-            # Download the compiled binary
-            # Method 1: Direct run (if static libpython was used)
-            chmod +x compiled_program.bin
-            ./compiled_program.bin
-            
-            # Method 2: Copy to Linux filesystem first (recommended for WSL)
-            cp /mnt/c/Users/username/Downloads/compiled_program.bin ~/
-            cd ~
-            chmod +x compiled_program.bin
-            ./compiled_program.bin
-            ```
-            
-            ## 📊 Environment Types
-            
-            | Environment | Portability | Requirements | Best For |
-            |-------------|-------------|--------------|----------|
-            | Static Libpython | Maximum | None | Any Linux system |
-            | Non-Static Libpython | High | Compatible system | Similar environments |
-            """)
-        
-        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
-            
-            This approach maximizes compatibility across different Python environments.
-            
-            ## ✅ What This Solves
-            
-            **Problems addressed:**
-            
-            - Static libpython not available error
-            - Python version mismatches
-            - WSL compatibility issues
-            - Dependency resolution
-            - Cross-environment portability
-            
-            ## ☁️ Current Environment Status
-            
-            ```
-            Python Version: {get_current_python_version()}
-            Nuitka Version: {get_nuitka_version()}
-            Platform: {platform.platform()}
-            Architecture: {platform.architecture()[0]}
-            Machine: {platform.machine()}
-            Static Libpython: {'✅ Available' if check_static_libpython() else '❌ Not Available'}
-            ```
-            
-            ## 📋 Best Practices
-            
-            **Recommendations:**
-            
-            1. Always use "Maximum Compatibility" mode
-            2. Copy binaries to Linux filesystem in WSL
-            3. Test the binary in the target environment
-            4. Let the app automatically choose the best settings
-            5. Check the compilation details for specific optimization used
-            """)
-    
-    gr.Markdown("---")
-    gr.Markdown("🤖 Created by Claude 3.7 Sonnet | 🚀 Powered by Nuitka with Smart Compilation")
 
-if __name__ == "__main__":
-    app.launch()
+## 📋 Usage Instructions:
+```bash
+chmod +x {os.path.basename(binary_path)}
+./{os.path.basename(binary_path)}