Bump version: v1.7.0

Update dependencies

.circleci/config.yml

@@ -1,25 +1,9 @@
 version: 2
 
 jobs:
-  flake8-mypy:
-    docker:
-      - image: circleci/python:3.6
-    steps:
-      - checkout
-
-      - run:
-          name: Install flake8 & mypy
-          command: sudo python -m pip install flake8 mypy
-      - run:
-          name: flake8
-          command: flake8
-      - run:
-          name: mypy
-          command: mypy
-
   osx-python3.6:
     macos:
-      xcode: "9.4.1"
+      xcode: 9.4.1
     environment:
       PYTHON: python3
     steps:
@@ -54,6 +38,5 @@ workflows:
   version: 2
   all-tests:
     jobs:
-      - flake8-mypy
       - osx-python3.6
       - linux-python3.6

.github/workflows/test.yml

@@ -1,22 +1,32 @@
 name: Test
 
 on:
-  push: {}
+  push:
+    branches:
+      - master
   pull_request:
     paths-ignore:
       - 'docs/**'
+  workflow_dispatch:
+    # allow manual runs on branches without a PR
 
 jobs:
-  test:
-    # skip branch builds on joerick/cibuildwheel, but always build `master` and pull requests
-    if: github.repository != 'joerick/cibuildwheel' || github.ref == 'refs/heads/master' || github.event_name == 'pull_request'
+  pre-commit:
+    name: Pre-commit checks (mypy, flake8, etc.)
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - uses: actions/setup-python@v2
+    - uses: pre-commit/action@v2.0.0
 
+  test:
     name: Test cibuildwheel on ${{ matrix.os }}
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
         os: [ubuntu-18.04, windows-latest, macos-latest]
         python_version: ['3.7']
+    timeout-minutes: 180
     steps:
     - uses: actions/checkout@v2
     - uses: actions/setup-python@v2
@@ -27,10 +37,21 @@ jobs:
     - name: Install dependencies
       run: |
         python -m pip install -r requirements-dev.txt
+
     - name: Install Visual C++ for Python 2.7
       if: runner.os == 'Windows'
       run: |
         choco install vcpython27 -f -y
+
+    - name: Get PR labels
+      id: pr-labels
+      uses: joerick/pr-labels-action@v1.0.6
+
+    - name: Sample build
+      if: contains(steps.pr-labels.outputs.labels, ' ci-sample-build ')
+      run: |
+        python bin/sample_build.py
+
     - name: Test cibuildwheel
       run: |
         python ./bin/run_tests.py

.gitlab-ci.yml

@@ -0,0 +1,15 @@
+linux:
+  image: python:3.8
+  services:
+    - name: docker:dind
+      entrypoint: ["env", "-u", "DOCKER_HOST"]
+      command: ["dockerd-entrypoint.sh"]
+  variables:
+    DOCKER_HOST: tcp://docker:2375/
+    DOCKER_DRIVER: overlay2
+    # See https://github.com/docker-library/docker/pull/166
+    DOCKER_TLS_CERTDIR: ""
+  script:
+    - curl -sSL https://get.docker.com/ | sh
+    - python -m pip install -r requirements-dev.txt
+    - python ./bin/run_tests.py

.pre-commit-config.yaml

@@ -1,21 +1,25 @@
 repos:
--   repo: https://gitlab.com/pycqa/flake8
-    rev: 3.8.1
-    hooks:
-    - id: flake8
-      pass_filenames: true
-      # this seems to need to be here in addition to setup.cfg
-      exclude: cibuildwheel/resources/
--   repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v2.3.0
-    hooks:
-    - id: check-yaml
-    - id: check-merge-conflict
-    - id: end-of-file-fixer
-      exclude: cibuildwheel/resources/pinned_docker_images.cfg
--   repo: https://github.com/pre-commit/mirrors-mypy
-    rev: ''  # Use the sha / tag you want to point at
-    hooks:
-    - id: mypy
-      files: cibuildwheel|test
-      exclude: cibuildwheel/resources
+- repo: https://gitlab.com/pycqa/flake8
+  rev: 3.8.3
+  hooks:
+  - id: flake8
+    exclude: cibuildwheel/resources/
+    additional_dependencies: [flake8-bugbear]
+
+- repo: https://github.com/pre-commit/pre-commit-hooks
+  rev: v3.2.0
+  hooks:
+  - id: check-case-conflict
+  - id: check-merge-conflict
+  - id: check-yaml
+  - id: end-of-file-fixer
+    exclude: cibuildwheel/resources/pinned_docker_images.cfg
+  - id: mixed-line-ending
+  - id: trailing-whitespace
+
+- repo: https://github.com/pre-commit/mirrors-mypy
+  rev: v0.782
+  hooks:
+  - id: mypy
+    files: cibuildwheel/|test/
+    pass_filenames: false

.travis.yml

@@ -28,7 +28,9 @@ jobs:
 
     - name: macOS | x86_64 | Python 3.x
       os: osx
-      env: PYTHON=python3
+      env:
+        - PYTHON=python3
+        - PYTEST_ADDOPTS='-k "unit_test or test_0_basic" --suppress-no-test-exit-code'
 
     - name: Windows | x86_64 | Python 3.6
       os: windows
@@ -52,6 +54,6 @@ jobs:
     # must repeat the s390x job above exactly to match
     - *linux_s390x_36
 
-install: $PYTHON -m pip install -r requirements-dev.txt
+install: $PYTHON -m pip install -r requirements-dev.txt pytest-custom-exit-code
 
 script: $PYTHON ./bin/run_tests.py

README.md

@@ -17,18 +17,19 @@ What does it do?
 
 |   | macOS x86_64 | Windows 64bit | Windows 32bit | manylinux x86_64 | manylinux i686 | manylinux aarch64 | manylinux ppc64le | manylinux s390x |
 |---|---|---|---|---|---|---|---|---|
-| CPython 2.7     | ✅ | ✅¹ | ✅¹ | ✅ | ✅ |     |     |     |
-| CPython 3.5     | ✅ | ✅  | ✅  | ✅ | ✅ | ✅  | ✅  | ✅² |
-| CPython 3.6     | ✅ | ✅  | ✅  | ✅ | ✅ | ✅  | ✅  | ✅² |
-| CPython 3.7     | ✅ | ✅  | ✅  | ✅ | ✅ | ✅  | ✅  | ✅² |
-| CPython 3.8     | ✅ | ✅  | ✅  | ✅ | ✅ | ✅  | ✅  | ✅² |
-| CPython 3.9³    | 🛠 | 🛠  | 🛠  | 🛠 | 🛠 | 🛠  | 🛠  |    |
-| PyPy 2.7 v7.3.0 | ✅ |     | ✅  | ✅ |    |     |     |     |
-| PyPy 3.6 v7.3.0 | ✅ |     | ✅  | ✅ |    |     |     |     |
+| CPython 2.7     | ✅ | ✅¹ | ✅¹ | ✅ | ✅ |    |    |    |
+| CPython 3.5     | ✅ | ✅  | ✅  | ✅ | ✅ | ✅² | ✅² | ✅³ |
+| CPython 3.6     | ✅ | ✅  | ✅  | ✅ | ✅ | ✅² | ✅² | ✅³ |
+| CPython 3.7     | ✅ | ✅  | ✅  | ✅ | ✅ | ✅² | ✅² | ✅³ |
+| CPython 3.8     | ✅ | ✅  | ✅  | ✅ | ✅ | ✅² | ✅² | ✅³ |
+| CPython 3.9     | ✅ | ✅  | ✅  | ✅ | ✅ | ✅² | ✅² | ✅³ |
+| PyPy 2.7 v7.3.3 | ✅ |    | ✅  | ✅ |    |    |    |    |
+| PyPy 3.6 v7.3.3 | ✅ |    | ✅  | ✅ |    |    |    |    |
+| PyPy 3.7 (beta) v7.3.3 | ✅ |    | ✅  | ✅ |    |    |    |    |
 
 <sup>¹ Not supported on Travis</sup><br>
