Ubuntu Manpage: nuitka - the Python compiler

NAME

       nuitka - the Python compiler

SYNOPSIS

       nuitka [--module] [--run] [options] main_module.py

OPTIONS

--version
show program's version number and exit

-h, --help
show this help message and exit

--module
Create an extension module executable instead of a program. Defaults to off.

--standalone
Enable standalone mode in build. This allows you to transfer the created binary to
other machines without it relying on an existing Python installation. It implies
these option: "--recurse-all". You may also want to use "--python-flag=no_site" to
avoid the "site.py" module, which can save a lot of code dependencies. Defaults to
off.

--python-debug
Use debug version or not. Default uses what you are using to run Nuitka, most
likely a non-debug version.

--python-flag=PYTHON_FLAGS
Python flags to use. Default uses what you are using to run Nuitka, this enforces a
specific mode. These are options that also exist to standard Python executable.
Currently supported: "-S" (alias "nosite"), "static_hashes" (not use hash
randomization), "no_warnings" (do not give Python runtime warnings), "-O" (alias
"noasserts"). Default empty.

--python-for-scons=PYTHON_SCONS
If using Python3.3 or Python3.4, provide the path of a Python binary to use for
Scons. Otherwise Nuitka can use what you run Nuitka with or a "scons" binary that
is found in PATH, or a Python installation from Windows registry.

--warn-implicit-exceptions
Enable warnings for implicit exceptions detected at compile time.

--warn-unusual-code
Enable warnings for unusual code detected at compile time.

--assume-yes-for-downloads
Allow Nuitka to download code if necessary, e.g. dependency walker on Windows.

Control the inclusion of modules and packages:

--include-package=PACKAGE
Include a whole package. Give as a Python namespace, e.g.
``some_package.sub_package`` and Nuitka will then find it and include it and all
the modules found below that disk location in the binary or extension module it
creates, and make it available for import by the code. Default empty.

--include-module=MODULE
Include a single module. Give as a Python namespace, e.g.
``some_package.some_module`` and Nuitka will then find it and include it in the
binary or extension module it creates, and make it available for import by the
code. Default empty.

--include-plugin-directory=MODULE/PACKAGE
Include the content of that directory, no matter if it's used by the given main
program in a visible form. Overrides all other recursion options. Can be given
multiple times. Default empty.

--include-plugin-files=PATTERN
Include into files matching the PATTERN. Overrides all recursion other options. Can
be given multiple times. Default empty.

Control the recursion into imported modules:

--follow-stdlib, --recurse-stdlib
Also descend into imported modules from standard library. This will increase the
compilation time by a lot. Defaults to off.

--nofollow-imports, --recurse-none
When --recurse-none is used, do not descend into any imported modules at all,
overrides all other recursion options. Defaults to off.

--follow-imports, --recurse-all
When --recurse-all is used, attempt to descend into all imported modules. Defaults
to off.

--follow-import-to=MODULE/PACKAGE, --recurse-to=MODULE/PACKAGE
Recurse to that module, or if a package, to the whole package. Can be given
multiple times. Default empty.

--nofollow-import-to=MODULE/PACKAGE, --recurse-not-to=MODULE/PACKAGE
Do not recurse to that module name, or if a package name, to the whole package in
any case, overrides all other options. Can be given multiple times. Default empty.

Immediate execution after compilation:

--run Execute immediately the created binary (or import the compiled module). Defaults to
off.

--debugger, --gdb
Execute inside "gdb" to automatically get a stack trace. Defaults to off.

--execute-with-pythonpath
When immediately executing the created binary (--execute), don't reset PYTHONPATH.
When all modules are successfully included, you ought to not need PYTHONPATH
anymore.

Dump options for internal tree:

--xml Dump the final result of optimization as XML, then exit.

Code generation choices:

--full-compat
Enforce absolute compatibility with CPython. Do not even allow minor deviations
from CPython behavior, e.g. better tracebacks, which are not really incompatible,
but different. This is intended for tests only and should not be necessary for
normal use.

--file-reference-choice=FILE_REFERENCE_MODE
Select what value "__file__" is going to be. With "runtime" (default for standalone
binary mode and module mode), the created binaries and modules, use the location of
themselves to deduct the value of "__file__". Included packages pretend to be in
directories below that location. This allows you to include data files in
deployments. If you merely seek acceleration, it's better for you to use the
"original" value, where the source files location will be used. With "frozen" a
notation "<frozen module_name>" is used. For compatibility reasons, the "__file__"
value will always have ".py" suffix independent of what it really is.

Output choices:

-o FILENAME
Specify how the executable should be named. For extension modules there is no
choice, also not for standalone mode and using it will be an error. This may
include path information that needs to exist though. Defaults to <program_name> on
this platform. .bin

--output-dir=DIRECTORY
Specify where intermediate and final output files should be put. The DIRECTORY will
be populated with C files, object files, etc. Defaults to current directory.

--remove-output
Removes the build directory after producing the module or exe file. Defaults to
off.

--no-pyi-file
Do not create a ".pyi" file for extension modules created by Nuitka. This is used
to detect implicit imports. Defaults to off.

