From 08a6962d3f8cab3042db1b0c8ceb3819e4800638 Mon Sep 17 00:00:00 2001 From: Ethan Paul <24588726+enpaul@users.noreply.github.com> Date: Tue, 9 Feb 2021 23:53:56 -0500 Subject: [PATCH] General refactoring Fix some pseudo-hungarian type notation Fix out of date docstrings Fix arbitrary argument ordering in function signatures Remove interchangable usage of dep/dependency variable naming Remove interchangable usage of packages/package_map for same data --- tox_poetry_installer/hooks.py | 14 +-- tox_poetry_installer/utilities.py | 183 ++++++++++++++---------------- 2 files changed, 95 insertions(+), 102 deletions(-) diff --git a/tox_poetry_installer/hooks.py b/tox_poetry_installer/hooks.py index a42b7ee..3b9bae4 100644 --- a/tox_poetry_installer/hooks.py +++ b/tox_poetry_installer/hooks.py @@ -4,11 +4,9 @@ All implementations of tox hooks are defined here, as well as any single-use hel specifically related to implementing the hooks (to keep the size/readability of the hook functions themselves manageable). """ -from typing import List from typing import Optional import tox -from poetry.core.packages import Package as PoetryPackage from tox.action import Action as ToxAction from tox.config import Parser as ToxParser from tox.venv import VirtualEnv as ToxVirtualEnv @@ -92,13 +90,13 @@ def tox_testenv_install_deps(venv: ToxVirtualEnv, action: ToxAction) -> Optional f"Unlocked dependencies '{venv.envconfig.deps}' specified for environment '{venv.name}' which requires locked dependencies" ) - package_map: PackageMap = { + packages: PackageMap = { package.name: package for package in poetry.locker.locked_repository(True).packages } if venv.envconfig.install_dev_deps: - dev_deps = utilities.find_dev_dependencies(poetry, package_map) + dev_deps = utilities.find_dev_deps(packages, poetry) tox.reporter.verbosity1( f"{constants.REPORTER_PREFIX} Identified {len(dev_deps)} development dependencies to install to env" ) @@ -108,15 +106,17 @@ def tox_testenv_install_deps(venv: ToxVirtualEnv, action: ToxAction) -> Optional f"{constants.REPORTER_PREFIX} Env does not install development dependencies, skipping" ) - env_deps = utilities.find_env_dependencies(venv, poetry, package_map) + env_deps = utilities.find_additional_deps( + packages, poetry, venv.envconfig.locked_deps + ) tox.reporter.verbosity1( f"{constants.REPORTER_PREFIX} Identified {len(env_deps)} environment dependencies to install to env" ) if not venv.envconfig.skip_install and not venv.envconfig.config.skipsdist: - project_deps: List[PoetryPackage] = utilities.find_project_dependencies( - venv, poetry, package_map + project_deps = utilities.find_project_deps( + packages, poetry, venv.envconfig.extras ) else: project_deps = [] diff --git a/tox_poetry_installer/utilities.py b/tox_poetry_installer/utilities.py index c477945..c6da224 100644 --- a/tox_poetry_installer/utilities.py +++ b/tox_poetry_installer/utilities.py @@ -21,20 +21,55 @@ if typing.TYPE_CHECKING: from tox_poetry_installer import _poetry +def check_preconditions(venv: ToxVirtualEnv, action: ToxAction) -> "_poetry.Poetry": + """Check that the local project environment meets expectations""" + # Skip running the plugin for the provisioning environment. The provisioned environment, + # for alternative Tox versions and/or the ``requires`` meta dependencies is specially + # handled by Tox and is out of scope for this plugin. Since one of the ways to install this + # plugin in the first place is via the Tox provisioning environment, it quickly becomes a + # chicken-and-egg problem. + if action.name == venv.envconfig.config.provision_tox_env: + raise exceptions.SkipEnvironment( + f"Skipping Tox provisioning env '{action.name}'" + ) + + # Skip running the plugin for the packaging environment. PEP-517 front ends can handle + # that better than we can, so let them do their thing. More to the point: if you're having + # problems in the packaging env that this plugin would solve, god help you. + if action.name == venv.envconfig.config.isolated_build_env: + raise exceptions.SkipEnvironment( + f"Skipping isolated packaging build env '{action.name}'" + ) + + from tox_poetry_installer import _poetry + + try: + return _poetry.Factory().create_poetry(venv.envconfig.config.toxinidir) + # Support running the plugin when the current tox project does not use Poetry for its + # environment/dependency management. + # + # ``RuntimeError`` is dangerous to blindly catch because it can be (and in Poetry's case, + # is) raised in many different places for different purposes. + except RuntimeError: + raise exceptions.SkipEnvironment( + "Project does not use Poetry for env management, skipping installation of locked dependencies" + ) from None + + def identify_transients( - packages: PackageMap, dependency_name: str, allow_missing: Sequence[str] = () + packages: PackageMap, dep_name: str, allow_missing: Sequence[str] = () ) -> List[PoetryPackage]: - """Using a poetry object identify all dependencies of a specific dependency + """Using a pool of packages, identify all transient dependencies of a given package name :param packages: All packages from the lockfile to use for identifying dependency relationships. - :param dependency_name: Bare name (without version) of the dependency to fetch the transient + :param dep_name: Bare name (without version) of the dependency to fetch the transient dependencies of. :param allow_missing: Sequence of package names to allow to be missing from the lockfile. Any packages that are not found in the lockfile but their name appears in this list will be silently skipped from installation. :returns: List of packages that need to be installed for the requested dependency. - .. note:: The package corresponding to the dependency named by ``dependency_name`` is included + .. note:: The package corresponding to the dependency named by ``dep_name`` is included in the list of returned packages. """ from tox_poetry_installer import _poetry @@ -90,98 +125,60 @@ def identify_transients( transients.append(package) try: - find_deps_of_deps(packages[dependency_name].name) + find_deps_of_deps(packages[dep_name].name) except KeyError: - if dependency_name in _poetry.Provider.UNSAFE_PACKAGES: + if dep_name in _poetry.Provider.UNSAFE_PACKAGES: tox.reporter.warning( - f"{constants.REPORTER_PREFIX} Installing package '{dependency_name}' using Poetry is not supported and will be skipped" + f"{constants.REPORTER_PREFIX} Installing package '{dep_name}' using Poetry is not supported and will be skipped" ) return [] if any( - delimiter in dependency_name - for delimiter in constants.PEP508_VERSION_DELIMITERS + delimiter in dep_name for delimiter in constants.PEP508_VERSION_DELIMITERS ): raise exceptions.LockedDepVersionConflictError( - f"Locked dependency '{dependency_name}' cannot include version specifier" + f"Locked dependency '{dep_name}' cannot include version specifier" ) from None raise exceptions.LockedDepNotFoundError( - f"No version of locked dependency '{dependency_name}' found in the project lockfile" + f"No version of locked dependency '{dep_name}' found in the project lockfile" ) from None return transients -def check_preconditions(venv: ToxVirtualEnv, action: ToxAction) -> "_poetry.Poetry": - """Check that the local project environment meets expectations""" - # Skip running the plugin for the provisioning environment. The provisioned environment, - # for alternative Tox versions and/or the ``requires`` meta dependencies is specially - # handled by Tox and is out of scope for this plugin. Since one of the ways to install this - # plugin in the first place is via the Tox provisioning environment, it quickly becomes a - # chicken-and-egg problem. - if action.name == venv.envconfig.config.provision_tox_env: - raise exceptions.SkipEnvironment( - f"Skipping Tox provisioning env '{action.name}'" - ) - - # Skip running the plugin for the packaging environment. PEP-517 front ends can handle - # that better than we can, so let them do their thing. More to the point: if you're having - # problems in the packaging env that this plugin would solve, god help you. - if action.name == venv.envconfig.config.isolated_build_env: - raise exceptions.SkipEnvironment( - f"Skipping isolated packaging build env '{action.name}'" - ) - - from tox_poetry_installer import _poetry - - try: - return _poetry.Factory().create_poetry(venv.envconfig.config.toxinidir) - # Support running the plugin when the current tox project does not use Poetry for its - # environment/dependency management. - # - # ``RuntimeError`` is dangerous to blindly catch because it can be (and in Poetry's case, - # is) raised in many different places for different purposes. - except RuntimeError: - raise exceptions.SkipEnvironment( - "Project does not use Poetry for env management, skipping installation of locked dependencies" - ) from None - - -def find_project_dependencies( - venv: ToxVirtualEnv, poetry: "_poetry.Poetry", packages: PackageMap +def find_project_deps( + packages: PackageMap, poetry: "_poetry.Poetry", extras: Sequence[str] = () ) -> List[PoetryPackage]: - """Find the root package dependencies + """Find the root project dependencies - Recursively identify the root package dependencies + Recursively identify the dependencies of the root project package - :param venv: Tox virtual environment to install the packages to - :param poetry: Poetry object the packages were sourced from - :param packages: Mapping of package names to the corresponding package object + :param packages: Mapping of all locked package names to their corresponding package object + :param poetry: Poetry object for the current project + :param extras: Sequence of extra names to include the dependencies of """ - base_dependencies: List[PoetryPackage] = [ + base_deps: List[PoetryPackage] = [ packages[item.name] for item in poetry.package.requires if not item.is_optional() ] - extra_dependencies: List[PoetryPackage] = [] - for extra in venv.envconfig.extras: + extra_deps: List[PoetryPackage] = [] + for extra in extras: tox.reporter.verbosity1( f"{constants.REPORTER_PREFIX} Processing project extra '{extra}'" ) try: - extra_dependencies += [ - packages[item.name] for item in poetry.package.extras[extra] - ] + extra_deps += [packages[item.name] for item in poetry.package.extras[extra]] except KeyError: raise exceptions.ExtraNotFoundError( - f"Environment '{venv.name}' specifies project extra '{extra}' which was not found in the lockfile" + f"Environment specifies project extra '{extra}' which was not found in the lockfile" ) from None dependencies: List[PoetryPackage] = [] - for dep in base_dependencies + extra_dependencies: + for dep in base_deps + extra_deps: dependencies += identify_transients( packages, dep.name.lower(), allow_missing=[poetry.package.name] ) @@ -189,43 +186,39 @@ def find_project_dependencies( return dependencies -def find_dev_dependencies( - poetry: "_poetry.Poetry", packages: PackageMap +def find_additional_deps( + packages: PackageMap, poetry: "_poetry.Poetry", dep_names: Sequence[str] +) -> List[PoetryPackage]: + """Find additional dependencies + + Recursively identify the dependencies of an arbitrary list of package names + + :param packages: Mapping of all locked package names to their corresponding package object + :param poetry: Poetry object for the current project + :param dep_names: Sequence of additional dependency names to recursively find the transient + dependencies for + """ + deps: List[PoetryPackage] = [] + for dep_name in dep_names: + deps += identify_transients( + packages, dep_name.lower(), allow_missing=[poetry.package.name] + ) + + return deps + + +def find_dev_deps( + packages: PackageMap, poetry: "_poetry.Poetry" ) -> List[PoetryPackage]: """Find the dev dependencies Recursively identify the Poetry dev dependencies - :param venv: Tox virtual environment to install the packages to - :param poetry: Poetry object the packages were sourced from - :param packages: Mapping of package names to the corresponding package object + :param packages: Mapping of all locked package names to their corresponding package object + :param poetry: Poetry object for the current project """ - dependencies: List[PoetryPackage] = [] - for dep_name in ( - poetry.pyproject.data["tool"]["poetry"].get("dev-dependencies", {}).keys() - ): - dependencies += identify_transients( - packages, dep_name, allow_missing=[poetry.package.name] - ) - - return dependencies - - -def find_env_dependencies( - venv: ToxVirtualEnv, poetry: "_poetry.Poetry", packages: PackageMap -) -> List[PoetryPackage]: - """Find the environment dependencies - - Recursively identify the dependencies to install for the current environment - - :param venv: Tox virtual environment to install the packages to - :param poetry: Poetry object the packages were sourced from - :param packages: Mapping of package names to the corresponding package object - """ - dependencies: List[PoetryPackage] = [] - for dep in venv.envconfig.locked_deps: - dependencies += identify_transients( - packages, dep.lower(), allow_missing=[poetry.package.name] - ) - - return dependencies + return find_additional_deps( + packages, + poetry, + poetry.pyproject.data["tool"]["poetry"].get("dev-dependencies", {}).keys(), + )