Provided by: nuitka_0.6.19.1+ds-1_all bug

NAME

       nuitka-run - the Python compiler

SYNOPSIS

       nuitka-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 for output. This allows you to transfer the created binary
              to other machines without it using an existing Python installation. This also means
              it will become big. It implies these option: "-- follow-imports". You may also want
              to use "--pythonflag=no_site" to avoid the "site.py" module, which can save  a  lot
              of code dependencies. Defaults to off.

       --onefile
              On  top  of  standalone  mode,  enable onefile mode. This means not a folder, but a
              compressed executable is created and used. 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=FLAG
              Python  flags  to use. Default is 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  "no_site"),  "static_hashes"  (do not use hash
              randomization), "no_warnings" (do not give Python runtime  warnings),  "-O"  (alias
              "no_asserts"), "no_docstrings" (do not use docstrings), and "-m".  Default empty.

       --python-for-scons=PATH
              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  external  code  if  necessary, e.g. dependency walker,
              ccache, and even gcc on Windows. To disable, redirect input from nul  device,  e.g.
              "</dev/null" or "<NUL:". Default is to prompt.

              Control the inclusion of modules and packages in result.:

       --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.  To  avoid  unwanted  sub
              packages,  e.g. tests you can e.g. do this "--nofollow-import-to=*.tests".  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 inclusion  options.  Can  be  given
              multiple times. Default empty.

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

       --prefer-source-code
              For already compiled extension modules, where there is both a source  file  and  an
              extension module, normally the extension module is used, but it should be better to
              compile the module from available source code for best performance. If not desired,
              there is --noprefer-source-code to disable warnings about it.  Default off.

              Control the following into imported modules:

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

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

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

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

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

              Data files for standalone/onefile mode:

       --include-package-data=PACKAGE
              Include  data  files of the given package name. Can use patterns. By default Nuitka
              does not unless hard coded and vital for operation of a package. This will  include
              all non-DLL, non-extension modules in the distribution. Default empty.

       --include-data-file=DESC
              Include data files by filenames in the distribution.  There are many allowed forms.
              With '--include-datafile=/path/to/file/*.txt=folder_name/some.txt' it will  copy  a
              single       file      and      complain      if      it's      multiple.      With
              '--include-datafile=/path/to/files/*.txt=folder_name/' it  will  put  all  matching
              files  into  that  folder.  For  recursive  copy there is a form with 3 values that
              '--includedata-file=/path/to/scan=folder_name=**/*.txt'    that    will    preserve
              directory structure. Default empty.

       --include-data-dir=DIRECTORY
              Include  data files from complete directory in the distribution. This is recursive.
              Check '--includedata-file' with patterns if you want  non-recursive  inclusion.  An
              example  would be '--include-datadir=/path/somedir=data/somedir' for plain copy, of
              the whole directory. All files are copied, if you want to exclude files you need to
              remove them beforehand.  Default empty.

              Immediate execution after compilation:

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

       --debugger, --gdb
              Execute inside a debugger, e.g. "gdb" or "lldb" 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. not having  better  tracebacks  or  exception  messages
              which  are  not really incompatible, but only different. This is intended for tests
              only and should not be used for normal use.

       --file-reference-choice=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. Not working currently. Defaults to
              off.

       --internal-graph
              Create graph of optimization process internals, do not use for whole programs,  but
              only for small test cases.  Defaults to off.

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

       --recompile-c-only
              This is not  incremental  compilation,  but  for  Nuitka  development  only.  Takes
              existing  files and simply compile them as C again. Allows compiling edited C files
              for quick debugging changes to the generated source, e.g. to see if code is  passed
              by,  values  output,  etc,  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. Do
              not think you can use this directly.

       --experimental=FLAG
              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.

       --low-memory
              Attempt to use less memory, by forking less C compilation jobs  and  using  options
              that  use  less  memory.  For  use on embedded machines. Use this in case of out of
              memory problems. Defaults to off.

              Backend C compiler choice:

       --clang
              Enforce the use of clang. On Windows this requires a working Visual Studio  version
              to piggy back on.  Defaults to off.

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

       --msvc=MSVC_VERSION
              Enforce  the  use  of  specific  MSVC  version on Windows.  Allowed values are e.g.
              "14.2" (MSVC 2019), specify an illegal value for a list of installed compilers,  or
              use  "latest".  Notice  that  only latest MSVC is really supported, and you can use
              "latest" to enforce that.  Defaults to MSVC on Windows  being  used  if  installed,
              otherwise MinGW64.

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

       --lto=choice
              Use link time optimizations (MSVC, gcc, clang).  Allowed values  are  "yes",  "no",
              and "auto" (when it's known to work). Defaults to "auto".

       --static-libpython=choice
              Use static link library of Python. Allowed values are "yes", "no", and "auto" (when
              it's known to work).  Defaults to "auto".

       --disable-ccache
              Do not attempt to use ccache (gcc, clang, etc.) or clcache (MSVC, clangcl).

              PGO compilation choices:

       --pgo  Enables C level profile guided optimization (PGO), by executing a  dedicated  build
              first  for  a  profiling  run,  and  then  using  the result to feedback into the C
              compilation. Note: This is experimental and not working with  standalone  modes  of
              Nuitka yet. Defaults to off.

       --pgo-args=PGO_ARGS
              Arguments  to be passed in case of profile guided optimization. These are passed to
              the special built executable during the PGO profiling run. Default empty.

       --pgo-executable=PGO_EXECUTABLE
              Command to execute when collecting profile information. Use this only, if you  need
              to launch it through a script that prepares it to run. Default use created program.

              Tracing features:

       --quiet
              Disable all information outputs, but show warnings.  Defaults to off.

       --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.

       --no-progressbar
              Disable progress bar outputs (if tqdm is installed).  Defaults to off.

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

       --show-modules
              Provide information for included modules and DLLs Defaults to off.

       --show-modules-output=PATH
              Where to output --show-modules, should be a filename.  Default is standard output.

       --report=COMPILATION_REPORT_FILENAME
              Report module inclusion in an XML output file. Default is off.

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

       --verbose-output=PATH
              Where to output --verbose, should be a filename.  Default is standard output.

              Windows specific controls:

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

       --windows-icon-from-ico=ICON_PATH
              Add executable icon. Can be given multiple times for different resolutions or files
              with  multiple icons inside. In the later case, you may also suffix with #<n> where
              n is an integer index starting from 1, specifying a specific icon to  be  included,
              and all others to be ignored.

       --windows-icon-from-exe=ICON_EXE_PATH
              Copy executable icons from this existing executable (Windows only).

       --onefile-windows-splash-screen-image=SPLASH_SCREEN_IMAGE
              When  compiling  for  Windows and onefile, show this while loading the application.
              Defaults to off.

       --windows-uac-admin
              Request Windows User Control, to grant admin rights on execution.  (Windows  only).
              Defaults to off.

       --windows-uac-uiaccess
              Request  Windows  User  Control, to enforce running from a few folders only, remote
              desktop access. (Windows only). Defaults to off.

       --windows-company-name=WINDOWS_COMPANY_NAME
              Name of the company to use in Windows Version information.  One of file or  product
              version  is  required,  when  a version resource needs to be added, e.g. to specify
              product name, or company name.  Defaults to unused.

       --windows-product-name=WINDOWS_PRODUCT_NAME
              Name of the product to  use  in  Windows  Version  information.  Defaults  to  base
              filename of the binary.

       --windows-file-version=WINDOWS_FILE_VERSION
              File  version to use in Windows Version information.  Must be a sequence of up to 4
              numbers, e.g. 1.0.0.0, only this format is allowed. One of file or product  version
              is  required,  when  a  version resource needs to be added, e.g. to specify product
              name, or company name. Defaults to unused.

       --windows-product-version=WINDOWS_PRODUCT_VERSION
              Product version to use in Windows Version information.  Must be a sequence of up to
              4  numbers,  e.g.  1.0.0.0,  only  this  format  is allowed. One of file or product
              version is required, when a version resource needs to be  added,  e.g.  to  specify
              product name, or company name. Defaults to unused.

       --windows-file-description=WINDOWS_FILE_DESCRIPTION
              Description of the file use in Windows Version information.  One of file or product
              version is required, when a version resource needs to be  added,  e.g.  to  specify
              product name, or company name.  Defaults to nonsense.

       --windows-onefile-tempdir-spec=ONEFILE_TEMPDIR_SPEC
              Use  this  as  a  temporary folder. Defaults to '%TEMP%\onefile_%PID%_%TIME%', i.e.
              system temporary directory.

       --windows-force-stdout-spec=WINDOWS_FORCE_STDOUT_SPEC
              Force standard output of the program to go to this location.  Useful  for  programs
              with  disabled  console  and  programs using the Windows Services Plugin of Nuitka.
              Defaults to not active, use e.g.  '%PROGRAM%.out.txt', i.e. file near your program.

       --windows-force-stderr-spec=WINDOWS_FORCE_STDERR_SPEC
              Force standard error of the program to go to this  location.  Useful  for  programs
              with  disabled  console  and  programs using the Windows Services Plugin of Nuitka.
              Defaults to not active, use e.g.  '%PROGRAM%.err.txt', i.e. file near your program.

              macOS specific controls:

       --macos-onefile-icon=ICON_PATH
              Add executable icon for binary to use. Can be given  only  one  time.  Defaults  to
              Python icon if available.

       --macos-disable-console
              When  compiling for macOS, disable the console window and create a GUI application.
              Defaults to off.

       --macos-create-app-bundle
              When compiling for macOS, create a bundle rather than a plain  binary  application.
              Currently  experimental  and  incomplete.  Currently this is the only way to unlock
              disabling of console.Defaults to off.

       --macos-signed-app-name=MACOS_SIGNED_APP_NAME
              Name of the application to use for macOS signing.   Follow  com.yourcompany.appname
              naming  results  for  best  results,  as these have to be globally unique, and will
              grant protected API accesses.

       --macos-app-name=MACOS_APP_NAME
              Name of the product to use in macOS bundle information. Defaults to  base  filename
              of the binary.

       --macos-app-version=MACOS_APP_VERSION
              Product version to use in macOS bundle information.  Defaults to 1.0 if not given.

              Linux specific controls:

       --linux-onefile-icon=ICON_PATH
              Add executable icon for onefile binary to use. Can be given only one time. Defaults
              to Python icon if available.

              Plugin control:

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

       --disable-plugin=PLUGIN_NAME, --plugin-disable=PLUGIN_NAME
              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
              "--disable-plugin=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 plugins to use.
              Defaults to off.

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

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

       --persist-source-changes
              Write source changes to original Python files. Use with care. May need permissions,
              best  for  use  in  a virtualenv to debug if plugin code changes work with standard
              Python or to benefit from bloat removal even with pure Python. Default False.

       Commercial: None Python: 3.7.3 (default, Jan 22  2021,  20:04:44)  Flavor:  Debian  Python
       Executable: /usr/bin/python3 OS: Linux Arch: x86_64 Distribution: Debian 10.9

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