def bdist_pex(project_dir, bdist_args=None):
with temporary_dir() as dist_dir:
cmd = ['setup.py', 'bdist_pex', '--bdist-dir={}'.format(dist_dir)]
if bdist_args:
cmd.extend(bdist_args)
spawn_python_job(args=cmd, cwd=project_dir).wait()
dists = os.listdir(dist_dir)
assert len(dists) == 1
yield os.path.join(dist_dir, dists[0])
def create_sdist(*args, **kwargs):
dist_dir = safe_mkdtemp()
with make_project(*args, **kwargs) as project_dir:
cmd = ['setup.py', 'sdist', '--dist-dir={}'.format(dist_dir)]
spawn_python_job(args=cmd,
cwd=project_dir,
expose=['setuptools'],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE).communicate()
dists = os.listdir(dist_dir)
assert len(dists) == 1
return os.path.join(dist_dir, dists[0])
def spawn_calculation(self):
search_path = [dist.location for dist in self.distributions]
program = dedent("""
import json
import sys
from collections import defaultdict
from pkg_resources import Environment
env = Environment(search_path={search_path!r})
dependency_requirements = []
for key in env:
for dist in env[key]:
dependency_requirements.extend(str(req) for req in dist.requires())
json.dump(dependency_requirements, sys.stdout)
""".format(search_path=search_path))
job = spawn_python_job(
args=['-c', program],
stdout=subprocess.PIPE,
interpreter=self.target.get_interpreter(),
expose=['setuptools']
)
return SpawnedJob.stdout(job=job, result_func=self._markers_by_requirement)
def create_sdist(**kwargs):
# type: (**Any) -> str
dist_dir = safe_mkdtemp()
with make_project(**kwargs) as project_dir:
cmd = ["setup.py", "sdist", "--dist-dir={}".format(dist_dir)]
spawn_python_job(
args=cmd,
cwd=project_dir,
expose=["setuptools"],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
).communicate()
dists = os.listdir(dist_dir)
assert len(dists) == 1
return os.path.join(dist_dir, dists[0])
def bdist_pex(project_dir, bdist_args=None):
with temporary_dir() as dist_dir:
cmd = [
"setup.py",
"--command-packages",
"pex.commands",
"bdist_pex",
"--bdist-dir={}".format(dist_dir),
]
if bdist_args:
cmd.extend(bdist_args)
spawn_python_job(args=cmd,
cwd=project_dir,
pythonpath=bdist_pex_pythonpath()).wait()
dists = os.listdir(dist_dir)
assert len(dists) == 1
yield os.path.join(dist_dir, dists[0])
def spawn_extract(distribution):
# type: (Distribution) -> SpawnedJob[Text]
job = spawn_python_job(
args=["-m", "wheel", "pack", "--dest-dir", dest_dir, distribution.location],
interpreter=pex.interpreter,
expose=["wheel"],
stdout=subprocess.PIPE,
)
return SpawnedJob.stdout(
job, result_func=lambda out: "{}: {}".format(distribution, out.decode())
)
def _extract_sdist(
pex, # type: PEX
dest_dir, # type: str
):
# type: (...) -> None
chroot = safe_mkdtemp()
src = os.path.join(chroot, "src")
safe_mkdir(src)
excludes = ["__main__.py", "PEX-INFO"]
if zipfile.is_zipfile(pex.path()):
PEXEnvironment(pex.path()).explode_code(src, exclude=excludes)
else:
shutil.copytree(pex.path(), src, ignore=lambda _dir, _names: excludes)
pex_info = pex.pex_info()
name, _ = os.path.splitext(os.path.basename(pex.path()))
version = "0.0.0+{}".format(pex_info.code_hash)
zip_safe = pex_info.zip_safe
py_modules = [os.path.splitext(f)[0] for f in os.listdir(src) if f.endswith(".py")]
packages = [
os.path.relpath(os.path.join(root, d), src).replace(os.sep, ".")
for root, dirs, _ in os.walk(src)
for d in dirs
]
install_requires = [str(req) for req in pex_info.requirements]
python_requires = None
if len(pex_info.interpreter_constraints) == 1:
python_requires = str(
PythonIdentity.parse_requirement(pex_info.interpreter_constraints[0]).specifier
)
elif pex_info.interpreter_constraints:
pex_warnings.warn(
"Omitting `python_requires` for {name} sdist since {pex} has multiple "
"interpreter constraints:\n{interpreter_constraints}".format(
name=name,
pex=os.path.normpath(pex.path()),
interpreter_constraints="\n".join(
"{index}.) {constraint}".format(index=index, constraint=constraint)
for index, constraint in enumerate(
pex_info.interpreter_constraints, start=1
)
),
)
)
entry_points = []
if pex_info.entry_point and ":" in pex_info.entry_point:
entry_points = [(name, pex_info.entry_point)]
with open(os.path.join(chroot, "setup.cfg"), "w") as fp:
fp.write(
dedent(
"""\
[metadata]
name = {name}
version = {version}
[options]
zip_safe = {zip_safe}
{py_modules}
{packages}
package_dir =
=src
include_package_data = True
{python_requires}
{install_requires}
[options.entry_points]
{entry_points}
"""
).format(
name=name,
version=version,
zip_safe=zip_safe,
py_modules=(
"py_modules =\n {}".format("\n ".join(py_modules)) if py_modules else ""
),
packages=(
"packages = \n {}".format("\n ".join(packages)) if packages else ""
),
install_requires=(
"install_requires =\n {}".format("\n ".join(install_requires))
if install_requires
else ""
),
python_requires=(
"python_requires = {}".format(python_requires) if python_requires else ""
),
entry_points=(
"console_scripts =\n {}".format(
"\n ".join(
"{} = {}".format(name, entry_point)
for name, entry_point in entry_points
)
)
if entry_points
else ""
),
)
)
with open(os.path.join(chroot, "MANIFEST.in"), "w") as fp:
fp.write("recursive-include src *")
with open(os.path.join(chroot, "setup.py"), "w") as fp:
fp.write("import setuptools; setuptools.setup()")
spawn_python_job(
args=["setup.py", "sdist", "--dist-dir", dest_dir],
interpreter=pex.interpreter,
expose=["setuptools"],
cwd=chroot,
).wait()
