Update app.py

app.py

@@ -343,11 +343,14 @@ 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 cross-compilation\n")
-                log_queue.put("Note: Cross-compiling from Linux to Windows using proper MinGW-w64 toolchain\n")
+                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")
         
         # Run compilation
         if progress_callback:
@@ -453,7 +456,10 @@ Add this to your requirements.txt and redeploy the space."""
                 except:
                     linking_info = "ℹ️ Compiled binary created successfully"
             else:
-                linking_info = "📦 Windows executable (cross-compiled with MinGW-w64)"
+                # For Windows, check architecture
+                linking_info = "📦 Windows x64 executable (cross-compiled with MinGW-w64)"
+                if log_queue:
+                    log_queue.put("Binary architecture: 64-bit (x64)\n")
             
             # Rename to desired extension
             if output_extension in ['.bin', '.sh', '.exe'] and not binary_path.endswith(output_extension):
@@ -485,7 +491,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 (.exe) via MinGW-w64' if output_extension == '.exe' else 'Linux'}
+- **Target Platform**: {'Windows x64 (.exe) via MinGW-w64' if output_extension == '.exe' else 'Linux'}
 
 ## Environment Results:
 **System Packages**: {packages_result}
@@ -497,19 +503,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 using MinGW-w64 toolchain for Windows compatibility' if output_extension == '.exe' else 'Should work on most compatible Linux systems'}
+- {'Cross-compiled specifically for Windows 64-bit (x64) 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 ''}
 
 ## 📋 Usage Instructions:
 ```bash
-{f'# For Windows:' if output_extension == '.exe' else f'chmod +x {binary_basename}'}
+{f'# For Windows (64-bit):' 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 using MinGW-w64
+{f'''- Compiled from Linux to Windows x64 using MinGW-w64
+- Uses --target-arch=x64 for explicit 64-bit compilation
 - Tested with wine if available: `wine {binary_basename}`
+- Compatible with Windows 7 64-bit and later
 - 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'}
 
@@ -525,7 +534,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 executable with: wine " + binary_basename + "\n")
+                    log_queue.put("🍷 You can test the Windows x64 executable with: wine " + binary_basename + "\n")
                 
             return result_summary, binary_path, compile_output, True
         else:
@@ -535,7 +544,7 @@ Add this to your requirements.txt and redeploy the space."""
 ## Error Details:
 - **Exit Code**: {process.returncode}
 - **Mode Attempted**: {mode_name}
-- **Target**: {'Windows (.exe) via MinGW-w64' if output_extension == '.exe' else 'Linux'}
+- **Target**: {'Windows x64 (.exe) via MinGW-w64' if output_extension == '.exe' else 'Linux'}
 
 ## Environment Results:
 **System Packages**: {packages_result}
@@ -553,6 +562,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 ''}
 
 ## Missing Dependencies:
 {', '.join(missing_deps) if missing_deps else 'None detected'}
@@ -561,7 +571,8 @@ Add this to your requirements.txt and redeploy the space."""
 - **Nuitka Version**: {nuitka_version}
 - **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"- **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 ''}"""
             if progress_callback:
                 progress_callback(1.0, "Compilation failed ❌")
             
@@ -593,7 +604,8 @@ Add this to your requirements.txt and redeploy the space."""
 2. Verify your code syntax
 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"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 ''}"""
         if progress_callback:
             progress_callback(1.0, "Error occurred ❌")
             
@@ -613,7 +625,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 executable with Wine**
+                return f"""🍷 **Running Windows x64 executable with Wine**
 
 ## Execution:
 ```bash
@@ -633,6 +645,7 @@ To run on Windows:
 
 ## Note:
 - Wine is available on this system for basic testing
+- This executable is compiled for Windows 64-bit (x64)
 - Full compatibility requires running on actual Windows
 - Some features may not work correctly in wine"""
             else:
@@ -640,7 +653,7 @@ To run on Windows:
 
 ## To run this binary:
 1. Download the .exe file
-2. Transfer it to a Windows machine
+2. Transfer it to a Windows machine (64-bit required)
 3. Run it by double-clicking or from command prompt
 
 ```cmd
@@ -649,6 +662,11 @@ cd /path/to/downloaded/file
 {os.path.basename(binary_path)}
 ```
 
