def build(cls, setup_root, target, interpreter=None):
packager = Packager(setup_root, interpreter=interpreter,
install_dir=os.path.join(setup_root, 'dist'))
try:
return packager.sdist()
except Packager.InstallFailure as e:
raise cls.SetupError(str(e))
def from_string(cls,
requirement_string,
options_builder,
interpreter=None):
requirement_string, extras = strip_extras(requirement_string)
if cls.is_installable(requirement_string):
if interpreter is None:
raise cls.InvalidRequirement(
'%s is not an installable directory because we were called '
'without an interpreter to use to execute setup.py.' %
requirement_string)
packager = Packager(requirement_string, interpreter=interpreter)
try:
sdist = packager.sdist()
except SetuptoolsInstallerBase.Error:
raise cls.InvalidRequirement(
'Could not create source distribution for %s' %
requirement_string)
package = Package.from_href(sdist)
return ResolvablePackage(package,
options_builder.build(package.name),
extras=extras)
else:
raise cls.InvalidRequirement(
'%s does not appear to be an installable directory.' %
requirement_string)
def build(cls, setup_root, target, interpreter=None):
packager = Packager(setup_root, interpreter=interpreter,
install_dir=os.path.join(setup_root, 'dist'))
try:
return packager.sdist()
except Packager.InstallFailure as e:
raise cls.SetupError(str(e))
def execute(self):
# We drive creation of setup.py distributions from the original target graph, grabbing codegen'd
# sources when needed. We ignore PythonDistribution targets.
def is_exported_python_target(t):
return t.is_original and self.has_provides(t) and not is_local_python_dist(t)
exported_python_targets = OrderedSet(t for t in self.context.target_roots
if is_exported_python_target(t))
if not exported_python_targets:
raise TaskError('setup-py target(s) must provide an artifact.')
dist_dir = self.get_options().pants_distdir
# NB: We have to create and then run in 2 steps so that we can discover all exported targets
# in-play in the creation phase which then allows a tsort of these exported targets in the run
# phase to ensure an exported target is, for example (--run="sdist upload"), uploaded before any
# exported target that depends on it is uploaded.
created = {}
def create(exported_python_target):
if exported_python_target not in created:
self.context.log.info('Creating setup.py project for {}'.format(exported_python_target))
subject = self.derived_by_original.get(exported_python_target, exported_python_target)
setup_dir, dependencies = self.create_setup_py(subject, dist_dir)
created[exported_python_target] = setup_dir
if self._recursive:
for dep in dependencies:
if is_exported_python_target(dep):
create(dep)
for exported_python_target in exported_python_targets:
create(exported_python_target)
interpreter = self.context.products.get_data(PythonInterpreter)
python_dists = self.context.products.register_data(self.PYTHON_DISTS_PRODUCT, {})
for exported_python_target in reversed(sort_targets(list(created.keys()))):
setup_dir = created.get(exported_python_target)
if setup_dir:
if not self._run:
self.context.log.info('Running packager against {}'.format(setup_dir))
setup_runner = Packager(setup_dir, interpreter=interpreter)
tgz_name = os.path.basename(setup_runner.sdist())
sdist_path = os.path.join(dist_dir, tgz_name)
self.context.log.info('Writing {}'.format(sdist_path))
shutil.move(setup_runner.sdist(), sdist_path)
safe_rmtree(setup_dir)
python_dists[exported_python_target] = sdist_path
else:
self.context.log.info('Running {} against {}'.format(self._run, setup_dir))
split_command = safe_shlex_split(self._run)
setup_runner = SetupPyRunner(setup_dir, split_command, interpreter=interpreter)
installed = setup_runner.run()
if not installed:
raise TaskError('Install failed.')
python_dists[exported_python_target] = setup_dir
def create_plugin(distribution_repo_dir, plugin, version=None):
with safe_open(os.path.join(distribution_repo_dir, plugin, 'setup.py'), 'w') as fp:
fp.write(dedent("""
from setuptools import setup
setup(name="{plugin}", version="{version}")
""").format(plugin=plugin, version=version or '0.0.0'))
packager = Packager(source_dir=os.path.join(distribution_repo_dir, plugin),
install_dir=distribution_repo_dir)
packager.run()
def execute(self):
targets = [
target for target in self.context.target_roots
if self.has_provides(target)
]
if not targets:
raise TaskError('setup-py target(s) must provide an artifact.')
dist_dir = self.get_options().pants_distdir
# NB: We have to create and then run in 2 steps so that we can discover all exported targets
# in-play in the creation phase which then allows a tsort of these exported targets in the run
# phase to ensure an exported target is, for example (--run="sdist upload"), uploaded before any
# exported target that depends on it is uploaded.
created = {}
def create(target):
if target not in created:
self.context.log.info(
'Creating setup.py project for {}'.format(target))
setup_dir, dependencies = self.create_setup_py(
target, dist_dir)
created[target] = setup_dir
if self._recursive:
for dep in dependencies:
if self.has_provides(dep):
create(dep)
for target in targets:
create(target)
executed = {
} # Collected and returned for tests, processed target -> sdist|setup_dir.
for target in reversed(sort_targets(created.keys())):
setup_dir = created.get(target)
if setup_dir:
if not self._run:
self.context.log.info(
'Running packager against {}'.format(setup_dir))
setup_runner = Packager(setup_dir)
tgz_name = os.path.basename(setup_runner.sdist())
sdist_path = os.path.join(dist_dir, tgz_name)
self.context.log.info('Writing {}'.format(sdist_path))
shutil.move(setup_runner.sdist(), sdist_path)
safe_rmtree(setup_dir)
executed[target] = sdist_path
else:
self.context.log.info('Running {} against {}'.format(
self._run, setup_dir))
setup_runner = SetupPyRunner(setup_dir, self._run)
setup_runner.run()
executed[target] = setup_dir
return executed
def execute(self):
# We drive creation of setup.py distributions from the original target graph, grabbing codegen'd
# sources when needed. We ignore PythonDistribution targets.
def is_exported_python_target(t):
return t.is_original and self.has_provides(t) and not is_local_python_dist(t)
exported_python_targets = OrderedSet(t for t in self.context.target_roots
if is_exported_python_target(t))
if not exported_python_targets:
raise TaskError('setup-py target(s) must provide an artifact.')
dist_dir = self.get_options().pants_distdir
# NB: We have to create and then run in 2 steps so that we can discover all exported targets
# in-play in the creation phase which then allows a tsort of these exported targets in the run
# phase to ensure an exported target is, for example (--run="sdist upload"), uploaded before any
# exported target that depends on it is uploaded.
created = {}
def create(exported_python_target):
if exported_python_target not in created:
self.context.log.info('Creating setup.py project for {}'.format(exported_python_target))
subject = self.derived_by_original.get(exported_python_target, exported_python_target)
setup_dir, dependencies = self.create_setup_py(subject, dist_dir)
created[exported_python_target] = setup_dir
if self._recursive:
for dep in dependencies:
if is_exported_python_target(dep):
create(dep)
for exported_python_target in exported_python_targets:
create(exported_python_target)
interpreter = self.context.products.get_data(PythonInterpreter)
python_dists = self.context.products.register_data(self.PYTHON_DISTS_PRODUCT, {})
for exported_python_target in reversed(sort_targets(list(created.keys()))):
setup_dir = created.get(exported_python_target)
if setup_dir:
if not self._run:
self.context.log.info('Running packager against {}'.format(setup_dir))
setup_runner = Packager(setup_dir, interpreter=interpreter)
tgz_name = os.path.basename(setup_runner.sdist())
sdist_path = os.path.join(dist_dir, tgz_name)
self.context.log.info('Writing {}'.format(sdist_path))
shutil.move(setup_runner.sdist(), sdist_path)
safe_rmtree(setup_dir)
python_dists[exported_python_target] = sdist_path
else:
self.context.log.info('Running {} against {}'.format(self._run, setup_dir))
split_command = safe_shlex_split(self._run)
setup_runner = SetupPyRunner(setup_dir, split_command, interpreter=interpreter)
setup_runner.run()
python_dists[exported_python_target] = setup_dir
def execute(self):
targets = [target for target in self.context.target_roots if self.has_provides(target)]
if not targets:
raise TaskError('setup-py target(s) must provide an artifact.')
dist_dir = self.get_options().pants_distdir
# NB: We have to create and then run in 2 steps so that we can discover all exported targets
# in-play in the creation phase which then allows a tsort of these exported targets in the run
# phase to ensure an exported target is, for example (--run="sdist upload"), uploaded before any
# exported target that depends on it is uploaded.
created = {}
def create(target):
if target not in created:
self.context.log.info('Creating setup.py project for {}'.format(target))
setup_dir, dependencies = self.create_setup_py(target, dist_dir)
created[target] = setup_dir
if self._recursive:
for dep in dependencies:
if self.has_provides(dep):
create(dep)
for target in targets:
create(target)
executed = {} # Collected and returned for tests, processed target -> sdist|setup_dir.
for target in reversed(sort_targets(created.keys())):
setup_dir = created.get(target)
if setup_dir:
if not self._run:
self.context.log.info('Running packager against {}'.format(setup_dir))
setup_runner = Packager(setup_dir)
tgz_name = os.path.basename(setup_runner.sdist())
sdist_path = os.path.join(dist_dir, tgz_name)
self.context.log.info('Writing {}'.format(sdist_path))
shutil.move(setup_runner.sdist(), sdist_path)
safe_rmtree(setup_dir)
executed[target] = sdist_path
else:
self.context.log.info('Running {} against {}'.format(self._run, setup_dir))
setup_runner = SetupPyRunner(setup_dir, self._run)
setup_runner.run()
executed[target] = setup_dir
return executed
def run_one(self, target):
dist_dir = self._config.getdefault('pants_distdir')
chroot = Chroot(dist_dir, name=target.provides.name)
self.write_contents(target, chroot)
self.write_setup(target, chroot)
target_base = '%s-%s' % (target.provides.name, target.provides.version)
setup_dir = os.path.join(dist_dir, target_base)
safe_rmtree(setup_dir)
shutil.move(chroot.path(), setup_dir)
if not self.old_options.run:
print('Running packager against %s' % setup_dir)
setup_runner = Packager(setup_dir)
tgz_name = os.path.basename(setup_runner.sdist())
print('Writing %s' % os.path.join(dist_dir, tgz_name))
shutil.move(setup_runner.sdist(), os.path.join(dist_dir, tgz_name))
safe_rmtree(setup_dir)
else:
print('Running %s against %s' % (self.old_options.run, setup_dir))
setup_runner = SetupPyRunner(setup_dir, self.old_options.run)
setup_runner.run()
def run_one(self, target):
dist_dir = self._config.getdefault("pants_distdir")
chroot = Chroot(dist_dir, name=target.provides.name)
self.write_contents(target, chroot)
self.write_setup(target, chroot)
target_base = "%s-%s" % (target.provides.name, target.provides.version)
setup_dir = os.path.join(dist_dir, target_base)
safe_rmtree(setup_dir)
os.rename(chroot.path(), setup_dir)
if not self.options.run:
print("Running packager against %s" % setup_dir)
setup_runner = Packager(setup_dir)
tgz_name = os.path.basename(setup_runner.sdist())
print("Writing %s" % os.path.join(dist_dir, tgz_name))
os.rename(setup_runner.sdist(), os.path.join(dist_dir, tgz_name))
safe_rmtree(setup_dir)
else:
print("Running %s against %s" % (self.options.run, setup_dir))
setup_runner = SetupPyRunner(setup_dir, self.options.run)
setup_runner.run()
def run_one(self, target):
dist_dir = self.get_options().pants_distdir
chroot = Chroot(dist_dir, name=target.provides.name)
self.write_contents(target, chroot)
self.write_setup(target, chroot)
target_base = '%s-%s' % (target.provides.name, target.provides.version)
setup_dir = os.path.join(dist_dir, target_base)
safe_rmtree(setup_dir)
shutil.move(chroot.path(), setup_dir)
if not self._run:
self.context.log.info('Running packager against %s' % setup_dir)
setup_runner = Packager(setup_dir)
tgz_name = os.path.basename(setup_runner.sdist())
self.context.log.info('Writing %s' % os.path.join(dist_dir, tgz_name))
shutil.move(setup_runner.sdist(), os.path.join(dist_dir, tgz_name))
safe_rmtree(setup_dir)
else:
self.context.log.info('Running %s against %s' % (self._run, setup_dir))
setup_runner = SetupPyRunner(setup_dir, self._run)
setup_runner.run()
def execute(self):
# We operate on the target roots, except that we replace codegen targets with their
# corresponding synthetic targets, since those have the generated sources that actually
# get published. Note that the "provides" attributed is copied from the original target
# to the synthetic target, so that the latter can be used as a direct stand-in for the
# former here.
preliminary_targets = set(t for t in self.context.target_roots
if self.has_provides(t))
targets = set(preliminary_targets)
for t in self.context.targets():
# A non-codegen target has derived_from equal to itself, so we check is_original
# to ensure that the synthetic targets take precedence.
# We check that the synthetic target has the same "provides" as the original, because
# there are other synthetic targets in play (e.g., resources targets) to which this
# substitution logic must not apply.
if (t.derived_from in preliminary_targets and not t.is_original
and self.has_provides(t)
and t.provides == t.derived_from.provides):
targets.discard(t.derived_from)
targets.add(t)
if not targets:
raise TaskError('setup-py target(s) must provide an artifact.')
dist_dir = self.get_options().pants_distdir
# NB: We have to create and then run in 2 steps so that we can discover all exported targets
# in-play in the creation phase which then allows a tsort of these exported targets in the run
# phase to ensure an exported target is, for example (--run="sdist upload"), uploaded before any
# exported target that depends on it is uploaded.
created = {}
def create(target):
if target not in created:
self.context.log.info(
'Creating setup.py project for {}'.format(target))
setup_dir, dependencies = self.create_setup_py(
target, dist_dir)
created[target] = setup_dir
if self._recursive:
for dep in dependencies:
if self.has_provides(dep):
create(dep)
for target in targets:
create(target)
executed = {
} # Collected and returned for tests, processed target -> sdist|setup_dir.
for target in reversed(sort_targets(created.keys())):
setup_dir = created.get(target)
if setup_dir:
if not self._run:
self.context.log.info(
'Running packager against {}'.format(setup_dir))
setup_runner = Packager(setup_dir)
tgz_name = os.path.basename(setup_runner.sdist())
sdist_path = os.path.join(dist_dir, tgz_name)
self.context.log.info('Writing {}'.format(sdist_path))
shutil.move(setup_runner.sdist(), sdist_path)
safe_rmtree(setup_dir)
executed[target] = sdist_path
else:
self.context.log.info('Running {} against {}'.format(
self._run, setup_dir))
setup_runner = SetupPyRunner(setup_dir, self._run)
setup_runner.run()
executed[target] = setup_dir
return executed
def build_pex(args, options):
interpreter = interpreter_from_options(options)
pex_builder = PEXBuilder(
path=safe_mkdtemp(),
interpreter=interpreter,
)
pex_info = pex_builder.info
pex_info.zip_safe = options.zip_safe
pex_info.always_write_cache = options.always_write_cache
pex_info.ignore_errors = options.ignore_errors
pex_info.inherit_path = options.inherit_path
installer = WheelInstaller if options.use_wheel else EggInstaller
interpreter = interpreter_from_options(options)
fetchers = [Fetcher(options.repos)]
if options.pypi:
fetchers.append(PyPIFetcher())
if options.indices:
fetchers.extend(PyPIFetcher(index) for index in options.indices)
translator = translator_from_options(options)
if options.use_wheel:
precedence = (WheelPackage, EggPackage, SourcePackage)
else:
precedence = (EggPackage, SourcePackage)
requirements = options.requirements[:]
if options.source_dirs:
temporary_package_root = safe_mkdtemp()
for source_dir in options.source_dirs:
try:
sdist = Packager(source_dir).sdist()
except installer.Error:
die('Failed to run installer for %s' % source_dir,
CANNOT_DISTILL)
# record the requirement information
sdist_pkg = Package.from_href(sdist)
requirements.append('%s==%s' %
(sdist_pkg.name, sdist_pkg.raw_version))
# copy the source distribution
shutil.copyfile(
sdist,
os.path.join(temporary_package_root, os.path.basename(sdist)))
# Tell pex where to find the packages
fetchers.append(Fetcher([temporary_package_root]))
with TRACER.timed('Resolving distributions'):
resolveds = requirement_resolver(requirements,
fetchers=fetchers,
translator=translator,
interpreter=interpreter,
platform=options.platform,
precedence=precedence,
cache=options.cache_dir,
cache_ttl=options.cache_ttl)
for pkg in resolveds:
log(' %s' % pkg, v=options.verbosity)
pex_builder.add_distribution(pkg)
pex_builder.add_requirement(pkg.as_requirement())
if options.entry_point is not None:
log('Setting entry point to %s' % options.entry_point,
v=options.verbosity)
pex_builder.info.entry_point = options.entry_point
else:
log('Creating environment PEX.', v=options.verbosity)
return pex_builder
def execute(self):
# We operate on the target roots, except that we replace codegen targets with their
# corresponding synthetic targets, since those have the generated sources that actually
# get published. Note that the "provides" attributed is copied from the original target
# to the synthetic target, so that the latter can be used as a direct stand-in for the
# former here.
preliminary_targets = set(t for t in self.context.target_roots if self.has_provides(t))
targets = set(preliminary_targets)
for t in self.context.targets():
# A non-codegen target has derived_from equal to itself, so we check is_original
# to ensure that the synthetic targets take precedence.
# We check that the synthetic target has the same "provides" as the original, because
# there are other synthetic targets in play (e.g., resources targets) to which this
# substitution logic must not apply.
if (t.derived_from in preliminary_targets and not t.is_original and
self.has_provides(t) and t.provides == t.derived_from.provides):
targets.discard(t.derived_from)
targets.add(t)
if not targets:
raise TaskError('setup-py target(s) must provide an artifact.')
dist_dir = self.get_options().pants_distdir
# NB: We have to create and then run in 2 steps so that we can discover all exported targets
# in-play in the creation phase which then allows a tsort of these exported targets in the run
# phase to ensure an exported target is, for example (--run="sdist upload"), uploaded before any
# exported target that depends on it is uploaded.
created = {}
def create(target):
if target not in created:
self.context.log.info('Creating setup.py project for {}'.format(target))
setup_dir, dependencies = self.create_setup_py(target, dist_dir)
created[target] = setup_dir
if self._recursive:
for dep in dependencies:
if self.has_provides(dep):
create(dep)
for target in targets:
create(target)
interpreter = self.context.products.get_data(PythonInterpreter)
python_dists = self.context.products.register_data(self.PYTHON_DISTS_PRODUCT, {})
for target in reversed(sort_targets(created.keys())):
setup_dir = created.get(target)
if setup_dir:
if not self._run:
self.context.log.info('Running packager against {}'.format(setup_dir))
setup_runner = Packager(setup_dir, interpreter=interpreter)
tgz_name = os.path.basename(setup_runner.sdist())
sdist_path = os.path.join(dist_dir, tgz_name)
self.context.log.info('Writing {}'.format(sdist_path))
shutil.move(setup_runner.sdist(), sdist_path)
safe_rmtree(setup_dir)
python_dists[target] = sdist_path
else:
self.context.log.info('Running {} against {}'.format(self._run, setup_dir))
setup_runner = SetupPyRunner(setup_dir, self._run, interpreter=interpreter)
setup_runner.run()
python_dists[target] = setup_dir
