diff options
68 files changed, 4551 insertions, 0 deletions
diff --git a/.dockerignore b/.dockerignore new file mode 100644 index 0000000..de4edc8 --- /dev/null +++ b/.dockerignore @@ -0,0 +1,6 @@ +.tox +.*_cache +*.egg-info +Dockerfile +build +dist diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS new file mode 100644 index 0000000..ca06f98 --- /dev/null +++ b/.github/CODEOWNERS @@ -0,0 +1 @@ +* @FFY00 @gaborbernat @layday @henryiii diff --git a/.github/dependabot.yml b/.github/dependabot.yml new file mode 100644 index 0000000..1230149 --- /dev/null +++ b/.github/dependabot.yml @@ -0,0 +1,6 @@ +version: 2 +updates: + - package-ecosystem: "github-actions" + directory: "/" + schedule: + interval: "daily" diff --git a/.github/workflows/check.yml b/.github/workflows/check.yml new file mode 100644 index 0000000..c6e9bfb --- /dev/null +++ b/.github/workflows/check.yml @@ -0,0 +1,33 @@ +name: check +on: + push: + branches: + - main + pull_request: + branches: + - main + schedule: + - cron: "0 8 * * *" + +jobs: + docs: + runs-on: ubuntu-latest + env: + PY_COLORS: 1 + TOX_PARALLEL_NO_SPINNER: 1 + steps: + - uses: actions/checkout@v3 + + - name: Setup Python 3.9 + uses: actions/setup-python@v4 + with: + python-version: 3.9 + + - name: Install tox + run: python -m pip install tox + + - name: Setup run environment + run: tox -vv --notest -e docs + + - name: Run check for docs + run: tox -e docs --skip-pkg-install diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml new file mode 100644 index 0000000..21e1321 --- /dev/null +++ b/.github/workflows/test.yml @@ -0,0 +1,131 @@ +name: test +on: + push: + branches: + - main + paths-ignore: + - "docs/**" + - "*.md" + pull_request: + branches: + - main + paths-ignore: + - "docs/**" + - "*.md" + schedule: + - cron: "0 8 * * *" + workflow_dispatch: + +concurrency: + group: test-${{ github.ref }} + cancel-in-progress: true + +jobs: + pytest: + runs-on: ${{ matrix.os }}-latest + env: + PYTEST_ADDOPTS: "--run-integration --showlocals -vv --durations=10 --reruns 5 --only-rerun subprocess.CalledProcessError" + strategy: + fail-fast: false + matrix: + os: + - ubuntu + - macos + - windows + py: + - "pypy-3.7" + - "pypy-3.8" + - "pypy-3.9" + - "3.11" + - "3.10" + - "3.9" + - "3.8" + - "3.7" + - "3.6" + tox-target: + - "tox" + - "min" + + steps: + - uses: actions/checkout@v3 + with: + fetch-depth: 0 + + - name: Setup python for test ${{ matrix.py }} + uses: actions/setup-python@v4 + with: + python-version: ${{ matrix.py }} + + - name: Pick environment to run + run: | + import platform + import os + import sys + + if platform.python_implementation() == "PyPy": + base = f"pypy{sys.version_info.major}{sys.version_info.minor}" + else: + base = f"py{sys.version_info.major}{sys.version_info.minor}" + env = f"BASE={base}\n" + print(f"Picked:\n{env}for {sys.version}") + with open(os.environ["GITHUB_ENV"], "a", encoding="utf-8") as file: + file.write(env) + shell: python + + - name: Setup python for tox + uses: actions/setup-python@v4 + with: + python-version: 3.9 + + - name: Install tox + run: python -m pip install tox + + - name: Run test suite via tox + if: matrix.tox-target == 'tox' + run: | + tox -vv --notest -e ${{env.BASE}} + tox -e ${{env.BASE}} --skip-pkg-install + + - name: Run minimum version test + if: matrix.tox-target == 'min' + run: tox -e ${{env.BASE}}-${{ matrix.tox-target }} + + - name: Run path test + if: matrix.tox-target == 'tox' && matrix.py == '3.10' + run: tox -e path + + - name: Combine coverage files + if: always() + run: tox -e coverage + + - uses: codecov/codecov-action@v3 + if: always() + env: + PYTHON: ${{ matrix.python }} + with: + file: ./.tox/coverage.xml + flags: tests + env_vars: PYTHON + name: ${{ matrix.py }} - ${{ matrix.os }} + + type: + runs-on: ubuntu-latest + env: + PY_COLORS: 1 + TOX_PARALLEL_NO_SPINNER: 1 + steps: + - uses: actions/checkout@v3 + + - name: Setup Python 3.9 + uses: actions/setup-python@v4 + with: + python-version: 3.9 + + - name: Install tox + run: python -m pip install tox + + - name: Setup run environment + run: tox -vv --notest -e type + + - name: Run check for type + run: tox -e type --skip-pkg-install diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..ac76f5d --- /dev/null +++ b/.gitignore @@ -0,0 +1,25 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] + +# Distribution / packaging +build/lib/ +dist/ +*.egg-info/ +.eggs + +# Testing and coverage +.cache +.nox/ +.mypy_cache/ +.pytest_cache +htmlcov/ +.coverage +coverage.xml +tests/integration/ +.integration-sources +.tox +Dockerfile + +# Restore src/build in case user ignores 'build' +!src/build diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml new file mode 100644 index 0000000..7c72733 --- /dev/null +++ b/.pre-commit-config.yaml @@ -0,0 +1,68 @@ +ci: + autofix_prs: false + autoupdate_commit_msg: "pre-commit: bump repositories" + +repos: + - repo: https://github.com/pre-commit/pre-commit-hooks + rev: v4.3.0 + hooks: + - id: check-ast + - id: check-builtin-literals + - id: check-docstring-first + - id: check-merge-conflict + - id: check-yaml + - id: check-toml + exclude: tests/packages/test-(bad-syntax|no-permission)/pyproject.toml + - id: debug-statements + - id: end-of-file-fixer + - id: trailing-whitespace + - id: double-quote-string-fixer + - repo: https://github.com/asottile/pyupgrade + rev: v3.1.0 + hooks: + - id: pyupgrade + args: ["--py36-plus"] + - repo: https://github.com/psf/black + rev: 22.10.0 + hooks: + - id: black + - repo: https://github.com/asottile/blacken-docs + rev: v1.12.1 + hooks: + - id: blacken-docs + additional_dependencies: [black==22.6] + - repo: https://github.com/pre-commit/mirrors-prettier + rev: "v3.0.0-alpha.2" + hooks: + - id: prettier + - repo: https://github.com/PyCQA/isort + rev: 5.10.1 + hooks: + - id: isort + - repo: https://github.com/asottile/setup-cfg-fmt + rev: v2.1.0 + hooks: + - id: setup-cfg-fmt + args: [--include-version-classifiers, --max-py-version=3.11] + - repo: https://github.com/PyCQA/flake8 + rev: "5.0.4" + hooks: + - id: flake8 + additional_dependencies: ["flake8-bugbear==22.7.1"] + language_version: python3.9 + - repo: https://github.com/codespell-project/codespell + rev: "v2.2.2" + hooks: + - id: codespell + args: ["-L", "sur"] + - repo: https://github.com/pre-commit/pygrep-hooks + rev: "v1.9.0" + hooks: + - id: python-check-blanket-noqa + - id: python-check-blanket-type-ignore + - id: python-no-log-warn + - id: python-no-eval + - id: python-use-type-annotations + - id: rst-backticks + - id: rst-directive-colons + - id: rst-inline-touching-normal diff --git a/.readthedocs.yml b/.readthedocs.yml new file mode 100644 index 0000000..d115133 --- /dev/null +++ b/.readthedocs.yml @@ -0,0 +1,12 @@ +version: 2 + +build: + os: ubuntu-20.04 + tools: + python: "3.10" + +python: + install: + - method: pip + path: . + extra_requirements: [docs] diff --git a/CHANGELOG.rst b/CHANGELOG.rst new file mode 100644 index 0000000..3e6bde6 --- /dev/null +++ b/CHANGELOG.rst @@ -0,0 +1,330 @@ ++++++++++ +Changelog ++++++++++ + + +0.9.0 (2022-10-27) +================== + +- Hide a Python 3.11.0 unavoidable warning with venv (`PR #527`_) +- Fix infinite recursion error in ``check_dependency`` with circular + dependencies (`PR #512`_, Fixes `#511`_) +- Only import colorama on Windows (`PR #494`_, Fixes `#493`_) +- Flush output more often to reduce interleaved output (`PR #494`_) +- Small API cleanup, like better ``__all__`` and srcdir being read only. (`PR #477`_) +- Only use ``importlib_metadata`` when needed (`PR #401`_) +- Clarify in printout when build dependencies are being installed (`PR #514`_) + +.. _PR #401: https://github.com/pypa/build/pull/401 +.. _PR #477: https://github.com/pypa/build/pull/477 +.. _PR #494: https://github.com/pypa/build/pull/494 +.. _PR #512: https://github.com/pypa/build/pull/512 +.. _PR #514: https://github.com/pypa/build/pull/514 +.. _PR #527: https://github.com/pypa/build/pull/527 +.. _#493: https://github.com/pypa/build/issues/493 +.. _#511: https://github.com/pypa/build/issues/511 + + +0.8.0 (2022-05-22) +================== + +- Accept ``os.PathLike[str]`` in addition to ``str`` for paths in public + API (`PR #392`_, Fixes `#372`_) +- Add schema validation for ``build-system`` table to check conformity + with PEP 517 and PEP 518 (`PR #365`_, Fixes `#364`_) +- Better support for Python 3.11 (sysconfig schemes `PR #434`_, `PR #463`_, tomllib `PR #443`_, warnings `PR #420`_) +- Improved error printouts (`PR #442`_) +- Avoid importing packaging unless needed (`PR #395`_, Fixes `#393`_) + + +Breaking Changes +---------------- + +- Failure to create a virtual environment in the ``build.env`` module now raises + ``build.FailedProcessError`` (`PR #442`_) + +.. _PR #365: https://github.com/pypa/build/pull/365 +.. _PR #392: https://github.com/pypa/build/pull/392 +.. _PR #395: https://github.com/pypa/build/pull/395 +.. _PR #420: https://github.com/pypa/build/pull/420 +.. _PR #434: https://github.com/pypa/build/pull/434 +.. _PR #442: https://github.com/pypa/build/pull/442 +.. _PR #443: https://github.com/pypa/build/pull/443 +.. _PR #463: https://github.com/pypa/build/pull/463 +.. _#364: https://github.com/pypa/build/issues/364 +.. _#372: https://github.com/pypa/build/issues/372 +.. _#393: https://github.com/pypa/build/pull/393 + + +0.7.0 (2021-09-16) +================== + +- Add ``build.util`` module with an high-level utility API (`PR #340`_) + +.. _PR #340: https://github.com/pypa/build/pull/340 + + +0.6.0.post1 (2021-08-05) +======================== + +- Fix compatibility with Python 3.6 and 3.7 (`PR #339`_, Fixes `#338`_) + +.. _PR #339: https://github.com/pypa/build/pull/339 +.. _#338: https://github.com/pypa/build/issues/338 + + + +0.6.0 (2021-08-02) +================== + +- Improved output (`PR #333`_, Fixes `#142`_) +- The CLI now honors `NO_COLOR`_ (`PR #333`_) +- The CLI can now be forced to colorize the output by setting the ``FORCE_COLOR`` environment variable (`PR #335`_) +- Added logging to ``build`` and ``build.env`` (`PR #333`_) +- Switch to a TOML v1 compliant parser (`PR #336`_, Fixes `#308`_) + + +Breaking Changes +---------------- + +- Dropped support for Python 2 and 3.5. + +.. _PR #333: https://github.com/pypa/build/pull/333 +.. _PR #335: https://github.com/pypa/build/pull/335 +.. _PR #336: https://github.com/pypa/build/pull/336 +.. _#142: https://github.com/pypa/build/issues/142 +.. _#308: https://github.com/pypa/build/issues/308 +.. _NO_COLOR: https://no-color.org + + + +0.5.1 (2021-06-22) +================== + +- Fix invoking the backend on an inexistent output directory with multiple levels (`PR #318`_, Fixes `#316`_) +- When building wheels via sdists, use an isolated temporary directory (`PR #321`_, Fixes `#320`_) + +.. _PR #318: https://github.com/pypa/build/pull/318 +.. _PR #321: https://github.com/pypa/build/pull/321 +.. _#316: https://github.com/pypa/build/issues/316 +.. _#320: https://github.com/pypa/build/issues/320 + + + +0.5.0 (2021-06-19) +================== + +- Add ``ProjectBuilder.metadata_path`` helper (`PR #303`_, Fixes `#301`_) +- Added a ``build.__main__.build_package_via_sdist`` method (`PR #304`_) +- Use appropriate installation scheme for Apple Python venvs (`PR #314`_, Fixes `#310`_) + +Breaking Changes +---------------- + +- Binary distributions are now built via the sdist by default in the CLI (`PR #304`_, Fixes `#257`_) + - ``python -m build`` will now build a sdist, extract it, and build a wheel from the source +- As a side-effect of `PR #304`_, ``build.__main__.build_package`` no longer does CLI error handling (print nice message and exit the program) +- Importing ``build.__main__`` no longer has any side-effects, it no longer overrides ``warnings.showwarning`` or runs ``colorama.init`` on import (`PR #312`_) + +.. _PR #303: https://github.com/pypa/build/pull/303 +.. _PR #304: https://github.com/pypa/build/pull/304 +.. _PR #312: https://github.com/pypa/build/pull/312 +.. _PR #314: https://github.com/pypa/build/pull/314 +.. _#257: https://github.com/pypa/build/issues/257 +.. _#301: https://github.com/pypa/build/issues/301 +.. _#310: https://github.com/pypa/build/issues/310 + + + +0.4.0 (2021-05-23) +================== + +- Validate that the supplied source directory is valid (`PR #260`_, Fixes `#259`_) +- Set and test minimum versions of build's runtime dependencies (`PR #267`_, Fixes `#263`_) +- Use symlinks on creating venv's when available (`PR #274`_, Fixes `#271`_) +- Error sooner if pip upgrade is required and fails (`PR #288`_, Fixes `#256`_) +- Add a ``runner`` argument to ``ProjectBuilder`` (`PR #290`_, Fixes `#289`_) +- Hide irrelevant ``pep517`` error traceback and improve error messages (`PR #296`_) +- Try to use ``colorama`` to fix colors on Windows (`PR #300`_) + +.. _PR #260: https://github.com/pypa/build/pull/260 +.. _PR #267: https://github.com/pypa/build/pull/267 +.. _PR #274: https://github.com/pypa/build/pull/274 +.. _PR #288: https://github.com/pypa/build/pull/288 +.. _PR #290: https://github.com/pypa/build/pull/290 +.. _PR #296: https://github.com/pypa/build/pull/296 +.. _PR #300: https://github.com/pypa/build/pull/300 +.. _#256: https://github.com/pypa/build/issues/256 +.. _#259: https://github.com/pypa/build/issues/259 +.. _#263: https://github.com/pypa/build/issues/263 +.. _#271: https://github.com/pypa/build/issues/271 +.. _#289: https://github.com/pypa/build/issues/289 + +Breaking Changes +---------------- + +- As a side-effect of `PR #260`_, projects not containing either a ``pyproject.toml`` or ``setup.py`` will be reported as invalid. This affects projects specifying only a ``setup.cfg``, such projects are recommended to add a ``pyproject.toml``. The new behavior is on par with what pip currently does, so if you are affected by this, your project should not be pip installable. +- The ``--skip-dependencies`` option has been renamed to ``--skip-dependency-check`` (`PR #297`_) +- The ``skip_dependencies`` argument of ``build.__main__.build_package`` has been renamed to ``skip_dependency_check`` (`PR #297`_) +- ``build.ConfigSettings`` has been renamed to ``build.ConfigSettingsType`` (`PR #298`_) +- ``build.ProjectBuilder.build_dependencies`` to ``build.ProjectBuilder.build_system_requires`` (`PR #284`_, Fixes `#182`_) +- ``build.ProjectBuilder.get_dependencies`` to ``build.ProjectBuilder.get_requires_for_build`` (`PR #284`_, Fixes `#182`_) + +.. _PR #284: https://github.com/pypa/build/pull/284 +.. _PR #297: https://github.com/pypa/build/pull/297 +.. _PR #298: https://github.com/pypa/build/pull/298 +.. _#182: https://github.com/pypa/build/issues/182 + + + +0.3.1 (2021-03-09) +================== + +- Support direct usage from pipx run in 0.16.1.0+ (`PR #247`_) +- Use UTF-8 encoding when reading pyproject.toml (`PR #251`_, Fixes `#250`_) + +.. _PR #247: https://github.com/pypa/build/pull/247 +.. _PR #251: https://github.com/pypa/build/pull/251 +.. _#250: https://github.com/pypa/build/issues/250 + + + +0.3.0 (2021-02-19) +================== + +- Upgrade pip based on venv pip version, avoids error on Debian Python 3.6.5-3.8 or issues installing wheels on Big Sur (`PR #229`_, `PR #230`_, Fixes `#228`_) +- Build dependencies in isolation, instead of in the build environment (`PR #232`_, Fixes `#231`_) +- Fallback on venv if virtualenv is too old (`PR #241`_) +- Add metadata preparation hook (`PR #217`_, Fixes `#130`_) + +.. _PR #217: https://github.com/pypa/build/pull/217 +.. _PR #229: https://github.com/pypa/build/pull/229 +.. _PR #230: https://github.com/pypa/build/pull/230 +.. _PR #232: https://github.com/pypa/build/pull/232 +.. _PR #241: https://github.com/pypa/build/pull/241 +.. _#130: https://github.com/pypa/build/issues/130 +.. _#228: https://github.com/pypa/build/issues/228 +.. _#231: https://github.com/pypa/build/issues/231 + + + +0.2.1 (2021-02-09) +================== + +- Fix error from unrecognised pip flag on Python 3.6.0 to 3.6.5 (`PR #227`_, Fixes `#226`_) + +.. _PR #227: https://github.com/pypa/build/pull/227 +.. _#226: https://github.com/pypa/build/issues/226 + + + +0.2.0 (2021-02-07) +================== + +- Check dependencies recursively (`PR #183`_, Fixes `#25`_) +- Build wheel and sdist distributions in separate environments, as they may have different dependencies (`PR #195`_, Fixes `#194`_) +- Add support for pre-releases in ``check_dependency`` (`PR #204`_, Fixes `#191`_) +- Fixes console scripts not being available during build (`PR #221`_, Fixes `#214`_) +- Do not add the default backend requirements to ``requires`` when no backend is specified (`PR #177`_, Fixes `#107`_) +- Return the sdist name in ``ProjectBuild.build`` (`PR #197`_) +- Improve documentation (`PR #178`_, `PR #203`_) +- Add changelog (`PR #219`_, Fixes `#169`_) + +Breaking changes +---------------- + +- Move ``config_settings`` argument to the hook calls (`PR #218`_, Fixes `#216`_) + +.. _PR #177: https://github.com/pypa/build/pull/177 +.. _PR #178: https://github.com/pypa/build/pull/178 +.. _PR #183: https://github.com/pypa/build/pull/183 +.. _PR #195: https://github.com/pypa/build/pull/195 +.. _PR #197: https://github.com/pypa/build/pull/197 +.. _PR #203: https://github.com/pypa/build/pull/203 +.. _PR #204: https://github.com/pypa/build/pull/204 +.. _PR #218: https://github.com/pypa/build/pull/218 +.. _PR #219: https://github.com/pypa/build/pull/219 +.. _PR #221: https://github.com/pypa/build/pull/221 +.. _#25: https://github.com/pypa/build/issues/25 +.. _#107: https://github.com/pypa/build/issues/107 +.. _#109: https://github.com/pypa/build/issues/109 +.. _#169: https://github.com/pypa/build/issues/169 +.. _#191: https://github.com/pypa/build/issues/191 +.. _#194: https://github.com/pypa/build/issues/194 +.. _#214: https://github.com/pypa/build/issues/214 +.. _#216: https://github.com/pypa/build/issues/216 + + + +0.1.0 (2020-10-29) +================== + +- Moved the upstream to PyPA +- Fixed building with isolation in a virtual environment +- Added env.IsolatedEnv abstract class +- Added env.IsolatedEnvBuilder (replaces env.IsolatedEnvironment usages) +- Added python_executable argument to the ProjectBuilder constructor +- Added --version/-V option to the CLI +- Added support for Python 3.9 +- Added py.typed marker +- Various miscellaneous fixes in the virtual environment creation +- Many general improvements in the documentation +- Documentation moved to the furo theme +- Updated the CoC to the PSF CoC, which PyPA has adopted + +Breaking changes +---------------- + +- Renamed the entrypoint script to pyproject-build +- Removed default arguments from all paths in ProjectBuilder +- Removed ProjectBuilder.hook +- Renamed __main__.build to __main__.build_package +- Changed the default outdir value to {srcdir}/dest +- Removed env.IsolatedEnvironment + + + +0.0.4 (2020-09-08) +================== + +- Packages are now built in isolation by default +- Added --no-isolation/-n flag to build in the current environment +- Add --config-setting/-C option to pass options to the backend +- Add IsolatedEnvironment class +- Fix creating the output directory if it doesn't exit +- Fix building with in-tree backends +- Fix broken entrypoint script (python-build) +- Add warning about incomplete verification when verifying extras +- Automatically detect typos in the build system table +- Minor documentation improvements + + + +0.0.3.1 (2020-06-10) +==================== + +- Fix bug preventing the CLI from being invoked +- Improved documentation + + + +0.0.3 (2020-06-09) +================== + +- Misc improvements +- Added documentation + + + +0.0.2 (2020-05-29) +================== + +- Add setuptools as a default fallback backend +- Fix extras handling in requirement strings + + + +0.0.1 (2020-05-17) +================== + +- Initial release @@ -0,0 +1,20 @@ +Copyright © 2019 Filipe Laíns <filipe.lains@gmail.com> + +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 (including the next +paragraph) 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. diff --git a/README.md b/README.md new file mode 100644 index 0000000..0932fd1 --- /dev/null +++ b/README.md @@ -0,0 +1,39 @@ +# build + +[](https://results.pre-commit.ci/latest/github/pypa/build/main) +[](https://github.com/pypa/build/actions) +[](https://github.com/pypa/build/actions/workflows/test.yml) +[](https://codecov.io/gh/pypa/build) + +[](https://pypa-build.readthedocs.io/en/latest/?badge=latest) +[](https://pypi.org/project/build/) +[](https://discord.gg/pypa) + +A simple, correct PEP 517 build frontend. + +See the [documentation](https://pypa-build.readthedocs.io/en/latest/) for more information. + +### Installation + +`build` can be installed via `pip` or an equivalent via: + +```console +$ pip install build +``` + +### Usage + +```console +$ python -m build +``` + +This will build the package in an isolated environment, generating a +source-distribution and wheel in the directory `dist/`. +See the [documentation](https://pypa-build.readthedocs.io/en/latest/) for full information. + +### Code of Conduct + +Everyone interacting in the build's codebase, issue trackers, chat rooms, and mailing lists is expected to follow +the [PSF Code of Conduct]. + +[psf code of conduct]: https://github.com/pypa/.github/blob/main/CODE_OF_CONDUCT.md diff --git a/codecov.yml b/codecov.yml new file mode 100644 index 0000000..5f91842 --- /dev/null +++ b/codecov.yml @@ -0,0 +1,6 @@ +coverage: + status: + patch: + default: + informational: true +comment: false diff --git a/docs/api.rst b/docs/api.rst new file mode 100644 index 0000000..254db23 --- /dev/null +++ b/docs/api.rst @@ -0,0 +1,26 @@ +API Documentation +================= + +``build`` module +---------------- + +.. automodule:: build + :members: + :undoc-members: + :show-inheritance: + +``build.env`` module +-------------------- + +.. automodule:: build.env + :members: + :undoc-members: + :show-inheritance: + +``build.util`` module +--------------------- + +.. automodule:: build.util + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/changelog.rst b/docs/changelog.rst new file mode 120000 index 0000000..e22698b --- /dev/null +++ b/docs/changelog.rst @@ -0,0 +1 @@ +../CHANGELOG.rst
\ No newline at end of file diff --git a/docs/conf.py b/docs/conf.py new file mode 100644 index 0000000..26e77d0 --- /dev/null +++ b/docs/conf.py @@ -0,0 +1,67 @@ +# Configuration file for the Sphinx documentation builder. +# +# This file only contains a selection of the most common options. For a full +# list see the documentation: +# https://www.sphinx-doc.org/en/master/usage/configuration.html + +# -- Path setup -------------------------------------------------------------- + +# If extensions (or modules to document with autodoc) are in another directory, +# add these directories to sys.path here. If the directory is relative to the +# documentation root, use os.path.abspath to make it absolute, like shown here. + +import build + + +# -- Project information ----------------------------------------------------- + +project = 'build' +copyright = '2020, Filipe Laíns' +author = 'Filipe Laíns' + +# The short X.Y version +version = build.__version__ +# The full version, including alpha/beta/rc tags +release = build.__version__ + + +# -- General configuration --------------------------------------------------- + +# Add any Sphinx extension module names here, as strings. They can be +# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom +# ones. +extensions = [ + 'sphinx.ext.autodoc', + 'sphinx.ext.intersphinx', + 'sphinx_autodoc_typehints', + 'sphinx_argparse_cli', +] + +intersphinx_mapping = { + 'python': ('https://docs.python.org/3/', None), +} + +# Add any paths that contain templates here, relative to this directory. +templates_path = ['_templates'] + +# List of patterns, relative to source directory, that match files and +# directories to ignore when looking for source files. +# This pattern also affects html_static_path and html_extra_path. +exclude_patterns = [] + +default_role = 'any' + +# -- Options for HTML output ------------------------------------------------- + +# The theme to use for HTML and HTML Help pages. See the documentation for +# a list of builtin themes. +# +html_theme = 'furo' +html_title = f'build {version}' + +# Add any paths that contain custom static files (such as style sheets) here, +# relative to this directory. They are copied after the builtin static files, +# so a file named 'default.css' will overwrite the builtin 'default.css'. +# html_static_path = ['_static'] + +autoclass_content = 'both' diff --git a/docs/differences.rst b/docs/differences.rst new file mode 100644 index 0000000..6fbc401 --- /dev/null +++ b/docs/differences.rst @@ -0,0 +1,30 @@ +============================ +Differences from other tools +============================ + +``pep517.build`` +---------------- + +build implements a CLI tailored to end users. + +``pep517.build`` contained a proof-of-concept of a :pep:`517` +frontend. It *"implement[ed] essentially the simplest possible frontend +tool, to exercise and illustrate how the core functionality can be +used"*. It has since been `deprecated and is scheduled for removal`_. + +``setup.py sdist bdist_wheel`` +------------------------------ + +build is roughly the equivalent of ``setup.py sdist bdist_wheel`` but +with :pep:`517` support, allowing use with projects that don't use setuptools. + +.. _deprecated and is scheduled for removal: https://github.com/pypa/pep517/pull/83 + +Custom Behaviors +---------------- + +Fallback Backend +^^^^^^^^^^^^^^^^ + +As recommended in :pep:`517`, if no backend is specified, ``build`` will +fallback to ``setuptools.build_meta:__legacy__``. diff --git a/docs/index.rst b/docs/index.rst new file mode 100644 index 0000000..f13aa7a --- /dev/null +++ b/docs/index.rst @@ -0,0 +1,54 @@ +:hide-toc: + +***** +build +***** + +A simple, correct :pep:`517` build frontend. + +build will invoke the :pep:`517` hooks to build a distribution package. +It is a simple build tool and does not perform any dependency management. + +.. sphinx_argparse_cli:: + :module: build.__main__ + :func: main_parser + :prog: python -m build + :title: python -m build + :usage_width: 97 + +.. note:: + + A ``pyproject-build`` CLI script is also available, so that tools such as pipx_ + can use it. + +By default build will build the package in an isolated +environment, but this behavior can be disabled with ``--no-isolation``. + +.. toctree:: + :hidden: + + mission + differences + +.. toctree:: + :caption: Usage + :hidden: + + installation + changelog + api + +.. toctree:: + :caption: Contributing + :hidden: + + test_suite + +.. toctree:: + :caption: Project Links + :hidden: + + Source Code <https://github.com/pypa/build/> + Issue Tracker <https://github.com/pypa/build/issues> + +.. _pipx: https://github.com/pipxproject/pipx diff --git a/docs/installation.rst b/docs/installation.rst new file mode 100644 index 0000000..563ff57 --- /dev/null +++ b/docs/installation.rst @@ -0,0 +1,77 @@ +============ +Installation +============ + +You can download a tarball_ from Github, checkout the latest `git tag`_ or fetch +the artifacts from `project page`_ on PyPI. + +The recommended way is to checkout the git tags, as they are PGP signed with one +of the following keys: + +- |3DCE51D60930EBA47858BA4146F633CBB0EB4BF2|_ *(Filipe Laíns)* + +``build`` may also be installed via `pip`_ or an equivalent: + +.. code-block:: sh + + $ pip install build + +.. tip:: + If you prefer, or are already using virtualenv_ in your workflow, you can + install ``build`` with the optional ``virtualenv`` dependency: + + .. code-block:: sh + + $ pip install 'build[virtualenv]' + + this way, ``build`` will use virtualenv_ for isolation, instead of venv_. + This can be particularly useful, for example, when using automation tools + that rely on virtualenv_, such as tox_, or when your operating system's + Python package does not include venv_ in the standard installation (such as + some versions of Ubuntu). + +Bootstrapping +============= + +This package can build itself with only the ``toml`` and ``pep517`` +dependencies. The ``--skip-dependency-check`` flag should be used in this +case. + +On Python 3.10 and older, we have a dependency on tomli_, but toml_ can be +used instead, which may make bootstrapping easier. + + +Compatibility +============= + +``build`` is verified to be compatible with the following Python +versions: + +- 2.7 +- 3.5 +- 3.6 +- 3.7 +- 3.8 +- 3.9 +- PyPy(2) +- PyPy3 + + +.. _pipx: https://github.com/pipxproject/pipx +.. _pip: https://github.com/pypa/pip +.. _PyPI: https://pypi.org/ + +.. _tox: https://tox.readthedocs.org/ +.. _virtualenv: https://virtualenv.pypa.io +.. _venv: https://docs.python.org/3/library/venv.html + +.. _tarball: https://github.com/pypa/build/releases +.. _git tag: https://github.com/pypa/build/tags +.. _project page: https://pypi.org/project/build/ + +.. _tomli: https://github.com/hukkin/tomli +.. _toml: https://github.com/uiri/toml + + +.. |3DCE51D60930EBA47858BA4146F633CBB0EB4BF2| replace:: ``3DCE51D60930EBA47858BA4146F633CBB0EB4BF2`` +.. _3DCE51D60930EBA47858BA4146F633CBB0EB4BF2: https://keyserver.ubuntu.com/pks/lookup?op=get&search=0x3dce51d60930eba47858ba4146f633cbb0eb4bf2 diff --git a/docs/mission.rst b/docs/mission.rst new file mode 100644 index 0000000..f83f60e --- /dev/null +++ b/docs/mission.rst @@ -0,0 +1,20 @@ +================= +Mission Statement +================= + +In the Python ecosystem, the build system tools and the package management +are very intertwined. While it might be useful for user to be able to access +all this capabilities in a single project (such as pip_), there are several +use cases where this is not desirable. The main being custom environments +(outside PyPI_) or situations where the user does its own package management, +such as Linux distributions. + +This project aims to fit the "building packages hole" for such use-cases in +:pep:`517`/:pep:`518` workflows. + +As it is intended to be used by users that do their own package management, +we will try to keep dependencies to a minimum, in order to try make +bootstrapping easier. + +.. _pip: https://github.com/pypa/pip +.. _PyPI: https://pypi.org/ diff --git a/docs/test_suite.rst b/docs/test_suite.rst new file mode 100644 index 0000000..d486106 --- /dev/null +++ b/docs/test_suite.rst @@ -0,0 +1,51 @@ +********** +Test Suite +********** + +Due to its nature, ``build`` has a somewhat complex test suite, which we will +try to go through in this document. + +Firstly, there are two set of tests, unit tests and integration tests. In unit +tests, we test the actual code implementation. In integration tests, we test +``build`` on a few real world projects; this is mostly a sanity test. + +Integration tests take a long time to run, and are not very helpful tracking +down issues, so they are **disabled by default**. They can be enabled by passing +either ``--run-integration`` or ``--only-integration`` arguments to pytest, +where the latter will disable the unit tests and only run the integration ones. +Even though these tests are disabled by default, they will be run in CI, +where test suite run durations are not a big issue. + +To run the test suite we use ``tox``, which automates running the test suite on +different environments: + + +.. code-block:: console + + tox + + +You can find out more about how to run ``tox`` and its arguments in the +`tox documentation`_. + +We have a fairly large environment matrix. We run tests for all supported Python +versions and implementations, and with the module being invoked from path, +sdist install, or wheel install. Additionally, we have an environment for type +checking, and one to produce the documentation. There are some other extra +environments, like checking the code with the minimum version of each +dependency. + +Some examples commands for this project: + - Run type checking: ``tox -e type`` + - Only run unit tests against Python 3.9: ``tox -e py39`` + - Run both unit and integration tests: ``tox -- --run-integration`` + - Only run integration tests: ``tox -- --only-integration`` + - Only run integration tests with parallel tasks: ``tox -- -n auto --only-integration`` + - Only run unit tests against Python 3.9 with the module installed via wheel: ``tox -e py39-wheel`` + + +We have CI testing, where we the test suite across all supported operating +systems, and have test coverage reports. + + +.. _tox documentation: https://tox.readthedocs.io/ diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..a4f7f4d --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,72 @@ +[build-system] +requires = ["setuptools >=42.0"] +build-backend = "setuptools.build_meta" + +[tool.coverage.run] +source = [ + "build", + "tests", +] + +[tool.coverage.report] +exclude_lines = [ + '\#\s*pragma: no cover', + '^\s*raise NotImplementedError\b', +] + +[tool.coverage.paths] +build = [ + "src", + "*/site-packages", + '*\site-packages', +] + +[tool.coverage.html] +show_contexts = true + +[tool.pytest.ini_options] +minversion = "6.0" +addopts = ["--strict-config", "--strict-markers"] +log_cli_level = "info" +testpaths = ["tests"] +xfail_strict = true +junit_family = "xunit2" +norecursedirs = "tests/integration/*" +markers = [ + "isolated", + "pypy3323bug", +] +filterwarnings = [ + "error", + "ignore:path is deprecated.:DeprecationWarning", + "ignore:The --rsyncdir command line argument and rsyncdirs config variable are deprecated.:DeprecationWarning", +] + +[tool.mypy] +files = "src" +python_version = "3.6" +strict = true +show_error_codes = true +enable_error_code = ["ignore-without-code", "truthy-bool", "redundant-expr"] + + +[[tool.mypy.overrides]] +module = [ + "colorama", # Optional dependency + "pep517.*", # Untyped + "virtualenv", # Optional dependency +] +ignore_missing_imports = true + +[tool.black] +line-length = 127 +skip-string-normalization = true +target-version = ["py39", "py38", "py37", "py36"] + +[tool.isort] +profile = "black" +lines_between_types = 1 +lines_after_imports = 2 +line_length = 127 +known_first_party = "build" +skip = [] # "build" is included in the default skip list diff --git a/setup.cfg b/setup.cfg new file mode 100644 index 0000000..19688d1 --- /dev/null +++ b/setup.cfg @@ -0,0 +1,74 @@ +[metadata] +name = build +version = 0.9.0 +description = A simple, correct PEP 517 build frontend +long_description = file: README.md +long_description_content_type = text/markdown +author = Filipe Laíns +author_email = lains@riseup.net +license = MIT +license_file = LICENSE +classifiers = + License :: OSI Approved :: MIT License + Programming Language :: Python :: 3 + Programming Language :: Python :: 3 :: Only + Programming Language :: Python :: 3.6 + Programming Language :: Python :: 3.7 + Programming Language :: Python :: 3.8 + Programming Language :: Python :: 3.9 + Programming Language :: Python :: 3.10 + Programming Language :: Python :: 3.11 + Programming Language :: Python :: Implementation :: CPython + Programming Language :: Python :: Implementation :: PyPy +project_urls = + homepage = https://github.com/pypa/build + changelog = https://pypa-build.readthedocs.io/en/stable/changelog.html + +[options] +packages = find: +install_requires = + packaging>=19.0 + pep517>=0.9.1 + colorama;os_name == "nt" # not actually a runtime dependency, only supplied as there is not "recommended dependency" support + importlib-metadata>=0.22;python_version < "3.8" + tomli>=1.0.0;python_version < "3.11" # toml can be used instead -- in case it makes bootstrapping easier +python_requires = >=3.6 +package_dir = + =src + +[options.packages.find] +where = src + +[options.entry_points] +console_scripts = + pyproject-build = build.__main__:entrypoint +pipx.run = + build = build.__main__:entrypoint + +[options.extras_require] +docs = + furo>=2021.08.31 + sphinx~=4.0 + sphinx-argparse-cli>=1.5 + sphinx-autodoc-typehints>=1.10 +test = + filelock>=3 + pytest>=6.2.4 + pytest-cov>=2.12 + pytest-mock>=2 + pytest-rerunfailures>=9.1 + pytest-xdist>=1.34 + toml>=0.10.0 + wheel>=0.36.0 + setuptools>=42.0.0;python_version < "3.10" + setuptools>=56.0.0;python_version >= "3.10" +typing = + importlib-metadata>=4.6.4 + mypy==0.950 + typing-extensions>=3.7.4.3;python_version < "3.8" +virtualenv = + virtualenv>=20.0.35 + +[options.package_data] +build = + py.typed diff --git a/setup.py b/setup.py new file mode 100644 index 0000000..b024da8 --- /dev/null +++ b/setup.py @@ -0,0 +1,4 @@ +from setuptools import setup + + +setup() diff --git a/src/build/__init__.py b/src/build/__init__.py new file mode 100644 index 0000000..0425a85 --- /dev/null +++ b/src/build/__init__.py @@ -0,0 +1,539 @@ +# SPDX-License-Identifier: MIT + +""" +build - A simple, correct PEP 517 build frontend +""" + +__version__ = '0.9.0' + +import contextlib +import difflib +import logging +import os +import re +import subprocess +import sys +import textwrap +import types +import warnings +import zipfile + +from collections import OrderedDict +from typing import ( + AbstractSet, + Any, + Callable, + Dict, + Iterator, + List, + Mapping, + MutableMapping, + Optional, + Sequence, + Set, + Tuple, + Type, + Union, +) + +import pep517.wrappers + + +TOMLDecodeError: Type[Exception] +toml_loads: Callable[[str], MutableMapping[str, Any]] + +if sys.version_info >= (3, 11): + from tomllib import TOMLDecodeError + from tomllib import loads as toml_loads +else: + try: + from tomli import TOMLDecodeError + from tomli import loads as toml_loads + except ModuleNotFoundError: # pragma: no cover + from toml import TomlDecodeError as TOMLDecodeError # type: ignore[import,no-redef] + from toml import loads as toml_loads # type: ignore[no-redef] + + +RunnerType = Callable[[Sequence[str], Optional[str], Optional[Mapping[str, str]]], None] +ConfigSettingsType = Mapping[str, Union[str, Sequence[str]]] +PathType = Union[str, 'os.PathLike[str]'] +_ExcInfoType = Union[Tuple[Type[BaseException], BaseException, types.TracebackType], Tuple[None, None, None]] + + +_WHEEL_NAME_REGEX = re.compile( + r'(?P<distribution>.+)-(?P<version>.+)' + r'(-(?P<build_tag>.+))?-(?P<python_tag>.+)' + r'-(?P<abi_tag>.+)-(?P<platform_tag>.+)\.whl' +) + + +_DEFAULT_BACKEND = { + 'build-backend': 'setuptools.build_meta:__legacy__', + 'requires': ['setuptools >= 40.8.0', 'wheel'], +} + + +_logger = logging.getLogger(__name__) + + +class BuildException(Exception): + """ + Exception raised by :class:`ProjectBuilder` + """ + + +class BuildBackendException(Exception): + """ + Exception raised when a backend operation fails + """ + + def __init__( + self, exception: Exception, description: Optional[str] = None, exc_info: _ExcInfoType = (None, None, None) + ) -> None: + super().__init__() + self.exception = exception + self.exc_info = exc_info + self._description = description + + def __str__(self) -> str: + if self._description: + return self._description + return f'Backend operation failed: {self.exception!r}' + + +class BuildSystemTableValidationError(BuildException): + """ + Exception raised when the ``[build-system]`` table in pyproject.toml is invalid. + """ + + def __str__(self) -> str: + return f'Failed to validate `build-system` in pyproject.toml: {self.args[0]}' + + +class FailedProcessError(Exception): + """ + Exception raised when an setup or prepration operation fails. + """ + + def __init__(self, exception: subprocess.CalledProcessError, description: str) -> None: + super().__init__() + self.exception = exception + self._description = description + + def __str__(self) -> str: + cmd = ' '.join(self.exception.cmd) + description = f"{self._description}\n Command '{cmd}' failed with return code {self.exception.returncode}" + for stream_name in ('stdout', 'stderr'): + stream = getattr(self.exception, stream_name) + if stream: + description += f'\n {stream_name}:\n' + description += textwrap.indent(stream.decode(), ' ') + return description + + +class TypoWarning(Warning): + """ + Warning raised when a possible typo is found + """ + + +@contextlib.contextmanager +def _working_directory(path: str) -> Iterator[None]: + current = os.getcwd() + + os.chdir(path) + + try: + yield + finally: + os.chdir(current) + + +def _validate_source_directory(srcdir: PathType) -> None: + if not os.path.isdir(srcdir): + raise BuildException(f'Source {srcdir} is not a directory') + pyproject_toml = os.path.join(srcdir, 'pyproject.toml') + setup_py = os.path.join(srcdir, 'setup.py') + if not os.path.exists(pyproject_toml) and not os.path.exists(setup_py): + raise BuildException(f'Source {srcdir} does not appear to be a Python project: no pyproject.toml or setup.py') + + +def check_dependency( + req_string: str, ancestral_req_strings: Tuple[str, ...] = (), parent_extras: AbstractSet[str] = frozenset() +) -> Iterator[Tuple[str, ...]]: + """ + Verify that a dependency and all of its dependencies are met. + + :param req_string: Requirement string + :param parent_extras: Extras (eg. "test" in myproject[test]) + :yields: Unmet dependencies + """ + import packaging.requirements + + if sys.version_info >= (3, 8): + import importlib.metadata as importlib_metadata + else: + import importlib_metadata + + req = packaging.requirements.Requirement(req_string) + normalised_req_string = str(req) + + # ``Requirement`` doesn't implement ``__eq__`` so we cannot compare reqs for + # equality directly but the string representation is stable. + if normalised_req_string in ancestral_req_strings: + # cyclical dependency, already checked. + return + + if req.marker: + extras = frozenset(('',)).union(parent_extras) + # a requirement can have multiple extras but ``evaluate`` can + # only check one at a time. + if all(not req.marker.evaluate(environment={'extra': e}) for e in extras): + # if the marker conditions are not met, we pretend that the + # dependency is satisfied. + return + + try: + dist = importlib_metadata.distribution(req.name) # type: ignore[no-untyped-call] + except importlib_metadata.PackageNotFoundError: + # dependency is not installed in the environment. + yield ancestral_req_strings + (normalised_req_string,) + else: + if req.specifier and not req.specifier.contains(dist.version, prereleases=True): + # the installed version is incompatible. + yield ancestral_req_strings + (normalised_req_string,) + elif dist.requires: + for other_req_string in dist.requires: + # yields transitive dependencies that are not satisfied. + yield from check_dependency(other_req_string, ancestral_req_strings + (normalised_req_string,), req.extras) + + +def _find_typo(dictionary: Mapping[str, str], expected: str) -> None: + for obj in dictionary: + if difflib.SequenceMatcher(None, expected, obj).ratio() >= 0.8: + warnings.warn( + f"Found '{obj}' in pyproject.toml, did you mean '{expected}'?", + TypoWarning, + ) + + +def _parse_build_system_table(pyproject_toml: Mapping[str, Any]) -> Dict[str, Any]: + # If pyproject.toml is missing (per PEP 517) or [build-system] is missing + # (per PEP 518), use default values + if 'build-system' not in pyproject_toml: + _find_typo(pyproject_toml, 'build-system') + return _DEFAULT_BACKEND + + build_system_table = dict(pyproject_toml['build-system']) + + # If [build-system] is present, it must have a ``requires`` field (per PEP 518) + if 'requires' not in build_system_table: + _find_typo(build_system_table, 'requires') + raise BuildSystemTableValidationError('`requires` is a required property') + elif not isinstance(build_system_table['requires'], list) or not all( + isinstance(i, str) for i in build_system_table['requires'] + ): + raise BuildSystemTableValidationError('`requires` must be an array of strings') + + if 'build-backend' not in build_system_table: + _find_typo(build_system_table, 'build-backend') + # If ``build-backend`` is missing, inject the legacy setuptools backend + # but leave ``requires`` intact to emulate pip + build_system_table['build-backend'] = _DEFAULT_BACKEND['build-backend'] + elif not isinstance(build_system_table['build-backend'], str): + raise BuildSystemTableValidationError('`build-backend` must be a string') + + if 'backend-path' in build_system_table and ( + not isinstance(build_system_table['backend-path'], list) + or not all(isinstance(i, str) for i in build_system_table['backend-path']) + ): + raise BuildSystemTableValidationError('`backend-path` must be an array of strings') + + unknown_props = build_system_table.keys() - {'requires', 'build-backend', 'backend-path'} + if unknown_props: + raise BuildSystemTableValidationError(f'Unknown properties: {", ".join(unknown_props)}') + + return build_system_table + + +class ProjectBuilder: + """ + The PEP 517 consumer API. + """ + + def __init__( + self, + srcdir: PathType, + python_executable: str = sys.executable, + scripts_dir: Optional[str] = None, + runner: RunnerType = pep517.wrappers.default_subprocess_runner, + ) -> None: + """ + :param srcdir: The source directory + :param scripts_dir: The location of the scripts dir (defaults to the folder where the python executable lives) + :param python_executable: The python executable where the backend lives + :param runner: An alternative runner for backend subprocesses + + The 'runner', if provided, must accept the following arguments: + + - cmd: a list of strings representing the command and arguments to + execute, as would be passed to e.g. 'subprocess.check_call'. + - cwd: a string representing the working directory that must be + used for the subprocess. Corresponds to the provided srcdir. + - extra_environ: a dict mapping environment variable names to values + which must be set for the subprocess execution. + + The default runner simply calls the backend hooks in a subprocess, writing backend output + to stdout/stderr. + """ + self._srcdir: str = os.path.abspath(srcdir) + _validate_source_directory(srcdir) + + spec_file = os.path.join(srcdir, 'pyproject.toml') + + try: + with open(spec_file, 'rb') as f: + spec = toml_loads(f.read().decode()) + except FileNotFoundError: + spec = {} + except PermissionError as e: + raise BuildException(f"{e.strerror}: '{e.filename}' ") # noqa: B904 # use raise from + except TOMLDecodeError as e: + raise BuildException(f'Failed to parse {spec_file}: {e} ') # noqa: B904 # use raise from + + self._build_system = _parse_build_system_table(spec) + self._backend = self._build_system['build-backend'] + self._scripts_dir = scripts_dir + self._hook_runner = runner + self._hook = pep517.wrappers.Pep517HookCaller( + self.srcdir, + self._backend, + backend_path=self._build_system.get('backend-path'), + python_executable=python_executable, + runner=self._runner, + ) + + def _runner( + self, cmd: Sequence[str], cwd: Optional[str] = None, extra_environ: Optional[Mapping[str, str]] = None + ) -> None: + # if script dir is specified must be inserted at the start of PATH (avoid duplicate path while doing so) + if self.scripts_dir is not None: + paths: Dict[str, None] = OrderedDict() + paths[str(self.scripts_dir)] = None + if 'PATH' in os.environ: + paths.update((i, None) for i in os.environ['PATH'].split(os.pathsep)) + extra_environ = {} if extra_environ is None else dict(extra_environ) + extra_environ['PATH'] = os.pathsep.join(paths) + self._hook_runner(cmd, cwd, extra_environ) + + @property + def srcdir(self) -> str: + """Project source directory.""" + return self._srcdir + + @property + def python_executable(self) -> str: + """ + The Python executable used to invoke the backend. + """ + # make mypy happy + exe: str = self._hook.python_executable + return exe + + @python_executable.setter + def python_executable(self, value: str) -> None: + self._hook.python_executable = value + + @property + def scripts_dir(self) -> Optional[str]: + """ + The folder where the scripts are stored for the python executable. + """ + return self._scripts_dir + + @scripts_dir.setter + def scripts_dir(self, value: Optional[str]) -> None: + self._scripts_dir = value + + @property + def build_system_requires(self) -> Set[str]: + """ + The dependencies defined in the ``pyproject.toml``'s + ``build-system.requires`` field or the default build dependencies + if ``pyproject.toml`` is missing or ``build-system`` is undefined. + """ + return set(self._build_system['requires']) + + def get_requires_for_build(self, distribution: str, config_settings: Optional[ConfigSettingsType] = None) -> Set[str]: + """ + Return the dependencies defined by the backend in addition to + :attr:`build_system_requires` for a given distribution. + + :param distribution: Distribution to get the dependencies of + (``sdist`` or ``wheel``) + :param config_settings: Config settings for the build backend + """ + self.log(f'Getting build dependencies for {distribution}...') + hook_name = f'get_requires_for_build_{distribution}' + get_requires = getattr(self._hook, hook_name) + + with self._handle_backend(hook_name): + return set(get_requires(config_settings)) + + def check_dependencies( + self, distribution: str, config_settings: Optional[ConfigSettingsType] = None + ) -> Set[Tuple[str, ...]]: + """ + Return the dependencies which are not satisfied from the combined set of + :attr:`build_system_requires` and :meth:`get_requires_for_build` for a given + distribution. + + :param distribution: Distribution to check (``sdist`` or ``wheel``) + :param config_settings: Config settings for the build backend + :returns: Set of variable-length unmet dependency tuples + """ + dependencies = self.get_requires_for_build(distribution, config_settings).union(self.build_system_requires) + return {u for d in dependencies for u in check_dependency(d)} + + def prepare( + self, distribution: str, output_directory: PathType, config_settings: Optional[ConfigSettingsType] = None + ) -> Optional[str]: + """ + Prepare metadata for a distribution. + + :param distribution: Distribution to build (must be ``wheel``) + :param output_directory: Directory to put the prepared metadata in + :param config_settings: Config settings for the build backend + :returns: The full path to the prepared metadata directory + """ + self.log(f'Getting metadata for {distribution}...') + try: + return self._call_backend( + f'prepare_metadata_for_build_{distribution}', + output_directory, + config_settings, + _allow_fallback=False, + ) + except BuildBackendException as exception: + if isinstance(exception.exception, pep517.wrappers.HookMissing): + return None + raise + + def build( + self, + distribution: str, + output_directory: PathType, + config_settings: Optional[ConfigSettingsType] = None, + metadata_directory: Optional[str] = None, + ) -> str: + """ + Build a distribution. + + :param distribution: Distribution to build (``sdist`` or ``wheel``) + :param output_directory: Directory to put the built distribution in + :param config_settings: Config settings for the build backend + :param metadata_directory: If provided, should be the return value of a + previous ``prepare`` call on the same ``distribution`` kind + :returns: The full path to the built distribution + """ + self.log(f'Building {distribution}...') + kwargs = {} if metadata_directory is None else {'metadata_directory': metadata_directory} + return self._call_backend(f'build_{distribution}', output_directory, config_settings, **kwargs) + + def metadata_path(self, output_directory: PathType) -> str: + """ + Generate the metadata directory of a distribution and return its path. + + If the backend does not support the ``prepare_metadata_for_build_wheel`` + hook, a wheel will be built and the metadata will be extracted from it. + + :param output_directory: Directory to put the metadata distribution in + :returns: The path of the metadata directory + """ + # prepare_metadata hook + metadata = self.prepare('wheel', output_directory) + if metadata is not None: + return metadata + + # fallback to build_wheel hook + wheel = self.build('wheel', output_directory) + match = _WHEEL_NAME_REGEX.match(os.path.basename(wheel)) + if not match: + raise ValueError('Invalid wheel') + distinfo = f"{match['distribution']}-{match['version']}.dist-info" + member_prefix = f'{distinfo}/' + with zipfile.ZipFile(wheel) as w: + w.extractall( + output_directory, + (member for member in w.namelist() if member.startswith(member_prefix)), + ) + return os.path.join(output_directory, distinfo) + + def _call_backend( + self, hook_name: str, outdir: PathType, config_settings: Optional[ConfigSettingsType] = None, **kwargs: Any + ) -> str: + outdir = os.path.abspath(outdir) + + callback = getattr(self._hook, hook_name) + + if os.path.exists(outdir): + if not os.path.isdir(outdir): + raise BuildException(f"Build path '{outdir}' exists and is not a directory") + else: + os.makedirs(outdir) + + with self._handle_backend(hook_name): + basename: str = callback(outdir, config_settings, **kwargs) + + return os.path.join(outdir, basename) + + @contextlib.contextmanager + def _handle_backend(self, hook: str) -> Iterator[None]: + with _working_directory(self.srcdir): + try: + yield + except pep517.wrappers.BackendUnavailable as exception: + raise BuildBackendException( # noqa: B904 # use raise from + exception, + f"Backend '{self._backend}' is not available.", + sys.exc_info(), + ) + except subprocess.CalledProcessError as exception: + raise BuildBackendException( # noqa: B904 # use raise from + exception, f'Backend subprocess exited when trying to invoke {hook}' + ) + except Exception as exception: + raise BuildBackendException(exception, exc_info=sys.exc_info()) # noqa: B904 # use raise from + + @staticmethod + def log(message: str) -> None: + """ + Log a message. + + The default implementation uses the logging module but this function can be + overridden by users to have a different implementation. + + :param message: Message to output + """ + if sys.version_info >= (3, 8): + _logger.log(logging.INFO, message, stacklevel=2) + else: + _logger.log(logging.INFO, message) + + +__all__ = [ + '__version__', + 'BuildSystemTableValidationError', + 'BuildBackendException', + 'BuildException', + 'ConfigSettingsType', + 'FailedProcessError', + 'ProjectBuilder', + 'RunnerType', + 'TypoWarning', + 'check_dependency', +] + + +def __dir__() -> List[str]: + return __all__ diff --git a/src/build/__main__.py b/src/build/__main__.py new file mode 100644 index 0000000..67b21d1 --- /dev/null +++ b/src/build/__main__.py @@ -0,0 +1,397 @@ +# SPDX-License-Identifier: MIT + + +import argparse +import contextlib +import os +import platform +import shutil +import subprocess +import sys +import tarfile +import tempfile +import textwrap +import traceback +import warnings + +from typing import Dict, Iterator, List, NoReturn, Optional, Sequence, TextIO, Type, Union + +import build + +from build import BuildBackendException, BuildException, ConfigSettingsType, FailedProcessError, PathType, ProjectBuilder +from build.env import IsolatedEnvBuilder + + +_COLORS = { + 'red': '\33[91m', + 'green': '\33[92m', + 'yellow': '\33[93m', + 'bold': '\33[1m', + 'dim': '\33[2m', + 'underline': '\33[4m', + 'reset': '\33[0m', +} +_NO_COLORS = {color: '' for color in _COLORS} + + +def _init_colors() -> Dict[str, str]: + if 'NO_COLOR' in os.environ: + if 'FORCE_COLOR' in os.environ: + warnings.warn('Both NO_COLOR and FORCE_COLOR environment variables are set, disabling color') + return _NO_COLORS + elif 'FORCE_COLOR' in os.environ or sys.stdout.isatty(): + return _COLORS + return _NO_COLORS + + +_STYLES = _init_colors() + + +def _cprint(fmt: str = '', msg: str = '') -> None: + print(fmt.format(msg, **_STYLES), flush=True) + + +def _showwarning( + message: Union[Warning, str], + category: Type[Warning], + filename: str, + lineno: int, + file: Optional[TextIO] = None, + line: Optional[str] = None, +) -> None: # pragma: no cover + _cprint('{yellow}WARNING{reset} {}', str(message)) + + +def _setup_cli() -> None: + warnings.showwarning = _showwarning + + if platform.system() == 'Windows': + try: + import colorama + + colorama.init() + except ModuleNotFoundError: + pass + + +def _error(msg: str, code: int = 1) -> NoReturn: # pragma: no cover + """ + Print an error message and exit. Will color the output when writing to a TTY. + + :param msg: Error message + :param code: Error code + """ + _cprint('{red}ERROR{reset} {}', msg) + raise SystemExit(code) + + +class _ProjectBuilder(ProjectBuilder): + @staticmethod + def log(message: str) -> None: + _cprint('{bold}* {}{reset}', message) + + +class _IsolatedEnvBuilder(IsolatedEnvBuilder): + @staticmethod + def log(message: str) -> None: + _cprint('{bold}* {}{reset}', message) + + +def _format_dep_chain(dep_chain: Sequence[str]) -> str: + return ' -> '.join(dep.partition(';')[0].strip() for dep in dep_chain) + + +def _build_in_isolated_env( + builder: ProjectBuilder, outdir: PathType, distribution: str, config_settings: Optional[ConfigSettingsType] +) -> str: + with _IsolatedEnvBuilder() as env: + builder.python_executable = env.executable + builder.scripts_dir = env.scripts_dir + # first install the build dependencies + env.install(builder.build_system_requires) + # then get the extra required dependencies from the backend (which was installed in the call above :P) + env.install(builder.get_requires_for_build(distribution)) + return builder.build(distribution, outdir, config_settings or {}) + + +def _build_in_current_env( + builder: ProjectBuilder, + outdir: PathType, + distribution: str, + config_settings: Optional[ConfigSettingsType], + skip_dependency_check: bool = False, +) -> str: + if not skip_dependency_check: + missing = builder.check_dependencies(distribution) + if missing: + dependencies = ''.join('\n\t' + dep for deps in missing for dep in (deps[0], _format_dep_chain(deps[1:])) if dep) + _cprint() + _error(f'Missing dependencies:{dependencies}') + + return builder.build(distribution, outdir, config_settings or {}) + + +def _build( + isolation: bool, + builder: ProjectBuilder, + outdir: PathType, + distribution: str, + config_settings: Optional[ConfigSettingsType], + skip_dependency_check: bool, +) -> str: + if isolation: + return _build_in_isolated_env(builder, outdir, distribution, config_settings) + else: + return _build_in_current_env(builder, outdir, distribution, config_settings, skip_dependency_check) + + +@contextlib.contextmanager +def _handle_build_error() -> Iterator[None]: + try: + yield + except (BuildException, FailedProcessError) as e: + _error(str(e)) + except BuildBackendException as e: + if isinstance(e.exception, subprocess.CalledProcessError): + _cprint() + _error(str(e)) + + if e.exc_info: + tb_lines = traceback.format_exception( + e.exc_info[0], + e.exc_info[1], + e.exc_info[2], + limit=-1, + ) + tb = ''.join(tb_lines) + else: + tb = traceback.format_exc(-1) + _cprint('\n{dim}{}{reset}\n', tb.strip('\n')) + _error(str(e)) + + +def _natural_language_list(elements: Sequence[str]) -> str: + if len(elements) == 0: + raise IndexError('no elements') + elif len(elements) == 1: + return elements[0] + else: + return '{} and {}'.format( + ', '.join(elements[:-1]), + elements[-1], + ) + + +def build_package( + srcdir: PathType, + outdir: PathType, + distributions: Sequence[str], + config_settings: Optional[ConfigSettingsType] = None, + isolation: bool = True, + skip_dependency_check: bool = False, +) -> Sequence[str]: + """ + Run the build process. + + :param srcdir: Source directory + :param outdir: Output directory + :param distribution: Distribution to build (sdist or wheel) + :param config_settings: Configuration settings to be passed to the backend + :param isolation: Isolate the build in a separate environment + :param skip_dependency_check: Do not perform the dependency check + """ + built: List[str] = [] + builder = _ProjectBuilder(srcdir) + for distribution in distributions: + out = _build(isolation, builder, outdir, distribution, config_settings, skip_dependency_check) + built.append(os.path.basename(out)) + return built + + +def build_package_via_sdist( + srcdir: PathType, + outdir: PathType, + distributions: Sequence[str], + config_settings: Optional[ConfigSettingsType] = None, + isolation: bool = True, + skip_dependency_check: bool = False, +) -> Sequence[str]: + """ + Build a sdist and then the specified distributions from it. + + :param srcdir: Source directory + :param outdir: Output directory + :param distribution: Distribution to build (only wheel) + :param config_settings: Configuration settings to be passed to the backend + :param isolation: Isolate the build in a separate environment + :param skip_dependency_check: Do not perform the dependency check + """ + if 'sdist' in distributions: + raise ValueError('Only binary distributions are allowed but sdist was specified') + + builder = _ProjectBuilder(srcdir) + sdist = _build(isolation, builder, outdir, 'sdist', config_settings, skip_dependency_check) + + sdist_name = os.path.basename(sdist) + sdist_out = tempfile.mkdtemp(prefix='build-via-sdist-') + built: List[str] = [] + # extract sdist + with tarfile.open(sdist) as t: + t.extractall(sdist_out) + try: + builder = _ProjectBuilder(os.path.join(sdist_out, sdist_name[: -len('.tar.gz')])) + if distributions: + builder.log(f'Building {_natural_language_list(distributions)} from sdist') + for distribution in distributions: + out = _build(isolation, builder, outdir, distribution, config_settings, skip_dependency_check) + built.append(os.path.basename(out)) + finally: + shutil.rmtree(sdist_out, ignore_errors=True) + return [sdist_name] + built + + +def main_parser() -> argparse.ArgumentParser: + """ + Construct the main parser. + """ + parser = argparse.ArgumentParser( + description=textwrap.indent( + textwrap.dedent( + ''' + A simple, correct PEP 517 build frontend. + + By default, a source distribution (sdist) is built from {srcdir} + and a binary distribution (wheel) is built from the sdist. + This is recommended as it will ensure the sdist can be used + to build wheels. + + Pass -s/--sdist and/or -w/--wheel to build a specific distribution. + If you do this, the default behavior will be disabled, and all + artifacts will be built from {srcdir} (even if you combine + -w/--wheel with -s/--sdist, the wheel will be built from {srcdir}). + ''' + ).strip(), + ' ', + ), + formatter_class=argparse.RawTextHelpFormatter, + ) + parser.add_argument( + 'srcdir', + type=str, + nargs='?', + default=os.getcwd(), + help='source directory (defaults to current directory)', + ) + parser.add_argument( + '--version', + '-V', + action='version', + version=f"build {build.__version__} ({','.join(build.__path__)})", + ) + parser.add_argument( + '--sdist', + '-s', + action='store_true', + help='build a source distribution (disables the default behavior)', + ) + parser.add_argument( + '--wheel', + '-w', + action='store_true', + help='build a wheel (disables the default behavior)', + ) + parser.add_argument( + '--outdir', + '-o', + type=str, + help=f'output directory (defaults to {{srcdir}}{os.sep}dist)', + ) + parser.add_argument( + '--skip-dependency-check', + '-x', + action='store_true', + help='do not check that build dependencies are installed', + ) + parser.add_argument( + '--no-isolation', + '-n', + action='store_true', + help='do not isolate the build in a virtual environment', + ) + parser.add_argument( + '--config-setting', + '-C', + action='append', + help='pass options to the backend. options which begin with a hyphen must be in the form of ' + '"--config-setting=--opt(=value)" or "-C--opt(=value)"', + ) + return parser + + +def main(cli_args: Sequence[str], prog: Optional[str] = None) -> None: # noqa: C901 + """ + Parse the CLI arguments and invoke the build process. + + :param cli_args: CLI arguments + :param prog: Program name to show in help text + """ + _setup_cli() + parser = main_parser() + if prog: + parser.prog = prog + args = parser.parse_args(cli_args) + + distributions = [] + config_settings = {} + + if args.config_setting: + for arg in args.config_setting: + setting, _, value = arg.partition('=') + if setting not in config_settings: + config_settings[setting] = value + else: + if not isinstance(config_settings[setting], list): + config_settings[setting] = [config_settings[setting]] + + config_settings[setting].append(value) + + if args.sdist: + distributions.append('sdist') + if args.wheel: + distributions.append('wheel') + + # outdir is relative to srcdir only if omitted. + outdir = os.path.join(args.srcdir, 'dist') if args.outdir is None else args.outdir + + if distributions: + build_call = build_package + else: + build_call = build_package_via_sdist + distributions = ['wheel'] + try: + with _handle_build_error(): + built = build_call( + args.srcdir, outdir, distributions, config_settings, not args.no_isolation, args.skip_dependency_check + ) + artifact_list = _natural_language_list( + ['{underline}{}{reset}{bold}{green}'.format(artifact, **_STYLES) for artifact in built] + ) + _cprint('{bold}{green}Successfully built {}{reset}', artifact_list) + except Exception as e: # pragma: no cover + tb = traceback.format_exc().strip('\n') + _cprint('\n{dim}{}{reset}\n', tb) + _error(str(e)) + + +def entrypoint() -> None: + main(sys.argv[1:]) + + +if __name__ == '__main__': # pragma: no cover + main(sys.argv[1:], 'python -m build') + + +__all__ = [ + 'main', + 'main_parser', +] diff --git a/src/build/env.py b/src/build/env.py new file mode 100644 index 0000000..b4a90a9 --- /dev/null +++ b/src/build/env.py @@ -0,0 +1,340 @@ +""" +Creates and manages isolated build environments. +""" +import abc +import functools +import logging +import os +import platform +import shutil +import subprocess +import sys +import sysconfig +import tempfile +import warnings + +from types import TracebackType +from typing import Callable, Collection, List, Optional, Tuple, Type + +import build + + +try: + import virtualenv +except ModuleNotFoundError: + virtualenv = None + + +_logger = logging.getLogger(__name__) + + +class IsolatedEnv(metaclass=abc.ABCMeta): + """Abstract base of isolated build environments, as required by the build project.""" + + @property + @abc.abstractmethod + def executable(self) -> str: + """The executable of the isolated build environment.""" + raise NotImplementedError + + @property + @abc.abstractmethod + def scripts_dir(self) -> str: + """The scripts directory of the isolated build environment.""" + raise NotImplementedError + + @abc.abstractmethod + def install(self, requirements: Collection[str]) -> None: + """ + Install packages from PEP 508 requirements in the isolated build environment. + + :param requirements: PEP 508 requirements + """ + raise NotImplementedError + + +@functools.lru_cache(maxsize=None) +def _should_use_virtualenv() -> bool: + import packaging.requirements + + # virtualenv might be incompatible if it was installed separately + # from build. This verifies that virtualenv and all of its + # dependencies are installed as specified by build. + return virtualenv is not None and not any( + packaging.requirements.Requirement(d[1]).name == 'virtualenv' + for d in build.check_dependency('build[virtualenv]') + if len(d) > 1 + ) + + +def _subprocess(cmd: List[str]) -> None: + """Invoke subprocess and output stdout and stderr if it fails.""" + try: + subprocess.run(cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT) + except subprocess.CalledProcessError as e: + print(e.output.decode(), end='', file=sys.stderr) + raise e + + +class IsolatedEnvBuilder: + """Builder object for isolated environments.""" + + def __init__(self) -> None: + self._path: Optional[str] = None + + def __enter__(self) -> IsolatedEnv: + """ + Create an isolated build environment. + + :return: The isolated build environment + """ + # Call ``realpath`` to prevent spurious warning from being emitted + # that the venv location has changed on Windows. The username is + # DOS-encoded in the output of tempfile - the location is the same + # but the representation of it is different, which confuses venv. + # Ref: https://bugs.python.org/issue46171 + self._path = os.path.realpath(tempfile.mkdtemp(prefix='build-env-')) + try: + # use virtualenv when available (as it's faster than venv) + if _should_use_virtualenv(): + self.log('Creating virtualenv isolated environment...') + executable, scripts_dir = _create_isolated_env_virtualenv(self._path) + else: + self.log('Creating venv isolated environment...') + executable, scripts_dir = _create_isolated_env_venv(self._path) + return _IsolatedEnvVenvPip( + path=self._path, + python_executable=executable, + scripts_dir=scripts_dir, + log=self.log, + ) + except Exception: # cleanup folder if creation fails + self.__exit__(*sys.exc_info()) + raise + + def __exit__( + self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType] + ) -> None: + """ + Delete the created isolated build environment. + + :param exc_type: The type of exception raised (if any) + :param exc_val: The value of exception raised (if any) + :param exc_tb: The traceback of exception raised (if any) + """ + if self._path is not None and os.path.exists(self._path): # in case the user already deleted skip remove + shutil.rmtree(self._path) + + @staticmethod + def log(message: str) -> None: + """ + Prints message + + The default implementation uses the logging module but this function can be + overwritten by users to have a different implementation. + + :param msg: Message to output + """ + if sys.version_info >= (3, 8): + _logger.log(logging.INFO, message, stacklevel=2) + else: + _logger.log(logging.INFO, message) + + +class _IsolatedEnvVenvPip(IsolatedEnv): + """ + Isolated build environment context manager + + Non-standard paths injected directly to sys.path will still be passed to the environment. + """ + + def __init__( + self, + path: str, + python_executable: str, + scripts_dir: str, + log: Callable[[str], None], + ) -> None: + """ + :param path: The path where the environment exists + :param python_executable: The python executable within the environment + :param log: Log function + """ + self._path = path + self._python_executable = python_executable + self._scripts_dir = scripts_dir + self._log = log + + @property + def path(self) -> str: + """The location of the isolated build environment.""" + return self._path + + @property + def executable(self) -> str: + """The python executable of the isolated build environment.""" + return self._python_executable + + @property + def scripts_dir(self) -> str: + return self._scripts_dir + + def install(self, requirements: Collection[str]) -> None: + """ + Install packages from PEP 508 requirements in the isolated build environment. + + :param requirements: PEP 508 requirement specification to install + + :note: Passing non-PEP 508 strings will result in undefined behavior, you *should not* rely on it. It is + merely an implementation detail, it may change any time without warning. + """ + if not requirements: + return + + self._log('Installing packages in isolated environment... ({})'.format(', '.join(sorted(requirements)))) + + # pip does not honour environment markers in command line arguments + # but it does for requirements from a file + with tempfile.NamedTemporaryFile('w+', prefix='build-reqs-', suffix='.txt', delete=False) as req_file: + req_file.write(os.linesep.join(requirements)) + try: + cmd = [ + self.executable, + '-Im', + 'pip', + 'install', + '--use-pep517', + '--no-warn-script-location', + '-r', + os.path.abspath(req_file.name), + ] + _subprocess(cmd) + finally: + os.unlink(req_file.name) + + +def _create_isolated_env_virtualenv(path: str) -> Tuple[str, str]: + """ + We optionally can use the virtualenv package to provision a virtual environment. + + :param path: The path where to create the isolated build environment + :return: The Python executable and script folder + """ + cmd = [str(path), '--no-setuptools', '--no-wheel', '--activators', ''] + result = virtualenv.cli_run(cmd, setup_logging=False) + executable = str(result.creator.exe) + script_dir = str(result.creator.script_dir) + return executable, script_dir + + +@functools.lru_cache(maxsize=None) +def _fs_supports_symlink() -> bool: + """Return True if symlinks are supported""" + # Using definition used by venv.main() + if not sys.platform.startswith('win'): + return True + + # Windows may support symlinks (setting in Windows 10) + with tempfile.NamedTemporaryFile(prefix='build-symlink-') as tmp_file: + dest = f'{tmp_file}-b' + try: + os.symlink(tmp_file.name, dest) + os.unlink(dest) + return True + except (OSError, NotImplementedError, AttributeError): + return False + + +def _create_isolated_env_venv(path: str) -> Tuple[str, str]: + """ + On Python 3 we use the venv package from the standard library. + + :param path: The path where to create the isolated build environment + :return: The Python executable and script folder + """ + import venv + + import packaging.version + + if sys.version_info < (3, 8): + import importlib_metadata as metadata + else: + from importlib import metadata + + symlinks = _fs_supports_symlink() + try: + with warnings.catch_warnings(): + if sys.version_info[:3] == (3, 11, 0): + warnings.filterwarnings('ignore', 'check_home argument is deprecated and ignored.', DeprecationWarning) + venv.EnvBuilder(with_pip=True, symlinks=symlinks).create(path) + except subprocess.CalledProcessError as exc: + raise build.FailedProcessError(exc, 'Failed to create venv. Maybe try installing virtualenv.') from None + + executable, script_dir, purelib = _find_executable_and_scripts(path) + + # Get the version of pip in the environment + pip_distribution = next(iter(metadata.distributions(name='pip', path=[purelib]))) # type: ignore[no-untyped-call] + current_pip_version = packaging.version.Version(pip_distribution.version) + + if platform.system() == 'Darwin' and int(platform.mac_ver()[0].split('.')[0]) >= 11: + # macOS 11+ name scheme change requires 20.3. Intel macOS 11.0 can be told to report 10.16 for backwards + # compatibility; but that also fixes earlier versions of pip so this is only needed for 11+. + is_apple_silicon_python = platform.machine() != 'x86_64' + minimum_pip_version = '21.0.1' if is_apple_silicon_python else '20.3.0' + else: + # PEP-517 and manylinux1 was first implemented in 19.1 + minimum_pip_version = '19.1.0' + + if current_pip_version < packaging.version.Version(minimum_pip_version): + _subprocess([executable, '-m', 'pip', 'install', f'pip>={minimum_pip_version}']) + + # Avoid the setuptools from ensurepip to break the isolation + _subprocess([executable, '-m', 'pip', 'uninstall', 'setuptools', '-y']) + return executable, script_dir + + +def _find_executable_and_scripts(path: str) -> Tuple[str, str, str]: + """ + Detect the Python executable and script folder of a virtual environment. + + :param path: The location of the virtual environment + :return: The Python executable, script folder, and purelib folder + """ + config_vars = sysconfig.get_config_vars().copy() # globally cached, copy before altering it + config_vars['base'] = path + scheme_names = sysconfig.get_scheme_names() + if 'venv' in scheme_names: + # Python distributors with custom default installation scheme can set a + # scheme that can't be used to expand the paths in a venv. + # This can happen if build itself is not installed in a venv. + # The distributors are encouraged to set a "venv" scheme to be used for this. + # See https://bugs.python.org/issue45413 + # and https://github.com/pypa/virtualenv/issues/2208 + paths = sysconfig.get_paths(scheme='venv', vars=config_vars) + elif 'posix_local' in scheme_names: + # The Python that ships on Debian/Ubuntu varies the default scheme to + # install to /usr/local + # But it does not (yet) set the "venv" scheme. + # If we're the Debian "posix_local" scheme is available, but "venv" + # is not, we use "posix_prefix" instead which is venv-compatible there. + paths = sysconfig.get_paths(scheme='posix_prefix', vars=config_vars) + elif 'osx_framework_library' in scheme_names: + # The Python that ships with the macOS developer tools varies the + # default scheme depending on whether the ``sys.prefix`` is part of a framework. + # But it does not (yet) set the "venv" scheme. + # If the Apple-custom "osx_framework_library" scheme is available but "venv" + # is not, we use "posix_prefix" instead which is venv-compatible there. + paths = sysconfig.get_paths(scheme='posix_prefix', vars=config_vars) + else: + paths = sysconfig.get_paths(vars=config_vars) + executable = os.path.join(paths['scripts'], 'python.exe' if sys.platform.startswith('win') else 'python') + if not os.path.exists(executable): + raise RuntimeError(f'Virtual environment creation failed, executable {executable} missing') + + return executable, paths['scripts'], paths['purelib'] + + +__all__ = [ + 'IsolatedEnvBuilder', + 'IsolatedEnv', +] diff --git a/src/build/py.typed b/src/build/py.typed new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/src/build/py.typed diff --git a/src/build/util.py b/src/build/util.py new file mode 100644 index 0000000..6c918ce --- /dev/null +++ b/src/build/util.py @@ -0,0 +1,60 @@ +# SPDX-License-Identifier: MIT + +import os +import pathlib +import sys +import tempfile + +import pep517 + +import build +import build.env + + +if sys.version_info >= (3, 8): + import importlib.metadata as importlib_metadata +else: + import importlib_metadata + + +def _project_wheel_metadata(builder: build.ProjectBuilder) -> 'importlib_metadata.PackageMetadata': + with tempfile.TemporaryDirectory() as tmpdir: + path = pathlib.Path(builder.metadata_path(tmpdir)) + # https://github.com/python/importlib_metadata/pull/343 + return importlib_metadata.PathDistribution(path).metadata # type: ignore[arg-type] + + +def project_wheel_metadata( + srcdir: build.PathType, + isolated: bool = True, +) -> 'importlib_metadata.PackageMetadata': + """ + Return the wheel metadata for a project. + + Uses the ``prepare_metadata_for_build_wheel`` hook if available, + otherwise ``build_wheel``. + + :param srcdir: Project source directory + :param isolated: Whether or not to run invoke the backend in the current + environment or to create an isolated one and invoke it + there. + """ + builder = build.ProjectBuilder( + os.fspath(srcdir), + runner=pep517.quiet_subprocess_runner, + ) + + if not isolated: + return _project_wheel_metadata(builder) + + with build.env.IsolatedEnvBuilder() as env: + builder.python_executable = env.executable + builder.scripts_dir = env.scripts_dir + env.install(builder.build_system_requires) + env.install(builder.get_requires_for_build('wheel')) + return _project_wheel_metadata(builder) + + +__all__ = [ + 'project_wheel_metadata', +] diff --git a/tests/conftest.py b/tests/conftest.py new file mode 100644 index 0000000..d65b64e --- /dev/null +++ b/tests/conftest.py @@ -0,0 +1,111 @@ +# SPDX-License-Identifier: MIT + +import os +import os.path +import shutil +import stat +import sys +import sysconfig +import tempfile + +import pytest + +import build.env + + +def pytest_addoption(parser): + os.environ['PYTHONWARNINGS'] = 'ignore:DEPRECATION::pip._internal.cli.base_command' # for when not run within tox + os.environ['PIP_DISABLE_PIP_VERSION_CHECK'] = '1' # do not pollute stderr with upgrade advisory + parser.addoption('--run-integration', action='store_true', help='run the integration tests') + parser.addoption('--only-integration', action='store_true', help='only run the integration tests') + + +PYPY3_WIN_VENV_BAD = ( + sys.implementation.name == 'pypy' and sys.implementation.version < (7, 3, 9) and sys.platform.startswith('win') +) +PYPY3_WIN_M = 'https://foss.heptapod.net/pypy/pypy/-/issues/3323 and https://foss.heptapod.net/pypy/pypy/-/issues/3321' + + +def pytest_collection_modifyitems(config, items): + skip_int = pytest.mark.skip(reason='integration tests not run (no --run-integration flag)') + skip_other = pytest.mark.skip(reason='only integration tests are run (got --only-integration flag)') + + if config.getoption('--run-integration') and config.getoption('--only-integration'): # pragma: no cover + raise pytest.UsageError("--run-integration and --only-integration can't be used together, choose one") + + if len(items) == 1: # do not require flags if called directly + return + for item in items: + is_integration_file = is_integration(item) + if PYPY3_WIN_VENV_BAD and item.get_closest_marker('pypy3323bug') and os.environ.get('PYPY3323BUG', None): + item.add_marker(pytest.mark.xfail(reason=PYPY3_WIN_M, strict=False)) + if PYPY3_WIN_VENV_BAD and item.get_closest_marker('isolated'): + if not (is_integration_file and item.originalname == 'test_build') or ( + hasattr(item, 'callspec') and '--no-isolation' not in item.callspec.params.get('args', []) + ): + item.add_marker(pytest.mark.xfail(reason=PYPY3_WIN_M, strict=True)) + if is_integration_file: # pragma: no cover + if not config.getoption('--run-integration') and not config.getoption('--only-integration'): + item.add_marker(skip_int) + elif config.getoption('--only-integration'): # pragma: no cover + item.add_marker(skip_other) + # run integration tests after unit tests + items.sort(key=lambda i: 1 if is_integration(i) else 0) + + +def is_integration(item): + return os.path.basename(item.location[0]) == 'test_integration.py' + + +@pytest.fixture(scope='session', autouse=True) +def ensure_syconfig_vars_created(): + # the config vars are globally cached and may use get_path, make sure they are created + sysconfig.get_config_vars() + + +@pytest.fixture +def packages_path(): + return os.path.realpath(os.path.join(__file__, '..', 'packages')) + + +def generate_package_path_fixture(package_name): + @pytest.fixture + def fixture(packages_path): + return os.path.join(packages_path, package_name) + + return fixture + + +# Generate path fixtures dynamically. +package_names = os.listdir(os.path.join(os.path.dirname(__file__), 'packages')) +for package_name in package_names: + normalized_name = package_name.replace('-', '_') + fixture_name = f'package_{normalized_name}' + globals()[fixture_name] = generate_package_path_fixture(package_name) + + +@pytest.fixture +def test_no_permission(packages_path): + path = os.path.join(packages_path, 'test-no-permission') + file = os.path.join(path, 'pyproject.toml') + orig_stat = os.stat(file).st_mode + + os.chmod(file, ~stat.S_IRWXU) + + yield os.path.join(packages_path, 'test-no-permission') + + os.chmod(file, orig_stat) + + +@pytest.fixture +def tmp_dir(): + path = tempfile.mkdtemp(prefix='python-build-test-') + + yield path + + shutil.rmtree(path) + + +@pytest.fixture(autouse=True) +def force_venv(mocker): + mocker.patch.object(build.env, '_should_use_virtualenv', lambda: False) diff --git a/tests/constraints.txt b/tests/constraints.txt new file mode 100644 index 0000000..b073bd9 --- /dev/null +++ b/tests/constraints.txt @@ -0,0 +1,9 @@ +importlib-metadata==0.22 +packaging==19.0 +pep517==0.9.1 +setuptools==42.0.0; python_version < "3.10" +setuptools==56.0.0; python_version >= "3.10" +toml==0.10.0 +tomli==1.0.0 +virtualenv==20.0.35 +wheel==0.36.0 diff --git a/tests/packages/inline/build.py b/tests/packages/inline/build.py new file mode 100644 index 0000000..a8e0dcb --- /dev/null +++ b/tests/packages/inline/build.py @@ -0,0 +1,63 @@ +import os +import sys + +from textwrap import dedent +from zipfile import ZipFile + + +name = 'demo_pkg_inline' +pkg_name = name.replace('_', '-') + +version = '1.0.0' +dist_info = f'{name}-{version}.dist-info' + +metadata = f'{dist_info}/METADATA' +wheel = f'{dist_info}/WHEEL' +entry_points = f'{dist_info}/entry_points.txt' +record = f'{dist_info}/RECORD' +init = f'{name}/__init__.py' +content = { + init: f"def do():\n print('greetings from {name}')", + metadata: f""" + Metadata-Version: 2.1 + Name: {pkg_name} + Version: {version} + Summary: Summary of package + Home-page: Does not exists + Author: someone + Author-email: a@o.com + License: MIT + Platform: ANY + + Desc + """, + wheel: f""" + Wheel-Version: 1.0 + Generator: {name}-{version} + Root-Is-Purelib: true + Tag: py3-none-any + """, + f'{dist_info}/top_level.txt': name, + entry_points: '\n[console_scripts]\ndemo-pkg-inline = demo_pkg_inline:do', + record: f""" + {name}/__init__.py,, + {dist_info}/METADATA,, + {dist_info}/WHEEL,, + {dist_info}/top_level.txt,, + {dist_info}/RECORD,, + """, +} + + +def build_wheel(wheel_directory, metadata_directory=None, config_settings=None): + base_name = f'{name}-{version}-py{sys.version_info.major}-none-any.whl' + path = os.path.join(wheel_directory, base_name) + with ZipFile(str(path), 'w') as zip_file_handler: + for arc_name, data in content.items(): + zip_file_handler.writestr(arc_name, dedent(data).strip()) + print(f'created wheel {path}') + return base_name + + +def get_requires_for_build_wheel(config_settings): + return [] diff --git a/tests/packages/inline/pyproject.toml b/tests/packages/inline/pyproject.toml new file mode 100644 index 0000000..dc9ecbb --- /dev/null +++ b/tests/packages/inline/pyproject.toml @@ -0,0 +1,4 @@ +[build-system] +requires = [] +build-backend = "build" +backend-path = ["."] diff --git a/tests/packages/legacy/legacy/__init__.py b/tests/packages/legacy/legacy/__init__.py new file mode 100644 index 0000000..d5a030b --- /dev/null +++ b/tests/packages/legacy/legacy/__init__.py @@ -0,0 +1,6 @@ +# SPDX-License-Identifier: MIT + +""" +legacy - Example legacy package +""" +__version__ = '1.0.0' diff --git a/tests/packages/legacy/setup.py b/tests/packages/legacy/setup.py new file mode 100644 index 0000000..9feee16 --- /dev/null +++ b/tests/packages/legacy/setup.py @@ -0,0 +1,17 @@ +#!/usr/bin/env python + +from setuptools import setup + + +setup( + name='legacy', + version='1.0.0', + author='Filipe Laíns', + author_email='lains@archlinux.org', + classifiers=[ + 'License :: OSI Approved :: MIT License', + 'Programming Language :: Python :: 2.7', + 'Programming Language :: Python :: 3', + ], + packages=['legacy'], +) diff --git a/tests/packages/test-bad-backend/pyproject.toml b/tests/packages/test-bad-backend/pyproject.toml new file mode 100644 index 0000000..c199a33 --- /dev/null +++ b/tests/packages/test-bad-backend/pyproject.toml @@ -0,0 +1,3 @@ +[build-system] +requires = [] +build-backend = "nonsense_package" diff --git a/tests/packages/test-bad-syntax/pyproject.toml b/tests/packages/test-bad-syntax/pyproject.toml new file mode 100644 index 0000000..cb84496 --- /dev/null +++ b/tests/packages/test-bad-syntax/pyproject.toml @@ -0,0 +1,2 @@ +[build-system] +requires = ['bad' 'syntax'] diff --git a/tests/packages/test-bad-wheel/backend_bad_wheel.py b/tests/packages/test-bad-wheel/backend_bad_wheel.py new file mode 100644 index 0000000..039cae0 --- /dev/null +++ b/tests/packages/test-bad-wheel/backend_bad_wheel.py @@ -0,0 +1,7 @@ +# SPDX-License-Identifier: MIT + +from setuptools.build_meta import build_sdist # noqa: F401 + + +def build_wheel(wheel_directory, config_settings=None, metadata_directory=None): + return 'not a wheel' diff --git a/tests/packages/test-bad-wheel/pyproject.toml b/tests/packages/test-bad-wheel/pyproject.toml new file mode 100644 index 0000000..77de5df --- /dev/null +++ b/tests/packages/test-bad-wheel/pyproject.toml @@ -0,0 +1,4 @@ +[build-system] +build-backend = 'backend_bad_wheel' +backend-path = ['.'] +requires = ['setuptools >= 42.0.0'] diff --git a/tests/packages/test-bad-wheel/setup.cfg b/tests/packages/test-bad-wheel/setup.cfg new file mode 100644 index 0000000..1a4be2f --- /dev/null +++ b/tests/packages/test-bad-wheel/setup.cfg @@ -0,0 +1,3 @@ +[metadata] +name = test_bad_wheel +version = 0.0.1 diff --git a/tests/packages/test-cant-build-via-sdist/backend_bad_sdist.py b/tests/packages/test-cant-build-via-sdist/backend_bad_sdist.py new file mode 100644 index 0000000..2afdb3d --- /dev/null +++ b/tests/packages/test-cant-build-via-sdist/backend_bad_sdist.py @@ -0,0 +1,23 @@ +# SPDX-License-Identifier: MIT + +import os.path +import tarfile +import zipfile + + +def build_sdist(sdist_directory, config_settings=None): + name = 'test_cant_build_via_sdist-1.0.0' + file = f'{name}.tar.gz' + with tarfile.open(os.path.join(sdist_directory, file), 'w') as t: + t.add('pyproject.toml', f'{name}/pyproject.toml') + t.add('backend_bad_sdist.py', f'{name}/backend_bad_sdist.py') + return file + + +def build_wheel(wheel_directory, config_settings=None, metadata_directory=None): + if not os.path.isfile('some-file-that-is-needed-for-build.txt'): + raise FileNotFoundError('some-file-that-is-needed-for-build.txt is missing!') + # pragma: no cover + file = 'test_cant_build_via_sdist-1.0.0-py2.py3-none-any.whl' + zipfile.ZipFile(os.path.join(wheel_directory, file), 'w').close() + return file diff --git a/tests/packages/test-cant-build-via-sdist/pyproject.toml b/tests/packages/test-cant-build-via-sdist/pyproject.toml new file mode 100644 index 0000000..e74afad --- /dev/null +++ b/tests/packages/test-cant-build-via-sdist/pyproject.toml @@ -0,0 +1,4 @@ +[build-system] +build-backend = 'backend_bad_sdist' +backend-path = ['.'] +requires = [] diff --git a/tests/packages/test-cant-build-via-sdist/some-file-that-is-needed-for-build.txt b/tests/packages/test-cant-build-via-sdist/some-file-that-is-needed-for-build.txt new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/tests/packages/test-cant-build-via-sdist/some-file-that-is-needed-for-build.txt diff --git a/tests/packages/test-flit/pyproject.toml b/tests/packages/test-flit/pyproject.toml new file mode 100644 index 0000000..9758b57 --- /dev/null +++ b/tests/packages/test-flit/pyproject.toml @@ -0,0 +1,13 @@ +[build-system] +requires = ['flit_core >=2,<3'] +build-backend = 'flit_core.buildapi' + +[tool.flit.metadata] +module = 'test_flit' +author = 'Filipe Laíns' +author-email = 'lains@archlinux.org' +classifiers = [ + 'License :: OSI Approved :: MIT License', + 'Programming Language :: Python :: 2.7', + 'Programming Language :: Python :: 3', +] diff --git a/tests/packages/test-flit/test_flit/__init__.py b/tests/packages/test-flit/test_flit/__init__.py new file mode 100644 index 0000000..264c2e3 --- /dev/null +++ b/tests/packages/test-flit/test_flit/__init__.py @@ -0,0 +1,6 @@ +# SPDX-License-Identifier: MIT + +""" +test_flit - Example flit package +""" +__version__ = '1.0.0' diff --git a/tests/packages/test-invalid-requirements/pyproject.toml b/tests/packages/test-invalid-requirements/pyproject.toml new file mode 100644 index 0000000..11974a0 --- /dev/null +++ b/tests/packages/test-invalid-requirements/pyproject.toml @@ -0,0 +1,3 @@ +[build-system] +requires = ['setuptools >= 42.0.0', 'wheel >= 0.36.0', 'this is invalid'] +build-backend = 'setuptools.build_meta' diff --git a/tests/packages/test-invalid-requirements/setup.cfg b/tests/packages/test-invalid-requirements/setup.cfg new file mode 100644 index 0000000..aa22d23 --- /dev/null +++ b/tests/packages/test-invalid-requirements/setup.cfg @@ -0,0 +1,3 @@ +[metadata] +name = test_invalid_requirements +version = 1.0.0 diff --git a/tests/packages/test-metadata/backend.py b/tests/packages/test-metadata/backend.py new file mode 100644 index 0000000..727dab9 --- /dev/null +++ b/tests/packages/test-metadata/backend.py @@ -0,0 +1,43 @@ +# SPDX-License-Identifier: MIT + +import pathlib +import textwrap + + +def get_requires_for_build_wheel(config_settings=None): + return ['tomli'] + + +def prepare_metadata_for_build_wheel(metadata_directory, config_settings=None): + import tomli + + with open('pyproject.toml', 'rb') as f: + metadata = tomli.load(f) + + distinfo = pathlib.Path( + metadata_directory, + '{}-{}.dist-info'.format( + metadata['project']['name'].replace('-', '-'), + metadata['project']['version'], + ), + ) + distinfo.mkdir(parents=True, exist_ok=True) + distinfo.joinpath('METADATA').write_text( + textwrap.dedent( + f''' + Metadata-Version: 2.2 + Name: {metadata['project']['name']} + Version: {metadata['project']['version']} + Summary: {metadata['project']['description']} + ''' + ).strip() + ) + return distinfo.name + + +def build_wheel(wheel_directory, config_settings=None, metadata_directory=None): + raise NotImplementedError + + +def build_sdist(sdist_directory, config_settings=None): + raise NotImplementedError diff --git a/tests/packages/test-metadata/pyproject.toml b/tests/packages/test-metadata/pyproject.toml new file mode 100644 index 0000000..3900263 --- /dev/null +++ b/tests/packages/test-metadata/pyproject.toml @@ -0,0 +1,14 @@ +[build-system] +requires = [] +build-backend = 'backend' +backend-path = ['.'] + +[project] +name = 'test-metadata' +version = '1.0.0' +description = 'hello!' + +[tool.black] +line-length = 127 +skip-string-normalization = true +target-version = ['py39', 'py38', 'py37', 'py36'] diff --git a/tests/packages/test-no-backend/pyproject.toml b/tests/packages/test-no-backend/pyproject.toml new file mode 100644 index 0000000..024e9e6 --- /dev/null +++ b/tests/packages/test-no-backend/pyproject.toml @@ -0,0 +1,2 @@ +[build-system] +requires = [] diff --git a/tests/packages/test-no-permission/pyproject.toml b/tests/packages/test-no-permission/pyproject.toml new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/tests/packages/test-no-permission/pyproject.toml diff --git a/tests/packages/test-no-prepare/backend_no_prepare.py b/tests/packages/test-no-prepare/backend_no_prepare.py new file mode 100644 index 0000000..206de1a --- /dev/null +++ b/tests/packages/test-no-prepare/backend_no_prepare.py @@ -0,0 +1,3 @@ +# SPDX-License-Identifier: MIT + +from setuptools.build_meta import build_sdist, build_wheel # noqa: F401 diff --git a/tests/packages/test-no-prepare/pyproject.toml b/tests/packages/test-no-prepare/pyproject.toml new file mode 100644 index 0000000..c6ca5f8 --- /dev/null +++ b/tests/packages/test-no-prepare/pyproject.toml @@ -0,0 +1,4 @@ +[build-system] +build-backend = 'backend_no_prepare' +backend-path = ['.'] +requires = ['setuptools >= 42.0.0', 'wheel >= 0.36.0'] diff --git a/tests/packages/test-no-prepare/setup.cfg b/tests/packages/test-no-prepare/setup.cfg new file mode 100644 index 0000000..c9e0a96 --- /dev/null +++ b/tests/packages/test-no-prepare/setup.cfg @@ -0,0 +1,3 @@ +[metadata] +name = test_no_prepare +version = 1.0.0 diff --git a/tests/packages/test-no-project/empty.txt b/tests/packages/test-no-project/empty.txt new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/tests/packages/test-no-project/empty.txt diff --git a/tests/packages/test-no-requires/pyproject.toml b/tests/packages/test-no-requires/pyproject.toml new file mode 100644 index 0000000..4f25948 --- /dev/null +++ b/tests/packages/test-no-requires/pyproject.toml @@ -0,0 +1,2 @@ +[build-system] +build-backend = 'something' diff --git a/tests/packages/test-optional-hooks/hookless_backend.py b/tests/packages/test-optional-hooks/hookless_backend.py new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/tests/packages/test-optional-hooks/hookless_backend.py diff --git a/tests/packages/test-optional-hooks/pyproject.toml b/tests/packages/test-optional-hooks/pyproject.toml new file mode 100644 index 0000000..2796891 --- /dev/null +++ b/tests/packages/test-optional-hooks/pyproject.toml @@ -0,0 +1,4 @@ +[build-system] +requires = [] +build-backend = 'hookless_backend' +backend-path = ['.'] diff --git a/tests/packages/test-setuptools/pyproject.toml b/tests/packages/test-setuptools/pyproject.toml new file mode 100644 index 0000000..b00a27a --- /dev/null +++ b/tests/packages/test-setuptools/pyproject.toml @@ -0,0 +1,3 @@ +[build-system] +requires = ['setuptools >= 42.0.0', 'wheel >= 0.36.0'] +build-backend = 'setuptools.build_meta' diff --git a/tests/packages/test-setuptools/setup.cfg b/tests/packages/test-setuptools/setup.cfg new file mode 100644 index 0000000..bf198b6 --- /dev/null +++ b/tests/packages/test-setuptools/setup.cfg @@ -0,0 +1,6 @@ +[metadata] +name = test_setuptools +version = 1.0.0 + +[bdist_wheel] +universal = 1 diff --git a/tests/packages/test-typo/pyproject.toml b/tests/packages/test-typo/pyproject.toml new file mode 100644 index 0000000..02d1af2 --- /dev/null +++ b/tests/packages/test-typo/pyproject.toml @@ -0,0 +1,3 @@ +[build_sytem] +requires = ['setuptools >= 40.8.0', 'wheel'] +build-backend = 'setuptools.build_meta' diff --git a/tests/test_env.py b/tests/test_env.py new file mode 100644 index 0000000..f6f381a --- /dev/null +++ b/tests/test_env.py @@ -0,0 +1,177 @@ +# SPDX-License-Identifier: MIT +import collections +import inspect +import logging +import platform +import subprocess +import sys +import sysconfig + +import pytest + +from packaging.version import Version + +import build.env + + +IS_PYPY3 = platform.python_implementation() == 'PyPy' + + +@pytest.mark.isolated +def test_isolation(): + subprocess.check_call([sys.executable, '-c', 'import build.env']) + with build.env.IsolatedEnvBuilder() as env: + with pytest.raises(subprocess.CalledProcessError): + debug = 'import sys; import os; print(os.linesep.join(sys.path));' + subprocess.check_call([env.executable, '-c', f'{debug} import build.env']) + + +@pytest.mark.isolated +def test_isolated_environment_install(mocker): + with build.env.IsolatedEnvBuilder() as env: + mocker.patch('build.env._subprocess') + + env.install([]) + build.env._subprocess.assert_not_called() + + env.install(['some', 'requirements']) + build.env._subprocess.assert_called() + args = build.env._subprocess.call_args[0][0][:-1] + assert args == [ + env.executable, + '-Im', + 'pip', + 'install', + '--use-pep517', + '--no-warn-script-location', + '-r', + ] + + +@pytest.mark.skipif(IS_PYPY3, reason='PyPy3 uses get path to create and provision venv') +@pytest.mark.skipif(sys.platform != 'darwin', reason='workaround for Apple Python') +def test_can_get_venv_paths_with_conflicting_default_scheme(mocker): + get_scheme_names = mocker.patch('sysconfig.get_scheme_names', return_value=('osx_framework_library',)) + with build.env.IsolatedEnvBuilder(): + pass + assert get_scheme_names.call_count == 1 + + +@pytest.mark.skipif('posix_local' not in sysconfig.get_scheme_names(), reason='workaround for Debian/Ubuntu Python') +def test_can_get_venv_paths_with_posix_local_default_scheme(mocker): + get_paths = mocker.spy(sysconfig, 'get_paths') + # We should never call this, but we patch it to ensure failure if we do + get_default_scheme = mocker.patch('sysconfig.get_default_scheme', return_value='posix_local') + with build.env.IsolatedEnvBuilder(): + pass + get_paths.assert_called_once_with(scheme='posix_prefix', vars=mocker.ANY) + assert get_default_scheme.call_count == 0 + + +def test_executable_missing_post_creation(mocker): + venv_create = mocker.patch('venv.EnvBuilder.create') + with pytest.raises(RuntimeError, match='Virtual environment creation failed, executable .* missing'): + with build.env.IsolatedEnvBuilder(): + pass + assert venv_create.call_count == 1 + + +def test_isolated_env_abstract(): + with pytest.raises(TypeError): + build.env.IsolatedEnv() + + +def test_isolated_env_has_executable_still_abstract(): + class Env(build.env.IsolatedEnv): + @property + def executable(self): + raise NotImplementedError + + with pytest.raises(TypeError): + Env() + + +def test_isolated_env_has_install_still_abstract(): + class Env(build.env.IsolatedEnv): + def install(self, requirements): + raise NotImplementedError + + with pytest.raises(TypeError): + Env() + + +@pytest.mark.pypy3323bug +def test_isolated_env_log(mocker, caplog, package_test_flit): + mocker.patch('build.env._subprocess') + caplog.set_level(logging.DEBUG) + + builder = build.env.IsolatedEnvBuilder() + frameinfo = inspect.getframeinfo(inspect.currentframe()) + builder.log('something') # line number 106 + with builder as env: + env.install(['something']) + + assert [(record.levelname, record.message) for record in caplog.records] == [ + ('INFO', 'something'), + ('INFO', 'Creating venv isolated environment...'), + ('INFO', 'Installing packages in isolated environment... (something)'), + ] + if sys.version_info >= (3, 8): # stacklevel + assert [(record.lineno) for record in caplog.records] == [ + frameinfo.lineno + 1, + frameinfo.lineno - 6, + frameinfo.lineno + 85, + ] + + +@pytest.mark.isolated +def test_default_pip_is_never_too_old(): + with build.env.IsolatedEnvBuilder() as env: + version = subprocess.check_output( + [env.executable, '-c', 'import pip; print(pip.__version__)'], universal_newlines=True + ).strip() + assert Version(version) >= Version('19.1') + + +@pytest.mark.isolated +@pytest.mark.parametrize('pip_version', ['20.2.0', '20.3.0', '21.0.0', '21.0.1']) +@pytest.mark.parametrize('arch', ['x86_64', 'arm64']) +def test_pip_needs_upgrade_mac_os_11(mocker, pip_version, arch): + SimpleNamespace = collections.namedtuple('SimpleNamespace', 'version') + + _subprocess = mocker.patch('build.env._subprocess') + mocker.patch('platform.system', return_value='Darwin') + mocker.patch('platform.machine', return_value=arch) + mocker.patch('platform.mac_ver', return_value=('11.0', ('', '', ''), '')) + metadata_name = 'importlib_metadata' if sys.version_info < (3, 8) else 'importlib.metadata' + mocker.patch(metadata_name + '.distributions', return_value=(SimpleNamespace(version=pip_version),)) + + min_version = Version('20.3' if arch == 'x86_64' else '21.0.1') + with build.env.IsolatedEnvBuilder(): + if Version(pip_version) < min_version: + print(_subprocess.call_args_list) + upgrade_call, uninstall_call = _subprocess.call_args_list + answer = 'pip>=20.3.0' if arch == 'x86_64' else 'pip>=21.0.1' + assert upgrade_call[0][0][1:] == ['-m', 'pip', 'install', answer] + assert uninstall_call[0][0][1:] == ['-m', 'pip', 'uninstall', 'setuptools', '-y'] + else: + (uninstall_call,) = _subprocess.call_args_list + assert uninstall_call[0][0][1:] == ['-m', 'pip', 'uninstall', 'setuptools', '-y'] + + +@pytest.mark.isolated +@pytest.mark.skipif(IS_PYPY3 and sys.platform.startswith('win'), reason='Isolated tests not supported on PyPy3 + Windows') +@pytest.mark.parametrize('has_symlink', [True, False] if sys.platform.startswith('win') else [True]) +def test_venv_symlink(mocker, has_symlink): + if has_symlink: + mocker.patch('os.symlink') + mocker.patch('os.unlink') + else: + mocker.patch('os.symlink', side_effect=OSError()) + + # Cache must be cleared to rerun + build.env._fs_supports_symlink.cache_clear() + supports_symlink = build.env._fs_supports_symlink() + build.env._fs_supports_symlink.cache_clear() + + assert supports_symlink is has_symlink diff --git a/tests/test_integration.py b/tests/test_integration.py new file mode 100644 index 0000000..bc2f4ff --- /dev/null +++ b/tests/test_integration.py @@ -0,0 +1,136 @@ +# SPDX-License-Identifier: MIT + +import os +import os.path +import platform +import re +import shutil +import subprocess +import sys +import tarfile +import urllib.request + +import filelock +import pytest + +import build.__main__ + + +IS_WINDOWS = sys.platform.startswith('win') +IS_PYPY3 = platform.python_implementation() == 'PyPy' + + +INTEGRATION_SOURCES = { + 'dateutil': ('dateutil/dateutil', '2.8.1'), + 'pip': ('pypa/pip', '20.2.1'), + 'Solaar': ('pwr-Solaar/Solaar', '1.0.3'), + 'flit': ('takluyver/flit', '2.3.0'), +} + +_SDIST = re.compile('.*.tar.gz') +_WHEEL = re.compile('.*.whl') +ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) + + +def get_project(name, tmp_path): + dest = tmp_path / name + if name == 'build': + # our own project is available in-source, just ignore development files + + def _ignore_folder(base, filenames): + ignore = [n for n in filenames if n in excl or any(n.endswith(i) for i in ('_cache', '.egg-info', '.pyc'))] + if os.path.basename == ROOT and 'build' in filenames: # ignore build only at root (our module is build too) + ignore.append('build') + return ignore + + excl = '.tox', 'dist', '.git', '__pycache__', '.integration-sources', '.github', 'tests', 'docs' + shutil.copytree(ROOT, str(dest), ignore=_ignore_folder) + return dest + + # for other projects download from github and cache it + tar_store = os.path.join(ROOT, '.integration-sources') + try: + os.makedirs(tar_store) + except OSError: # python 2 has no exist_ok, and checking with exists is not parallel safe + pass # just ignore, if the creation failed we will have another failure soon that will notify the user + + github_org_repo, version = INTEGRATION_SOURCES[name] + tar_filename = f'{name}-{version}.tar.gz' + tarball = os.path.join(tar_store, tar_filename) + with filelock.FileLock(os.path.join(tar_store, f'{tar_filename}.lock')): + if not os.path.exists(tarball): + url = f'https://github.com/{github_org_repo}/archive/{version}.tar.gz' + with urllib.request.urlopen(url) as request, open(tarball, 'wb') as file_handler: + shutil.copyfileobj(request, file_handler) + with tarfile.open(tarball, 'r:gz') as tar_handler: + tar_handler.extractall(str(dest)) + return dest / f'{name}-{version}' + + +@pytest.mark.parametrize( + 'call', + [ + None, # via code + [sys.executable, '-m', 'build'], # module + ['pyproject-build'], # entrypoint + ], + ids=['code', 'module', 'entrypoint'], +) +@pytest.mark.parametrize( + 'args', + [[], ['-x', '--no-isolation']], + ids=['isolated', 'no_isolation'], +) +@pytest.mark.parametrize( + 'project', + [ + 'build', + 'pip', + 'dateutil', + 'Solaar', + 'flit', + ], +) +@pytest.mark.isolated +def test_build(monkeypatch, project, args, call, tmp_path): + if project == 'flit' and '--no-isolation' in args: + pytest.xfail("can't build flit without isolation due to missing dependencies") + if project == 'Solaar' and IS_WINDOWS and IS_PYPY3: + pytest.xfail('Solaar fails building wheels via sdists on Windows on PyPy 3') + + monkeypatch.chdir(tmp_path) + monkeypatch.setenv('SETUPTOOLS_SCM_PRETEND_VERSION', '0+dummy') # for the projects that use setuptools_scm + + if call and call[0] == 'pyproject-build': + exe_name = f"pyproject-build{'.exe' if sys.platform.startswith('win') else ''}" + exe = os.path.join(os.path.dirname(sys.executable), exe_name) + if os.path.exists(exe): + call[0] = exe + else: + pytest.skip('Running via PYTHONPATH, so the pyproject-build entrypoint is not available') + path = get_project(project, tmp_path) + pkgs = tmp_path / 'pkgs' + args = [str(path), '-o', str(pkgs)] + args + + if call is None: + build.__main__.main(args) + else: + subprocess.check_call(call + args) + + pkg_names = os.listdir(str(pkgs)) + assert list(filter(_SDIST.match, pkg_names)) + assert list(filter(_WHEEL.match, pkg_names)) + + +def test_isolation(tmp_dir, package_test_flit, mocker): + try: + import flit_core # noqa: F401 + except ModuleNotFoundError: + pass + else: + pytest.xfail('flit_core is available -- we want it missing!') # pragma: no cover + + mocker.patch('build.__main__._error') + + build.__main__.main([package_test_flit, '-o', tmp_dir, '--no-isolation']) + build.__main__._error.assert_called_with("Backend 'flit_core.buildapi' is not available.") diff --git a/tests/test_main.py b/tests/test_main.py new file mode 100644 index 0000000..e1fbe0c --- /dev/null +++ b/tests/test_main.py @@ -0,0 +1,437 @@ +# SPDX-License-Identifier: MIT + +import contextlib +import importlib +import io +import os +import re +import subprocess +import sys +import venv + +import pytest + +import build +import build.__main__ + + +build_open_owner = 'builtins' + +cwd = os.getcwd() +out = os.path.join(cwd, 'dist') + + +@pytest.mark.parametrize( + ('cli_args', 'build_args', 'hook'), + [ + ( + [], + [cwd, out, ['wheel'], {}, True, False], + 'build_package_via_sdist', + ), + ( + ['-n'], + [cwd, out, ['wheel'], {}, False, False], + 'build_package_via_sdist', + ), + ( + ['-s'], + [cwd, out, ['sdist'], {}, True, False], + 'build_package', + ), + ( + ['-w'], + [cwd, out, ['wheel'], {}, True, False], + 'build_package', + ), + ( + ['-s', '-w'], + [cwd, out, ['sdist', 'wheel'], {}, True, False], + 'build_package', + ), + ( + ['source'], + ['source', os.path.join('source', 'dist'), ['wheel'], {}, True, False], + 'build_package_via_sdist', + ), + ( + ['-o', 'out'], + [cwd, 'out', ['wheel'], {}, True, False], + 'build_package_via_sdist', + ), + ( + ['source', '-o', 'out'], + ['source', 'out', ['wheel'], {}, True, False], + 'build_package_via_sdist', + ), + ( + ['-x'], + [cwd, out, ['wheel'], {}, True, True], + 'build_package_via_sdist', + ), + ( + ['-C--flag1', '-C--flag2'], + [cwd, out, ['wheel'], {'--flag1': '', '--flag2': ''}, True, False], + 'build_package_via_sdist', + ), + ( + ['-C--flag=value'], + [cwd, out, ['wheel'], {'--flag': 'value'}, True, False], + 'build_package_via_sdist', + ), + ( + ['-C--flag1=value', '-C--flag2=other_value', '-C--flag2=extra_value'], + [cwd, out, ['wheel'], {'--flag1': 'value', '--flag2': ['other_value', 'extra_value']}, True, False], + 'build_package_via_sdist', + ), + ], +) +def test_parse_args(mocker, cli_args, build_args, hook): + mocker.patch('build.__main__.build_package', return_value=['something']) + mocker.patch('build.__main__.build_package_via_sdist', return_value=['something']) + + build.__main__.main(cli_args) + + if hook == 'build_package': + build.__main__.build_package.assert_called_with(*build_args) + elif hook == 'build_package_via_sdist': + build.__main__.build_package_via_sdist.assert_called_with(*build_args) + else: + raise ValueError(f'Unknown hook {hook}') # pragma: no cover + + +def test_prog(): + out = io.StringIO() + + with pytest.raises(SystemExit): + with contextlib.redirect_stdout(out): + build.__main__.main(['--help'], prog='something') + + assert out.getvalue().startswith('usage: something [-h]') + + +def test_version(capsys): + with pytest.raises(SystemExit): + build.__main__.main(['--version']) + out, err = capsys.readouterr() + assert out.startswith(f'build {build.__version__}') + + +@pytest.mark.isolated +def test_build_isolated(mocker, package_test_flit): + build_cmd = mocker.patch('build.ProjectBuilder.build', return_value='something') + required_cmd = mocker.patch( + 'build.ProjectBuilder.get_requires_for_build', + side_effect=[ + ['dep1', 'dep2'], + ], + ) + mocker.patch('build.__main__._error') + install = mocker.patch('build.env._IsolatedEnvVenvPip.install') + + build.__main__.build_package(package_test_flit, '.', ['sdist']) + + install.assert_any_call({'flit_core >=2,<3'}) + + required_cmd.assert_called_with('sdist') + install.assert_any_call(['dep1', 'dep2']) + + build_cmd.assert_called_with('sdist', '.', {}) + + +def test_build_no_isolation_check_deps_empty(mocker, package_test_flit): + # check_dependencies = [] + build_cmd = mocker.patch('build.ProjectBuilder.build', return_value='something') + mocker.patch('build.ProjectBuilder.check_dependencies', return_value=[]) + + build.__main__.build_package(package_test_flit, '.', ['sdist'], isolation=False) + + build_cmd.assert_called_with('sdist', '.', {}) + + +@pytest.mark.parametrize( + ['missing_deps', 'output'], + [ + ([('foo',)], '\n\tfoo'), + ([('foo',), ('bar', 'baz', 'qux')], '\n\tfoo\n\tbar\n\tbaz -> qux'), + ], +) +def test_build_no_isolation_with_check_deps(mocker, package_test_flit, missing_deps, output): + error = mocker.patch('build.__main__._error') + build_cmd = mocker.patch('build.ProjectBuilder.build', return_value='something') + mocker.patch('build.ProjectBuilder.check_dependencies', return_value=missing_deps) + + build.__main__.build_package(package_test_flit, '.', ['sdist'], isolation=False) + + build_cmd.assert_called_with('sdist', '.', {}) + error.assert_called_with('Missing dependencies:' + output) + + +@pytest.mark.isolated +def test_build_raises_build_exception(mocker, package_test_flit): + mocker.patch('build.ProjectBuilder.get_requires_for_build', side_effect=build.BuildException) + mocker.patch('build.env._IsolatedEnvVenvPip.install') + + with pytest.raises(build.BuildException): + build.__main__.build_package(package_test_flit, '.', ['sdist']) + + +@pytest.mark.isolated +def test_build_raises_build_backend_exception(mocker, package_test_flit): + mocker.patch('build.ProjectBuilder.get_requires_for_build', side_effect=build.BuildBackendException(Exception('a'))) + mocker.patch('build.env._IsolatedEnvVenvPip.install') + + msg = f"Backend operation failed: Exception('a'{',' if sys.version_info < (3, 7) else ''})" + with pytest.raises(build.BuildBackendException, match=re.escape(msg)): + build.__main__.build_package(package_test_flit, '.', ['sdist']) + + +@pytest.mark.pypy3323bug +def test_build_package(tmp_dir, package_test_setuptools): + build.__main__.build_package(package_test_setuptools, tmp_dir, ['sdist', 'wheel']) + + assert sorted(os.listdir(tmp_dir)) == [ + 'test_setuptools-1.0.0-py2.py3-none-any.whl', + 'test_setuptools-1.0.0.tar.gz', + ] + + +@pytest.mark.pypy3323bug +def test_build_package_via_sdist(tmp_dir, package_test_setuptools): + build.__main__.build_package_via_sdist(package_test_setuptools, tmp_dir, ['wheel']) + + assert sorted(os.listdir(tmp_dir)) == [ + 'test_setuptools-1.0.0-py2.py3-none-any.whl', + 'test_setuptools-1.0.0.tar.gz', + ] + + +@pytest.mark.pypy3323bug +def test_build_package_via_sdist_cant_build(tmp_dir, package_test_cant_build_via_sdist): + with pytest.raises(build.BuildBackendException): + build.__main__.build_package_via_sdist(package_test_cant_build_via_sdist, tmp_dir, ['wheel']) + + +def test_build_package_via_sdist_invalid_distribution(tmp_dir, package_test_setuptools): + with pytest.raises(ValueError, match='Only binary distributions are allowed but sdist was specified'): + build.__main__.build_package_via_sdist(package_test_setuptools, tmp_dir, ['sdist']) + + +@pytest.mark.pypy3323bug +@pytest.mark.parametrize( + ('args', 'output'), + [ + ( + [], + [ + '* Creating venv isolated environment...', + '* Installing packages in isolated environment... (setuptools >= 42.0.0, wheel >= 0.36.0)', + '* Getting build dependencies for sdist...', + '* Building sdist...', + '* Building wheel from sdist', + '* Creating venv isolated environment...', + '* Installing packages in isolated environment... (setuptools >= 42.0.0, wheel >= 0.36.0)', + '* Getting build dependencies for wheel...', + '* Installing packages in isolated environment... (wheel)', + '* Building wheel...', + 'Successfully built test_setuptools-1.0.0.tar.gz and test_setuptools-1.0.0-py2.py3-none-any.whl', + ], + ), + ( + ['--no-isolation'], + [ + '* Getting build dependencies for sdist...', + '* Building sdist...', + '* Building wheel from sdist', + '* Getting build dependencies for wheel...', + '* Building wheel...', + 'Successfully built test_setuptools-1.0.0.tar.gz and test_setuptools-1.0.0-py2.py3-none-any.whl', + ], + ), + ( + ['--wheel'], + [ + '* Creating venv isolated environment...', + '* Installing packages in isolated environment... (setuptools >= 42.0.0, wheel >= 0.36.0)', + '* Getting build dependencies for wheel...', + '* Installing packages in isolated environment... (wheel)', + '* Building wheel...', + 'Successfully built test_setuptools-1.0.0-py2.py3-none-any.whl', + ], + ), + ( + ['--wheel', '--no-isolation'], + [ + '* Getting build dependencies for wheel...', + '* Building wheel...', + 'Successfully built test_setuptools-1.0.0-py2.py3-none-any.whl', + ], + ), + ( + ['--sdist', '--no-isolation'], + [ + '* Getting build dependencies for sdist...', + '* Building sdist...', + 'Successfully built test_setuptools-1.0.0.tar.gz', + ], + ), + ( + ['--sdist', '--wheel', '--no-isolation'], + [ + '* Getting build dependencies for sdist...', + '* Building sdist...', + '* Getting build dependencies for wheel...', + '* Building wheel...', + 'Successfully built test_setuptools-1.0.0.tar.gz and test_setuptools-1.0.0-py2.py3-none-any.whl', + ], + ), + ], + ids=[ + 'via-sdist-isolation', + 'via-sdist-no-isolation', + 'wheel-direct-isolation', + 'wheel-direct-no-isolation', + 'sdist-direct-no-isolation', + 'sdist-and-wheel-direct-no-isolation', + ], +) +@pytest.mark.flaky(reruns=5) +def test_output(package_test_setuptools, tmp_dir, capsys, args, output): + build.__main__.main([package_test_setuptools, '-o', tmp_dir] + args) + stdout, stderr = capsys.readouterr() + assert stdout.splitlines() == output + + +@pytest.fixture() +def main_reload_styles(): + try: + yield + finally: + importlib.reload(build.__main__) + + +@pytest.mark.pypy3323bug +@pytest.mark.parametrize( + ('color', 'stdout_error', 'stdout_body'), + [ + ( + False, + 'ERROR ', + [ + '* Creating venv isolated environment...', + '* Installing packages in isolated environment... (setuptools >= 42.0.0, this is invalid, wheel >= 0.36.0)', + '', + 'Traceback (most recent call last):', + ], + ), + ( + True, + '\33[91mERROR\33[0m ', + [ + '\33[1m* Creating venv isolated environment...\33[0m', + '\33[1m* Installing packages in isolated environment... ' + '(setuptools >= 42.0.0, this is invalid, wheel >= 0.36.0)\33[0m', + '', + '\33[2mTraceback (most recent call last):', + ], + ), + ], + ids=['no-color', 'color'], +) +def test_output_env_subprocess_error( + mocker, + monkeypatch, + main_reload_styles, + package_test_invalid_requirements, + tmp_dir, + capsys, + color, + stdout_body, + stdout_error, +): + try: + # do not inject hook to have clear output on capsys + mocker.patch('colorama.init') + except ModuleNotFoundError: # colorama might not be available + pass + + monkeypatch.delenv('NO_COLOR', raising=False) + monkeypatch.setenv('FORCE_COLOR' if color else 'NO_COLOR', '') + + importlib.reload(build.__main__) # reload module to set _STYLES + + with pytest.raises(SystemExit): + build.__main__.main([package_test_invalid_requirements, '-o', tmp_dir]) + stdout, stderr = capsys.readouterr() + stdout, stderr = stdout.splitlines(), stderr.splitlines() + + assert stdout[:4] == stdout_body + assert stdout[-1].startswith(stdout_error) + + assert len(stderr) == 1 + assert stderr[0].startswith('ERROR: Invalid requirement: ') + + +@pytest.mark.parametrize( + ('tty', 'env', 'colors'), + [ + (False, {}, build.__main__._NO_COLORS), + (True, {}, build.__main__._COLORS), + (False, {'NO_COLOR': ''}, build.__main__._NO_COLORS), + (True, {'NO_COLOR': ''}, build.__main__._NO_COLORS), + (False, {'FORCE_COLOR': ''}, build.__main__._COLORS), + (True, {'FORCE_COLOR': ''}, build.__main__._COLORS), + ], +) +def test_colors(mocker, monkeypatch, main_reload_styles, tty, env, colors): + mocker.patch('sys.stdout.isatty', return_value=tty) + for key, value in env.items(): + monkeypatch.setenv(key, value) + + importlib.reload(build.__main__) # reload module to set _STYLES + + assert build.__main__._STYLES == colors + + +def test_colors_conflict(monkeypatch, main_reload_styles): + with monkeypatch.context() as m: + m.setenv('NO_COLOR', '') + m.setenv('FORCE_COLOR', '') + + with pytest.warns( + UserWarning, + match='Both NO_COLOR and FORCE_COLOR environment variables are set, disabling color', + ): + importlib.reload(build.__main__) + + assert build.__main__._STYLES == build.__main__._NO_COLORS + + +def raise_called_process_err(*args, **kwargs): + raise subprocess.CalledProcessError(1, ['test', 'args'], b'stdoutput', b'stderror') + + +def test_venv_fail(monkeypatch, package_test_flit, tmp_dir, capsys): + monkeypatch.setattr(venv.EnvBuilder, 'create', raise_called_process_err) + monkeypatch.setenv('NO_COLOR', '') + + importlib.reload(build.__main__) # reload module to set _STYLES + + with pytest.raises(SystemExit): + build.__main__.main([package_test_flit, '-o', tmp_dir]) + + stdout, stderr = capsys.readouterr() + + assert ( + stdout + == '''\ +* Creating venv isolated environment... +ERROR Failed to create venv. Maybe try installing virtualenv. + Command 'test args' failed with return code 1 + stdout: + stdoutput + stderr: + stderror +''' + ) + assert stderr == '' diff --git a/tests/test_module.py b/tests/test_module.py new file mode 100644 index 0000000..1d3d1cc --- /dev/null +++ b/tests/test_module.py @@ -0,0 +1,16 @@ +# SPDX-License-Identifier: MIT + +import sys + +import pytest + +import build + + +def test_version(): + assert build.__version__ + + +@pytest.mark.skipif(sys.version_info < (3, 7), reason='Python 3.7+ required for dir support') +def test_dir(): + assert set(dir(build)) == set(build.__all__) diff --git a/tests/test_projectbuilder.py b/tests/test_projectbuilder.py new file mode 100644 index 0000000..57ff9f9 --- /dev/null +++ b/tests/test_projectbuilder.py @@ -0,0 +1,672 @@ +# SPDX-License-Identifier: MIT + + +import copy +import importlib +import logging +import os +import sys +import textwrap + +import pep517.wrappers +import pytest + +import build + + +if sys.version_info >= (3, 8): # pragma: no cover + from importlib import metadata as importlib_metadata +else: # pragma: no cover + import importlib_metadata + +import pathlib + + +build_open_owner = 'builtins' + + +DEFAULT_BACKEND = { + 'build-backend': 'setuptools.build_meta:__legacy__', + 'requires': ['setuptools >= 40.8.0', 'wheel'], +} + + +class MockDistribution(importlib_metadata.Distribution): + def locate_file(self, path): # pragma: no cover + return '' + + @classmethod + def from_name(cls, name): + if name == 'extras_dep': + return ExtraMockDistribution() + elif name == 'requireless_dep': + return RequirelessMockDistribution() + elif name == 'recursive_dep': + return RecursiveMockDistribution() + elif name == 'prerelease_dep': + return PrereleaseMockDistribution() + elif name == 'circular_dep': + return CircularMockDistribution() + elif name == 'nested_circular_dep': + return NestedCircularMockDistribution() + raise importlib_metadata.PackageNotFoundError + + +class ExtraMockDistribution(MockDistribution): + def read_text(self, filename): + if filename == 'METADATA': + return textwrap.dedent( + """ + Metadata-Version: 2.2 + Name: extras_dep + Version: 1.0.0 + Provides-Extra: extra_without_associated_deps + Provides-Extra: extra_with_unmet_deps + Requires-Dist: unmet_dep; extra == 'extra_with_unmet_deps' + Provides-Extra: extra_with_met_deps + Requires-Dist: extras_dep; extra == 'extra_with_met_deps' + Provides-Extra: recursive_extra_with_unmet_deps + Requires-Dist: recursive_dep; extra == 'recursive_extra_with_unmet_deps' + """ + ).strip() + + +class RequirelessMockDistribution(MockDistribution): + def read_text(self, filename): + if filename == 'METADATA': + return textwrap.dedent( + """ + Metadata-Version: 2.2 + Name: requireless_dep + Version: 1.0.0 + """ + ).strip() + + +class RecursiveMockDistribution(MockDistribution): + def read_text(self, filename): + if filename == 'METADATA': + return textwrap.dedent( + """ + Metadata-Version: 2.2 + Name: recursive_dep + Version: 1.0.0 + Requires-Dist: recursive_unmet_dep + """ + ).strip() + + +class PrereleaseMockDistribution(MockDistribution): + def read_text(self, filename): + if filename == 'METADATA': + return textwrap.dedent( + """ + Metadata-Version: 2.2 + Name: prerelease_dep + Version: 1.0.1a0 + """ + ).strip() + + +class CircularMockDistribution(MockDistribution): + def read_text(self, filename): + if filename == 'METADATA': + return textwrap.dedent( + """ + Metadata-Version: 2.2 + Name: circular_dep + Version: 1.0.0 + Requires-Dist: nested_circular_dep + """ + ).strip() + + +class NestedCircularMockDistribution(MockDistribution): + def read_text(self, filename): + if filename == 'METADATA': + return textwrap.dedent( + """ + Metadata-Version: 2.2 + Name: nested_circular_dep + Version: 1.0.0 + Requires-Dist: circular_dep + """ + ).strip() + + +@pytest.mark.parametrize( + ('requirement_string', 'expected'), + [ + ('extras_dep', None), + ('missing_dep', ('missing_dep',)), + ('requireless_dep', None), + ('extras_dep[undefined_extra]', None), + # would the wheel builder filter this out? + ('extras_dep[extra_without_associated_deps]', None), + ( + 'extras_dep[extra_with_unmet_deps]', + ('extras_dep[extra_with_unmet_deps]', 'unmet_dep; extra == "extra_with_unmet_deps"'), + ), + ( + 'extras_dep[recursive_extra_with_unmet_deps]', + ( + 'extras_dep[recursive_extra_with_unmet_deps]', + 'recursive_dep; extra == "recursive_extra_with_unmet_deps"', + 'recursive_unmet_dep', + ), + ), + ('extras_dep[extra_with_met_deps]', None), + ('missing_dep; python_version>"10"', None), + ('missing_dep; python_version<="1"', None), + ('missing_dep; python_version>="1"', ('missing_dep; python_version >= "1"',)), + ('extras_dep == 1.0.0', None), + ('extras_dep == 2.0.0', ('extras_dep==2.0.0',)), + ('extras_dep[extra_without_associated_deps] == 1.0.0', None), + ('extras_dep[extra_without_associated_deps] == 2.0.0', ('extras_dep[extra_without_associated_deps]==2.0.0',)), + ('prerelease_dep >= 1.0.0', None), + ('circular_dep', None), + ], +) +def test_check_dependency(monkeypatch, requirement_string, expected): + monkeypatch.setattr(importlib_metadata, 'Distribution', MockDistribution) + assert next(build.check_dependency(requirement_string), None) == expected + + +def test_bad_project(package_test_no_project): + # Passing a nonexistent project directory + with pytest.raises(build.BuildException): + build.ProjectBuilder(os.path.join(package_test_no_project, 'does-not-exist')) + # Passing a file as a project directory + with pytest.raises(build.BuildException): + build.ProjectBuilder(os.path.join(package_test_no_project, 'empty.txt')) + # Passing a project directory with no pyproject.toml or setup.py + with pytest.raises(build.BuildException): + build.ProjectBuilder(package_test_no_project) + + +def test_init(mocker, package_test_flit, package_legacy, test_no_permission, package_test_bad_syntax): + mocker.patch('pep517.wrappers.Pep517HookCaller') + + # correct flit pyproject.toml + builder = build.ProjectBuilder(package_test_flit) + pep517.wrappers.Pep517HookCaller.assert_called_with( + package_test_flit, 'flit_core.buildapi', backend_path=None, python_executable=sys.executable, runner=builder._runner + ) + pep517.wrappers.Pep517HookCaller.reset_mock() + + # custom python + builder = build.ProjectBuilder(package_test_flit, python_executable='some-python') + pep517.wrappers.Pep517HookCaller.assert_called_with( + package_test_flit, 'flit_core.buildapi', backend_path=None, python_executable='some-python', runner=builder._runner + ) + pep517.wrappers.Pep517HookCaller.reset_mock() + + # FileNotFoundError + builder = build.ProjectBuilder(package_legacy) + pep517.wrappers.Pep517HookCaller.assert_called_with( + package_legacy, + 'setuptools.build_meta:__legacy__', + backend_path=None, + python_executable=sys.executable, + runner=builder._runner, + ) + + # PermissionError + if not sys.platform.startswith('win'): # can't correctly set the permissions required for this + with pytest.raises(build.BuildException): + build.ProjectBuilder(test_no_permission) + + # TomlDecodeError + with pytest.raises(build.BuildException): + build.ProjectBuilder(package_test_bad_syntax) + + +@pytest.mark.parametrize('value', [b'something', 'something_else']) +def test_python_executable(package_test_flit, value): + builder = build.ProjectBuilder(package_test_flit) + + builder.python_executable = value + assert builder.python_executable == value + assert builder._hook.python_executable == value + + +@pytest.mark.parametrize('distribution', ['wheel', 'sdist']) +def test_get_requires_for_build_missing_backend(packages_path, distribution): + bad_backend_path = os.path.join(packages_path, 'test-bad-backend') + builder = build.ProjectBuilder(bad_backend_path) + + with pytest.raises(build.BuildBackendException): + builder.get_requires_for_build(distribution) + + +@pytest.mark.parametrize('distribution', ['wheel', 'sdist']) +def test_get_requires_for_build_missing_optional_hooks(package_test_optional_hooks, distribution): + builder = build.ProjectBuilder(package_test_optional_hooks) + + assert builder.get_requires_for_build(distribution) == set() + + +@pytest.mark.parametrize('distribution', ['wheel', 'sdist']) +def test_build_missing_backend(packages_path, distribution, tmpdir): + bad_backend_path = os.path.join(packages_path, 'test-bad-backend') + builder = build.ProjectBuilder(bad_backend_path) + + with pytest.raises(build.BuildBackendException): + builder.build(distribution, str(tmpdir)) + + +def test_check_dependencies(mocker, package_test_flit): + mocker.patch('pep517.wrappers.Pep517HookCaller.get_requires_for_build_sdist') + mocker.patch('pep517.wrappers.Pep517HookCaller.get_requires_for_build_wheel') + + builder = build.ProjectBuilder(package_test_flit) + + side_effects = [ + [], + ['something'], + pep517.wrappers.BackendUnavailable, + ] + + builder._hook.get_requires_for_build_sdist.side_effect = copy.copy(side_effects) + builder._hook.get_requires_for_build_wheel.side_effect = copy.copy(side_effects) + + # requires = [] + assert builder.check_dependencies('sdist') == {('flit_core<3,>=2',)} + assert builder.check_dependencies('wheel') == {('flit_core<3,>=2',)} + + # requires = ['something'] + assert builder.check_dependencies('sdist') == {('flit_core<3,>=2',), ('something',)} + assert builder.check_dependencies('wheel') == {('flit_core<3,>=2',), ('something',)} + + # BackendUnavailable + with pytest.raises(build.BuildBackendException): + builder.check_dependencies('sdist') + with pytest.raises(build.BuildBackendException): + not builder.check_dependencies('wheel') + + +def test_working_directory(tmp_dir): + assert os.path.realpath(os.curdir) != os.path.realpath(tmp_dir) + with build._working_directory(tmp_dir): + assert os.path.realpath(os.curdir) == os.path.realpath(tmp_dir) + + +def test_working_directory_exc_is_not_transformed(mocker, package_test_flit, tmp_dir): + mocker.patch('build._working_directory', side_effect=OSError) + + builder = build.ProjectBuilder(package_test_flit) + with pytest.raises(OSError): + builder._call_backend('build_sdist', tmp_dir) + + +def test_build(mocker, package_test_flit, tmp_dir): + mocker.patch('pep517.wrappers.Pep517HookCaller', autospec=True) + mocker.patch('build._working_directory', autospec=True) + + builder = build.ProjectBuilder(package_test_flit) + + builder._hook.build_sdist.side_effect = ['dist.tar.gz', Exception] + builder._hook.build_wheel.side_effect = ['dist.whl', Exception] + + assert builder.build('sdist', tmp_dir) == os.path.join(tmp_dir, 'dist.tar.gz') + builder._hook.build_sdist.assert_called_with(tmp_dir, None) + build._working_directory.assert_called_with(package_test_flit) + + assert builder.build('wheel', tmp_dir) == os.path.join(tmp_dir, 'dist.whl') + builder._hook.build_wheel.assert_called_with(tmp_dir, None) + build._working_directory.assert_called_with(package_test_flit) + + with pytest.raises(build.BuildBackendException): + build._working_directory.assert_called_with(package_test_flit) + builder.build('sdist', tmp_dir) + + with pytest.raises(build.BuildBackendException): + build._working_directory.assert_called_with(package_test_flit) + builder.build('wheel', tmp_dir) + + +def test_default_backend(mocker, package_legacy): + mocker.patch('pep517.wrappers.Pep517HookCaller', autospec=True) + + builder = build.ProjectBuilder(package_legacy) + + assert builder._build_system == DEFAULT_BACKEND + + +def test_missing_backend(mocker, package_test_no_backend): + mocker.patch('pep517.wrappers.Pep517HookCaller', autospec=True) + + builder = build.ProjectBuilder(package_test_no_backend) + + assert builder._build_system == {'requires': [], 'build-backend': DEFAULT_BACKEND['build-backend']} + + +def test_missing_requires(mocker, package_test_no_requires): + mocker.patch('pep517.wrappers.Pep517HookCaller', autospec=True) + + with pytest.raises(build.BuildException): + build.ProjectBuilder(package_test_no_requires) + + +def test_build_system_typo(mocker, package_test_typo): + mocker.patch('pep517.wrappers.Pep517HookCaller', autospec=True) + + with pytest.warns(build.TypoWarning): + build.ProjectBuilder(package_test_typo) + + +def test_missing_outdir(mocker, tmp_dir, package_test_flit): + mocker.patch('pep517.wrappers.Pep517HookCaller', autospec=True) + + builder = build.ProjectBuilder(package_test_flit) + builder._hook.build_sdist.return_value = 'dist.tar.gz' + out = os.path.join(tmp_dir, 'out') + + builder.build('sdist', out) + + assert os.path.isdir(out) + + +def test_relative_outdir(mocker, tmp_dir, package_test_flit): + mocker.patch('pep517.wrappers.Pep517HookCaller', autospec=True) + + builder = build.ProjectBuilder(package_test_flit) + builder._hook.build_sdist.return_value = 'dist.tar.gz' + + builder.build('sdist', '.') + + builder._hook.build_sdist.assert_called_with(os.path.abspath('.'), None) + + +def test_build_not_dir_outdir(mocker, tmp_dir, package_test_flit): + mocker.patch('pep517.wrappers.Pep517HookCaller', autospec=True) + + builder = build.ProjectBuilder(package_test_flit) + builder._hook.build_sdist.return_value = 'dist.tar.gz' + out = os.path.join(tmp_dir, 'out') + + open(out, 'a').close() # create empty file + + with pytest.raises(build.BuildException): + builder.build('sdist', out) + + +@pytest.fixture(scope='session') +def demo_pkg_inline(tmp_path_factory): + # builds a wheel without any dependencies and with a console script demo-pkg-inline + tmp_path = tmp_path_factory.mktemp('demo-pkg-inline') + builder = build.ProjectBuilder(srcdir=os.path.join(os.path.dirname(__file__), 'packages', 'inline')) + out = tmp_path / 'dist' + builder.build('wheel', str(out)) + return next(out.iterdir()) + + +@pytest.mark.isolated +def test_build_with_dep_on_console_script(tmp_path, demo_pkg_inline, capfd, mocker): + """ + All command-line scripts provided by the build-required packages must be present in the build environment's PATH. + """ + # we first install demo pkg inline as build dependency (as this provides a console script we can check) + # to validate backend invocations contain the correct path we use an inline backend that will fail, but first + # provides the PATH information (and validates shutil.which is able to discover the executable - as PEP states) + toml = textwrap.dedent( + ''' + [build-system] + requires = ["demo_pkg_inline"] + build-backend = "build" + backend-path = ["."] + + [project] + description = "Factory ⸻ A code generator 🏭" + authors = [{name = "Łukasz Langa"}] + ''' + ) + code = textwrap.dedent( + ''' + import os + import shutil + import sys + print("BB " + os.environ["PATH"]) + exe_at = shutil.which("demo-pkg-inline") + print("BB " + exe_at) + ''' + ) + (tmp_path / 'pyproject.toml').write_text(toml, encoding='UTF-8') + (tmp_path / 'build.py').write_text(code) + + deps = {str(demo_pkg_inline)} # we patch the requires demo_pkg_inline to refer to the wheel -> we don't need index + mocker.patch('build.ProjectBuilder.build_system_requires', new_callable=mocker.PropertyMock, return_value=deps) + from build.__main__ import main + + with pytest.raises(SystemExit): + main(['--wheel', '--outdir', str(tmp_path / 'dist'), str(tmp_path)]) + + out, err = capfd.readouterr() + lines = [line[3:] for line in out.splitlines() if line.startswith('BB ')] # filter for our markers + path_vars = lines[0].split(os.pathsep) + which_detected = lines[1] + assert which_detected.startswith(path_vars[0]), out + + +def test_prepare(mocker, tmp_dir, package_test_flit): + mocker.patch('pep517.wrappers.Pep517HookCaller', autospec=True) + mocker.patch('build._working_directory', autospec=True) + + builder = build.ProjectBuilder(package_test_flit) + builder._hook.prepare_metadata_for_build_wheel.return_value = 'dist-1.0.dist-info' + + assert builder.prepare('wheel', tmp_dir) == os.path.join(tmp_dir, 'dist-1.0.dist-info') + builder._hook.prepare_metadata_for_build_wheel.assert_called_with(tmp_dir, None, _allow_fallback=False) + build._working_directory.assert_called_with(package_test_flit) + + +def test_prepare_no_hook(mocker, tmp_dir, package_test_flit): + mocker.patch('pep517.wrappers.Pep517HookCaller', autospec=True) + + builder = build.ProjectBuilder(package_test_flit) + failure = pep517.wrappers.HookMissing('prepare_metadata_for_build_wheel') + builder._hook.prepare_metadata_for_build_wheel.side_effect = failure + + assert builder.prepare('wheel', tmp_dir) is None + + +def test_prepare_error(mocker, tmp_dir, package_test_flit): + mocker.patch('pep517.wrappers.Pep517HookCaller', autospec=True) + + builder = build.ProjectBuilder(package_test_flit) + builder._hook.prepare_metadata_for_build_wheel.side_effect = Exception + + with pytest.raises(build.BuildBackendException, match='Backend operation failed: Exception'): + builder.prepare('wheel', tmp_dir) + + +def test_prepare_not_dir_outdir(mocker, tmp_dir, package_test_flit): + mocker.patch('pep517.wrappers.Pep517HookCaller', autospec=True) + + builder = build.ProjectBuilder(package_test_flit) + + out = os.path.join(tmp_dir, 'out') + with open(out, 'w') as f: + f.write('Not a directory') + with pytest.raises(build.BuildException, match='Build path .* exists and is not a directory'): + builder.prepare('wheel', out) + + +def test_no_outdir_single(mocker, tmp_dir, package_test_flit): + mocker.patch('pep517.wrappers.Pep517HookCaller.prepare_metadata_for_build_wheel', return_value='') + + builder = build.ProjectBuilder(package_test_flit) + + out = os.path.join(tmp_dir, 'out') + builder.prepare('wheel', out) + + assert os.path.isdir(out) + + +def test_no_outdir_multiple(mocker, tmp_dir, package_test_flit): + mocker.patch('pep517.wrappers.Pep517HookCaller.prepare_metadata_for_build_wheel', return_value='') + + builder = build.ProjectBuilder(package_test_flit) + + out = os.path.join(tmp_dir, 'does', 'not', 'exist') + builder.prepare('wheel', out) + + assert os.path.isdir(out) + + +def test_runner_user_specified(tmp_dir, package_test_flit): + def dummy_runner(cmd, cwd=None, env=None): + raise RuntimeError('Runner was called') + + builder = build.ProjectBuilder(package_test_flit, runner=dummy_runner) + with pytest.raises(build.BuildBackendException, match='Runner was called'): + builder.build('wheel', tmp_dir) + + +def test_metadata_path_no_prepare(tmp_dir, package_test_no_prepare): + builder = build.ProjectBuilder(package_test_no_prepare) + + metadata = importlib_metadata.PathDistribution( + pathlib.Path(builder.metadata_path(tmp_dir)), + ).metadata + + assert metadata['name'] == 'test-no-prepare' + assert metadata['Version'] == '1.0.0' + + +def test_metadata_path_with_prepare(tmp_dir, package_test_setuptools): + builder = build.ProjectBuilder(package_test_setuptools) + + metadata = importlib_metadata.PathDistribution( + pathlib.Path(builder.metadata_path(tmp_dir)), + ).metadata + + assert metadata['name'] == 'test-setuptools' + assert metadata['Version'] == '1.0.0' + + +def test_metadata_path_legacy(tmp_dir, package_legacy): + builder = build.ProjectBuilder(package_legacy) + + metadata = importlib_metadata.PathDistribution( + pathlib.Path(builder.metadata_path(tmp_dir)), + ).metadata + + assert metadata['name'] == 'legacy' + assert metadata['Version'] == '1.0.0' + + +def test_metadata_invalid_wheel(tmp_dir, package_test_bad_wheel): + builder = build.ProjectBuilder(package_test_bad_wheel) + + with pytest.raises(ValueError, match='Invalid wheel'): + builder.metadata_path(tmp_dir) + + +@pytest.fixture +def mock_tomli_not_available(mocker): + loads = mocker.patch('tomli.loads') + mocker.patch.dict(sys.modules, {'tomli': None}) + importlib.reload(build) + try: + yield + finally: + loads.assert_not_called() + mocker.stopall() + importlib.reload(build) + + +@pytest.mark.skipif(sys.version_info >= (3, 11), reason='No need to test old toml support on 3.11+') +def test_toml_instead_of_tomli(mocker, mock_tomli_not_available, tmp_dir, package_test_flit): + mocker.patch('pep517.wrappers.Pep517HookCaller', autospec=True) + + builder = build.ProjectBuilder(package_test_flit) + builder._hook.build_sdist.return_value = 'dist.tar.gz' + + builder.build('sdist', '.') + + builder._hook.build_sdist.assert_called_with(os.path.abspath('.'), None) + + +def test_log(mocker, caplog, package_test_flit): + mocker.patch('pep517.wrappers.Pep517HookCaller', autospec=True) + mocker.patch('build.ProjectBuilder._call_backend', return_value='some_path') + caplog.set_level(logging.DEBUG) + + builder = build.ProjectBuilder(package_test_flit) + builder.get_requires_for_build('sdist') + builder.get_requires_for_build('wheel') + builder.prepare('wheel', '.') + builder.build('sdist', '.') + builder.build('wheel', '.') + builder.log('something') + + assert [(record.levelname, record.message) for record in caplog.records] == [ + ('INFO', 'Getting build dependencies for sdist...'), + ('INFO', 'Getting build dependencies for wheel...'), + ('INFO', 'Getting metadata for wheel...'), + ('INFO', 'Building sdist...'), + ('INFO', 'Building wheel...'), + ('INFO', 'something'), + ] + if sys.version_info >= (3, 8): # stacklevel + assert caplog.records[-1].lineno == 602 + + +@pytest.mark.parametrize( + ('pyproject_toml', 'parse_output'), + [ + ( + {'build-system': {'requires': ['foo']}}, + {'requires': ['foo'], 'build-backend': 'setuptools.build_meta:__legacy__'}, + ), + ( + {'build-system': {'requires': ['foo'], 'build-backend': 'bar'}}, + {'requires': ['foo'], 'build-backend': 'bar'}, + ), + ( + {'build-system': {'requires': ['foo'], 'build-backend': 'bar', 'backend-path': ['baz']}}, + {'requires': ['foo'], 'build-backend': 'bar', 'backend-path': ['baz']}, + ), + ], +) +def test_parse_valid_build_system_table_type(pyproject_toml, parse_output): + assert build._parse_build_system_table(pyproject_toml) == parse_output + + +@pytest.mark.parametrize( + ('pyproject_toml', 'error_message'), + [ + ( + {'build-system': {}}, + '`requires` is a required property', + ), + ( + {'build-system': {'requires': 'not an array'}}, + '`requires` must be an array of strings', + ), + ( + {'build-system': {'requires': [1]}}, + '`requires` must be an array of strings', + ), + ( + {'build-system': {'requires': ['foo'], 'build-backend': ['not a string']}}, + '`build-backend` must be a string', + ), + ( + {'build-system': {'requires': ['foo'], 'backend-path': 'not an array'}}, + '`backend-path` must be an array of strings', + ), + ( + {'build-system': {'requires': ['foo'], 'backend-path': [1]}}, + '`backend-path` must be an array of strings', + ), + ( + {'build-system': {'requires': ['foo'], 'unknown-prop': False}}, + 'Unknown properties: unknown-prop', + ), + ], +) +def test_parse_invalid_build_system_table_type(pyproject_toml, error_message): + with pytest.raises(build.BuildSystemTableValidationError, match=error_message): + build._parse_build_system_table(pyproject_toml) diff --git a/tests/test_self_packaging.py b/tests/test_self_packaging.py new file mode 100644 index 0000000..abe09f8 --- /dev/null +++ b/tests/test_self_packaging.py @@ -0,0 +1,103 @@ +# These tests check the sdist, path, and wheel of build to ensure that all are valid. + +import subprocess +import sys +import tarfile +import zipfile + +from pathlib import Path + +import pytest + + +DIR = Path(__file__).parent.resolve() +MAIN_DIR = DIR.parent + +sdist_files = { + 'LICENSE', + 'PKG-INFO', + 'README.md', + 'pyproject.toml', + 'setup.cfg', + 'setup.py', + 'src', + 'src/build', + 'src/build.egg-info', + 'src/build.egg-info/PKG-INFO', + 'src/build.egg-info/SOURCES.txt', + 'src/build.egg-info/dependency_links.txt', + 'src/build.egg-info/entry_points.txt', + 'src/build.egg-info/requires.txt', + 'src/build.egg-info/top_level.txt', + 'src/build/__init__.py', + 'src/build/__main__.py', + 'src/build/env.py', + 'src/build/py.typed', + 'src/build/util.py', +} + +wheel_files = { + 'build/__init__.py', + 'build/__main__.py', + 'build/env.py', + 'build/py.typed', + 'build/util.py', + 'dist-info/LICENSE', + 'dist-info/METADATA', + 'dist-info/RECORD', + 'dist-info/WHEEL', + 'dist-info/entry_points.txt', + 'dist-info/top_level.txt', +} + + +def test_build_sdist(monkeypatch, tmpdir): + + monkeypatch.chdir(MAIN_DIR) + + subprocess.run( + [ + sys.executable, + '-m', + 'build', + '--sdist', + '--outdir', + str(tmpdir), + ], + check=True, + ).stdout + + (sdist,) = tmpdir.visit('*.tar.gz') + + with tarfile.open(str(sdist), 'r:gz') as tar: + simpler = {n.split('/', 1)[-1] for n in tar.getnames()[1:]} + + assert simpler == sdist_files + + +@pytest.mark.parametrize('args', ((), ('--wheel',)), ids=('from_sdist', 'direct')) +def test_build_wheel(monkeypatch, tmpdir, args): + + monkeypatch.chdir(MAIN_DIR) + + subprocess.run( + [ + sys.executable, + '-m', + 'build', + *args, + '--outdir', + str(tmpdir), + ], + check=True, + ) + + (wheel,) = tmpdir.visit('*.whl') + + with zipfile.ZipFile(str(wheel)) as z: + names = z.namelist() + + trimmed = {n for n in names if 'dist-info' not in n} + trimmed |= {f"dist-info/{n.split('/', 1)[-1]}" for n in names if 'dist-info' in n} + + assert trimmed == wheel_files diff --git a/tests/test_util.py b/tests/test_util.py new file mode 100644 index 0000000..9f090b5 --- /dev/null +++ b/tests/test_util.py @@ -0,0 +1,44 @@ +# SPDX-License-Identifier: MIT + +import pytest + +import build.util + + +@pytest.mark.pypy3323bug +@pytest.mark.parametrize('isolated', [False, True]) +def test_wheel_metadata(package_test_setuptools, isolated): + metadata = build.util.project_wheel_metadata(package_test_setuptools, isolated) + + assert metadata['name'] == 'test-setuptools' + assert metadata['version'] == '1.0.0' + + +@pytest.mark.pypy3323bug +def test_wheel_metadata_isolation(package_test_flit): + try: + import flit_core # noqa: F401 + except ModuleNotFoundError: + pass + else: + pytest.xfail('flit_core is available -- we want it missing!') # pragma: no cover + + metadata = build.util.project_wheel_metadata(package_test_flit) + + assert metadata['name'] == 'test_flit' + assert metadata['version'] == '1.0.0' + + with pytest.raises( + build.BuildBackendException, + match="Backend 'flit_core.buildapi' is not available.", + ): + build.util.project_wheel_metadata(package_test_flit, isolated=False) + + +@pytest.mark.pypy3323bug +def test_with_get_requires(package_test_metadata): + metadata = build.util.project_wheel_metadata(package_test_metadata) + + assert metadata['name'] == 'test-metadata' + assert str(metadata['version']) == '1.0.0' + assert metadata['summary'] == 'hello!' @@ -0,0 +1,109 @@ +[tox] +envlist = + fix + type + docs + path + {py311, py310, py39, py38, py37, py36, pypy37, pypy38, pypy39}{, -min} +isolated_build = true +skip_missing_interpreters = true +minversion = 3.14 +requires = + virtualenv>=20.0.34 + +[testenv] +description = + run test suite with {basepython} +passenv = + LC_ALL + PIP_* + PYTEST_* + TERM +setenv = + COVERAGE_FILE = {toxworkdir}/.coverage.{envname} + TEST_STATUS_DIR = {envtmpdir} + PYPY3323BUG = 1 +extras = + test +commands = + pytest -ra --cov --cov-config pyproject.toml \ + --cov-report=html:{envdir}/htmlcov --cov-context=test \ + --cov-report=xml:{toxworkdir}/coverage.{envname}.xml {posargs:-n auto} + +[testenv:fix] +description = run static analysis and style checks +passenv = + HOMEPATH + PROGRAMDATA +basepython = python3.9 +skip_install = true +deps = + pre-commit>=2 +commands = + pre-commit run --all-files --show-diff-on-failure + python -c 'print("hint: run {envdir}/bin/pre-commit install to add checks as pre-commit hook")' + +[testenv:path] +description = verify build can run from source (bootstrap) +setenv = + PYTHONPATH = {toxinidir}/src + COVERAGE_FILE = {toxworkdir}/.coverage.{envname} +commands_pre = + python -E -m pip uninstall -y build colorama + +[testenv:type] +description = run type check on code base +extras = typing +commands = + mypy + +[testenv:{py311, py310, py39, py38, py37, py36, pypy37, pypy38, pypy39}-min] +description = check minimum versions required of all dependencies +skip_install = true +commands_pre = + pip install .[test] -c tests/constraints.txt + +[testenv:docs] +description = build documentations +basepython = python3.8 +extras = + docs +commands = + sphinx-build -n docs {envtmpdir} {posargs:-W} + python -c 'print("Documentation available under file://{envtmpdir}/index.html")' + +[testenv:dev] +description = generate a DEV environment +usedevelop = true +deps = + virtualenv>=20.0.34 +extras = + doc + test +commands = + python -m pip list --format=columns + python -c 'import sys; print(sys.executable)' + +[testenv:coverage] +description = combine coverage from test environments +passenv = + DIFF_AGAINST +setenv = +skip_install = true +deps = + coverage[toml]>=5.1 + diff_cover>=3 +parallel_show_output = true +commands = + coverage combine {toxworkdir} + coverage report --skip-covered --show-missing -i + coverage xml -o {toxworkdir}/coverage.xml -i + coverage html -d {toxworkdir}/htmlcov -i + python -m diff_cover.diff_cover_tool --compare-branch {env:DIFF_AGAINST:origin/main} {toxworkdir}/coverage.xml +depends = {py311, py310, py39, py38, py37, py36, pypy37, pypy38, pypy39}{,-min}, path + +[flake8] +max-line-length = 127 +max-complexity = 10 +extend-ignore = E203 +extend-select = B9 |