+## 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
+
 ## Alternative:
 Install wine to test Windows executables on Linux:
 ```bash
@@ -692,7 +710,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 cross-compilation.")
+    gr.Markdown("Convert your Python code into portable executables using Nuitka, with proper MinGW-w64 support for Windows 64-bit cross-compilation.")
     
     # Check environment status
     has_static = check_static_libpython()
@@ -711,15 +729,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 cross-compilation supported.")
+        gr.Markdown("✅ **MinGW-w64 Available!** Windows 64-bit 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 .exe generation.
-    > This follows the official Nuitka documentation for cross-platform compilation.
+    > ℹ️ **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.
     """)
     
     with gr.Tabs():
@@ -803,13 +821,16 @@ 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 cross-compilation")
+                        gr.Markdown("✅ **MinGW-w64**: Available for Windows 64-bit cross-compilation")
                     
                     if check_static_libpython():
                         gr.Markdown("🔗 **Static libpython will be used for Linux targets!**")
                     else:
                         gr.Markdown("🔧 **Using portable compilation flags**")
                     
+                    # Add architecture notice
+                    gr.Markdown("🏗️ **Windows Target**: x64 (64-bit) architecture")
+                    
                     compile_btn = gr.Button("🚀 Compile with Nuitka", variant="primary")
             
             # Progress Bar Section
@@ -841,10 +862,10 @@ input('Press Enter to exit...')""",
                     run_btn = gr.Button("🧪 Test Run Binary", variant="secondary")
                     run_output = gr.Markdown(label="Execution Output")
             
-            # Variables to store state (FIXED: Using None instead of queue.Queue())
+            # Variables to store state
             current_binary_path = gr.State(None)
             compilation_success = gr.State(False)
-            log_queue = gr.State(None)  # Changed from queue.Queue() to None
+            log_queue = gr.State(None)
             
             def update_progress_display(progress, status):
                 """Update the progress bar display"""
@@ -896,10 +917,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 targets..." if extension == ".exe" else "Checking environment..."),
+                        (0.15, "Checking MinGW-w64 for Windows x64 targets..." if extension == ".exe" else "Checking environment..."),
                         (0.2, "Setting up environment..."),
                         (0.3, "Installing requirements..."),
-                        (0.4, f"Starting {'Windows cross-' if extension == '.exe' else ''}compilation..."),
+                        (0.4, f"Starting {'Windows x64 cross-' if extension == '.exe' else ''}compilation..."),
                         (0.5, "Processing imports..."),
                         (0.6, "Optimizing code..."),
                         (0.7, f"Creating {extension} binary..."),
@@ -947,7 +968,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 .exe created)"
+                        final_status += " (Windows x64 .exe created)"
                     
                     yield (
                         gr.update(visible=True),  # progress_section
@@ -1045,13 +1066,14 @@ input('Press Enter to exit...')""",
         
         with gr.TabItem("📖 How to Use"):
             gr.Markdown("""
-            ## 🎯 MinGW-w64 Cross-Compilation
+            ## 🎯 MinGW-w64 Cross-Compilation to Windows 64-bit
             
-            **Proper Windows .exe Generation**
+            **Proper Windows x64 .exe Generation**
             
-            This app now uses the **correct method** for generating Windows .exe files from Linux:
+            This app now uses the **correct method** for generating 64-bit 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
             
@@ -1060,6 +1082,7 @@ input('Press Enter to exit...')""",
             - Visual progress bar with cross-compilation status
             - Automatic MinGW-w64 detection
             - Wine testing support for .exe files
+            - **Explicit 64-bit architecture targeting**
             
             ## 📋 Usage Instructions
             
@@ -1071,13 +1094,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 (proper method)
+            - **Windows (.exe)**: Cross-compiled using MinGW-w64 (64-bit, proper method)
             
             ### 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 binary
+            - Download the resulting 64-bit binary
             
             ### 4. Run Your Binary
             
@@ -1088,7 +1111,7 @@ input('Press Enter to exit...')""",
             ./compiled_program.bin
             ```
             
