def make_release_tree(self, base_dir, files):
_sdist.make_release_tree(self, base_dir, files)
print('removing version.py to replace with our own.')
os.unlink(os.path.join(base_dir, 'helga', 'version.py'))
print('writing our own version.py with version number "{version}".'.format(version=self.distribution.get_version()))
with open(os.path.join(base_dir, 'helga', 'version.py'), 'w') as vh:
vh.write('__version__ = "{version}"\n'.format(version=self.distribution.get_version()))
def make_release_tree(self, base_dir, files):
"""
python.org: Create the directory tree that will become the source
distribution archive.
"""
target_path_length = len(Sdist._build_target_path)
target_src_path = path.join(Sdist._build_target_path, "src") + path.sep
target_relative_src_path = path.join(".", target_src_path)
target_src_path_length = len(target_src_path)
target_relative_src_path_length = len(target_relative_src_path)
files_filtered = [ ]
for _file in files:
if (_file[:target_src_path_length] == target_src_path): _file = _file[target_path_length + 1:]
elif (_file[:target_relative_src_path_length] == target_relative_src_path):
_file = _file[target_path_length + 3:]
#
files_filtered.append(_file)
#
_sdist.make_release_tree(self, base_dir, files_filtered)
def make_release_tree(self, base_dir, files):
"""
python.org: Create the directory tree that will become the source
distribution archive.
"""
target_path_length = len(Sdist._build_target_path)
target_src_path = path.join(Sdist._build_target_path, "src") + path.sep
target_relative_src_path = path.join(".", target_src_path)
target_src_path_length = len(target_src_path)
target_relative_src_path_length = len(target_relative_src_path)
files_filtered = []
for _file in files:
if (_file[:target_src_path_length] == target_src_path):
_file = _file[target_path_length + 1:]
elif (_file[:target_relative_src_path_length] ==
target_relative_src_path):
_file = _file[target_path_length + 3:]
#
files_filtered.append(_file)
#
_sdist.make_release_tree(self, base_dir, files_filtered)
def make_release_tree(self, base_dir, files):
sdist.make_release_tree(self, base_dir, files)
ver_path = os.path.join(base_dir, 'pepper', 'version.json')
with open(ver_path, 'wb') as f:
version = read_version_tag()
json.dump({'version': version}, f)
def make_release_tree(self, base_dir, files):
sdist.make_release_tree(self, base_dir, files)
link = 'hard' if hasattr(os, 'link') else None
pkg_dir = os.path.join(base_dir, 'openbabel')
self.copy_file(os.path.join('..', 'stereo.i'), pkg_dir, link=link)
self.copy_file(os.path.join('..', 'openbabel-python.i'),
pkg_dir,
link=link)
def make_release_tree(self, base_dir, files):
# Run the parent command first
sdist.make_release_tree(self, base_dir, files)
# Run translation-canary in release mode to remove any bad translations
sys.path.append('translation-canary')
from translation_canary.translated import testSourceTree # pylint: disable=import-error
testSourceTree(base_dir, releaseMode=True)
def make_release_tree(self, base_dir, files):
# Run the parent command first
sdist.make_release_tree(self, base_dir, files)
# Run translation-canary in release mode to remove any bad translations
sys.path.append('translation-canary')
from translation_canary.translated import testSourceTree # pylint: disable=import-error
testSourceTree(base_dir, releaseMode=True)
def make_release_tree(self, base_dir, files):
sdist.make_release_tree(self, base_dir, files)
# Let's generate salt/_version.py to include in the sdist tarball
self.distribution.running_salt_sdist = True
self.distribution.salt_version_hardcoded_path = os.path.join(
base_dir, 'salt', '_version.py')
self.run_command('write-salt-version')
def make_release_tree(self, base_dir, files):
_sdist.make_release_tree(self, base_dir, files)
# now locate _version.py in the new base_dir directory (remembering
# that it may be a hardlink) and replace it with an updated value
target_versionfile = os.path.join(base_dir, versionfile_path)
print("updating {}...".format(target_versionfile))
os.unlink(target_versionfile)
with open(target_versionfile, "w") as fh:
fh.write(short_version_py.format(**self._generated_versions))
def make_release_tree(self, base_dir, files):
_sdist.make_release_tree(self, base_dir, files)
# now locate _version.py in the new base_dir directory (remembering that it may be a hardlink) and replace it with an
# updated value
target_versionfile = path_join(base_dir, versionfile_source)
print('UPDATING {}'.format(target_versionfile))
os_unlink(target_versionfile)
with open(target_versionfile, 'w') as f:
f.write(SHORT_VERSION_PY % self._versioneer_generated_versions)
def make_release_tree(self, base_dir, files):
_sdist.make_release_tree(self, base_dir, files)
# now locate _version.py in the new base_dir directory (remembering
# that it may be a hardlink) and replace it with an updated value
target_versionfile = os.path.join(base_dir, versionfile_path)
print("updating {}...".format(target_versionfile))
os.unlink(target_versionfile)
with open(target_versionfile, "w") as fh:
fh.write(short_version_py.format(**self._generated_versions))
def make_release_tree(self, base_dir, files):
_sdist.make_release_tree(self, base_dir, files)
# now locate _version.py in the new base_dir directory (remembering that it may be a hardlink) and replace it with an
# updated value
target_versionfile = path_join(base_dir, versionfile_source)
print('UPDATING {}'.format(target_versionfile))
os_unlink(target_versionfile)
with open(target_versionfile, 'w') as f:
f.write(SHORT_VERSION_PY % self._versioneer_generated_versions)
def make_release_tree(self, base_dir, files):
_sdist.make_release_tree(self, base_dir, files)
# now locate _version.py in the new base_dir directory (remembering
# that it may be a hardlink) and replace it with an updated value
target_versionfile = os.path.join(base_dir, versionfile_source)
print("UPDATING %s" % target_versionfile)
os.unlink(target_versionfile)
with open(target_versionfile, "w") as f:
f.write(SHORT_VERSION_PY % self._versioneer_generated_versions)
def make_release_tree(self, base_dir, files):
cfg = get_config()
_sdist.make_release_tree(self, base_dir, files)
# now locate _version.py in the new base_dir directory (remembering
# that it may be a hardlink) and replace it with an updated value
target_versionfile = os.path.join(base_dir, cfg.versionfile_source)
print("UPDATING %s" % target_versionfile)
write_to_version_file(target_versionfile,
self._versioneer_generated_versions)
def make_release_tree(self, base_dir, files):
_sdist.make_release_tree(self, base_dir, files)
# now locate _version.py in the new base_dir directory (remembering
# that it may be a hardlink) and replace it with an updated value
target_versionfile = os.path.join(base_dir, versionfile_source)
print("UPDATING %s" % target_versionfile)
os.unlink(target_versionfile)
with open(target_versionfile, "w") as f:
f.write(SHORT_VERSION_PY % self._versioneer_generated_versions)
def make_release_tree(self, base_dir, files):
pypi_msg = u"""PyPI-distributed chipsec PIP package doesn't contain a pre-built kernel\n""" \
"""driver. Please use it only when a kernel driver is already present on the\n""" \
"""system. Otherwise, please install chipsec from source, using the following\n""" \
"""procedure:\n""" \
""" https://github.com/chipsec/chipsec/blob/master/chipsec-manual.pdf"""
_sdist.make_release_tree(self, base_dir, files)
no_driver_marker = os.path.join(base_dir, NO_DRIVER_MARKER_FILE)
with io.open(no_driver_marker, "w", encoding="utf-8") as fd:
fd.write(pypi_msg)
def make_release_tree(self, base_dir, files):
distutils_sdist.make_release_tree(self, base_dir, files)
self.maybe_move_file(base_dir, 'LICENSE', 'doc/LICENSE')
# distutils doesn't seem to handle symlinks-to-directories
# out of the box, so let's take care of them manually:
target = os.readlink('data')
dest = os.path.join(base_dir, 'data')
distutils.log.info('linking %s -> %s', dest, target)
if not self.dry_run:
os.symlink(target, dest)
def make_release_tree(self, base_dir, files):
_sdist.make_release_tree(self, base_dir, files)
# Save any egg_info command line options used to create this sdist
dest = os.path.join(base_dir, 'setup.cfg')
if hasattr(os, 'link') and os.path.exists(dest):
# unlink and re-copy, since it might be hard-linked, and
# we don't want to change the source version
os.unlink(dest)
self.copy_file('setup.cfg', dest)
self.get_finalized_command('egg_info').save_version_info(dest)
def make_release_tree(self, base_dir, files):
_sdist.make_release_tree(self, base_dir, files)
# Save any egg_info command line options used to create this sdist
dest = os.path.join(base_dir, 'setup.cfg')
if hasattr(os,'link') and os.path.exists(dest):
# unlink and re-copy, since it might be hard-linked, and
# we don't want to change the source version
os.unlink(dest)
self.copy_file('setup.cfg', dest)
self.get_finalized_command('egg_info').save_version_info(dest)
def make_release_tree(self, base_dir, files):
sdist.make_release_tree(self, base_dir, files)
# ensure there's a buildslave/VERSION file
fn = os.path.join(base_dir, "buildslave", "VERSION")
open(fn, "w").write(version)
# ensure that NEWS has a copy of the latest release notes, copied from
# the master tree, with the proper version substituted
src_fn = os.path.join("..", "master", "docs", "relnotes/index.rst")
src = open(src_fn).read()
src = src.replace("|version|", version)
dst_fn = os.path.join(base_dir, "NEWS")
open(dst_fn, "w").write(src)
def make_release_tree(self, base_dir, files):
sdist.make_release_tree(self, base_dir, files)
import pbr.packaging
version = pbr.packaging.get_version('git')
files = [
'pkgs/PKGBUILD', 'pkgs/hammercloud.spec', 'debian/changelog'
]
for pkgfile in files:
with open(os.path.join(base_dir, pkgfile), 'r') as tmpfile:
filedata = tmpfile.read()
filedata = filedata.replace('XXXX', version)
with open(os.path.join(base_dir, pkgfile), 'w') as tmpfile:
print(filedata, file=tmpfile)
def make_release_tree(self, base_dir, files):
sdist.make_release_tree(self, base_dir, files)
# ensure there's a buildslave/VERSION file
fn = os.path.join(base_dir, 'buildslave', 'VERSION')
open(fn, 'w').write(version)
# ensure that NEWS has a copy of the latest release notes, copied from
# the master tree, with the proper version substituted
src_fn = os.path.join('..', 'master', 'docs', 'relnotes/index.rst')
src = open(src_fn).read()
src = src.replace('|version|', version)
dst_fn = os.path.join(base_dir, 'NEWS')
open(dst_fn, 'w').write(src)
def make_release_tree(self, base_dir, files):
sdist.make_release_tree(self, base_dir, files)
# ensure there's a buildslave/VERSION file
fn = os.path.join(base_dir, 'buildslave', 'VERSION')
open(fn, 'w').write(version)
# ensure that NEWS has a copy of the latest release notes, copied from
# the master tree, with the proper version substituted
src_fn = os.path.join('..', 'master', 'docs', 'relnotes/index.rst')
src = open(src_fn).read()
src = src.replace('|version|', version)
dst_fn = os.path.join(base_dir, 'NEWS')
open(dst_fn, 'w').write(src)
def make_release_tree(self, base_dir, files):
sdist.make_release_tree(self, base_dir, files)
version_line = "__version__ = '{0}'\n".format(__version__)
old_ver_name = os.path.join(base_dir, 'eucaconsole/version.py')
new_ver_name = old_ver_name + '.new'
with open(new_ver_name, 'w') as new_ver:
with open(old_ver_name) as old_ver:
for line in old_ver:
if line.startswith('__version__ ='):
new_ver.write(version_line)
else:
new_ver.write(line)
new_ver.flush()
os.rename(new_ver_name, old_ver_name)
def make_release_tree(self, base_dir, files):
if self.distribution.ssh_packaging:
self.distribution.salt_ssh_packaging_file = PACKAGED_FOR_SALT_SSH_FILE
self.run_command('write_salt_ssh_packaging_file')
self.filelist.files.append(os.path.basename(PACKAGED_FOR_SALT_SSH_FILE))
sdist.make_release_tree(self, base_dir, files)
# Let's generate salt/_version.py to include in the sdist tarball
self.distribution.running_salt_sdist = True
self.distribution.salt_version_hardcoded_path = os.path.join(
base_dir, 'salt', '_version.py'
)
self.run_command('write_salt_version')
def make_release_tree(self, base_dir, files):
sdist.make_release_tree(self, base_dir, files)
# ensure there's a buildbot/VERSION file
fn = os.path.join(base_dir, 'buildbot', 'VERSION')
open(fn, 'w').write(version)
# ensure that NEWS has a copy of the latest release notes, with the
# proper version substituted
src_fn = os.path.join('docs', 'release-notes.rst')
src = open(src_fn).read()
src = src.replace('|version|', version)
dst_fn = os.path.join(base_dir, 'NEWS')
open(dst_fn, 'w').write(src)
def make_release_tree(self, base_dir, files):
sdist.make_release_tree(self, base_dir, files)
version_line = "__version__ = '{0}'\n".format(__version__)
old_init_name = os.path.join(base_dir, 'euca2ools/__init__.py')
new_init_name = old_init_name + '.new'
with open(new_init_name, 'w') as new_init:
with open(old_init_name) as old_init:
for line in old_init:
if line.startswith('__version__ ='):
new_init.write(version_line)
else:
new_init.write(line)
new_init.flush()
os.rename(new_init_name, old_init_name)
def make_release_tree(self, base_dir, files):
sdist.make_release_tree(self, base_dir, files)
# ensure there's a buildbot/VERSION file
fn = os.path.join(base_dir, 'buildbot', 'VERSION')
open(fn, 'w').write(version)
# ensure that NEWS has a copy of the latest release notes, with the
# proper version substituted
src_fn = os.path.join('docs', 'release-notes.rst')
src = open(src_fn).read()
src = src.replace('|version|', version)
dst_fn = os.path.join(base_dir, 'NEWS')
open(dst_fn, 'w').write(src)
def make_release_tree(self, base_dir, files):
sdist.make_release_tree(self, base_dir, files)
version_line = "__version__ = '{0}'\n".format(__version__)
orig_setup = os.path.join(base_dir, 'setup.py')
new_setup = orig_setup + '.new'
with open(new_setup, 'w') as new_fh:
with open(orig_setup) as orig_fh:
for line in orig_fh:
if line.startswith('__version__ ='):
new_fh.write(version_line)
else:
new_fh.write(line)
new_fh.flush()
os.rename(new_setup, orig_setup)
def make_release_tree(self, base_dir, files):
if self.distribution.ssh_packaging:
self.distribution.salt_ssh_packaging_file = PACKAGED_FOR_SALT_SSH_FILE
self.run_command('write-salt-ssh-packaging-file')
self.filelist.files.append(
os.path.basename(PACKAGED_FOR_SALT_SSH_FILE))
sdist.make_release_tree(self, base_dir, files)
# Let's generate salt/_version.py to include in the sdist tarball
self.distribution.running_salt_sdist = True
self.distribution.salt_version_hardcoded_path = os.path.join(
base_dir, 'salt', '_version.py')
self.run_command('write-salt-version')
def make_release_tree(self, base_dir, files):
sdist.make_release_tree(self, base_dir, files)
version_line = "__version__ = '{0}'\n".format(__version__)
old_init_name = os.path.join(base_dir, "eucalyptus_admin/__init__.py")
new_init_name = old_init_name + ".new"
with open(new_init_name, "w") as new_init:
with open(old_init_name) as old_init:
for line in old_init:
if line.startswith("__version__ ="):
new_init.write(version_line)
else:
new_init.write(line)
new_init.flush()
os.rename(new_init_name, old_init_name)
def make_release_tree(self, base_dir, files):
sdist.make_release_tree(self, base_dir, files)
# ensure there's a buildbot/VERSION file
fn = os.path.join(base_dir, "buildbot", "VERSION")
open(fn, "w").write(version)
# ensure that NEWS has a copy of the latest release notes, with the
# proper version substituted
src_fn = os.path.join("docs", "release-notes.rst")
src = open(src_fn).read()
src = src.replace("|version|", version)
dst_fn = os.path.join(base_dir, "NEWS")
open(dst_fn, "w").write(src)
def make_release_tree(self, base_dir, files):
sdist.make_release_tree(self, base_dir, files)
version_line = "__version__ = '{0}'\n".format(__version__)
old_init_name = os.path.join(base_dir, 'requestbuilder/__init__.py')
new_init_name = old_init_name + '.new'
with open(new_init_name, 'w') as new_init:
with open(old_init_name) as old_init:
for line in old_init:
if line.startswith('__version__ ='):
new_init.write(version_line)
else:
new_init.write(line)
new_init.flush()
os.rename(new_init_name, old_init_name)
def make_release_tree(self, base_dir, files):
sdist.make_release_tree(self, base_dir, files)
version_line = "__version__ = '{0}'\n".format(__version__)
orig_module = os.path.join(base_dir, 'sos/plugins/eucameta.py')
new_module = orig_module + '.new'
with open(new_module, 'w') as new_fh:
with open(orig_module) as orig_fh:
for line in orig_fh:
if line.startswith('__version__ ='):
new_fh.write(version_line)
else:
new_fh.write(line)
new_fh.flush()
os.rename(new_module, orig_module)
def make_release_tree(self, base_dir, files):
sdist.make_release_tree(self, base_dir, files)
# make sure we include the git version in the release
setup_py = open(base_dir + '/setup.py').read()
setup_py = setup_py.replace('\r\n', '\n')
if not "\nVERSION_SUFFIX = ''\n" in setup_py:
raise Exception('Variable for version suffix is missing.')
os.unlink(base_dir + '/setup.py')
setup_py = setup_py.replace(
"\nVERSION_SUFFIX = ''\n",
"\nVERSION_SUFFIX = {}\n".format(repr(suffix)))
f = open(base_dir + '/setup.py', 'w')
f.write(setup_py)
f.close()
def make_release_tree(self, base_dir, files):
self.mkpath(base_dir)
self.copy_file(
os.path.join(self.distribution.subpackage_folder, "setup.cfg"),
base_dir,
)
if self.readme:
# Copy the readme from the subfolder, to the top level of the dist
self.copy_file(self.readme, base_dir)
self.make_pep517_stub_setup(base_dir)
# By-pass setuptools's method -- it copies the wrong setup.cfg
base.make_release_tree(self, base_dir, files)
def make_release_tree(self, base_dir, files):
res = sdist.make_release_tree(self, base_dir, files)
build_py = self.get_finalized_command('build_py')
filename = build_py.get_module_outfile(
base_dir, ['PyInstaller', 'utils'], 'git')
_write_git_version_file(filename)
return res
def make_release_tree(self, base_dir, files):
res = sdist.make_release_tree(self, base_dir, files)
build_py = self.get_finalized_command('build_py')
filename = build_py.get_module_outfile(base_dir,
['PyInstaller', 'utils'], 'git')
_write_git_version_file(filename)
return res
def make_release_tree(self, base_dir, files):
"""
Extend distutils's make_release_tree method to include a
correctly-formatted ``setup.cfg`` in the source distribution.
"""
du_sdist.make_release_tree(self, base_dir, files)
# Save any egg_info command line options used to create this sdist
dest = os.path.join(base_dir, 'setup.cfg')
if hasattr(os, 'link') and os.path.exists(dest):
# unlink and re-copy, since it might be hard-linked, and
# we don't want to change the source version
os.unlink(dest)
self.copy_file('setup.cfg', dest)
self.get_finalized_command('gitegginfo').save_version_info(dest)
def make_release_tree(self, base_dir, files):
if self.distribution.ssh_packaging:
self.distribution.salt_ssh_packaging_file = PACKAGED_FOR_SALT_SSH_FILE
self.run_command('write_salt_ssh_packaging_file')
self.filelist.files.append(
os.path.basename(PACKAGED_FOR_SALT_SSH_FILE))
if not IS_PY3 and not isinstance(base_dir, str):
# Work around some bad code in distutils which logs unicode paths
# against a str format string.
base_dir = base_dir.encode('utf-8')
sdist.make_release_tree(self, base_dir, files)
# Let's generate salt/_version.py to include in the sdist tarball
self.distribution.running_salt_sdist = True
self.distribution.salt_version_hardcoded_path = os.path.join(
base_dir, 'salt', '_version.py')
self.run_command('write_salt_version')
def make_release_tree(self, base_dir, files):
if self.distribution.ssh_packaging:
self.distribution.salt_ssh_packaging_file = PACKAGED_FOR_SALT_SSH_FILE
self.run_command('write_salt_ssh_packaging_file')
self.filelist.files.append(
os.path.basename(PACKAGED_FOR_SALT_SSH_FILE))
pkgfiles = [
pkgfile if IS_PY3 else pkgfile.decode(__salt_system_encoding__)
for pkgfile in files
]
sdist.make_release_tree(self, base_dir, pkgfiles)
# Let's generate salt/_version.py to include in the sdist tarball
self.distribution.running_salt_sdist = True
self.distribution.salt_version_hardcoded_path = os.path.join(
base_dir, 'salt', '_version.py')
self.run_command('write_salt_version')
def make_release_tree(self, base_dir, files):
if self.ssh_packaging:
self.distribution.salt_ssh_packaging_file = PACKAGED_FOR_SALT_SSH_FILE
self.run_command('write-salt-ssh-packaging-file')
self.distribution.package_data.pop('salt.daemons.flo', None)
self.filelist.files.append(
os.path.basename(PACKAGED_FOR_SALT_SSH_FILE))
self.distribution.metadata.name = 'salt-ssh'
self.distribution.data_files = [('share/man/man1', [
'doc/man/salt-ssh.1', 'doc/man/salt-run.1',
'doc/man/salt-call.1', 'doc/man/salt-cloud.1'
]), ('share/man/man7', ['doc/man/salt.7'])]
sdist.make_release_tree(self, base_dir, files)
# Let's generate salt/_version.py to include in the sdist tarball
self.distribution.running_salt_sdist = True
self.distribution.salt_version_hardcoded_path = os.path.join(
base_dir, 'salt', '_version.py')
self.run_command('write-salt-version')
def make_release_tree(self, base_dir, files):
sdist.make_release_tree(self, base_dir, files)
try:
popen = subprocess.Popen(["git", "describe"], stdout=subprocess.PIPE)
popen.wait()
version = popen.stdout.read().strip()
version_line = "__version__ = '{0}'\n".format(version)
old_init_file_name = os.path.join(base_dir, "euca2ools/__init__.py")
new_init_file_name = old_init_file_name + ".new"
with open(new_init_file_name, "w") as new_init_file:
with open(old_init_file_name) as old_init_file:
for line in old_init_file:
if re.match("__version__ *= *'.*'", line):
new_init_file.write(version_line)
else:
new_init_file.write(line)
new_init_file.flush()
os.rename(new_init_file_name, old_init_file_name)
except:
# Not really a problem; we'll just leave it as-is
pass
def make_release_tree(self, base_dir, files):
sdist.make_release_tree(self, base_dir, files)
try:
popen = subprocess.Popen(['git', 'describe'],
stdout=subprocess.PIPE)
popen.wait()
version = popen.stdout.read().strip()
version_line = '__version__ = \'{0}\'\n'.format(version)
old_init_file_name = os.path.join(base_dir,
'euca2ools/__init__.py')
new_init_file_name = old_init_file_name + '.new'
with open(new_init_file_name, 'w') as new_init_file:
with open(old_init_file_name) as old_init_file:
for line in old_init_file:
if re.match("__version__ *= *'.*'", line):
new_init_file.write(version_line)
else:
new_init_file.write(line)
new_init_file.flush()
os.rename(new_init_file_name, old_init_file_name)
except:
# Not really a problem; we'll just leave it as-is
pass
def make_release_tree(self, base_dir, files):
sdist.make_release_tree(self, base_dir, files)
# ensure there's a buildbot/VERSION file
fn = os.path.join(base_dir, 'buildbot', 'VERSION')
open(fn, 'w').write(version)
def make_release_tree(self, base_dir, files):
# Run the parent command first
sdist.make_release_tree(self, base_dir, files)
testSourceTree(base_dir, releaseMode=True)
def make_release_tree(self, base_dir, files):
sdist.make_release_tree(self, base_dir, files)
link = 'hard' if hasattr(os, 'link') else None
pkg_dir = os.path.join(base_dir, 'openbabel')
self.copy_file(os.path.join('..', 'stereo.i'), pkg_dir, link=link)
self.copy_file(os.path.join('..', 'openbabel-python.i'), pkg_dir, link=link)
def make_release_tree(self, base_dir, files):
if os.path.isdir(base_dir):
_remove_tree(base_dir, dry_run=self.dry_run)
_sdist.make_release_tree(self, base_dir, files)
def make_release_tree(self, base_dir, files):
sdist.make_release_tree(self, base_dir, files)
target_version_file = join(base_dir, self.distribution.metadata.name, ".version")
print("UPDATING {0}".format(target_version_file))
with open(target_version_file, 'w') as f:
f.write(self.distribution.metadata.version)
def make_release_tree(self, base_dir, files):
sdist.make_release_tree(self, base_dir, files)
fn = os.path.join(base_dir, 'src/radical/agent/', 'VERSION')
open(fn, 'w').write(update_version())
def make_release_tree(self, base_dir, files):
distutils_sdist.make_release_tree(self, base_dir, files)
self.maybe_move_file(base_dir, 'LICENSE', 'doc/LICENSE')
def make_release_tree(self, base_dir, files):
if os.path.isdir(base_dir):
_remove_tree(base_dir, dry_run=self.dry_run)
_sdist.make_release_tree(self, base_dir, files)
def make_release_tree(self, base_dir, files):
sdist.make_release_tree(self, base_dir, files)
target_dir = join(base_dir, self.distribution.metadata.name)
write_version_into_init(target_dir, self.distribution.metadata.version)
write_version_file(target_dir, self.distribution.metadata.version)
def make_release_tree(self, base_dir, files):
sdist.make_release_tree(self, base_dir, files)
# ensure there's a buildbot/VERSION file
fn = os.path.join(base_dir, 'buildbot', 'VERSION')
open(fn, 'w').write(version)
def make_release_tree(self, base_dir, files):
sdist.make_release_tree(self, base_dir, files)
link = 'hard' if hasattr(os, 'link') else None
self.copy_file('../stereo.i', base_dir, link=link)
self.copy_file('../openbabel-python.i', base_dir, link=link)
def make_release_tree(self, base_dir, files):
distutils_sdist.make_release_tree(self, base_dir, files)
for manname in glob.iglob(os.path.join(base_dir, 'doc', '*.1')):
self.execute(self._rewrite_manpage, [manname], 'rewriting {0}'.format(manname))
self._maybe_move_file(base_dir, 'COPYING', 'doc/COPYING')
def make_release_tree(self, base_dir, files):
sdist.make_release_tree(self, base_dir, files)
with open(os.path.join(base_dir, 'MANIFEST.in'), 'w') as f:
f.write('\n'.join(self.includes))
def make_release_tree(self, base_dir, files):
distutils_sdist.make_release_tree(self, base_dir, files)
self.maybe_move_file(base_dir, 'LICENSE', 'doc/LICENSE')
