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

NAME

       nuitka - the Python compiler

SYNOPSIS

       nuitka [--module] [--execute] [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, --portable
              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   options:   "--recurse-all  --recursestdlib".  You  may  also  want  to  use
              "--pythonflag=no_site" to avoid the "site.py" module. Defaults to off.

       --nofreeze-stdlib
              In standalone mode by default all modules of standard library  will  be  frozen  as
              bytecode.  This  compiles  them  all and as a result compilation time will increase
              very much.

       --python-version=PYTHON_VERSION
              Major version of Python to be used, one  of  '2.6',  '2.7',  '3.2',  '3.3',  '3.4',
              '3.5', or '3.6'. Defaults to what you run Nuitka with (currently 2.7)

       --python-debug, --python-dbg
              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.

       --python2-for-scons=PYTHON2_SCONS
              If using Python3, provide the path of a Python2 binary to use. For Python2 defaults
              to  what  you  run  Nuitka  with,  otherwise searches on Windows in the registry or
              non-Windows in PATH.

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

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

   Control the recursion into imported modules:

       --recurse-stdlib
              Also descend into imported modules from standard library. Defaults to off.

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

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

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

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

       --recurse-plugins=MODULE/PACKAGE, --recurse-directory=MODULE/PACKAGE
              Recurse into 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.

       --recurse-files=PATTERN, --recurse-pattern=PATTERN
              Recurse into files matching the PATTERN. Overrides all recursion other options. Can
              be given multiple times.  Default empty.

   Immediate execution after compilation:

       --run, --execute
              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, --keep-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:

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

       --display-tree
              Display the final result of optimization in a GUI, 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 directory choices:

       --output-dir=DIRECTORY
              Specify where intermediate and final output files should be put. 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.

   Debug features:

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

       --unstripped, --no-strip, --unstriped
              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, --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.

       --mingw
              Enforce the use of MinGW on Windows. Defaults to off.

       --msvc=MSVC
              Enforce the use of specific MSVC version on Windows.  Allowed values are e.g.  9.0,
              9.0exp,  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 (g++ 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, --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.

EXAMPLES

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

              $ nuitka some_module.py

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

              $ nuitka --exe some_program.py

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

              $ nuitka --exe --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  --exe --execute --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 --exe

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

       Note: This will *not* degrade performance:

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

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

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

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