-<sup>² Beta support until Travis CI fixes <a href="https://travis-ci.community/t/no-space-left-on-device-for-system-z/5954/11">a bug</a></sup><br>
-<sup>³ Python 3.9 is not yet ABI stable, so you shouldn't publish wheels with it yet. But if you want to check that your wheels build on Python 3.9, try our [`python3.9` branch](https://github.com/joerick/cibuildwheel/pull/382)!</sup>
+<sup>² Only supported on Travis</sup><br>
+<sup>³ Beta support until Travis CI fixes <a href="https://travis-ci.community/t/no-space-left-on-device-for-system-z/5954/11">a bug</a></sup><br>
 
 - Builds manylinux, macOS and Windows wheels for CPython and PyPy using Azure Pipelines, Travis CI, AppVeyor, and CircleCI
 - Bundles shared library dependencies on Linux and macOS through [auditwheel](https://github.com/pypa/auditwheel) and [delocate](https://github.com/matthew-brett/delocate)
@@ -37,17 +38,20 @@ What does it do?
 Usage
 -----
 
-`cibuildwheel` currently works on **Travis CI**, **Azure Pipelines**, **AppVeyor** and **GitHub Actions** to build wheels for all three supported platforms (Linux, macOS, Windows). On **CircleCI** Linux and macOS wheels can be built.
+`cibuildwheel` currently works on **Travis CI**, **Azure Pipelines**, **AppVeyor**, **GitHub Actions**, **CircleCI**, and **Gitlab CI**. Check the table below for supported platforms on each service:
 
-|                 | Linux | macOS | Windows |
-|-----------------|-------|-------|---------|
-| Azure Pipelines | ✅    | ✅    | ✅      |
-| Travis CI       | ✅    | ✅    | ✅      |
-| AppVeyor        | ✅    | ✅    | ✅      |
-| GitHub Actions  | ✅    | ✅    | ✅      |
-| CircleCI        | ✅    | ✅    |         |
+|                 | Linux | macOS | Windows | Linux ARM |
+|-----------------|-------|-------|---------|--------------|
+| Azure Pipelines | ✅    | ✅    | ✅      | ✴️¹           |
+| Travis CI       | ✅    | ✅    | ✅      | ✅           |
+| AppVeyor        | ✅    | ✅    | ✅      |              |
+| GitHub Actions  | ✅    | ✅    | ✅      | ✴️¹           |
+| CircleCI        | ✅    | ✅    |         |              |
+| Gitlab CI       | ✅    |       |         |              |
 
-`cibuildwheel` is not intended to run on your development machine. Because it uses system Python from Python.org it will try to install packages globally - not what you expect from a build tool! Instead, isolated CI services like Travis CI, CircleCI, Azure Pipelines and AppVeyor are ideal.
+<sup>¹ Requires a "third-party build host"; expected to work with cibuildwheel but not directly tested by our CI.</sup><br>
+
+`cibuildwheel` is not intended to run on your development machine. Because it uses system Python from Python.org it will try to install packages globally - not what you expect from a build tool! Instead, isolated CI services like those mentioned above are ideal.
 
 <!--intro-end-->
 
@@ -72,6 +76,8 @@ jobs:
       before_install:
         - choco install python --version 3.8.0
         - export PATH="/c/Python38:/c/Python38/Scripts:$PATH"
+        # make sure it's on PATH as 'python3'
+        - ln -s /c/Python38/python.exe /c/Python38/python3.exe
 
 env:
   global:
@@ -79,7 +85,7 @@ env:
     # Note: TWINE_PASSWORD is set to a PyPI API token in Travis settings
 
 install:
-  - python3 -m pip install cibuildwheel==1.5.0
+  - python3 -m pip install cibuildwheel==1.7.0
 
 script:
   # build the wheels, put them into './wheelhouse'
@@ -94,7 +100,7 @@ after_success:
     fi
 ```
 
-For more information, including how to build on Appveyor, Azure, CircleCI, check out the [documentation](https://cibuildwheel.readthedocs.org) and also check out [the examples](https://github.com/joerick/cibuildwheel/tree/master/examples).
+For more information, including how to build on GitHub Actions, Appveyor, Azure Pipelines, or CircleCI, check out the [documentation](https://cibuildwheel.readthedocs.org) and the [examples](https://github.com/joerick/cibuildwheel/tree/master/examples).
 
 Options
 -------
@@ -121,24 +127,31 @@ Working examples
 
 Here are some repos that use cibuildwheel.
 
-- [pyinstrument_cext](https://github.com/joerick/pyinstrument_cext)
+- [Matplotlib](https://github.com/matplotlib/matplotlib) - The venerable Matplotlib, a Python library with C++ portions, built for Linux, Mac, and Windows on Github Actions.
+- [pyinstrument_cext](https://github.com/joerick/pyinstrument_cext) - A simple C extension, without external dependencies, built on Travis CI/Appveyor.
 - [websockets](https://github.com/aaugustin/websockets)
-- [Parselmouth](https://github.com/YannickJadoul/Parselmouth)
+- [Parselmouth](https://github.com/YannickJadoul/Parselmouth) - A Python interface to the Praat software package, using pybind11, C++17 and CMake, with the core Praat static library built only once and shared between wheels; all platforms built on Github Actions.
 - [python-admesh](https://github.com/admesh/python-admesh)
 - [pybase64](https://github.com/mayeut/pybase64)
 - [KDEpy](https://github.com/tommyod/KDEpy)
 - [AutoPy](https://github.com/autopilot-rs/autopy)
 - [apriltags2-ethz](https://github.com/safijari/apriltags2_ethz)
 - [TgCrypto](https://github.com/pyrogram/tgcrypto)
-- [Twisted](https://github.com/twisted/twisted)
+- [twisted-iocpsupport](https://github.com/twisted/twisted-iocpsupport) - A submodule of Twisted that hooks into native C APIs using Cython. Built on Github CI for Windows.
 - [gmic-py](https://github.com/dtschump/gmic-py)
 - [creme](https://github.com/creme-ml/creme)
 - [PyAV](https://github.com/PyAV-Org/PyAV)
 - [aiortc](https://github.com/aiortc/aiortc)
 - [aioquic](https://github.com/aiortc/aioquic)
 - [pikepdf](https://github.com/pikepdf/pikepdf)
+- [fathon](https://github.com/stfbnc/fathon)
+- [etebase-py](https://github.com/etesync/etebase-py) - Python bindings to a Rust library using `setuptools-rust`, and `sccache` for improved speed, built on Travis CI.
+- [xmlstarlet](https://github.com/dimitern/xmlstarlet) - Python 3.6+ CFFI bindings with true MSVC build and GitHub Actions.
+- [bx-python](https://github.com/bxlab/bx-python) - A library that includes Cython extensions, built on Travis CI for Mac and Linux.
 
 > Add your repo here! Send a PR.
+>
+> <sup>I'd like to include notes here to indicate why an example might be interesting to cibuildwheel users - the styles/technologies/techniques used in each. Please include that in future additions!</sup>
 
 Legal note
 ----------
@@ -152,6 +165,102 @@ This is similar to static linking, so it might have some licence implications. C
 Changelog
 =========
 
+### 1.7.0
+
+_26 November 2020_
+
+- ✨ New logging format, that uses 'fold groups' in CI services that support
+  it. (#458)
+- 🛠 Update PyPy to 7.3.3 (#460)
+- 🐛 Fix a bug where CIBW_BEFORE_ALL runs with a very old version of Python on
+  Linux. (#464)
+
+### 1.6.4
+
+_31 October 2020_
+
+- 🐛 Fix crash on Appveyor during nuget install due to old system CA
+  certificates. We now use certifi's CA certs to download files. (#455)
+
+### 1.6.3
+
+_12 October 2020_
+
+- 🐛 Fix missing SSL certificates on macOS (#447)
+- 🛠 Update OpenSSL Python 3.5 patch to 1.1.1h on macOS (#449)
+
+### 1.6.2
+
+_9 October 2020_
+
+- ✨ Python 3.9 updated to the final release version - v3.9.0 (#440)
+- 🛠 Pypy updated to v7.3.2, adding alpha support for Python 3.7 (#430)
+
+### 1.6.1
+
+_20 September 2020_
+
+- 🛠 Add PPC64LE manylinux image supporting Python 3.9. (#436)
+- 📚 Add project URLs to PyPI listing (#428)
+
+### 1.6.0
+
+_9 September 2020_
+
+- 🌟 Add Python 3.9 support! This initial support uses release candidate
+  builds. You can start publishing wheels for Python 3.9 now, ahead of
+  the official release. (#382)
+
+  Minor note - if you're building PPC64LE wheels, the manylinux image pinned
+  by this version is
+  [still on Python 3.9b3](https://github.com/pypa/manylinux/issues/758), not a
+  release candidate. We'd advise holding off on distributing 3.9 ppc64le wheels
+  until a subsequent version of cibuildwheel.
+- 🌟 Add Gitlab CI support. Gitlab CI can now build Linux wheels, using
+  cibuildwheel. (#419)
+- 🐛 Fix a bug that causes pyproject.toml dependencies to fail to install on
+  Windows (#420)
+- 📚 Added some information about Windows VC++ runtimes and how they relate
+  to wheels.
+
+### 1.5.5
+
+_22 July 2020_
+
+- 🐛 Fix a bug that would cause command substitutions in CIBW_ENVIRONMENT to
+  produce no output on Linux (#411)
+- 🐛 Fix regression (introduced in 1.5.3) which caused BEFORE_BUILD and
+  BEFORE_ALL to be executed in the wrong directory (#410)
+
+### 1.5.4
+
+_19 June 2020_
+
+- 🐛 Fix a bug that would cause command substitutions in CIBW_ENVIRONMENT
+  variables to not interpret quotes in commands correctly (#406, #408)
+
+### 1.5.3
+
+_19 July 2020_
+
+- 🛠 Update CPython 3.8 to 3.8.3 (#405)
+- 🛠 Internal refactoring of Linux build, to move control flow into Python (#386)
+
+### 1.5.2
+
+_8 July 2020_
+
+- 🐛 Fix an issue on Windows where pyproject.toml would cause an error when
+  some requirements formats were used. (#401)
+- 🛠 Update CPython 3.7 to 3.7.8 (#394)
+
+### 1.5.1
+
+_25 June 2020_
+
+- 🐛 Fix "OSError: [WinError 17] The system cannot move the file to a different
+  disk drive" on Github Actions (#388, #389)
+
 ### 1.5.0
 
 _24 June 2020_
@@ -467,6 +576,7 @@ Maintainers
 - Joe Rickerby [@joerick](https://github.com/joerick)
 - Yannick Jadoul [@YannickJadoul](https://github.com/YannickJadoul)
 - Matthieu Darbois [@mayeut](https://github.com/mayeut)
+- Henry Schreiner [@henryiii](https://github.com/henryiii)
 
 Credits
 -------

appveyor.yml

@@ -1,7 +1,4 @@
 environment:
-  # workaround an appveyor bug on macos 
-  # see https://github.com/appveyor/ci/issues/3376#issuecomment-611314299
-  APPVEYOR_CONSOLE_DISABLE_PTY: true
   matrix:
     - APPVEYOR_BUILD_WORKER_IMAGE: Ubuntu
       APPVEYOR_JOB_NAME: "python37-x64-ubuntu"
@@ -10,11 +7,6 @@ environment:
     - APPVEYOR_BUILD_WORKER_IMAGE: macos-mojave
       APPVEYOR_JOB_NAME: "python37-x64-macos-mojave"
 
-# while pypy libffi dependency is failing the build, allow failures on macos
-matrix:	
-  allow_failures:	
-    - APPVEYOR_BUILD_WORKER_IMAGE: macos-mojave
-
 stack: python 3.7
 
 build: off
@@ -24,7 +16,7 @@ init:
 - ps: |
       $BRANCH = if ($env:APPVEYOR_PULL_REQUEST_HEAD_REPO_BRANCH) { $env:APPVEYOR_PULL_REQUEST_HEAD_REPO_BRANCH } else { $env:APPVEYOR_REPO_BRANCH }
       if (-not ($BRANCH -eq 'master' -or $BRANCH.ToLower().StartsWith('appveyor-'))) {
-        $env:PYTEST_ADDOPTS='-k "unit_test or _basic" --suppress-no-test-exit-code'
+        $env:PYTEST_ADDOPTS='-k "unit_test or test_0_basic" --suppress-no-test-exit-code'
       }
 
 install: python -m pip install -r requirements-dev.txt pytest-custom-exit-code

azure-pipelines.yml

@@ -21,6 +21,7 @@ jobs:
 
 - job: windows_36
   pool: {vmImage: 'vs2017-win2016'}
+  timeoutInMinutes: 180
   steps:
     - task: UsePythonVersion@0
       inputs:
@@ -33,6 +34,7 @@ jobs:
 
 - job: windows_38
   pool: {vmImage: 'vs2017-win2016'}
+  timeoutInMinutes: 180
   steps:
     - task: UsePythonVersion@0
       inputs:

bin/bump_version.py

@@ -7,6 +7,7 @@ import cibuildwheel
 from packaging.version import Version, InvalidVersion
 import subprocess
 import glob
+import urllib.parse
 
 config = [
     # file path, version find/replace format
@@ -19,6 +20,25 @@ config = [
 
 @click.command()
 def bump_version():
+    current_version = cibuildwheel.__version__
+
+    try:
+        commit_date_str = subprocess.run([
+            'git',
+            'show', '-s', '--pretty=format:%ci',
+            f'v{current_version}^{{commit}}'
+        ], check=True, capture_output=True, encoding='utf8').stdout
+        commit_date_parts = commit_date_str.split(' ')
+
+        url = 'https://github.com/joerick/cibuildwheel/pulls?' + urllib.parse.urlencode({
+            'q': f'is:pr merged:>{commit_date_parts[0]}T{commit_date_parts[1]}{commit_date_parts[2]}',
+        })
+        print(f'PRs merged since last release:\n  {url}')
+        print()
+    except subprocess.CalledProcessError as e:
+        print(e)
+        print('Failed to get previous version tag information.')
+
     git_changes_result = subprocess.run(['git diff-index --quiet HEAD --'], shell=True)
     repo_has_uncommitted_changes = git_changes_result.returncode != 0
 
@@ -26,7 +46,6 @@ def bump_version():
         print('error: Uncommitted changes detected.')
         exit(1)
 
-    current_version = cibuildwheel.__version__
     print(              'Current version:', current_version)  # noqa
     new_version = input('    New version: ').strip()
 
@@ -87,6 +106,7 @@ def bump_version():
 
     print('Files updated. If you want to update the changelog as part of this')
     print('commit, do that now.')
+    print()
 
     while input('Type "done" to continue: ').strip().lower() != 'done':
         pass

bin/run_example_ci_configs.py

@@ -0,0 +1,137 @@
+#!/usr/bin/env python3
+
+import os
+from pathlib import Path
+import shutil
+from subprocess import run
+import sys
+import textwrap
+import time
+import click
+from collections import namedtuple
+from urllib.parse import quote
+
+
+def shell(cmd, **kwargs):
+    return run([cmd], shell=True, **kwargs)
+
+
+def git_repo_has_changes():
+    unstaged_changes = shell('git diff-index --quiet HEAD --').returncode != 0
+    staged_changes = shell('git diff-index --quiet --cached HEAD --').returncode != 0
+    return unstaged_changes or staged_changes
+
+
+def generate_basic_project(path):
+    sys.path.insert(0, '')
+    from test.test_projects.c import new_c_project
+
+    project = new_c_project()
+    project.generate(path)
+
+
+CIService = namedtuple('CIService', 'name src_config_path dst_config_path badge_md')
+services = [
+    CIService(
+        name='appveyor',
+        src_config_path='examples/appveyor-minimal.yml',
+        dst_config_path='appveyor.yml',
+        badge_md='[![Build status](https://ci.appveyor.com/api/projects/status/wbsgxshp05tt1tif/branch/{branch}?svg=true)](https://ci.appveyor.com/project/joerick/cibuildwheel/branch/{branch})',
+    ),
+    CIService(
+        name='azure-pipelines',
+        src_config_path='examples/azure-pipelines-minimal.yml',
+        dst_config_path='azure-pipelines.yml',
+        badge_md='[![Build Status](https://dev.azure.com/joerick0429/cibuildwheel/_apis/build/status/joerick.cibuildwheel?branchName={branch})](https://dev.azure.com/joerick0429/cibuildwheel/_build/latest?definitionId=2&branchName={branch})',
+    ),
+    CIService(
+        name='circle-ci',
+        src_config_path='examples/circleci-minimal.yml',
+        dst_config_path='.circleci/config.yml',
+        badge_md='[![CircleCI](https://circleci.com/gh/joerick/cibuildwheel/tree/{branch_escaped}.svg?style=svg)](https://circleci.com/gh/joerick/cibuildwheel/tree/{branch})',
+    ),
+    CIService(
+        name='github',
+        src_config_path='examples/github-minimal.yml',
+        dst_config_path='.github/workflows/example.yml',
+        badge_md='[![Build](https://github.com/joerick/cibuildwheel/workflows/Build/badge.svg?branch={branch})](https://github.com/joerick/cibuildwheel/actions)',
+    ),
+    CIService(
+        name='travis-ci',
+        src_config_path='examples/travis-ci-minimal.yml',
+        dst_config_path='.travis.yml',
+        badge_md='[![Build Status](https://travis-ci.org/joerick/cibuildwheel.svg?branch={branch})](https://travis-ci.org/joerick/cibuildwheel)',
+    ),
+    CIService(
+        name='gitlab',
+        src_config_path='examples/gitlab-minimal.yml',
+        dst_config_path='.gitlab-ci.yml',
+        badge_md='[![Gitlab](https://gitlab.com/joerick/cibuildwheel/badges/{branch}/pipeline.svg)](https://gitlab.com/joerick/cibuildwheel/-/commits/{branch})'
+    ),
+]
+
+
+@click.command()
+def run_example_ci_configs():
+    if git_repo_has_changes():
+        print('Your git repo has uncommitted changes. Commit or stash before continuing.')
+        exit(1)
+
+    previous_branch = shell('git rev-parse --abbrev-ref HEAD',
+                            check=True,
+                            capture_output=True,
+                            encoding='utf8').stdout.strip()
+
+    timestamp = time.strftime('%Y-%m-%dT%H-%M-%S', time.gmtime())
+    branch_name = f'example-config-test---{previous_branch}-{timestamp}'
+
+    try:
+        shell(f'git checkout --orphan {branch_name}', check=True)
+
+        example_project = Path('example_root')
+        generate_basic_project(example_project)
+
+        for service in services:
+            src_config_file = Path(service.src_config_path)
+            dst_config_file = example_project / service.dst_config_path
+
+            dst_config_file.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copyfile(src_config_file, dst_config_file)
+
+        run(['git', 'add', example_project], check=True)
+        run(['git', 'commit', '-m', textwrap.dedent(f'''
+            Test example minimal configs
+
+            Testing files: {[s.src_config_path for s in services]}
+            Generated from branch: {previous_branch}
+            Time: {timestamp}
+        ''')], check=True)
+        shell(f'git subtree --prefix={example_project} push origin {branch_name}', check=True)
+
+        print('---')
+        print()
+        print('> **Examples test run**')
+        print('> ')
+        print(f'> Branch: [{branch_name}](https://github.com/joerick/cibuildwheel/tree/{branch_name})')
+        print('> ')
+        print('> | Service | Config | Status |')
+        print('> |---|---|---|')
+        for service in services:
+            badge = service.badge_md.format(branch=branch_name, branch_escaped=quote(branch_name, safe=''))
+            print(f'> | {service.name} | `{service.src_config_path}` | {badge} |')
+        print('> ')
+        print('> Generated by `bin/run_example_ci_config.py`')
+        print()
+        print('---')
+    finally:
+        # remove any local changes
+        shutil.rmtree(example_project, ignore_errors=True)
+        shell('git checkout -- .')
+        shell(f'git checkout {previous_branch}', check=True)
+        shell(f'git branch -D --force {branch_name}', check=True)
+
+
+if __name__ == '__main__':
+    os.chdir(os.path.dirname(__file__))
+    os.chdir('..')
+    run_example_ci_configs(standalone_mode=True)

bin/run_tests.py

@@ -10,7 +10,11 @@ if __name__ == '__main__':
     os.chdir(Path(__file__).resolve().parents[1])
 
     # run the unit tests
-    subprocess.check_call([sys.executable, '-m', 'pytest', 'unit_test'])
+    unit_test_args = [sys.executable, '-m', 'pytest', 'unit_test']
+    # run the docker unit tests only on Linux
+    if sys.platform.startswith('linux'):
+        unit_test_args += ['--run-docker']
+    subprocess.check_call(unit_test_args)
 
     # run the integration tests
     subprocess.check_call([sys.executable, '-m', 'pytest', '-x', '--durations', '0', 'test'])

bin/sample_build.py

@@ -0,0 +1,25 @@
+#!/usr/bin/env python3
+
+import os
+import subprocess
+import sys
+import argparse
+import tempfile
+from pathlib import Path
+
+if __name__ == '__main__':
+    # move cwd to the project root
+    os.chdir(Path(__file__).resolve().parents[1])
+
+    parser = argparse.ArgumentParser(description='Runs a sample build')
+    parser.add_argument('project_python_path', nargs='?', default='test.test_0_basic.basic_project')
+
+    options = parser.parse_args()
+
+    project_dir = tempfile.mkdtemp()
+    subprocess.run([
+        sys.executable, '-m', 'test.test_projects',
+        options.project_python_path, project_dir
+    ], check=True)
+
+    exit(subprocess.run(['cibuildwheel'], cwd=project_dir).returncode)

bin/update_dependencies.py

@@ -19,7 +19,7 @@ subprocess.check_call([
     '--upgrade',
     'cibuildwheel/resources/constraints.in',
 ])
-for python_version in ['27', '35', '36']:
+for python_version in ['27', '35', '36', '37']:
     subprocess.check_call([
         f'./env{python_version}/bin/pip-compile',
         '--allow-unsafe',

cibuildwheel/__init__.py

@@ -1 +1 @@
-__version__ = '1.5.0'
+__version__ = '1.7.0'

cibuildwheel/__main__.py

@@ -21,6 +21,7 @@ from cibuildwheel.util import (
     BuildSelector,
     DependencyConstraints,
     Unbuffered,
+    detect_ci_provider,
     resources_dir,
 )
 
@@ -47,12 +48,6 @@ def get_option_from_environment(option_name: str, platform: Optional[str] = None
     return os.environ.get(option_name, default)
 
 
-def strtobool(val: str) -> bool:
-    if val.lower() in ('y', 'yes', 't', 'true', 'on', '1'):
-        return True
-    return False
-
-
 def main() -> None:
     parser = argparse.ArgumentParser(
         description='Build wheels for all the platforms.',
@@ -96,13 +91,14 @@ def main() -> None:
     if args.platform != 'auto':
         platform = args.platform
     else:
-        ci = strtobool(os.environ.get('CI', 'false')) or 'BITRISE_BUILD_NUMBER' in os.environ or 'AZURE_HTTP_USER_AGENT' in os.environ or 'GITHUB_WORKFLOW' in os.environ
-        if not ci:
-            print('cibuildwheel: Unable to detect platform. cibuildwheel should run on your CI server, '
-                  'Travis CI, AppVeyor, Azure Pipelines, GitHub Actions and CircleCI are supported. You '
-                  'can run on your development machine or other CI providers using the --platform argument. '
-                  'Check --help output for more information.',
-                  file=sys.stderr)
+        ci_provider = detect_ci_provider()
+        if ci_provider is None:
+            print(textwrap.dedent('''
+                cibuildwheel: Unable to detect platform. cibuildwheel should run on your CI server;
+                Travis CI, AppVeyor, Azure Pipelines, GitHub Actions, CircleCI, and Gitlab are
+                supported. You can run on your development machine or other CI providers using the
+                --platform argument. Check --help output for more information.
+            '''), file=sys.stderr)
             exit(2)
         if sys.platform.startswith('linux'):
             platform = 'linux'

cibuildwheel/bashlex_eval.py

@@ -1,17 +1,23 @@
-import shlex
 import subprocess
-
-from typing import Dict, NamedTuple
+from typing import Callable, Dict, List, NamedTuple, Optional, Sequence
 
 import bashlex  # type: ignore
 
+# a function that takes a command and the environment, and returns the result
+EnvironmentExecutor = Callable[[List[str], Dict[str, str]], str]
+
+
+def local_environment_executor(command: List[str], env: Dict[str, str]) -> str:
+    return subprocess.check_output(command, env=env, universal_newlines=True)
+
 
 class NodeExecutionContext(NamedTuple):
     environment: Dict[str, str]
     input: str
+    executor: EnvironmentExecutor
 
 
-def evaluate(value: str, environment: Dict[str, str]) -> str:
+def evaluate(value: str, environment: Dict[str, str], executor: Optional[EnvironmentExecutor] = None) -> str:
     if not value:
         # empty string evaluates to empty string
         # (but trips up bashlex)
@@ -26,7 +32,7 @@ def evaluate(value: str, environment: Dict[str, str]) -> str:
 
     return evaluate_node(
         value_word_node,
-        context=NodeExecutionContext(environment=environment, input=value)
+        context=NodeExecutionContext(environment=environment, input=value, executor=executor or local_environment_executor)
     )
 
 
@@ -34,40 +40,64 @@ def evaluate_node(node: bashlex.ast.node, context: NodeExecutionContext) -> str:
     if node.kind == 'word':
         return evaluate_word_node(node, context=context)
     elif node.kind == 'commandsubstitution':
-        return evaluate_command_node(node.command, context=context)
+        node_result = evaluate_command_node(node.command, context=context)
+        # bash removes training newlines in command substitution
+        return node_result.rstrip()
     elif node.kind == 'parameter':
         return evaluate_parameter_node(node, context=context)
     else:
-        raise ValueError(f'Unsupported bash construct: "{node.word}"')
+        raise ValueError(f'Unsupported bash construct: "{node.kind}"')
 
 
 def evaluate_word_node(node: bashlex.ast.node, context: NodeExecutionContext) -> str:
-    word_start = node.pos[0]
-    word_end = node.pos[1]
-    word_string = context.input[word_start:word_end]
-    letters = list(word_string)
+    value = node.word
 
     for part in node.parts:
-        part_start = part.pos[0] - word_start
-        part_end = part.pos[1] - word_start
+        part_string = context.input[part.pos[0]:part.pos[1]]
+        part_value = evaluate_node(part, context=context)
 
-        # Set all the characters in the part to None
-        for i in range(part_start, part_end):
-            letters[i] = ''
+        if part_string not in value:
+            raise RuntimeError(
+                'bash parse failed. part "{}" not found in "{}". Word was "{}". Full input was "{}"'.format(
+                    part_string, value, node.word, context.input,
+                )
+            )
 
-        letters[part_start] = evaluate_node(part, context=context)
+        value = value.replace(part_string, part_value, 1)
 
-    # remove the None letters and concat
-    value = ''.join(letters)
-
-    # apply bash-like quotes/whitespace treatment
-    return ' '.join(word.strip() for word in shlex.split(value))
+    return value
 
 
 def evaluate_command_node(node: bashlex.ast.node, context: NodeExecutionContext) -> str:
-    words = [evaluate_node(part, context=context) for part in node.parts]
-    command = ' '.join(words)
-    return subprocess.check_output(shlex.split(command), env=context.environment, universal_newlines=True)
+    if any(n.kind == 'operator' for n in node.parts):
+        return evaluate_nodes_as_compound_command(node.parts, context=context)
+    else:
+        return evaluate_nodes_as_simple_command(node.parts, context=context)
+
+
+def evaluate_nodes_as_compound_command(nodes: Sequence[bashlex.ast.node], context: NodeExecutionContext) -> str:
+    # bashlex doesn't support any operators besides ';' inside command
+    # substitutions, so we only need to handle that case. We do so assuming
+    # that `set -o errexit` is on, because it's easier to code!
+
+    result = ''
+    for node in nodes:
+        if node.kind == 'command':
+            result += evaluate_command_node(node, context=context)
+        elif node.kind == 'operator':
+            if node.op == ';':
+                pass
+            else:
+                raise ValueError(f'Unsupported bash operator: "{node.op}"')
+        else:
+            raise ValueError(f'Unsupported bash node in compound command: "{node.kind}"')
+
+    return result
+
+
+def evaluate_nodes_as_simple_command(nodes: List[bashlex.ast.node], context: NodeExecutionContext):
+    command = [evaluate_node(part, context=context) for part in nodes]
+    return context.executor(command, context.environment)
 
 
 def evaluate_parameter_node(node: bashlex.ast.node, context: NodeExecutionContext) -> str:

cibuildwheel/docker_container.py

@@ -0,0 +1,193 @@
+import io
+import json
+import os
+import shlex
+import subprocess
+import sys
+import uuid
+from os import PathLike
+from pathlib import Path, PurePath
+from typing import IO, Dict, List, Optional, Sequence, Union
+
+
+class DockerContainer:
+    '''
+    An object that represents a running Docker container.
+
+    Intended for use as a context manager e.g.
+    `with DockerContainer('ubuntu') as docker:`
+
+    A bash shell is running in the remote container. When `call()` is invoked,
+    the command is relayed to the remote shell, and the results are streamed
+    back to cibuildwheel.
+    '''
+    UTILITY_PYTHON = '/opt/python/cp38-cp38/bin/python'
+
+    process: subprocess.Popen
+    bash_stdin: IO[bytes]
+    bash_stdout: IO[bytes]
+
+    def __init__(self, docker_image: str, simulate_32_bit: bool = False, cwd: Optional[Union[str, PathLike]] = None):
+        self.docker_image = docker_image
+        self.simulate_32_bit = simulate_32_bit
+        self.cwd = cwd
+
+    def __enter__(self) -> 'DockerContainer':
+        self.name = f'cibuildwheel-{uuid.uuid4()}'
+        cwd_args = ['-w', str(self.cwd)] if self.cwd else []
+        shell_args = ['linux32', '/bin/bash'] if self.simulate_32_bit else ['/bin/bash']
+        subprocess.run(
+            [
+                'docker', 'create',
+                '--env', 'CIBUILDWHEEL',
+                '--name', self.name,
+                '-i',
+                '-v', '/:/host',  # ignored on CircleCI
+                *cwd_args,
+                self.docker_image,
+                *shell_args
+            ],
+            check=True,
+        )
+        self.process = subprocess.Popen(
+            [
+                'docker', 'start',
+                '--attach', '--interactive',
+                self.name,
+            ],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+        )
+
+        assert self.process.stdin and self.process.stdout
+        self.bash_stdin = self.process.stdin
+        self.bash_stdout = self.process.stdout
+
+        # run a noop command to block until the container is responding
+        self.call(['/bin/true'])
+
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.bash_stdin.close()
+        self.process.terminate()
+        self.process.wait()
+
+        subprocess.run(['docker', 'rm', '--force', '-v', self.name], stdout=subprocess.DEVNULL)
+        self.name = None
+
+    def copy_into(self, from_path: Path, to_path: PurePath) -> None:
+        # `docker cp` causes 'no space left on device' error when
+        # a container is running and the host filesystem is
+        # mounted. https://github.com/moby/moby/issues/38995
+        # Use `docker exec` instead.
+
+        if from_path.is_dir():
+            self.call(['mkdir', '-p', to_path])
+            subprocess.run(
+                f'tar cf - . | docker exec -i {self.name} tar -xC {shell_quote(to_path)} -f -',
+                shell=True,
+                check=True,
+                cwd=from_path)
+        else:
+            subprocess.run(
+                f'cat {shell_quote(from_path)} | docker exec -i {self.name} sh -c "cat > {shell_quote(to_path)}"',
+                shell=True,
+                check=True)
+
+    def copy_out(self, from_path: PurePath, to_path: Path) -> None:
+        # note: we assume from_path is a dir
+        to_path.mkdir(parents=True, exist_ok=True)
+
+        subprocess.run(
+            f'docker exec -i {self.name} tar -cC {shell_quote(from_path)} -f - . | tar -xf -',
+            shell=True,
+            check=True,
+            cwd=to_path
+        )
+
+    def glob(self, path: PurePath, pattern: str) -> List[PurePath]:
+        glob_pattern = os.path.join(str(path), pattern)
+
+        path_strs = json.loads(self.call([
+            self.UTILITY_PYTHON,
+            '-c',
+            f'import sys, json, glob; json.dump(glob.glob({glob_pattern!r}), sys.stdout)'
+        ], capture_output=True))
+
+        return [PurePath(p) for p in path_strs]
+
+    def call(self, args: Sequence[Union[str, PathLike]], env: Optional[Dict[str, str]] = None,
+             capture_output=False, cwd: Optional[Union[str, PathLike]] = None) -> str:
+
+        chdir = f'cd {cwd}' if cwd else ''
+        env_assignments = ' '.join(f'{shlex.quote(k)}={shlex.quote(v)}'
+                                   for k, v in env.items()) if env is not None else ''
+        command = ' '.join(shlex.quote(str(a)) for a in args)
+        end_of_message = str(uuid.uuid4())
+
+        # log the command we're executing
+        print(f'    + {command}')
+
+        # Write a command to the remote shell. First we change the
+        # cwd, if that's required. Then, we use the `env` utility to run
+        # `command` inside the specified environment. We use `env` because it
+        # can cope with spaces and strange characters in the name or value.
+        # Finally, the remote shell is told to write a footer - this will show
+        # up in the output so we know when to stop reading, and will include
+        # the returncode of `command`.
+        self.bash_stdin.write(bytes(f'''(
+            {chdir}
+            env {env_assignments} {command}
+            printf "%04d%s\n" $? {end_of_message}
+        )
+        ''', encoding='utf8', errors='surrogateescape'))
+        self.bash_stdin.flush()
+
+        if capture_output:
+            output_io: IO[bytes] = io.BytesIO()
+        else:
+            output_io = sys.stdout.buffer
+
+        while True:
+            line = self.bash_stdout.readline()
+
+            if line.endswith(b'%s\n' % (bytes(end_of_message, encoding='utf8'))):
+                footer_offset = (
+                    len(line)
+                    - 1  # newline character
+                    - len(end_of_message)  # delimiter
+                    - 4  # 4 returncode decimals
+                )
+                returncode_str = line[footer_offset:footer_offset+4]
+                returncode = int(returncode_str)
+                # add the last line to output, without the footer
+                output_io.write(line[0:footer_offset])
+                break
+            else:
+                output_io.write(line)
+
+        if isinstance(output_io, io.BytesIO):
+            output = str(output_io.getvalue(), encoding='utf8', errors='surrogateescape')
+        else:
+            output = ''
+
+        if returncode != 0:
+            raise subprocess.CalledProcessError(returncode, args, output)
+
+        return output
+
+    def get_environment(self) -> Dict[str, str]:
+        return json.loads(self.call([
+            self.UTILITY_PYTHON,
+            '-c',
+            'import sys, json, os; json.dump(os.environ.copy(), sys.stdout)'
+        ], capture_output=True))
+
+    def environment_executor(self, command: List[str], environment: Dict[str, str]) -> str:
+        # used as an EnvironmentExecutor to evaluate commands and capture output
+        return self.call(command, env=environment, capture_output=True)
+
+
+def shell_quote(path: PurePath) -> str:
+    return shlex.quote(str(path))

cibuildwheel/environment.py

@@ -1,6 +1,6 @@
 import bashlex  # type: ignore
 
-from typing import Dict, List, Mapping
+from typing import Dict, List, Mapping, Optional
 
 from . import bashlex_eval
 
@@ -46,9 +46,9 @@ class EnvironmentAssignment:
         self.name = name
         self.value = value
 
-    def evaluated_value(self, environment: Dict[str, str]) -> str:
+    def evaluated_value(self, environment: Dict[str, str], executor: Optional[bashlex_eval.EnvironmentExecutor] = None) -> str:
         '''Returns the value of this assignment, as evaluated in the environment'''
-        return bashlex_eval.evaluate(self.value, environment=environment)
+        return bashlex_eval.evaluate(self.value, environment=environment, executor=executor)
 
     def as_shell_assignment(self) -> str:
         return f'export {self.name}={self.value}'
@@ -61,11 +61,13 @@ class ParsedEnvironment:
     def __init__(self, assignments: List[EnvironmentAssignment]):
         self.assignments = assignments
 
-    def as_dictionary(self, prev_environment: Mapping[str, str]) -> Dict[str, str]:
+    def as_dictionary(self,
+                      prev_environment: Mapping[str, str],
+                      executor: Optional[bashlex_eval.EnvironmentExecutor] = None) -> Dict[str, str]:
         environment = dict(**prev_environment)
 
         for assignment in self.assignments:
-            value = assignment.evaluated_value(environment=environment)
+            value = assignment.evaluated_value(environment=environment, executor=executor)
             environment[assignment.name] = value
 
         return environment

cibuildwheel/linux.py

@@ -1,27 +1,15 @@
-import os
 import platform
-import shlex
 import subprocess
 import sys
 import textwrap
-import uuid
+from os import PathLike
 from pathlib import Path, PurePath
+from typing import List, NamedTuple, Union
 
-from typing import List, NamedTuple, Optional, Union
-
-from .util import (
-    BuildOptions,
-    BuildSelector,
-    get_build_verbosity_extra_flags,
-    prepare_command,
-)
-
-
-def call(args: List[str], input: Optional[Union[str, bytes]] = None, universal_newlines: bool = False) -> None:
-    print('+ ' + ' '.join(shlex.quote(a) for a in args))
-    subprocess.run(
-        args, input=input, universal_newlines=universal_newlines, check=True
-    )
+from .docker_container import DockerContainer
+from .logger import log
+from .util import (BuildOptions, BuildSelector, NonPlatformWheelError,
+                   get_build_verbosity_extra_flags, prepare_command)
 
 
 def matches_platform(identifier: str) -> bool:
@@ -48,37 +36,47 @@ def matches_platform(identifier: str) -> bool:
 class PythonConfiguration(NamedTuple):
     version: str
     identifier: str
-    path: str
+    path_str: str
+
+    @property
+    def path(self):
+        return PurePath(self.path_str)
 
 
 def get_python_configurations(build_selector: BuildSelector) -> List[PythonConfiguration]:
     python_configurations = [
-        PythonConfiguration(version='2.7', identifier='cp27-manylinux_x86_64', path='/opt/python/cp27-cp27m'),
-        PythonConfiguration(version='2.7', identifier='cp27-manylinux_x86_64', path='/opt/python/cp27-cp27mu'),
-        PythonConfiguration(version='3.5', identifier='cp35-manylinux_x86_64', path='/opt/python/cp35-cp35m'),
-        PythonConfiguration(version='3.6', identifier='cp36-manylinux_x86_64', path='/opt/python/cp36-cp36m'),
-        PythonConfiguration(version='3.7', identifier='cp37-manylinux_x86_64', path='/opt/python/cp37-cp37m'),
-        PythonConfiguration(version='3.8', identifier='cp38-manylinux_x86_64', path='/opt/python/cp38-cp38'),
-        PythonConfiguration(version='2.7', identifier='cp27-manylinux_i686', path='/opt/python/cp27-cp27m'),
-        PythonConfiguration(version='2.7', identifier='cp27-manylinux_i686', path='/opt/python/cp27-cp27mu'),
-        PythonConfiguration(version='3.5', identifier='cp35-manylinux_i686', path='/opt/python/cp35-cp35m'),
-        PythonConfiguration(version='3.6', identifier='cp36-manylinux_i686', path='/opt/python/cp36-cp36m'),
-        PythonConfiguration(version='3.7', identifier='cp37-manylinux_i686', path='/opt/python/cp37-cp37m'),
-        PythonConfiguration(version='3.8', identifier='cp38-manylinux_i686', path='/opt/python/cp38-cp38'),
-        PythonConfiguration(version='2.7', identifier='pp27-manylinux_x86_64', path='/opt/python/pp27-pypy_73'),
-        PythonConfiguration(version='3.6', identifier='pp36-manylinux_x86_64', path='/opt/python/pp36-pypy36_pp73'),
-        PythonConfiguration(version='3.5', identifier='cp35-manylinux_aarch64', path='/opt/python/cp35-cp35m'),
-        PythonConfiguration(version='3.6', identifier='cp36-manylinux_aarch64', path='/opt/python/cp36-cp36m'),
-        PythonConfiguration(version='3.7', identifier='cp37-manylinux_aarch64', path='/opt/python/cp37-cp37m'),
-        PythonConfiguration(version='3.8', identifier='cp38-manylinux_aarch64', path='/opt/python/cp38-cp38'),
-        PythonConfiguration(version='3.5', identifier='cp35-manylinux_ppc64le', path='/opt/python/cp35-cp35m'),
-        PythonConfiguration(version='3.6', identifier='cp36-manylinux_ppc64le', path='/opt/python/cp36-cp36m'),
-        PythonConfiguration(version='3.7', identifier='cp37-manylinux_ppc64le', path='/opt/python/cp37-cp37m'),
-        PythonConfiguration(version='3.8', identifier='cp38-manylinux_ppc64le', path='/opt/python/cp38-cp38'),
-        PythonConfiguration(version='3.5', identifier='cp35-manylinux_s390x', path='/opt/python/cp35-cp35m'),
-        PythonConfiguration(version='3.6', identifier='cp36-manylinux_s390x', path='/opt/python/cp36-cp36m'),
-        PythonConfiguration(version='3.7', identifier='cp37-manylinux_s390x', path='/opt/python/cp37-cp37m'),
-        PythonConfiguration(version='3.8', identifier='cp38-manylinux_s390x', path='/opt/python/cp38-cp38'),
+        PythonConfiguration(version='2.7', identifier='cp27-manylinux_x86_64', path_str='/opt/python/cp27-cp27m'),
+        PythonConfiguration(version='2.7', identifier='cp27-manylinux_x86_64', path_str='/opt/python/cp27-cp27mu'),
+        PythonConfiguration(version='3.5', identifier='cp35-manylinux_x86_64', path_str='/opt/python/cp35-cp35m'),
+        PythonConfiguration(version='3.6', identifier='cp36-manylinux_x86_64', path_str='/opt/python/cp36-cp36m'),
+        PythonConfiguration(version='3.7', identifier='cp37-manylinux_x86_64', path_str='/opt/python/cp37-cp37m'),
+        PythonConfiguration(version='3.8', identifier='cp38-manylinux_x86_64', path_str='/opt/python/cp38-cp38'),
+        PythonConfiguration(version='3.9', identifier='cp39-manylinux_x86_64', path_str='/opt/python/cp39-cp39'),
+        PythonConfiguration(version='2.7', identifier='cp27-manylinux_i686', path_str='/opt/python/cp27-cp27m'),
+        PythonConfiguration(version='2.7', identifier='cp27-manylinux_i686', path_str='/opt/python/cp27-cp27mu'),
+        PythonConfiguration(version='3.5', identifier='cp35-manylinux_i686', path_str='/opt/python/cp35-cp35m'),
+        PythonConfiguration(version='3.6', identifier='cp36-manylinux_i686', path_str='/opt/python/cp36-cp36m'),
+        PythonConfiguration(version='3.7', identifier='cp37-manylinux_i686', path_str='/opt/python/cp37-cp37m'),
+        PythonConfiguration(version='3.8', identifier='cp38-manylinux_i686', path_str='/opt/python/cp38-cp38'),
+        PythonConfiguration(version='3.9', identifier='cp39-manylinux_i686', path_str='/opt/python/cp39-cp39'),
+        PythonConfiguration(version='2.7', identifier='pp27-manylinux_x86_64', path_str='/opt/python/pp27-pypy_73'),
+        PythonConfiguration(version='3.6', identifier='pp36-manylinux_x86_64', path_str='/opt/python/pp36-pypy36_pp73'),
+        PythonConfiguration(version='3.7', identifier='pp37-manylinux_x86_64', path_str='/opt/python/pp37-pypy37_pp73'),
+        PythonConfiguration(version='3.5', identifier='cp35-manylinux_aarch64', path_str='/opt/python/cp35-cp35m'),
+        PythonConfiguration(version='3.6', identifier='cp36-manylinux_aarch64', path_str='/opt/python/cp36-cp36m'),
+        PythonConfiguration(version='3.7', identifier='cp37-manylinux_aarch64', path_str='/opt/python/cp37-cp37m'),
+        PythonConfiguration(version='3.8', identifier='cp38-manylinux_aarch64', path_str='/opt/python/cp38-cp38'),
+        PythonConfiguration(version='3.9', identifier='cp39-manylinux_aarch64', path_str='/opt/python/cp39-cp39'),
+        PythonConfiguration(version='3.5', identifier='cp35-manylinux_ppc64le', path_str='/opt/python/cp35-cp35m'),
+        PythonConfiguration(version='3.6', identifier='cp36-manylinux_ppc64le', path_str='/opt/python/cp36-cp36m'),
+        PythonConfiguration(version='3.7', identifier='cp37-manylinux_ppc64le', path_str='/opt/python/cp37-cp37m'),
+        PythonConfiguration(version='3.8', identifier='cp38-manylinux_ppc64le', path_str='/opt/python/cp38-cp38'),
+        PythonConfiguration(version='3.9', identifier='cp39-manylinux_ppc64le', path_str='/opt/python/cp39-cp39'),
+        PythonConfiguration(version='3.5', identifier='cp35-manylinux_s390x', path_str='/opt/python/cp35-cp35m'),
+        PythonConfiguration(version='3.6', identifier='cp36-manylinux_s390x', path_str='/opt/python/cp36-cp36m'),
+        PythonConfiguration(version='3.7', identifier='cp37-manylinux_s390x', path_str='/opt/python/cp37-cp37m'),
+        PythonConfiguration(version='3.8', identifier='cp38-manylinux_s390x', path_str='/opt/python/cp38-cp38'),
+        PythonConfiguration(version='3.9', identifier='cp39-manylinux_s390x', path_str='/opt/python/cp39-cp39'),
     ]
     # skip builds as required
     return [c for c in python_configurations if matches_platform(c.identifier) and build_selector(c.identifier)]
@@ -86,7 +84,7 @@ def get_python_configurations(build_selector: BuildSelector) -> List[PythonConfi
 
 def build(options: BuildOptions) -> None:
     try:
-        subprocess.check_call(['docker', '--version'])
+        subprocess.check_output(['docker', '--version'])
     except Exception:
         print('cibuildwheel: Docker not found. Docker is required to run Linux builds. '
               'If you\'re building on Travis CI, add `services: [docker]` to your .travis.yml.'
@@ -110,207 +108,159 @@ def build(options: BuildOptions) -> None:
     if cwd != abs_package_dir and cwd not in abs_package_dir.parents:
         raise Exception('package_dir must be inside the working directory')
 
-    container_package_dir = PurePath('/project') / abs_package_dir.relative_to(cwd)
+    container_project_path = PurePath('/project')
+    container_package_dir = container_project_path / abs_package_dir.relative_to(cwd)
+    container_output_dir = PurePath('/output')
 
     for implementation, platform_tag, docker_image in platforms:
         platform_configs = [c for c in python_configurations if c.identifier.startswith(implementation) and c.identifier.endswith(platform_tag)]
         if not platform_configs:
             continue
 
-        shell_cmd = ['linux32', '/bin/bash'] if platform_tag.endswith("i686") else ['/bin/bash']
-
-        container_name = f'cibuildwheel-{uuid.uuid4()}'
-        call(['docker', 'create',
-              '--env', 'CIBUILDWHEEL',
-              '--name', container_name,
-              '-i',
-              '-v', '/:/host',  # ignored on CircleCI
-              docker_image,
-              '/bin/bash'])
-
         try:
-            call(['docker', 'cp', '.', container_name + ':/project'])
+            log.step(f'Starting Docker image {docker_image}...')
+            with DockerContainer(docker_image, simulate_32_bit=platform_tag.endswith('i686'), cwd=container_project_path) as docker:
 
-            call(['docker', 'start', container_name])
+                log.step('Copying project into Docker...')
+                docker.copy_into(Path.cwd(), container_project_path)
 
-            if options.before_all:
-                call(
-                    ['docker', 'exec', '-i', container_name] + shell_cmd,
-                    universal_newlines=True,
-                    input='''
-                        PS4='    + '
+                if options.before_all:
+                    log.step('Running before_all...')
 
-                        set -o errexit
-                        set -o xtrace
+                    env = docker.get_environment()
+                    env['PATH'] = f'/opt/python/cp38-cp38/bin:{env["PATH"]}'
+                    env = options.environment.as_dictionary(env, executor=docker.environment_executor)
 
-                        # add a modern Python interpreter to PATH so it can be used by BEFORE_ALL
-                        # commands
-                        export PATH=/opt/python/cp38-cp38:$PATH
+                    before_all_prepared = prepare_command(options.before_all, project=container_project_path, package=container_package_dir)
+                    docker.call(['sh', '-c', before_all_prepared], env=env)
 
-                        {environment_exports}
+                for config in platform_configs:
+                    log.build_start(config.identifier)
 
-                        sh -c {before_all}
+                    dependency_constraint_flags: List[Union[str, PathLike]] = []
 
-                    '''.format(
-                        environment_exports='\n'.join(options.environment.as_shell_commands()),
-                        before_all=shlex.quote(prepare_command(options.before_all, project='/project', package=container_package_dir))
-                    )
-                )
+                    if options.dependency_constraints:
+                        constraints_file = options.dependency_constraints.get_for_python_version(config.version)
+                        container_constraints_file = PurePath('/constraints.txt')
 
-            for config in platform_configs:
-                if options.dependency_constraints:
-                    constraints_file = options.dependency_constraints.get_for_python_version(config.version)
+                        docker.copy_into(constraints_file, container_constraints_file)
+                        dependency_constraint_flags = ['-c', container_constraints_file]
 
-                    # `docker cp` causes 'no space left on device' error when
-                    # a container is running and the host filesystem is
-                    # mounted. https://github.com/moby/moby/issues/38995
-                    # Use `docker exec` instead.
-                    with open(constraints_file, 'rb') as f:
-                        call(
-                            ['docker', 'exec', '-i', container_name, 'sh', '-c', 'cat > /constraints.txt'],
-                            input=f.read(),
-                        )
+                    log.step('Setting up build environment...')
 
-                call(
-                    ['docker', 'exec', '-i', container_name] + shell_cmd,
-                    universal_newlines=True,
-                    input='''
-                        # give xtrace output an extra level of indent inside docker
-                        PS4='    + '
+                    env = docker.get_environment()
 
-                        set -o errexit
-                        set -o xtrace
-                        mkdir -p /output
-                        cd /project
+                    # put this config's python top of the list
+                    python_bin = config.path / 'bin'
+                    env['PATH'] = f'{python_bin}:{env["PATH"]}'
 
-                        PYBIN="{config_python_bin}"
+                    env = options.environment.as_dictionary(env, executor=docker.environment_executor)
 
-                        export PATH="$PYBIN:$PATH"
-                        {environment_exports}
+                    # check config python and pip are still on PATH
+                    which_python = docker.call(['which', 'python'], env=env, capture_output=True).strip()
+                    if PurePath(which_python) != python_bin / 'python':
+                        print("cibuildwheel: python available on PATH doesn't match our installed instance. If you have modified PATH, ensure that you don't overwrite cibuildwheel's entry or insert python above it.", file=sys.stderr)
+                        exit(1)
 
-                        # check the active python and pip are in PYBIN
-                        if [ "$(which pip)" != "$PYBIN/pip" ]; then
-                        echo "cibuildwheel: python available on PATH doesn't match our installed instance. If you have modified PATH, ensure that you don't overwrite cibuildwheel's entry or insert python above it."
-                        exit 1
-                        fi
-                        if [ "$(which python)" != "$PYBIN/python" ]; then
-                        echo "cibuildwheel: pip available on PATH doesn't match our installed instance. If you have modified PATH, ensure that you don't overwrite cibuildwheel's entry or insert pip above it."
-                        exit 1
-                        fi
+                    which_pip = docker.call(['which', 'pip'], env=env, capture_output=True).strip()
+                    if PurePath(which_pip) != python_bin / 'pip':
+                        print("cibuildwheel: pip available on PATH doesn't match our installed instance. If you have modified PATH, ensure that you don't overwrite cibuildwheel's entry or insert pip above it.", file=sys.stderr)
+                        exit(1)
 
-                        if [ ! -z {before_build} ]; then
-                            sh -c {before_build}
-                        fi
+                    if options.before_build:
+                        log.step('Running before_build...')
+                        before_build_prepared = prepare_command(options.before_build, project=container_project_path, package=container_package_dir)
+                        docker.call(['sh', '-c', before_build_prepared], env=env)
 
-                        # Build the wheel
-                        rm -rf /tmp/built_wheel
-                        mkdir /tmp/built_wheel
-                        pip wheel {package_dir} -w /tmp/built_wheel --no-deps {build_verbosity_flag}
-                        built_wheel=(/tmp/built_wheel/*.whl)
+                    log.step('Building wheel...')
 
-                        # repair the wheel
-                        rm -rf /tmp/repaired_wheels
-                        mkdir /tmp/repaired_wheels
-                        # NOTE: 'built_wheel' here is a bash array of glob matches; "$built_wheel" returns
-                        # the first element
-                        if [[ "$built_wheel" == *none-any.whl ]] || [ -z {repair_command} ]; then
-                            # pure Python wheel or empty repair command
-                            mv "$built_wheel" /tmp/repaired_wheels
-                        else
-                            sh -c {repair_command} repair_command "$built_wheel"
-                        fi
-                        repaired_wheels=(/tmp/repaired_wheels/*.whl)
+                    temp_dir = PurePath('/tmp/cibuildwheel')
+                    built_wheel_dir = temp_dir / 'built_wheel'
+                    docker.call(['rm', '-rf', built_wheel_dir])
+                    docker.call(['mkdir', '-p', built_wheel_dir])
 
-                        if [ ! -z {test_command} ]; then
-                            # Set up a virtual environment to install and test from, to make sure
-                            # there are no dependencies that were pulled in at build time.
-                            pip install {dependency_install_flags} virtualenv
-                            venv_dir=`mktemp -d`/venv
-                            python -m virtualenv --no-download "$venv_dir"
+                    docker.call([
+                        'pip', 'wheel',
+                        container_package_dir,
+                        '-w', built_wheel_dir,
+                        '--no-deps',
+                        *get_build_verbosity_extra_flags(options.build_verbosity)
+                    ], env=env)
 
-                            # run the tests in a subshell to keep that `activate`
-                            # script from polluting the env
-                            (
-                                source "$venv_dir/bin/activate"
+                    built_wheel = docker.glob(built_wheel_dir, '*.whl')[0]
 
-                                echo "Running tests using `which python`"
+                    repaired_wheel_dir = temp_dir / 'repaired_wheel'
+                    docker.call(['rm', '-rf', repaired_wheel_dir])
+                    docker.call(['mkdir', '-p', repaired_wheel_dir])
 
-                                if [ ! -z {before_test} ]; then
-                                    sh -c {before_test}
-                                fi
+                    if built_wheel.name.endswith('none-any.whl'):
+                        raise NonPlatformWheelError()
 
-                                # Install the wheel we just built
-                                # Note: If auditwheel produced two wheels, it's because the earlier produced wheel
-                                # conforms to multiple manylinux standards. These multiple versions of the wheel are
-                                # functionally the same, differing only in name, wheel metadata, and possibly include
-                                # different external shared libraries. so it doesn't matter which one we run the tests on.
-                                # Let's just pick the first one.
-                                pip install "${{repaired_wheels[0]}}"{test_extras}
+                    if options.repair_command:
+                        log.step('Repairing wheel...')
+                        repair_command_prepared = prepare_command(options.repair_command, wheel=built_wheel, dest_dir=repaired_wheel_dir)
+                        docker.call(['sh', '-c', repair_command_prepared], env=env)
+                    else:
+                        docker.call(['mv', built_wheel, repaired_wheel_dir])
 
-                                # Install any requirements to run the tests
-                                if [ ! -z "{test_requires}" ]; then
-                                    pip install {test_requires}
-                                fi
+                    repaired_wheels = docker.glob(repaired_wheel_dir, '*.whl')
 
-                                # Run the tests from a different directory
-                                pushd $HOME
-                                sh -c {test_command}
-                                popd
-                            )
-                            # exit if tests failed (needed for older bash versions)
-                            if [ $? -ne 0 ]; then
-                              exit 1;
-                            fi
+                    if options.test_command:
+                        log.step('Testing wheel...')
 
-                            # clean up
-                            rm -rf "$venv_dir"
-                        fi
+                        # set up a virtual environment to install and test from, to make sure
+                        # there are no dependencies that were pulled in at build time.
+                        docker.call(['pip', 'install', 'virtualenv', *dependency_constraint_flags], env=env)
+                        venv_dir = PurePath(docker.call(['mktemp', '-d'], capture_output=True).strip()) / 'venv'
 
-                        # we're all done here; move it to output
-                        mv "${{repaired_wheels[@]}}" /output
-                        for repaired_wheel in "${{repaired_wheels[@]}}"; do
-                            chown {uid}:{gid} "/output/$(basename "$repaired_wheel")"
-                        done
-                    '''.format(
-                        config_python_bin=config.path + '/bin',
-                        package_dir=container_package_dir,
-                        test_requires=' '.join(options.test_requires),
-                        test_extras=options.test_extras,
-                        test_command=shlex.quote(
-                            prepare_command(options.test_command, project='/project', package=container_package_dir) if options.test_command else ''
-                        ),
-                        before_build=shlex.quote(
-                            prepare_command(options.before_build, project='/project', package=container_package_dir) if options.before_build else ''
-                        ),
-                        build_verbosity_flag=' '.join(get_build_verbosity_extra_flags(options.build_verbosity)),
-                        repair_command=shlex.quote(
-                            prepare_command(options.repair_command, wheel='"$1"', dest_dir='/tmp/repaired_wheels') if options.repair_command else ''
-                        ),
-                        environment_exports='\n'.join(options.environment.as_shell_commands()),
-                        uid=os.getuid(),
-                        gid=os.getgid(),
-                        before_test=shlex.quote(
-                            prepare_command(options.before_test, project='/project', package=container_package_dir) if options.before_test else ''
-                        ),
-                        dependency_install_flags='-c /constraints.txt' if options.dependency_constraints else '',
-                    )
-                )
+                        docker.call(['python', '-m', 'virtualenv', '--no-download', venv_dir], env=env)
 
-            # copy the output back into the host
-            call(['docker', 'cp',
-                  container_name + ':/output/.',
-                  str(options.output_dir.resolve())])
+                        virtualenv_env = env.copy()
+                        virtualenv_env['PATH'] = f"{venv_dir / 'bin'}:{virtualenv_env['PATH']}"
+
+                        if options.before_test:
+                            before_test_prepared = prepare_command(options.before_test, project=container_project_path, package=container_package_dir)
+                            docker.call(['sh', '-c', before_test_prepared], env=virtualenv_env)
+
+                        # Install the wheel we just built
+                        # Note: If auditwheel produced two wheels, it's because the earlier produced wheel
+                        # conforms to multiple manylinux standards. These multiple versions of the wheel are
+                        # functionally the same, differing only in name, wheel metadata, and possibly include
+                        # different external shared libraries. so it doesn't matter which one we run the tests on.
+                        # Let's just pick the first one.
+                        wheel_to_test = repaired_wheels[0]
+                        docker.call(['pip', 'install', str(wheel_to_test) + options.test_extras], env=virtualenv_env)
+
+                        # Install any requirements to run the tests
+                        if options.test_requires:
+                            docker.call(['pip', 'install', *options.test_requires], env=virtualenv_env)
+
+                        # Run the tests from a different directory
+                        test_command_prepared = prepare_command(options.test_command, project=container_project_path, package=container_package_dir)
+                        docker.call(['sh', '-c', test_command_prepared], cwd='/root', env=virtualenv_env)
+
+                        # clean up test environment
+                        docker.call(['rm', '-rf', venv_dir])
+
+                    # move repaired wheels to output
+                    docker.call(['mkdir', '-p', container_output_dir])
+                    docker.call(['mv', *repaired_wheels, container_output_dir])
+
+                    log.build_end()
+
+                log.step('Copying wheels back to host...')
+                # copy the output back into the host
+                docker.copy_out(container_output_dir, options.output_dir)
+                log.step_end()
         except subprocess.CalledProcessError as error:
+            log.error(f'Command {error.cmd} failed with code {error.returncode}. {error.stdout}')
             troubleshoot(options.package_dir, error)
             exit(1)
-        finally:
-            # Still gets executed, even when 'exit(1)' gets called
-            call(['docker', 'rm', '--force', '-v', container_name])
 
 
 def troubleshoot(package_dir: Path, error: Exception) -> None:
-    if (isinstance(error, subprocess.CalledProcessError) and 'exec' in error.cmd):
-        # the bash script failed
+    if (isinstance(error, subprocess.CalledProcessError) and error.cmd[0:2] == ['pip', 'wheel']):
+        # the 'pip wheel' step failed.
         print('Checking for common errors...')
         so_files = list(package_dir.glob('**/*.so'))
 
@@ -323,7 +273,7 @@ def troubleshoot(package_dir: Path, error: Exception) -> None:
 
                   If you're using Cython and have previously done an in-place build,
                   remove those build files (*.so and *.c) before starting cibuildwheel.
-            '''))
+            '''), file=sys.stderr)
 
             print('  Files detected:')
             print('\n'.join([f'    {f}' for f in so_files]))

cibuildwheel/logger.py

@@ -0,0 +1,263 @@
+import codecs
+import os
+import re
+import sys
+import time
+from typing import Optional, Union
+
+from cibuildwheel.util import CIProvider, detect_ci_provider
+
+DEFAULT_FOLD_PATTERN = ('{name}', '')
+FOLD_PATTERNS = {
+    'azure': ('##[group]{name}', '##[endgroup]'),
+    'travis': ('travis_fold:start:{identifier}\n{name}', 'travis_fold:end:{identifier}'),
+    'github': ('::group::{name}', '::endgroup::{name}'),
+}
+
+PLATFORM_IDENTIFIER_DESCIPTIONS = {
+    'manylinux_x86_64': 'manylinux x86_64',
+    'manylinux_i686': 'manylinux i686',
+    'manylinux_aarch64': 'manylinux aarch64',
+    'manylinux_ppc64le': 'manylinux ppc64le',
+    'manylinux_s390x': 'manylinux s390x',
+    'win32': 'Windows 32bit',
+    'win_amd64': 'Windows 64bit',
+    'macosx_x86_64': 'macOS x86_64',
+}
+
+
+class Logger:
+    fold_mode: str
+    colors_enabled: bool
+    unicode_enabled: bool
+    active_build_identifier: Optional[str] = None
+    build_start_time: Optional[float] = None
+    step_start_time: Optional[float] = None
+    active_fold_group_name: Optional[str] = None
+
+    def __init__(self):
+        if sys.platform == 'win32' and hasattr(sys.stdout, 'reconfigure'):
+            # the encoding on Windows can be a 1-byte charmap, but all CIs
+            # support utf8, so we hardcode that
+            sys.stdout.reconfigure(encoding='utf8')
+
+        self.unicode_enabled = file_supports_unicode(sys.stdout)
+
+        ci_provider = detect_ci_provider()
+
+        if ci_provider == CIProvider.azure_pipelines:
+            self.fold_mode = 'azure'
+            self.colors_enabled = True
+
+        elif ci_provider == CIProvider.github_actions:
+            self.fold_mode = 'github'
+            self.colors_enabled = True
+
+        elif ci_provider == CIProvider.travis_ci:
+            self.fold_mode = 'travis'
+            self.colors_enabled = True
+
+        elif ci_provider == CIProvider.appveyor:
+            self.fold_mode = 'disabled'
+            self.colors_enabled = True
+
+        else:
+            self.fold_mode = 'disabled'
+            self.colors_enabled = file_supports_color(sys.stdout)
+
+    def build_start(self, identifier: str):
+        self.step_end()
+        c = self.colors
+        description = build_description_from_identifier(identifier)
+        print()
+        print(f'{c.bold}{c.blue}Building {identifier} wheel{c.end}')
+        print(f'{description}')
+        print()
+
+        self.build_start_time = time.time()
+        self.active_build_identifier = identifier
+
+    def build_end(self):
+        assert self.build_start_time is not None
+        assert self.active_build_identifier is not None
+        self.step_end()
+
+        c = self.colors
+        s = self.symbols
+        duration = time.time() - self.build_start_time
+
+        print()
+        print(f'{c.green}{s.done} {c.end}{self.active_build_identifier} finished in {duration:.2f}s')
+        self.build_start_time = None
+        self.active_build_identifier = None
+
+    def step(self, step_description: str):
+        self.step_end()
+        self.step_start_time = time.time()
+        self._start_fold_group(step_description)
+
+    def step_end(self, success=True):
+        if self.step_start_time is not None:
+            self._end_fold_group()
+            c = self.colors
+            s = self.symbols
+            duration = time.time() - self.step_start_time
+            if success:
+                print(f'{c.green}{s.done} {c.end}{duration:.2f}s'.rjust(78))
+            else:
+                print(f'{c.red}{s.error} {c.end}{duration:.2f}s'.rjust(78))
+
+            self.step_start_time = None
+
+    def error(self, error: Union[Exception, str]):
+        self.step_end(success=False)
+        print()
+
+        if self.fold_mode == 'github':
+            print(f'::error::{error}')
+        else:
+            c = self.colors
+            print(f'{c.bright_red}Error{c.end} {error}')
+
+    def _start_fold_group(self, name: str):
+        self._end_fold_group()
+        self.active_fold_group_name = name
+        fold_start_pattern = FOLD_PATTERNS.get(self.fold_mode, DEFAULT_FOLD_PATTERN)[0]
+        identifier = self._fold_group_identifier(name)
+
+        print(fold_start_pattern.format(name=self.active_fold_group_name, identifier=identifier))
+        print()
+        sys.stdout.flush()
+
+    def _end_fold_group(self):
+        if self.active_fold_group_name:
+            fold_start_pattern = FOLD_PATTERNS.get(self.fold_mode, DEFAULT_FOLD_PATTERN)[1]
+            identifier = self._fold_group_identifier(self.active_fold_group_name)
+            print(fold_start_pattern.format(name=self.active_fold_group_name, identifier=identifier))
+            sys.stdout.flush()
+            self.active_fold_group_name = None
+
+    def _fold_group_identifier(self, name: str):
+        '''
+        Travis doesn't like fold groups identifiers that have spaces in. This
+        method converts them to ascii identifiers
+        '''
+        # whitespace to underscores
+        identifier = re.sub(r'\s+', '_', name)
+        # remove non-alphanum
+        identifier = re.sub(r'[^A-Za-z\d_]+', '', identifier)
+        # trim underscores
+        identifier = identifier.strip('_')
+        # lowercase, shorten
+        return identifier.lower()[:20]
+
+    @property
+    def colors(self):
+        if self.colors_enabled:
+            return Colors.enabled
+        else:
+            return Colors.disabled
+
+    @property
+    def symbols(self):
+        if self.unicode_enabled:
+            return Symbols.unicode
+        else:
+            return Symbols.ascii
+
+
+def build_description_from_identifier(identifier: str):
+    python_identifier, _, platform_identifier = identifier.partition('-')
+
+    build_description = ''
+
+    python_interpreter = python_identifier[0:2]
+    python_version = python_identifier[2:4]
+
+    if python_interpreter == 'cp':
+        build_description += 'CPython'
+    elif python_interpreter == 'pp':
+        build_description += 'PyPy'
+    else:
+        raise Exception('unknown python')
+
+    build_description += f' {python_version[0]}.{python_version[1]} '
+
+    try:
+        build_description += PLATFORM_IDENTIFIER_DESCIPTIONS[platform_identifier]
+    except KeyError as e:
+        raise Exception('unknown platform') from e
+
+    return build_description
+
+
+class Colors:
+    class Enabled:
+        red = '\033[31m'
+        green = '\033[32m'
+        yellow = '\033[33m'
+        blue = '\033[34m'
+        cyan = '\033[36m'
+        bright_red = '\033[91m'
+        bright_green = '\033[92m'
+        white = '\033[37m\033[97m'
+
+        bg_grey = '\033[48;5;235m'
+
+        bold = '\033[1m'
+        faint = '\033[2m'
+
+        end = '\033[0m'
+
+    class Disabled:
+        def __getattr__(self, attr: str) -> str:
+            return ''
+
+    enabled = Enabled()
+    disabled = Disabled()
+
+
+class Symbols:
+    class Unicode:
+        done = '✓'
+        error = '✕'
+
+    class Ascii:
+        done = 'done'
+        error = 'failed'
+
+    unicode = Unicode()
+    ascii = Ascii()
+
+
+def file_supports_color(file_obj):
+    """
+    Returns True if the running system's terminal supports color.
+    """
+    plat = sys.platform
+    supported_platform = (plat != 'win32' or 'ANSICON' in os.environ)
+
+    is_a_tty = file_is_a_tty(file_obj)
+
+    return (supported_platform and is_a_tty)
+
+
+def file_is_a_tty(file_obj):
+    return hasattr(file_obj, 'isatty') and file_obj.isatty()
+
+
+def file_supports_unicode(file_obj):
+    encoding = getattr(file_obj, 'encoding', None)
+    if not encoding:
+        return False
+
+    codec_info = codecs.lookup(encoding)
+
+    return ('utf' in codec_info.name)
+
+
+'''
+Global instance of the Logger.
+'''
+# (there's only one stdout per-process, so a global instance is justified)
+log = Logger()

cibuildwheel/macos.py

@@ -4,27 +4,23 @@ import shutil
 import subprocess
 import sys
 import tempfile
+from os import PathLike
 from pathlib import Path
-
-from typing import Dict, List, Optional, NamedTuple, Union
+from typing import Dict, List, NamedTuple, Optional, Sequence, Union
 
 from .environment import ParsedEnvironment
-from .util import (
-    BuildOptions,
-    BuildSelector,
-    download,
-    get_build_verbosity_extra_flags,
-    get_pip_script,
-    prepare_command,
-)
+from .logger import log
+from .util import (BuildOptions, BuildSelector, NonPlatformWheelError,
+                   download, get_build_verbosity_extra_flags, get_pip_script,
+                   install_certifi_script, prepare_command)
 
 
-def call(args: Union[str, List[str]], env: Optional[Dict[str, str]] = None, cwd: Optional[str] = None, shell: bool = False) -> int:
+def call(args: Union[str, Sequence[Union[str, PathLike]]], env: Optional[Dict[str, str]] = None, cwd: Optional[str] = None, shell: bool = False) -> int:
     # print the command executing for the logs
     if shell:
         print(f'+ {args}')
     else:
-        print('+ ' + ' '.join(shlex.quote(a) for a in args))
+        print('+ ' + ' '.join(shlex.quote(str(a)) for a in args))
 
     return subprocess.check_call(args, env=env, cwd=cwd, shell=shell)
 
@@ -41,11 +37,13 @@ def get_python_configurations(build_selector: BuildSelector) -> List[PythonConfi
         PythonConfiguration(version='2.7', identifier='cp27-macosx_x86_64', url='https://www.python.org/ftp/python/2.7.18/python-2.7.18-macosx10.9.pkg'),
         PythonConfiguration(version='3.5', identifier='cp35-macosx_x86_64', url='https://www.python.org/ftp/python/3.5.4/python-3.5.4-macosx10.6.pkg'),
         PythonConfiguration(version='3.6', identifier='cp36-macosx_x86_64', url='https://www.python.org/ftp/python/3.6.8/python-3.6.8-macosx10.9.pkg'),
-        PythonConfiguration(version='3.7', identifier='cp37-macosx_x86_64', url='https://www.python.org/ftp/python/3.7.7/python-3.7.7-macosx10.9.pkg'),
-        PythonConfiguration(version='3.8', identifier='cp38-macosx_x86_64', url='https://www.python.org/ftp/python/3.8.3/python-3.8.3-macosx10.9.pkg'),
+        PythonConfiguration(version='3.7', identifier='cp37-macosx_x86_64', url='https://www.python.org/ftp/python/3.7.8/python-3.7.8-macosx10.9.pkg'),
+        PythonConfiguration(version='3.8', identifier='cp38-macosx_x86_64', url='https://www.python.org/ftp/python/3.8.4/python-3.8.4-macosx10.9.pkg'),
+        PythonConfiguration(version='3.9', identifier='cp39-macosx_x86_64', url='https://www.python.org/ftp/python/3.9.0/python-3.9.0-macosx10.9.pkg'),
         # PyPy
-        PythonConfiguration(version='2.7', identifier='pp27-macosx_x86_64', url='https://downloads.python.org/pypy/pypy2.7-v7.3.1-osx64.tar.bz2'),
-        PythonConfiguration(version='3.6', identifier='pp36-macosx_x86_64', url='https://downloads.python.org/pypy/pypy3.6-v7.3.1-osx64.tar.bz2'),
+        PythonConfiguration(version='2.7', identifier='pp27-macosx_x86_64', url='https://downloads.python.org/pypy/pypy2.7-v7.3.3-osx64.tar.bz2'),
+        PythonConfiguration(version='3.6', identifier='pp36-macosx_x86_64', url='https://downloads.python.org/pypy/pypy3.6-v7.3.3-osx64.tar.bz2'),
+        PythonConfiguration(version='3.7', identifier='pp37-macosx_x86_64', url='https://downloads.python.org/pypy/pypy3.7-v7.3.3-osx64.tar.bz2'),
     ]
 
     # skip builds as required
@@ -75,6 +73,9 @@ def install_cpython(version: str, url: str) -> Path:
 
     # if this version of python isn't installed, get it from python.org and install
     python_package_identifier = f'org.python.Python.PythonFramework-{version}'
+    python_executable = 'python3' if version[0] == '3' else 'python'
+    installation_bin_path = Path(f'/Library/Frameworks/Python.framework/Versions/{version}/bin')
+
     if python_package_identifier not in installed_system_packages:
         # download the pkg
         download(url, Path('/tmp/Python.pkg'))
@@ -82,12 +83,12 @@ def install_cpython(version: str, url: str) -> Path:
         call(['sudo', 'installer', '-pkg', '/tmp/Python.pkg', '-target', '/'])
         # patch open ssl
         if version == '3.5':
-            open_ssl_patch_url = f'https://github.com/mayeut/patch-macos-python-openssl/releases/download/v1.0.2u/patch-macos-python-{version}-openssl-v1.0.2u.tar.gz'
+            open_ssl_patch_url = f'https://github.com/mayeut/patch-macos-python-openssl/releases/download/v1.1.1h/patch-macos-python-{version}-openssl-v1.1.1h.tar.gz'
             download(open_ssl_patch_url, Path('/tmp/python-patch.tar.gz'))
             call(['sudo', 'tar', '-C', f'/Library/Frameworks/Python.framework/Versions/{version}/', '-xmf', '/tmp/python-patch.tar.gz'])
 
-    installation_bin_path = Path(f'/Library/Frameworks/Python.framework/Versions/{version}/bin')
-    python_executable = 'python3' if version[0] == '3' else 'python'
+        call(["sudo", str(installation_bin_path/python_executable), str(install_certifi_script)])
+
     pip_executable = 'pip3' if version[0] == '3' else 'pip'
     make_symlinks(installation_bin_path, python_executable, pip_executable)
 
@@ -103,7 +104,7 @@ def install_pypy(version: str, url: str) -> Path:
     if not installation_path.exists():
         downloaded_tar_bz2 = Path("/tmp") / pypy_tar_bz2
         download(url, downloaded_tar_bz2)
-        call(['tar', '-C', '/tmp', '-xf', str(downloaded_tar_bz2)])
+        call(['tar', '-C', '/tmp', '-xf', downloaded_tar_bz2])
 
     installation_bin_path = installation_path / 'bin'
     python_executable = 'pypy3' if version[0] == '3' else 'pypy'
@@ -113,14 +114,21 @@ def install_pypy(version: str, url: str) -> Path:
     return installation_bin_path
 
 
-def setup_python(python_configuration: PythonConfiguration, dependency_constraint_flags: List[str], environment: ParsedEnvironment) -> Dict[str, str]:
-    if python_configuration.identifier.startswith('cp'):
+def setup_python(python_configuration: PythonConfiguration,
+                 dependency_constraint_flags: Sequence[Union[str, PathLike]],
+                 environment: ParsedEnvironment) -> Dict[str, str]:
+    implementation_id = python_configuration.identifier.split("-")[0]
+    log.step(f'Installing Python {implementation_id}...')
+
+    if implementation_id.startswith('cp'):
         installation_bin_path = install_cpython(python_configuration.version, python_configuration.url)
-    elif python_configuration.identifier.startswith('pp'):
+    elif implementation_id.startswith('pp'):
         installation_bin_path = install_pypy(python_configuration.version, python_configuration.url)
     else:
         raise ValueError("Unknown Python implementation")
 
+    log.step('Setting up build environment...')
+
     env = os.environ.copy()
     env['PATH'] = os.pathsep.join([
         str(SYMLINKS_DIR),
@@ -146,7 +154,7 @@ def setup_python(python_configuration: PythonConfiguration, dependency_constrain
         exit(1)
 
     # install pip & wheel
-    call(['python', str(get_pip_script)] + dependency_constraint_flags, env=env, cwd="/tmp")
+    call(['python', get_pip_script, *dependency_constraint_flags], env=env, cwd="/tmp")
     assert (installation_bin_path / 'pip').exists()
     call(['which', 'pip'], env=env)
     call(['pip', '--version'], env=env)
@@ -154,7 +162,6 @@ def setup_python(python_configuration: PythonConfiguration, dependency_constrain
     if which_pip != '/tmp/cibw_bin/pip':
         print("cibuildwheel: pip available on PATH doesn't match our installed instance. If you have modified PATH, ensure that you don't overwrite cibuildwheel's entry or insert pip above it.", file=sys.stderr)
         exit(1)
-    call(['pip', 'install', '--upgrade', 'setuptools', 'wheel', 'delocate'] + dependency_constraint_flags, env=env)
 
     # Set MACOSX_DEPLOYMENT_TARGET to 10.9, if the user didn't set it.
     # CPython 3.5 defaults to 10.6, and pypy defaults to 10.7, causing
@@ -168,6 +175,9 @@ def setup_python(python_configuration: PythonConfiguration, dependency_constrain
         # https://github.com/python/cpython/blob/a5ed2fe0eedefa1649aa93ee74a0bafc8e628a10/Lib/_osx_support.py#L260
         env.setdefault('ARCHFLAGS', '-arch x86_64')
 
+    log.step('Installing build tools...')
+    call(['pip', 'install', '--upgrade', 'setuptools', 'wheel', 'delocate', *dependency_constraint_flags], env=env)
+
     return env
 
 
@@ -176,90 +186,111 @@ def build(options: BuildOptions) -> None:
     built_wheel_dir = temp_dir / 'built_wheel'
     repaired_wheel_dir = temp_dir / 'repaired_wheel'
 
-    if options.before_all:
-        env = options.environment.as_dictionary(prev_environment=os.environ)
-        before_all_prepared = prepare_command(options.before_all, project='.', package=options.package_dir)
-        call([before_all_prepared], shell=True, env=env)
+    try:
+        if options.before_all:
+            log.step('Running before_all...')
+            env = options.environment.as_dictionary(prev_environment=os.environ)
+            before_all_prepared = prepare_command(options.before_all, project='.', package=options.package_dir)
+            call([before_all_prepared], shell=True, env=env)
 
-    python_configurations = get_python_configurations(options.build_selector)
+        python_configurations = get_python_configurations(options.build_selector)
 
-    for config in python_configurations:
-        dependency_constraint_flags = []
-        if options.dependency_constraints:
-            dependency_constraint_flags = [
-                '-c', str(options.dependency_constraints.get_for_python_version(config.version))
-            ]
+        for config in python_configurations:
+            log.build_start(config.identifier)
 
-        env = setup_python(config, dependency_constraint_flags, options.environment)
+            dependency_constraint_flags: Sequence[Union[str, PathLike]] = []
+            if options.dependency_constraints:
+                dependency_constraint_flags = [
+                    '-c', options.dependency_constraints.get_for_python_version(config.version)
+                ]
 
-        # run the before_build command
-        if options.before_build:
-            before_build_prepared = prepare_command(options.before_build, project='.', package=options.package_dir)
-            call(before_build_prepared, env=env, shell=True)
+            env = setup_python(config, dependency_constraint_flags, options.environment)
 
-        # build the wheel
-        if built_wheel_dir.exists():
-            shutil.rmtree(built_wheel_dir)
-        built_wheel_dir.mkdir(parents=True)
-        # Path.resolve() is needed. Without it pip wheel may try to fetch package from pypi.org
-        # see https://github.com/joerick/cibuildwheel/pull/369
-        call(['pip', 'wheel', str(options.package_dir.resolve()), '-w', str(built_wheel_dir), '--no-deps'] + get_build_verbosity_extra_flags(options.build_verbosity), env=env)
-        built_wheel = next(built_wheel_dir.glob('*.whl'))
+            if options.before_build:
+                log.step('Running before_build...')
+                before_build_prepared = prepare_command(options.before_build, project='.', package=options.package_dir)
+                call(before_build_prepared, env=env, shell=True)
 
-        # repair the wheel
-        if repaired_wheel_dir.exists():
-            shutil.rmtree(repaired_wheel_dir)
-        repaired_wheel_dir.mkdir(parents=True)
-        if built_wheel.name.endswith('none-any.whl') or not options.repair_command:
-            # pure Python wheel or empty repair command
-            built_wheel.rename(repaired_wheel_dir / built_wheel.name)
-        else:
-            repair_command_prepared = prepare_command(options.repair_command, wheel=built_wheel, dest_dir=repaired_wheel_dir)
-            call(repair_command_prepared, env=env, shell=True)
-        repaired_wheel = next(repaired_wheel_dir.glob('*.whl'))
+            log.step('Building wheel...')
+            if built_wheel_dir.exists():
+                shutil.rmtree(built_wheel_dir)
+            built_wheel_dir.mkdir(parents=True)
 
-        if options.test_command:
-            # set up a virtual environment to install and test from, to make sure
-            # there are no dependencies that were pulled in at build time.
-            call(['pip', 'install', 'virtualenv'] + dependency_constraint_flags, env=env)
-            venv_dir = Path(tempfile.mkdtemp())
+            # Path.resolve() is needed. Without it pip wheel may try to fetch package from pypi.org
+            # see https://github.com/joerick/cibuildwheel/pull/369
+            call([
+                'pip', 'wheel',
+                options.package_dir.resolve(),
+                '-w', built_wheel_dir,
+                '--no-deps',
+                *get_build_verbosity_extra_flags(options.build_verbosity)
+            ], env=env)
 
-            # Use --no-download to ensure determinism by using seed libraries
-            # built into virtualenv
-            call(['python', '-m', 'virtualenv', '--no-download', str(venv_dir)], env=env)
+            built_wheel = next(built_wheel_dir.glob('*.whl'))
 
-            virtualenv_env = env.copy()
-            virtualenv_env['PATH'] = os.pathsep.join([
-                str(venv_dir / 'bin'),
-                virtualenv_env['PATH'],
-            ])
+            if repaired_wheel_dir.exists():
+                shutil.rmtree(repaired_wheel_dir)
+            repaired_wheel_dir.mkdir(parents=True)
 
-            # check that we are using the Python from the virtual environment
-            call(['which', 'python'], env=virtualenv_env)
+            if built_wheel.name.endswith('none-any.whl'):
+                raise NonPlatformWheelError()
 
-            if options.before_test:
-                before_test_prepared = prepare_command(options.before_test, project='.', package=options.package_dir)
-                call(before_test_prepared, env=virtualenv_env, shell=True)
+            if options.repair_command:
+                log.step('Repairing wheel...')
+                repair_command_prepared = prepare_command(options.repair_command, wheel=built_wheel, dest_dir=repaired_wheel_dir)
+                call(repair_command_prepared, env=env, shell=True)
+            else:
+                shutil.move(str(built_wheel), repaired_wheel_dir)
 
-            # install the wheel
-            call(['pip', 'install', str(repaired_wheel) + options.test_extras], env=virtualenv_env)
+            repaired_wheel = next(repaired_wheel_dir.glob('*.whl'))
 
-            # test the wheel
-            if options.test_requires:
-                call(['pip', 'install'] + options.test_requires, env=virtualenv_env)
+            if options.test_command:
+                log.step('Testing wheel...')
+                # set up a virtual environment to install and test from, to make sure
+                # there are no dependencies that were pulled in at build time.
+                call(['pip', 'install', 'virtualenv', *dependency_constraint_flags], env=env)
+                venv_dir = Path(tempfile.mkdtemp())
 
-            # run the tests from $HOME, with an absolute path in the command
-            # (this ensures that Python runs the tests against the installed wheel
-            # and not the repo code)
-            test_command_prepared = prepare_command(
-                options.test_command,
-                project=Path('.').resolve(),
-                package=options.package_dir.resolve()
-            )
-            call(test_command_prepared, cwd=os.environ['HOME'], env=virtualenv_env, shell=True)
+                # Use --no-download to ensure determinism by using seed libraries
+                # built into virtualenv
+                call(['python', '-m', 'virtualenv', '--no-download', venv_dir], env=env)
 
-            # clean up
-            shutil.rmtree(venv_dir)
+                virtualenv_env = env.copy()
+                virtualenv_env['PATH'] = os.pathsep.join([
+                    str(venv_dir / 'bin'),
+                    virtualenv_env['PATH'],
+                ])
 
-        # we're all done here; move it to output (overwrite existing)
-        repaired_wheel.replace(options.output_dir / repaired_wheel.name)
+                # check that we are using the Python from the virtual environment
+                call(['which', 'python'], env=virtualenv_env)
+
+                if options.before_test:
+                    before_test_prepared = prepare_command(options.before_test, project='.', package=options.package_dir)
+                    call(before_test_prepared, env=virtualenv_env, shell=True)
+
+                # install the wheel
+                call(['pip', 'install', str(repaired_wheel) + options.test_extras], env=virtualenv_env)
+
+                # test the wheel
+                if options.test_requires:
+                    call(['pip', 'install'] + options.test_requires, env=virtualenv_env)
+
+                # run the tests from $HOME, with an absolute path in the command
+                # (this ensures that Python runs the tests against the installed wheel
+                # and not the repo code)
+                test_command_prepared = prepare_command(
+                    options.test_command,
+                    project=Path('.').resolve(),
+                    package=options.package_dir.resolve()
+                )
+                call(test_command_prepared, cwd=os.environ['HOME'], env=virtualenv_env, shell=True)
+
+                # clean up
+                shutil.rmtree(venv_dir)
+
+            # we're all done here; move it to output (overwrite existing)
+            shutil.move(str(repaired_wheel), options.output_dir)
+            log.build_end()
+    except subprocess.CalledProcessError as error:
+        log.error(f'Command {error.cmd} failed with code {error.returncode}. {error.stdout}')
+        exit(1)

cibuildwheel/resources/constraints-python27.txt

@@ -6,21 +6,21 @@
 #
 appdirs==1.4.4            # via virtualenv
 configparser==4.0.2       # via importlib-metadata
-contextlib2==0.6.0.post1  # via importlib-metadata, importlib-resources, virtualenv
-delocate==0.8.0           # via -r cibuildwheel/resources/constraints.in
-distlib==0.3.0            # via virtualenv
+contextlib2==0.6.0.post1  # via importlib-metadata, importlib-resources
+delocate==0.8.2           # via -r cibuildwheel/resources/constraints.in
+distlib==0.3.1            # via virtualenv
 filelock==3.0.12          # via virtualenv
-importlib-metadata==1.6.0  # via importlib-resources, virtualenv
-importlib-resources==1.5.0  # via virtualenv
+importlib-metadata==2.1.0  # via virtualenv
+importlib-resources==3.3.0  # via virtualenv
 pathlib2==2.3.5           # via importlib-metadata, importlib-resources, virtualenv
 scandir==1.10.0           # via pathlib2
 singledispatch==3.4.0.3   # via importlib-resources
 six==1.15.0               # via pathlib2, virtualenv
-typing==3.7.4.1           # via importlib-resources
-virtualenv==20.0.21       # via -r cibuildwheel/resources/constraints.in
-wheel==0.34.2             # via -r cibuildwheel/resources/constraints.in, delocate
+typing==3.7.4.3           # via importlib-resources
+virtualenv==20.2.1        # via -r cibuildwheel/resources/constraints.in
+wheel==0.35.1             # via -r cibuildwheel/resources/constraints.in, delocate
 zipp==1.2.0               # via importlib-metadata, importlib-resources
 
 # The following packages are considered to be unsafe in a requirements file:
-pip==20.1.1               # via -r cibuildwheel/resources/constraints.in
-setuptools==44.1.0        # via -r cibuildwheel/resources/constraints.in
+pip==20.2.4               # via -r cibuildwheel/resources/constraints.in
+setuptools==44.1.1        # via -r cibuildwheel/resources/constraints.in

cibuildwheel/resources/constraints-python35.txt

@@ -5,16 +5,16 @@
 #    bin/update_constraints.py
 #
 appdirs==1.4.4            # via virtualenv
-delocate==0.8.0           # via -r cibuildwheel/resources/constraints.in
-distlib==0.3.0            # via virtualenv
+delocate==0.8.2           # via -r cibuildwheel/resources/constraints.in
+distlib==0.3.1            # via virtualenv
 filelock==3.0.12          # via virtualenv
-importlib-metadata==1.6.0  # via importlib-resources, virtualenv
-importlib-resources==1.5.0  # via virtualenv
+importlib-metadata==2.1.0  # via virtualenv
+importlib-resources==3.2.1  # via virtualenv
 six==1.15.0               # via virtualenv
-virtualenv==20.0.21       # via -r cibuildwheel/resources/constraints.in
-wheel==0.34.2             # via -r cibuildwheel/resources/constraints.in, delocate
+virtualenv==20.2.1        # via -r cibuildwheel/resources/constraints.in
+wheel==0.35.1             # via -r cibuildwheel/resources/constraints.in, delocate
 zipp==1.2.0               # via importlib-metadata, importlib-resources
 
 # The following packages are considered to be unsafe in a requirements file:
-pip==20.1.1               # via -r cibuildwheel/resources/constraints.in
-setuptools==46.4.0        # via -r cibuildwheel/resources/constraints.in
+pip==20.2.4               # via -r cibuildwheel/resources/constraints.in
+setuptools==50.3.2        # via -r cibuildwheel/resources/constraints.in

cibuildwheel/resources/constraints-python36.txt

@@ -5,16 +5,16 @@
 #    bin/update_constraints.py
 #
 appdirs==1.4.4            # via virtualenv
-delocate==0.8.0           # via -r cibuildwheel/resources/constraints.in
-distlib==0.3.0            # via virtualenv
+delocate==0.8.2           # via -r cibuildwheel/resources/constraints.in
+distlib==0.3.1            # via virtualenv
 filelock==3.0.12          # via virtualenv
-importlib-metadata==1.6.0  # via importlib-resources, virtualenv
-importlib-resources==1.5.0  # via virtualenv
+importlib-metadata==3.1.0  # via virtualenv
+importlib-resources==3.3.0  # via virtualenv
 six==1.15.0               # via virtualenv
-virtualenv==20.0.21       # via -r cibuildwheel/resources/constraints.in
-wheel==0.34.2             # via -r cibuildwheel/resources/constraints.in, delocate
-zipp==3.1.0               # via importlib-metadata, importlib-resources
+virtualenv==20.2.1        # via -r cibuildwheel/resources/constraints.in
+wheel==0.35.1             # via -r cibuildwheel/resources/constraints.in, delocate
+zipp==3.4.0               # via importlib-metadata, importlib-resources
 
 # The following packages are considered to be unsafe in a requirements file:
-pip==20.1.1               # via -r cibuildwheel/resources/constraints.in
-setuptools==46.4.0        # via -r cibuildwheel/resources/constraints.in
+pip==20.2.4               # via -r cibuildwheel/resources/constraints.in
+setuptools==50.3.2        # via -r cibuildwheel/resources/constraints.in

cibuildwheel/resources/constraints-python37.txt

@@ -0,0 +1,19 @@
+#
+# This file is autogenerated by pip-compile
+# To update, run:
+#
+#    bin/update_constraints.py
+#
+appdirs==1.4.4            # via virtualenv
+delocate==0.8.2           # via -r cibuildwheel/resources/constraints.in
+distlib==0.3.1            # via virtualenv
+filelock==3.0.12          # via virtualenv
+importlib-metadata==3.1.0  # via virtualenv
+six==1.15.0               # via virtualenv
+virtualenv==20.2.1        # via -r cibuildwheel/resources/constraints.in
+wheel==0.35.1             # via -r cibuildwheel/resources/constraints.in, delocate
+zipp==3.4.0               # via importlib-metadata
+
+# The following packages are considered to be unsafe in a requirements file:
+pip==20.2.4               # via -r cibuildwheel/resources/constraints.in
+setuptools==50.3.2        # via -r cibuildwheel/resources/constraints.in

cibuildwheel/resources/constraints.txt

@@ -5,15 +5,13 @@
 #    bin/update_constraints.py
 #
 appdirs==1.4.4            # via virtualenv
-delocate==0.8.0           # via -r cibuildwheel/resources/constraints.in
-distlib==0.3.0            # via virtualenv
+delocate==0.8.2           # via -r cibuildwheel/resources/constraints.in
+distlib==0.3.1            # via virtualenv
 filelock==3.0.12          # via virtualenv
-importlib-metadata==1.6.0  # via virtualenv
 six==1.15.0               # via virtualenv
-virtualenv==20.0.21       # via -r cibuildwheel/resources/constraints.in
-wheel==0.34.2             # via -r cibuildwheel/resources/constraints.in, delocate
-zipp==3.1.0               # via importlib-metadata
+virtualenv==20.2.1        # via -r cibuildwheel/resources/constraints.in
+wheel==0.35.1             # via -r cibuildwheel/resources/constraints.in, delocate
 
 # The following packages are considered to be unsafe in a requirements file:
-pip==20.1.1               # via -r cibuildwheel/resources/constraints.in
-setuptools==46.4.0        # via -r cibuildwheel/resources/constraints.in
+pip==20.2.4               # via -r cibuildwheel/resources/constraints.in
+setuptools==50.3.2        # via -r cibuildwheel/resources/constraints.in

cibuildwheel/resources/install_certifi.py

@@ -0,0 +1,50 @@
+# Based on: https://github.com/python/cpython/blob/master/Mac/BuildScript/resources/install_certificates.command
+
+# install_certifi.py
+#
+# sample script to install or update a set of default Root Certificates
+# for the ssl module.  Uses the certificates provided by the certifi package:
+#       https://pypi.org/project/certifi/
+
+import os
+import os.path
+import ssl
+import stat
+import subprocess
+import sys
+
+STAT_0o775 = (stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR
+              | stat.S_IRGRP | stat.S_IWGRP | stat.S_IXGRP
+              | stat.S_IROTH | stat.S_IXOTH)
+
+if sys.version_info[0] == 2:
+    FileNotFoundError = OSError
+
+
+def main():
+    openssl_dir, openssl_cafile = os.path.split(
+        ssl.get_default_verify_paths().openssl_cafile)
+    print(" -- pip install --upgrade certifi")
+    subprocess.check_call([sys.executable,
+                           "-E", "-s", "-m", "pip", "install", "--upgrade", "certifi"])
+
+    import certifi
+    # change working directory to the default SSL directory
+    os.chdir(openssl_dir)
+    relpath_to_certifi_cafile = os.path.relpath(certifi.where())
+
+    print(" -- removing any existing file or link")
+    try:
+        os.remove(openssl_cafile)
+    except FileNotFoundError:
+        pass
+    print(" -- creating symlink to certifi certificate bundle")
+    os.symlink(relpath_to_certifi_cafile, openssl_cafile)
+
+    print(" -- setting permissions")
+    os.chmod(openssl_cafile, STAT_0o775)
+    print(" -- update complete")
+
+
+if __name__ == '__main__':
+    main()

cibuildwheel/resources/pinned_docker_images.cfg

@@ -1,22 +1,22 @@
 [x86_64]
-manylinux1 = quay.io/pypa/manylinux1_x86_64:2020-05-25-b56702d
-manylinux2010 = quay.io/pypa/manylinux2010_x86_64:2020-05-20-c7bbd11
-manylinux2014 = quay.io/pypa/manylinux2014_x86_64:2020-05-17-2f8ac3b
+manylinux1 = quay.io/pypa/manylinux1_x86_64:2020-11-11-0f1f128
+manylinux2010 = quay.io/pypa/manylinux2010_x86_64:2020-11-11-201fb79
+manylinux2014 = quay.io/pypa/manylinux2014_x86_64:2020-11-11-bc8ce45
 
 [i686]
-manylinux1 = quay.io/pypa/manylinux1_i686:2020-05-25-b56702d
-manylinux2010 = quay.io/pypa/manylinux2010_i686:2020-05-20-c7bbd11
-manylinux2014 = quay.io/pypa/manylinux2014_i686:2020-05-17-2f8ac3b
+manylinux1 = quay.io/pypa/manylinux1_i686:2020-11-11-0f1f128
+manylinux2010 = quay.io/pypa/manylinux2010_i686:2020-11-11-201fb79
+manylinux2014 = quay.io/pypa/manylinux2014_i686:2020-11-11-bc8ce45
 
 [pypy_x86_64]
-manylinux2010 = pypywheels/manylinux2010-pypy_x86_64:2020-04-25-eb2cdff
+manylinux2010 = pypywheels/manylinux2010-pypy_x86_64:2020-11-21-a03b9e9
 
 [aarch64]
-manylinux2014 = quay.io/pypa/manylinux2014_aarch64:2020-05-17-2f8ac3b
+manylinux2014 = quay.io/pypa/manylinux2014_aarch64:2020-11-11-bc8ce45
 
 [ppc64le]
-manylinux2014 = quay.io/pypa/manylinux2014_ppc64le:2020-05-17-2f8ac3b
+manylinux2014 = quay.io/pypa/manylinux2014_ppc64le:2020-11-11-bc8ce45
 
 [s390x]
-manylinux2014 = quay.io/pypa/manylinux2014_s390x:2020-05-17-2f8ac3b
+manylinux2014 = quay.io/pypa/manylinux2014_s390x:2020-11-11-bc8ce45
 

cibuildwheel/util.py

@@ -1,11 +1,15 @@
 import os
+import ssl
+import textwrap
 import urllib.request
+from enum import Enum
 from fnmatch import fnmatch
 from pathlib import Path
 from time import sleep
-
 from typing import Dict, List, NamedTuple, Optional, Union
 
+import certifi
+
 from .environment import ParsedEnvironment
 
 
@@ -39,7 +43,10 @@ class BuildSelector:
         return match_any(self.build_patterns) and not match_any(self.skip_patterns)
 
     def __repr__(self) -> str:
-        return f'BuildSelector({" ".join(self.build_patterns)!r} - {" ".join(self.skip_patterns)!r})'
+        if not self.skip_patterns:
+            return f'BuildSelector({" ".join(self.build_patterns)!r})'
+        else:
+            return f'BuildSelector({" ".join(self.build_patterns)!r} - {" ".join(self.skip_patterns)!r})'
 
 
 # Taken from https://stackoverflow.com/a/107717
@@ -65,10 +72,14 @@ def download(url: str, dest: Path) -> None:
     if not dest_dir.exists():
         dest_dir.mkdir(parents=True)
 
+    # we've had issues when relying on the host OS' CA certificates on Windows,
+    # so we use certifi (this sounds odd but requests also does this by default)
+    cafile = os.environ.get('SSL_CERT_FILE', certifi.where())
+    context = ssl.create_default_context(cafile=cafile)
     repeat_num = 3
     for i in range(repeat_num):
         try:
-            response = urllib.request.urlopen(url)
+            response = urllib.request.urlopen(url, context=context)
         except Exception:
             if i == repeat_num - 1:
                 raise
@@ -106,6 +117,9 @@ class DependencyConstraints:
         else:
             return self.base_file_path
 
+    def __repr__(self):
+        return f'{self.__class__.__name__}{self.base_file_path!r})'
+
 
 class BuildOptions(NamedTuple):
     package_dir: Path
@@ -126,3 +140,54 @@ class BuildOptions(NamedTuple):
 
 resources_dir = Path(__file__).resolve().parent / 'resources'
 get_pip_script = resources_dir / 'get-pip.py'
+install_certifi_script = resources_dir / "install_certifi.py"
+
+
+class NonPlatformWheelError(Exception):
+    def __init__(self) -> None:
+        message = textwrap.dedent('''
+            cibuildwheel: Build failed because a pure Python wheel was generated.
+
+            If you intend to build a pure-Python wheel, you don't need cibuildwheel - use
+            `pip wheel -w DEST_DIR .` instead.
+
+            If you expected a platform wheel, check your project configuration, or run
+            cibuildwheel with CIBW_BUILD_VERBOSITY=1 to view build logs.
+        ''')
+
+        super().__init__(message)
+
+
+def strtobool(val: str) -> bool:
+    if val.lower() in ('y', 'yes', 't', 'true', 'on', '1'):
+        return True
+    return False
+
+
+class CIProvider(str, Enum):
+    travis_ci = 'travis'
+    appveyor = 'appveyor'
+    circle_ci = 'circle_ci'
+    azure_pipelines = 'azure_pipelines'
+    github_actions = 'github_actions'
+    gitlab = 'gitlab'
+    other = 'other'
+
+
+def detect_ci_provider() -> Optional[CIProvider]:
+    if 'TRAVIS' in os.environ:
+        return CIProvider.travis_ci
+    elif 'APPVEYOR' in os.environ:
+        return CIProvider.appveyor
+    elif 'CIRCLECI' in os.environ:
+        return CIProvider.circle_ci
+    elif 'AZURE_HTTP_USER_AGENT' in os.environ:
+        return CIProvider.azure_pipelines
+    elif 'GITHUB_ACTIONS' in os.environ:
+        return CIProvider.github_actions
+    elif 'GITLAB_CI' in os.environ:
+        return CIProvider.gitlab
+    elif strtobool(os.environ.get('CI', 'false')):
+        return CIProvider.other
+    else:
+        return None

cibuildwheel/windows.py

@@ -3,30 +3,34 @@ import shutil
 import subprocess
 import sys
 import tempfile
+from os import PathLike
 from pathlib import Path
+from typing import Dict, List, NamedTuple, Optional, Sequence, Union
 from zipfile import ZipFile
+
 import toml
 
-from typing import Dict, List, Optional, NamedTuple
-
 from .environment import ParsedEnvironment
-from .util import (
-    BuildOptions,
-    BuildSelector,
-    download,
-    get_build_verbosity_extra_flags,
-    get_pip_script,
-    prepare_command,
-)
-
+from .logger import log
+from .util import (BuildOptions, BuildSelector, NonPlatformWheelError,
+                   download, get_build_verbosity_extra_flags, get_pip_script,
+                   prepare_command)
 
 IS_RUNNING_ON_AZURE = Path('C:\\hostedtoolcache').exists()
 IS_RUNNING_ON_TRAVIS = os.environ.get('TRAVIS_OS_NAME') == 'windows'
 
 
-def shell(args: List[str], env: Optional[Dict[str, str]] = None, cwd: Optional[str] = None) -> int:
-    print('+ ' + ' '.join(args))
-    return subprocess.check_call(' '.join(args), env=env, cwd=cwd, shell=True)
+def call(args: Sequence[Union[str, PathLike]], env: Optional[Dict[str, str]] = None,
+         cwd: Optional[str] = None) -> None:
+    print('+ ' + ' '.join(str(a) for a in args))
+    # we use shell=True here, even though we don't need a shell due to a bug
+    # https://bugs.python.org/issue8557
+    subprocess.check_call([str(a) for a in args], env=env, cwd=cwd, shell=True)
+
+
+def shell(command: str, env: Optional[Dict[str, str]] = None, cwd: Optional[str] = None) -> None:
+    print(f'+ {command}')
+    subprocess.check_call(command, env=env, cwd=cwd, shell=True)
 
 
 def get_nuget_args(version: str, arch: str) -> List[str]:
@@ -52,13 +56,16 @@ def get_python_configurations(build_selector: BuildSelector) -> List[PythonConfi
         PythonConfiguration(version='3.5.4', arch='64', identifier='cp35-win_amd64', url=None),
         PythonConfiguration(version='3.6.8', arch='32', identifier='cp36-win32', url=None),
         PythonConfiguration(version='3.6.8', arch='64', identifier='cp36-win_amd64', url=None),
-        PythonConfiguration(version='3.7.7', arch='32', identifier='cp37-win32', url=None),
-        PythonConfiguration(version='3.7.7', arch='64', identifier='cp37-win_amd64', url=None),
-        PythonConfiguration(version='3.8.3', arch='32', identifier='cp38-win32', url=None),
-        PythonConfiguration(version='3.8.3', arch='64', identifier='cp38-win_amd64', url=None),
+        PythonConfiguration(version='3.7.8', arch='32', identifier='cp37-win32', url=None),
+        PythonConfiguration(version='3.7.8', arch='64', identifier='cp37-win_amd64', url=None),
+        PythonConfiguration(version='3.8.4', arch='32', identifier='cp38-win32', url=None),
+        PythonConfiguration(version='3.8.4', arch='64', identifier='cp38-win_amd64', url=None),
+        PythonConfiguration(version='3.9.0', arch='32', identifier='cp39-win32', url=None),
+        PythonConfiguration(version='3.9.0', arch='64', identifier='cp39-win_amd64', url=None),
         # PyPy
-        PythonConfiguration(version='2.7', arch='32', identifier='pp27-win32', url='https://downloads.python.org/pypy/pypy2.7-v7.3.1-win32.zip'),
-        PythonConfiguration(version='3.6', arch='32', identifier='pp36-win32', url='https://downloads.python.org/pypy/pypy3.6-v7.3.1-win32.zip'),
+        PythonConfiguration(version='2.7', arch='32', identifier='pp27-win32', url='https://downloads.python.org/pypy/pypy2.7-v7.3.3-win32.zip'),
+        PythonConfiguration(version='3.6', arch='32', identifier='pp36-win32', url='https://downloads.python.org/pypy/pypy3.6-v7.3.3-win32.zip'),
+        PythonConfiguration(version='3.7', arch='32', identifier='pp37-win32', url='https://downloads.python.org/pypy/pypy3.7-v7.3.3-win32.zip'),
     ]
 
     if IS_RUNNING_ON_TRAVIS:
@@ -80,7 +87,7 @@ def extract_zip(zip_src: Path, dest: Path) -> None:
 def install_cpython(version: str, arch: str, nuget: Path) -> Path:
     nuget_args = get_nuget_args(version, arch)
     installation_path = Path(nuget_args[-1]) / (nuget_args[0] + '.' + version) / 'tools'
-    shell([str(nuget), 'install'] + nuget_args)
+    call([nuget, 'install', *nuget_args])
     return installation_path
 
 
@@ -101,14 +108,18 @@ def install_pypy(version: str, arch: str, url: str) -> Path:
     return installation_path
 
 
-def setup_python(python_configuration: PythonConfiguration, dependency_constraint_flags: List[str], environment: ParsedEnvironment) -> Dict[str, str]:
+def setup_python(python_configuration: PythonConfiguration, dependency_constraint_flags: Sequence[Union[str, PathLike]], environment: ParsedEnvironment) -> Dict[str, str]:
     nuget = Path('C:\\cibw\\nuget.exe')
     if not nuget.exists():
+        log.step('Downloading nuget...')
         download('https://dist.nuget.org/win-x86-commandline/latest/nuget.exe', nuget)
 
-    if python_configuration.identifier.startswith('cp'):
+    implementation_id = python_configuration.identifier.split("-")[0]
+    log.step(f'Installing Python {implementation_id}...')
+
+    if implementation_id.startswith('cp'):
         installation_path = install_cpython(python_configuration.version, python_configuration.arch, nuget)
-    elif python_configuration.identifier.startswith('pp'):
+    elif implementation_id.startswith('pp'):
         assert python_configuration.url is not None
         installation_path = install_pypy(python_configuration.version, python_configuration.arch, python_configuration.url)
     else:
@@ -116,6 +127,8 @@ def setup_python(python_configuration: PythonConfiguration, dependency_constrain
 
     assert (installation_path / 'python.exe').exists()
 
+    log.step('Setting up build environment...')
+
     # set up PATH and environment variables for run_with_env
     env = os.environ.copy()
     env['PYTHON_VERSION'] = python_configuration.version
@@ -129,9 +142,9 @@ def setup_python(python_configuration: PythonConfiguration, dependency_constrain
     env = environment.as_dictionary(prev_environment=env)
 
     # for the logs - check we're running the right version of python
-    shell(['where', 'python'], env=env)
-    shell(['python', '--version'], env=env)
-    shell(['python', '-c', '"import struct; print(struct.calcsize(\'P\') * 8)"'], env=env)
+    call(['where', 'python'], env=env)
+    call(['python', '--version'], env=env)
+    call(['python', '-c', '"import struct; print(struct.calcsize(\'P\') * 8)"'], env=env)
     where_python = subprocess.check_output(['where', 'python'], env=env, universal_newlines=True).splitlines()[0].strip()
     if where_python != str(installation_path / 'python.exe'):
         print("cibuildwheel: python available on PATH doesn't match our installed instance. If you have modified PATH, ensure that you don't overwrite cibuildwheel's entry or insert python above it.", file=sys.stderr)
@@ -139,17 +152,18 @@ def setup_python(python_configuration: PythonConfiguration, dependency_constrain
 
     # make sure pip is installed
     if not (installation_path / 'Scripts' / 'pip.exe').exists():
-        shell(['python', str(get_pip_script)] + dependency_constraint_flags, env=env, cwd="C:\\cibw")
+        call(['python', get_pip_script, *dependency_constraint_flags], env=env, cwd="C:\\cibw")
     assert (installation_path / 'Scripts' / 'pip.exe').exists()
     where_pip = subprocess.check_output(['where', 'pip'], env=env, universal_newlines=True).splitlines()[0].strip()
     if where_pip.strip() != str(installation_path / 'Scripts' / 'pip.exe'):
         print("cibuildwheel: pip available on PATH doesn't match our installed instance. If you have modified PATH, ensure that you don't overwrite cibuildwheel's entry or insert pip above it.", file=sys.stderr)
         exit(1)
 
-    # prepare the Python environment
-    shell(['python', '-m', 'pip', 'install', '--upgrade', 'pip'] + dependency_constraint_flags, env=env)
-    shell(['pip', '--version'], env=env)
-    shell(['pip', 'install', '--upgrade', 'setuptools', 'wheel'] + dependency_constraint_flags, env=env)
+    log.step('Installing build tools...')
+
+    call(['python', '-m', 'pip', 'install', '--upgrade', 'pip', *dependency_constraint_flags], env=env)
+    call(['pip', '--version'], env=env)
+    call(['pip', 'install', '--upgrade', 'setuptools', 'wheel', *dependency_constraint_flags], env=env)
 
     return env
 
@@ -175,8 +189,15 @@ def pep_518_cp35_workaround(package_dir: Path, env: Dict[str, str]) -> None:
             if 'build-system' in data
             else []
         )
+
         if requirements:
-            shell(['pip', 'install'] + requirements, env=env)
+            log.step('Performing PEP518 workaround...')
+            with tempfile.TemporaryDirectory() as d:
+                reqfile = Path(d) / "requirements.txt"
+                with reqfile.open("w") as f:
+                    for r in requirements:
+                        print(r, file=f)
+                call(['pip', 'install', '-r', reqfile], env=env)
 
 
 def build(options: BuildOptions) -> None:
@@ -184,103 +205,122 @@ def build(options: BuildOptions) -> None:
     built_wheel_dir = temp_dir / 'built_wheel'
     repaired_wheel_dir = temp_dir / 'repaired_wheel'
 
-    # install nuget as best way to provide python
-    nuget = Path('C:\\cibw\\nuget.exe')
-    download('https://dist.nuget.org/win-x86-commandline/latest/nuget.exe', nuget)
+    try:
+        if options.before_all:
+            log.step('Running before_all...')
+            env = options.environment.as_dictionary(prev_environment=os.environ)
+            before_all_prepared = prepare_command(options.before_all, project='.', package=options.package_dir)
+            shell(before_all_prepared, env=env)
 
-    if options.before_all:
-        env = options.environment.as_dictionary(prev_environment=os.environ)
-        before_all_prepared = prepare_command(options.before_all, project='.', package=options.package_dir)
-        shell([before_all_prepared], env=env)
+        python_configurations = get_python_configurations(options.build_selector)
 
-    python_configurations = get_python_configurations(options.build_selector)
-    for config in python_configurations:
-        dependency_constraint_flags = []
-        if options.dependency_constraints:
-            dependency_constraint_flags = [
-                '-c', str(options.dependency_constraints.get_for_python_version(config.version))
-            ]
+        for config in python_configurations:
+            log.build_start(config.identifier)
 
-        # install Python
-        env = setup_python(config, dependency_constraint_flags, options.environment)
+            dependency_constraint_flags: Sequence[Union[str, PathLike]] = []
+            if options.dependency_constraints:
+                dependency_constraint_flags = [
+                    '-c', options.dependency_constraints.get_for_python_version(config.version)
+                ]
 
-        # run the before_build command
-        if options.before_build:
-            before_build_prepared = prepare_command(options.before_build, project='.', package=options.package_dir)
-            shell([before_build_prepared], env=env)
+            # install Python
+            env = setup_python(config, dependency_constraint_flags, options.environment)
 
-        # activate the PEP 518 patch if on Windows Python 3.5
-        # (will only have an effect if PEP 517 builds are used):
-        if config.version.startswith('3.5'):
-            pep_518_cp35_workaround(options.package_dir, env)
+            # run the before_build command
+            if options.before_build:
+                log.step('Running before_build...')
+                before_build_prepared = prepare_command(options.before_build, project='.', package=options.package_dir)
+                shell(before_build_prepared, env=env)
 
-        # build the wheel
-        if built_wheel_dir.exists():
-            shutil.rmtree(built_wheel_dir)
-        built_wheel_dir.mkdir(parents=True)
-        # Path.resolve() is needed. Without it pip wheel may try to fetch package from pypi.org
-        # see https://github.com/joerick/cibuildwheel/pull/369
-        shell(['pip', 'wheel', str(options.package_dir.resolve()), '-w', str(built_wheel_dir), '--no-deps'] + get_build_verbosity_extra_flags(options.build_verbosity), env=env)
-        built_wheel = next(built_wheel_dir.glob('*.whl'))
+            # activate the PEP 518 patch if on Windows Python 3.5
+            # (will only have an effect if PEP 517 builds are used):
+            if config.version.startswith('3.5'):
+                pep_518_cp35_workaround(options.package_dir, env)
 
-        # repair the wheel
-        if repaired_wheel_dir.exists():
-            shutil.rmtree(repaired_wheel_dir)
-        repaired_wheel_dir.mkdir(parents=True)
-        if built_wheel.name.endswith('none-any.whl') or not options.repair_command:
-            # pure Python wheel or empty repair command
-            built_wheel.rename(repaired_wheel_dir / built_wheel.name)
-        else:
-            repair_command_prepared = prepare_command(options.repair_command, wheel=built_wheel, dest_dir=repaired_wheel_dir)
-            shell([repair_command_prepared], env=env)
-        repaired_wheel = next(repaired_wheel_dir.glob('*.whl'))
+            log.step('Building wheel...')
+            if built_wheel_dir.exists():
+                shutil.rmtree(built_wheel_dir)
+            built_wheel_dir.mkdir(parents=True)
+            # Path.resolve() is needed. Without it pip wheel may try to fetch package from pypi.org
+            # see https://github.com/joerick/cibuildwheel/pull/369
+            call([
+                'pip', 'wheel',
+                options.package_dir.resolve(),
+                '-w', built_wheel_dir,
+                '--no-deps',
+                *get_build_verbosity_extra_flags(options.build_verbosity)
+            ], env=env)
 
-        if options.test_command:
-            # set up a virtual environment to install and test from, to make sure
-            # there are no dependencies that were pulled in at build time.
-            shell(['pip', 'install', 'virtualenv'] + dependency_constraint_flags, env=env)
-            venv_dir = Path(tempfile.mkdtemp())
+            built_wheel = next(built_wheel_dir.glob('*.whl'))
 
-            # Use --no-download to ensure determinism by using seed libraries
-            # built into virtualenv
-            shell(['python', '-m', 'virtualenv', '--no-download', str(venv_dir)], env=env)
+            # repair the wheel
+            if repaired_wheel_dir.exists():
+                shutil.rmtree(repaired_wheel_dir)
+            repaired_wheel_dir.mkdir(parents=True)
 
-            virtualenv_env = env.copy()
-            virtualenv_env['PATH'] = os.pathsep.join([
-                str(venv_dir / 'Scripts'),
-                virtualenv_env['PATH'],
-            ])
+            if built_wheel.name.endswith('none-any.whl'):
+                raise NonPlatformWheelError()
 
-            # check that we are using the Python from the virtual environment
-            shell(['which', 'python'], env=virtualenv_env)
+            if options.repair_command:
+                log.step('Repairing wheel...')
+                repair_command_prepared = prepare_command(options.repair_command, wheel=built_wheel, dest_dir=repaired_wheel_dir)
+                shell(repair_command_prepared, env=env)
+            else:
+                shutil.move(str(built_wheel), repaired_wheel_dir)
 
-            if options.before_test:
-                before_test_prepared = prepare_command(
-                    options.before_test,
-                    project='.',
-                    package=options.package_dir
+            repaired_wheel = next(repaired_wheel_dir.glob('*.whl'))
+
+            if options.test_command:
+                log.step('Testing wheel...')
+                # set up a virtual environment to install and test from, to make sure
+                # there are no dependencies that were pulled in at build time.
+                call(['pip', 'install', 'virtualenv', *dependency_constraint_flags], env=env)
+                venv_dir = Path(tempfile.mkdtemp())
+
+                # Use --no-download to ensure determinism by using seed libraries
+                # built into virtualenv
+                call(['python', '-m', 'virtualenv', '--no-download', venv_dir], env=env)
+
+                virtualenv_env = env.copy()
+                virtualenv_env['PATH'] = os.pathsep.join([
+                    str(venv_dir / 'Scripts'),
+                    virtualenv_env['PATH'],
+                ])
+
+                # check that we are using the Python from the virtual environment
+                call(['which', 'python'], env=virtualenv_env)
+
+                if options.before_test:
+                    before_test_prepared = prepare_command(
+                        options.before_test,
+                        project='.',
+                        package=options.package_dir
+                    )
+                    shell(before_test_prepared, env=virtualenv_env)
+
+                # install the wheel
+                call(['pip', 'install', str(repaired_wheel) + options.test_extras], env=virtualenv_env)
+
+                # test the wheel
+                if options.test_requires:
+                    call(['pip', 'install'] + options.test_requires, env=virtualenv_env)
+
+                # run the tests from c:\, with an absolute path in the command
+                # (this ensures that Python runs the tests against the installed wheel
+                # and not the repo code)
+                test_command_prepared = prepare_command(
+                    options.test_command,
+                    project=Path('.').resolve(),
+                    package=options.package_dir.resolve()
                 )
-                shell([before_test_prepared], env=virtualenv_env)
+                shell(test_command_prepared, cwd='c:\\', env=virtualenv_env)
 
-            # install the wheel
-            shell(['pip', 'install', str(repaired_wheel) + options.test_extras], env=virtualenv_env)
+                # clean up
+                shutil.rmtree(venv_dir)
 
-            # test the wheel
-            if options.test_requires:
-                shell(['pip', 'install'] + options.test_requires, env=virtualenv_env)
-
-            # run the tests from c:\, with an absolute path in the command
-            # (this ensures that Python runs the tests against the installed wheel
-            # and not the repo code)
-            test_command_prepared = prepare_command(
-                options.test_command,
-                project=Path('.').resolve(),
-                package=options.package_dir.resolve()
-            )
-            shell([test_command_prepared], cwd='c:\\', env=virtualenv_env)
-
-            # clean up
-            shutil.rmtree(venv_dir)
-
-        # we're all done here; move it to output (remove if already exists)
-        repaired_wheel.replace(options.output_dir / repaired_wheel.name)
+            # we're all done here; move it to output (remove if already exists)
+            shutil.move(str(repaired_wheel), options.output_dir)
+            log.build_end()
+    except subprocess.CalledProcessError as error:
+        log.error(f'Command {error.cmd} failed with code {error.returncode}. {error.stdout}')
+        exit(1)

docs/contributing.md

@@ -28,3 +28,79 @@ cibuildwheel doesn't really do anything itself - it's always deferring to other
 We're not responsible for errors in those tools, for fixing errors/crashes there. But cibuildwheel's job is providing users with an 'integrated' user experience across those tools. We provide an abstraction. The user says 'build me some wheels', not 'open the docker container, build a wheel with pip, fix up the symbols with auditwheel' etc.  However, errors have a habit of breaking abstractions. And this is where users get confused, because the mechanism of cibuildwheel is laid bare, and they must understand a little bit how it works to debug.
 
 So, if we can, I'd like to improve the experience on errors as well. In [this](https://github.com/joerick/cibuildwheel/issues/139) case, it takes a bit of knowledge to understand that the linux builds are happening in a totally different OS via docker, that the linked symbols won't match, that auditwheel will fail because of this. A problem with how the tools fit together, instead of the tools themselves.
+
+Maintainer notes
+----------------
+
+## Testing minimal configs
+
+cibuildwheel's _minimal_ example configs can be tested on a simple project on cibuildwheel's existing CI. These should be run whenever the minimal configs change.
+
+To test minimal configs, make sure you have a clean git repo, then run the script:
+
+```bash
+bin/run_example_ci_configs.py
+```
+
+The script will create an isolated 'orphan' commit containing all the minimal config CI files, and a simple C extension project, and push that to a branch on the `origin` repo. The project's CI is already set up to run on branch push, so will begin testing.
+
+The script then outputs a Markdown table that can be copy/pasted into a PR to monitor and record the test.
+
+## Preparing environments
+
+The dependency update script in the next section requires multiple python versions installed. One way to do this is to use `pyenv`:
+
+```bash
+pyenv install 2.7.18
+pyenv install 3.5.9
+pyenv install 3.6.11
+pyenv install 3.7.8
+# Optionally add 3.8 and make it the local version;
+# otherwise assuming 3.8+ already is your current python version
+```
+
+Then, you need to make the required virtual environments:
+
+```bash
+$(pyenv prefix 2.7.18)/bin/python -m pip install virtualenv
+$(pyenv prefix 2.7.18)/bin/python -m virtualenv env27
+$(pyenv prefix 3.5.9)/bin/python -m venv env35
+$(pyenv prefix 3.6.11)/bin/python -m venv env36
+$(pyenv prefix 3.7.8)/bin/python -m venv env37
+```
+
+<!-- Note for fish users: use zsh/bash for these lines for now, there's not a nice one-line fish replacement -->
+
+And, you need to install the requirements into each environment:
+
+```bash
+for f in env*/bin/pip; do $f install pip-tools; done
+```
+
+
+## Making a release
+
+Before making a release, ensure pinned dependencies are up-to-date. Run the script:
+
+```bash
+bin/make_dependency_update_pr.py
+```
+
+If updates are needed, this will push a PR with those updates for the CI to test. Once green, merge this PR.
+
+Then, increment the project version number using:
+
+```bash
+bin/bump_version.py
+```
+
+You'll be prompted to enter the new version number. Update the changelog when prompted. The script will create a 'bump version' commit and version tag.
+
+Finally, cut the release and upload to PyPI/Github.
+
+```bash
+rm -rf dist
+python setup.py sdist bdist_wheel
+twine upload dist/*
+git push && git push --tags
+```

docs/deliver-to-pypi.md

@@ -9,14 +9,14 @@ After you've built your wheels, you'll probably want to deliver them to PyPI.
 On your development machine, do the following...
 
 ```bash
-# Clear out your 'dist' folder. 
+# Clear out your 'dist' folder.
 rm -rf dist
 # Make a source distribution
 python setup.py sdist
 
 # 🏃🏻
 # Go and download your wheel files from wherever you put them. e.g. your CI
-# provider can be configured to store them for you. Put them all into the 
+# provider can be configured to store them for you. Put them all into the
 # 'dist' folder.
 
 # Upload using 'twine' (you may need to 'pip install twine')
@@ -33,4 +33,4 @@ Obviously, manual steps are for chumps, so we can automate this a little by usin
 
 If you don't need much control over the release of a package, you can set up cibuildwheel to deliver the wheels straight to PyPI. This doesn't require anycloud storage to work - you just need to bump the version and tag it.
 
-[`examples/travis-deploy.yml`](https://github.com/joerick/cibuildwheel/blob/master/examples/travis-deploy.yml) and [`examples/github-deploy.yml`](https://github.com/joerick/cibuildwheel/blob/master/examples/travis-deploy.yml) are example configurations that automatocially upload wheels to PyPI. Also check out [this example repo](https://github.com/joerick/cibuildwheel-autopypi-example) for more detailed instructions on how to set this up.
+[`examples/travis-ci-deploy.yml`](https://github.com/joerick/cibuildwheel/blob/master/examples/travis-ci-deploy.yml) and [`examples/github-deploy.yml`](https://github.com/joerick/cibuildwheel/blob/master/examples/github-deploy.yml) are example configurations that automatically upload wheels to PyPI. Also check out [this example repo](https://github.com/joerick/cibuildwheel-autopypi-example) for more detailed instructions on how to set this up.

docs/extra.css

@@ -59,7 +59,7 @@ h1, h2, h3, h4, h5, h6 {
     background-color: #eff1f3;
     font-size: 85%;
     font-weight: bold;
-    
+
     border-top-left-radius: 3px;
     border-top-right-radius: 3px;
 

docs/faq.md

@@ -61,3 +61,23 @@ python3 -m cibuildwheel --output-dir wheelhouse
 python3 -m pip install twine
 python3 -m twine upload wheelhouse/*.whl
 ```
+
+### 'ImportError: DLL load failed: The specific module could not be found' error on Windows
+
+Visual Studio and MSVC link the compiled binary wheels to the Microsoft Visual C++ Runtime. Normally, these are included with Python, but when compiling with a newer version of Visual Studio, it is possible users will run into problems on systems that do not have these runtime libraries installed. The solution is to ask users to download the corresponding Visual C++ Redistributable from the [Microsoft website](https://support.microsoft.com/en-us/help/2977003/the-latest-supported-visual-c-downloads) and install it. Since a Python installation normally includes these VC++ Redistributable files for [the version of the MSVC compiler used to compile Python](https://wiki.python.org/moin/WindowsCompilers), this is typically only a problem when compiling a Python 2.7 C extension with a newer compiler, e.g. to support a modern C++ standard (see [the section on modern C++ standards for Python 2.7](cpp_standards.md#windows-and-python-27) for more details).
+
+Additionally, Visual Studio 2019 started linking to an even newer DLL, `VCRUNTIME140_1.dll`, besides the `VCRUNTIME140.dll` that is included with recent Python versions (starting from Python 3.5; see [here](https://wiki.python.org/moin/WindowsCompilers) for more details on the corresponding Visual Studio & MSVC versions used to compile the different Python versions). To avoid this extra dependency on `VCRUNTIME140_1.dll`, the [`/d2FH4-` flag](https://devblogs.microsoft.com/cppblog/making-cpp-exception-handling-smaller-x64/) can be added to the MSVC invocations (check out [this issue](https://github.com/joerick/cibuildwheel/issues/423) for details and references).
+
+To add the `/d2FH4-` flag to a standard `setup.py` using `setuptools`, the `extra_compile_args` option can be used:
+
+```python
+    ext_modules=[
+        Extension(
+            'c_module',
+            sources=['extension.c'],
+            extra_compile_args=['/d2FH4-'] if sys.platform == 'win32' else []
+        )
+    ],
+```
+
+To investigate the dependencies of a C extension (i.e., the `.pyd` file, a DLL in disguise) on Windows, [Dependency Walker](http://www.dependencywalker.com/) is a great tool.

docs/index.md

@@ -2,9 +2,9 @@
 title: Home
 ---
 
-{% 
+{%
    includemarkdown "../README.md"
-   start="<!--intro-start-->" 
+   start="<!--intro-start-->"
    end="<!--intro-end-->"
 %}
 

docs/options.md

@@ -86,13 +86,16 @@ When setting the options, you can use shell-style globbing syntax (as per [`fnma
 | Python 3.6      | cp36-macosx_x86_64  | cp36-manylinux_x86_64  | cp36-manylinux_i686  | cp36-win_amd64  | cp36-win32     | cp36-manylinux_aarch64 | cp36-manylinux_ppc64le | cp36-manylinux_s390x |
 | Python 3.7      | cp37-macosx_x86_64  | cp37-manylinux_x86_64  | cp37-manylinux_i686  | cp37-win_amd64  | cp37-win32     | cp37-manylinux_aarch64 | cp37-manylinux_ppc64le | cp37-manylinux_s390x |
 | Python 3.8      | cp38-macosx_x86_64  | cp38-manylinux_x86_64  | cp38-manylinux_i686  | cp38-win_amd64  | cp38-win32     | cp38-manylinux_aarch64 | cp38-manylinux_ppc64le | cp38-manylinux_s390x |
-| PyPy 2.7 v7.3.0 | pp27-macosx_x86_64  | pp27-manylinux_x86_64  |                      |                 | pp27-win32     |                        |                        |                      |
-| PyPy 3.6 v7.3.0 | pp36-macosx_x86_64  | pp36-manylinux_x86_64  |                      |                 | pp36-win32     |                        |                        |                      |
+| Python 3.9      | cp39-macosx_x86_64  | cp39-manylinux_x86_64  | cp39-manylinux_i686  | cp39-win_amd64  | cp39-win32     | cp39-manylinux_aarch64 | cp39-manylinux_ppc64le | cp39-manylinux_s390x |
+| PyPy 2.7 v7.3.3 | pp27-macosx_x86_64  | pp27-manylinux_x86_64  |                      |                 | pp27-win32     |                        |                        |                      |
+| PyPy 3.6 v7.3.3 | pp36-macosx_x86_64  | pp36-manylinux_x86_64  |                      |                 | pp36-win32     |                        |                        |                      |
+| PyPy 3.7 (beta) v7.3.3 | pp37-macosx_x86_64  | pp37-manylinux_x86_64  |                      |                 | pp37-win32     |                        |                        |                      |
+
 
 The list of supported and currently selected build identifiers can also be retrieved by passing the `--print-build-identifiers` flag to `cibuildwheel`.
 The format is `python_tag-platform_tag`, with tags similar to those in [PEP 425](https://www.python.org/dev/peps/pep-0425/#details).
 
-For CPython, the minimally supported macOS version is 10.9; for PyPy 2.7 and PyPy 3.6, respectively macOS 10.7 and 10.13 or higher is required.
+For CPython, the minimally supported macOS version is 10.9; for PyPy 2.7 and PyPy 3.6/3.7, respectively macOS 10.7 and 10.13 or higher is required.
 
 #### Examples
 

docs/setup.md

@@ -48,7 +48,7 @@ Commit this file, enable building of your repo on Travis CI, and push.
 
 Then setup a deployment method by following the [Travis CI deployment docs](https://docs.travis-ci.com/user/deployment/), or see [Delivering to PyPI](deliver-to-pypi.md). For more info on `.travis.yml`, check out the [docs](https://docs.travis-ci.com/).
 
-[`examples/travis-deploy.yml`](https://github.com/joerick/cibuildwheel/blob/master/examples/travis-deploy.yml) extends this minimal example with a demonstration of how to automatically upload the built wheels to PyPI.
+[`examples/travis-ci-deploy.yml`](https://github.com/joerick/cibuildwheel/blob/master/examples/travis-ci-deploy.yml) extends this minimal example with a demonstration of how to automatically upload the built wheels to PyPI.
 
 # CircleCI [linux/mac] {: #circleci}
 
@@ -66,6 +66,19 @@ Commit this file, enable building of your repo on CircleCI, and push.
 
 CircleCI will store the built wheels for you - you can access them from the project console. Check out the CircleCI [docs](https://circleci.com/docs/2.0/configuration-reference/#section=configuration) for more info on this config file.
 
+# Gitlab CI [linux] {: #gitlab-ci}
+
+To build Linux wheels on Gitlab CI, create a `.gitlab-ci.yml` file in your repo,
+
+> .gitlab-ci.yml
+```yaml
+{% include "../examples/gitlab-minimal.yml" %}
+```
+
+Commit this file, and push to Gitlab. The pipeline should start automatically.
+
+Gitlab will store the built wheels for you - you can access them from the Pipelines view. Check out the Gitlab [docs](https://docs.gitlab.com/ee/ci/yaml/) for more info on this config file.
+
 # AppVeyor [linux/mac/windows] {: #appveyor}
 
 To build Linux, Mac, and Windows wheels on AppVeyor, create an `appveyor.yml` file in your repo.

examples/appveyor-minimal.yml

@@ -12,7 +12,7 @@ stack: python 3.7
 init:
 - cmd: set PATH=C:\Python37;C:\Python37\Scripts;%PATH%
 
-install: python -m pip install cibuildwheel==1.5.0
+install: python -m pip install cibuildwheel==1.7.0
 
 build_script: python -m cibuildwheel --output-dir wheelhouse
 

examples/azure-pipelines-minimal.yml

@@ -4,9 +4,12 @@ jobs:
   steps:
     - task: UsePythonVersion@0
     - bash: |
+        set -o errexit
         python3 -m pip install --upgrade pip
-        pip3 install cibuildwheel==1.5.0
-        cibuildwheel --output-dir wheelhouse .
+        pip3 install cibuildwheel==1.7.0
+      displayName: Install dependencies
+    - bash: cibuildwheel --output-dir wheelhouse .
+      displayName: Build wheels
     - task: PublishBuildArtifacts@1
       inputs: {pathtoPublish: 'wheelhouse'}
 
@@ -15,11 +18,14 @@ jobs:
   steps:
     - task: UsePythonVersion@0
     - bash: |
+        set -o errexit
         python3 -m pip install --upgrade pip
-        pip3 install cibuildwheel==1.5.0
-        cibuildwheel --output-dir wheelhouse .
+        python3 -m pip install cibuildwheel==1.7.0
+      displayName: Install dependencies
+    - bash: cibuildwheel --output-dir wheelhouse .
+      displayName: Build wheels
     - task: PublishBuildArtifacts@1
-      inputs: {pathtoPublish: 'wheelhouse'}
+      inputs: {pathtoPublish: wheelhouse}
 
 - job: windows
   pool: {vmImage: 'vs2017-win2016'}
@@ -28,8 +34,11 @@ jobs:
     - script: choco install vcpython27 -f -y
       displayName: Install Visual C++ for Python 2.7
     - bash: |
+        set -o errexit
         python -m pip install --upgrade pip
-        pip install cibuildwheel==1.5.0
-        cibuildwheel --output-dir wheelhouse .
+        pip install cibuildwheel==1.7.0
+      displayName: Install dependencies
+    - bash: cibuildwheel --output-dir wheelhouse .
+      displayName: Build wheels
     - task: PublishBuildArtifacts@1
       inputs: {pathtoPublish: 'wheelhouse'}

examples/circleci-minimal.yml

@@ -11,7 +11,7 @@ jobs:
       - run:
           name: Build the Linux wheels.
           command: |
-            pip3 install --user cibuildwheel==1.5.0
+            pip3 install --user cibuildwheel==1.7.0
             cibuildwheel --output-dir wheelhouse
       - store_artifacts:
           path: wheelhouse/
@@ -19,13 +19,13 @@ jobs:
   osx-wheels:
     working_directory: ~/osx-wheels
     macos:
-      xcode: "10.0.0"
+      xcode: 10.0.0
     steps:
       - checkout
       - run:
           name: Build the OS X wheels.
           command: |
-            pip3 install --user cibuildwheel==1.5.0
+            pip3 install cibuildwheel==1.7.0
             cibuildwheel --output-dir wheelhouse
       - store_artifacts:
           path: wheelhouse/

examples/github-deploy.yml

@@ -28,7 +28,7 @@ jobs:
 
       - name: Install cibuildwheel
         run: |
-          python -m pip install cibuildwheel==1.5.0
+          python -m pip install cibuildwheel==1.7.0
 
       - name: Install Visual C++ for Python 2.7
         if: runner.os == 'Windows'

examples/github-minimal.yml

@@ -20,7 +20,7 @@ jobs:
 
       - name: Install cibuildwheel
         run: |
-          python -m pip install cibuildwheel==1.5.0
+          python -m pip install cibuildwheel==1.7.0
 
       - name: Install Visual C++ for Python 2.7
         if: runner.os == 'Windows'

examples/gitlab-minimal.yml

@@ -0,0 +1,19 @@
+linux:
+  image: python:3.8
+  # make a docker daemon available for cibuildwheel to use
+  services:
+    - name: docker:dind
+      entrypoint: ["env", "-u", "DOCKER_HOST"]
+      command: ["dockerd-entrypoint.sh"]
+  variables:
+    DOCKER_HOST: tcp://docker:2375/
+    DOCKER_DRIVER: overlay2
+    # See https://github.com/docker-library/docker/pull/166
+    DOCKER_TLS_CERTDIR: ""
+  script:
+    - curl -sSL https://get.docker.com/ | sh
+    - python -m pip install cibuildwheel
+    - cibuildwheel --output-dir wheelhouse
+  artifacts:
+    paths:
+      - wheelhouse/

examples/travis-ci-deploy.yml

@@ -25,7 +25,7 @@ env:
     # Note: TWINE_PASSWORD is set to a PyPI API token in Travis settings
 
 install:
-  - python3 -m pip install cibuildwheel==1.5.0
+  - python3 -m pip install cibuildwheel==1.7.0
 
 script:
   # build the wheels, put them into './wheelhouse'

examples/travis-ci-minimal.yml

@@ -26,7 +26,7 @@ jobs:
         - ln -s /c/Python38/python.exe /c/Python38/python3.exe
 
 install:
-  - python3 -m pip install cibuildwheel==1.5.0
+  - python3 -m pip install cibuildwheel==1.7.0
 
 script:
   # build the wheels, put them into './wheelhouse'

examples/travis-ci-test-and-deploy.yml

@@ -55,7 +55,7 @@ jobs:
     - stage: deploy
       name: Build and deploy Linux wheels
       services: docker
-      install: python3 -m pip install cibuildwheel==1.5.0
+      install: python3 -m pip install cibuildwheel==1.7.0
       script: python3 -m cibuildwheel --output-dir wheelhouse
       after_success: |
         python3 -m pip install twine
@@ -65,7 +65,7 @@ jobs:
       name: Build and deploy macOS wheels
       os: osx
       language: shell
-      install: python3 -m pip install cibuildwheel==1.5.0
+      install: python3 -m pip install cibuildwheel==1.7.0
       script: python3 -m cibuildwheel --output-dir wheelhouse
       after_success: |
         python3 -m pip install twine
@@ -75,7 +75,7 @@ jobs:
       name: Build and deploy Windows wheels
       os: windows
       language: shell
-      install: python3 -m pip install cibuildwheel==1.5.0
+      install: python3 -m pip install cibuildwheel==1.7.0
       script: python3 -m cibuildwheel --output-dir wheelhouse
       after_success: |
         python3 -m pip install twine

requirements-dev.txt

@@ -6,3 +6,5 @@ pymdown-extensions
 pip-tools
 requests
 click
+mypy
+typing-extensions

setup.cfg

@@ -1,5 +1,6 @@
 [flake8]
-ignore = E501,W503,E741
+ignore = E501,W503,E741,E226,B950
+select = C,E,F,W,B,B9
 application-import-names = cibuildwheel
 exclude =
   cibuildwheel/resources/,

setup.py

@@ -11,14 +11,18 @@ long_description = (this_directory / 'README.md').read_text(encoding='utf-8')
 
 setup(
     name='cibuildwheel',
-    version='1.5.0',
-    install_requires=['bashlex!=0.13', 'toml'],
+    version='1.7.0',
+    install_requires=['bashlex!=0.13', 'toml', 'certifi'],
     description="Build Python wheels on CI with minimal configuration.",
     long_description=long_description,
     long_description_content_type='text/markdown',
     author="Joe Rickerby",
     author_email='joerick@mac.com',
     url='https://github.com/joerick/cibuildwheel',
+    project_urls={
+        'Changelog': 'https://github.com/joerick/cibuildwheel#changelog',
+        'Documentation': 'https://cibuildwheel.readthedocs.io/',
+    },
     packages=['cibuildwheel', ],
     license="BSD",
     zip_safe=False,

test/test_0_basic.py

@@ -1,7 +1,9 @@
-import textwrap
 import platform
-from . import test_projects
-from . import utils
+import textwrap
+import pytest
+
+from cibuildwheel.logger import Logger
+from . import test_projects, utils
 
 basic_project = test_projects.new_c_project(
     setup_py_add=textwrap.dedent('''
@@ -25,6 +27,22 @@ def test(tmp_path):
     assert set(actual_wheels) == set(expected_wheels)
 
 
+@pytest.mark.skip(reason='to keep test output clean')
+def test_sample_build(tmp_path, capfd):
+    project_dir = tmp_path / 'project'
+    basic_project.generate(project_dir)
+
+    # build the wheels, and let the output passthrough to the caller, so
+    # we can see how it looks
+    with capfd.disabled():
+        logger = Logger()
+        logger.step('test_sample_build')
+        try:
+            utils.cibuildwheel_run(project_dir)
+        finally:
+            logger.step_end()
+
+
 def test_build_identifiers(tmp_path):
     project_dir = tmp_path / 'project'
     basic_project.generate(project_dir)

test/test_before_all.py

@@ -1,4 +1,5 @@
-import os
+import pytest
+import subprocess
 import textwrap
 
 from . import utils
@@ -21,18 +22,44 @@ def test(tmp_path):
     project_dir = tmp_path / 'project'
     project_with_before_build_asserts.generate(project_dir)
 
-    with open(os.path.join(project_dir, "text_info.txt"), mode='w') as ff:
+    with (project_dir / 'text_info.txt').open(mode='w') as ff:
         print("dummy text", file=ff)
 
     # build the wheels
+    before_all_command = '''python -c "import os;open('{project}/text_info.txt', 'w').write('sample text '+os.environ.get('TEST_VAL', ''))"'''
     actual_wheels = utils.cibuildwheel_run(project_dir, add_env={
         # write python version information to a temporary file, this is
         # checked in setup.py
-        'CIBW_BEFORE_ALL': '''python -c "import os;open('{project}/text_info.txt', 'w').write('sample text '+os.environ.get('TEST_VAL', ''))"''',
+        'CIBW_BEFORE_ALL': before_all_command,
+        'CIBW_BEFORE_ALL_LINUX': before_all_command + ''' && python -c "import sys; assert sys.version_info >= (3, 6)"''',
         'CIBW_ENVIRONMENT': "TEST_VAL='123'"
     })
 
     # also check that we got the right wheels
-    os.remove(os.path.join(project_dir, "text_info.txt"))
+    (project_dir / 'text_info.txt').unlink()
+    expected_wheels = utils.expected_wheels('spam', '0.1.0')
+    assert set(actual_wheels) == set(expected_wheels)
+
+
+def test_failing_command(tmp_path):
+    project_dir = tmp_path / 'project'
+    test_projects.new_c_project().generate(project_dir)
+
+    with pytest.raises(subprocess.CalledProcessError):
+        utils.cibuildwheel_run(project_dir, add_env={
+            'CIBW_BEFORE_ALL': 'false',
+            'CIBW_BEFORE_ALL_WINDOWS': 'exit /b 1',
+        })
+
+
+def test_cwd(tmp_path):
+    project_dir = tmp_path / 'project'
+    test_projects.new_c_project().generate(project_dir)
+
+    actual_wheels = utils.cibuildwheel_run(project_dir, add_env={
+        'CIBW_BEFORE_ALL': f'''python -c "import os; assert os.getcwd() == {str(project_dir)!r}"''',
+        'CIBW_BEFORE_ALL_LINUX': '''python -c "import os; assert os.getcwd() == '/project'"''',
+    })
+
     expected_wheels = utils.expected_wheels('spam', '0.1.0')
     assert set(actual_wheels) == set(expected_wheels)

test/test_before_build.py

@@ -1,3 +1,5 @@
+import pytest
+import subprocess
 import textwrap
 
 from . import utils
@@ -32,14 +34,41 @@ def test(tmp_path):
     project_dir = tmp_path / 'project'
     project_with_before_build_asserts.generate(project_dir)
 
+    before_build = ('''python -c "import sys; open('{output_dir}pythonversion.txt', 'w').write(sys.version)" && '''
+                    '''python -c "import sys; open('{output_dir}pythonexecutable.txt', 'w').write(sys.executable)"''')
+
     # build the wheels
     actual_wheels = utils.cibuildwheel_run(project_dir, add_env={
         # write python version information to a temporary file, this is
         # checked in setup.py
-        'CIBW_BEFORE_BUILD': '''python -c "import sys; open('/tmp/pythonversion.txt', 'w').write(sys.version)" && python -c "import sys; open('/tmp/pythonexecutable.txt', 'w').write(sys.executable)"''',
-        'CIBW_BEFORE_BUILD_WINDOWS': '''python -c "import sys; open('c:\\pythonversion.txt', 'w').write(sys.version)" && python -c "import sys; open('c:\\pythonexecutable.txt', 'w').write(sys.executable)"''',
+        'CIBW_BEFORE_BUILD': before_build.format(output_dir='/tmp/'),
+        'CIBW_BEFORE_BUILD_WINDOWS': before_build.format(output_dir=r'c:\\'),
     })
 
     # also check that we got the right wheels
     expected_wheels = utils.expected_wheels('spam', '0.1.0')
     assert set(actual_wheels) == set(expected_wheels)
+
+
+def test_failing_command(tmp_path):
+    project_dir = tmp_path / 'project'
+    test_projects.new_c_project().generate(project_dir)
+
+    with pytest.raises(subprocess.CalledProcessError):
+        utils.cibuildwheel_run(project_dir, add_env={
+            'CIBW_BEFORE_BUILD': 'false',
+            'CIBW_BEFORE_BUILD_WINDOWS': 'exit /b 1',
+        })
+
+
+def test_cwd(tmp_path):
+    project_dir = tmp_path / 'project'
+    test_projects.new_c_project().generate(project_dir)
+
+    actual_wheels = utils.cibuildwheel_run(project_dir, add_env={
+        'CIBW_BEFORE_BUILD': f'''python -c "import os; assert os.getcwd() == {str(project_dir)!r}"''',
+        'CIBW_BEFORE_BUILD_LINUX': '''python -c "import os; assert os.getcwd() == '/project'"''',
+    })
+
+    expected_wheels = utils.expected_wheels('spam', '0.1.0')
+    assert set(actual_wheels) == set(expected_wheels)

test/test_dependency_versions.py

@@ -66,6 +66,9 @@ def test_pinned_versions(tmp_path, python_version):
     elif python_version == '3.6':
         constraint_filename = 'constraints-python36.txt'
         build_pattern = '[cp]p36-*'
+    elif python_version == '3.7':
+        constraint_filename = 'constraints-python37.txt'
+        build_pattern = '[cp]p37-*'
     else:
         constraint_filename = 'constraints.txt'
         build_pattern = '[cp]p38-*'

test/test_docker_images.py

@@ -32,10 +32,10 @@ def test(tmp_path):
     actual_wheels = utils.cibuildwheel_run(project_dir, add_env={
         'CIBW_MANYLINUX_X86_64_IMAGE': 'dockcross/manylinux2010-x64',
         'CIBW_MANYLINUX_I686_IMAGE': 'dockcross/manylinux2010-x86',
-        'CIBW_SKIP': 'pp*',
+        'CIBW_SKIP': 'pp* cp39-*',
     })
 
     # also check that we got the right wheels built
     expected_wheels = [w for w in utils.expected_wheels('spam', '0.1.0')
-                       if '-pp' not in w]
+                       if '-pp' not in w and '-cp39-' not in w]
     assert set(actual_wheels) == set(expected_wheels)

test/test_environment.py

@@ -13,12 +13,15 @@ project_with_environment_asserts = test_projects.new_c_project(
         # explode if environment isn't correct, as set in CIBW_ENVIRONMENT
         CIBW_TEST_VAR = os.environ.get("CIBW_TEST_VAR")
         CIBW_TEST_VAR_2 = os.environ.get("CIBW_TEST_VAR_2")
+        CIBW_TEST_VAR_3 = os.environ.get("CIBW_TEST_VAR_3")
         PATH = os.environ.get("PATH")
 
         if CIBW_TEST_VAR != "a b c":
             raise Exception('CIBW_TEST_VAR should equal "a b c". It was "%s"' % CIBW_TEST_VAR)
         if CIBW_TEST_VAR_2 != "1":
             raise Exception('CIBW_TEST_VAR_2 should equal "1". It was "%s"' % CIBW_TEST_VAR_2)
+        if CIBW_TEST_VAR_3 != "test string 3":
+            raise Exception('CIBW_TEST_VAR_3 should equal "test string 3". It was "%s"' % CIBW_TEST_VAR_3)
         if "/opt/cibw_test_path" not in PATH:
             raise Exception('PATH should contain "/opt/cibw_test_path". It was "%s"' % PATH)
         if "$PATH" in PATH:
@@ -44,7 +47,7 @@ def test(tmp_path):
     assert set(actual_wheels) == set(expected_wheels)
 
 
-def test_overridden_path(tmp_path):
+def test_overridden_path(tmp_path, capfd):
     project_dir = tmp_path / 'project'
     output_dir = tmp_path / 'output'
 
@@ -54,8 +57,21 @@ def test_overridden_path(tmp_path):
 
     # mess up PATH, somehow
     with pytest.raises(subprocess.CalledProcessError):
-        utils.cibuildwheel_run(project_dir, output_dir=output_dir, add_env={
-            'CIBW_ENVIRONMENT': '''SOMETHING="$(mkdir new_path && touch new_path/python)" PATH="$(realpath new_path):$PATH"''',
-            'CIBW_ENVIRONMENT_WINDOWS': '''SOMETHING="$(mkdir new_path && type nul > new_path/python.exe)" PATH="$CD\\new_path;$PATH"''',
-        })
+        if utils.platform == 'linux':
+            utils.cibuildwheel_run(project_dir, output_dir=output_dir, add_env={
+                'CIBW_BEFORE_ALL': 'mkdir new_path && touch new_path/python && chmod +x new_path/python',
+                'CIBW_ENVIRONMENT': '''PATH="$(pwd)/new_path:$PATH"''',
+            })
+        else:
+            new_path = tmp_path / 'another_bin'
+            new_path.mkdir()
+            (new_path / 'python').touch(mode=0o777)
+
+            utils.cibuildwheel_run(project_dir, output_dir=output_dir, add_env={
+                'NEW_PATH': str(new_path),
+                'CIBW_ENVIRONMENT': f'''PATH="$NEW_PATH{os.pathsep}$PATH"''',
+            })
+
     assert len(os.listdir(output_dir)) == 0
+    captured = capfd.readouterr()
+    assert "python available on PATH doesn't match our installed instance" in captured.err

test/test_pep518.py

@@ -1,13 +1,18 @@
 import textwrap
 from . import test_projects
 from . import utils
+import os
 
 basic_project = test_projects.new_c_project(
     setup_py_add=textwrap.dedent(
         """
         # Will fail if PEP 518 does work
+        import sys
         import requests
-        assert requests.__version__ == "2.23.0", "Requests found but wrong version ({0})".format(requests.__version__)
+        if sys.version_info < (3, 6, 0):
+            assert requests.__version__ == "2.22.0", "Requests found but wrong version ({0})".format(requests.__version__)
+        else:
+            assert requests.__version__ == "2.23.0", "Requests found but wrong version ({0})".format(requests.__version__)
 
         # Just making sure environment is still set
         import os
@@ -22,9 +27,11 @@ basic_project.files[
 ] = """
 [build-system]
 requires = [
-    "setuptools>=42",
+    "setuptools >= 42",
+    "setuptools_scm[toml]>=4.1.2",
     "wheel",
-    "requests==2.23.0"
+    "requests==2.22.0; python_version<'3.6'",
+    "requests==2.23.0; python_version>='3.6'"
 ]
 
 build-backend = "setuptools.build_meta"
@@ -42,3 +49,10 @@ def test_pep518(tmp_path):
     # check that the expected wheels are produced
     expected_wheels = utils.expected_wheels("spam", "0.1.0")
     assert set(actual_wheels) == set(expected_wheels)
+
+    # These checks ensure an extra file is not created when using custom
+    # workaround; see https://github.com/joerick/cibuildwheel/issues/421
+    assert not (project_dir / "42").exists()
+    assert not (project_dir / "4.1.2").exists()
+
+    assert len(os.listdir(project_dir)) == len(basic_project.files)

test/test_projects/__main__.py

@@ -1,8 +1,9 @@
-from argparse import ArgumentParser
 import importlib
-import tempfile
-import sys
 import subprocess
+import sys
+import tempfile
+from argparse import ArgumentParser
+from pathlib import Path
 
 
 def main():
@@ -10,27 +11,34 @@ def main():
         prog="python -m test.test_projects",
         description='Generate a test project to check it out'
     )
+    parser.add_argument('--open', action='store_true', help='''
+        Open the generated project in a file explorer
+    ''')
     parser.add_argument('PROJECT', help='''
         Python path to a project object. E.g. test.test_0_basic.basic_project
     ''')
+    parser.add_argument('OUTPUT', nargs='?', help='''
+        Path to output dir. If no dir is passed, a tempdir will be generated.
+    ''')
     options = parser.parse_args()
 
     module, _, name = options.PROJECT.rpartition('.')
 
     project = getattr(importlib.import_module(module), name)
 
-    project_dir = tempfile.mkdtemp()
+    project_dir = Path(options.OUTPUT or tempfile.mkdtemp())
     project.generate(project_dir)
 
     print('Project generated at', project_dir)
     print()
 
-    if sys.platform == 'darwin':
-        subprocess.check_call(['open', '--', project_dir])
-    elif sys.platform == 'linux2':
-        subprocess.check_call(['xdg-open', '--', project_dir])
-    elif sys.platform == 'win32':
-        subprocess.check_call(['explorer', project_dir])
+    if options.open:
+        if sys.platform == 'darwin':
+            subprocess.check_call(['open', '--', project_dir])
+        elif sys.platform == 'linux2':
+            subprocess.check_call(['xdg-open', '--', project_dir])
+        elif sys.platform == 'win32':
+            subprocess.check_call(['explorer', project_dir])
 
 
 if __name__ == '__main__':

test/test_pure_wheel.py

@@ -0,0 +1,36 @@
+import subprocess
+import pytest
+from test import test_projects
+from . import utils
+
+pure_python_project = test_projects.TestProject()
+pure_python_project.files['setup.py'] = '''
+from setuptools import Extension, setup
+
+setup(
+    name="spam",
+    py_modules=['spam'],
+    version="0.1.0",
+)
+'''
+
+pure_python_project.files['spam.py'] = '''
+def a_function():
+    pass
+'''
+
+
+def test(tmp_path, capfd):
+    # this test checks that if a pure wheel is generated, the build should
+    # fail.
+    project_dir = tmp_path / 'project'
+    pure_python_project.generate(project_dir)
+
+    with pytest.raises(subprocess.CalledProcessError):
+        actual_wheels = utils.cibuildwheel_run(project_dir)
+        print('produced wheels:', actual_wheels)
+
+    captured = capfd.readouterr()
+    print('out', captured.out)
+    print('err', captured.err)
+    assert "Build failed because a pure Python wheel was generated" in captured.err

test/test_ssl.py

@@ -13,11 +13,10 @@ project_with_ssl_tests = test_projects.new_c_project(
         else:
             from urllib.request import urlopen
 
-        if sys.version_info[0:2] == (3, 3):
-            data = urlopen("https://www.nist.gov")
-        else:
-            context = ssl.SSLContext(ssl.PROTOCOL_TLSv1_2)
-            data = urlopen("https://www.nist.gov", context=context)
+        context = ssl.SSLContext(ssl.PROTOCOL_TLSv1_2)
+        data = urlopen("https://www.nist.gov", context=context)
+        data = urlopen("https://raw.githubusercontent.com/joerick/cibuildwheel/master/CI.md", context=context)
+        data = urlopen("https://raw.githubusercontent.com/joerick/cibuildwheel/master/CI.md")
     ''')
 )
 

test/test_testing.py

@@ -103,15 +103,26 @@ def test_extras_require(tmp_path):
     assert set(actual_wheels) == set(expected_wheels)
 
 
+project_with_a_failing_test = test_projects.new_c_project()
+project_with_a_failing_test.files['test/spam_test.py'] = r'''
+from unittest import TestCase
+
+class TestSpam(TestCase):
+    def test_something(self):
+        self.fail('this test is supposed to fail')
+'''
+
+
 def test_failing_test(tmp_path):
     """Ensure a failing test causes cibuildwheel to error out and exit"""
     project_dir = tmp_path / 'project'
     output_dir = tmp_path / 'output'
-    project_with_a_test.generate(project_dir)
+    project_with_a_failing_test.generate(project_dir)
 
     with pytest.raises(subprocess.CalledProcessError):
         utils.cibuildwheel_run(project_dir, output_dir=output_dir, add_env={
-            'CIBW_TEST_COMMAND': 'false',
+            'CIBW_TEST_REQUIRES': 'nose',
+            'CIBW_TEST_COMMAND': 'nosetests {project}/test',
             # manylinux1 has a version of bash that's been shown to have
             # problems with this, so let's check that.
             'CIBW_MANYLINUX_I686_IMAGE': 'manylinux1',

test/test_troubleshooting.py

@@ -0,0 +1,28 @@
+import subprocess
+import pytest
+from .test_projects import TestProject
+from . import utils
+
+so_file_project = TestProject()
+
+so_file_project.files['libnothing.so'] = ''
+
+so_file_project.files['setup.py'] = '''
+raise Exception('this build will fail')
+'''
+
+
+def test_failed_project_with_so_files(tmp_path, capfd):
+    if utils.platform != 'linux':
+        pytest.skip('this test is only relevant to the linux build')
+
+    project_dir = tmp_path / 'project'
+    so_file_project.generate(project_dir)
+
+    with pytest.raises(subprocess.CalledProcessError):
+        utils.cibuildwheel_run(project_dir)
+
+    captured = capfd.readouterr()
+    print('out', captured.out)
+    print('err', captured.err)
+    assert "NOTE: Shared object (.so) files found in this project." in captured.err

test/utils.py

@@ -91,10 +91,10 @@ def expected_wheels(package_name, package_version, manylinux_versions=None,
         else:
             manylinux_versions = ['manylinux2014']
 
-    python_abi_tags = ['cp35-cp35m', 'cp36-cp36m', 'cp37-cp37m', 'cp38-cp38']
+    python_abi_tags = ['cp35-cp35m', 'cp36-cp36m', 'cp37-cp37m', 'cp38-cp38', 'cp39-cp39']
 
     if pm.machine() in ['x86_64', 'AMD64', 'x86']:
-        python_abi_tags += ['cp27-cp27m', 'pp27-pypy_73', 'pp36-pypy36_pp73']
+        python_abi_tags += ['cp27-cp27m', 'pp27-pypy_73', 'pp36-pypy36_pp73', 'pp37-pypy37_pp73']
 
         if platform == 'linux':
             python_abi_tags.append('cp27-cp27mu')  # python 2.7 has 2 different ABI on manylinux

unit_test/conftest.py

@@ -0,0 +1,21 @@
+import pytest
+
+
+def pytest_addoption(parser):
+    parser.addoption(
+        "--run-docker", action="store_true", default=False, help="run docker tests"
+    )
+
+
+def pytest_configure(config):
+    config.addinivalue_line("markers", "docker: mark test requiring docker to run")
+
+
+def pytest_collection_modifyitems(config, items):
+    if config.getoption("--run-docker"):
+        # --run-docker given in cli: do not skip docker tests
+        return
+    skip_docker = pytest.mark.skip(reason="need --run-docker option to run")
+    for item in items:
+        if "docker" in item.keywords:
+            item.add_marker(skip_docker)

unit_test/docker_container_test.py

@@ -0,0 +1,162 @@
+import platform
+import random
+import shutil
+import subprocess
+import textwrap
+from pathlib import Path, PurePath
+
+import pytest
+
+from cibuildwheel.docker_container import DockerContainer
+from cibuildwheel.environment import EnvironmentAssignment
+
+# for these tests we use manylinux2014 images, because they're available on
+# multi architectures and include python3.8
+pm = platform.machine()
+if pm == "x86_64":
+    DEFAULT_IMAGE = 'quay.io/pypa/manylinux2014_x86_64:2020-05-17-2f8ac3b'
+elif pm == "aarch64":
+    DEFAULT_IMAGE = 'quay.io/pypa/manylinux2014_aarch64:2020-05-17-2f8ac3b'
+elif pm == "ppc64le":
+    DEFAULT_IMAGE = 'quay.io/pypa/manylinux2014_ppc64le:2020-05-17-2f8ac3b'
+elif pm == "s390x":
+    DEFAULT_IMAGE = 'quay.io/pypa/manylinux2014_s390x:2020-05-17-2f8ac3b'
+
+
+@pytest.mark.docker
+def test_simple():
+    with DockerContainer(DEFAULT_IMAGE) as container:
+        assert container.call(['echo', 'hello'], capture_output=True) == 'hello\n'
+
+
+@pytest.mark.docker
+def test_no_lf():
+    with DockerContainer(DEFAULT_IMAGE) as container:
+        assert container.call(['printf', 'hello'], capture_output=True) == 'hello'
+
+
+@pytest.mark.docker
+def test_environment():
+    with DockerContainer(DEFAULT_IMAGE) as container:
+        assert container.call(['sh', '-c', 'echo $TEST_VAR'], env={'TEST_VAR': '1'}, capture_output=True) == '1\n'
+
+
+@pytest.mark.docker
+def test_cwd():
+    with DockerContainer(DEFAULT_IMAGE, cwd='/cibuildwheel/working_directory') as container:
+        assert container.call(['pwd'], capture_output=True) == '/cibuildwheel/working_directory\n'
+        assert container.call(['pwd'], capture_output=True, cwd='/opt') == '/opt\n'
+
+
+@pytest.mark.docker
+def test_container_removed():
+    with DockerContainer(DEFAULT_IMAGE) as container:
+        docker_containers_listing = subprocess.run('docker container ls', shell=True, check=True, stdout=subprocess.PIPE, universal_newlines=True).stdout
+        assert container.name in docker_containers_listing
+        old_container_name = container.name
+
+    docker_containers_listing = subprocess.run('docker container ls', shell=True, check=True, stdout=subprocess.PIPE, universal_newlines=True).stdout
+    assert old_container_name not in docker_containers_listing
+
+
+@pytest.mark.docker
+def test_large_environment():
+    # max environment variable size is 128kB
+    long_env_var_length = 127*1024
+    large_environment = {
+        'a': '0'*long_env_var_length,
+        'b': '0'*long_env_var_length,
+        'c': '0'*long_env_var_length,
+        'd': '0'*long_env_var_length,
+    }
+
+    with DockerContainer(DEFAULT_IMAGE) as container:
+        # check the length of d
+        assert container.call(['sh', '-c', 'echo ${#d}'], env=large_environment, capture_output=True) == f'{long_env_var_length}\n'
+
+
+@pytest.mark.docker
+def test_binary_output():
+    with DockerContainer(DEFAULT_IMAGE) as container:
+        # note: the below embedded snippets are in python2
+
+        # check that we can pass though arbitrary binary data without erroring
+        container.call(['/usr/bin/python2', '-c', textwrap.dedent('''
+            import sys
+            sys.stdout.write(''.join(chr(n) for n in range(0, 256)))
+        ''')])
+
+        # check that we can capture arbitrary binary data
+        output = container.call(['/usr/bin/python2', '-c', textwrap.dedent('''
+            import sys
+            sys.stdout.write(''.join(chr(n % 256) for n in range(0, 512)))
+        ''')], capture_output=True)
+
+        data = bytes(output, encoding='utf8', errors='surrogateescape')
+
+        for i in range(0, 512):
+            assert data[i] == i % 256
+
+        # check that environment variables can carry binary data, except null characters
+        # (https://www.gnu.org/software/libc/manual/html_node/Environment-Variables.html)
+        binary_data = bytes(n for n in range(1, 256))
+        binary_data_string = str(binary_data, encoding='utf8', errors='surrogateescape')
+        output = container.call(
+            ['python2', '-c', 'import os, sys; sys.stdout.write(os.environ["TEST_VAR"])'],
+            env={'TEST_VAR': binary_data_string},
+            capture_output=True,
+        )
+        assert output == binary_data_string
+
+
+@pytest.mark.docker
+def test_file_operations(tmp_path: Path):
+    with DockerContainer(DEFAULT_IMAGE) as container:
+        # test copying a file in
+        test_binary_data = bytes(random.randrange(256) for _ in range(1000))
+        original_test_file = tmp_path / 'test.dat'
+        original_test_file.write_bytes(test_binary_data)
+
+        dst_file = PurePath('/tmp/test.dat')
+
+        container.copy_into(original_test_file, dst_file)
+
+        output = container.call(['cat', dst_file], capture_output=True)
+        assert test_binary_data == bytes(output, encoding='utf8', errors='surrogateescape')
+
+
+@pytest.mark.docker
+def test_dir_operations(tmp_path: Path):
+    with DockerContainer(DEFAULT_IMAGE) as container:
+        test_binary_data = bytes(random.randrange(256) for _ in range(1000))
+        original_test_file = tmp_path / 'test.dat'
+        original_test_file.write_bytes(test_binary_data)
+
+        # test copying a dir in
+        test_dir = tmp_path / 'test_dir'
+        test_dir.mkdir()
+        test_file = test_dir / 'test.dat'
+        shutil.copyfile(original_test_file, test_file)
+
+        dst_dir = PurePath('/tmp/test_dir')
+        dst_file = dst_dir / 'test.dat'
+        container.copy_into(test_dir, dst_dir)
+
+        output = container.call(['cat', dst_file], capture_output=True)
+        assert test_binary_data == bytes(output, encoding='utf8', errors='surrogateescape')
+
+        # test glob
+        assert container.glob(dst_dir, '*.dat') == [dst_file]
+
+        # test copy dir out
+        new_test_dir = tmp_path / 'test_dir_new'
+        container.copy_out(dst_dir, new_test_dir)
+
+        assert test_binary_data == (new_test_dir / 'test.dat').read_bytes()
+
+
+@pytest.mark.docker
+def test_environment_executor():
+    with DockerContainer(DEFAULT_IMAGE) as container:
+        assignment = EnvironmentAssignment("TEST=$(echo 42)")
+        assert assignment.evaluated_value({}, container.environment_executor) == "42"

unit_test/download_test.py

@@ -0,0 +1,31 @@
+import certifi
+import pytest
+import ssl
+
+from cibuildwheel.util import download
+
+
+DOWNLOAD_URL = 'https://raw.githubusercontent.com/joerick/cibuildwheel/v1.6.3/requirements-dev.txt'
+
+
+def test_download(monkeypatch, tmp_path):
+    monkeypatch.delenv('SSL_CERT_FILE', raising=False)
+    dest = tmp_path / 'file.txt'
+    download(DOWNLOAD_URL, dest)
+    assert len(dest.read_bytes()) == 134
+
+
+def test_download_good_ssl_cert_file(monkeypatch, tmp_path):
+    monkeypatch.setenv('SSL_CERT_FILE', certifi.where())
+    dest = tmp_path / 'file.txt'
+    download(DOWNLOAD_URL, dest)
+    assert len(dest.read_bytes()) == 134
+
+
+def test_download_bad_ssl_cert_file(monkeypatch, tmp_path):
+    bad_cafile = tmp_path / 'ca.pem'
+    bad_cafile.write_text('bad certificates')
+    monkeypatch.setenv('SSL_CERT_FILE', str(bad_cafile))
+    dest = tmp_path / 'file.txt'
+    with pytest.raises(ssl.SSLError):
+        download(DOWNLOAD_URL, dest)

unit_test/environment_test.py

@@ -40,7 +40,7 @@ def test_inheritance():
 
 
 def test_shell_eval():
-    environment_recipe = parse_environment('VAR="$(echo "a test" string)"')
+    environment_recipe = parse_environment('VAR="$(echo "a   test" string)"')
 
     env_copy = os.environ.copy()
     env_copy.pop('VAR', None)
@@ -50,8 +50,8 @@ def test_shell_eval():
     )
     environment_cmds = environment_recipe.as_shell_commands()
 
-    assert environment_dict['VAR'] == 'a test string'
-    assert environment_cmds == ['export VAR="$(echo "a test" string)"']
+    assert environment_dict['VAR'] == 'a   test string'
+    assert environment_cmds == ['export VAR="$(echo "a   test" string)"']
 
 
 def test_shell_eval_and_env():
@@ -94,3 +94,32 @@ def test_no_vars_pass_through():
     environment_dict = environment_recipe.as_dictionary(prev_environment={'CIBUILDWHEEL': 'awesome'})
 
     assert environment_dict == {'CIBUILDWHEEL': 'awesome'}
+
+
+def test_operators_inside_eval():
+    environment_recipe = parse_environment('SOMETHING="$(echo a; echo b; echo c)"')
+
+    # pass the existing process env so PATH is available
+    environment_dict = environment_recipe.as_dictionary(os.environ.copy())
+
+    assert environment_dict.get('SOMETHING') == 'a\nb\nc'
+
+
+def test_substitution_with_backslash():
+    environment_recipe = parse_environment('PATH2="somewhere_else;$PATH1"')
+
+    # pass the existing process env so PATH is available
+    environment_dict = environment_recipe.as_dictionary(prev_environment={
+        'PATH1': 'c:\\folder\\'
+    })
+
+    assert environment_dict.get('PATH2') == 'somewhere_else;c:\\folder\\'
+
+
+def test_awkwardly_quoted_variable():
+    environment_recipe = parse_environment('VAR2=something"like this""$VAR1"$VAR1$(echo "theres more")"$(echo "and more!")"')
+
+    # pass the existing process env so PATH is available
+    environment_dict = environment_recipe.as_dictionary({'VAR1': 'but wait'})
+
+    assert environment_dict.get('VAR2') == 'somethinglike thisbut waitbut waittheres moreand more!'

unit_test/main_tests/main_platform_test.py

@@ -11,7 +11,11 @@ def test_unknown_platform_non_ci(monkeypatch, capsys):
     monkeypatch.delenv('CI', raising=False)
     monkeypatch.delenv('BITRISE_BUILD_NUMBER', raising=False)
     monkeypatch.delenv('AZURE_HTTP_USER_AGENT', raising=False)
-    monkeypatch.delenv('GITHUB_WORKFLOW', raising=False)
+    monkeypatch.delenv('TRAVIS', raising=False)
+    monkeypatch.delenv('APPVEYOR', raising=False)
+    monkeypatch.delenv('GITHUB_ACTIONS', raising=False)
+    monkeypatch.delenv('GITLAB_CI', raising=False)
+    monkeypatch.delenv('CIRCLECI', raising=False)
     monkeypatch.delenv('CIBW_PLATFORM', raising=False)
 
     with pytest.raises(SystemExit) as exit: