def run(self):
"""Add pythonpath to pyclewn script in a 'home scheme' installation."""
if pythonpath is not None and pythonpath not in sys.path:
path_append = string.Template("sys.path.append('${pythonpath}')\n")
self.executable += '\n\nimport sys\n' \
+ path_append.substitute(pythonpath=pythonpath)
_build_scripts.run(self)
def run(self):
build_scripts.run(self)
for sfn in sfx_scripts:
fixscript(sfn, self.build_dir, DEF_SUFFIX)
for sfn in nosfx_scripts:
fixscript(sfn, self.build_dir, DEF_NOSUFFIX)
def run(self):
global chromedriver_version, chromedriver_checksums
validate = False
if chromedriver_version:
if chromedriver_checksums:
validate = True
else:
chromedriver_version = get_chromedriver_version()
file_name = 'chromedriver_{0}.zip'.format(chromedriver_version)
zip_path = os.path.join(tempfile.gettempdir(), file_name)
if validate:
if os.path.exists(zip_path):
print("\t - requested file '{0}' found at '{1}'."
.format(file_name, zip_path))
if self._validate(zip_path):
print("\t - cached file '{0}' is valid.".format(zip_path))
else:
print("\t - cached file '{0}' is not valid!"
.format(zip_path))
self._download(zip_path, validate=True)
else:
self._download(zip_path, validate=True)
else:
self._download(zip_path)
self._unzip(zip_path)
self.scripts = [os.path.join(self.build_dir, script) for script in
os.listdir(self.build_dir)]
build_scripts.run(self)
def run(self):
global chromedriver_version, chromedriver_checksums
validate = False
if chromedriver_version:
if chromedriver_checksums:
validate = True
else:
chromedriver_version = get_chromedriver_version()
file_name = 'chromedriver_{0}.zip'.format(chromedriver_version)
zip_path = os.path.join(tempfile.gettempdir(), file_name)
if validate:
if os.path.exists(zip_path):
print("\t - requested file '{0}' found at '{1}'."
.format(file_name, zip_path))
if self._validate(zip_path):
print("\t - cached file '{0}' is valid.".format(zip_path))
else:
print("\t - cached file '{0}' is not valid!".format(zip_path))
self._download(zip_path, validate=True)
else:
self._download(zip_path, validate=True)
else:
self._download(zip_path)
self._unzip(zip_path)
self.scripts = [os.path.join(self.build_dir, script) for script in
os.listdir(self.build_dir)]
build_scripts.run(self)
def run(self):
if sys.platform != 'win32':
self.announce("create startup script")
opj = os.path.join
# Peek into "install" command to find out where it is going to install to
inst_cmd = self.get_finalized_command('install')
if inst_cmd:
# Note: we user the "purelib" because we don't ship binary
# executables. If we ever compile things into execs, we shall
# use "platlib"
openerp_site_packages = opj(inst_cmd.install_purelib,'openerp-client')
if inst_cmd.root and openerp_site_packages.startswith(inst_cmd.root):
# trick: when we install relative to root, we mostly mean to
# temporary put the files there, and then move back to the
# stripped prefix dir. So we don't write the full root into
# the script
iroot = inst_cmd.root
if iroot.endswith('/'):
iroot = iroot[:-1]
openerp_site_packages = openerp_site_packages[len(iroot):]
else:
# Hard-code the Linux /usr/lib/pythonX.Y/... path
openerp_site_packages = opj('/usr', 'lib', 'python%s' % py_short_version, 'site-packages', 'openerp-client')
start_script = "#!/bin/sh\ncd %s\nexec %s ./openerp-client.py $@\n" % (openerp_site_packages, sys.executable)
# write script
f = open('openerp-client', 'w')
f.write(start_script)
f.close()
build_scripts.run(self)
def run(self):
if sys.platform != 'win32':
self.announce("create startup script")
opj = os.path.join
# Peek into "install" command to find out where it is going to install to
inst_cmd = self.get_finalized_command('install')
if inst_cmd:
# Note: we user the "purelib" because we don't ship binary
# executables. If we ever compile things into execs, we shall
# use "platlib"
openerp_site_packages = opj(inst_cmd.install_purelib,'openerp-client')
if inst_cmd.root and openerp_site_packages.startswith(inst_cmd.root):
# trick: when we install relative to root, we mostly mean to
# temporary put the files there, and then move back to the
# stripped prefix dir. So we don't write the full root into
# the script
iroot = inst_cmd.root
if iroot.endswith('/'):
iroot = iroot[:-1]
openerp_site_packages = openerp_site_packages[len(iroot):]
else:
# Hard-code the Linux /usr/lib/pythonX.Y/... path
openerp_site_packages = opj('/usr', 'lib', 'python%s' % py_short_version, 'site-packages', 'openerp-client')
start_script = "#!/bin/sh\ncd %s\nexec %s ./openerp-client.py $@\n" % (openerp_site_packages, sys.executable)
# write script
f = open('openerp-client', 'w')
f.write(start_script)
f.close()
build_scripts.run(self)
def run(self):
build_scripts.run(self)
for f in os.listdir(self.build_dir):
fpath = os.path.join(self.build_dir, f)
if not fpath.endswith('.py'):
if os.path.exists(fpath + '.py'): os.unlink(fpath + '.py')
os.rename(fpath, fpath + '.py')
def run(self):
build_scripts.run(self)
for sfn in sfx_scripts:
fixscript(sfn, self.build_dir, DEF_SUFFIX)
for sfn in nosfx_scripts:
fixscript(sfn, self.build_dir, DEF_NOSUFFIX)
def run(self):
if self.scripts is not None and "pychecker" in self.scripts:
script_path = get_script_path(self.build_dir)
self.scripts.remove("pychecker")
self.scripts.append(script_path)
self.mkpath(self.build_dir)
self.execute(func=open, args=[script_path, "w"], msg="creating empty script %s" % script_path)
build_scripts.run(self) # invoke "standard" action
def run(self):
build_scripts_class.run(self)
if os.name == 'posix' and not self.dry_run:
for script in self.scripts:
if script.endswith('.py'):
file = os.path.join(self.build_dir, script)
print 'renaming %s to %s' % (file, file[:-3])
os.rename(file, file[:-3]) # len('.py') == 3
def run(self):
build_scripts_class.run(self)
if os.name == 'posix' and not self.dry_run:
for script in self.scripts:
if script.endswith('.py'):
file = os.path.join(self.build_dir, script)
print 'renaming %s to %s' % (file, file[:-3])
os.rename(file, file[:-3]) # len('.py') == 3
def run(self):
build_scripts.run(self)
for script in self.scripts:
script = convert_path(script)
outfile = join(self.build_dir, basename(script))
if os.path.exists(outfile) and outfile.endswith(".py"):
newfile = outfile[:-3] # drop .py
log.info("renaming %s -> %s", outfile, basename(newfile))
os.rename(outfile, newfile)
def run(self):
build_scripts.run(self)
self.path_header = get_python_lib(prefix=prefix).replace(
'dist-packages', 'site-packages')
self.outfiles = [
os.path.join(self.build_dir, os.path.basename(script))
for script in self.distribution.scripts
]
self.add_paths_to_scripts()
def run(self):
build_scripts.run(self)
for script in self.scripts:
script = convert_path(script)
outfile = join(self.build_dir, basename(script))
if os.path.exists(outfile) and outfile.endswith(".py"):
newfile = outfile[:-3] # drop .py
log.info("renaming %s -> %s", outfile, basename(newfile))
os.rename(outfile, newfile)
def run(self):
self.distribution.scripts.append(os.path.join('bin',
'sage-env-config'))
if not self.distribution.entry_points:
self.entry_points = self.distribution.entry_points = dict()
if 'console_scripts' not in self.distribution.entry_points:
self.distribution.entry_points['console_scripts'] = []
self.distribution.entry_points['console_scripts'].append(
'sage-config=sage_conf:_main')
distutils_build_scripts.run(self)
def run(self):
cwd = os.getcwd()
os.chdir(os.path.join(BASEPATH, 'bluepy'))
cmd = ['make']
def _make():
call(cmd)
self.execute(_make, [])
os.chdir(cwd)
build_scripts.run(self)
def run(self):
build_scripts_class.run(self)
if os.name == 'posix' and not self.dry_run:
for script in self.scripts:
fname, ext = os.path.splitext(script)
if ext == '.py':
file = os.path.join(self.build_dir, script)
file_no_ext = os.path.join(self.build_dir, fname)
print 'renaming %s to %s' % (file, file_no_ext)
os.rename(file, file_no_ext)
def run(self):
build_scripts_class.run(self)
if os.name == 'posix' and not self.dry_run:
for script in self.scripts:
fname, ext = os.path.splitext(script)
if ext == '.py':
file = os.path.join(self.build_dir, script)
file_no_ext = os.path.join(self.build_dir, fname)
print 'renaming %s to %s' % (file, file_no_ext)
os.rename(file, file_no_ext)
def run(self):
build_scripts.run(self)
for script in self.scripts:
script = convert_path(script)
outfile = join(self.build_dir, basename(script))
if os.path.exists(outfile) and outfile.endswith(".py"):
if basename(outfile) == "main.py":
dn, fn = split(outfile)
newfile = join(dn, "yumex-dnf")
log.info("renaming %s -> %s", outfile, basename(newfile))
os.rename(outfile, newfile)
def run(self):
# Process the files list, stripping '.py' from script names.
new_list = []
for script in self.scripts:
if script.endswith('.py'):
self.copy_file(script, script[:-3])
script = script[:-3]
new_list.append(script)
# Pass the processed list to the original build_scripts.run()
self.scripts = new_list
build_scripts.run(self)
def run (self):
scripts = ['./scripts/cl-update-config']
backup_build_dir = self.build_dir
backup_scripts = filter(lambda x: not x in scripts, self.scripts)
self.scripts = scripts
self.build_dir = self.build_dir + "-bin"
build_scripts.run(self)
if backup_scripts:
self.scripts = backup_scripts
self.build_dir = backup_build_dir
build_scripts.run(self)
def run (self):
scripts = ['./scripts/proxy', './scripts/dhcp',
'./scripts/execserv']
backup_build_dir = self.build_dir
backup_scripts = filter(lambda x: not x in scripts, self.scripts)
self.scripts = scripts
self.build_dir = self.build_dir + "-bin"
build_scripts.run(self)
self.scripts = backup_scripts
self.build_dir = backup_build_dir
build_scripts.run(self)
def run(self):
build_scripts.run(self)
for script in self.scripts:
script = convert_path(script)
outfile = join(self.build_dir, basename(script))
if os.path.exists(outfile) and outfile.endswith(".py"):
if basename(outfile) in RENAME_SCRIPTS:
dn, fn = split(outfile)
newfile = join(dn, RENAME_SCRIPTS[fn])
log.info("renaming %s -> %s", outfile, basename(newfile))
os.rename(outfile, newfile)
def run(self):
build_scripts.run(self)
for script in self.scripts:
script = convert_path(script)
outfile = join(self.build_dir, basename(script))
if os.path.exists(outfile) and outfile.endswith(".py"):
if basename(outfile) in RENAME_SCRIPTS:
dn, fn = split(outfile)
newfile = join(dn, RENAME_SCRIPTS[fn])
log.info("renaming %s -> %s", outfile, basename(newfile))
os.rename(outfile, newfile)
def run(self):
if 'Windows' in platform.system() or 'CYGWIN' in platform.system():
os.system('gcc -o %sscripts/rlimit %ssrc/rlimit/rlimit-NT.c' %
(root_dir, root_dir))
else:
os.system('gcc -o %sscripts/rlimit %ssrc/rlimit/rlimit.c' %
(root_dir, root_dir))
# Update the scripts list
self.scripts += glob.glob(root_dir + 'scripts/rlimit*')
build_scripts.run(self)
def run(self):
build_scripts.run(self)
self.run_command('build_ext')
build_ext = self.get_finalized_command("build_ext")
for ext in self.distribution.rust_extensions:
if ext.binding == Binding.Exec:
# GZ 2021-08-19: Not handling multiple binaries yet.
os.replace(
os.path.join(build_ext.build_lib, ext.name),
os.path.join(self.build_dir, ext.name))
def run(self):
_build_scripts.run(self)
if self.scripts and os.name == "nt":
# Make sure that all installed scripts have .py extension
for file in self.scripts:
file = convert_path(file)
file = os.path.join(self.build_dir, os.path.basename(file))
root, ext = os.path.splitext(file)
path = root + ".py"
if os.path.exists(path):
os.remove(file)
else:
self.move_file(file, path)
def run(self):
_build_scripts.run(self)
if self.scripts and os.name == "nt":
# Make sure that all installed scripts have .py extension
for file in self.scripts:
file = convert_path(file)
file = os.path.join(self.build_dir, os.path.basename(file))
root, ext = os.path.splitext(file)
path = root + ".py"
if os.path.exists(path):
os.remove(file)
else:
self.move_file(file, path)
def run(self):
from umdinst.setup import gen_config, gen_wrappers
env = self.distribution.get_command_obj("install")
# First, check to make sure the javapath is valid
if env.with_hackystat:
if (env.javapath is not None) and (env.javapath is not "") and not os.access(env.javapath, os.X_OK):
# raise ValueError, "Could not find java executable in 'javapath' specified in config: " + env.javapath + "\nSpecify a valid java executable with the '--javapath=' option or disable Hackystat with the '--without-hackystat' option."
print "Error: could not find java executable in 'javapath' specified in config: " + env.javapath + "\nSpecify a valid java executable with the '--javapath=' option or disable Hackystat with the '--without-hackystat' option."
sys.exit(-1)
# Sanity check, make sure there's a keyfile, or setup will fail for now
if not os.path.exists(os.path.join("conf", env.keyfile)):
raise ValueError, "Cannot locate keyfile (%s) which is needed for installation." % env.keyfile
# Sanity check, make sure there's a askfile, or setup will fail for now
if not os.path.exists(os.path.join("conf", env.whitelistfile)):
raise ValueError, "Cannot locate askfile (%s) which is needed for installation." % env.whitelistfile
# Generate the config file for runtime
platform_specific_file = os.path.join("scripts", "wrapper", "platform_specific.py")
gen_config.gen_platform_specific_config(env, platform_specific_file)
# Generate the wrapper scripts
absprefix = os.path.abspath(env.prefix)
version = "%d.%d" % sys.version_info[:2]
libpath = """%s/lib/python%s/site-packages""" % (absprefix, version)
gen_wrappers.gen_wrappers(env, libpath)
if env.with_pooledlog:
logfiledir = os.path.join(absprefix, ".data")
self.createdir(logfiledir)
from stat import S_IRWXU, S_IRWXG, S_IRWXO
os.chmod(logfiledir, S_IRWXU | S_IRWXG | S_IRWXO)
print """changing mode of %s to 777 for pooled logging""" % logfiledir
# from umdinst.setup import autobackup
# autobackup.launch_backup_daemon()
# Finally, a dirty trick to add dynamically generated scripts
# to the script list
self.scripts = self.scripts + [
"scripts/wrapper/" + x for x in os.listdir("scripts/wrapper/") if not os.path.isdir(x)
]
# Run the default build_script.run() method
build_scripts.run(self)
def run (self):
if not self.scripts:
return
self.scripts = self.generate_scripts(self.scripts)
return old_build_scripts.run(self)
def run(self):
self.mkpath(self.build_dir)
must_clean = []
for _file in self.distribution.viewer:
#if the link already exists (build already ran don't try to create it
if not os.path.exists(_file):
macsyview_src = os.path.join('macsyview', _file)
if os.path.exists(macsyview_src):
os.symlink(os.path.abspath(os.path.join('macsyview', _file)), _file)
must_clean.append(_file)
self.scripts += self.viewer
else:
log.warn("macsyview not found")
_build_scripts.run(self)
for _link in must_clean:
os.unlink(_link)
def run(self):
# Do the default actions.
base.run(self)
# Work around distutils bug (for python > 2.3)
# change permissions to executable.
for s in self.scripts:
script = os.path.join(self.build_dir, os.path.basename(s))
if self.dry_run:
self.announce("changing mode of %s"%script)
else:
oldmode = os.stat(script)[ST_MODE] & int('7777', 8)
newmode = (oldmode | int('555', 8)) & int('7777', 8)
if newmode != oldmode:
self.announce("changing mode of %s from %o to %o"%(script, oldmode, newmode)),
os.chmod(script, newmode)
def run(self):
self.mkpath(self.build_dir)
must_clean = []
for _file in self.distribution.viewer:
#if the link already exists (build already ran don't try to create it
if not os.path.exists(_file):
macsyview_src = os.path.join('macsyview', _file)
if os.path.exists(macsyview_src):
os.symlink(
os.path.abspath(os.path.join('macsyview', _file)),
_file)
must_clean.append(_file)
self.scripts += self.viewer
else:
log.warn("macsyview not found")
_build_scripts.run(self)
for _link in must_clean:
os.unlink(_link)
def run(self):
# Do the default actions.
base.run(self)
# Work around distutils bug (for python > 2.3)
# change permissions to executable.
for s in self.scripts:
script = os.path.join(self.build_dir, os.path.basename(s))
if self.dry_run:
self.announce("changing mode of %s" % script)
else:
oldmode = os.stat(script)[ST_MODE] & int('7777', 8)
newmode = (oldmode | int('555', 8)) & int('7777', 8)
if newmode != oldmode:
self.announce("changing mode of %s from %o to %o" %
(script, oldmode, newmode)),
os.chmod(script, newmode)
def run(self):
global geckodriver_version, geckodriver_checksums
if not geckodriver_version:
geckodriver_version = get_geckodriver_version()
file_name = 'geckodriver_{version}.{compression}'.format(
version=geckodriver_version,
compression=self._get_compression_suffix())
zip_path = os.path.join(tempfile.gettempdir(), file_name)
self._download(zip_path)
self._unzip(zip_path)
self.scripts = [
os.path.join(self.build_dir, script)
for script in os.listdir(self.build_dir)
]
build_scripts.run(self)
def run(self):
if not self.scripts:
return
self.scripts = self.generate_scripts(self.scripts)
# Now make sure that the distribution object has this list of scripts.
# setuptools' develop command requires that this be a list of filenames,
# not functions.
self.distribution.scripts = self.scripts
return old_build_scripts.run(self)
def run (self):
if not self.scripts:
return
self.scripts = self.generate_scripts(self.scripts)
# Now make sure that the distribution object has this list of scripts.
# setuptools' develop command requires that this be a list of filenames,
# not functions.
self.distribution.scripts = self.scripts
return old_build_scripts.run(self)
def run(self):
# Not in posix system. Add prefix .py just to be sure
if os.name != "posix":
self.distribution.add_prefix = True
# Remove .py prefix in posix.
elif os.name == "posix" and not self.distribution.add_prefix:
self.distribution.remove_prefix = True
try:
tempdir = mkdtemp()
new_names = []
for script in self.scripts:
new_name = os.path.join(tempdir,self._transform_script_name(script))
new_names.append(new_name)
copyfile(script,new_name)
self.scripts = new_names
build_scripts.run(self)
finally:
if os.path.isdir(tempdir):
rmtree(tempdir)
def run(self):
from distutils import log
if not self.scripts:
return
saved_scripts = self.scripts
self.scripts = []
for script in saved_scripts:
script = distutils.util.convert_path(script)
script_copy, script_ext = os.path.splitext(script)
if script_ext != '.py':
log.debug("Not removing extension from %s since it's not '.py'", script)
else:
log.debug("Copying %s -> %s", script, script_copy)
self.copy_file(script, script_copy)
self.scripts.append(script_copy)
# distutils is compatible with 2.1 so we cannot use super() to
# call it.
_build_scripts.run(self)
self.scripts = saved_scripts
def run(self):
# Not in posix system. Add prefix .py just to be sure
if os.name != "posix":
self.distribution.add_prefix = True
# Remove .py prefix in posix.
elif os.name == "posix" and not self.distribution.add_prefix:
self.distribution.remove_prefix = True
try:
tempdir = mkdtemp()
new_names = []
for script in self.scripts:
new_name = os.path.join(tempdir,
self._transform_script_name(script))
new_names.append(new_name)
copyfile(script, new_name)
self.scripts = new_names
build_scripts.run(self)
finally:
if os.path.isdir(tempdir):
rmtree(tempdir)
def run(self):
global chromedriver_version, chromedriver_checksums
# validate = False
# if chromedriver_version:
# if chromedriver_checksums:
# validate = True
# else:
# chromedriver_version = get_chromedriver_version()
# file_name = 'chromedriver_{0}.zip'.format(chromedriver_version)
# zip_path = os.path.join(tempfile.gettempdir(), file_name)
# print('--------------------')
# print(zip_path)
# print('--------------------')
# if validate:
# if os.path.exists(zip_path):
# print("\t - requested file '{0}' found at '{1}'."
# .format(file_name, zip_path))
# if self._validate(zip_path):
# print("\t - cached file '{0}' is valid.".format(zip_path))
# else:
# print("\t - cached file '{0}' is not valid!"
# .format(zip_path))
# self._download(zip_path, validate=True)
# else:
# self._download(zip_path, validate=True)
# else:
zip_path = '/tmp/chromedriver_{}.zip'.format(version)
self._download(zip_path)
self._unzip(zip_path)
self.scripts = [
os.path.join(self.build_dir, script)
for script in os.listdir(self.build_dir)
]
build_scripts.run(self)
def run(self):
if os.name != 'nt':
return build_scripts.run(self)
exebuilt = False
try:
self.run_command('build_hgexe')
exebuilt = True
except (DistutilsError, CCompilerError):
log.warn('failed to build optional hg.exe')
if exebuilt:
# Copying hg.exe to the scripts build directory ensures it is
# installed by the install_scripts command.
hgexecommand = self.get_finalized_command('build_hgexe')
dest = os.path.join(self.build_dir, 'hg.exe')
self.mkpath(self.build_dir)
self.copy_file(hgexecommand.hgexepath, dest)
# Remove hg.bat because it is redundant with hg.exe.
self.scripts.remove('contrib/win32/hg.bat')
return build_scripts.run(self)
def run(self):
if not self.scripts:
return
saved_scripts = self.scripts
self.scripts = []
for script in saved_scripts:
script = distutils.util.convert_path(script)
script_copy, script_ext = os.path.splitext(script)
if script_ext != '.py':
log.debug("Not removing extension from {script} "
"since it's not '.py'".format(script=script))
else:
log.debug("Copying {orig} -> {dest}".format(orig=script,
dest=script_copy))
self.copy_file(script, script_copy)
self.scripts.append(script_copy)
# distutils is compatible with 2.1 so we cannot use super() to
# call it.
_build_scripts.run(self)
self.outfiles = self.scripts
self.scripts = saved_scripts
def run(self):
if os.name != 'nt' or self.distribution.pure:
return build_scripts.run(self)
exebuilt = False
try:
self.run_command('build_hgexe')
exebuilt = True
except (DistutilsError, CCompilerError):
log.warn('failed to build optional hg.exe')
if exebuilt:
# Copying hg.exe to the scripts build directory ensures it is
# installed by the install_scripts command.
hgexecommand = self.get_finalized_command('build_hgexe')
dest = os.path.join(self.build_dir, 'hg.exe')
self.mkpath(self.build_dir)
self.copy_file(hgexecommand.hgexepath, dest)
# Remove hg.bat because it is redundant with hg.exe.
self.scripts.remove('contrib/win32/hg.bat')
return build_scripts.run(self)
def run(self):
if not self.scripts:
return
saved_scripts = self.scripts
self.scripts = []
for script in saved_scripts:
script = distutils.util.convert_path(script)
script_copy, script_ext = os.path.splitext(script)
if script_ext != '.py':
log.debug("Not removing extension from {script} "
"since it's not '.py'".format(script=script))
else:
log.debug("Copying {orig} -> {dest}".format(
orig=script, dest=script_copy))
self.copy_file(script, script_copy)
self.scripts.append(script_copy)
# distutils is compatible with 2.1 so we cannot use super() to
# call it.
_build_scripts.run(self)
self.outfiles = self.scripts
self.scripts = saved_scripts
def run (self):
"change PYTHON_PATH for DAMARIS executable"
_build_scripts.run(self)
script="scripts/DAMARIS"
script = convert_path(script)
outfile = os.path.join(self.build_dir, os.path.basename(script))
self.damaris_dir=os.path.normpath(self.damaris_dir)
if self.damaris_dir in sys.path:
log.debug("not changing %s (this path is on standard path)", script)
# nothing to do for us
return
# now change PATH in DAMARIS script
# copy backup
log.info("adapting DAMARIS script to use local installation")
shutil.copyfile(outfile, outfile+".bak")
# the file should keep all its attributes (executable...)
inf=file(outfile+".bak","r")
outf=file(outfile,"w")
l=inf.readline()
while not l.startswith("import sys") and l!="":
outf.write(l)
l=inf.readline()
if l!="":
outf.write(l)
l=inf.readline()
while l.endswith("# inserted by setup.py\n"):
l=inf.readline()
outf.write("sys.path.insert(0,\"%s\") # inserted by setup.py\n"%self.damaris_dir)
outf.write(l)
outf.writelines(inf.readlines())
inf.close()
outf.close()
os.remove(outfile+".bak")
def run(self):
versions = versioneer.get_versions()
tempdir = tempfile.mkdtemp()
generated = os.path.join(tempdir, "rundemo")
with open(generated, "wb") as f:
for line in open("src/rundemo-template", "rb"):
if line.strip().decode("ascii") == "#versions":
f.write(('versions = %r\n' % (versions,)).encode("ascii"))
else:
f.write(line)
self.scripts = [generated]
rc = build_scripts.run(self)
os.unlink(generated)
os.rmdir(tempdir)
return rc
def run(self):
build_scripts.finalize_options(self)
# fixup scripts to look in the build_ext output folder
if self.scripts:
build_ext = self.get_finalized_command("build_ext")
output_dir = os.path.dirname(build_ext.get_ext_fullpath("clr"))
scripts = []
for script in self.scripts:
if os.path.exists(os.path.join(output_dir, script)):
script = os.path.join(output_dir, script)
scripts.append(script)
self.scripts = scripts
return build_scripts.run(self)
def run(self):
versions = versioneer.get_versions()
tempdir = tempfile.mkdtemp()
generated = os.path.join(tempdir, "git-annex-remote-googledrive")
with open(generated, "wb") as f:
for line in open("git-annex-remote-googledrive", "rb"):
if line.strip().decode("ascii") == "versions = None":
f.write('versions = {}\n'.format(versions).encode("ascii"))
else:
f.write(line)
self.scripts = [generated]
rc = build_scripts.run(self)
os.unlink(generated)
os.rmdir(tempdir)
return rc
def run(self):
from distutils import log
if not self.scripts:
return
saved_scripts = self.scripts
self.scripts = []
for script in saved_scripts:
script = distutils.util.convert_path(script)
script_copy, script_ext = os.path.splitext(script)
if script_ext != '.py':
log.debug(
"Not removing extension from %s since it's not '.py'",
script)
else:
log.debug("Copying %s -> %s", script, script_copy)
self.copy_file(script, script_copy)
self.scripts.append(script_copy)
# distutils is compatible with 2.1 so we cannot use super() to
# call it.
_build_scripts.run(self)
self.scripts = saved_scripts
def run(self):
build_scripts.finalize_options(self)
# fixup scripts to look in the build_ext output folder
if self.scripts:
build_ext = self.get_finalized_command("build_ext")
output_dir = os.path.dirname(build_ext.get_ext_fullpath("clr"))
scripts = []
for script in self.scripts:
if os.path.exists(os.path.join(output_dir, script)):
script = os.path.join(output_dir, script)
scripts.append(script)
self.scripts = scripts
return build_scripts.run(self)
def run(self):
version = versioneer.get_version()
add_literal_substitution("version", 'version = "%s"\n' % version)
add_substitution("ed25519", "ed25519.py")
add_base64_substitution("setup-lockup-b64", "setup-lockup.py")
tempdir = tempfile.mkdtemp()
git_lockup = os.path.join(tempdir, "git-lockup")
with open(git_lockup, "wb") as f:
f.write(construct("git-lockup-template"))
# modify self.scripts with the source pathname of scripts to install
# into self.build_dir . When we upcall, those scripts will be copied
# and adjusted (their shbang line set to sys.executable).
self.scripts = [git_lockup]
rc = build_scripts.run(self)
os.unlink(git_lockup)
os.rmdir(tempdir)
return rc
def run(self):
version = versioneer.get_version()
add_literal_substitution("version", 'version = "%s"\n' % version)
add_substitution("ed25519", "ed25519.py")
add_base64_substitution("setup-lockup-b64", "setup-lockup.py")
tempdir = tempfile.mkdtemp()
git_lockup = os.path.join(tempdir, "git-lockup")
with open(git_lockup, "wb") as f:
f.write(construct("git-lockup-template"))
# modify self.scripts with the source pathname of scripts to install
# into self.build_dir . When we upcall, those scripts will be copied
# and adjusted (their shbang line set to sys.executable).
self.scripts = [git_lockup]
rc = build_scripts.run(self)
os.unlink(git_lockup)
os.rmdir(tempdir)
return rc
def run(self):
v = generate_versioneer_py()
v_b64 = base64.b64encode(v).decode("ascii")
lines = [v_b64[i:i+60] for i in range(0, len(v_b64), 60)]
v_b64 = "\n".join(lines)+"\n"
with open("src/installer.py") as f:
s = f.read()
s = ver(s.replace("@VERSIONEER-INSTALLER@", v_b64))
tempdir = tempfile.mkdtemp()
installer = os.path.join(tempdir, "versioneer")
with open(installer, "w") as f:
f.write(s)
self.scripts = [installer]
rc = build_scripts.run(self)
os.unlink(installer)
os.rmdir(tempdir)
return rc
def run(self):
v = generate_versioneer_py()
v_b64 = base64.b64encode(v).decode("ascii")
lines = [v_b64[i:i + 60] for i in range(0, len(v_b64), 60)]
v_b64 = "\n".join(lines) + "\n"
with open("src/installer.py") as f:
s = f.read()
s = ver(s.replace("@VERSIONEER-INSTALLER@", v_b64))
tempdir = tempfile.mkdtemp()
installer = os.path.join(tempdir, "versioneer")
with open(installer, "w") as f:
f.write(s)
self.scripts = [installer]
rc = build_scripts.run(self)
os.unlink(installer)
os.rmdir(tempdir)
return rc
