def _expandProjectArg(arg, filename_arg, for_eval):
def wrap(value):
if for_eval:
return repr(value)
else:
return value
values = {
"OS": wrap(Utils.getOS()),
"Arch": wrap(Utils.getArchitecture()),
"Version": getNuitkaVersion(),
"MAIN_DIRECTORY": wrap(os.path.dirname(filename_arg) or "."),
}
arg = arg.format(**values)
return arg
# other defaults and work a bit different with parameters.
is_nuitka_run = os.path.basename(sys.argv[0]).lower().endswith("-run")
if not is_nuitka_run:
usage = "usage: %prog [--module] [--run] [options] main_module.py"
else:
usage = "usage: %prog [options] main_module.py"
parser = OptionParser(
usage=usage,
version="\n".join((
getNuitkaVersion(),
"Python: " + sys.version.split("\n")[0],
"Executable: " + sys.executable,
"OS: " + Utils.getOS(),
"Arch: " + Utils.getArchitecture(),
)),
)
parser.add_option(
"--module",
action="store_false",
dest="executable",
default=True,
help="""\
Create an extension module executable instead of a program. Defaults to off.""",
)
parser.add_option(
"--standalone",
action="store_true",
def runScons(main_module, quiet):
# Scons gets transported many details, that we express as variables, and
# have checks for them, leading to many branches and statements,
# pylint: disable=too-many-branches,too-many-statements
options = {
"name" : os.path.basename(
getTreeFilenameWithSuffix(main_module, "")
),
"result_name" : getResultBasepath(main_module),
"source_dir" : getSourceDirectoryPath(main_module),
"debug_mode" : _asBoolStr(Options.isDebug()),
"python_debug" : _asBoolStr(Options.isPythonDebug()),
"unstripped_mode" : _asBoolStr(Options.isUnstripped()),
"module_mode" : _asBoolStr(Options.shallMakeModule()),
"full_compat" : _asBoolStr(Options.isFullCompat()),
"experimental" : ','.join(Options.getExperimentalIndications()),
"trace_mode" : _asBoolStr(Options.shallTraceExecution()),
"python_version" : python_version_str,
"target_arch" : Utils.getArchitecture(),
"python_prefix" : sys.prefix,
"nuitka_src" : SconsInterface.getSconsDataPath(),
"nuitka_cache" : getCacheDir(),
"module_count" : "%d" % (
1 + \
len(ModuleRegistry.getDoneUserModules()) + \
len(ModuleRegistry.getUncompiledNonTechnicalModules())
)
}
if not Options.shallMakeModule():
options["result_exe"] = getResultFullpath(main_module)
# Ask Scons to cache on Windows, except where the directory is thrown
# away. On non-Windows you can should use ccache instead.
if not Options.isRemoveBuildDir() and Utils.getOS() == "Windows":
options["cache_mode"] = "true"
if Options.isLto():
options["lto_mode"] = "true"
if Options.shallDisableConsoleWindow():
options["win_disable_console"] = "true"
if Options.isStandaloneMode():
options["standalone_mode"] = "true"
if not Options.isStandaloneMode() and \
not Options.shallMakeModule() and \
isUninstalledPython():
options["uninstalled_python"] = "true"
if ModuleRegistry.getUncompiledTechnicalModules():
options["frozen_modules"] = str(
len(ModuleRegistry.getUncompiledTechnicalModules())
)
if Options.isShowScons():
options["show_scons"] = "true"
if Options.isMingw64():
options["mingw_mode"] = "true"
if Options.getMsvcVersion():
msvc_version = Options.getMsvcVersion()
msvc_version = msvc_version.replace("exp", "Exp")
if '.' not in msvc_version:
msvc_version += ".0"
options["msvc_version"] = msvc_version
if Options.isClang():
options["clang_mode"] = "true"
if Options.getIconPath():
options["icon_path"] = Options.getIconPath()
if Options.isProfile():
options["profile_mode"] = "true"
if "no_warnings" in getPythonFlags():
options["no_python_warnings"] = "true"
if python_version < 300 and sys.flags.py3k_warning:
options["python_sysflag_py3k_warning"] = "true"
if python_version < 300 and (sys.flags.division_warning or sys.flags.py3k_warning):
options["python_sysflag_division_warning"] = "true"
if sys.flags.bytes_warning:
options["python_sysflag_bytes_warning"] = "true"
if int(os.environ.get("NUITKA_SITE_FLAG", "no_site" in Options.getPythonFlags())):
options["python_sysflag_no_site"] = "true"
if "trace_imports" in Options.getPythonFlags():
options["python_sysflag_verbose"] = "true"
if python_version < 300 and sys.flags.unicode:
options["python_sysflag_unicode"] = "true"
if python_version >= 370 and sys.flags.utf8_mode:
options["python_sysflag_utf8"] = "true"
abiflags = getPythonABI()
if abiflags:
options["abiflags"] = abiflags
return SconsInterface.runScons(options, quiet), options
def runScons(main_module, quiet):
# Scons gets transported many details, that we express as variables, and
# have checks for them, leading to many branches, pylint: disable=R0912
python_version_str = "%d.%d" % (sys.version_info[0], sys.version_info[1])
if hasattr(sys, "abiflags"):
if Options.isPythonDebug() or \
hasattr(sys, "getobjects"):
if sys.abiflags.startswith('d'):
python_version_str += sys.abiflags
else:
python_version_str += 'd' + sys.abiflags
else:
python_version_str += sys.abiflags
def asBoolStr(value):
return "true" if value else "false"
options = {
"name" : Utils.basename(
getTreeFilenameWithSuffix(main_module, "")
),
"result_name" : getResultBasepath(main_module),
"source_dir" : getSourceDirectoryPath(main_module),
"debug_mode" : asBoolStr(Options.isDebug()),
"python_debug" : asBoolStr(Options.isPythonDebug()),
"unstripped_mode" : asBoolStr(Options.isUnstripped()),
"module_mode" : asBoolStr(Options.shallMakeModule()),
"optimize_mode" : asBoolStr(Options.isOptimize()),
"full_compat" : asBoolStr(Options.isFullCompat()),
"experimental" : asBoolStr(Options.isExperimental()),
"trace_mode" : asBoolStr(Options.shallTraceExecution()),
"python_version" : python_version_str,
"target_arch" : Utils.getArchitecture(),
"python_prefix" : sys.prefix,
"nuitka_src" : SconsInterface.getSconsDataPath(),
"module_count" : "%d" % (
len(ModuleRegistry.getDoneUserModules()) + 1
)
}
# Ask Scons to cache on Windows, except where the directory is thrown
# away. On non-Windows you can should use ccache instead.
if not Options.isRemoveBuildDir() and Utils.getOS() == "Windows":
options["cache_mode"] = "true"
if Options.isLto():
options["lto_mode"] = "true"
if Options.shallDisableConsoleWindow():
options["win_disable_console"] = "true"
if Options.isStandaloneMode():
options["standalone_mode"] = "true"
if not Options.isStandaloneMode() and \
not Options.shallMakeModule() and \
isUninstalledPython():
options["uninstalled_python"] = "true"
if ModuleRegistry.getUncompiledModules():
options["frozen_modules"] = str(
len(ModuleRegistry.getUncompiledModules())
)
if Options.isShowScons():
options["show_scons"] = "true"
if Options.isMingw():
options["mingw_mode"] = "true"
if Options.getMsvcVersion():
msvc_version = Options.getMsvcVersion()
msvc_version = msvc_version.replace("exp", "Exp")
if '.' not in msvc_version:
msvc_version += ".0"
options["msvc_version"] = msvc_version
if Options.isClang():
options["clang_mode"] = "true"
if Options.getIconPath():
options["icon_path"] = Options.getIconPath()
if Options.isProfile():
options["profile_mode"] = "true"
return SconsInterface.runScons(options, quiet), options
def getDependsExePath():
""" Return the path of depends.exe (for Windows).
Will prompt the user to download if not already cached in AppData
directory for Nuitka.
"""
if Utils.getArchitecture() == "x86":
depends_url = "http://dependencywalker.com/depends22_x86.zip"
else:
depends_url = "http://dependencywalker.com/depends22_x64.zip"
if "APPDATA" not in os.environ:
sys.exit("Error, standalone mode cannot find 'APPDATA' environment.")
nuitka_app_dir = os.path.join(os.environ["APPDATA"], "nuitka")
if not os.path.isdir(nuitka_app_dir):
makePath(nuitka_app_dir)
nuitka_depends_zip = os.path.join(nuitka_app_dir,
os.path.basename(depends_url))
if not os.path.isfile(nuitka_depends_zip):
Tracing.printLine("""\
Nuitka will make use of Dependency Walker (http://dependencywalker.com) tool
to analyze the dependencies of Python extension modules. Is it OK to download
and put it in APPDATA (no installer needed, cached, one time question).""")
reply = raw_input("Proceed and download? [Yes]/No ")
if reply.lower() in ("no", 'n'):
sys.exit(
"Nuitka does not work in --standalone on Windows without.")
info("Downloading '%s'" % depends_url)
urlretrieve(depends_url, nuitka_depends_zip)
nuitka_depends_dir = os.path.join(nuitka_app_dir, Utils.getArchitecture())
if not os.path.isdir(nuitka_depends_dir):
os.makedirs(nuitka_depends_dir)
depends_exe = os.path.join(nuitka_depends_dir, "depends.exe")
if not os.path.isfile(depends_exe):
info("Extracting to '%s'" % depends_exe)
import zipfile
try:
depends_zip = zipfile.ZipFile(nuitka_depends_zip)
depends_zip.extractall(nuitka_depends_dir)
except Exception: # Catching anything zip throws, pylint:disable=W0703
info("Problem with the downloaded zip file, deleting it.")
deleteFile(depends_exe, must_exist=False)
deleteFile(nuitka_depends_zip, must_exist=True)
sys.exit("Error, need '%s' as extracted from '%s'." %
(depends_exe, depends_url))
assert os.path.isfile(depends_exe)
return depends_exe
def runSconsBackend(quiet):
# Scons gets transported many details, that we express as variables, and
# have checks for them, leading to many branches and statements,
# pylint: disable=too-many-branches,too-many-statements
asBoolStr = SconsInterface.asBoolStr
options = {
"result_name": OutputDirectories.getResultBasepath(onefile=False),
"source_dir": OutputDirectories.getSourceDirectoryPath(),
"debug_mode": asBoolStr(Options.is_debug),
"python_debug": asBoolStr(Options.isPythonDebug()),
"unstripped_mode": asBoolStr(Options.isUnstripped()),
"module_mode": asBoolStr(Options.shallMakeModule()),
"full_compat": asBoolStr(Options.is_fullcompat),
"experimental": ",".join(Options.getExperimentalIndications()),
"trace_mode": asBoolStr(Options.shallTraceExecution()),
"python_version": python_version_str,
"target_arch": Utils.getArchitecture(),
"python_prefix": getDirectoryRealPath(sys.prefix),
"nuitka_src": SconsInterface.getSconsDataPath(),
"module_count": "%d"
% (
1
+ len(ModuleRegistry.getDoneModules())
+ len(ModuleRegistry.getUncompiledNonTechnicalModules())
),
}
if not Options.shallMakeModule():
options["result_exe"] = OutputDirectories.getResultFullpath(onefile=False)
if Options.shallUseStaticLibPython():
options["static_libpython"] = asBoolStr(True)
if Options.isStandaloneMode():
options["standalone_mode"] = asBoolStr(True)
if Options.isOnefileMode():
options["onefile_mode"] = asBoolStr(True)
if Options.isWindowsOnefileTempDirMode():
options["onefile_temp_mode"] = asBoolStr(True)
if Options.getForcedStdoutPath():
options["forced_stdout_path"] = Options.getForcedStdoutPath()
if Options.getForcedStderrPath():
options["forced_stderr_path"] = Options.getForcedStderrPath()
if Options.shallTreatUninstalledPython():
options["uninstalled_python"] = asBoolStr(True)
if ModuleRegistry.getUncompiledTechnicalModules():
options["frozen_modules"] = str(
len(ModuleRegistry.getUncompiledTechnicalModules())
)
if Utils.getOS() == "Windows":
options["noelf_mode"] = asBoolStr(True)
if Options.isProfile():
options["profile_mode"] = asBoolStr(True)
if "no_warnings" in getPythonFlags():
options["no_python_warnings"] = asBoolStr(True)
if "no_asserts" in getPythonFlags():
options["python_sysflag_optimize"] = asBoolStr(True)
if python_version < 0x300 and sys.flags.py3k_warning:
options["python_sysflag_py3k_warning"] = asBoolStr(True)
if python_version < 0x300 and (
sys.flags.division_warning or sys.flags.py3k_warning
):
options["python_sysflag_division_warning"] = asBoolStr(True)
if sys.flags.bytes_warning:
options["python_sysflag_bytes_warning"] = asBoolStr(True)
if int(os.environ.get("NUITKA_SITE_FLAG", Options.hasPythonFlagNoSite())):
options["python_sysflag_no_site"] = asBoolStr(True)
if "trace_imports" in Options.getPythonFlags():
options["python_sysflag_verbose"] = asBoolStr(True)
if "no_randomization" in Options.getPythonFlags():
options["python_sysflag_no_randomization"] = asBoolStr(True)
if python_version < 0x300 and sys.flags.unicode:
options["python_sysflag_unicode"] = asBoolStr(True)
if python_version >= 0x370 and sys.flags.utf8_mode:
options["python_sysflag_utf8"] = asBoolStr(True)
abiflags = getPythonABI()
if abiflags:
options["abiflags"] = abiflags
if Options.shallMakeModule():
options["module_suffix"] = getSharedLibrarySuffix(preferred=True)
SconsInterface.setCommonOptions(options)
return (
SconsInterface.runScons(
options=options, quiet=quiet, scons_filename="Backend.scons"
),
options,
)
def getDependsExePath():
""" Return the path of depends.exe (for Windows).
Will prompt the user to download if not already cached in AppData
directory for Nuitka.
"""
if Utils.getArchitecture() == "x86":
depends_url = "http://dependencywalker.com/depends22_x86.zip"
else:
depends_url = "http://dependencywalker.com/depends22_x64.zip"
nuitka_app_dir = getAppDir()
nuitka_depends_dir = os.path.join(nuitka_app_dir, Utils.getArchitecture())
nuitka_depends_zip = os.path.join(nuitka_depends_dir,
os.path.basename(depends_url))
depends_exe = os.path.join(nuitka_depends_dir, "depends.exe")
makePath(nuitka_depends_dir)
if not os.path.isfile(nuitka_depends_zip) and not os.path.isfile(
depends_exe):
if assumeYesForDownloads():
reply = "y"
else:
Tracing.printLine("""\
Nuitka will make use of Dependency Walker (http://dependencywalker.com) tool
to analyze the dependencies of Python extension modules. Is it OK to download
and put it in "%s".
No installer needed, cached, one time question.
Proceed and download? [Yes]/No """ % (nuitka_app_dir))
Tracing.flushStdout()
reply = raw_input()
if reply.lower() in ("no", "n"):
sys.exit(
"Nuitka does not work in --standalone on Windows without.")
info("Downloading '%s'" % depends_url)
try:
urlretrieve(depends_url, nuitka_depends_zip)
except Exception: # Any kind of error, pylint: disable=broad-except
sys.exit("""Failed to download '%s'.\
Contents should manually be extracted to '%s'.""" %
(depends_url, nuitka_depends_dir))
if not os.path.isfile(depends_exe):
info("Extracting to '%s'" % depends_exe)
import zipfile
try:
depends_zip = zipfile.ZipFile(nuitka_depends_zip)
depends_zip.extractall(nuitka_depends_dir)
except Exception: # Catching anything zip throws, pylint: disable=broad-except
info("Problem with the downloaded zip file, deleting it.")
deleteFile(depends_exe, must_exist=False)
deleteFile(nuitka_depends_zip, must_exist=True)
sys.exit("Error, need '%s' as extracted from '%s'." %
(depends_exe, depends_url))
assert os.path.isfile(depends_exe)
return depends_exe
def runSconsBackend(quiet):
# Scons gets transported many details, that we express as variables, and
# have checks for them, leading to many branches and statements,
# pylint: disable=too-many-branches,too-many-statements
asBoolStr = SconsInterface.asBoolStr
options = {
"result_name":
OutputDirectories.getResultBasepath(onefile=False),
"source_dir":
OutputDirectories.getSourceDirectoryPath(),
"debug_mode":
asBoolStr(Options.is_debug),
"python_debug":
asBoolStr(Options.isPythonDebug()),
"unstripped_mode":
asBoolStr(Options.isUnstripped()),
"module_mode":
asBoolStr(Options.shallMakeModule()),
"full_compat":
asBoolStr(Options.is_fullcompat),
"experimental":
",".join(Options.getExperimentalIndications()),
"trace_mode":
asBoolStr(Options.shallTraceExecution()),
"python_version":
python_version_str,
"target_arch":
Utils.getArchitecture(),
"python_prefix":
getDirectoryRealPath(sys.prefix),
"nuitka_src":
SconsInterface.getSconsDataPath(),
"module_count":
"%d" % (1 + len(ModuleRegistry.getDoneModules()) +
len(ModuleRegistry.getUncompiledNonTechnicalModules())),
}
if not Options.shallMakeModule():
options["result_exe"] = OutputDirectories.getResultFullpath()
# Ask Scons to cache on Windows, except where the directory is thrown
# away. On non-Windows you can should use ccache instead.
if not Options.isRemoveBuildDir() and Utils.getOS() == "Windows":
options["cache_mode"] = "true"
if Options.isLto():
options["lto_mode"] = asBoolStr(True)
if Options.shallUseStaticLibPython():
options["static_libpython"] = asBoolStr(True)
if Options.shallDisableConsoleWindow():
options["win_disable_console"] = asBoolStr(True)
if Options.isStandaloneMode():
options["standalone_mode"] = asBoolStr(True)
if Options.shallTreatUninstalledPython():
options["uninstalled_python"] = asBoolStr(True)
if ModuleRegistry.getUncompiledTechnicalModules():
options["frozen_modules"] = str(
len(ModuleRegistry.getUncompiledTechnicalModules()))
if Options.isShowScons():
options["show_scons"] = asBoolStr(True)
if Options.isMingw64():
options["mingw_mode"] = asBoolStr(True)
if Options.getMsvcVersion():
msvc_version = Options.getMsvcVersion()
msvc_version = msvc_version.replace("exp", "Exp")
if "." not in msvc_version:
msvc_version += ".0"
options["msvc_version"] = msvc_version
if Utils.getOS() == "Windows":
options["noelf_mode"] = asBoolStr(True)
if Options.isClang():
options["clang_mode"] = asBoolStr(True)
if Options.isProfile():
options["profile_mode"] = asBoolStr(True)
if "no_warnings" in getPythonFlags():
options["no_python_warnings"] = asBoolStr(True)
if "no_asserts" in getPythonFlags():
options["python_sysflag_optimize"] = asBoolStr(True)
if python_version < 0x300 and sys.flags.py3k_warning:
options["python_sysflag_py3k_warning"] = asBoolStr(True)
if python_version < 0x300 and (sys.flags.division_warning
or sys.flags.py3k_warning):
options["python_sysflag_division_warning"] = asBoolStr(True)
if sys.flags.bytes_warning:
options["python_sysflag_bytes_warning"] = asBoolStr(True)
if int(
os.environ.get("NUITKA_SITE_FLAG", "no_site"
in Options.getPythonFlags())):
options["python_sysflag_no_site"] = asBoolStr(True)
if "trace_imports" in Options.getPythonFlags():
options["python_sysflag_verbose"] = asBoolStr(True)
if "no_randomization" in Options.getPythonFlags():
options["python_sysflag_no_randomization"] = asBoolStr(True)
if python_version < 0x300 and sys.flags.unicode:
options["python_sysflag_unicode"] = asBoolStr(True)
if python_version >= 0x370 and sys.flags.utf8_mode:
options["python_sysflag_utf8"] = asBoolStr(True)
abiflags = getPythonABI()
if abiflags:
options["abiflags"] = abiflags
cpp_defines = Plugins.getPreprocessorSymbols()
if cpp_defines:
options["cpp_defines"] = ",".join(
"%s%s%s" % (key, "=" if value else "", value or "")
for key, value in cpp_defines.items())
link_libraries = Plugins.getExtraLinkLibraries()
if link_libraries:
options["link_libraries"] = ",".join(link_libraries)
if Options.shallMakeModule():
options["module_suffix"] = getSharedLibrarySuffix(preferred=True)
if Options.shallRunInDebugger():
options["full_names"] = asBoolStr(True)
if Options.assumeYesForDownloads():
options["assume_yes_for_downloads"] = asBoolStr(True)
return (
SconsInterface.runScons(options=options,
quiet=quiet,
scons_filename="Backend.scons"),
options,
)
def runScons(main_module, quiet):
# Scons gets transported many details, that we express as variables, and
# have checks for them, leading to many branches and statements,
# pylint: disable=too-many-branches,too-many-statements
options = {
"name": os.path.basename(getTreeFilenameWithSuffix(main_module, "")),
"result_name": getResultBasepath(main_module),
"source_dir": getSourceDirectoryPath(main_module),
"debug_mode": _asBoolStr(Options.isDebug()),
"python_debug": _asBoolStr(Options.isPythonDebug()),
"unstripped_mode": _asBoolStr(Options.isUnstripped()),
"module_mode": _asBoolStr(Options.shallMakeModule()),
"full_compat": _asBoolStr(Options.isFullCompat()),
"experimental": ",".join(Options.getExperimentalIndications()),
"trace_mode": _asBoolStr(Options.shallTraceExecution()),
"python_version": python_version_str,
"target_arch": Utils.getArchitecture(),
"python_prefix": sys.prefix,
"nuitka_src": SconsInterface.getSconsDataPath(),
"nuitka_cache": getCacheDir(),
"module_count": "%d"
% (
1
+ len(ModuleRegistry.getDoneUserModules())
+ len(ModuleRegistry.getUncompiledNonTechnicalModules())
),
}
if not Options.shallMakeModule():
options["result_exe"] = getResultFullpath(main_module)
# Ask Scons to cache on Windows, except where the directory is thrown
# away. On non-Windows you can should use ccache instead.
if not Options.isRemoveBuildDir() and Utils.getOS() == "Windows":
options["cache_mode"] = "true"
if Options.isLto():
options["lto_mode"] = "true"
# For AnaConda default to trying static lib python library, which
# normally is just not available or if it is even unusable.
if "Anaconda" in sys.version:
options["static_libpython"] = "true"
if Options.shallDisableConsoleWindow():
options["win_disable_console"] = "true"
if Options.isStandaloneMode():
options["standalone_mode"] = "true"
if (
not Options.isStandaloneMode()
and not Options.shallMakeModule()
and isUninstalledPython()
):
options["uninstalled_python"] = "true"
if ModuleRegistry.getUncompiledTechnicalModules():
options["frozen_modules"] = str(
len(ModuleRegistry.getUncompiledTechnicalModules())
)
if Options.isShowScons():
options["show_scons"] = "true"
if Options.isMingw64():
options["mingw_mode"] = "true"
if Options.getMsvcVersion():
msvc_version = Options.getMsvcVersion()
msvc_version = msvc_version.replace("exp", "Exp")
if "." not in msvc_version:
msvc_version += ".0"
options["msvc_version"] = msvc_version
if Options.isClang():
options["clang_mode"] = "true"
if Options.getIconPath():
options["icon_path"] = Options.getIconPath()
if Options.isProfile():
options["profile_mode"] = "true"
if "no_warnings" in getPythonFlags():
options["no_python_warnings"] = "true"
if "no_asserts" in getPythonFlags():
options["python_sysflag_optimize"] = "true"
if python_version < 300 and sys.flags.py3k_warning:
options["python_sysflag_py3k_warning"] = "true"
if python_version < 300 and (sys.flags.division_warning or sys.flags.py3k_warning):
options["python_sysflag_division_warning"] = "true"
if sys.flags.bytes_warning:
options["python_sysflag_bytes_warning"] = "true"
if int(os.environ.get("NUITKA_SITE_FLAG", "no_site" in Options.getPythonFlags())):
options["python_sysflag_no_site"] = "true"
if "trace_imports" in Options.getPythonFlags():
options["python_sysflag_verbose"] = "true"
if python_version < 300 and sys.flags.unicode:
options["python_sysflag_unicode"] = "true"
if python_version >= 370 and sys.flags.utf8_mode:
options["python_sysflag_utf8"] = "true"
abiflags = getPythonABI()
if abiflags:
options["abiflags"] = abiflags
return SconsInterface.runScons(options, quiet), options
default=None,
help="""\
Major version of Python to be used, one of %s.
Defaults to what you run Nuitka with (currently %s)""" %
(getSupportedPythonVersionStr(), python_version_str))
if os.name == "nt":
parser.add_option("--python-arch",
action="store",
dest="python_arch",
choices=("x86", "x86_64"),
default=None,
help="""\
Architecture of Python to use. One of "x86" or "x86_64".
Defaults to what you run Nuitka with (currently "%s").""" %
(Utils.getArchitecture()))
parser.add_option("--python-debug",
"--python-dbg",
action="store_true",
dest="python_debug",
default=None,
help="""\
Use debug version or not. Default uses what you are using to run Nuitka, most
likely a non-debug version.""")
parser.add_option("--python-flag",
action="append",
dest="python_flags",
default=[],
help="""\
def getDependsExePath():
""" Return the path of depends.exe (for Windows).
Will prompt the user to download if not already cached in AppData
directory for Nuitka.
"""
if Utils.getArchitecture() == "x86":
depends_url = "http://dependencywalker.com/depends22_x86.zip"
else:
depends_url = "http://dependencywalker.com/depends22_x64.zip"
if "APPDATA" not in os.environ:
sys.exit("Error, standalone mode cannot find 'APPDATA' environment.")
nuitka_app_dir = Utils.joinpath(os.environ["APPDATA"], "nuitka")
if not Utils.isDir(nuitka_app_dir):
Utils.makePath(nuitka_app_dir)
nuitka_depends_zip = Utils.joinpath(
nuitka_app_dir,
Utils.basename(depends_url)
)
if not Utils.isFile(nuitka_depends_zip):
Tracing.printLine("""\
Nuitka will make use of Dependency Walker (http://dependencywalker.com) tool
to analyze the dependencies of Python extension modules. Is it OK to download
and put it in APPDATA (no installer needed, cached, one time question).""")
reply = raw_input("Proceed and download? [Yes]/No ")
if reply.lower() in ("no", 'n'):
sys.exit("Nuitka does not work in --standalone on Windows without.")
info("Downloading '%s'" % depends_url)
urlretrieve(
depends_url,
nuitka_depends_zip
)
nuitka_depends_dir = Utils.joinpath(
nuitka_app_dir,
Utils.getArchitecture()
)
if not Utils.isDir(nuitka_depends_dir):
os.makedirs(nuitka_depends_dir)
depends_exe = os.path.join(
nuitka_depends_dir,
"depends.exe"
)
if not Utils.isFile(depends_exe):
info("Extracting to '%s'" % depends_exe)
import zipfile
try:
depends_zip = zipfile.ZipFile(nuitka_depends_zip)
depends_zip.extractall(nuitka_depends_dir)
except Exception: # Catching anything zip throws, pylint:disable=W0703
info("Problem with the downloaded zip file, deleting it.")
Utils.deleteFile(depends_exe, must_exist = False)
Utils.deleteFile(nuitka_depends_zip, must_exist = True)
sys.exit(
"Error, need '%s' as extracted from '%s'." % (
depends_exe,
depends_url
)
)
assert Utils.isFile(depends_exe)
return depends_exe
def getDependsExePath():
""" Return the path of depends.exe (for Windows).
Will prompt the user to download if not already cached in AppData
directory for Nuitka.
"""
if Utils.getArchitecture() == "x86":
depends_url = "http://dependencywalker.com/depends22_x86.zip"
else:
depends_url = "http://dependencywalker.com/depends22_x64.zip"
nuitka_app_dir = getAppDir()
nuitka_depends_dir = os.path.join(nuitka_app_dir, Utils.getArchitecture())
nuitka_depends_zip = os.path.join(nuitka_depends_dir, os.path.basename(depends_url))
depends_exe = os.path.join(nuitka_depends_dir, "depends.exe")
makePath(nuitka_depends_dir)
if not os.path.isfile(nuitka_depends_zip) and not os.path.isfile(depends_exe):
if assumeYesForDownloads():
reply = "y"
else:
Tracing.printLine(
"""\
Nuitka will make use of Dependency Walker (http://dependencywalker.com) tool
to analyze the dependencies of Python extension modules. Is it OK to download
and put it in "%s".
No installer needed, cached, one time question.
Proceed and download? [Yes]/No """
% (nuitka_app_dir)
)
Tracing.flushStdout()
reply = raw_input()
if reply.lower() in ("no", "n"):
sys.exit("Nuitka does not work in --standalone on Windows without.")
info("Downloading '%s'" % depends_url)
try:
urlretrieve(depends_url, nuitka_depends_zip)
except Exception: # Any kind of error, pylint: disable=broad-except
sys.exit(
"""Failed to download '%s'.\
Contents should manually be extracted to '%s'."""
% (depends_url, nuitka_depends_dir)
)
if not os.path.isfile(depends_exe):
info("Extracting to '%s'" % depends_exe)
import zipfile
try:
depends_zip = zipfile.ZipFile(nuitka_depends_zip)
depends_zip.extractall(nuitka_depends_dir)
except Exception: # Catching anything zip throws, pylint:disable=W0703
info("Problem with the downloaded zip file, deleting it.")
deleteFile(depends_exe, must_exist=False)
deleteFile(nuitka_depends_zip, must_exist=True)
sys.exit(
"Error, need '%s' as extracted from '%s'." % (depends_exe, depends_url)
)
assert os.path.isfile(depends_exe)
return depends_exe
def getCachedDownload(
url,
binary,
flatten,
is_arch_specific,
specifity,
message,
reject,
assume_yes_for_downloads,
):
# Many branches to deal with, pylint: disable=too-many-branches,too-many-statements
nuitka_app_dir = getAppDir()
nuitka_app_dir = os.path.join(nuitka_app_dir,
os.path.basename(binary).replace(".exe", ""))
if is_arch_specific:
nuitka_app_dir = os.path.join(nuitka_app_dir, Utils.getArchitecture())
if specifity:
nuitka_app_dir = os.path.join(nuitka_app_dir, specifity)
download_path = os.path.join(nuitka_app_dir, os.path.basename(url))
exe_path = os.path.join(nuitka_app_dir, binary)
makePath(nuitka_app_dir)
if not os.path.isfile(download_path) and not os.path.isfile(exe_path):
if assume_yes_for_downloads:
reply = "y"
else:
Tracing.printLine("""\
%s
Is it OK to download and put it in %r.
No installer needed, cached, one time question.
Proceed and download? [Yes]/No """ % (message, nuitka_app_dir))
Tracing.flushStandardOutputs()
try:
reply = raw_input()
except EOFError:
reply = "no"
if reply.lower() in ("no", "n"):
if reject is not None:
Tracing.general.sysexit(reject)
else:
Tracing.general.info("Downloading '%s'." % url)
try:
urlretrieve(url, download_path)
except Exception: # Any kind of error, pylint: disable=broad-except
try:
urlretrieve(url.replace("https://", "http://"),
download_path)
except Exception: # Any kind of error, pylint: disable=broad-except
Tracing.general.sysexit(
"Failed to download '%s'. Contents should manually be copied to '%s'."
% (url, download_path))
if not os.path.isfile(exe_path) and os.path.isfile(download_path):
Tracing.general.info("Extracting to '%s'" % exe_path)
import zipfile
try:
zip_file = zipfile.ZipFile(download_path)
for zip_info in zip_file.infolist():
if zip_info.filename[-1] == "/":
continue
if flatten:
zip_info.filename = os.path.basename(zip_info.filename)
zip_file.extract(zip_info, nuitka_app_dir)
except Exception: # Catching anything zip throws, pylint: disable=broad-except
Tracing.general.info(
"Problem with the downloaded zip file, deleting it.")
deleteFile(binary, must_exist=False)
deleteFile(download_path, must_exist=True)
Tracing.general.sysexit("Error, need %r as extracted from %r." %
(binary, url))
# Check success here, and make sure it's executable.
if os.path.isfile(exe_path):
addFileExecutablePermission(exe_path)
else:
if reject:
Tracing.general.sysexit(reject)
exe_path = None
return exe_path
is_nuitka_run = os.path.basename(sys.argv[0]).lower().endswith("-run")
if not is_nuitka_run:
usage = "usage: %prog [--module] [--run] [options] main_module.py"
else:
usage = "usage: %prog [options] main_module.py"
parser = OptionParser(
usage=usage,
version="\n".join(
(
getNuitkaVersion(),
"Python: " + sys.version.split("\n")[0],
"Executable: " + sys.executable,
"OS: " + Utils.getOS(),
"Arch: " + Utils.getArchitecture(),
)
),
)
parser.add_option(
"--module",
action="store_false",
dest="executable",
default=True,
help="""\
Create an extension module executable instead of a program. Defaults to off.""",
)
parser.add_option(
"--standalone",