-            #### For Windows executables:
+            #### For Windows executables (64-bit):
             ```cmd
             # Download the .exe file to Windows
             compiled_program.exe
@@ -1106,7 +1129,7 @@ input('Press Enter to exit...')""",
             
             ## 🔧 MinGW-w64 Requirements
             
-            **For Windows cross-compilation, the following should be pre-installed:**
+            **For Windows 64-bit cross-compilation, the following should be pre-installed:**
             ```bash
             # Ubuntu/Debian
             apt install mingw-w64 gcc-mingw-w64 g++-mingw-w64
@@ -1120,32 +1143,35 @@ input('Press Enter to exit...')""",
             **Windows .exe from Linux (MinGW-w64 method):**
             - ✅ Uses proper MinGW-w64 cross-compiler
             - ✅ Follows official Nuitka documentation
-            - ✅ Produces native Windows executables
+            - ✅ Produces native Windows 64-bit executables
+            - ✅ Explicitly targets x64 architecture
             - ⚠️ 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
             
-            ## 📊 Compilation Methods
+            ## 📊 Architecture Support
             
-            | Method | Reliability | Compatibility | Size | Notes |
-            |--------|------------|---------------|------|-------|
-            | Native Linux | Highest | Best | Medium | Direct compilation |
-            | MinGW-w64 to .exe | High | Good | Large | Proper cross-compilation |
-            | Other methods | Variable | Poor | Variable | Not recommended |
+            | 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 |
             """)
         
         with gr.TabItem("ℹ️ About"):
             gr.Markdown(f"""
             ## 🧠 MinGW-w64 Cross-Compilation Technology
             
-            **Proper Implementation:**
+            **Proper 64-bit Implementation:**
             
             1. **MinGW-w64 Toolchain**: Uses the correct cross-compiler for Windows
             2. **Nuitka Integration**: Proper `--mingw64` flag usage
-            3. **Real-time Monitoring**: Watch MinGW-w64 compilation in real-time
-            4. **Wine Testing**: Optional testing of Windows executables on Linux
-            5. **Automatic Detection**: Checks for required MinGW-w64 components
-            6. **Proper Flags**: Uses `--windows-disable-console` for GUI apps
+            3. **Architecture Targeting**: Explicit `--target-arch=x64` for 64-bit
+            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
             
@@ -1153,10 +1179,12 @@ input('Press Enter to exit...')""",
             
             - ✅ 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**
             
             ## ☁️ Environment Status
             
@@ -1169,6 +1197,7 @@ input('Press Enter to exit...')""",
             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
             ```
             
             ## 📋 Best Practices
@@ -1180,7 +1209,8 @@ 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 on actual Windows systems
+            6. ✅ **Verify 64-bit architecture in compilation logs**
+            7. ✅ Test on actual Windows 64-bit systems
             
             **Package compatibility:**
             
@@ -1188,6 +1218,7 @@ 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
             
@@ -1196,6 +1227,7 @@ 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
             
@@ -1205,25 +1237,32 @@ input('Press Enter to exit...')""",
             
             1. Nuitka converts Python to C code
             2. MinGW-w64 cross-compiles C to Windows PE format
-            3. Static linking reduces Windows dependencies
-            4. Result is a native Windows executable
-            5. Optional Wine testing for basic validation
+            3. **Explicitly targets x64 (64-bit) architecture**
+            4. Static linking reduces Windows dependencies
+            5. Result is a native Windows 64-bit 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
             ```
             
-            This is the **correct and recommended** method for Windows cross-compilation with Nuitka.
+            **Key flags for 64-bit compilation:**
+            - `--mingw64`: Use MinGW-w64 toolchain
+            - `--target-arch=x64`: Explicitly target 64-bit architecture
+            - `--msvc=14.3`: MSVC compatibility mode
+            
+            This ensures **proper 64-bit Windows compatibility**.
             """)
     
     gr.Markdown("---")
-    gr.Markdown("🤖 Created by Claude 3.7 Sonnet | 🚀 Powered by Nuitka + MinGW-w64 | ☁️ Proper cross-compilation | 📊 Real-time logs")
+    gr.Markdown("🤖 Created by Claude 3.7 Sonnet | 🚀 Powered by Nuitka + MinGW-w64 | ☁️ Proper x64 cross-compilation | 📊 Real-time logs")
 
 if __name__ == "__main__":
     # Create necessary directories on startup