Update app.py

app.py

@@ -344,14 +344,12 @@ Add this to your requirements.txt and redeploy the space."""
             cmd.extend([
                 "--mingw64",  # Use MinGW-w64 for cross-compilation
                 "--windows-disable-console",  # Disable console window for GUI apps
-                "--target-arch=x64",  # Explicitly target 64-bit architecture
-                "--msvc=14.3",  # Use MSVC compatibility mode
             ])
             # Note: --mingw64 flag tells Nuitka to use MinGW-w64 for Windows cross-compilation
             if log_queue:
-                log_queue.put("Using MinGW-w64 for Windows 64-bit cross-compilation\n")
-                log_queue.put("Note: Cross-compiling from Linux to Windows x64 using proper MinGW-w64 toolchain\n")
-                log_queue.put("Target architecture: x64 (64-bit)\n")
+                log_queue.put("Using MinGW-w64 for Windows cross-compilation\n")
+                log_queue.put("Note: Cross-compiling from Linux to Windows using MinGW-w64 toolchain\n")
+                log_queue.put("Target: Windows 64-bit (MinGW-w64 default)\n")
         
         # Run compilation
         if progress_callback:
@@ -457,10 +455,10 @@ Add this to your requirements.txt and redeploy the space."""
                 except:
                     linking_info = "ℹ️ Compiled binary created successfully"
             else:
-                # For Windows, check architecture
-                linking_info = "📦 Windows x64 executable (cross-compiled with MinGW-w64)"
+                # For Windows
+                linking_info = "📦 Windows executable (cross-compiled with MinGW-w64)"
                 if log_queue:
-                    log_queue.put("Binary architecture: 64-bit (x64)\n")
+                    log_queue.put("Binary: Windows x64 format (MinGW-w64 default)\n")
             
             # Rename to desired extension
             if output_extension in ['.bin', '.sh', '.exe'] and not binary_path.endswith(output_extension):
@@ -489,7 +487,7 @@ Add this to your requirements.txt and redeploy the space."""
 - **Compiled with Python**: {current_python}
 - **Static Libpython Available**: {static_status}
 - **Linking**: {linking_info}
-- **Target Platform**: {'Windows x64 (.exe) via MinGW-w64' if output_extension == '.exe' else 'Linux'}
+- **Target Platform**: {'Windows (via MinGW-w64)' if output_extension == '.exe' else 'Linux'}
 
 ## Environment Results:
 **System Packages**: {packages_result}
@@ -501,22 +499,22 @@ Add this to your requirements.txt and redeploy the space."""
 ## 🚀 Portability Notes:
 - This binary was compiled with maximum compatibility settings
 - Using --onefile for single-file distribution
-- {'Cross-compiled specifically for Windows 64-bit (x64) using MinGW-w64 toolchain' if output_extension == '.exe' else 'Should work on most compatible Linux systems'}
+- {'Cross-compiled for Windows using MinGW-w64 toolchain' if output_extension == '.exe' else 'Should work on most compatible Linux systems'}
 {f'- Console window disabled for Windows GUI applications' if output_extension == '.exe' else ''}
-- {'Explicitly targets x64 architecture for maximum Windows compatibility' if output_extension == '.exe' else ''}
+- {'MinGW-w64 produces 64-bit Windows executables by default' if output_extension == '.exe' else ''}
 
 ## 📋 Usage Instructions:
 ```bash
-{f'# For Windows (64-bit):' if output_extension == '.exe' else f'chmod +x {binary_basename}'}
+{f'# For Windows:' if output_extension == '.exe' else f'chmod +x {binary_basename}'}
 {f'# Download to Windows machine and run:' if output_extension == '.exe' else ''}
 {f'{binary_basename}' if output_extension == '.exe' else f'./{binary_basename}'}
 ```
 
 ## ⚠️ Cross-Compilation Notes:
