Merge pull request #62 from enpaul/enp/61

Add three state boolean logic for install_project_deps config

.github/scripts/setup-env.sh

@@ -0,0 +1,72 @@
+#!/usr/bin/env bash
+#
+# Environment setup script for the local project. Intended to be used with automation
+# to create a repeatable local environment for tests to be run in. The python env
+# this script creates can be accessed at the location defined by the CI_VENV variable
+# below.
+
+set -e;
+
+# ##### Prereqs #####
+#
+# Set global vars for usage in the script, create the cache directory so we can rely
+# on that existing, then dump some diagnostic info for later reference.
+#
+CI_VENV=$HOME/ci;
+CI_CACHE=$HOME/.cache;
+CI_CACHE_GET_POETRY="$CI_CACHE/get-poetry.py";
+CI_POETRY=$HOME/.poetry/bin/poetry;
+CI_VENV_PIP="$CI_VENV/bin/pip";
+CI_VENV_PIP_VERSION=19.3.1;
+CI_VENV_TOX="$CI_VENV/bin/tox";
+
+mkdir --parents "$CI_CACHE";
+
+command -v python;
+python --version;
+
+# ##### Install Poetry #####
+#
+# Download the poetry install script to the cache directory and then install poetry.
+# After dump the poetry version for later reference.
+#
+curl https://raw.githubusercontent.com/python-poetry/poetry/master/get-poetry.py \
+  --output "$CI_CACHE_GET_POETRY" \
+  --silent \
+  --show-error \
+  --location;
+python "$CI_CACHE_GET_POETRY" --yes 1>/dev/null;
+
+python "$CI_POETRY" --version --no-ansi;
+
+# ##### Setup Runtime Venv #####
+#
+# Create a virtual environment for poetry to use, upgrade pip in that venv to a pinned
+# version, then install the current project to the venv.
+#
+# Note 1: Poetry, Tox, and this project plugin all use pip under the hood for package
+#         installation. This means that even though we are creating up to eight venvs
+#         during a given CI run they all share the same download cache.
+# Note 2: The "VIRTUAL_ENV=$CI_VENV" prefix on the poetry commands below sets the venv
+#         that poetry will use for operations. There is no CLI flag for poetry that
+#         directs it to use a given environment, but if it finds itself in an existing
+#         environment it will use it and skip environment creation.
+#
+python -m venv "$CI_VENV";
+
+$CI_VENV_PIP install "pip==$CI_VENV_PIP_VERSION" \
+  --upgrade \
+  --quiet;
+
+VIRTUAL_ENV=$CI_VENV "$CI_POETRY" install \
+  --extras poetry \
+  --quiet \
+  --no-ansi \
+  &>/dev/null;
+
+# ##### Print Debug Info #####
+#
+# Print the pip and tox versions (which will include registered plugins)
+#
+$CI_VENV_PIP --version;
+echo "tox $($CI_VENV_TOX --version)";

.github/workflows/ci.yaml

@@ -0,0 +1,70 @@
+---
+name: CI
+on:
+  pull_request:
+    types: ["opened", "synchronize"]
+  push:
+    branches: ["devel"]
+jobs:
+  Test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python:
+          - version: 3.6
+            toxenv: py36
+          - version: 3.7
+            toxenv: py37
+          - version: 3.8
+            toxenv: py38
+          - version: 3.9
+            toxenv: py39
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Setup:python${{ matrix.python.version }}
+        uses: actions/setup-python@v1
+        with:
+          python-version: ${{ matrix.python.version }}
+      - name: Setup:cache
+        uses: actions/cache@v2
+        with:
+          path: |
+            ~/.cache/pip
+            ~/.cache/pypoetry/cache
+            ~/.poetry
+          # Including the hashed poetry.lock in the cache slug ensures that the cache
+          # will be invalidated, and thus all packages will be redownloaded, if the
+          # lockfile is updated
+          key: ${{ runner.os }}-${{ matrix.python.toxenv }}-${{ hashFiles('**/poetry.lock') }}
+      - name: Setup:env
+        run: .github/scripts/setup-env.sh
+      - name: Run:${{ matrix.python.toxenv }}
+        run: $HOME/ci/bin/tox -e ${{ matrix.python.toxenv }}
+  Check:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Setup:python3.8
+        uses: actions/setup-python@v1
+        with:
+          python-version: 3.8
+      - name: Setup:cache
+        uses: actions/cache@v2
+        with:
+          path: |
+            ~/.cache/pip
+            ~/.cache/pypoetry/cache
+            ~/.poetry
+          # Hardcoded 'py38' slug here lets this cache piggyback on the 'py38' cache
+          # that is generated for the tests above
+          key: ${{ runner.os }}-py38-${{ hashFiles('**/poetry.lock') }}
+      - name: Setup:env
+        run: .github/scripts/setup-env.sh
+      - name: Run:static
+        run: $HOME/ci/bin/tox -e static
+      - name: Run:static-tests
+        run: $HOME/ci/bin/tox -e static-tests
+      - name: Run:security
+        run: $HOME/ci/bin/tox -e security

.pre-commit-config.yaml

@@ -1,28 +1,79 @@
 ---
+# All of the pre-commit hooks here actually use the `pytyhon` pre-commit language
+# setting. However, for the python language setting, pre-commit will create and manage
+# a cached virtual environment for each hook ID and do a bare `pip install <repo>` into
+# the venv to setup the hook. This can result in conflicting dependency versions between
+# the version installed to the pre-commit venv and the version installed to the Poetry
+# venv specified in the lockfile.
+#
+# The solution is to specify `language: system` for all hooks and then install the
+# required dependencies to the Poetry venv. The `system` language skips the isolated
+# venv creation and looks for the entrypoint specified by the hook in the global
+# environment which, if running in the Poetry venv, will find the entrypoint provided
+# by the Poetry-managed dependency.
+#
 repos:
-  - repo: https://github.com/psf/black
-    rev: 20.8b1
-    hooks:
-      - id: black
-        language_version: python3.7
-
-  - repo: https://github.com/asottile/blacken-docs
-    rev: v0.5.0
-    hooks:
-      - id: blacken-docs
-        additional_dependencies: [black==20.8b1]
-        language_version: python3.7
-
-  - repo: https://github.com/asottile/reorder_python_imports
-    rev: v2.3.5
-    hooks:
-      - id: reorder-python-imports
-        language_version: python3
-
-  - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v2.0.0
+  - repo: local
     hooks:
       - id: end-of-file-fixer
+        name: end-of-file-fixer
+        entry: end-of-file-fixer
+        language: system
+        types:
+          - text
+
       - id: fix-encoding-pragma
-        args: [--remove]
-      - id: trailing-whitespace
+        name: fix-encoding-pragma
+        entry: fix-encoding-pragma
+        language: system
+        args:
+          - "--remove"
+        types:
+          - python
+
+      - id: trailing-whitespace-fixer
+        name: trailing-whitespace-fixer
+        entry: trailing-whitespace-fixer
+        language: system
+        types:
+          - text
+
+      - id: check-merge-conflict
+        name: check-merge-conflict
+        entry: check-merge-conflict
+        language: system
+        types:
+          - text
+
+      - id: reorder-python-imports
+        name: reorder-python-imports
+        entry: reorder-python-imports
+        language: system
+        args:
+          - "--unclassifiable-application-module=tox_poetry_installer"
+        types:
+          - python
+
+      - id: black
+        name: black
+        entry: black
+        language: system
+        types:
+          - python
+
+      - id: blacken-docs
+        name: blacken-docs
+        entry: blacken-docs
+        language: system
+        types:
+          - text
+
+      - id: mdformat
+        name: mdformat
+        entry: mdformat
+        language: system
+        args:
+          - "--number"
+          - "--wrap=90"
+        types:
+          - markdown

CHANGELOG.md

