def writer(tmpdir_cwd):
with open("src_file", "w"), open("src_file2", "w"):
pass
cli_args = [
"--dry-run",
"--output-file",
"requirements.txt",
"src_file",
"src_file2",
]
with cli.make_context("pip-compile", cli_args) as ctx:
writer = OutputWriter(
src_files=["src_file", "src_file2"],
dst_file=ctx.params["output_file"],
click_ctx=ctx,
dry_run=True,
emit_header=True,
emit_index=True,
emit_trusted_host=True,
annotate=True,
generate_hashes=False,
default_index_url=None,
index_urls=[],
trusted_hosts=[],
format_control=FormatControl(set(), set()),
allow_unsafe=False,
find_links=[],
emit_find_links=True,
)
yield writer
def test_get_compile_command_sort_args(tmpdir_cwd):
"""
Test that get_compile_command correctly sorts arguments.
The order is "pip-compile {sorted options} {sorted src files}".
"""
with open("setup.py", "w"), open("requirements.in", "w"):
pass
args = [
"--no-index",
"--no-emit-trusted-host",
"--no-annotate",
"setup.py",
"--find-links",
"foo",
"--find-links",
"bar",
"requirements.in",
]
with compile_cli.make_context("pip-compile", args) as ctx:
assert get_compile_command(ctx) == (
"pip-compile --find-links=bar --find-links=foo "
"--no-annotate --no-emit-trusted-host --no-index "
"requirements.in setup.py")
def writer(tmpdir_cwd):
with open("src_file", "w"), open("src_file2", "w"):
pass
cli_args = [
"--dry-run",
"--output-file",
"requirements.txt",
"src_file",
"src_file2",
]
with cli.make_context("pip-compile", cli_args) as ctx:
writer = OutputWriter(
src_files=["src_file", "src_file2"],
dst_file=ctx.params["output_file"],
click_ctx=ctx,
dry_run=True,
emit_header=True,
emit_index=True,
emit_trusted_host=True,
annotate=True,
generate_hashes=False,
default_index_url=None,
index_urls=[],
trusted_hosts=[],
format_control=FormatControl(set(), set()),
allow_unsafe=False,
find_links=[],
)
yield writer
def test_get_compile_command_escaped_filenames(tmpdir_cwd):
"""
Test that get_compile_command output (re-)escapes ' -- '-escaped filenames.
"""
with open("--requirements.in", "w"):
pass
with compile_cli.make_context("pip-compile", ["--", "--requirements.in"]) as ctx:
assert get_compile_command(ctx) == "pip-compile -- --requirements.in"
def test_get_compile_command_with_files(tmpdir_cwd, filename):
"""
Test that get_compile_command returns a command with correct
and sanitized file names.
"""
os.mkdir("sub")
path = os.path.join("sub", filename)
with open(path, "w"):
pass
args = [path, "--output-file", "requirements.txt"]
with compile_cli.make_context("pip-compile", args) as ctx:
assert (
get_compile_command(ctx) ==
f"pip-compile --output-file=requirements.txt {shlex.quote(path)}")
def write_to_bento(self, bento_fs: FS, build_ctx: str):
py_folder = fs.path.join("env", "python")
wheels_folder = fs.path.join(py_folder, "wheels")
bento_fs.makedirs(py_folder, recreate=True)
# Save the python version of current build environment
with bento_fs.open(fs.path.join(py_folder, "version.txt"), "w") as f:
f.write(PYTHON_VERSION)
# Move over required wheel files
# Note: although wheel files outside of build_ctx will also work, we should
# discourage users from doing that
if self.wheels is not None:
for whl_file in self.wheels: # pylint: disable=not-an-iterable
whl_file = resolve_user_filepath(whl_file, build_ctx)
copy_file_to_fs_folder(whl_file, bento_fs, wheels_folder)
# If BentoML is installed in editable mode, build bentoml whl and save to Bento
build_bentoml_whl_to_target_if_in_editable_mode(
bento_fs.getsyspath(wheels_folder))
if self.requirements_txt is not None:
requirements_txt_file = resolve_user_filepath(
self.requirements_txt, build_ctx)
copy_file_to_fs_folder(
requirements_txt_file,
bento_fs,
py_folder,
dst_filename="requirements.txt",
)
elif self.packages is not None:
with bento_fs.open(fs.path.join(py_folder, "requirements.txt"),
"w") as f:
f.write("\n".join(self.packages))
else:
# Return early if no python packages were specified
return
pip_args: t.List[str] = []
if self.no_index:
pip_args.append("--no-index")
if self.index_url:
pip_args.append(f"--index-url={self.index_url}")
if self.trusted_host:
for item in self.trusted_host: # pylint: disable=not-an-iterable
pip_args.append(f"--trusted-host={item}")
if self.find_links:
for item in self.find_links: # pylint: disable=not-an-iterable
pip_args.append(f"--find-links={item}")
if self.extra_index_url:
for item in self.extra_index_url: # pylint: disable=not-an-iterable
pip_args.append(f"--extra-index-url={item}")
if self.pip_args:
# Additional user provided pip_args
pip_args.append(self.pip_args)
# write pip install args to a text file if applicable
if pip_args:
with bento_fs.open(fs.path.join(py_folder, "pip_args.txt"),
"w") as f:
f.write(" ".join(pip_args))
if self.lock_packages:
# Note: "--allow-unsafe" is required for including setuptools in the
# generated requirements.lock.txt file, and setuptool is required by
# pyfilesystem2. Once pyfilesystem2 drop setuptools as dependency, we can
# remove the "--allow-unsafe" flag here.
# Note: "--generate-hashes" is purposefully not used here because it will
# break if user includes PyPI package from version control system
pip_compile_in = bento_fs.getsyspath(
fs.path.join(py_folder, "requirements.txt"))
pip_compile_out = bento_fs.getsyspath(
fs.path.join(py_folder, "requirements.lock.txt"))
pip_compile_args = ([pip_compile_in] + pip_args + [
"--quiet",
"--allow-unsafe",
"--no-header",
f"--output-file={pip_compile_out}",
])
logger.info("Locking PyPI package versions..")
click_ctx = pip_compile_cli.make_context("pip-compile",
pip_compile_args)
try:
pip_compile_cli.invoke(click_ctx)
except Exception as e:
logger.error(f"Failed locking PyPI packages: {e}")
logger.error(
"Falling back to using user-provided package requirement specifier, equivalent to `lock_packages=False`"
)
def test_get_compile_command(tmpdir_cwd, cli_args, expected_command):
"""
Test general scenarios for the get_compile_command function.
"""
with compile_cli.make_context("pip-compile", cli_args) as ctx:
assert get_compile_command(ctx) == expected_command
