def test_validate_files(files):
if all(os.path.exists(file_) for file_ in files):
assert validate_files(files=files, exit_on_failure=False)
else:
with pytest.raises(SystemExit):
assert validate_files(files=files)
assert not validate_files(files=files, exit_on_failure=False)
def lock_command(args, packages=None, exit_on_failure=True):
"""Display or save locked requirements for current environment
:param args: Command arguments
:param packages: Collection of packages
:param exit_on_failure: Enable/disable exiting application on failure
:return: None
"""
requirements_files = (args.requirements or Config.requirements_files or [])
ignore_list = (args.ignore or Config.ignore_list or [])
save_lock = args.save or False
lock_filepath = args.file or Config.lock_file_path
printer = Printer()
if not validate_files(files=requirements_files,
printer=printer,
exit_on_failure=exit_on_failure):
return False
requirements = RequirementCollection()
for requirements_file in requirements_files:
requirements.extend(
RequirementCollection.from_file(filepath=requirements_file))
lock_ignore_list = [
key for key in ignore_list if key not in requirements.keys()
]
packages = (packages or dependency_list(ignore_list=lock_ignore_list))
locked = locked_requirements(packages=packages, requirements=requirements)
if save_lock:
locked.save_lock_file(filepath=lock_filepath)
printer.success(message=messages.LOCK_EXPORTED.format(
file_path=lock_filepath))
else:
for item in locked:
printer.info("{}=={}".format(
printer.colored_message(item.key, color.DEFAULT_PACKAGE),
item.version_id))
return True
def list_command(args, packages=None, exit_on_failure=True):
"""List installed dependencies with configurable filters
:param args: Command arguments
:param packages: Collection of packages
:param exit_on_failure: Enable/disable exiting application on failure
:return: None
"""
requirements_files = (args.requirements or Config.requirements_files or [])
ignore_list = (args.ignore or Config.ignore_list or [])
printer = Printer()
if not validate_files(files=requirements_files,
printer=printer,
exit_on_failure=exit_on_failure):
return False
requirements = RequirementCollection()
for requirements_file in requirements_files:
requirements.extend(
RequirementCollection.from_file(filepath=requirements_file))
requirements = requirements if requirements else None
packages = (packages or dependency_list(ignore_list=ignore_list,
requirements=requirements))
headers = [messages.PACKAGE, messages.INSTALLED]
tabular_data = [[
printer.colored_message(message=package.key,
message_color=printer.color_package),
package.version_id
] for package in packages]
if tabular_data:
printer.table(headers=headers, tabular_data=tabular_data)
else:
printer.info(messages.PACKAGES_NOT_FOUND)
return True
def missing_requirements_command(args, packages=None, exit_on_failure=True):
"""Runs detection of required packages that are not installed
:param args: Command arguments
:param packages: Collection of packages
:param exit_on_failure: Enable/disable exiting application on failure
:return: None
"""
requirements_files = (
args.requirements or Config.requirements_files or []
)
ignore_list = (
args.ignore or Config.ignore_list or []
)
printer = Printer()
if not validate_files(
files=requirements_files,
printer=printer,
exit_on_failure=exit_on_failure):
return False
requirements = RequirementCollection()
for requirements_file in requirements_files:
requirements.extend(
RequirementCollection.from_file(filepath=requirements_file)
)
packages = (
packages or dependency_list(ignore_list=ignore_list)
)
missing = [
(package, required_by)
for package, required_by
in missing_requirements(
packages=packages,
requirements=requirements,
ignore_list=ignore_list
)
]
headers = [
messages.PACKAGE,
messages.REQUIRED,
messages.REQUIRED_BY,
]
tabular_data = []
for package, requirers in missing:
if requirers:
for required_by, required_version in requirers:
tabular_data.append([
printer.colored_message(
message=package.key,
message_color=printer.color_package
),
required_version,
required_by.key,
])
else:
tabular_data.append([
printer.colored_message(
message=package.key,
message_color=printer.color_package
),
package.version.specifier,
"Requirements",
])
if tabular_data:
printer.error(messages.MISSING_FOUND)
printer.table(headers=headers, tabular_data=tabular_data)
if exit_on_failure:
sys.exit(1)
return False
printer.success(messages.MISSING_OK)
return True
def tree_command(args, packages=None, exit_on_failure=True):
"""Display dependency tree for a single package or the entire environment
:param args: Command arguments
:param packages: Collection of packages
:param exit_on_failure: Enable/disable exiting application on failure
:return: None
"""
package_key = args.package
requirements_files = (args.requirements or Config.requirements_files or [])
ignore_list = (args.ignore or Config.ignore_list or [])
printer = Printer()
if not validate_files(files=requirements_files,
printer=printer,
exit_on_failure=exit_on_failure):
return False
requirements = RequirementCollection()
for requirements_file in requirements_files:
requirements.extend(
RequirementCollection.from_file(filepath=requirements_file))
package_string = '{package} [{installed}: {version}]'
requirement_string = (
'{spacing}{package} [{installed}: {version} | {required}: {spec}]')
packages = (packages or dependency_list(ignore_list=ignore_list))
if package_key:
package = packages.get(key=package_key)
if not package:
printer.error(
messages.PACKAGE_NOT_FOUND.format(package=package_key))
sys.exit(1)
tree = {package: package_dependency_tree(dependency=package)}
else:
tree = dependency_tree(
packages=packages,
requirements=requirements if requirements else None)
if not tree:
printer.info(messages.PACKAGES_NOT_FOUND)
def print_dependency_tree(requirements_list, indent=0):
spacing = ' ' * indent
for requirement in requirements_list:
printer.info(
requirement_string.format(
spacing=spacing,
package=printer.colored_message(
message=requirement.key,
message_color=printer.color_package),
installed=messages.INSTALLED,
version=requirement.version_id,
required=messages.REQUIRED,
spec=requirement.specified_version), )
print_dependency_tree(requirements_list[requirement], indent + 2)
for dependency in tree:
printer.info(
package_string.format(package=printer.colored_message(
message=dependency.key, message_color=printer.color_package),
installed=messages.INSTALLED,
version=dependency.version))
print_dependency_tree(tree[dependency], indent=2)
return True
def validate_command(args, packages=None, exit_on_failure=True):
"""Runs requirement file validation
:param args: Command arguments
:param packages: Collection of packages
:param exit_on_failure: Enable/disable exiting application on failure
:return: None
"""
strict = args.strict or False
ignore_list = (
args.ignore or Config.ignore_list or []
)
requirements_files = (
args.requirements or Config.requirements_files or []
)
lock_files = (
args.lock or Config.lock_files or []
)
printer = Printer()
if not validate_files(
files=requirements_files,
printer=printer,
exit_on_failure=exit_on_failure
) or not validate_files(
files=lock_files,
printer=printer,
exit_on_failure=exit_on_failure):
return False
try:
requirements = RequirementCollection.from_files(
filepaths=requirements_files
)
locked = RequirementCollection.from_files(filepaths=lock_files)
except Exception as e:
# Always exit on invalid requirements
printer.error('{}: {}'.format(messages.REQUIREMENTS_PARSING_ERROR, e))
sys.exit(1)
checks_ok = []
packages = (
packages or dependency_list(ignore_list=ignore_list)
)
checks_ok.append(check_unlocked_requirements(
requirements=requirements,
printer=printer,
))
checks_ok.append(check_unset_locks(
requirements=requirements,
locked=locked,
printer=printer,
))
checks_ok.append(check_package_version_mismatch(
packages=packages,
locked=locked,
printer=printer,
))
checks_ok.append(check_requirement_version_mismatch(
requirements=requirements,
locked=locked,
printer=printer,
))
if strict:
checks_ok.append(check_unnecessary_packages(
packages=packages,
requirements=requirements,
locked=locked,
printer=printer,
))
checks_ok.append(check_unnecessary_locks(
requirements=requirements,
locked=locked,
ignore_list=ignore_list,
printer=printer,
))
return (
sys.exit(1) if exit_on_failure else False
if not all(checks_ok)
else True
)