@@ -0,0 +1,272 @@
+# changelog
+
+See also: [Github Release Page](https://github.com/enpaul/tox-poetry-installer/releases).
+
+## Version 0.8.0
+
+View this release on:
+[Github](https://github.com/enpaul/tox-poetry-installer/releases/tag/0.8.0),
+[PyPI](https://pypi.org/project/tox-poetry-installer/0.8.0/)
+
+- Add default installation of locked dependencies using thread workers, decreasing
+  environment provisioning times by ~90%
+- Add runtime option `--parallel-install-threads` to support configuring the number of
+  worker threads for parallel dependency installation
+- Add configuration option `install_project_deps` to support disabling the install of
+  project dependencies to an environment
+- Deprecate runtime option `--parallelize-locked-install`
+
+## Version 0.7.0
+
+View this release on:
+[Github](https://github.com/enpaul/tox-poetry-installer/releases/tag/0.7.0),
+[PyPI](https://pypi.org/project/tox-poetry-installer/0.7.0/)
+
+- Add runtime option `--parallelize-locked-install` to support installing locked
+  dependencies in parallel to speed up test environment creation
+- Add config option `require_poetry` to allow per-environment control over whether the
+  plugin should force an error
+- Add unit tests for custom dependency processing and installation
+- Update internal logging system to reduce code duplication
+- Update documentation to improve readability
+- Deprecate runtime option `--require-poetry`
+
+## Version 0.6.4
+
+View this release on:
+[Github](https://github.com/enpaul/tox-poetry-installer/releases/tag/0.6.4),
+[PyPI](https://pypi.org/project/tox-poetry-installer/0.6.4/)
+
+- Remove custom package compatibility checking logic from transient dependency resolution
+  process
+- Add integration with Poetry's compatibility
+  [`Marker`](https://github.com/python-poetry/poetry-core/blob/master/poetry/core/version/markers.py)
+  object system for determining package compatibility with the current platform ([#43](https://github.com/enpaul/tox-poetry-installer/issues/43))
+- Add missing PyPI classifier for Python 3
+
+## Version 0.6.3
+
+View this release on:
+[Github](https://github.com/enpaul/tox-poetry-installer/releases/tag/0.6.3),
+[PyPI](https://pypi.org/project/tox-poetry-installer/0.6.3/)
+
+- Update required `tox` version from `^3.0` to `^3.8` to avoid compatibility issues
+- Update logging messages to improve UX
+- Fix transient dependency packages being installed in a pseudo-random order due to Python
+  sets being unordered ([#41](https://github.com/enpaul/tox-poetry-installer/issues/41))
+- Fix outdated docstrings
+
+## Version 0.6.2
+
+View this release on:
+[Github](https://github.com/enpaul/tox-poetry-installer/releases/tag/0.6.2),
+[PyPI](https://pypi.org/project/tox-poetry-installer/0.6.2/)
+
+- Update locked version of `py` to `1.10.0` to address
+  [CVE-2020-29651](https://nvd.nist.gov/vuln/detail/CVE-2020-29651)
+- Fix dependency identification failing when the package under test is a transient
+  dependency of a locked dependency specified for installation
+- Fix `AttributeError` being raised while creating the Tox self-provisioned environment when
+  using either the
+  [`minversion`](https://tox.readthedocs.io/en/latest/config.html#conf-minversion) or
+  [`requires`](https://tox.readthedocs.io/en/latest/config.html#conf-requires) Tox config
+  options
+
+## Version 0.6.1
+
+View this release on:
+[Github](https://github.com/enpaul/tox-poetry-installer/releases/tag/0.6.1),
+[PyPI](https://pypi.org/project/tox-poetry-installer/0.6.1/)
+
+- Update logging around transient dependency processing to improve debugging of dependency
+  installation problems
+- Fix regression around handling of Poetry's unsafe packages when the unsafe package is a
+  transient dependency ([#33](https://github.com/enpaul/tox-poetry-installer/issues/33))
+- Fix handling of Poetry's unsafe packages when the unsafe package is a primary (environment
+  or package) dependency
+
+## Version 0.6.0
+
+View this release on:
+[Github](https://github.com/enpaul/tox-poetry-installer/releases/tag/0.6.0),
+[PyPI](https://pypi.org/project/tox-poetry-installer/0.6.0/)
+
+- Add `poetry` extra to support installing Poetry as a direct dependency of the plugin
+- Add `--require-poetry` runtime option to force Tox failure if Poetry is not installed
+- Update logging messages to improve UX around non-verbose messaging
+- Update error logging to avoid dumping stack traces
+- Update integration with Tox's `action` object to better manage internal state at runtime
+- Update documentation to more clearly cover more use cases
+- Remove `poetry` as a required dependency to support external Poetry installations
+
+First beta release :tada:
+
+## Version 0.5.2
+
+View this release on:
+[Github](https://github.com/enpaul/tox-poetry-installer/releases/tag/0.5.2),
+[PyPI](https://pypi.org/project/tox-poetry-installer/0.5.2/)
+
+- Fix always attempting to install dependencies with incompatible python version constraints
+- Fix always attempting to install dependencies with incompatible python platforms
+
+## Version 0.5.1
+
+View this release on:
+[Github](https://github.com/enpaul/tox-poetry-installer/releases/tag/0.5.1),
+[PyPI](https://pypi.org/project/tox-poetry-installer/0.5.1/)
+
+- Add CI/Tox tests for Python-3.9
+- Update dependency processing to reduce duplication during installation
+- Update minimum python requirement to `3.6.1`
+- Fix `UnboundLocal` exception when not installing project dependencies
+
+## Version 0.5.0
+
+View this release on:
+[Github](https://github.com/enpaul/tox-poetry-installer/releases/tag/0.5.0),
+[PyPI](https://pypi.org/project/tox-poetry-installer/0.5.0/)
+
+- Add option `locked_deps` to better support both locked and unlocked dependencies in a
+  single environment
+- Add blocking functionality when using `require_locked_deps = true` to prevent other hooks
+  from running after this one
+- Update documentation to include new configuration options and errors
+- Update documentation to improve future maintainability
+- Update module structure to move from single-file module to multi-file directory module
+- Fix `RecursionError` when installing locked dependencies that specify recursive
+  dependencies
+- Fix always reinstalling all locked dependencies on every run regardless of update status
+
+## Version 0.4.0
+
+View this release on:
+[Github](https://github.com/enpaul/tox-poetry-installer/releases/tag/0.4.0),
+[PyPI](https://pypi.org/project/tox-poetry-installer/0.4.0/)
+
+- Add `install_dev_deps` configuration option for automatically installing all Poetry
+  dev-dependencies into a Tox testenv
+
+## Version 0.3.1
+
+View this release on:
+[Github](https://github.com/enpaul/tox-poetry-installer/releases/tag/0.3.1),
+[PyPI](https://pypi.org/project/tox-poetry-installer/0.3.1/)
+
+- Fix error when installing an environment with no extras specified in the configuration
+- Fix problem where only the dependencies of the sequentially last extra would be installed
+- Fix regression causing no project dependencies to be installed
+
+## Version 0.3.0
+
+View this release on:
+[Github](https://github.com/enpaul/tox-poetry-installer/releases/tag/0.3.0),
+[PyPI](https://pypi.org/project/tox-poetry-installer/0.3.0/)
+
+- Add support for the Tox
+  [`extras`](https://tox.readthedocs.io/en/latest/config.html#conf-extras) configuration
+  parameter
+- Update runtime-skip-conditional checks to improve clarity and ease of future maintenance
+- Update lockfile parsing to avoid parsing it multiple times for a single testenv
+- Fix missing `poetry-core` dependency when using Poetry\<1.1.0
+
+## Version 0.2.4
+
+View this release on:
+[Github](https://github.com/enpaul/tox-poetry-installer/releases/tag/0.2.4),
+[PyPI](https://pypi.org/project/tox-poetry-installer/0.2.4/)
+
+- Fix support for Poetry-1.1 ([#2](https://github.com/enpaul/tox-poetry-installer/issues/2))
+- Include tests in sdist ([#8](https://github.com/enpaul/tox-poetry-installer/issues/8))
+
+## Version 0.2.3
+
+View this release on:
+[Github](https://github.com/enpaul/tox-poetry-installer/releases/tag/0.2.3),
+[PyPI](https://pypi.org/project/tox-poetry-installer/0.2.3/)
+
+- Fix usage of the plugin in non-Poetry based projects ([#1](https://github.com/enpaul/tox-poetry-installer/issues/1))
+- Fix treating dependency names as case sensitive when they shouldn't be ([#7](https://github.com/enpaul/tox-poetry-installer/issues/7))
+
+## Version 0.2.2
+
+View this release on:
+[Github](https://github.com/enpaul/tox-poetry-installer/releases/tag/0.2.2),
+[PyPI](https://pypi.org/project/tox-poetry-installer/0.2.2/)
+
+- Fix breaking when running Tox in projects that do not use Poetry for their
+  environment/dependency management ([#1](https://github.com/enpaul/tox-poetry-installer/issues/1))
+
+## Version 0.2.1
+
+View this release on:
+[Github](https://github.com/enpaul/tox-poetry-installer/releases/tag/0.2.1),
+[PyPI](https://pypi.org/project/tox-poetry-installer/0.2.1/)
+
+- Fix duplicate installation of transient environment dependencies
+- Fix logging error indicating all environments always have zero dependencies
+- Fix installing main dependencies when `skip_install` is false but `skipdist` is true
+
+## Version 0.2.0
+
+View this release on:
+[Github](https://github.com/enpaul/tox-poetry-installer/releases/tag/0.2.0),
+[PyPI](https://pypi.org/project/tox-poetry-installer/0.2.0/)
+
+- Add support for per-environment configuration setting `require_locked_deps`
+- Add support for per-dependency lock requirement setting using `@poetry` suffix
+- Add support for coexisting locked and unlocked dependencies in a single test environment
+- Update documentation to include more usage examples
+- Update documentation to improve clarity around problems and drawbacks
+- Fix logging messages being inconsistently formatted
+- Fix raising the same exception for "locked dependency not found" and "locked dependency
+  specifies alternate version" errors
+- Fix plugin errors not reporting to Tox that they happened
+- Fix plugin errors not causing Tox to mark the env as failed
+
+## Version 0.1.3
+
+View this release on:
+[Github](https://github.com/enpaul/tox-poetry-installer/releases/tag/0.1.3),
+[PyPI](https://pypi.org/project/tox-poetry-installer/0.1.3/)
+
+- Fix core functionality of installing dependencies from lockfile for the
+  package-under-development ("dev-package") built by Tox
+- Fix log messages not being displayed with Tox output
+- Add additional logging output for diagnostics
+- Update Poetry requirement to exclude upcoming Poetry-1.1.0 release which will break
+  compatibility
+
+This is the first release where the core functionality actually works as expected :tada:
+
+## Version 0.1.2
+
+View this release on:
+[Github](https://github.com/enpaul/tox-poetry-installer/releases/tag/0.1.2),
+[PyPI](https://pypi.org/project/tox-poetry-installer/0.1.2/)
+
+- Test trivial functionality on Python-3.6 and Python-3.7
+- Fix disagreement between `pyproject.toml` and module metadata on what the current version
+  is
+- Fix constant named for PEP-440 that should have been named for PEP-508
+
+## Version 0.1.1
+
+View this release on:
+[Github](https://github.com/enpaul/tox-poetry-installer/releases/tag/0.1.1),
+[PyPI](https://pypi.org/project/tox-poetry-installer/0.1.1/)
+
+- Add/update project documentation
+- Add static analysis and formatting enforcement automation to toxfile
+- Add security analysis to toxfile
+- Fix raising `KeyError` for unlocked dependencies
+- Fix mishandling of Poetry's "unsafe dependencies"
+- Lint, blacken, and generally improve code quality
+
+## Version 0.1.0
+
+View this release on:
+[Github](https://github.com/enpaul/tox-poetry-installer/releases/tag/0.1.0),
+
+- Add support for installing Tox environment dependencies using Poetry from the Poetry
+  lockfile

CODE_OF_CONDUCT.md

@@ -1,129 +1,115 @@
-
 # Contributor Covenant Code of Conduct
 
 ## Our Pledge
 
-We as members, contributors, and leaders pledge to make participation in our
-community a harassment-free experience for everyone, regardless of age, body
-size, visible or invisible disability, ethnicity, sex characteristics, gender
-identity and expression, level of experience, education, socio-economic status,
-nationality, personal appearance, race, religion, or sexual identity
-and orientation.
+We as members, contributors, and leaders pledge to make participation in our community a
+harassment-free experience for everyone, regardless of age, body size, visible or
+invisible disability, ethnicity, sex characteristics, gender identity and expression,
+level of experience, education, socio-economic status, nationality, personal appearance,
+race, religion, or sexual identity and orientation.
 
-We pledge to act and interact in ways that contribute to an open, welcoming,
-diverse, inclusive, and healthy community.
+We pledge to act and interact in ways that contribute to an open, welcoming, diverse,
+inclusive, and healthy community.
 
 ## Our Standards
 
-Examples of behavior that contributes to a positive environment for our
-community include:
+Examples of behavior that contributes to a positive environment for our community include:
 
-* Demonstrating empathy and kindness toward other people
-* Being respectful of differing opinions, viewpoints, and experiences
-* Giving and gracefully accepting constructive feedback
-* Accepting responsibility and apologizing to those affected by our mistakes,
-  and learning from the experience
-* Focusing on what is best not just for us as individuals, but for the
-  overall community
+- Demonstrating empathy and kindness toward other people
+- Being respectful of differing opinions, viewpoints, and experiences
+- Giving and gracefully accepting constructive feedback
+- Accepting responsibility and apologizing to those affected by our mistakes, and learning
+  from the experience
+- Focusing on what is best not just for us as individuals, but for the overall community
 
 Examples of unacceptable behavior include:
 
-* The use of sexualized language or imagery, and sexual attention or
-  advances of any kind
-* Trolling, insulting or derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or email
-  address, without their explicit permission
-* Other conduct which could reasonably be considered inappropriate in a
-  professional setting
+- The use of sexualized language or imagery, and sexual attention or advances of any kind
+- Trolling, insulting or derogatory comments, and personal or political attacks
+- Public or private harassment
+- Publishing others' private information, such as a physical or email address, without their
+  explicit permission
+- Other conduct which could reasonably be considered inappropriate in a professional setting
 
 ## Enforcement Responsibilities
 
-Community leaders are responsible for clarifying and enforcing our standards of
-acceptable behavior and will take appropriate and fair corrective action in
-response to any behavior that they deem inappropriate, threatening, offensive,
-or harmful.
+Community leaders are responsible for clarifying and enforcing our standards of acceptable
+behavior and will take appropriate and fair corrective action in response to any behavior
+that they deem inappropriate, threatening, offensive, or harmful.
 
-Community leaders have the right and responsibility to remove, edit, or reject
-comments, commits, code, wiki edits, issues, and other contributions that are
-not aligned to this Code of Conduct, and will communicate reasons for moderation
-decisions when appropriate.
+Community leaders have the right and responsibility to remove, edit, or reject comments,
+commits, code, wiki edits, issues, and other contributions that are not aligned to this
+Code of Conduct, and will communicate reasons for moderation decisions when appropriate.
 
 ## Scope
 
-This Code of Conduct applies within all community spaces, and also applies when
-an individual is officially representing the community in public spaces.
-Examples of representing our community include using an official e-mail address,
-posting via an official social media account, or acting as an appointed
-representative at an online or offline event.
+This Code of Conduct applies within all community spaces, and also applies when an
+individual is officially representing the community in public spaces. Examples of
+representing our community include using an official e-mail address, posting via an
+official social media account, or acting as an appointed representative at an online or
+offline event.
 
 ## Enforcement
 
-Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported to the community leaders responsible for enforcement at
-[INSERT CONTACT METHOD].
-All complaints will be reviewed and investigated promptly and fairly.
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported to the
+community leaders responsible for enforcement at \[INSERT CONTACT METHOD\]. All
+complaints will be reviewed and investigated promptly and fairly.
 
-All community leaders are obligated to respect the privacy and security of the
-reporter of any incident.
+All community leaders are obligated to respect the privacy and security of the reporter of
+any incident.
 
 ## Enforcement Guidelines
 
-Community leaders will follow these Community Impact Guidelines in determining
-the consequences for any action they deem in violation of this Code of Conduct:
+Community leaders will follow these Community Impact Guidelines in determining the
+consequences for any action they deem in violation of this Code of Conduct:
 
 ### 1. Correction
 
 **Community Impact**: Use of inappropriate language or other behavior deemed
 unprofessional or unwelcome in the community.
 
-**Consequence**: A private, written warning from community leaders, providing
-clarity around the nature of the violation and an explanation of why the
-behavior was inappropriate. A public apology may be requested.
+**Consequence**: A private, written warning from community leaders, providing clarity
+around the nature of the violation and an explanation of why the behavior was
+inappropriate. A public apology may be requested.
 
 ### 2. Warning
 
-**Community Impact**: A violation through a single incident or series
-of actions.
+**Community Impact**: A violation through a single incident or series of actions.
 
-**Consequence**: A warning with consequences for continued behavior. No
-interaction with the people involved, including unsolicited interaction with
-those enforcing the Code of Conduct, for a specified period of time. This
-includes avoiding interactions in community spaces as well as external channels
-like social media. Violating these terms may lead to a temporary or
-permanent ban.
+**Consequence**: A warning with consequences for continued behavior. No interaction with
+the people involved, including unsolicited interaction with those enforcing the Code of
+Conduct, for a specified period of time. This includes avoiding interactions in community
+spaces as well as external channels like social media. Violating these terms may lead to a
+temporary or permanent ban.
 
 ### 3. Temporary Ban
 
-**Community Impact**: A serious violation of community standards, including
-sustained inappropriate behavior.
+**Community Impact**: A serious violation of community standards, including sustained
+inappropriate behavior.
 
-**Consequence**: A temporary ban from any sort of interaction or public
-communication with the community for a specified period of time. No public or
-private interaction with the people involved, including unsolicited interaction
-with those enforcing the Code of Conduct, is allowed during this period.
-Violating these terms may lead to a permanent ban.
+**Consequence**: A temporary ban from any sort of interaction or public communication with
+the community for a specified period of time. No public or private interaction with the
+people involved, including unsolicited interaction with those enforcing the Code of
+Conduct, is allowed during this period. Violating these terms may lead to a permanent ban.
 
 ### 4. Permanent Ban
 
-**Community Impact**: Demonstrating a pattern of violation of community
-standards, including sustained inappropriate behavior,  harassment of an
-individual, or aggression toward or disparagement of classes of individuals.
+**Community Impact**: Demonstrating a pattern of violation of community standards,
+including sustained inappropriate behavior, harassment of an individual, or aggression
+toward or disparagement of classes of individuals.
 
-**Consequence**: A permanent ban from any sort of public interaction within
-the community.
+**Consequence**: A permanent ban from any sort of public interaction within the community.
 
 ## Attribution
 
-This Code of Conduct is adapted from the [Contributor Covenant][homepage],
-version 2.0, available at
-https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 2.0,
+available at https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
 
 Community Impact Guidelines were inspired by [Mozilla's code of conduct
 enforcement ladder](https://github.com/mozilla/diversity).
 
-[homepage]: https://www.contributor-covenant.org
-
 For answers to common questions about this code of conduct, see the FAQ at
 https://www.contributor-covenant.org/faq. Translations are available at
 https://www.contributor-covenant.org/translations.
+
+[homepage]: https://www.contributor-covenant.org

LICENSE.md

@@ -1,11 +1,12 @@
 ## Copyright 2020 Ethan Paul
 
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the Software without restriction, including without limitation
-the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
-and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+Permission is hereby granted, free of charge, to any person obtaining a copy of this
+software and associated documentation files (the "Software"), to deal in the Software
+without restriction, including without limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
+to whom the Software is furnished to do so, subject to the following conditions:
 
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of
-the Software.
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
 
 **THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.**

Makefile

@@ -19,7 +19,7 @@ clean-py:
 	rm --recursive --force ./dist
 	rm --recursive --force ./build
 	rm --recursive --force ./*.egg-info
-	rm --recursive --force __pycache__/
+	rm --recursive --force ./**/__pycache__/
 
 clean: clean-tox clean-py; ## Clean temp build/cache files and directories
 
@@ -32,5 +32,9 @@ source: ## Build Python source distribution package
 test: ## Run the project testsuite(s)
 	poetry run tox --recreate
 
-publish: wheel source ## Build and upload to pypi (requires $PYPI_API_KEY be set)
-	poetry publish --username __token__ --password $(PYPI_API_KEY)
+dev: ## Create the local dev environment
+	poetry install -E poetry
+	poetry run pre-commit install
+
+publish: test wheel source ## Build and upload to pypi (requires $PYPI_API_KEY be set)
+	@poetry publish --username __token__ --password $(PYPI_API_KEY)

README.md

@@ -1,214 +1,362 @@
 # tox-poetry-installer
 
-A plugin for [Tox](https://tox.readthedocs.io/en/latest/) that allows test environment
-dependencies to be installed using [Poetry](https://python-poetry.org/) using its lockfile.
+A plugin for [Tox](https://tox.readthedocs.io/en/latest/) that lets you install test
+environment dependencies from the [Poetry](https://python-poetry.org/) lockfile.
 
-⚠️ **This project is alpha software and should not be used in a production capacity** ⚠️
+[![CI Status](https://github.com/enpaul/tox-poetry-installer/workflows/CI/badge.svg?event=push)](https://github.com/enpaul/tox-poetry-installer/actions)
+[![PyPI Version](https://img.shields.io/pypi/v/tox-poetry-installer)](https://pypi.org/project/tox-poetry-installer/)
+[![PyPI Downloads](https://img.shields.io/pypi/dm/tox-poetry-installer)](https://libraries.io/pypi/tox-poetry-installer)
+[![License](https://img.shields.io/pypi/l/tox-poetry-installer)](https://opensource.org/licenses/MIT)
+[![Python Supported Versions](https://img.shields.io/pypi/pyversions/tox-poetry-installer)](https://www.python.org)
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
 
-![image](https://img.shields.io/pypi/l/tox-poetry-installer)
-![image](https://img.shields.io/pypi/v/tox-poetry-installer)
-![image](https://img.shields.io/pypi/pyversions/tox-poetry-installer)
+⚠️ **This project is beta software and is under active development** ⚠️
 
-**Documentation**
+## Documentation
 
-* [Installation and Usage](#installation-and-usage)
-* [Limitations](#limitations)
-* [Why would I use this?](#what-problems-does-this-solve) (What problems does this solve?)
-* [Developing](#developing)
-* [Contributing](#contributing)
-* [Roadmap](#roadmap)
-  * [Path to Beta](#path-to-beta)
-  * [Path to Stable](#path-to-stable)
+- [Feature Overview](#feature-overview)
+- [Using the Plugin](#user-documentation)
+  - [Installing](#installing)
+  - [Quick Start](#quick-start)
+  - [References](#references)
+    - [Config Options](#configuration-options)
+    - [Runtime Options](#runtime-options)
+    - [Errors](#errors)
+  - [Other Notes](#other-notes)
+    - [Unsupported Tox config options](#unsupported-tox-config-options)
+    - [Updating locked dependencies in a testenv](#updating-locked-dependencies-in-a-testenv)
+    - [Installing unsafe dependencies](#installing-unsafe-dependencies)
+    - [Using with an unmanaged Poetry installation](#using-with-an-unmanaged-poetry-installation)
+- [Developing the Plugin](#developer-documentation)
+- [Road Map](#road-map)
 
-Related resources:
-* [Poetry Python Project Manager](https://python-poetry.org/)
-* [Tox Automation Project](https://tox.readthedocs.io/en/latest/)
-* [Tox plugins](https://tox.readthedocs.io/en/latest/plugins.html)
+See the
+[Changelog](https://github.com/enpaul/tox-poetry-installer/blob/devel/CHANGELOG.md) for
+release history.
 
+*See also: [official Tox plugins](https://tox.readthedocs.io/en/latest/plugins.html), [Poetry-Dev-Dependencies Tox plugin](https://github.com/sinoroc/tox-poetry-dev-dependencies), [Poetry Tox plugin](https://github.com/tkukushkin/tox-poetry)*
 
-## Installation and Usage
+## Feature Overview
 
-1. Install the plugin from PyPI:
+- Manage package versions in exactly one place and with exactly one tool: Poetry.
+- Ensure CI/CD and other automation tools are using the same package versions that you are
+  in your local development environment.
+- Add only the packages you need to a Tox test environment, instead of everything in your
+  lockfile.
+- Directly integrate with Poetry, re-using your existing package indexes and credentials
+  with no additional configuration.
+- Wherever possible, built-in Tox config options are always respected and their behavior
+  kept consistent.
+- Extremely configurable. Every feature can be disabled or enabled for any given Tox test
+  environment.
+- Friendly to other Tox plugins and supports a wide range of environments.
+
+## User Documentation
+
+*This section is for users looking to integrate the plugin with their project or CI system. For information on contributing to the plugin please see the [Developer Docs](#developer-documentation)*
+
+### Installing
+
+The recommended way to install the plugin is to add it to a project using Poetry:
+
+```bash
+poetry add tox-poetry-installer[poetry] --dev
+```
+
+> **Note:** Always install the plugin with the `[poetry]` extra, unless you are
+> [managing the Poetry installation yourself](#externally-managed-poetry-installation).
+
+Alternatively, it can be installed directly to a virtual environment using Pip, though
+this is not recommended:
+
+```bash
+source somevenv/bin/activate
+pip install tox-poetry-installer
+```
+
+Alternatively alternatively, it can be installed using the Tox
+[`requires`](https://tox.readthedocs.io/en/latest/config.html#conf-requires) option by
+adding the below to `tox.ini`, though this is also not recommended:
+
+```ini
+requires =
+    tox-poetry-installer[poetry] == 0.8.0
+```
+
+After installing, check that Tox recognizes the plugin by running
+`poetry run tox --version`. The command should give output similar to below:
 
 ```
+3.20.0 imported from .venv/lib64/python3.8/site-packages/tox/__init__.py
+registered plugins:
+    tox-poetry-installer-0.8.0 at .venv/lib64/python3.8/site-packages/tox_poetry_installer/__init__.py
+```
+
+### Quick Start
+
+Congratulations! 🎉 Just by installing the plugin your Tox config is already using locked
+dependencies: when Tox builds and installs your project package to a test environment,
+your project package's dependencies will be installed from the lockfile.
+
+Now lets update an example `tox.ini` to install the other test environment dependencies
+from the lockfile.
+
+A `testenv` from the example `tox.ini` we're starting with is below:
+
+```ini
+[testenv]
+description = Some very cool tests
+deps =
+    black == 20.8b1
+    pylint >=2.4.4,<2.7.0
+    mypy <0.800
+commands = ...
+```
+
+To update the config so that the testenv dependencies are installed from the lockfile, we
+can replace the built-in
+[`deps`](https://tox.readthedocs.io/en/latest/config.html#conf-deps) option with the
+`locked_deps` option provided by the plugin, and then remove the inline version
+specifiers. With these changes the three testenv dependencies (as well as all of their
+dependencies) will be installed from the lockfile when the test environment is recreated:
+
+```ini
+[testenv]
+description = Some very cool tests
+locked_deps =
+    black
+    pylint
+    mypy
+commands = ...
+```
+
+We can also add the `require_locked_deps` option to the test environment. This will both
+block any other install tools (another plugin or Tox itself) from installing dependencies
+to the Tox environment and also cause Tox to fail if the test environment also uses the
+built-in [`deps`](https://tox.readthedocs.io/en/latest/config.html#conf-deps) option:
+
+```ini
+[testenv]
+description = Some very cool tests
+require_locked_deps = true
+locked_deps =
+    black
+    pylint
+    mypy
+commands = ...
+```
+
+> **Note:** Settings configured on the main `testenv` environment are inherited by child
+> test environments (for example, `testenv:foo`). To override this, specify the setting in
+> the child environment with a different value.
+
+Alternatively, we can skip specifying all of our dependencies for a test environment in
+the Tox config and just install all of our Poetry dev-dependencies automatically:
+
+```ini
+[testenv]
+description = Some very cool tests
+require_locked_deps = true
+install_dev_deps = true
+commands = ...
+```
+
+> **Note:** Setting `install_dev_deps = true` on an environment that also installs the
+> project package is functionally equivalent to running `poetry install`.
+
+Finally, we can also install an unlocked dependency (a dependency which doesn't take its
+version from the Poetry lockfile) into the test environment alongside the locked ones. We
+need to remove the `require_locked_deps = true` option, otherwise the environment will
+error, and then we can add the unlocked dependency using the built-in
+[`deps`](https://tox.readthedocs.io/en/latest/config.html#conf-deps) option:
+
+```ini
+[testenv]
+description = Some very cool tests
+deps =
+    pytest >= 5.6.0,<6.0.0
+locked_deps =
+    black
+    pylint
+    mypy
+commands = ...
+```
+
+## References
+
+### Configuration Options
+
+All options listed below are Tox environment options and can be applied to one or more
+environment sections of the `tox.ini` file. They cannot be applied to the global Tox
+configuration section.
+
+> **Note:** Settings configured on the main `testenv` environment are inherited by child
+> test environments (for example, `testenv:foo`). To override this, specify the setting in
+> the child environment with a different value.
+
+| Option                 |  Type   | Default | Description                                                                                                                                                                                                                                                                                                                                                          |
+| :--------------------- | :-----: | :-----: | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `locked_deps`          |  List   |  `[]`   | Names of packages to install to the test environment from the Poetry lockfile. Transient dependencies (packages required by these dependencies) are automatically included.                                                                                                                                                                                          |
+| `require_locked_deps`  | Boolean |  False  | Whether the plugin should block attempts to install unlocked dependencies to the test environment. If enabled, then the [`tox_testenv_install_deps`](https://tox.readthedocs.io/en/latest/plugins.html#tox.hookspecs.tox_testenv_install_deps) plugin hook will be intercepted and an error will be raised if the test environment has the `deps` option configured. |
+| `install_dev_deps`     | Boolean |  False  | Whether all of the Poetry dev-dependencies should be installed to the test environment.                                                                                                                                                                                                                                                                              |
+| `install_project_deps` | Boolean |  True   | Whether all of the Poetry primary dependencies for the project package should be installed to the test environment.                                                                                                                                                                                                                                                  |
+| `require_poetry`       | Boolean |  False  | Whether Tox should be forced to fail if the plugin cannot import Poetry locally. If `False` then the plugin will be skipped for the test environment if Poetry cannot be imported. If `True` then the plugin will force the environment to error and the Tox run to fail.                                                                                            |
+
+### Runtime Options
+
+All arguments listed below can be passed to the `tox` command to modify runtime behavior
+of the plugin.
+
+| Argument                     |  Type   | Default | Description                                                                                                                                                                                                                                                                          |
+| :--------------------------- | :-----: | :-----: | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `--parallel-install-threads` | Integer |  `10`   | Number of worker threads to use to install dependencies in parallel. Installing in parallel with more threads can greatly speed up the install process, but can cause race conditions during install. Pass this option with the value `0` to entirely disable parallel installation. |
+
+> **Note:** The `--require-poetry` runtime option is deprecated and will be removed in
+> version 1.0.0. Please set `require_poetry = true` in `tox.ini` for environments that
+> should fail if Poetry is not available.
+
+> **Note:** The `--parallelize-locked-install` option is deprecated and will be removed in
+> version 1.0.0. Please use the `--parallel-install-threads` option.
+
+### Errors
+
+There are several errors that the plugin can encounter for a test environment when Tox is
+run. If an error is encountered then the status of the test environment that caused the
+error will be set to one of the "Status" values below to indicate what the error was.
+
+| Status/Name                     | Cause                                                                                                                                                                                                                           |
+| :------------------------------ | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `ExtraNotFoundError`            | Indicates that the [`extras`](https://tox.readthedocs.io/en/latest/config.html#conf-extras) config option specified an extra that is not configured by Poetry in `pyproject.toml`.                                              |
+| `LockedDepVersionConflictError` | Indicates that an item in the `locked_deps` config option includes a [PEP-508 version specifier](https://www.python.org/dev/peps/pep-0508/#grammar) (ex: `pytest >=6.0, <6.1`).                                                 |
+| `LockedDepNotFoundError`        | Indicates that an item specified in the `locked_deps` config option does not match the name of a package in the Poetry lockfile.                                                                                                |
+| `LockedDepsRequiredError`       | Indicates that a test environment with the `require_locked_deps` config option set to `true` also specified unlocked dependencies using the [`deps`](https://tox.readthedocs.io/en/latest/config.html#conf-deps) config option. |
+| `PoetryNotInstalledError`       | Indicates that the `poetry` module could not be imported under the current runtime environment, and the `--require-poetry` flag was provided.                                                                                   |
+
+> **Note:** One or more of these errors can be caused by the `pyproject.toml` being out of
+> sync with the Poetry lockfile. If this is the case, than a warning will be logged when Tox
+> is run.
+
+### Other Notes
+
+#### Unsupported Tox config options
+
+Below are the built-in Tox config options that are not respected by this plugin. All of
+these options are made obsolete by the Poetry lockfile: either they aren't needed or their
+equivalent functionality is instead taken directly from the package details Poetry stores
+in its lockfile.
+
+> **Note:** The unsupported Tox config options will still apply to unlocked dependencies
+> being installed with the default Tox installation backend.
+
+- [`install_command`](https://tox.readthedocs.io/en/latest/config.html#conf-install_command)
+- [`pip_pre`](https://tox.readthedocs.io/en/latest/config.html#conf-pip_pre)
+- [`download`](https://tox.readthedocs.io/en/latest/config.html#conf-download)
+- [`indexserver`](https://tox.readthedocs.io/en/latest/config.html#conf-indexserver)
+- [`usedevelop`](https://tox.readthedocs.io/en/latest/config.html#conf-indexserver)
+
+#### Updating locked dependencies in a testenv
+
+When Poetry updates the version of a package in the lockfile (using either `poetry lock`
+or `poetry update`) then the plugin will automatically use this new version to install the
+package to a test environment; there is no need to manually update `tox.ini` after
+updating the Poetry lockfile.
+
+However, the plugin cannot determine when the lockfile is updated. If a Tox test
+environment has already been created then it will need to be recreated (using Tox's
+built-in
+[`--recreate`](https://tox.readthedocs.io/en/latest/example/basic.html#forcing-re-creation-of-virtual-environments)
+option) for the new version to be found and installed.
+
+> **Note:** To force Tox to always recreate a test environment the
+> [`recreate`](https://tox.readthedocs.io/en/latest/config.html#conf-recreate) config option
+> can be set.
+
+#### Installing unsafe dependencies
+
+There are several packages that cannot be installed from the lockfile because they are
+excluded by Poetry itself. As a result these packages cannot be installed by this plugin
+either as test environment dependencies passed directly to `locked_deps` or as a transient
+dependency. When one of these packages is encountered by the plugin a warning will be
+logged to the console and
+**the unsafe package will not be installed to the test environment**.
+
+This list can be found in the Poetry source code
+[here](https://github.com/python-poetry/poetry/blob/master/poetry/puzzle/provider.py). As
+of [Poetry 1.1.6](https://github.com/python-poetry/poetry/releases/tag/1.1.6) there are
+four packages classified as "unsafe" by Poetry and excluded from the lockfile:
+
+- `setuptools`
+- `distribute`
+- `pip`
+- `wheel`
+
+#### Using with an unmanaged Poetry installation
+
+In CI/CD systems, automation environments, or other Python environments where the loaded
+site packages are not managed by Poetry, it can be useful to manage the local installation
+of Poetry externally. This also helps to avoid problems that can be caused by the
+`--no-root`, `--no-dev`, or `--remove-untracked` arguments to the `poetry install` command
+which, in some situations, can cause Poetry to uninstall itself if Poetry is specified as
+a dependency of one of the packages it is managing (like this plugin). To support these
+use cases, this plugin specifies the `poetry` package as an optional dependency that can
+be installed using a setuptools extra also named `poetry`.
+
+**Critical Warning: This plugin requires Poetry to function. If the plugin is installed without the `poetry` setuptools extra then Poetry must be installed independently for the plugin to function properly.**
+
+To skip installing the `poetry` package as a dependency of `tox-poetry-installer`, do not
+specify the `poetry` extra when adding the plugin:
+
+```bash
+# Adding the package without the "[poetry]" extra specifier so that
+# Poetry is not added as a transient dev-dependency:
 poetry add tox-poetry-installer --dev
+
+# Adding the package with the "[poetry]" extra specifier, so the Poetry
+# package will be added to the environment and tracked in the lockfile:
+poetry add tox-poetry-installer[poetry] --dev
 ```
 
-2. Remove all version specifications from the environment dependencies in `tox.ini`:
+Once the plugin is installed- either with or without the Poetry extra- you can validate
+that the plugin will run correctly with the following command. This command checks that
+all three required components (Tox, Poetry, and the plugin itself) are available in the
+current Python environment:
 
-```ini
-# This...
-[testenv]
-description = My cool test environment
-deps =
-    requests >=2.19,<3.0
-    toml == 0.10.0
-    pytest >=5.4
-
-# ...becomes this:
-[testenv]
-description = My cool test environment
-deps =
-    requests
-    toml
-    pytest
+```bash
+python -c '\
+  import tox;\
+  import tox_poetry_installer;\
+  from poetry.poetry import Poetry;\
+'
 ```
 
-3. Run Tox with the `--recreate` flag to rebuild the test environments:
+> **Note:** To force Tox to fail if Poetry is not installed, run the `tox` command with the
+> `--require-poetry` option. See the [Runtime Options](#runtime-options) for more
+> information.
 
-```
-poetry run tox --recreate
-```
+## Developer Documentation
 
-4. 💸 Profit 💸
+All project contributors and participants are expected to adhere to the
+[Contributor Covenant Code of Conduct, v2](CODE_OF_CONDUCT.md) ([external link](https://www.contributor-covenant.org/version/2/0/code_of_conduct/)).
 
+The `devel` branch has the latest (and potentially unstable) changes. The stable releases
+are tracked on [Github](https://github.com/enpaul/tox-poetry-installer/releases),
+[PyPi](https://pypi.org/project/tox-poetry-installer/#history), and in the
+[Changelog](CHANGELOG.md).
 
-## Limitations
+- To report a bug, request a feature, or ask for assistance, please
+  [open an issue on the Github repository](https://github.com/enpaul/tox-poetry-installer/issues/new).
+- To report a security concern or code of conduct violation, please contact the project
+  author directly at **‌me \[at‌\] enp dot‎ ‌one**.
+- To submit an update, please
+  [fork the repository](https://docs.github.com/en/enterprise/2.20/user/github/getting-started-with-github/fork-a-repo)
+  and [open a pull request](https://github.com/enpaul/tox-poetry-installer/compare).
 
-* In general, any command line or INI settings that affect how Tox installs environment
-  dependencies will be disabled by installing this plugin. A non-exhaustive and untested
-  list of the INI options that are not expected to work with this plugin is below:
-  * [`install_command`](https://tox.readthedocs.io/en/latest/config.html#conf-install_command)
-  * [`pip_pre`](https://tox.readthedocs.io/en/latest/config.html#conf-pip_pre)
-  * [`downloadcache`](https://tox.readthedocs.io/en/latest/config.html#conf-downloadcache) (deprecated)
-  * [`download`](https://tox.readthedocs.io/en/latest/config.html#conf-download)
-  * [`indexserver`](https://tox.readthedocs.io/en/latest/config.html#conf-indexserver)
-  * [`usedevelop`](https://tox.readthedocs.io/en/latest/config.html#conf-indexserver)
-  * [`extras`](https://tox.readthedocs.io/en/latest/config.html#conf-extras)
+Developing this project requires at least [Python 3.6](https://www.python.org/downloads/)
+and at least [Poetry 1.0](https://python-poetry.org/docs/#installation). GNU Make can
+optionally be used to quickly setup a local development environment, but this is not
+required.
 
-* When the plugin is enabled all dependencies for all environments will use the Poetry backend
-  provided by the plugin; this functionality cannot be disabled on a per-environment basis.
-
-* Alternative versions cannot be specified alongside versions from the lockfile. All
-  dependencies are installed from the lockfile and alternative versions cannot be specified
-  in the Tox configuration.
-
-
-## Why would I use this?
-
-**Introduction**
-
-The lockfile is a file generated by a package manager for a project that lists what
-dependencies are installed, the versions of those dependencies, and additional metadata that
-the package manager can use to recreate the local project environment. This allows developers
-to have confidence that a bug they are encountering that may be caused by one of their
-dependencies will be reproducible on another device. In addition, installing a project
-environment from a lockfile gives confidence that automated systems running tests or performing
-builds are using the same environment that a developer is.
-
-[Poetry](https://python-poetry.org/) is a project dependency manager for Python projects, and
-as such it creates and manages a lockfile so that its users can benefit from all the features
-described above. [Tox](https://tox.readthedocs.io/en/latest/#what-is-tox) is an automation tool
-that allows Python developers to run tests suites, perform builds, and automate tasks within
-self contained [Python virtual environments](https://docs.python.org/3/tutorial/venv.html).
-To make these environments useful, Tox supports installing per-environment dependencies.
-However, since these environments are created on the fly and Tox does not maintain a lockfile,
-there can be subtle differences between the dependencies a developer is using and the
-dependencies Tox uses.
-
-This is where this plugin comes into play.
-
-By default Tox uses [Pip](https://docs.python.org/3/tutorial/venv.html) to install the
-PEP-508 compliant dependencies to a test environment. A more robust way to do this is to
-install dependencies directly from the lockfile so that the version installed to the Tox
-environment always matches the version Poetry specifies. This plugin overwrites the default
-Tox dependency installation behavior and replaces it with a Poetry-based installation using
-the dependency metadata from the lockfile.
-
-**The Problem**
-
-Environment dependencies for a Tox environment are usually done in PEP-508 format like the
-below example
-
-```ini
-# tox.ini
-...
-
-[testenv]
-description = Some very cool tests
-deps =
-    foo == 1.2.3
-    bar >=1.3,<2.0
-    baz
-
-...
-```
-
-Perhaps these dependencies are also useful during development, so they can be added to the
-Poetry environment using this command:
-
- ```
- poetry add foo==1.2.3 bar>=1.3,<2.0 baz --dev
- ```
-
- However there are three potential problems that could arise from each of these environment
- dependencies that would _only_ appear in the Tox environment and not in the Poetry
- environment:
-
- * **The `foo` dependency is pinned to a specific version:** let's imagine a security
-   vulnerability is discovered in `foo` and the maintainers release version `1.2.4` to fix
-   it. A developer can run `poetry remove foo && poetry add foo^1.2` to get the new version,
-   but the Tox environment is left unchanged. The developer environment specified by the
-   lockfile is now patched against the vulnerability, but the Tox environment is not.
-
-* **The `bar` dependency specifies a dynamic range:** a dynamic range allows a range of
-  versions to be installed, but the lockfile will have an exact version specified so that
-  the Poetry environment is reproducible; this allows versions to be updated with
-  `poetry update` rather than with the `remove` and `add` used above. If the maintainers of
-  `bar` release version `1.6.0` then the Tox environment will install it because it is valid
-  for the specified version range, meanwhile the Poetry environment will continue to install
-  the version from the lockfile until `poetry update bar` explicitly updates it. The
-  development environment is now has a different version of `bar` than the Tox environment.
-
-* **The `baz` dependency is unpinned:** unpinned dependencies are
-  [generally a bad idea](https://python-poetry.org/docs/faq/#why-are-unbound-version-constraints-a-bad-idea),
-  but here it can cause real problems. Poetry will interpret an unbound dependency using
-  [the carrot requirement](https://python-poetry.org/docs/dependency-specification/#caret-requirements)
-  but Pip (via Tox) will interpret it as a wildcard. If the latest version of `baz` is `1.0.0`
-  then `poetry add baz` will result in a constraint of `baz>=1.0.0,<2.0.0` while the Tox
-  environment will have a constraint of `baz==*`. The Tox environment can now install an
-  incompatible version of `baz` that cannot be easily caught using `poetry update`.
-
-All of these problems can apply not only to the dependencies specified for a Tox environment,
-but also to the dependencies of those dependencies, and so on.
-
-**The Solution**
-
-This plugin requires that all dependencies specified for all Tox environments be unbound
-with no version constraint specified at all. This seems counter-intuitive given the problems
-outlined above, but what it allows the plugin to do is offload all version management to
-Poetry.
-
-On initial inspection, the environment below appears less stable than the one presented above
-because it does not specify any versions for its dependencies:
-
-```ini
-# tox.ini
-...
-
-[testenv]
-description = Some very cool tests
-deps =
-    foo
-    bar
-    baz
-
-...
-```
-
-However with the `tox-poetry-installer` plugin installed this instructs Tox to install these
-dependencies using the Poetry lockfile so that the version installed to the Tox environment
-exactly matches the version Poetry is managing. When `poetry update` updates the lockfile
-with new dependency versions, Tox will automatically install these new versions without needing
-any changes to the configuration.
-
-All dependencies are specified in one place (the lockfile) and dependency version management is
-handled by a tool dedicated to that task (Poetry).
-
-
-## Developing
-
-This project requires Poetry-1.0+, see the [installation instructions here](https://python-poetry.org/docs/#installation).
+To setup a local development environment:
 
 ```bash
 # Clone the repository...
@@ -217,66 +365,66 @@ git clone https://github.com/enpaul/tox-poetry-installer.git
 # ...over SSH
 git clone git@github.com:enpaul/tox-poetry-installer.git
 
-# Create a the local project virtual environment and install dependencies
-cd tox-poetry-installer
-poetry install
+cd tox-poetry-installer/
 
-# Install pre-commit hooks
+# Create and configure the local development environment...
+# ...with make:
+make dev
+# ...manually:
+poetry install -E poetry --remove-untracked
 poetry run pre-commit install
 
-# Run tests and static analysis
-poetry run tox
+# Run tests and CI locally...
+# ...with make:
+make test
+# ...manually:
+poetry run tox --recreate
+
+# See additional make targets
+make help
 ```
 
+> **Note:** The pre-commit hooks require dependencies in the Poetry environment to run. To
+> make a commit with the pre-commit hooks, you will need to run `poetry run git commit` or,
+> alternatively, [launch an environment shell](https://python-poetry.org/docs/cli/#shell).
 
-## Contributing
+## Road Map
 
-All project contributors and participants are expected to adhere to the
-[Contributor Covenant Code of Conduct, Version 2](CODE_OF_CONDUCT.md).
+This project is under active development and is classified as beta software, ready for
+production environments on a provisional basis only.
 
-* To report a bug, request a feature, or ask for assistance, please
-  [open an issue on the Github repository](https://github.com/enpaul/tox-poetry-installer/issues/new).
-* To report a security concern or code of conduct violation, please contact the project author
-  directly at **ethan dot paul at enp dot one**.
-* To submit an update, please
-  [fork the repository](https://docs.github.com/en/enterprise/2.20/user/github/getting-started-with-github/fork-a-repo)
-  and
-  [open a pull request](https://github.com/enpaul/tox-poetry-installer/compare).
-
-
-## Roadmap
-
-This project is under active development and is classified as alpha software, not yet ready
-usage in production systems.
-
-* Beta classification will be assigned when the initial feature set is finalized
-* Stable classification will be assigned when the test suite covers an acceptable number of
+- Beta classification was assigned with
+  [v0.6.0](https://github.com/enpaul/tox-poetry-installer/releases/tag/0.6.0)
+- Stable classification will be assigned when the test suite covers an acceptable number of
   use cases
 
 ### Path to Beta
 
-- [ ] Verify that primary package dependencies (from the `.package` env) are installed
-      correctly using the Poetry backend.
-- [ ] Support the [`extras`](https://tox.readthedocs.io/en/latest/config.html#conf-extras)
-      Tox configuration option
-- [ ] Add per-environment Tox configuration option to fall back to default installation
-      backend.
-- [ ] Add detection of a changed lockfile to automatically trigger a rebuild of Tox
-      environments when necessary.
-- [ ] Add warnings when an unsupported Tox configuration option is detected while using the
-      Poetry backend.
-- [X] Add trivial tests to ensure the project metadata is consistent between the pyproject.toml
-      and the module constants.
-- [ ] Update to use [poetry-core](https://github.com/python-poetry/poetry-core)
-      Tox configuration option) and improve robustness of the Tox and Poetry module imports
-      to avoid potentially breaking API changes in upstream packages.
+- [x] Verify that primary package dependencies (from the `.package` env) are installed
+  correctly using the Poetry backend.
+- [x] Support the [`extras`](https://tox.readthedocs.io/en/latest/config.html#conf-extras) Tox
+  configuration option ([#4](https://github.com/enpaul/tox-poetry-installer/issues/4))
+- [x] Add per-environment Tox configuration option to fall back to default installation
+  backend.
+- [ ] ~Add warnings when an unsupported Tox configuration option is detected while using the
+  Poetry backend.~ ([#5](https://github.com/enpaul/tox-poetry-installer/issues/5))
+- [x] Add trivial tests to ensure the project metadata is consistent between the pyproject.toml
+  and the module constants.
+- [x] Update to use [poetry-core](https://github.com/python-poetry/poetry-core) and improve
+  robustness of the Tox and Poetry module imports to avoid potentially breaking API changes
+  in upstream packages. ([#2](https://github.com/enpaul/tox-poetry-installer/issues/2))
+- [ ] ~Find and implement a way to mitigate the
+  [UNSAFE_DEPENDENCIES issue](https://github.com/python-poetry/poetry/issues/1584) in
+  Poetry.~ ([#6](https://github.com/enpaul/tox-poetry-installer/issues/6))
+- [x] Fix logging to make proper use of Tox's logging reporter infrastructure ([#3](https://github.com/enpaul/tox-poetry-installer/issues/3))
+- [x] Add configuration option for installing all dev-dependencies to a testenv ([#14](https://github.com/enpaul/tox-poetry-installer/issues/14))
 
 ### Path to Stable
 
 Everything in Beta plus...
 
-- [ ] Add tests for each feature version of Tox between 2.3 and 3.20
-- [ ] Add tests for Python-3.6, 3.7, and 3.8
-- [ ] Add Github Actions based CI
-- [ ] Add CI for CPython, PyPy, and Conda
-- [ ] Add CI for Linux and Windows
+- [ ] Fully replace dependency on `poetry` with dependency on `poetry-core` ([#2](https://github.com/enpaul/tox-poetry-installer/issues/2))
+- [x] Add comprehensive unit tests
+- [ ] Add tests for each feature version of Tox between 3.8 and 3.20
+- [x] Add tests for Python-3.6, 3.7, 3.8, and 3.9
+- [x] Add Github Actions based CI

pyproject.toml

@@ -1,49 +1,65 @@
 [tool.poetry]
 name = "tox-poetry-installer"
-version = "0.1.2"
+version = "0.8.1"
 license = "MIT"
 authors = ["Ethan Paul <24588726+enpaul@users.noreply.github.com>"]
-description = "Tox plugin to install Tox environment dependencies using the Poetry backend and lockfile"
+description = "A plugin for Tox that lets you install test environment dependencies from the Poetry lockfile"
 repository = "https://github.com/enpaul/tox-poetry-installer/"
-packages = [{include = "tox_poetry_installer.py"}]
+packages = [
+  {include = "tox_poetry_installer"},
+  {include = "tests/*.py", format = "sdist"}
+]
+include = [
+  "tox_poetry_installer/py.typed"
+]
 keywords = ["tox", "poetry", "plugin"]
 readme = "README.md"
 classifiers = [
-  "Development Status :: 3 - Alpha",
+  "Development Status :: 4 - Beta",
   "Environment :: Plugins",
   "Framework :: tox",
   "Intended Audience :: Developers",
   "License :: OSI Approved :: MIT License",
   "Natural Language :: English",
   "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
   "Programming Language :: Python :: 3.6",
   "Programming Language :: Python :: 3.7",
   "Programming Language :: Python :: 3.8",
+  "Programming Language :: Python :: 3.9",
   "Programming Language :: Python :: Implementation :: CPython",
 ]
 
 [tool.poetry.plugins.tox]
 poetry_installer = "tox_poetry_installer"
 
+[tool.poetry.extras]
+poetry = ["poetry"]
+
 [tool.poetry.dependencies]
-python = "^3.6"
-poetry = "^1.0.0"
-tox = "^2.3.0 || ^3.0.0"
+python = "^3.6.1"
+poetry = {version = "^1.0.0", optional = true}
+poetry-core = "^1.0.0"
+tox = "^3.8.0"
 
 [tool.poetry.dev-dependencies]
 bandit = "^1.6.2"
-black = {version = "^20.8b1", allow-prereleases = true}
-ipython = {version = "^7.18.1", python = "^3.7"}
+black = { version = "^20.8b1", allow-prereleases = true }
+blacken-docs = "^1.8.0"
+ipython = { version = "^7.18.1", python = "^3.7" }
 mypy = "^0.782"
-pre-commit = {version = "^2.7.1", python = "^3.6.1"}
+pre-commit = "^2.7.1"
+pre-commit-hooks = "^3.3.0"
 pylint = "^2.4.4"
 pytest = "^6.0.2"
 pytest-cov = "^2.10.1"
-reorder-python-imports = {version = "^2.3.5", python = "^3.6.1"}
+reorder-python-imports = "^2.3.5"
 safety = "^1.9.0"
 toml = "^0.10.1"
 tox = "^3.20.0"
+mdformat = "^0.6.4"
+mdformat-gfm = "^0.2"
 
 [build-system]
-requires = ["poetry>=1.0.0"]
-build-backend = "poetry.masonry.api"
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"

tests/fixtures.py

@@ -0,0 +1,63 @@
+# pylint: disable=missing-module-docstring, missing-function-docstring, unused-argument, too-few-public-methods
+import time
+from pathlib import Path
+
+import poetry.factory
+import poetry.installation.pip_installer
+import poetry.utils.env
+import pytest
+import tox
+from poetry.core.packages import Package as PoetryPackage
+
+from tox_poetry_installer import utilities
+
+
+TEST_PROJECT_PATH = Path(__file__).parent.resolve() / "test-project"
+
+FAKE_VENV_PATH = Path("nowhere")
+
+
+class MockVirtualEnv:
+    """Mock class for the :class:`poetry.utils.env.VirtualEnv` and :class:`tox.venv.VirtualEnv`"""
+
+    class MockTestenvConfig:  # pylint: disable=missing-class-docstring
+        envdir = FAKE_VENV_PATH
+
+    def __init__(self, *args, **kwargs):
+        self.envconfig = self.MockTestenvConfig()
+        self.installed = []
+
+    @staticmethod
+    def is_valid_for_marker(*args, **kwargs):
+        return True
+
+
+class MockPipInstaller:
+    """Mock class for the :class:`poetry.installation.pip_installer.PipInstaller`"""
+
+    def __init__(self, env: MockVirtualEnv, **kwargs):
+        self.env = env
+
+    def install(self, package: PoetryPackage):
+        self.env.installed.append(package)
+        time.sleep(1)
+
+
+@pytest.fixture
+def mock_venv(monkeypatch):
+    monkeypatch.setattr(utilities, "convert_virtualenv", lambda venv: venv)
+    monkeypatch.setattr(
+        poetry.installation.pip_installer, "PipInstaller", MockPipInstaller
+    )
+    monkeypatch.setattr(tox.venv, "VirtualEnv", MockVirtualEnv)
+    monkeypatch.setattr(poetry.utils.env, "VirtualEnv", MockVirtualEnv)
+
+
+@pytest.fixture(scope="function")
+def mock_poetry_factory(monkeypatch):
+    pypoetry = poetry.factory.Factory().create_poetry(cwd=TEST_PROJECT_PATH)
+
+    def mock_factory(*args, **kwargs):
+        return pypoetry
+
+    monkeypatch.setattr(poetry.factory.Factory, "create_poetry", mock_factory)

tests/test-project/poetry.lock

@@ -0,0 +1,505 @@
+[[package]]
+name = "appdirs"
+version = "1.4.4"
+description = "A small Python module for determining appropriate platform-specific dirs, e.g. a \"user data dir\"."
+category = "main"
+optional = false
+python-versions = "*"
+
+[[package]]
+name = "attrs"
+version = "20.3.0"
+description = "Classes Without Boilerplate"
+category = "main"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*"
+
+[package.extras]
+dev = ["coverage[toml] (>=5.0.2)", "hypothesis", "pympler", "pytest (>=4.3.0)", "six", "zope.interface", "furo", "sphinx", "pre-commit"]
+docs = ["furo", "sphinx", "zope.interface"]
+tests = ["coverage[toml] (>=5.0.2)", "hypothesis", "pympler", "pytest (>=4.3.0)", "six", "zope.interface"]
+tests_no_zope = ["coverage[toml] (>=5.0.2)", "hypothesis", "pympler", "pytest (>=4.3.0)", "six"]
+
+[[package]]
+name = "certifi"
+version = "2020.12.5"
+description = "Python package for providing Mozilla's CA Bundle."
+category = "main"
+optional = false
+python-versions = "*"
+
+[[package]]
+name = "chardet"
+version = "4.0.0"
+description = "Universal encoding detector for Python 2 and 3"
+category = "main"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*"
+
+[[package]]
+name = "click"
+version = "7.1.2"
+description = "Composable command line interface toolkit"
+category = "main"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*"
+
+[[package]]
+name = "colorama"
+version = "0.4.4"
+description = "Cross-platform colored terminal text."
+category = "main"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*"
+
+[[package]]
+name = "distlib"
+version = "0.3.1"
+description = "Distribution utilities"
+category = "main"
+optional = false
+python-versions = "*"
+
+[[package]]
+name = "filelock"
+version = "3.0.12"
+description = "A platform independent file lock."
+category = "main"
+optional = false
+python-versions = "*"
+
+[[package]]
+name = "flask"
+version = "1.1.2"
+description = "A simple framework for building complex web applications."
+category = "main"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*"
+
+[package.dependencies]
+click = ">=5.1"
+itsdangerous = ">=0.24"
+Jinja2 = ">=2.10.1"
+Werkzeug = ">=0.15"
+
+[package.extras]
+dev = ["pytest", "coverage", "tox", "sphinx", "pallets-sphinx-themes", "sphinxcontrib-log-cabinet", "sphinx-issues"]
+docs = ["sphinx", "pallets-sphinx-themes", "sphinxcontrib-log-cabinet", "sphinx-issues"]
+dotenv = ["python-dotenv"]
+
+[[package]]
+name = "idna"
+version = "2.10"
+description = "Internationalized Domain Names in Applications (IDNA)"
+category = "main"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*"
+
+[[package]]
+name = "importlib-metadata"
+version = "3.10.1"
+description = "Read metadata from Python packages"
+category = "main"
+optional = false
+python-versions = ">=3.6"
+
+[package.dependencies]
+typing-extensions = {version = ">=3.6.4", markers = "python_version < \"3.8\""}
+zipp = ">=0.5"
+
+[package.extras]
+docs = ["sphinx", "jaraco.packaging (>=8.2)", "rst.linker (>=1.9)"]
+testing = ["pytest (>=4.6)", "pytest-checkdocs (>=2.4)", "pytest-flake8", "pytest-cov", "pytest-enabler (>=1.0.1)", "packaging", "pep517", "pyfakefs", "flufl.flake8", "pytest-black (>=0.3.7)", "pytest-mypy", "importlib-resources (>=1.3)"]
+
+[[package]]
+name = "importlib-resources"
+version = "5.1.2"
+description = "Read resources from Python packages"
+category = "main"
+optional = false
+python-versions = ">=3.6"
+
+[package.dependencies]
+zipp = {version = ">=0.4", markers = "python_version < \"3.8\""}
+
+[package.extras]
+docs = ["sphinx", "jaraco.packaging (>=8.2)", "rst.linker (>=1.9)"]
+testing = ["pytest (>=4.6)", "pytest-checkdocs (>=1.2.3)", "pytest-flake8", "pytest-cov", "pytest-enabler", "pytest-black (>=0.3.7)", "pytest-mypy"]
+
+[[package]]
+name = "itsdangerous"
+version = "1.1.0"
+description = "Various helpers to pass data to untrusted environments and back."
+category = "main"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*"
+
+[[package]]
+name = "jinja2"
+version = "2.11.3"
+description = "A very fast and expressive template engine."
+category = "main"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*"
+
+[package.dependencies]
+MarkupSafe = ">=0.23"
+
+[package.extras]
+i18n = ["Babel (>=0.8)"]
+
+[[package]]
+name = "markupsafe"
+version = "1.1.1"
+description = "Safely add untrusted strings to HTML/XML markup."
+category = "main"
+optional = false
+python-versions = ">=2.7,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*"
+
+[[package]]
+name = "packaging"
+version = "20.9"
+description = "Core utilities for Python packages"
+category = "main"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*"
+
+[package.dependencies]
+pyparsing = ">=2.0.2"
+
+[[package]]
+name = "pluggy"
+version = "0.13.1"
+description = "plugin and hook calling mechanisms for python"
+category = "main"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*"
+
+[package.dependencies]
+importlib-metadata = {version = ">=0.12", markers = "python_version < \"3.8\""}
+
+[package.extras]
+dev = ["pre-commit", "tox"]
+
+[[package]]
+name = "py"
+version = "1.10.0"
+description = "library with cross-python path, ini-parsing, io, code, log facilities"
+category = "main"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*"
+
+[[package]]
+name = "pyparsing"
+version = "2.4.7"
+description = "Python parsing module"
+category = "main"
+optional = false
+python-versions = ">=2.6, !=3.0.*, !=3.1.*, !=3.2.*"
+
+[[package]]
+name = "python-dateutil"
+version = "2.8.1"
+description = "Extensions to the standard Python datetime module"
+category = "main"
+optional = false
+python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,>=2.7"
+
+[package.dependencies]
+six = ">=1.5"
+
+[[package]]
+name = "requests"
+version = "2.25.1"
+description = "Python HTTP for Humans."
+category = "main"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*"
+
+[package.dependencies]
+certifi = ">=2017.4.17"
+chardet = ">=3.0.2,<5"
+idna = ">=2.5,<3"
+urllib3 = ">=1.21.1,<1.27"
+
+[package.extras]
+security = ["pyOpenSSL (>=0.14)", "cryptography (>=1.3.4)"]
+socks = ["PySocks (>=1.5.6,!=1.5.7)", "win-inet-pton"]
+
+[[package]]
+name = "six"
+version = "1.15.0"
+description = "Python 2 and 3 compatibility utilities"
+category = "main"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*"
+
+[[package]]
+name = "toml"
+version = "0.10.2"
+description = "Python Library for Tom's Obvious, Minimal Language"
+category = "main"
+optional = false
+python-versions = ">=2.6, !=3.0.*, !=3.1.*, !=3.2.*"
+
+[[package]]
+name = "tox"
+version = "3.23.0"
+description = "tox is a generic virtualenv management and test command line tool"
+category = "main"
+optional = false
+python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,>=2.7"
+
+[package.dependencies]
+colorama = {version = ">=0.4.1", markers = "platform_system == \"Windows\""}
+filelock = ">=3.0.0"
+importlib-metadata = {version = ">=0.12", markers = "python_version < \"3.8\""}
+packaging = ">=14"
+pluggy = ">=0.12.0"
+py = ">=1.4.17"
+six = ">=1.14.0"
+toml = ">=0.9.4"
+virtualenv = ">=16.0.0,<20.0.0 || >20.0.0,<20.0.1 || >20.0.1,<20.0.2 || >20.0.2,<20.0.3 || >20.0.3,<20.0.4 || >20.0.4,<20.0.5 || >20.0.5,<20.0.6 || >20.0.6,<20.0.7 || >20.0.7"
+
+[package.extras]
+docs = ["pygments-github-lexers (>=0.0.5)", "sphinx (>=2.0.0)", "sphinxcontrib-autoprogram (>=0.1.5)", "towncrier (>=18.5.0)"]
+testing = ["flaky (>=3.4.0)", "freezegun (>=0.3.11)", "psutil (>=5.6.1)", "pytest (>=4.0.0)", "pytest-cov (>=2.5.1)", "pytest-mock (>=1.10.0)", "pytest-randomly (>=1.0.0)", "pytest-xdist (>=1.22.2)", "pathlib2 (>=2.3.3)"]
+
+[[package]]
+name = "typing-extensions"
+version = "3.7.4.3"
+description = "Backported and Experimental Type Hints for Python 3.5+"
+category = "main"
+optional = false
+python-versions = "*"
+
+[[package]]
+name = "urllib3"
+version = "1.26.4"
+description = "HTTP library with thread-safe connection pooling, file post, and more."
+category = "main"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, <4"
+
+[package.extras]
+secure = ["pyOpenSSL (>=0.14)", "cryptography (>=1.3.4)", "idna (>=2.0.0)", "certifi", "ipaddress"]
+socks = ["PySocks (>=1.5.6,!=1.5.7,<2.0)"]
+brotli = ["brotlipy (>=0.6.0)"]
+
+[[package]]
+name = "virtualenv"
+version = "20.4.3"
+description = "Virtual Python Environment builder"
+category = "main"
+optional = false
+python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,>=2.7"
+
+[package.dependencies]
+appdirs = ">=1.4.3,<2"
+distlib = ">=0.3.1,<1"
+filelock = ">=3.0.0,<4"
+importlib-metadata = {version = ">=0.12", markers = "python_version < \"3.8\""}
+importlib-resources = {version = ">=1.0", markers = "python_version < \"3.7\""}
+six = ">=1.9.0,<2"
+
+[package.extras]
+docs = ["proselint (>=0.10.2)", "sphinx (>=3)", "sphinx-argparse (>=0.2.5)", "sphinx-rtd-theme (>=0.4.3)", "towncrier (>=19.9.0rc1)"]
+testing = ["coverage (>=4)", "coverage-enable-subprocess (>=1)", "flaky (>=3)", "pytest (>=4)", "pytest-env (>=0.6.2)", "pytest-freezegun (>=0.4.1)", "pytest-mock (>=2)", "pytest-randomly (>=1)", "pytest-timeout (>=1)", "packaging (>=20.0)", "xonsh (>=0.9.16)"]
+
+[[package]]
+name = "werkzeug"
+version = "1.0.1"
+description = "The comprehensive WSGI web application library."
+category = "main"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*"
+
+[package.extras]
+dev = ["pytest", "pytest-timeout", "coverage", "tox", "sphinx", "pallets-sphinx-themes", "sphinx-issues"]
+watchdog = ["watchdog"]
+
+[[package]]
+name = "zipp"
+version = "3.4.1"
+description = "Backport of pathlib-compatible object wrapper for zip files"
+category = "main"
+optional = false
+python-versions = ">=3.6"
+
+[package.extras]
+docs = ["sphinx", "jaraco.packaging (>=8.2)", "rst.linker (>=1.9)"]
+testing = ["pytest (>=4.6)", "pytest-checkdocs (>=1.2.3)", "pytest-flake8", "pytest-cov", "pytest-enabler", "jaraco.itertools", "func-timeout", "pytest-black (>=0.3.7)", "pytest-mypy"]
+
+[metadata]
+lock-version = "1.1"
+python-versions = "^3.6.1"
+content-hash = "af9db950cd722e7dc52b691fb58abc1e22ab48b34ddfe4c5258b3c755a3892fa"
+
+[metadata.files]
+appdirs = [
+    {file = "appdirs-1.4.4-py2.py3-none-any.whl", hash = "sha256:a841dacd6b99318a741b166adb07e19ee71a274450e68237b4650ca1055ab128"},
+    {file = "appdirs-1.4.4.tar.gz", hash = "sha256:7d5d0167b2b1ba821647616af46a749d1c653740dd0d2415100fe26e27afdf41"},
+]
+attrs = [
+    {file = "attrs-20.3.0-py2.py3-none-any.whl", hash = "sha256:31b2eced602aa8423c2aea9c76a724617ed67cf9513173fd3a4f03e3a929c7e6"},
+    {file = "attrs-20.3.0.tar.gz", hash = "sha256:832aa3cde19744e49938b91fea06d69ecb9e649c93ba974535d08ad92164f700"},
+]
+certifi = [
+    {file = "certifi-2020.12.5-py2.py3-none-any.whl", hash = "sha256:719a74fb9e33b9bd44cc7f3a8d94bc35e4049deebe19ba7d8e108280cfd59830"},
+    {file = "certifi-2020.12.5.tar.gz", hash = "sha256:1a4995114262bffbc2413b159f2a1a480c969de6e6eb13ee966d470af86af59c"},
+]
+chardet = [
+    {file = "chardet-4.0.0-py2.py3-none-any.whl", hash = "sha256:f864054d66fd9118f2e67044ac8981a54775ec5b67aed0441892edb553d21da5"},
+    {file = "chardet-4.0.0.tar.gz", hash = "sha256:0d6f53a15db4120f2b08c94f11e7d93d2c911ee118b6b30a04ec3ee8310179fa"},
+]
+click = [
+    {file = "click-7.1.2-py2.py3-none-any.whl", hash = "sha256:dacca89f4bfadd5de3d7489b7c8a566eee0d3676333fbb50030263894c38c0dc"},
+    {file = "click-7.1.2.tar.gz", hash = "sha256:d2b5255c7c6349bc1bd1e59e08cd12acbbd63ce649f2588755783aa94dfb6b1a"},
+]
+colorama = [
+    {file = "colorama-0.4.4-py2.py3-none-any.whl", hash = "sha256:9f47eda37229f68eee03b24b9748937c7dc3868f906e8ba69fbcbdd3bc5dc3e2"},
+    {file = "colorama-0.4.4.tar.gz", hash = "sha256:5941b2b48a20143d2267e95b1c2a7603ce057ee39fd88e7329b0c292aa16869b"},
+]
+distlib = [
+    {file = "distlib-0.3.1-py2.py3-none-any.whl", hash = "sha256:8c09de2c67b3e7deef7184574fc060ab8a793e7adbb183d942c389c8b13c52fb"},
+    {file = "distlib-0.3.1.zip", hash = "sha256:edf6116872c863e1aa9d5bb7cb5e05a022c519a4594dc703843343a9ddd9bff1"},
+]
+filelock = [
+    {file = "filelock-3.0.12-py3-none-any.whl", hash = "sha256:929b7d63ec5b7d6b71b0fa5ac14e030b3f70b75747cef1b10da9b879fef15836"},
+    {file = "filelock-3.0.12.tar.gz", hash = "sha256:18d82244ee114f543149c66a6e0c14e9c4f8a1044b5cdaadd0f82159d6a6ff59"},
+]
+flask = [
+    {file = "Flask-1.1.2-py2.py3-none-any.whl", hash = "sha256:8a4fdd8936eba2512e9c85df320a37e694c93945b33ef33c89946a340a238557"},
+    {file = "Flask-1.1.2.tar.gz", hash = "sha256:4efa1ae2d7c9865af48986de8aeb8504bf32c7f3d6fdc9353d34b21f4b127060"},
+]
+idna = [
+    {file = "idna-2.10-py2.py3-none-any.whl", hash = "sha256:b97d804b1e9b523befed77c48dacec60e6dcb0b5391d57af6a65a312a90648c0"},
+    {file = "idna-2.10.tar.gz", hash = "sha256:b307872f855b18632ce0c21c5e45be78c0ea7ae4c15c828c20788b26921eb3f6"},
+]
+importlib-metadata = [
+    {file = "importlib_metadata-3.10.1-py3-none-any.whl", hash = "sha256:2ec0faae539743ae6aaa84b49a169670a465f7f5d64e6add98388cc29fd1f2f6"},
+    {file = "importlib_metadata-3.10.1.tar.gz", hash = "sha256:c9356b657de65c53744046fa8f7358afe0714a1af7d570c00c3835c2d724a7c1"},
+]
+importlib-resources = [
+    {file = "importlib_resources-5.1.2-py3-none-any.whl", hash = "sha256:ebab3efe74d83b04d6bf5cd9a17f0c5c93e60fb60f30c90f56265fce4682a469"},
+    {file = "importlib_resources-5.1.2.tar.gz", hash = "sha256:642586fc4740bd1cad7690f836b3321309402b20b332529f25617ff18e8e1370"},
+]
+itsdangerous = [
+    {file = "itsdangerous-1.1.0-py2.py3-none-any.whl", hash = "sha256:b12271b2047cb23eeb98c8b5622e2e5c5e9abd9784a153e9d8ef9cb4dd09d749"},
+    {file = "itsdangerous-1.1.0.tar.gz", hash = "sha256:321b033d07f2a4136d3ec762eac9f16a10ccd60f53c0c91af90217ace7ba1f19"},
+]
+jinja2 = [
+    {file = "Jinja2-2.11.3-py2.py3-none-any.whl", hash = "sha256:03e47ad063331dd6a3f04a43eddca8a966a26ba0c5b7207a9a9e4e08f1b29419"},
+    {file = "Jinja2-2.11.3.tar.gz", hash = "sha256:a6d58433de0ae800347cab1fa3043cebbabe8baa9d29e668f1c768cb87a333c6"},
+]
+markupsafe = [
+    {file = "MarkupSafe-1.1.1-cp27-cp27m-macosx_10_6_intel.whl", hash = "sha256:09027a7803a62ca78792ad89403b1b7a73a01c8cb65909cd876f7fcebd79b161"},
+    {file = "MarkupSafe-1.1.1-cp27-cp27m-manylinux1_i686.whl", hash = "sha256:e249096428b3ae81b08327a63a485ad0878de3fb939049038579ac0ef61e17e7"},
+    {file = "MarkupSafe-1.1.1-cp27-cp27m-manylinux1_x86_64.whl", hash = "sha256:500d4957e52ddc3351cabf489e79c91c17f6e0899158447047588650b5e69183"},
+    {file = "MarkupSafe-1.1.1-cp27-cp27m-win32.whl", hash = "sha256:b2051432115498d3562c084a49bba65d97cf251f5a331c64a12ee7e04dacc51b"},
+    {file = "MarkupSafe-1.1.1-cp27-cp27m-win_amd64.whl", hash = "sha256:98c7086708b163d425c67c7a91bad6e466bb99d797aa64f965e9d25c12111a5e"},
+    {file = "MarkupSafe-1.1.1-cp27-cp27mu-manylinux1_i686.whl", hash = "sha256:cd5df75523866410809ca100dc9681e301e3c27567cf498077e8551b6d20e42f"},
+    {file = "MarkupSafe-1.1.1-cp27-cp27mu-manylinux1_x86_64.whl", hash = "sha256:43a55c2930bbc139570ac2452adf3d70cdbb3cfe5912c71cdce1c2c6bbd9c5d1"},
+    {file = "MarkupSafe-1.1.1-cp34-cp34m-macosx_10_6_intel.whl", hash = "sha256:1027c282dad077d0bae18be6794e6b6b8c91d58ed8a8d89a89d59693b9131db5"},
+    {file = "MarkupSafe-1.1.1-cp34-cp34m-manylinux1_i686.whl", hash = "sha256:62fe6c95e3ec8a7fad637b7f3d372c15ec1caa01ab47926cfdf7a75b40e0eac1"},
+    {file = "MarkupSafe-1.1.1-cp34-cp34m-manylinux1_x86_64.whl", hash = "sha256:88e5fcfb52ee7b911e8bb6d6aa2fd21fbecc674eadd44118a9cc3863f938e735"},
+    {file = "MarkupSafe-1.1.1-cp34-cp34m-win32.whl", hash = "sha256:ade5e387d2ad0d7ebf59146cc00c8044acbd863725f887353a10df825fc8ae21"},
+    {file = "MarkupSafe-1.1.1-cp34-cp34m-win_amd64.whl", hash = "sha256:09c4b7f37d6c648cb13f9230d847adf22f8171b1ccc4d5682398e77f40309235"},
+    {file = "MarkupSafe-1.1.1-cp35-cp35m-macosx_10_6_intel.whl", hash = "sha256:79855e1c5b8da654cf486b830bd42c06e8780cea587384cf6545b7d9ac013a0b"},
+    {file = "MarkupSafe-1.1.1-cp35-cp35m-manylinux1_i686.whl", hash = "sha256:c8716a48d94b06bb3b2524c2b77e055fb313aeb4ea620c8dd03a105574ba704f"},
+    {file = "MarkupSafe-1.1.1-cp35-cp35m-manylinux1_x86_64.whl", hash = "sha256:7c1699dfe0cf8ff607dbdcc1e9b9af1755371f92a68f706051cc8c37d447c905"},
+    {file = "MarkupSafe-1.1.1-cp35-cp35m-win32.whl", hash = "sha256:6dd73240d2af64df90aa7c4e7481e23825ea70af4b4922f8ede5b9e35f78a3b1"},
+    {file = "MarkupSafe-1.1.1-cp35-cp35m-win_amd64.whl", hash = "sha256:9add70b36c5666a2ed02b43b335fe19002ee5235efd4b8a89bfcf9005bebac0d"},
+    {file = "MarkupSafe-1.1.1-cp36-cp36m-macosx_10_6_intel.whl", hash = "sha256:24982cc2533820871eba85ba648cd53d8623687ff11cbb805be4ff7b4c971aff"},
+    {file = "MarkupSafe-1.1.1-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:d53bc011414228441014aa71dbec320c66468c1030aae3a6e29778a3382d96e5"},
+    {file = "MarkupSafe-1.1.1-cp36-cp36m-manylinux1_i686.whl", hash = "sha256:00bc623926325b26bb9605ae9eae8a215691f33cae5df11ca5424f06f2d1f473"},
+    {file = "MarkupSafe-1.1.1-cp36-cp36m-manylinux1_x86_64.whl", hash = "sha256:717ba8fe3ae9cc0006d7c451f0bb265ee07739daf76355d06366154ee68d221e"},
+    {file = "MarkupSafe-1.1.1-cp36-cp36m-manylinux2010_i686.whl", hash = "sha256:3b8a6499709d29c2e2399569d96719a1b21dcd94410a586a18526b143ec8470f"},
+    {file = "MarkupSafe-1.1.1-cp36-cp36m-manylinux2010_x86_64.whl", hash = "sha256:84dee80c15f1b560d55bcfe6d47b27d070b4681c699c572af2e3c7cc90a3b8e0"},
+    {file = "MarkupSafe-1.1.1-cp36-cp36m-manylinux2014_aarch64.whl", hash = "sha256:b1dba4527182c95a0db8b6060cc98ac49b9e2f5e64320e2b56e47cb2831978c7"},
+    {file = "MarkupSafe-1.1.1-cp36-cp36m-win32.whl", hash = "sha256:535f6fc4d397c1563d08b88e485c3496cf5784e927af890fb3c3aac7f933ec66"},
+    {file = "MarkupSafe-1.1.1-cp36-cp36m-win_amd64.whl", hash = "sha256:b1282f8c00509d99fef04d8ba936b156d419be841854fe901d8ae224c59f0be5"},
+    {file = "MarkupSafe-1.1.1-cp37-cp37m-macosx_10_6_intel.whl", hash = "sha256:8defac2f2ccd6805ebf65f5eeb132adcf2ab57aa11fdf4c0dd5169a004710e7d"},
+    {file = "MarkupSafe-1.1.1-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:bf5aa3cbcfdf57fa2ee9cd1822c862ef23037f5c832ad09cfea57fa846dec193"},
+    {file = "MarkupSafe-1.1.1-cp37-cp37m-manylinux1_i686.whl", hash = "sha256:46c99d2de99945ec5cb54f23c8cd5689f6d7177305ebff350a58ce5f8de1669e"},
+    {file = "MarkupSafe-1.1.1-cp37-cp37m-manylinux1_x86_64.whl", hash = "sha256:ba59edeaa2fc6114428f1637ffff42da1e311e29382d81b339c1817d37ec93c6"},
+    {file = "MarkupSafe-1.1.1-cp37-cp37m-manylinux2010_i686.whl", hash = "sha256:6fffc775d90dcc9aed1b89219549b329a9250d918fd0b8fa8d93d154918422e1"},
+    {file = "MarkupSafe-1.1.1-cp37-cp37m-manylinux2010_x86_64.whl", hash = "sha256:a6a744282b7718a2a62d2ed9d993cad6f5f585605ad352c11de459f4108df0a1"},
+    {file = "MarkupSafe-1.1.1-cp37-cp37m-manylinux2014_aarch64.whl", hash = "sha256:195d7d2c4fbb0ee8139a6cf67194f3973a6b3042d742ebe0a9ed36d8b6f0c07f"},
+    {file = "MarkupSafe-1.1.1-cp37-cp37m-win32.whl", hash = "sha256:b00c1de48212e4cc9603895652c5c410df699856a2853135b3967591e4beebc2"},
+    {file = "MarkupSafe-1.1.1-cp37-cp37m-win_amd64.whl", hash = "sha256:9bf40443012702a1d2070043cb6291650a0841ece432556f784f004937f0f32c"},
+    {file = "MarkupSafe-1.1.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:6788b695d50a51edb699cb55e35487e430fa21f1ed838122d722e0ff0ac5ba15"},
+    {file = "MarkupSafe-1.1.1-cp38-cp38-manylinux1_i686.whl", hash = "sha256:cdb132fc825c38e1aeec2c8aa9338310d29d337bebbd7baa06889d09a60a1fa2"},
+    {file = "MarkupSafe-1.1.1-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:13d3144e1e340870b25e7b10b98d779608c02016d5184cfb9927a9f10c689f42"},
+    {file = "MarkupSafe-1.1.1-cp38-cp38-manylinux2010_i686.whl", hash = "sha256:acf08ac40292838b3cbbb06cfe9b2cb9ec78fce8baca31ddb87aaac2e2dc3bc2"},
+    {file = "MarkupSafe-1.1.1-cp38-cp38-manylinux2010_x86_64.whl", hash = "sha256:d9be0ba6c527163cbed5e0857c451fcd092ce83947944d6c14bc95441203f032"},
+    {file = "MarkupSafe-1.1.1-cp38-cp38-manylinux2014_aarch64.whl", hash = "sha256:caabedc8323f1e93231b52fc32bdcde6db817623d33e100708d9a68e1f53b26b"},
+    {file = "MarkupSafe-1.1.1-cp38-cp38-win32.whl", hash = "sha256:596510de112c685489095da617b5bcbbac7dd6384aeebeda4df6025d0256a81b"},
+    {file = "MarkupSafe-1.1.1-cp38-cp38-win_amd64.whl", hash = "sha256:e8313f01ba26fbbe36c7be1966a7b7424942f670f38e666995b88d012765b9be"},
+    {file = "MarkupSafe-1.1.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:d73a845f227b0bfe8a7455ee623525ee656a9e2e749e4742706d80a6065d5e2c"},
+    {file = "MarkupSafe-1.1.1-cp39-cp39-manylinux1_i686.whl", hash = "sha256:98bae9582248d6cf62321dcb52aaf5d9adf0bad3b40582925ef7c7f0ed85fceb"},
+    {file = "MarkupSafe-1.1.1-cp39-cp39-manylinux1_x86_64.whl", hash = "sha256:2beec1e0de6924ea551859edb9e7679da6e4870d32cb766240ce17e0a0ba2014"},
+    {file = "MarkupSafe-1.1.1-cp39-cp39-manylinux2010_i686.whl", hash = "sha256:7fed13866cf14bba33e7176717346713881f56d9d2bcebab207f7a036f41b850"},
+    {file = "MarkupSafe-1.1.1-cp39-cp39-manylinux2010_x86_64.whl", hash = "sha256:6f1e273a344928347c1290119b493a1f0303c52f5a5eae5f16d74f48c15d4a85"},
+    {file = "MarkupSafe-1.1.1-cp39-cp39-manylinux2014_aarch64.whl", hash = "sha256:feb7b34d6325451ef96bc0e36e1a6c0c1c64bc1fbec4b854f4529e51887b1621"},
+    {file = "MarkupSafe-1.1.1-cp39-cp39-win32.whl", hash = "sha256:22c178a091fc6630d0d045bdb5992d2dfe14e3259760e713c490da5323866c39"},
+    {file = "MarkupSafe-1.1.1-cp39-cp39-win_amd64.whl", hash = "sha256:b7d644ddb4dbd407d31ffb699f1d140bc35478da613b441c582aeb7c43838dd8"},
+    {file = "MarkupSafe-1.1.1.tar.gz", hash = "sha256:29872e92839765e546828bb7754a68c418d927cd064fd4708fab9fe9c8bb116b"},
+]
+packaging = [
+    {file = "packaging-20.9-py2.py3-none-any.whl", hash = "sha256:67714da7f7bc052e064859c05c595155bd1ee9f69f76557e21f051443c20947a"},
+    {file = "packaging-20.9.tar.gz", hash = "sha256:5b327ac1320dc863dca72f4514ecc086f31186744b84a230374cc1fd776feae5"},
+]
+pluggy = [
+    {file = "pluggy-0.13.1-py2.py3-none-any.whl", hash = "sha256:966c145cd83c96502c3c3868f50408687b38434af77734af1e9ca461a4081d2d"},
+    {file = "pluggy-0.13.1.tar.gz", hash = "sha256:15b2acde666561e1298d71b523007ed7364de07029219b604cf808bfa1c765b0"},
+]
+py = [
+    {file = "py-1.10.0-py2.py3-none-any.whl", hash = "sha256:3b80836aa6d1feeaa108e046da6423ab8f6ceda6468545ae8d02d9d58d18818a"},
+    {file = "py-1.10.0.tar.gz", hash = "sha256:21b81bda15b66ef5e1a777a21c4dcd9c20ad3efd0b3f817e7a809035269e1bd3"},
+]
+pyparsing = [
+    {file = "pyparsing-2.4.7-py2.py3-none-any.whl", hash = "sha256:ef9d7589ef3c200abe66653d3f1ab1033c3c419ae9b9bdb1240a85b024efc88b"},
+    {file = "pyparsing-2.4.7.tar.gz", hash = "sha256:c203ec8783bf771a155b207279b9bccb8dea02d8f0c9e5f8ead507bc3246ecc1"},
+]
+python-dateutil = [
+    {file = "python-dateutil-2.8.1.tar.gz", hash = "sha256:73ebfe9dbf22e832286dafa60473e4cd239f8592f699aa5adaf10050e6e1823c"},
+    {file = "python_dateutil-2.8.1-py2.py3-none-any.whl", hash = "sha256:75bb3f31ea686f1197762692a9ee6a7550b59fc6ca3a1f4b5d7e32fb98e2da2a"},
+]
+requests = [
+    {file = "requests-2.25.1-py2.py3-none-any.whl", hash = "sha256:c210084e36a42ae6b9219e00e48287def368a26d03a048ddad7bfee44f75871e"},
+    {file = "requests-2.25.1.tar.gz", hash = "sha256:27973dd4a904a4f13b263a19c866c13b92a39ed1c964655f025f3f8d3d75b804"},
+]
+six = [
+    {file = "six-1.15.0-py2.py3-none-any.whl", hash = "sha256:8b74bedcbbbaca38ff6d7491d76f2b06b3592611af620f8426e82dddb04a5ced"},
+    {file = "six-1.15.0.tar.gz", hash = "sha256:30639c035cdb23534cd4aa2dd52c3bf48f06e5f4a941509c8bafd8ce11080259"},
+]
+toml = [
+    {file = "toml-0.10.2-py2.py3-none-any.whl", hash = "sha256:806143ae5bfb6a3c6e736a764057db0e6a0e05e338b5630894a5f779cabb4f9b"},
+    {file = "toml-0.10.2.tar.gz", hash = "sha256:b3bda1d108d5dd99f4a20d24d9c348e91c4db7ab1b749200bded2f839ccbe68f"},
+]
+tox = [
+    {file = "tox-3.23.0-py2.py3-none-any.whl", hash = "sha256:e007673f3595cede9b17a7c4962389e4305d4a3682a6c5a4159a1453b4f326aa"},
+    {file = "tox-3.23.0.tar.gz", hash = "sha256:05a4dbd5e4d3d8269b72b55600f0b0303e2eb47ad5c6fe76d3576f4c58d93661"},
+]
+typing-extensions = [
+    {file = "typing_extensions-3.7.4.3-py2-none-any.whl", hash = "sha256:dafc7639cde7f1b6e1acc0f457842a83e722ccca8eef5270af2d74792619a89f"},
+    {file = "typing_extensions-3.7.4.3-py3-none-any.whl", hash = "sha256:7cb407020f00f7bfc3cb3e7881628838e69d8f3fcab2f64742a5e76b2f841918"},
+    {file = "typing_extensions-3.7.4.3.tar.gz", hash = "sha256:99d4073b617d30288f569d3f13d2bd7548c3a7e4c8de87db09a9d29bb3a4a60c"},
+]
+urllib3 = [
+    {file = "urllib3-1.26.4-py2.py3-none-any.whl", hash = "sha256:2f4da4594db7e1e110a944bb1b551fdf4e6c136ad42e4234131391e21eb5b0df"},
+    {file = "urllib3-1.26.4.tar.gz", hash = "sha256:e7b021f7241115872f92f43c6508082facffbd1c048e3c6e2bb9c2a157e28937"},
+]
+virtualenv = [
+    {file = "virtualenv-20.4.3-py2.py3-none-any.whl", hash = "sha256:83f95875d382c7abafe06bd2a4cdd1b363e1bb77e02f155ebe8ac082a916b37c"},
+    {file = "virtualenv-20.4.3.tar.gz", hash = "sha256:49ec4eb4c224c6f7dd81bb6d0a28a09ecae5894f4e593c89b0db0885f565a107"},
+]
+werkzeug = [
+    {file = "Werkzeug-1.0.1-py2.py3-none-any.whl", hash = "sha256:2de2a5db0baeae7b2d2664949077c2ac63fbd16d98da0ff71837f7d1dea3fd43"},
+    {file = "Werkzeug-1.0.1.tar.gz", hash = "sha256:6c80b1e5ad3665290ea39320b91e1be1e0d5f60652b964a3070216de83d2e47c"},
+]
+zipp = [
+    {file = "zipp-3.4.1-py3-none-any.whl", hash = "sha256:51cb66cc54621609dd593d1787f286ee42a5c0adbb4b29abea5a63edc3e03098"},
+    {file = "zipp-3.4.1.tar.gz", hash = "sha256:3607921face881ba3e026887d8150cca609d517579abe052ac81fc5aeffdbd76"},
+]

tests/test-project/pyproject.toml

@@ -0,0 +1,19 @@
+[tool.poetry]
+name = "test-project"
+version = "0.0.0"
+license = "MIT"
+authors = ["Ethan Paul <24588726+enpaul@users.noreply.github.com>"]
+description = "A fake project for testing"
+
+[tool.poetry.dependencies]
+python = "^3.6.1"
+requests = "^2.25.1"
+tox = "^3.23.0"
+python-dateutil = "^2.8.1"
+Flask = "^1.1.2"
+toml = "^0.10.2"
+attrs = "^20.3.0"
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"

tests/test_installer.py

@@ -0,0 +1,59 @@
+# pylint: disable=missing-module-docstring, redefined-outer-name, unused-argument, wrong-import-order, unused-import
+import time
+
+import tox.venv
+from poetry.factory import Factory
+
+from .fixtures import mock_poetry_factory
+from .fixtures import mock_venv
+from tox_poetry_installer import datatypes
+from tox_poetry_installer import installer
+
+
+def test_deduplication(mock_venv, mock_poetry_factory):
+    """Test that the installer does not install duplicate dependencies"""
+    poetry = Factory().create_poetry(None)
+    packages: datatypes.PackageMap = {
+        item.name: item for item in poetry.locker.locked_repository(False).packages
+    }
+
+    venv = tox.venv.VirtualEnv()
+    to_install = [packages["toml"], packages["toml"]]
+
+    installer.install(poetry, venv, to_install)
+
+    assert len(set(to_install)) == len(venv.installed)  # pylint: disable=no-member
+
+
+def test_parallelization(mock_venv, mock_poetry_factory):
+    """Test that behavior is consistent between parallel and non-parallel usage"""
+    poetry = Factory().create_poetry(None)
+    packages: datatypes.PackageMap = {
+        item.name: item for item in poetry.locker.locked_repository(False).packages
+    }
+
+    to_install = [
+        packages["toml"],
+        packages["toml"],
+        packages["tox"],
+        packages["requests"],
+        packages["python-dateutil"],
+        packages["attrs"],
+    ]
+
+    venv_sequential = tox.venv.VirtualEnv()
+    start_sequential = time.time()
+    installer.install(poetry, venv_sequential, to_install, 0)
+    sequential = time.time() - start_sequential
+
+    venv_parallel = tox.venv.VirtualEnv()
+    start_parallel = time.time()
+    installer.install(poetry, venv_parallel, to_install, 5)
+    parallel = time.time() - start_parallel
+
+    # The mock delay during package install is static (one second) so these values should all
+    # be within microseconds of each other
+    assert parallel < sequential
+    assert round(parallel * 5) == round(sequential)
+    assert round(sequential) == len(set(to_install))
+    assert round(parallel * 5) == len(set(to_install))

tests/test_metadata.py

@@ -7,7 +7,7 @@ from pathlib import Path
 
 import toml
 
-import tox_poetry_installer
+from tox_poetry_installer import __about__
 
 
 def test_metadata():
@@ -16,16 +16,14 @@ def test_metadata():
     with (Path(__file__).resolve().parent / ".." / "pyproject.toml").open() as infile:
         pyproject = toml.load(infile, _dict=dict)
 
-    assert pyproject["tool"]["poetry"]["name"] == tox_poetry_installer.__title__
-    assert pyproject["tool"]["poetry"]["version"] == tox_poetry_installer.__version__
-    assert pyproject["tool"]["poetry"]["license"] == tox_poetry_installer.__license__
-    assert (
-        pyproject["tool"]["poetry"]["description"] == tox_poetry_installer.__summary__
-    )
-    assert pyproject["tool"]["poetry"]["repository"] == tox_poetry_installer.__url__
+    assert pyproject["tool"]["poetry"]["name"] == __about__.__title__
+    assert pyproject["tool"]["poetry"]["version"] == __about__.__version__
+    assert pyproject["tool"]["poetry"]["license"] == __about__.__license__
+    assert pyproject["tool"]["poetry"]["description"] == __about__.__summary__
+    assert pyproject["tool"]["poetry"]["repository"] == __about__.__url__
     assert (
         all(
-            item in tox_poetry_installer.__authors__
+            item in __about__.__authors__
             for item in pyproject["tool"]["poetry"]["authors"]
         )
         is True
@@ -33,7 +31,7 @@ def test_metadata():
     assert (
         all(
             item in pyproject["tool"]["poetry"]["authors"]
-            for item in tox_poetry_installer.__authors__
+            for item in __about__.__authors__
         )
         is True
     )

tests/test_transients.py

@@ -0,0 +1,85 @@
+# pylint: disable=missing-module-docstring, redefined-outer-name, unused-argument, wrong-import-order, unused-import
+import poetry.factory
+import poetry.utils.env
+import pytest
+from poetry.puzzle.provider import Provider
+
+from .fixtures import mock_poetry_factory
+from .fixtures import mock_venv
+from tox_poetry_installer import constants
+from tox_poetry_installer import datatypes
+from tox_poetry_installer import exceptions
+from tox_poetry_installer import utilities
+
+
+def test_exclude_unsafe():
+    """Test that the unsafe packages are properly excluded
+
+    Also ensure that the internal constant matches the value from Poetry
+    """
+    assert Provider.UNSAFE_PACKAGES == constants.UNSAFE_PACKAGES
+
+    for dep in constants.UNSAFE_PACKAGES:
+        assert utilities.identify_transients(dep, dict(), None) == []
+
+
+def test_allow_missing():
+    """Test that the ``allow_missing`` parameter works as expected"""
+    with pytest.raises(exceptions.LockedDepNotFoundError):
+        utilities.identify_transients("luke-skywalker", dict(), None)
+
+    assert (
+        utilities.identify_transients(
+            "darth-vader", dict(), None, allow_missing=["darth-vader"]
+        )
+        == []
+    )
+
+
+def test_exclude_pep508():
+    """Test that dependencies specified in PEP508 format are properly excluded"""
+    for version in [
+        "foo==1.0",
+        "foo==1",
+        "foo>2.0.0",
+        "foo<=9.3.4.7.8",
+        "foo>999,<=4.6",
+        "foo>1234 || foo<2021.01.01",
+        "foo!=7",
+        "foo~=0.8",
+        "foo!=9,==7",
+        "=>foo",
+    ]:
+        with pytest.raises(exceptions.LockedDepVersionConflictError):
+            utilities.identify_transients(version, dict(), None)
+
+
+def test_functional(mock_poetry_factory, mock_venv):
+    """Integration tests for the :func:`identify_transients` function
+
+    Trivially test that it resolves dependencies properly and that the parent package
+    is always the last in the returned list.
+    """
+    pypoetry = poetry.factory.Factory().create_poetry(None)
+    packages: datatypes.PackageMap = {
+        item.name: item for item in pypoetry.locker.locked_repository(False).packages
+    }
+    venv = poetry.utils.env.VirtualEnv()  # pylint: disable=no-value-for-parameter
+
+    requests_requires = [
+        packages["certifi"],
+        packages["chardet"],
+        packages["idna"],
+        packages["urllib3"],
+        packages["requests"],
+    ]
+
+    transients = utilities.identify_transients("requests", packages, venv)
+
+    assert all((item in requests_requires) for item in transients)
+    assert all((item in transients) for item in requests_requires)
+
+    for package in [packages["requests"], packages["tox"], packages["flask"]]:
+        transients = utilities.identify_transients(package, packages, venv)
+        assert transients[-1] == package
+        assert len(transients) == len(set(transients))

tox.ini

@@ -1,62 +1,65 @@
 [tox]
-envlist = py36, py37, py38, static, static-tests, security
+envlist = py36, py37, py38, py39, static, static-tests, security
 isolated_build = true
+skip_missing_interpreters = true
 
 [testenv]
 description = Run the tests
-deps =
+require_locked_deps = true
+require_poetry = true
+extras =
+    poetry
+locked_deps =
     pytest
     pytest-cov
     toml
 commands =
-    pytest --cov tox_poetry_installer --cov-config {toxinidir}/.coveragerc tests/ --cov-report term-missing
+    pytest --cov {toxinidir}/tox_poetry_installer --cov-config {toxinidir}/.coveragerc --cov-report term-missing {toxinidir}/tests/
 
 [testenv:static]
 description = Static formatting and quality enforcement
 basepython = python3.8
+platform = linux
 ignore_errors = true
-deps =
-    pylint
-    mypy
+locked_deps =
     black
+    blacken-docs
+    mdformat
+    mdformat-gfm
+    mypy
     reorder-python-imports
     pre-commit
+    pre-commit-hooks
+    pylint
 commands =
-    black {toxinidir}/tox_poetry_installer.py
-    reorder-python-imports {toxinidir}/tox_poetry_installer.py
     pre-commit run --all-files
-    pylint --rcfile {toxinidir}/.pylintrc {toxinidir}/tox_poetry_installer.py
-    mypy --ignore-missing-imports --no-strict-optional {toxinidir}/tox_poetry_installer.py
+    pylint --rcfile {toxinidir}/.pylintrc {toxinidir}/tox_poetry_installer/
+    mypy --ignore-missing-imports --no-strict-optional {toxinidir}/tox_poetry_installer/
 
 [testenv:static-tests]
 description = Static formatting and quality enforcement for the tests
 basepython = python3.8
-ingore_errors = true
-deps =
+platform = linux
+ignore_errors = true
+locked_deps =
     pylint
+    pytest
     mypy
-    black
-    reorder-python-imports
-allowlist_externals =
-    bash
 commands =
-    black {toxinidir}/tests/
-    bash -c "reorder-python-imports {toxinidir}/tests/*.py --unclassifiable-application-module tox_poetry_installer"
     pylint --rcfile {toxinidir}/.pylintrc {toxinidir}/tests/
     mypy --ignore-missing-imports --no-strict-optional {toxinidir}/tests/
 
 [testenv:security]
 description = Security checks
 basepython = python3.8
+platform = linux
 ignore_errors = true
-skip_install = true
-deps =
+locked_deps =
     bandit
     safety
     poetry
-allowlist_externals =
-    bash
 commands =
-    bandit --recursive {toxinidir}/tox_poetry_installer.py
-    bash -c "bandit --skip B101 {toxinidir}/tests/*.py"
-    bash -c "poetry export --format requirements.txt --without-hashes --dev | safety check --stdin --bare"
+    bandit --recursive --quiet {toxinidir}/tox_poetry_installer/
+    bandit --recursive --quiet --skip B101 {toxinidir}/tests/
+    poetry export --format requirements.txt --output {envtmpdir}/requirements.txt --without-hashes --dev
+    safety check --bare --file {envtmpdir}/requirements.txt

tox_poetry_installer.py

@@ -1,142 +0,0 @@
-"""Tox plugin for installing environments using Poetry
-
-This plugin makes use of the ``tox_testenv_install_deps`` Tox plugin hook to replace the default
-installation functionality to install dependencies from the Poetry lockfile for the project. It
-does this by using ``poetry`` to read in the lockfile, identify necessary dependencies, and then
-use Poetry's ``PipInstaller`` class to install those packages into the Tox environment.
-"""
-import logging
-from pathlib import Path
-from typing import Dict
-from typing import List
-from typing import Optional
-from typing import Tuple
-
-from poetry.factory import Factory as PoetryFactory
-from poetry.factory import Poetry
-from poetry.installation.pip_installer import PipInstaller as PoetryPipInstaller
-from poetry.io.null_io import NullIO as PoetryNullIO
-from poetry.packages import Package as PoetryPackage
-from poetry.puzzle.provider import Provider as PoetryProvider
-from poetry.utils.env import VirtualEnv as PoetryVirtualEnv
-from tox import hookimpl
-from tox.action import Action as ToxAction
-from tox.venv import VirtualEnv as ToxVirtualEnv
-
-
-__title__ = "tox-poetry-installer"
-__summary__ = "Tox plugin to install Tox environment dependencies using the Poetry backend and lockfile"
-__version__ = "0.1.2"
-__url__ = "https://github.com/enpaul/tox-poetry-installer/"
-__license__ = "MIT"
-__authors__ = ["Ethan Paul <24588726+enpaul@users.noreply.github.com>"]
-
-
-_PEP508_VERSION_DELIMITERS: Tuple[str, ...] = ("~=", "==", "!=", ">", "<")
-
-
-class ToxPoetryInstallerException(Exception):
-    """Error while installing locked dependencies to the test environment"""
-
-
-class NoLockedDependencyError(ToxPoetryInstallerException):
-    """Cannot install a package that is not in the lockfile"""
-
-
-def _make_poetry(venv: ToxVirtualEnv) -> Poetry:
-    """Helper to make a poetry object from a toxenv"""
-    return PoetryFactory().create_poetry(venv.envconfig.config.toxinidir)
-
-
-def _find_locked_dependencies(
-    poetry: Poetry, dependency_name: str
-) -> List[PoetryPackage]:
-    """Using a poetry object identify all dependencies of a specific dependency
-
-    :param poetry: Populated poetry object which can be used to build a populated locked
-                   repository object.
-    :param dependency_name: Bare name (without version) of the dependency to fetch the transient
-                            dependencies of.
-    :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
-              in the list of returned packages.
-    """
-    packages: Dict[str, PoetryPackage] = {
-        package.name: package
-        for package in poetry.locker.locked_repository(True).packages
-    }
-
-    try:
-        top_level = packages[dependency_name]
-
-        def find_transients(name: str) -> List[PoetryPackage]:
-            if name in PoetryProvider.UNSAFE_PACKAGES:
-                return []
-            transients = [packages[name]]
-            for dep in packages[name].requires:
-                transients += find_transients(dep.name)
-            return transients
-
-        return find_transients(top_level.name)
-
-    except KeyError:
-        if any(
-            delimiter in dependency_name for delimiter in _PEP508_VERSION_DELIMITERS
-        ):
-            message = "specifying a version in the tox environment definition is incompatible with installing from a lockfile"
-        else:
-            message = (
-                "no version of the package was found in the current project's lockfile"
-            )
-
-        raise NoLockedDependencyError(
-            f"Cannot install requirement '{dependency_name}': {message}"
-        ) from None
-
-
-@hookimpl
-def tox_testenv_install_deps(
-    venv: ToxVirtualEnv, action: ToxAction
-) -> Optional[List[PoetryPackage]]:
-    """Install the dependencies for the current environment
-
-    Loads the local Poetry environment and the corresponding lockfile then pulls the dependencies
-    specified by the Tox environment. Finally these dependencies are installed into the Tox
-    environment using the Poetry ``PipInstaller`` backend.
-
-    :param venv: Tox virtual environment object with configuration for the local Tox environment.
-    :param action: Tox action object
-    """
-
-    logger = logging.getLogger(__name__)
-
-    if action.name == venv.envconfig.config.isolated_build_env:
-        logger.debug(
-            f"Environment {action.name} is isolated build environment; skipping Poetry-based dependency installation"
-        )
-        return None
-
-    poetry = _make_poetry(venv)
-
-    logger.debug(f"Loaded project pyproject.toml from {poetry.file}")
-
-    dependencies: List[PoetryPackage] = []
-    for env_dependency in venv.envconfig.deps:
-        dependencies += _find_locked_dependencies(poetry, env_dependency.name)
-
-    logger.debug(
-        f"Identified {len(dependencies)} dependencies for environment {action.name}"
-    )
-
-    installer = PoetryPipInstaller(
-        env=PoetryVirtualEnv(path=Path(venv.envconfig.envdir)),
-        io=PoetryNullIO(),
-        pool=poetry.pool,
-    )
-
-    for dependency in dependencies:
-        logger.info(f"Installing environment dependency: {dependency}")
-        installer.install(dependency)
-
-    return dependencies

tox_poetry_installer/__about__.py

@@ -0,0 +1,7 @@
+# pylint: disable=missing-docstring
+__title__ = "tox-poetry-installer"
+__summary__ = "A plugin for Tox that lets you install test environment dependencies from the Poetry lockfile"
+__version__ = "0.8.1"
+__url__ = "https://github.com/enpaul/tox-poetry-installer/"
+__license__ = "MIT"
+__authors__ = ["Ethan Paul <24588726+enpaul@users.noreply.github.com>"]

tox_poetry_installer/__init__.py

@@ -0,0 +1,3 @@
+# pylint: disable=missing-docstring
+from tox_poetry_installer.hooks import tox_addoption
+from tox_poetry_installer.hooks import tox_testenv_install_deps

tox_poetry_installer/_poetry.py

@@ -0,0 +1,39 @@
+"""You've heard of vendoirization, now get ready for internal namespace shadowing
+
+Poetry is an optional dependency of this package explicitly to support the use case of having the
+plugin and the `poetry` package installed to the same python environment; this is most common in
+containers and/or CI. In this case there are two potential problems that can arise in this case:
+
+* The installation of the plugin overwrites the installed version of Poetry resulting in
+  compatibility issues.
+* Running `poetry install --no-dev`, when this plugin is in the dev-deps, results in poetry being
+  uninstalled from the environment.
+
+To support these edge cases, and more broadly to support not messing with a system package manager,
+the `poetry` package dependency is listed as optional dependency. This allows the plugin to be
+installed to the same environment as Poetry and import that same Poetry installation here.
+
+However, simply importing Poetry on the assumption that it is installed breaks another valid use
+case: having this plugin installed alongside Tox when not using a Poetry-based project. To account
+for this the imports in this module are isolated and the resultant import error that would result
+is converted to an internal error that can be caught by callers. Rather than importing this module
+at the module scope it is imported into function scope wherever Poetry components are needed. This
+moves import errors from load time to runtime which allows the plugin to be skipped if Poetry isn't
+installed and/or a more helpful error be raised within the Tox framework.
+"""
+# pylint: disable=unused-import
+import sys
+
+from tox_poetry_installer import exceptions
+
+
+try:
+    from poetry.factory import Factory
+    from poetry.installation.pip_installer import PipInstaller
+    from poetry.io.null_io import NullIO
+    from poetry.poetry import Poetry
+    from poetry.utils.env import VirtualEnv
+except ImportError:
+    raise exceptions.PoetryNotInstalledError(
+        f"No version of Poetry could be imported under the current environment for '{sys.executable}'"
+    ) from None

tox_poetry_installer/constants.py

@@ -0,0 +1,26 @@
+"""Static constants for reference
+
+Rule of thumb: if it's an arbitrary value that will never be changed at runtime, it should go
+in this module.
+
+All constants should be type hinted.
+"""
+from typing import Set
+from typing import Tuple
+
+from tox_poetry_installer import __about__
+
+
+# Valid PEP508 version delimiters. These are used to test whether a given string (specifically a
+# dependency name) is just a package name or also includes a version identifier.
+PEP508_VERSION_DELIMITERS: Tuple[str, ...] = ("~=", "==", "!=", ">", "<")
+
+# Prefix all reporter messages should include to indicate that they came from this module in the
+# console output.
+REPORTER_PREFIX: str = f"{__about__.__title__}:"
+
+# Internal list of packages that poetry has deemed unsafe and are excluded from the lockfile
+UNSAFE_PACKAGES: Set[str] = {"distribute", "pip", "setuptools", "wheel"}
+
+# Number of threads to use for installing dependencies by default
+DEFAULT_INSTALL_THREADS: int = 10

tox_poetry_installer/datatypes.py

@@ -0,0 +1,8 @@
+"""Definitions for typehints/containers used by the plugin"""
+from typing import Dict
+
+from poetry.core.packages import Package as PoetryPackage
+
+
+# Map of package names to the package object
+PackageMap = Dict[str, PoetryPackage]

tox_poetry_installer/exceptions.py

@@ -0,0 +1,43 @@
+"""Custom plugin exceptions
+
+All exceptions should inherit from the common base exception :exc:`ToxPoetryInstallerException`.
+
+::
+
+  ToxPoetryInstallerException
+   +-- SkipEnvironment
+   |    +-- PoetryNotInstalledError
+   +-- LockedDepVersionConflictError
+   +-- LockedDepNotFoundError
+   +-- ExtraNotFoundError
+   +-- LockedDepsRequiredError
+
+"""
+
+
+class ToxPoetryInstallerException(Exception):
+    """Error while installing locked dependencies to the test environment"""
+
+
+class SkipEnvironment(ToxPoetryInstallerException):
+    """Current environment does not meet preconditions and should be skipped by the plugin"""
+
+
+class PoetryNotInstalledError(SkipEnvironment):
+    """No version of Poetry could be imported from the current Python environment"""
+
+
+class LockedDepVersionConflictError(ToxPoetryInstallerException):
+    """Locked dependencies cannot specify an alternate version for installation"""
+
+
+class LockedDepNotFoundError(ToxPoetryInstallerException):
+    """Locked dependency was not found in the lockfile"""
+
+
+class ExtraNotFoundError(ToxPoetryInstallerException):
+    """Project package extra not defined in project's pyproject.toml"""
+
+
+class LockedDepsRequiredError(ToxPoetryInstallerException):
+    """Environment cannot specify unlocked dependencies when locked dependencies are required"""

tox_poetry_installer/hooks.py

@@ -0,0 +1,263 @@
+"""Main hook definition module
+
+All implementations of tox hooks are defined here, as well as any single-use helper functions
+specifically related to implementing the hooks (to keep the size/readability of the hook functions
+themselves manageable).
+"""
+from typing import Optional
+
+import tox
+from tox.action import Action as ToxAction
+from tox.config import Parser as ToxParser
+from tox.venv import VirtualEnv as ToxVirtualEnv
+
+from tox_poetry_installer import __about__
+from tox_poetry_installer import constants
+from tox_poetry_installer import exceptions
+from tox_poetry_installer import installer
+from tox_poetry_installer import logger
+from tox_poetry_installer import utilities
+from tox_poetry_installer.datatypes import PackageMap
+
+
+def _postprocess_install_project_deps(
+    testenv_config, value: Optional[str]  # pylint: disable=unused-argument
+) -> Optional[bool]:
+    """An awful hack to patch on three-state boolean logic to a config parameter
+
+    .. warning: This logic should 100% be removed in the next feature release. It's here to work
+                around a bad design for now but should not persist.
+
+    The bug filed in `#61`_ is caused by a combination of poor design and attempted cleverness. The
+    name of the ``install_project_deps`` config option implies that it has ultimate control over
+    whether the project dependencies are installed to the testenv, but this is not actually correct.
+    What it actually allows the user to do is force the project dependencies to not be installed to
+    an environment that would otherwise install them. This was intended behavior, however the
+    intention was wrong.
+
+    .. _`#61`: https://github.com/enpaul/tox-poetry-installer/issues/61
+
+    In an effort to be clever the plugin automatically skips installing project dependencies when
+    the project package is not installed to the testenv (``skip_install = true``) or if packaging
+    as a whole is disabled (``skipsdist = true``). The intention of this behavior is to install only
+    the expected dependencies to a testenv and no more. However, this conflicts with the
+    ``install_project_deps`` config option, which cannot override this behavior because it defaults
+    to ``True``. In effect, ``install_project_deps = true`` in fact means "automatically
+    determine whether to install project dependencies" and ``install_project_deps = false`` means
+    "never install the project dependencies". This is not ideal and unintuitive.
+
+    To avoid having to make a breaking change this workaround has been added to support three-state
+    logic between ``True``, ``False``, and ``None``. The ``install_project_deps`` option is now
+    parsed by Tox as a string with a default value of ``None``. If the value is not ``None`` then
+    this post processing function will try to convert it to a boolean the same way that Tox's
+    `SectionReader.getbool()`_ method does, raising an error to mimic the default behavior if it
+    can't.
+
+    .. _`SectionReader.getbool()`: https://github.com/tox-dev/tox/blob/f8459218ee5ab5753321b3eb989b7beee5b391ad/src/tox/config/__init__.py#L1724
+
+    The three states for the ``install_project_deps`` setting are:
+    * ``None`` - User did not configure the setting, package dependency installation is
+      determined automatically
+    * ``True`` - User configured the setting to ``True``, package dependencies will be installed
+    * ``False`` - User configured the setting to ``False``, package dependencies will not be
+      installed
+
+    This config option should be deprecated with the 1.0.0 release and instead an option like
+    ``always_install_project_deps`` should be added which overrides the default determination and
+    just installs the project dependencies. The counterpart (``never_install_project_deps``)
+    shouldn't be needed, since I don't think there's a real use case for that.
+    """
+    if value is None:
+        return value
+
+    if value.lower() == "true":
+        return True
+    if value.lower() == "false":
+        return False
+
+    raise tox.exception.ConfigError(
+        f"install_project_deps: boolean value '{value}' needs to be 'True' or 'False'"
+    )
+
+
+@tox.hookimpl
+def tox_addoption(parser: ToxParser):
+    """Add required configuration options to the tox INI file
+
+    Adds the ``require_locked_deps`` configuration option to the venv to check whether all
+    dependencies should be treated as locked or not.
+    """
+
+    parser.add_argument(
+        "--require-poetry",
+        action="store_true",
+        dest="require_poetry",
+        help="(deprecated) Trigger a failure if Poetry is not available to Tox",
+    )
+
+    parser.add_argument(
+        "--parallelize-locked-install",
+        type=int,
+        dest="parallelize_locked_install",
+        default=None,
+        help="(deprecated) Number of worker threads to use for installing dependencies from the Poetry lockfile in parallel",
+    )
+
+    parser.add_argument(
+        "--parallel-install-threads",
+        type=int,
+        dest="parallel_install_threads",
+        default=constants.DEFAULT_INSTALL_THREADS,
+        help="Number of locked dependencies to install simultaneously; set to 0 to disable parallel installation",
+    )
+
+    parser.add_testenv_attribute(
+        name="install_dev_deps",
+        type="bool",
+        default=False,
+        help="Automatically install all Poetry development dependencies to the environment",
+    )
+
+    parser.add_testenv_attribute(
+        name="install_project_deps",
+        type="string",
+        default=None,
+        help="Automatically install all Poetry primary dependencies to the environment",
+        postprocess=_postprocess_install_project_deps,
+    )
+
+    parser.add_testenv_attribute(
+        name="require_locked_deps",
+        type="bool",
+        default=False,
+        help="Require all dependencies in the environment be installed using the Poetry lockfile",
+    )
+
+    parser.add_testenv_attribute(
+        name="require_poetry",
+        type="bool",
+        default=False,
+        help="Trigger a failure if Poetry is not available to Tox",
+    )
+
+    parser.add_testenv_attribute(
+        name="locked_deps",
+        type="line-list",
+        help="List of locked dependencies to install to the environment using the Poetry lockfile",
+    )
+
+
+@tox.hookimpl
+def tox_testenv_install_deps(venv: ToxVirtualEnv, action: ToxAction) -> Optional[bool]:
+    """Install the dependencies for the current environment
+
+    Loads the local Poetry environment and the corresponding lockfile then pulls the dependencies
+    specified by the Tox environment. Finally these dependencies are installed into the Tox
+    environment using the Poetry ``PipInstaller`` backend.
+
+    :param venv: Tox virtual environment object with configuration for the local Tox environment.
+    :param action: Tox action object
+    """
+
+    try:
+        poetry = utilities.check_preconditions(venv, action)
+    except exceptions.SkipEnvironment as err:
+        if isinstance(err, exceptions.PoetryNotInstalledError) and (
+            venv.envconfig.config.option.require_poetry or venv.envconfig.require_poetry
+        ):
+            venv.status = err.__class__.__name__
+            logger.error(str(err))
+            return False
+        logger.info(str(err))
+        return None
+
+    logger.info(f"Loaded project pyproject.toml from {poetry.file}")
+
+    virtualenv = utilities.convert_virtualenv(venv)
+
+    if not poetry.locker.is_fresh():
+        logger.warning(
+            f"The Poetry lock file is not up to date with the latest changes in {poetry.file}"
+        )
+
+    try:
+        if venv.envconfig.require_locked_deps and venv.envconfig.deps:
+            raise exceptions.LockedDepsRequiredError(
+                f"Unlocked dependencies '{venv.envconfig.deps}' specified for environment '{venv.name}' which requires locked dependencies"
+            )
+
+        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_deps(packages, virtualenv, poetry)
+            logger.info(
+                f"Identified {len(dev_deps)} development dependencies to install to env"
+            )
+        else:
+            dev_deps = []
+            logger.info("Env does not install development dependencies, skipping")
+
+        env_deps = utilities.find_additional_deps(
+            packages, virtualenv, poetry, venv.envconfig.locked_deps
+        )
+
+        logger.info(
+            f"Identified {len(env_deps)} environment dependencies to install to env"
+        )
+
+        install_project_deps = (
+            venv.envconfig.install_project_deps
+            if venv.envconfig.install_project_deps is not None
+            else (
+                not venv.envconfig.skip_install and not venv.envconfig.config.skipsdist
+            )
+        )
+
+        if install_project_deps:
+            project_deps = utilities.find_project_deps(
+                packages, virtualenv, poetry, venv.envconfig.extras
+            )
+            logger.info(
+                f"Identified {len(project_deps)} project dependencies to install to env"
+            )
+        else:
+            project_deps = []
+            logger.info("Env does not install project package dependencies, skipping")
+    except exceptions.ToxPoetryInstallerException as err:
+        venv.status = err.__class__.__name__
+        logger.error(str(err))
+        return False
+    except Exception as err:
+        venv.status = "InternalError"
+        logger.error(f"Internal plugin error: {err}")
+        raise err
+
+    dependencies = dev_deps + env_deps + project_deps
+    if (
+        venv.envconfig.config.option.parallel_install_threads
+        != constants.DEFAULT_INSTALL_THREADS
+    ):
+        parallel_threads = venv.envconfig.config.option.parallel_install_threads
+    else:
+        parallel_threads = (
+            venv.envconfig.config.option.parallelize_locked_install
+            if venv.envconfig.config.option.parallelize_locked_install is not None
+            else constants.DEFAULT_INSTALL_THREADS
+        )
+    log_parallel = f" (using {parallel_threads} threads)" if parallel_threads else ""
+
+    action.setactivity(
+        __about__.__title__,
+        f"Installing {len(dependencies)} dependencies from Poetry lock file{log_parallel}",
+    )
+    installer.install(
+        poetry,
+        venv,
+        dependencies,
+        parallel_threads,
+    )
+
+    return venv.envconfig.require_locked_deps or None

tox_poetry_installer/installer.py

@@ -0,0 +1,73 @@
+"""Funcationality for performing virtualenv installation"""
+# Silence this one globally to support the internal function imports for the proxied poetry module.
+# See the docstring in 'tox_poetry_installer._poetry' for more context.
+# pylint: disable=import-outside-toplevel
+import concurrent.futures
+import contextlib
+import typing
+from typing import Sequence
+from typing import Set
+
+from poetry.core.packages import Package as PoetryPackage
+from tox.venv import VirtualEnv as ToxVirtualEnv
+
+from tox_poetry_installer import logger
+from tox_poetry_installer import utilities
+
+if typing.TYPE_CHECKING:
+    from tox_poetry_installer import _poetry
+
+
+def install(
+    poetry: "_poetry.Poetry",
+    venv: ToxVirtualEnv,
+    packages: Sequence[PoetryPackage],
+    parallels: int = 0,
+):
+    """Install a bunch of packages to a virtualenv
+
+    :param poetry: Poetry object the packages were sourced from
+    :param venv: Tox virtual environment to install the packages to
+    :param packages: List of packages to install to the virtual environment
+    :param parallels: Number of parallel processes to use for installing dependency packages, or
+                      ``None`` to disable parallelization.
+    """
+    from tox_poetry_installer import _poetry
+
+    logger.info(
+        f"Installing {len(packages)} packages to environment at {venv.envconfig.envdir}"
+    )
+
+    pip = _poetry.PipInstaller(
+        env=utilities.convert_virtualenv(venv),
+        io=_poetry.NullIO(),
+        pool=poetry.pool,
+    )
+
+    installed: Set[PoetryPackage] = set()
+
+    @contextlib.contextmanager
+    def _optional_parallelize():
+        """A bit of cheat, really
+
+        A context manager that exposes a common interface for the caller that optionally
+        enables/disables the usage of the parallel thread pooler depending on the value of
+        the ``parallels`` parameter.
+        """
+        if parallels > 0:
+            with concurrent.futures.ThreadPoolExecutor(
+                max_workers=parallels
+            ) as executor:
+                yield executor.submit
+        else:
+            yield lambda func, arg: func(arg)
+
+    with _optional_parallelize() as executor:
+        for dependency in packages:
+            if dependency not in installed:
+                installed.add(dependency)
+                logger.debug(f"Installing {dependency}")
+                executor(pip.install, dependency)
+            else:
+                logger.debug(f"Skipping {dependency}, already installed")
+        logger.debug("Waiting for installs to finish...")

tox_poetry_installer/logger.py

@@ -0,0 +1,29 @@
+"""Logging wrappers to reduce duplication elsewhere
+
+Calling ``tox.reporter.something()`` and having to format a string with the prefix
+gets really old fast, but more importantly it also makes the flow of the main code
+more difficult to follow because of the added complexity.
+"""
+import tox
+
+from tox_poetry_installer import constants
+
+
+def error(message: str):
+    """Wrapper around :func:`tox.reporter.error`"""
+    tox.reporter.error(f"{constants.REPORTER_PREFIX} {message}")
+
+
+def warning(message: str):
+    """Wrapper around :func:`tox.reporter.warning`"""
+    tox.reporter.warning(f"{constants.REPORTER_PREFIX} {message}")
+
+
+def info(message: str):
+    """Wrapper around :func:`tox.reporter.verbosity1`"""
+    tox.reporter.verbosity1(f"{constants.REPORTER_PREFIX} {message}")
+
+
+def debug(message: str):
+    """Wrapper around :func:`tox.reporter.verbosity2`"""
+    tox.reporter.verbosity2(f"{constants.REPORTER_PREFIX} {message}")

tox_poetry_installer/utilities.py

@@ -0,0 +1,235 @@
+"""Helper utility functions, usually bridging Tox and Poetry functionality"""
+# Silence this one globally to support the internal function imports for the proxied poetry module.
+# See the docstring in 'tox_poetry_installer._poetry' for more context.
+# pylint: disable=import-outside-toplevel
+import typing
+from pathlib import Path
+from typing import List
+from typing import Sequence
+from typing import Set
+from typing import Union
+
+from poetry.core.packages import Dependency as PoetryDependency
+from poetry.core.packages import Package as PoetryPackage
+from tox.action import Action as ToxAction
+from tox.venv import VirtualEnv as ToxVirtualEnv
+
+from tox_poetry_installer import constants
+from tox_poetry_installer import exceptions
+from tox_poetry_installer import logger
+from tox_poetry_installer.datatypes import PackageMap
+
+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}'"
+        )
+
+    if venv.envconfig.config.option.require_poetry:
+        logger.warning(
+            "DEPRECATION: The '--require-poetry' runtime option is deprecated and will be "
+            "removed in version 1.0.0. Please update test environments that require Poetry to "
+            "set the 'require_poetry = true' option in tox.ini"
+        )
+
+    if venv.envconfig.config.option.parallelize_locked_install is not None:
+        logger.warning(
+            "DEPRECATION: The '--parallelize-locked-install' option is deprecated and will "
+            "be removed in version 1.0.0. Please use the '--parallel-install-threads' option."
+        )
+
+    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 convert_virtualenv(venv: ToxVirtualEnv) -> "_poetry.VirtualEnv":
+    """Convert a Tox venv to a Poetry venv
+
+    :param venv: Tox ``VirtualEnv`` object representing a tox virtual environment
+    :returns: Poetry ``VirtualEnv`` object representing a poetry virtual environment
+    """
+    from tox_poetry_installer import _poetry
+
+    return _poetry.VirtualEnv(path=Path(venv.envconfig.envdir))
+
+
+def identify_transients(
+    dep: Union[PoetryDependency, str],
+    packages: PackageMap,
+    venv: "_poetry.VirtualEnv",
+    allow_missing: Sequence[str] = (),
+) -> List[PoetryPackage]:
+    """Using a pool of packages, identify all transient dependencies of a given package name
+
+    :param dep: Either the Poetry dependency or the dependency's bare package name to recursively
+                identify the transient dependencies of
+    :param packages: All packages from the lockfile to use for identifying dependency relationships.
+    :param venv: Poetry virtual environment to use for package compatibility checks
+    :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 specified by the ``dep`` parameter will
+              be included in the returned list of packages.
+    """
+    transients: List[PoetryPackage] = []
+    searched: Set[str] = set()
+
+    def _deps_of_dep(transient: PoetryDependency):
+        searched.add(transient.name)
+
+        if venv.is_valid_for_marker(transient.marker):
+            for requirement in packages[transient.name].requires:
+                if requirement.name not in searched:
+                    _deps_of_dep(requirement)
+            logger.debug(f"Including {transient} for installation")
+            transients.append(packages[transient.name])
+        else:
+            logger.debug(f"Skipping {transient}: package requires {transient.marker}")
+
+    try:
+        if isinstance(dep, str):
+            dep = packages[dep].to_dependency()
+
+        _deps_of_dep(dep)
+    except KeyError as err:
+        dep_name = err.args[0]
+
+        if dep_name in constants.UNSAFE_PACKAGES:
+            logger.warning(
+                f"Installing package '{dep_name}' using Poetry is not supported and will be skipped"
+            )
+            logger.debug(f"Skipping {dep_name}: designated unsafe by Poetry")
+            return []
+
+        if dep_name in allow_missing:
+            logger.debug(f"Skipping {dep_name}: package is allowed to be unlocked")
+            return []
+
+        if any(
+            delimiter in dep_name for delimiter in constants.PEP508_VERSION_DELIMITERS
+        ):
+            raise exceptions.LockedDepVersionConflictError(
+                f"Locked dependency '{dep_name}' cannot include version specifier"
+            ) from None
+
+        raise exceptions.LockedDepNotFoundError(
+            f"No version of locked dependency '{dep_name}' found in the project lockfile"
+        ) from None
+
+    return transients
+
+
+def find_project_deps(
+    packages: PackageMap,
+    venv: "_poetry.VirtualEnv",
+    poetry: "_poetry.Poetry",
+    extras: Sequence[str] = (),
+) -> List[PoetryPackage]:
+    """Find the root project dependencies
+
+    Recursively identify the dependencies of the root project package
+
+    :param packages: Mapping of all locked package names to their corresponding package object
+    :param venv: Poetry virtual environment to use for package compatibility checks
+    :param poetry: Poetry object for the current project
+    :param extras: Sequence of extra names to include the dependencies of
+    """
+
+    base_deps: List[PoetryPackage] = [
+        packages[item.name]
+        for item in poetry.package.requires
+        if not item.is_optional()
+    ]
+
+    extra_deps: List[PoetryPackage] = []
+    for extra in extras:
+        logger.info(f"Processing project extra '{extra}'")
+        try:
+            extra_deps += [packages[item.name] for item in poetry.package.extras[extra]]
+        except KeyError:
+            raise exceptions.ExtraNotFoundError(
+                f"Environment specifies project extra '{extra}' which was not found in the lockfile"
+            ) from None
+
+    dependencies: List[PoetryPackage] = []
+    for dep in base_deps + extra_deps:
+        dependencies += identify_transients(
+            dep.name.lower(), packages, venv, allow_missing=[poetry.package.name]
+        )
+
+    return dependencies
+
+
+def find_additional_deps(
+    packages: PackageMap,
+    venv: "_poetry.VirtualEnv",
+    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 venv: Poetry virtual environment to use for package compatibility checks
+    :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(
+            dep_name.lower(), packages, venv, allow_missing=[poetry.package.name]
+        )
+
+    return deps
+
+
+def find_dev_deps(
+    packages: PackageMap, venv: "_poetry.VirtualEnv", poetry: "_poetry.Poetry"
+) -> List[PoetryPackage]:
+    """Find the dev dependencies
+
+    Recursively identify the Poetry dev dependencies
+
+    :param packages: Mapping of all locked package names to their corresponding package object
+    :param venv: Poetry virtual environment to use for package compatibility checks
+    :param poetry: Poetry object for the current project
+    """
+    return find_additional_deps(
+        packages,
+        venv,
+        poetry,
+        poetry.pyproject.data["tool"]["poetry"].get("dev-dependencies", {}).keys(),
+    )