def test_can_create_wheel_from_valid_directory(
extracted_six_package,
current_platform,
logger: Logger,
requirement_parser: RequirementParser,
):
Wheel.from_wheel_directory_path(extracted_six_package, current_platform,
logger, requirement_parser)
def import_wheel(self, wheel: Wheel,
requirement_parser: RequirementParser) -> None:
dependent = requirement_parser.parse(wheel.name)
for runtime_dependency in wheel.runtime_dependencies(
wheel.target_platform()):
self.set_runtime_dependency(dependent, runtime_dependency)
for build_dependency in wheel.build_dependencies(
wheel.target_platform()):
self.set_buildtime_dependency(dependent, build_dependency)
def test_can_add_build_dependencies_to_wheel(
wheel: Wheel,
current_platform: TargetPlatform,
requirement_parser: RequirementParser,
):
build_dependencies = RequirementSet(current_platform)
build_dependencies.add(requirement_parser.parse("dep1"))
build_dependencies.add(requirement_parser.parse("dep2"))
wheel.add_build_dependencies(build_dependencies)
assert "dep1" in wheel.build_dependencies(current_platform)
assert "dep2" in wheel.build_dependencies(current_platform)
def test_can_understand_wheel_dependecies(
current_platform: TargetPlatform,
requirement_parser: RequirementParser):
runtime_dependencies = RequirementSet(current_platform)
runtime_dependency = requirement_parser.parse("runtime_dependency")
runtime_dependencies.add(runtime_dependency)
build_dependencies = RequirementSet(current_platform)
build_dependency = requirement_parser.parse("build_dependency")
build_dependencies.add(build_dependency)
wheel = Wheel(
name="testpackage",
version="",
deps=runtime_dependencies,
target_platform=current_platform,
license="",
homepage="",
description="",
build_dependencies=build_dependencies,
)
requirement = requirement_parser.parse("testpackage")
dependency_graph = DependencyGraph()
dependency_graph.import_wheel(wheel, requirement_parser)
assert dependency_graph.is_buildtime_dependency(requirement,
build_dependency)
assert dependency_graph.is_runtime_dependency(requirement,
runtime_dependency)
def flit_wheel(data_directory, current_platform, logger, requirement_parser):
path = os.path.join(data_directory, "flit-1.3-py3-none-any.whl")
with Archive(path=path).extracted_files() as wheel_directory:
return Wheel.from_wheel_directory_path(
os.path.join(wheel_directory, "flit-1.3.dist-info"),
current_platform,
logger,
requirement_parser,
)
def extracted_six_package(six_requirements, wheel_builder,
default_environment):
wheels = wheel_builder.build(six_requirements)
for wheel_directory in wheels:
wheel = Wheel.from_wheel_directory_path(wheel_directory,
default_environment)
if wheel.name == "six":
return wheel_directory
raise Exception('Error when trying to build wheel for "six == 1.12.0"')
def wheel():
return Wheel(
name="test-wheel",
version="1.0",
deps=set(),
homepage="https://example.test",
license="",
description="description",
)
def extracted_six_package(six_requirements, wheel_builder, current_platform,
logger, requirement_parser):
wheels = wheel_builder.build(six_requirements)
for wheel_directory in wheels:
wheel = Wheel.from_wheel_directory_path(wheel_directory,
current_platform, logger,
requirement_parser)
if wheel.name == "six":
return wheel_directory
raise Exception('Error when trying to build wheel for "six == 1.12.0"')
def wheel(current_platform):
build_dependencies = RequirementSet(current_platform)
dependencies = RequirementSet(current_platform)
return Wheel(
name="test-wheel",
version="1.0",
deps=dependencies,
homepage="https://example.test",
license="",
description="description",
build_dependencies=build_dependencies,
target_platform=current_platform,
)
def setupcfg_package_wheel(
setupcfg_package_wheel_path: str,
logger: Logger,
requirement_parser: RequirementParser,
current_platform: TargetPlatform,
) -> Wheel:
archive = Archive(path=setupcfg_package_wheel_path)
with archive.extracted_files() as directory:
return Wheel.from_wheel_directory_path(
os.path.join(directory, "setupcfg_package-1.0.dist-info"),
current_platform,
logger,
requirement_parser,
)
def main(
self,
wheel_paths: Iterable[str],
target_platform: TargetPlatform,
source_distributions: Dict[str, SourceDistribution],
) -> List[Wheel]:
"""Extract packages metadata from wheels dist-info folders.
"""
output = ""
metadata: List[Wheel] = []
self.logger.info(
"-- sources ---------------------------------------------------------------"
)
for name, source in self.sources.items():
self.logger.info("{name}, {source}".format(name=name, source=name))
self.logger.info(
"--------------------------------------------------------------------------"
)
wheels = []
for wheel_path in wheel_paths:
self.logger.debug("|-> from %s" % os.path.basename(wheel_path))
wheel_metadata = Wheel.from_wheel_directory_path(
wheel_path, target_platform, self.logger,
self.requirement_parser)
if not wheel_metadata:
continue
if wheel_metadata.name in source_distributions:
source_distribution = source_distributions[wheel_metadata.name]
wheel_metadata.add_build_dependencies(
source_distribution.build_dependencies(target_platform))
wheel_metadata.package_format = source_distribution.package_format
wheels.append(wheel_metadata)
self.logger.debug(
"-- wheel_metadata --------------------------------------------------------"
)
self.logger.debug(
json.dumps(wheel_metadata.to_dict(), sort_keys=True, indent=4))
self.logger.debug(
"--------------------------------------------------------------------------"
)
self.process_wheel(wheel_metadata)
return wheels
def test_can_create_wheel_from_valid_directory(extracted_six_package,
default_environment):
Wheel.from_wheel_directory_path(extracted_six_package, default_environment)
def test_that_setupcfg_package_wheel_contains_pytest_as_testing_dependency(
setupcfg_package_wheel: Wheel, ):
assert "pytest" in setupcfg_package_wheel.dependencies(extras=["testing"])
def test_that_setupcfg_package_wheel_contains_requests_as_dependency(
setupcfg_package_wheel: Wheel, ):
assert "requests" in setupcfg_package_wheel.dependencies()
def test_that_to_dict_is_json_serializable(wheel: Wheel):
json.dumps(wheel.to_dict())
def test_that_setupcfg_package_wheel_does_not_contain_pytest_as_non_testing_dependency(
setupcfg_package_wheel: Wheel, ):
assert "pytest" not in setupcfg_package_wheel.dependencies()
def main(
self,
wheel_paths: Iterable[str],
default_environment: Any,
wheel_cache_dir: str,
additional_dependencies: Dict[str, RequirementSet],
) -> List[Wheel]:
"""Extract packages metadata from wheels dist-info folders.
"""
output = ""
metadata: List[Wheel] = []
if self.verbose > 1:
click.echo(
"-- sources ---------------------------------------------------------------"
)
for name, source in self.sources.items():
click.echo("{name}, {source}".format(name=name, source=name))
click.echo(
"--------------------------------------------------------------------------"
)
wheels = []
try:
for wheel_path in wheel_paths:
output += "|-> from %s" % os.path.basename(wheel_path)
if self.verbose > 0:
click.echo("|-> from %s" % os.path.basename(wheel_path))
wheel_metadata = Wheel.from_wheel_directory_path(
wheel_path, default_environment)
if not wheel_metadata:
continue
if wheel_metadata.name in TO_IGNORE:
if self.verbose > 0:
click.echo(" SKIPPING")
continue
if wheel_metadata.name in additional_dependencies:
wheel_metadata.add_build_dependencies(
map(
lambda dependency: dependency.name(),
additional_dependencies[wheel_metadata.name],
))
wheels.append(wheel_metadata)
if self.verbose > 1:
click.echo(
"-- wheel_metadata --------------------------------------------------------"
)
click.echo(
json.dumps(wheel_metadata.to_dict(),
sort_keys=True,
indent=4))
click.echo(
"--------------------------------------------------------------------------"
)
self.process_wheel(wheel_metadata)
except Exception as e:
if self.verbose == 0:
click.echo(output)
raise
return wheels