-{f'''- Compiled from Linux to Windows x64 using MinGW-w64
-- Uses --target-arch=x64 for explicit 64-bit compilation
+{f'''- Compiled from Linux to Windows using MinGW-w64
+- MinGW-w64 creates 64-bit executables by default
 - Tested with wine if available: `wine {binary_basename}`
-- Compatible with Windows 7 64-bit and later
+- Compatible with Windows 64-bit systems
 - Some Windows-specific libraries may need additional setup
 - GUI frameworks may require special handling''' if output_extension == '.exe' else 'Native Linux compilation with maximum compatibility'}
 
@@ -532,7 +530,7 @@ Add this to your requirements.txt and redeploy the space."""
             if log_queue:
                 log_queue.put("✅ Compilation completed successfully!\n")
                 if output_extension == ".exe":
-                    log_queue.put("🍷 You can test the Windows x64 executable with: wine " + binary_basename + "\n")
+                    log_queue.put("🍷 You can test the Windows executable with: wine " + binary_basename + "\n")
                 
             return result_summary, binary_path, compile_output, True
         else:
@@ -542,7 +540,7 @@ Add this to your requirements.txt and redeploy the space."""
 ## Error Details:
 - **Exit Code**: {process.returncode}
 - **Mode Attempted**: {mode_name}
-- **Target**: {'Windows x64 (.exe) via MinGW-w64' if output_extension == '.exe' else 'Linux'}
+- **Target**: {'Windows (via MinGW-w64)' if output_extension == '.exe' else 'Linux'}
 
 ## Environment Results:
 **System Packages**: {packages_result}
@@ -560,7 +558,7 @@ Add this to your requirements.txt and redeploy the space."""
 4. Review the compilation logs above
 {f"5. For Windows cross-compilation, ensure MinGW-w64 is properly installed" if output_extension == '.exe' else ''}
 {f"6. Some packages may not support Windows cross-compilation" if output_extension == '.exe' else ''}
-{f"7. For 64-bit Windows, ensure all dependencies support x64 architecture" if output_extension == '.exe' else ''}
+{f"7. MinGW-w64 creates 64-bit executables by default" if output_extension == '.exe' else ''}
 
 ## Missing Dependencies:
 {', '.join(missing_deps) if missing_deps else 'None detected'}
@@ -570,7 +568,7 @@ Add this to your requirements.txt and redeploy the space."""
 - **Python Version**: {current_python}
 - **Platform**: {platform.platform()}
 {f"- **MinGW-w64**: {'Available' if not check_mingw_installation() else 'Missing components'}" if output_extension == '.exe' else ''}
-{f"- **Target Architecture**: x64 (64-bit)" if output_extension == '.exe' else ''}"""
+{f"- **Target Architecture**: x64 (MinGW-w64 default)" if output_extension == '.exe' else ''}"""
             if progress_callback:
                 progress_callback(1.0, "Compilation failed ❌")
             
@@ -603,7 +601,7 @@ Add this to your requirements.txt and redeploy the space."""
 3. Check available disk space
 4. Try with simpler code first
 {f"5. Ensure MinGW-w64 is installed for Windows cross-compilation" if output_extension == '.exe' else ''}
-{f"6. For Windows 64-bit, ensure proper x64 toolchain" if output_extension == '.exe' else ''}"""
+{f"6. MinGW-w64 produces 64-bit Windows executables by default" if output_extension == '.exe' else ''}"""
         if progress_callback:
             progress_callback(1.0, "Error occurred ❌")
             
@@ -623,7 +621,7 @@ def run_compiled_binary(binary_path):
             # Try to run with wine first
             wine_result = subprocess.run(["which", "wine"], capture_output=True)
             if wine_result.returncode == 0:
-                return f"""🍷 **Running Windows x64 executable with Wine**
+                return f"""🍷 **Running Windows executable with Wine**
 
 ## Execution:
 ```bash
@@ -643,7 +641,7 @@ To run on Windows:
 
 ## Note:
 - Wine is available on this system for basic testing
-- This executable is compiled for Windows 64-bit (x64)
+- This executable is compiled for Windows 64-bit (MinGW-w64 default)
 - Full compatibility requires running on actual Windows
 - Some features may not work correctly in wine"""
             else:
@@ -651,7 +649,7 @@ To run on Windows:
 
 ## To run this binary:
 1. Download the .exe file
-2. Transfer it to a Windows machine (64-bit required)
+2. Transfer it to a Windows machine
 3. Run it by double-clicking or from command prompt
 
 ```cmd
@@ -661,9 +659,8 @@ cd /path/to/downloaded/file
 ```
 
 ## Note:
-- This executable is compiled for Windows 64-bit (x64)
-- Compatible with Windows 7 64-bit and later
-- Will not work on 32-bit Windows systems
+- This executable is compiled for Windows 64-bit (MinGW-w64 default)
+- Compatible with most Windows 64-bit systems
 
 ## Alternative:
 Install wine to test Windows executables on Linux:
@@ -708,7 +705,7 @@ wine {os.path.basename(binary_path)}
 # Create Gradio interface
 with gr.Blocks(title="Nuitka Python Compiler with MinGW-w64", theme=gr.themes.Soft()) as app:
     gr.Markdown("# 🚀 Nuitka Python Compiler (MinGW-w64 Cross-Compilation)")
-    gr.Markdown("Convert your Python code into portable executables using Nuitka, with proper MinGW-w64 support for Windows 64-bit cross-compilation.")
+    gr.Markdown("Convert your Python code into portable executables using Nuitka, with MinGW-w64 support for Windows cross-compilation.")
     
     # Check environment status
     has_static = check_static_libpython()
@@ -727,15 +724,15 @@ with gr.Blocks(title="Nuitka Python Compiler with MinGW-w64", theme=gr.themes.So
         gr.Markdown(f"⚠️ **MinGW-w64 Components Missing:** {', '.join(mingw_missing)}")
         gr.Markdown("📝 **For Windows .exe generation**, MinGW-w64 should be pre-installed in the environment.")
     else:
-        gr.Markdown("✅ **MinGW-w64 Available!** Windows 64-bit cross-compilation supported.")
+        gr.Markdown("✅ **MinGW-w64 Available!** Windows cross-compilation supported.")
     
     if [dep for dep in missing_deps if dep != "nuitka" and dep != "mingw-w64"]:
         gr.Markdown(f"⚠️ **Other missing dependencies:** {', '.join([dep for dep in missing_deps if dep != 'nuitka' and dep != 'mingw-w64'])}")
     
     # MinGW-w64 information
     gr.Markdown("""
-    > ℹ️ **MinGW-w64 Cross-Compilation**: Using proper MinGW-w64 toolchain for Windows 64-bit .exe generation.
-    > This follows the official Nuitka documentation and explicitly targets x64 architecture.
+    > ℹ️ **MinGW-w64 Cross-Compilation**: Using MinGW-w64 toolchain for Windows .exe generation.
+    > MinGW-w64 produces 64-bit Windows executables by default.
     """)
     
     with gr.Tabs():
@@ -819,7 +816,7 @@ input('Press Enter to exit...')""",
                     if mingw_missing:
                         gr.Markdown(f"⚠️ **MinGW-w64**: Missing ({', '.join(mingw_missing)})")
                     else:
-                        gr.Markdown("✅ **MinGW-w64**: Available for Windows 64-bit cross-compilation")
+                        gr.Markdown("✅ **MinGW-w64**: Available for Windows cross-compilation")
                     
                     if check_static_libpython():
                         gr.Markdown("🔗 **Static libpython will be used for Linux targets!**")
@@ -827,7 +824,7 @@ input('Press Enter to exit...')""",
                         gr.Markdown("🔧 **Using portable compilation flags**")
                     
                     # Add architecture notice
-                    gr.Markdown("🏗️ **Windows Target**: x64 (64-bit) architecture")
+                    gr.Markdown("🏗️ **Windows Target**: MinGW-w64 produces 64-bit executables by default")
                     
                     compile_btn = gr.Button("🚀 Compile with Nuitka", variant="primary")
             
@@ -915,10 +912,10 @@ input('Press Enter to exit...')""",
                     # Progress simulation with log updates
                     progress_steps = [
                         (0.1, "Checking Nuitka installation..."),
-                        (0.15, "Checking MinGW-w64 for Windows x64 targets..." if extension == ".exe" else "Checking environment..."),
+                        (0.15, "Checking MinGW-w64 for Windows targets..." if extension == ".exe" else "Checking environment..."),
                         (0.2, "Setting up environment..."),
                         (0.3, "Installing requirements..."),
-                        (0.4, f"Starting {'Windows x64 cross-' if extension == '.exe' else ''}compilation..."),
+                        (0.4, f"Starting {'Windows cross-' if extension == '.exe' else ''}compilation..."),
                         (0.5, "Processing imports..."),
                         (0.6, "Optimizing code..."),
                         (0.7, f"Creating {extension} binary..."),
@@ -966,7 +963,7 @@ input('Press Enter to exit...')""",
                     # Final progress update
                     final_status = "✅ Compilation successful!" if success else "❌ Compilation failed"
                     if success and extension == ".exe":
-                        final_status += " (Windows x64 .exe created)"
+                        final_status += " (Windows .exe created)"
                     
                     yield (
                         gr.update(visible=True),  # progress_section
@@ -1064,23 +1061,22 @@ input('Press Enter to exit...')""",
         
         with gr.TabItem("📖 How to Use"):
             gr.Markdown("""
-            ## 🎯 MinGW-w64 Cross-Compilation to Windows 64-bit
+            ## 🎯 MinGW-w64 Cross-Compilation to Windows
             
-            **Proper Windows x64 .exe Generation**
+            **Proper Windows .exe Generation**
             
-            This app now uses the **correct method** for generating 64-bit Windows .exe files from Linux:
+            This app uses MinGW-w64 for generating Windows .exe files from Linux:
             - **MinGW-w64 toolchain** for cross-compilation
             - **`--mingw64` flag** in Nuitka
-            - **`--target-arch=x64`** for explicit 64-bit compilation
             - **`--windows-disable-console`** for GUI applications
-            - **Proper cross-compilation setup** as per Nuitka documentation
+            - **MinGW-w64 produces 64-bit binaries by default**
             
             **Features:**
             - Real-time compilation logs
             - Visual progress bar with cross-compilation status
             - Automatic MinGW-w64 detection
             - Wine testing support for .exe files
-            - **Explicit 64-bit architecture targeting**
+            - **64-bit Windows compatibility**
             
             ## 📋 Usage Instructions
             
@@ -1092,13 +1088,13 @@ input('Press Enter to exit...')""",
             ### 2. Choose Target Platform
             - **Linux (.bin)**: Native Linux executable (fastest compilation)
             - **Linux (.sh)**: Shell script format
-            - **Windows (.exe)**: Cross-compiled using MinGW-w64 (64-bit, proper method)
+            - **Windows (.exe)**: Cross-compiled using MinGW-w64
             
             ### 3. Compile
             - Click "Compile with Nuitka"
             - Watch the real-time logs showing MinGW-w64 usage
             - Monitor the progress bar for cross-compilation status
-            - Download the resulting 64-bit binary
+            - Download the resulting binary
             
             ### 4. Run Your Binary
             
@@ -1109,7 +1105,7 @@ input('Press Enter to exit...')""",
             ./compiled_program.bin
             ```
             
-            #### For Windows executables (64-bit):
+            #### For Windows executables:
             ```cmd
             # Download the .exe file to Windows
             compiled_program.exe
@@ -1127,7 +1123,7 @@ input('Press Enter to exit...')""",
             
             ## 🔧 MinGW-w64 Requirements
             
-            **For Windows 64-bit cross-compilation, the following should be pre-installed:**
+            **For Windows cross-compilation, the following should be pre-installed:**
             ```bash
             # Ubuntu/Debian
             apt install mingw-w64 gcc-mingw-w64 g++-mingw-w64
@@ -1139,50 +1135,45 @@ input('Press Enter to exit...')""",
             ## ⚠️ Cross-Compilation Notes
             
             **Windows .exe from Linux (MinGW-w64 method):**
-            - ✅ Uses proper MinGW-w64 cross-compiler
-            - ✅ Follows official Nuitka documentation
-            - ✅ Produces native Windows 64-bit executables
-            - ✅ Explicitly targets x64 architecture
+            - ✅ Uses MinGW-w64 cross-compiler
+            - ✅ Produces Windows 64-bit executables by default
             - ⚠️ Some Python packages may not cross-compile
             - ⚠️ Windows-specific APIs may need special handling
             - ✅ Can be tested with wine on Linux
-            - ✅ Compatible with Windows 7 64-bit and later
+            - ✅ Compatible with most Windows 64-bit systems
             
             ## 📊 Architecture Support
             
             | Target | Architecture | Compatibility | Notes |
             |--------|-------------|---------------|-------|
             | Linux | x64 | Native | Best performance |
-            | Windows | x64 (64-bit) | Excellent | Proper MinGW-w64 cross-compilation |
-            | Windows | x86 (32-bit) | Not supported | Use x64 instead |
+            | Windows | x64 (64-bit) | Excellent | MinGW-w64 default |
+            | Windows | x86 (32-bit) | Not by default | MinGW-w64 creates 64-bit |
             """)
         
         with gr.TabItem("ℹ️ About"):
             gr.Markdown(f"""
             ## 🧠 MinGW-w64 Cross-Compilation Technology
             
-            **Proper 64-bit Implementation:**
+            **Implementation:**
             
-            1. **MinGW-w64 Toolchain**: Uses the correct cross-compiler for Windows
-            2. **Nuitka Integration**: Proper `--mingw64` flag usage
-            3. **Architecture Targeting**: Explicit `--target-arch=x64` for 64-bit
+            1. **MinGW-w64 Toolchain**: Uses the cross-compiler for Windows
+            2. **Nuitka Integration**: Uses `--mingw64` flag
+            3. **Architecture**: MinGW-w64 produces 64-bit executables by default
             4. **Real-time Monitoring**: Watch MinGW-w64 compilation in real-time
             5. **Wine Testing**: Optional testing of Windows executables on Linux
             6. **Automatic Detection**: Checks for required MinGW-w64 components
-            7. **Proper Flags**: Uses `--windows-disable-console` for GUI apps
             
-            ## ✅ Improvements in This Version
+            ## ✅ Features
             
-            **Enhanced cross-compilation:**
+            **Cross-compilation support:**
             
             - ✅ Proper MinGW-w64 implementation
-            - ✅ Follows official Nuitka documentation
-            - ✅ **Explicit 64-bit architecture targeting**
             - ✅ Real-time MinGW-w64 status in logs
             - ✅ Automatic MinGW-w64 component detection
             - ✅ Wine testing instructions
             - ✅ Better error handling for cross-compilation
-            - ✅ **Architecture verification in output**
+            - ✅ **64-bit Windows binaries by default**
             
             ## ☁️ Environment Status
             
@@ -1194,8 +1185,8 @@ input('Press Enter to exit...')""",
             MinGW-w64 Status: {'✅ Available' if not check_mingw_installation() else f'❌ Missing: {", ".join(check_mingw_installation())}'}
             Static Libpython: {'✅ Available' if check_static_libpython() else '❌ Not Available'}
             Environment: Hugging Face Spaces
-            Cross-Compilation: Proper MinGW-w64 support
-            Target Architecture: x64 (64-bit) for Windows
+            Cross-Compilation: MinGW-w64 support
+            Target Architecture: 64-bit (MinGW-w64 default)
             ```
             
             ## 📋 Best Practices
@@ -1207,8 +1198,7 @@ input('Press Enter to exit...')""",
             3. ✅ Check MinGW-w64 status before compiling .exe
             4. ✅ Use real-time logs to monitor progress
             5. ✅ Test .exe files with wine if available
-            6. ✅ **Verify 64-bit architecture in compilation logs**
-            7. ✅ Test on actual Windows 64-bit systems
+            6. ✅ Test on actual Windows systems
             
             **Package compatibility:**
             
@@ -1216,7 +1206,6 @@ input('Press Enter to exit...')""",
             2. ⚠️ Avoid packages with C extensions when cross-compiling
             3. ⚠️ GUI frameworks may need special handling
             4. ⚠️ Windows-specific packages won't work in cross-compilation
-            5. ✅ **Ensure all dependencies support 64-bit architecture**
             
             ## 🔧 Troubleshooting
             
@@ -1225,7 +1214,6 @@ input('Press Enter to exit...')""",
             - **Missing MinGW-w64**: Install required packages in Docker image
             - **Cross-compilation fails**: Check package compatibility
             - **Large .exe files**: Normal for standalone Windows executables
-            - **32-bit/64-bit mismatch**: Script now explicitly targets x64
             - **Runtime errors**: Test with different Nuitka flags
             - **Wine issues**: Wine testing is optional, real Windows testing preferred
             
@@ -1235,32 +1223,30 @@ input('Press Enter to exit...')""",
             
             1. Nuitka converts Python to C code
             2. MinGW-w64 cross-compiles C to Windows PE format
-            3. **Explicitly targets x64 (64-bit) architecture**
+            3. **Default output is 64-bit Windows executable**
             4. Static linking reduces Windows dependencies
-            5. Result is a native Windows 64-bit executable
+            5. Result is a native Windows executable
             6. Optional Wine testing for basic validation
             
             **Command structure:**
             ```bash
             python -m nuitka \\
               --mingw64 \\
-              --target-arch=x64 \\
               --onefile \\
               --windows-disable-console \\
               --show-progress \\
               your_script.py
             ```
             
-            **Key flags for 64-bit compilation:**
+            **Key flags:**
             - `--mingw64`: Use MinGW-w64 toolchain
-            - `--target-arch=x64`: Explicitly target 64-bit architecture
-            - `--msvc=14.3`: MSVC compatibility mode
+            - `--windows-disable-console`: For GUI apps
             
-            This ensures **proper 64-bit Windows compatibility**.
+            MinGW-w64 **produces 64-bit Windows executables by default**.
             """)
     
     gr.Markdown("---")
-    gr.Markdown("🤖 Created by Claude 3.7 Sonnet | 🚀 Powered by Nuitka + MinGW-w64 | ☁️ Proper x64 cross-compilation | 📊 Real-time logs")
+    gr.Markdown("🤖 Created by Claude 3.7 Sonnet | 🚀 Powered by Nuitka + MinGW-w64 | ☁️ 64-bit cross-compilation")
 
 if __name__ == "__main__":
     # Create necessary directories on startup