def run(self):
metadata = self.distribution.metadata
constantsModule = cx_Freeze.ConstantsModule(metadata.version)
for constant in self.constants:
parts = constant.split("=")
if len(parts) == 1:
name = constant
value = None
else:
name, stringValue = parts
value = eval(stringValue)
constantsModule.values[name] = value
freezer = cx_Freeze.Freezer(self.distribution.executables,
[constantsModule], self.includes, self.excludes, self.packages,
self.replace_paths, (not self.no_compress), self.optimize,
self.path, self.build_exe,
includeMSVCR = self.include_msvcr,
includeFiles = self.include_files,
binIncludes = self.bin_includes,
binExcludes = self.bin_excludes,
zipIncludes = self.zip_includes,
silent = self.silent,
namespacePackages = self.namespace_packages,
binPathIncludes = self.bin_path_includes,
binPathExcludes = self.bin_path_excludes,
metadata = metadata,
zipIncludePackages = self.zip_include_packages,
zipExcludePackages = self.zip_exclude_packages)
freezer.Freeze()
def run(self):
metadata = self.distribution.metadata
constantsModule = cx_Freeze.ConstantsModule(metadata.version)
for constant in self.constants:
parts = constant.split("=")
if len(parts) == 1:
name = constant
value = None
else:
name, stringValue = parts
value = eval(stringValue)
constantsModule.values[name] = value
freezer = cx_Freeze.Freezer(self.distribution.executables,
[constantsModule], self.includes, self.excludes, self.packages,
self.replace_paths, self.compressed, self.optimize,
self.copy_dependent_files, self.init_script, self.base,
self.path, self.create_shared_zip, self.append_script_to_exe,
self.include_in_shared_zip, self.build_exe, icon = self.icon,
includeMSVCR = self.include_msvcr,
includeFiles = self.include_files,
binIncludes = self.bin_includes,
binExcludes = self.bin_excludes,
zipIncludes = self.zip_includes,
silent = self.silent,
namespacePackages = self.namespace_packages,
binPathIncludes = self.bin_path_includes,
binPathExcludes = self.bin_path_excludes,
metadata = metadata)
freezer.Freeze()
def run(self):
metadata = self.distribution.metadata
constants_module = cx_Freeze.ConstantsModule(metadata.version,
constants=self.constants)
if self.namespace_packages:
warnings.warn(
"namespace-packages is obsolete and will be removed in the next version"
)
freezer = cx_Freeze.Freezer(
self.distribution.executables,
constants_module,
self.includes,
self.excludes,
self.packages,
self.replace_paths,
(not self.no_compress),
self.optimize,
self.path,
self.build_exe,
includeMSVCR=self.include_msvcr,
includeFiles=self.include_files,
binIncludes=self.bin_includes,
binExcludes=self.bin_excludes,
zipIncludes=self.zip_includes,
silent=self.silent,
binPathIncludes=self.bin_path_includes,
binPathExcludes=self.bin_path_excludes,
metadata=metadata,
zipIncludePackages=self.zip_include_packages,
zipExcludePackages=self.zip_exclude_packages,
)
# keep freezer around so that its data case be used in bdist_mac phase
self.freezer = freezer
freezer.Freeze()
def main():
args = parse_command_line(prepare_parser())
executables = [
cx_Freeze.Executable(
args.script,
args.init_script,
args.base_name,
args.target_name,
args.icon,
)
]
freezer = cx_Freeze.Freezer(
executables,
includes=args.includes,
excludes=args.excludes,
packages=args.packages,
replacePaths=args.replace_paths,
compress=args.compress,
optimizeFlag=args.optimize_flag,
path=None,
targetDir=args.target_dir,
includeFiles=args.include_files,
zipIncludes=args.zip_includes,
silent=args.silent,
zipIncludePackages=args.zip_include_packages,
zipExcludePackages=args.zip_exclude_packages,
)
freezer.Freeze()
def main():
executables = [
cx_Freeze.Executable(
"main.py",
targetName=target_name,
base=base,
)
]
freezer = cx_Freeze.Freezer(executables,
includes=[],
excludes=[
'_gtkagg', '_tkagg', 'bsddb', 'curses',
'email', 'pywin.debugger',
'pywin.debugger.dbgcon', 'pywin.dialogs',
'tcl', 'Tkconstants', 'Tkinter'
],
replacePaths=[],
compress=True,
optimizeFlag=1,
copyDependentFiles=True,
initScript=None,
base=None,
path=None,
createLibraryZip=False,
appendScriptToExe=True,
targetDir=None,
zipIncludes=[],
includeFiles=['assets/', 'docs/', 'data/'],
icon='assets/ico/liac_chess.ico',
silent=None)
freezer.Freeze()
def run(self):
metadata = self.distribution.metadata
constants_module = cx_Freeze.ConstantsModule(metadata.version,
constants=self.constants)
freezer = cx_Freeze.Freezer(
self.distribution.executables,
constants_module,
self.includes,
self.excludes,
self.packages,
self.replace_paths, (not self.no_compress),
self.optimize,
self.path,
self.build_exe,
includeMSVCR=self.include_msvcr,
includeFiles=self.include_files,
binIncludes=self.bin_includes,
binExcludes=self.bin_excludes,
zipIncludes=self.zip_includes,
silent=self.silent,
namespacePackages=self.namespace_packages,
binPathIncludes=self.bin_path_includes,
binPathExcludes=self.bin_path_excludes,
metadata=metadata,
zipIncludePackages=self.zip_include_packages,
zipExcludePackages=self.zip_exclude_packages)
freezer.Freeze()
def setUp(self):
self.tdir = tempfile.mkdtemp()
scriptfile = os.path.join(self.tdir, "script.py")
self.distdir = distdir = os.path.join(self.tdir, "dist")
with open(scriptfile, "w") as f:
f.write("import signedimp.crypto.rsa\n")
f = cx_Freeze.Freezer([cx_Freeze.Executable(scriptfile)],
targetDir=self.distdir)
f.Freeze()
if sys.platform == "win32":
self.scriptexe = os.path.join(self.distdir, "script.exe")
else:
self.scriptexe = os.path.join(self.distdir, "script")
def main():
"""
Package the model runner. Warning: This assumes that this script is in the
same directory as model_runner.py.
"""
# Initial cleanup.
modelRunnerDir = os.path.dirname(os.path.realpath(__file__))
buildDir = os.path.join(modelRunnerDir, "build")
distDir = os.path.join(modelRunnerDir, "dist")
nupicDir = os.path.join(modelRunnerDir, "nupic")
os.system("rm -rf build %s %s %s" % (buildDir, distDir, nupicDir))
# Install nupic locally, using the version listed in requirements.txt, and
# include it in the library.zip generated by cx_freeze.
requirementsPath = os.path.join(os.path.join(modelRunnerDir, os.pardir),
"requirements.txt")
requirements = getRequirements(requirementsPath)
nupicPackage = "nupic" # if nupic req is not listed, get the latest version.
for requirement in requirements:
if "nupic" in requirement:
nupicPackage = requirement
break
nupicInstall = ("pip install --target %s %s" %
(os.path.join(modelRunnerDir, "nupic"), nupicPackage))
os.system(nupicInstall)
zipIncludes = generate_zip_includes(
os.path.join(modelRunnerDir, "nupic", "nupic"), "nupic")
# Include the Pyproj data folder. Data files are not found by cx_freeze
# automatically so you need to tell it where to find it.
includeFiles = ([(pyproj.pyproj_datadir, os.path.join("pyproj", "data"))] +
[(os.path.join(modelRunnerDir,
"stats_schema.json"), "stats_schema.json")])
print includeFiles
# Freeze the model runner
executables = [
cx_Freeze.Executable(os.path.join(modelRunnerDir, "model_runner.py"),
targetName="model_runner")
]
freezer = cx_Freeze.Freezer(executables,
namespacePackages=["nupic", "prettytable"],
zipIncludes=zipIncludes,
includeFiles=includeFiles,
silent=True)
freezer.Freeze()
# final cleanup
os.system("rm -rf %s" % nupicDir)
def main():
args = parse_command_line(prepare_parser())
steps = set(args.steps)
if "python" in steps:
app_name = "speech-client"
app_root = os.path.join("dist")
source_root = os.path.join(app_root, "speech-client")
shutil.rmtree(app_root, ignore_errors=True)
executables = [
cx_Freeze.Executable(
MAIN,
args.init_script,
args.base_name,
app_name,
args.icon,
)
]
freezer = cx_Freeze.Freezer(
executables,
includes=["codecs"],
excludes=EXCLUDES,
packages=args.packages,
compress=args.compress,
optimizeFlag=args.optimize_flag,
path=None,
targetDir=app_root,
includeFiles=[
(
"Lib\site-packages\webrtcvad_wheels-2.0.10.post2.dist-info",
"lib\webrtcvad_wheels-2.0.10.post2.dist-info",
),
("models", "models"),
("bin", "bin"),
],
zipIncludes=args.zip_includes,
silent=args.silent,
zipIncludePackages=args.zip_include_packages,
zipExcludePackages=args.zip_exclude_packages,
)
freezer.Freeze()
app_root = os.path.abspath(os.path.join("..", "..", ".."))
if "c#" in steps:
build_release(app_root)
if 'zip' in steps:
build_release_zip(app_root)
def main():
options = ParseCommandLine()
executables = [
cx_Freeze.Executable(options.script,
initScript=options.initScript,
base=options.baseName,
icon=options.icon,
targetName=options.targetName)
]
freezer = cx_Freeze.Freezer(executables,
includes=options.includeModules,
excludes=options.excludeModules,
replacePaths=options.replacePaths,
compress=options.compress,
optimizeFlag=options.optimized,
path=None,
targetDir=options.targetDir,
zipIncludes=options.zipIncludes,
silent=options.silent)
freezer.Freeze()
def main():
"""
Package the script. Warning: This assumes that this script is in the
same directory as target script to freeze.
"""
# Initial cleanup.
scriptDir = os.path.dirname(os.path.realpath(__file__))
buildDir = os.path.join(scriptDir, "build")
distDir = os.path.join(scriptDir, "dist")
os.system("rm -rf build %s %s" % (buildDir, distDir))
# Freeze the script
executables = [
cx_Freeze.Executable(os.path.join(scriptDir, "sensor_publisher.py"),
targetName="sensor_publisher")
]
freezer = cx_Freeze.Freezer(executables, silent=True)
freezer.Freeze()
def main():
options = ParseCommandLine()
executables = [
cx_Freeze.Executable(options.script, targetName=options.targetName)
]
freezer = cx_Freeze.Freezer(executables,
includes=options.includeModules,
excludes=options.excludeModules,
replacePaths=options.replacePaths,
compress=options.compress,
optimizeFlag=options.optimized,
copyDependentFiles=options.copyDeps,
initScript=options.initScript,
base=options.baseName,
path=None,
createLibraryZip=False,
appendScriptToExe=True,
targetDir=options.targetDir,
zipIncludes=options.zipIncludes,
icon=options.icon,
silent=options.silent)
freezer.Freeze()
# Simply include entire package, to save effort
full_includes = ['skimage', 'pygments']
full_includes += get_files_for_package_start('pyopencl')
full_includes += get_files_for_package_start('scikits.ann')
full_includes += get_files_for_package_start('mpl_toolkits')
full_includes += get_files_for_package_start('sklearn')
for package in full_includes:
if package is not None:
include_files.append((SITE_PACKAGE_DIR + package, package))
executables = [
cx_Freeze.Executable('multiscale_extraction.py', base=None),
cx_Freeze.Executable('gpu_device_selection.py', base=None)
]
main_system_temp = tempfile.mkdtemp()
freezer = cx_Freeze.Freezer(executables,
includes=includes,
includeFiles=include_files,
targetDir=main_system_temp)
freezer.Freeze()
zip_dir(save_file_name, main_system_temp)
except:
raise
finally:
if main_system_temp:
shutil.rmtree(main_system_temp)
def build_all(toplevel_directory, build_directory):
'''
Given the toplevel directory (eg. '~/esptool') and the build-directory (eg.
'~/esptool/build'), this function builds the following scripts with
cx_Freeze:
- espefuse.py
- espsecure.py
- esptool.py
:param toplevel_directory: The toplevel 'esptool' directory, eg. '~/esptool'.
The scripts to be built can be found directly in
this toplevel directory, eg:
- ~/esptool/espefuse.py
- ~/esptool/espsecure.py
- ~/esptool/esptool.py
:param build_directory: The directory where the build output gets generated,
eg. '~/esptool/build'.
:return: None
'''
print(f'build executables...\n')
#* Define executables
#* ------------------
is_windows = platform.system().lower() == 'windows'
executables = [
cx_Freeze.Executable(
'espefuse.py',
initScript=None,
base=None,
icon='espressif.ico',
targetName='espefuse.exe' if is_windows else 'espefuse',
),
cx_Freeze.Executable(
'espsecure.py',
initScript=None,
base=None,
icon='espressif.ico',
targetName='espsecure.exe' if is_windows else 'espsecure',
),
cx_Freeze.Executable(
'esptool.py',
initScript=None,
base=None,
icon='espressif.ico',
targetName='esptool.exe' if is_windows else 'esptool',
),
]
#* Define 'search_path'
#* --------------------
search_path = []
temp = sys.path
temp.append(toplevel_directory)
for p in temp:
p = p.replace('\\', '/')
search_path.append(p)
#* Invoke Freezer()
#* ----------------
freezer = cx_Freeze.Freezer(
executables,
replacePaths=[],
compress=True,
optimizeFlag=True,
path=search_path,
targetDir=build_directory,
includeFiles=[],
zipIncludes=[],
silent=False,
)
freezer.Freeze()
print('\n' 'finish build\n')
return
def freeze(dist):
"""Freeze the given distribution data using cx_Freeze."""
includes = dist.includes
excludes = dist.excludes
options = dist.freezer_options
# Merge in any encludes/excludes given in freezer_options
for inc in options.pop("includes", ()):
includes.append(inc)
for exc in options.pop("excludes", ()):
excludes.append(exc)
if "esky" not in includes and "esky" not in excludes:
includes.append("esky")
if "pypy" not in includes and "pypy" not in excludes:
excludes.append("pypy")
# cx_Freeze doesn't seem to respect __path__ properly; hack it so
# that the required distutils modules are always found correctly.
def load_distutils(finder, module):
module.path = distutils.__path__ + module.path
finder.IncludeModule("distutils.dist")
cx_Freeze.hooks.load_distutils = load_distutils
# Build kwds arguments out of the given freezer opts.
kwds = {}
for (nm, val) in options.iteritems():
kwds[_normalise_opt_name(nm)] = val
kwds["includes"] = includes
kwds["excludes"] = excludes
kwds["targetDir"] = dist.freeze_dir
# Build an Executable object for each script.
# To include the esky startup code, we write each to a tempdir.
executables = []
for exe in dist.get_executables():
base = None
if exe.gui_only and sys.platform == "win32":
base = "Win32GUI"
executables.append(
cx_Freeze.Executable(exe.script,
base=base,
targetName=exe.name,
icon=exe.icon,
**exe._kwds))
# Freeze up the executables
f = cx_Freeze.Freezer(executables, **kwds)
f.Freeze()
# Copy data files into the freeze dir
for (src, dst) in dist.get_data_files():
dst = os.path.join(dist.freeze_dir, dst)
dstdir = os.path.dirname(dst)
if not os.path.isdir(dstdir):
dist.mkpath(dstdir)
dist.copy_file(src, dst)
# Copy package data into the library.zip
# For now, this only works if there's a shared "library.zip" file.
if f.createLibraryZip:
lib = zipfile.ZipFile(os.path.join(dist.freeze_dir, "library.zip"),
"a")
for (src, arcnm) in dist.get_package_data():
lib.write(src, arcnm)
lib.close()
else:
for (src, arcnm) in dist.get_package_data():
err = "use of package_data currently requires createLibraryZip=True"
raise RuntimeError(err)
# Create the bootstrap code, using custom code if specified.
code_source = ["__name__ = '__main__'"]
esky_name = dist.distribution.get_name()
code_source.append("__esky_name__ = %r" % (esky_name, ))
code_source.append(inspect.getsource(esky.bootstrap))
if dist.compile_bootstrap_exes:
if sys.platform == "win32":
# Unfortunately this doesn't work, because the cxfreeze exe
# contains frozen modules that are inaccessible to a bootstrapped
# interpreter. Disabled until I figure out a workaround. :-(
pass
# The pypy-compiled bootstrap exe will try to load a python env
# into its own process and run this "take2" code to bootstrap.
#take2_code = code_source[1:]
#take2_code.append(_CUSTOM_WIN32_CHAINLOADER)
#take2_code.append(dist.get_bootstrap_code())
#take2_code = compile("\n".join(take2_code),"<string>","exec")
#take2_code = marshal.dumps(take2_code)
#clscript = "import marshal; "
#clscript += "exec marshal.loads(%r); " % (take2_code,)
#clscript = clscript.replace("%","%%")
#clscript += "chainload(\"%s\")"
# Here's the actual source for the compiled bootstrap exe.
#from esky.bdist_esky import pypy_libpython
#code_source.append(inspect.getsource(pypy_libpython))
#code_source.append("_PYPY_CHAINLOADER_SCRIPT = %r" % (clscript,))
#code_source.append(_CUSTOM_PYPY_CHAINLOADER)
code_source.append(dist.get_bootstrap_code())
code_source = "\n".join(code_source)
for exe in dist.get_executables(normalise=False):
if not exe.include_in_bootstrap_env:
continue
bsexe = dist.compile_to_bootstrap_exe(exe, code_source)
if sys.platform == "win32":
fexe = os.path.join(dist.freeze_dir, exe.name)
winres.copy_safe_resources(fexe, bsexe)
else:
if sys.platform == "win32":
code_source.append(_CUSTOM_WIN32_CHAINLOADER)
code_source.append(dist.get_bootstrap_code())
code_source.append("bootstrap()")
code_source = "\n".join(code_source)
maincode = imp.get_magic() + struct.pack("<i", 0)
maincode += marshal.dumps(
compile(code_source, INITNAME + ".py", "exec"))
# Create code for a fake esky.bootstrap module
eskycode = imp.get_magic() + struct.pack("<i", 0)
eskycode += marshal.dumps(compile("", "esky/__init__.py", "exec"))
eskybscode = imp.get_magic() + struct.pack("<i", 0)
eskybscode += marshal.dumps(compile("", "esky/bootstrap.py", "exec"))
# Copy any core dependencies
if "fcntl" not in sys.builtin_module_names:
for nm in os.listdir(dist.freeze_dir):
if nm.startswith("fcntl"):
dist.copy_to_bootstrap_env(nm)
for nm in os.listdir(dist.freeze_dir):
if is_core_dependency(nm):
dist.copy_to_bootstrap_env(nm)
# Copy the loader program for each script into the bootstrap env, and
# append the bootstrapping code to it as a zipfile.
for exe in dist.get_executables(normalise=False):
if not exe.include_in_bootstrap_env:
continue
exepath = dist.copy_to_bootstrap_env(exe.name)
bslib = zipfile.PyZipFile(exepath, "a", zipfile.ZIP_STORED)
cdate = (2000, 1, 1, 0, 0, 0)
bslib.writestr(zipfile.ZipInfo(INITNAME + ".pyc", cdate), maincode)
bslib.writestr(zipfile.ZipInfo("esky/__init__.pyc", cdate),
eskycode)
bslib.writestr(zipfile.ZipInfo("esky/bootstrap.pyc", cdate),
eskybscode)
bslib.close()
import os
import sys
import subprocess
from app_settings import *
try:
import cx_Freeze
except ImportError:
print("ERROR: cx_freeze is not installed")
sys.exit(-1)
executables = [
cx_Freeze.Executable("qt_bootstrap.py",
targetName="{}.exe".format(APP_COMMAND))
]
freezer = cx_Freeze.Freezer(executables,
copyDependentFiles=True,
createLibraryZip=False,
appendScriptToExe=True,
icon=APP_ICON,
silent=False)
freezer.Freeze()
metadata1.description = '快速代理切换程序'.decode('utf-8')
metadata2.description = 'PyProxySwitch命令行配置工具'.decode('utf-8')
except:
metadata1.description = '快速代理切换程序'
metadata2.description = 'PyProxySwitch命令行配置工具'
freezer1 = cx_Freeze.Freezer(
[cx_Freeze.Executable('PyProxySwitch/src/PyProxySwitch.pyw', base=base)],
# base='Console')],
includes=['pps_qrc', 'pps_config', 'add_proxy_ui', 'pps_conf_ui'],
excludes=['PyQt4', 'unicodedata', 'bz2'],
# replacePaths = options.replacePaths,
compress=True,
optimizeFlag=1,
# initScript = options.initScript,
#~ path = ,
createLibraryZip=False,
appendScriptToExe=True,
targetDir=targetDir,
# copyDependentFiles=False,
# zipIncludes = options['zipIncludes'],
includeFiles=includeFiles,
icon='./PyProxySwitch/img/PyProxySwitch.ico',
# silent = options.silent
metadata=metadata1)
freezer2 = cx_Freeze.Freezer(
[cx_Freeze.Executable("PyProxySwitch/src/pps_config.py", base='Console')],
excludes=['PyQt4', 'unicodedata', 'bz2'],
compress=True,
optimizeFlag=1,
