Create app.py

app.py

@@ -0,0 +1,655 @@
+import gradio as gr
+import os
+import subprocess
+import sys
+import shutil
+import uuid
+import platform
+import time
+from pathlib import Path
+import tempfile
+import glob
+
+def ensure_dir(dir_path):
+    """Ensure directory exists"""
+    Path(dir_path).mkdir(parents=True, exist_ok=True)
+
+def check_dependencies():
+    """Check if required dependencies are available"""
+    missing_deps = []
+    
+    # Check for patchelf
+    result = subprocess.run(["which", "patchelf"], capture_output=True)
+    if result.returncode != 0:
+        missing_deps.append("patchelf")
+    
+    # Check for gcc
+    result = subprocess.run(["which", "gcc"], capture_output=True)
+    if result.returncode != 0:
+        missing_deps.append("gcc")
+    
+    return missing_deps
+
+def check_static_libpython():
+    """Check if static libpython is available"""
+    try:
+        # Try to find static libpython
+        result = subprocess.run(
+            [sys.executable, "-c", "import sysconfig; print(sysconfig.get_config_var('LIBDIR'))"],
+            capture_output=True, text=True
+        )
+        if result.returncode == 0:
+            libdir = result.stdout.strip()
+            # Look for libpython.a files
+            static_libs = glob.glob(os.path.join(libdir, "libpython*.a"))
+            return len(static_libs) > 0
+    except:
+        pass
+    return False
+
+def get_current_python_version():
+    """Get the current Python version for compatibility notes"""
+    return f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"
+
+def get_nuitka_version():
+    """Get the current Nuitka version to handle different command line options"""
+    try:
+        result = subprocess.run([sys.executable, "-m", "nuitka", "--version"], 
+                                capture_output=True, text=True)
+        if result.returncode == 0:
+            version_line = result.stdout.strip().split('\n')[0]
+            # Extract version number from output like "Nuitka 2.5.0"
+            version = version_line.split()[-1]
+            return version
+        return "unknown"
+    except:
+        return "unknown"
+
+def install_system_packages(packages_content, progress=gr.Progress()):
+    """Install system packages from packages.txt content"""
+    if not packages_content.strip():
+        return "No system packages specified."
+    
+    progress(0, desc="Starting package installation...")
+    
+    # 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
+                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)}
+"""
+        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)
+
+def find_compiled_binary(output_dir, output_filename):
+    """Find the compiled binary, checking different possible paths"""
+    # Try direct path first
+    direct_path = os.path.join(output_dir, output_filename)
+    if os.path.exists(direct_path):
+        return direct_path
+    
+    # Try in .dist folder (standalone builds)
+    dist_path = os.path.join(output_dir, "user_script.dist", output_filename)
+    if os.path.exists(dist_path):
+        return dist_path
+    
+    # Try using glob to find any executable
+    patterns = [
+        os.path.join(output_dir, "**", output_filename),
+        os.path.join(output_dir, "**", "user_script"),
+        os.path.join(output_dir, "**", "*.bin"),
+        os.path.join(output_dir, "**", "*.exe")
+    ]
+    
+    for pattern in patterns:
+        matches = glob.glob(pattern, recursive=True)
+        if matches:
+            return matches[0]
+    
+    return None
+
+def compile_with_nuitka(code, requirements, packages, compilation_mode, output_extension, progress=gr.Progress()):
+    """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()
+    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())
+    base_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "user_code")
+    job_dir = os.path.join(base_dir, job_id)
+    output_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "compiled_output", job_id)
+    
+    # Create directories
+    ensure_dir(job_dir)
+    ensure_dir(output_dir)
+    
+    progress(0.1, desc="Installing dependencies...")
+    
+    # Install system packages if specified
+    packages_result = "No system packages specified."
+    if packages.strip():
+        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 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
+    
+    # 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
+        
+        compile_options = {
+            "max_compatibility": {
+                "name": "Maximum Compatibility Binary",
+                "cmd": build_cmd([
+                    sys.executable, "-m", "nuitka",
+                    "--standalone",
+                    "--onefile",  # Single portable file
+                    "--show-progress",
+                    "--remove-output",
+                    "--follow-imports",
+                    "--assume-yes-for-downloads",  # Auto-download missing dependencies
+                    "--python-flag=no_site",  # Reduce dependencies
+                    script_path,
+                    f"--output-dir={output_dir}"
+                ], use_static=True),
+                "creates_runner": False
+            },
+            "portable": {
+                "name": "Portable Non-Standalone",
+                "cmd": build_cmd([
+                    sys.executable, "-m", "nuitka",
+                    "--show-progress",
+                    "--remove-output",
+                    "--assume-yes-for-downloads",
+                    "--python-flag=no_site",
+                    script_path,
+                    f"--output-dir={output_dir}"
+                ], use_static=True),
+                "creates_runner": False
+            },
+            "standalone": {
+                "name": "Standalone Binary",
+                "cmd": build_cmd([
+                    sys.executable, "-m", "nuitka",
+                    "--standalone",
+                    "--onefile",
+                    "--show-progress",
+                    "--remove-output",
+                    "--assume-yes-for-downloads",
+                    "--python-flag=no_site",
+                    script_path,
+                    f"--output-dir={output_dir}"
+                ], use_static=True),
+                "creates_runner": False
+            }
+        }
+        
+        selected_option = compile_options[compilation_mode]
+        
+        # Run compilation
+        process = subprocess.Popen(
+            selected_option['cmd'],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            bufsize=1,
+            universal_newlines=True
+        )
+        
+        # Progress tracking
+        compile_output = ""
+        line_count = 0
+        
+        # Real-time progress display
+        for line in iter(process.stdout.readline, ''):
+            compile_output += line
+            line_count += 1
+            
+            # Update progress
+            progress_val = 0.3 + (min(line_count / 200, 0.69) * 0.7)
+            progress(progress_val, desc="Compiling...")
+        
+        process.wait()
+        
+        progress(0.9, desc="Finalizing...")
+        
+        # Find the compiled binary
+        output_filename = f"user_script{output_extension}"
+        binary_path = find_compiled_binary(output_dir, output_filename)
+        
+        # If not found with expected extension, try finding any executable
+        if not binary_path:
+            # Try common executable patterns for onefile
+            patterns = [
+                os.path.join(output_dir, "user_script"),
+                os.path.join(output_dir, "user_script.bin"),
+                os.path.join(output_dir, "**", "user_script"),
+                os.path.join(output_dir, "**", "*.bin"),
+            ]
+            
+            for pattern in patterns:
+                matches = glob.glob(pattern, recursive=True)
+                if matches:
+                    binary_path = matches[0]
+                    break
+        
+        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
+            
+            # 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"
+                else:
+                    linking_info = "ℹ️ Compiled binary - should work on compatible systems"
+            
+            # Rename to desired extension
+            if output_extension in ['.bin', '.sh'] and not binary_path.endswith(output_extension):
+                new_binary_path = binary_path + output_extension
+                shutil.move(binary_path, new_binary_path)
+                binary_path = new_binary_path
+            
+            # Make executable
+            os.chmod(binary_path, 0o755)
+            
+            # Current Python version info
+            current_python = get_current_python_version()
+            
+            # Add system info to result
+            result_summary = f"""
+Compilation Details:
+- Mode: {selected_option['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}
+
+Binary Information: {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
+"""
+            
+            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.Info("🎯 Static Libpython Available! Maximum portability enabled.")
+    else:
+        gr.Info("🔧 Using alternative portable options. Static libpython not available.")
+    
+    if missing_deps:
+        gr.Warning(f"⚠️ Missing dependencies: {', '.join(missing_deps)}")
+    else:
+        gr.Info("✅ 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"
+                            )
+                    
+                    compilation_mode = gr.Dropdown(
+                        choices=[
+                            ("max_compatibility", "Maximum Compatibility (Recommended)"),
+                            ("portable", "Portable Binary"),
+                            ("standalone", "Standalone Binary")
+                        ],
+                        value="max_compatibility",
+                        label="Compilation Mode"
+                    )
+                    
+                    output_extension = gr.Dropdown(
+                        choices=[".bin", ".sh"],
+                        value=".bin",
+                        label="Output File Extension"
+                    )
+                    
+                    gr.Info(f"📍 Compiling with Python {get_current_python_version()}")
+                    if check_static_libpython():
+                        gr.Success("🔗 Static libpython will be used!")
+                    else:
+                        gr.Info("🔧 Using portable compilation flags")
+                    
+                    compile_btn = gr.Button("🚀 Compile with Nuitka", variant="primary")
+            
+            # Results section
+            result_summary = gr.Textbox(label="Compilation Results", lines=10, visible=False)
+            compile_logs = gr.Textbox(label="Compilation Logs", lines=10, visible=False)
+            download_file = gr.File(label="Download Compiled Binary", visible=False)
+            
+            # Test run section
+            with gr.Row():
+                run_btn = gr.Button("🧪 Test Run", visible=False)
+                run_output = gr.Textbox(label="Execution Output", lines=8, visible=False)
+            
+            # 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(value=summary, visible=True),  # result_summary
+                        gr.update(value=logs, visible=True),     # compile_logs
+                        gr.update(value=download_path, visible=True),  # download_file
+                        gr.update(visible=True),  # run_btn
+                        binary_path,  # current_binary_path state
+                        True  # compilation_success state
+                    )
+                else:
+                    return (
+                        gr.update(value=summary, visible=True),  # result_summary
+                        gr.update(value=logs, visible=True),     # compile_logs
+                        gr.update(visible=False),  # download_file
+                        gr.update(visible=False),  # run_btn
+                        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, visible=True)
+                else:
+                    return gr.update(value="No binary available to run.", visible=True)
+            
+            compile_btn.click(
+                handle_compilation,
+                inputs=[code_input, requirements_input, packages_input, compilation_mode, output_extension],
+                outputs=[result_summary, compile_logs, download_file, run_btn, 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(share=True)