Debug features:

--debug
Executing all self checks possible to find errors in Nuitka, do not use for
production. Defaults to off.

--unstripped
Keep debug info in the resulting object file for better debugger interaction.
Defaults to off.

--profile
Enable vmprof based profiling of time spent. Defaults to off.

--graph
Create graph of optimization process. Defaults to off.

--trace-execution
Traced execution output, output the line of code before executing it. Defaults to
off.

--recompile-c-only
Take existing files and compile them again. Allows compiling edited C files with
the C compiler for quick debugging changes to the generated source. Defaults to
off. Depends on compiling Python source to determine which files it should look at.

--generate-c-only
Generate only C source code, and do not compile it to binary or module. This is for
debugging and code coverage analysis that doesn't waste CPU. Defaults to off.

--experimental=EXPERIMENTAL
Use features declared as 'experimental'. May have no effect if no experimental
features are present in the code. Uses secret tags (check source) per experimented
feature.

Backend C compiler choice:

--clang
Enforce the use of clang (needs clang 3.2 or higher). Defaults to off.

--mingw64
Enforce the use of MinGW64 on Windows. Defaults to off.

--msvc=MSVC
Enforce the use of specific MSVC version on Windows. Allowed values are e.g. 14.0,
specify an illegal value for a list of installed compilers. Defaults to the most
recent version.

-j N, --jobs=N
Specify the allowed number of parallel C compiler jobs. Defaults to the system CPU
count.

--lto Use link time optimizations if available and usable (gcc 4.6 and higher). Defaults
to off.

Tracing features:

--show-scons
Operate Scons in non-quiet mode, showing the executed commands. Defaults to off.

--show-progress
Provide progress information and statistics. Defaults to off.

--show-memory
Provide memory information and statistics. Defaults to off.

--show-modules
Provide a final summary on included modules. Defaults to off.

--verbose
Output details of actions taken, esp. in optimizations. Can become a lot. Defaults
to off.

Windows specific output control:

--windows-disable-console
When compiling for Windows, disable the console window. Defaults to off.

--windows-icon=ICON_PATH
Add executable icon (Windows only).

Plugin control:

--plugin-enable=PLUGINS_ENABLED, --enable-plugin=PLUGINS_ENABLED
Enabled plugins. Must be plug-in names. Use --pluginlist to query the full list and
exit. Default empty.

--plugin-disable=PLUGINS_DISABLED, --disable-plugin=PLUGINS_DISABLED
Disabled plugins. Must be plug-in names. Use --pluginlist to query the full list
and exit. Default empty.

--plugin-no-detection
Plugins can detect if they might be used, and the you can disable the warning via
--plugin-disable=pluginthat-warned, or you can use this option to disable the
mechanism entirely, which also speeds up compilation slightly of course as this
detection code is run in vain once you are certain of which plug-ins to use.
Defaults to off.

--plugin-list
Show list of all available plugins and exit. Defaults to off.

--user-plugin=USER_PLUGINS
The file name of user plugin. Can be given multiple times. Default empty.

Python: 2.7.13 (default, Sep 26 2018, 18:42:22) Executable: /usr/bin/python2 OS: Linux
Arch: armv7l

EXAMPLES

       Compile a Python file "some_module.py" to a module "some_module.so":

              $ nuitka --module some_module.py

       Compile a Python program "some_program.py" to an executable "some_program.exe":

              $ nuitka some_program.py

       Compile  a  Python  program "some_program.py" and the package "some_package" it uses to an
       executable "some_program.exe":

              $ nuitka --recurse-to=some_package some_program.py

       Compile a Python program "some_program.py" and all the modules it uses  to  an  executable
       "some_program.exe". Then execute it immediately when ready:

              $ nuitka --run --recurse-all some_program.py

       Compile a Python program "some_program.py" and the modules it uses (even standard library)
       to an executable "some_program.exe":

              $ nuitka --recurse-all --recurse-stdlib some_program.py

       Compile a Python program "some_program.py" and  the  modules  it  uses  to  an  executable
       "some_program.exe". Keep the debug information, so valgrind, gdb, etc. work nicely.

       Note: This will *not* degrade performance:

              $ nuitka --unstriped --recurse-all some_program.py

       Compile  a  Python  program  "some_program.py"  and  the  modules it uses to an executable
       "some_program.exe". Perform all kinds of checks about correctness of the generated  C  and
       run-time checks.

       Note: This will degrade performance and should only be used to debug Nuitka:

              $ nuitka --debug --recurse-all some_program.py

       Compile  a  Python  program  "some_program.py"  and  the  modules it uses to an executable
       "some_program.exe". Perform all kinds of checks about correctness of the generated  C  and
       run-time checks. Also use the debug Python library, which does its own checks.

       Note: This will degrade performance and should only be used to debug Nuitka:

              $ nuitka --debug --python-debug --recurse-all some_program.py

       Compile a Python program "some_program.py" and the plugins modules it loads at run time to
       an executable "some_program.exe":

              $ nuitka --recurse-all --recurse-directory=plugins_dir some_program.py