How can i convert python to exe automatically in code

Question

I want to dynamically convert a python file into a .exe. I have already tried using auto-py-to-exe, but it involves the usage of a GUI and does not involve programmatic conversion of the file.

Taking the example of the code provided below, I want to convert the file second.py, into a .exe file, purely using code, and without any manual actions whatsoever.

first.py -:

import os

code = """
print(hello world)
"""

with open("second.py", "w") as second_file:
        second_file.write(code)

convert_to_exe('second.py') # Yet not clear, on how to achieve this.

Answer 1

There isn't one very clean way to make an executable in python, but you can combine two libraries to get the job done:

1. subprocess
2. pyinstaller

You can use subprocess.run('pyinstaller', '--onefile', 'pythonScriptName.py') to get the functionality you're looking for.

You can check out pyinstaller's documentation to add more arguments to the command.

Adding that, your program would look like this:

import os
import subprocess

code = """
print(hello world)
"""

with open("second.py", "w") as second_file:
        second_file.write(code)

subprocess.run('pyinstaller', '--onefile', 'secondfile.py')

You can also use the subprocess library to run that newly made executable as well if that's what you're looking for.

Answer 2

Looking at the question, and based off of the conversation I had in the comments, it seems like the goal here, is to create an exe dynamically/programmatically(completely using code). There are many ways of achieving this, one such way is by using the cx_freeze module.

Using this module, you can write a setup script for the exe and then use a command to build the exe -:

import sys
from cx_Freeze import setup, Executable

# Dependencies are automatically detected, but it might need fine tuning.
build_exe_options = {
    "excludes": ["tkinter", "unittest"],
    "zip_include_packages": ["encodings", "PySide6"],
}

# base="Win32GUI" should be used only for Windows GUI app
base = "Win32GUI" if sys.platform == "win32" else None

setup(
    name="guifoo",
    version="0.1",
    description="My GUI application!",
    options={"build_exe": build_exe_options},
    executables=[Executable("guifoo.py", base=base)],
)

Building the exe -:

python setup.py build

(from docs)

The result of the execution of this command has been described in the docs as follows -:

This command will create a subdirectory called build with a further subdirectory starting with the letters exe. and ending with the typical identifier for the platform and python version. This allows for multiple platforms to be built without conflicts.

---

Furthermore, if you wish to create the exe entirely using code without any separate manual work whatsoever, the configurations need to still be ascertained, but other than that, you can use the subprocess module's call method with shell = True as the argument, to run the command-line command programmatically as well. Somewhat like so -:

import subprocess

def create_exe(code, excludes, zip_include_packages, name, version, description) :
    with open('source_for_exe_file.py', 'w') as f :
        f.write(code)
    
    setup_script = 'import sys\nfrom cx_Freeze import setup, Executable\n# Dependencies are automatically detected, but it might need fine tuning.\nbuild_exe_options = {"excludes" : {excludes}, "zip_include_packages" : {zip_include_packages},}\n# base = "Win32GUI" should be used only for Windows GUI app\nbase = "Win32GUI" if sys.platform == "win32" else None\nsetup(name = {name}, version = {version}, description = {description}, options = {"build_exe" : build_exe_options}, executables = [Executable("source_for_exe.py", base = base)],)'.format(excludes = excludes, zip_include_packages = zip_include_packages, name = name, version = version, description = description)
    with open('setup.py', 'w') as f :
        f.write(setup_script)
    
    result = subprocess.call('python setup.py build', shell = True)
    return result # Just returning any command line output.

Please note that the code provided, has not been tested, and thus it's proper functionality is uncertain, given the lack of proper explanation of the kind of code that can be expected. Also note that, the result of this function will be the creation of the exe in the build folder's subfolder as mentioned in the first approach. The only difference here being that, no manual execution of the command was involved.

---

Also, as mentioned previously in the answer, there are multiple other ways of achieving the same as well, one such way is by using pyinstaller like so -:

import PyInstaller.__main__

PyInstaller.__main__.run([
    'second.py',
    '--onefile',
    '--windowed'
])

Note that, this was partially taken from the docs, with the only modification being the change in the name of the file, but this is a viable and more simplistic approach, if the complex differences are to be ignored.

Also, since py2exe was mentioned in the question, I would suggest having a look at this source. Its a tutorial to create an executable by using a setup script similar to the cx_freeze approach demonstrated above, but with the advantage of simplicity. I must mention though, that the tutorial seems to have been written for python 2.0 and any changes to the method explained there, can cause it to not work for python 3.0.