Packaging a python library

    dist
    build
    migrations

python_files =
    test_*.py
    *_test.py
    tests.py
addopts =
    -ra
    --strict
    --ignore=docs/conf.py
    --ignore=setup.py
    --ignore=ci
    --ignore=.eggs
    --doctest-modules
    --doctest-glob=\*.rst
    --tb=short
testpaths =
    tests

[tool:isort]
force_single_line = True
line_length = 120
known_first_party = nameless
default_section = THIRDPARTY
forced_separate = test_nameless
skip = .tox,.eggs,ci/templates,build,dist

[matrix]
# This is the configuration for the `./bootstrap.py` script.
# It generates `.travis.yml`, `tox.ini` and `.appveyor.yml`.
#
# Syntax: [alias:] value [!variable[glob]] [&variable[glob]]
#
# alias:
#  - is used to generate the tox environment
#  - it's optional
#  - if not present the alias will be computed from the `value`
# value:
#  - a value of "-" means empty
# !variable[glob]:
#  - exclude the combination of the current `value` with
#    any value matching the `glob` in `variable`
#  - can use as many you want
# &variable[glob]:
#  - only include the combination of the current `value`
#    when there's a value matching `glob` in `variable`
#  - can use as many you want

python_versions =
    py27
    py35
    py36
    py37
    py38
    py39
    pypy
    pypy3

dependencies =
#    1.4: Django==1.4.16 !python_versions[py3*]
#    1.5: Django==1.5.11
#    1.6: Django==1.6.8
#    1.7: Django==1.7.1 !python_versions[py26]
# Deps commented above are provided as examples. That's what you would use in a Django project.

coverage_flags =
    cover: true
    nocov: false
environment_variables =
    -

#!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import absolute_import
from __future__ import print_function
from __future__ import unicode_literals

import os
import subprocess
import sys
from os.path import abspath
from os.path import dirname
from os.path import exists
from os.path import join

base_path = dirname(dirname(abspath(__file__)))


def check_call(args):
    print("+", *args)
    subprocess.check_call(args)


def exec_in_env():
    env_path = join(base_path, ".tox", "bootstrap")
    if sys.platform == "win32":
        bin_path = join(env_path, "Scripts")
    else:
        bin_path = join(env_path, "bin")
    if not exists(env_path):
        import subprocess

        print("Making bootstrap env in: {0} ...".format(env_path))
        try:
            check_call([sys.executable, "-m", "venv", env_path])
        except subprocess.CalledProcessError:
            try:
                check_call([sys.executable, "-m", "virtualenv", env_path])
            except subprocess.CalledProcessError:
                check_call(["virtualenv", env_path])
        print("Installing `jinja2` into bootstrap environment...")
        check_call([join(bin_path, "pip"), "install", "jinja2", "tox", "matrix"])
    python_executable = join(bin_path, "python")
    if not os.path.exists(python_executable):
        python_executable += '.exe'

    print("Re-executing with: {0}".format(python_executable))
    print("+ exec", python_executable, __file__, "--no-env")
    os.execv(python_executable, [python_executable, __file__, "--no-env"])


def main():
    import jinja2
    import matrix

    print("Project path: {0}".format(base_path))

    jinja = jinja2.Environment(
        loader=jinja2.FileSystemLoader(join(base_path, "ci", "templates")),
        trim_blocks=True,
        lstrip_blocks=True,
        keep_trailing_newline=True
    )

    tox_environments = {}
    for (alias, conf) in matrix.from_file(join(base_path, "setup.cfg")).items():
        deps = conf["dependencies"]
        tox_environments[alias] = {
            "deps": deps.split(),
        }
        if "coverage_flags" in conf:
            cover = {"false": False, "true": True}[conf["coverage_flags"].lower()]
            tox_environments[alias].update(cover=cover)
        if "environment_variables" in conf:
            env_vars = conf["environment_variables"]
            tox_environments[alias].update(env_vars=env_vars.split())

    for name in os.listdir(join("ci", "templates")):
        with open(join(base_path, name), "w") as fh:
            fh.write(jinja.get_template(name).render(tox_environments=tox_environments))
        print("Wrote {}".format(name))
    print("DONE.")


if __name__ == "__main__":
    args = sys.argv[1:]
    if args == ["--no-env"]:
        main()
    elif not args:
        exec_in_env()
    else:
        print("Unexpected arguments {0}".format(args), file=sys.stderr)
        sys.exit(1)

language: python
dist: xenial
virt: lxd
cache: false
env:
  global:
    - LD_PRELOAD=/lib/x86_64-linux-gnu/libSegFault.so
    - SEGFAULT_SIGNALS=all
    - LANG=en_US.UTF-8
matrix:
  include:
    - python: '3.6'
      env:
        - TOXENV=check
{%- for env, config in tox_environments|dictsort %}{{ '' }}
    - env:
        - TOXENV={{ env }}{% if config.cover %},codecov,extension-coveralls,coveralls{% endif %}
{%- if env.startswith('pypy3') %}{{ '' }}
        - TOXPYTHON=pypy3
      python: 'pypy3'
{%- elif env.startswith('pypy') %}{{ '' }}
      python: 'pypy'
{%- else %}{{ '' }}
      python: '{{ '{0[2]}.{0[3]}'.format(env) }}'
{%- endif %}{{ '' }}
{%- endfor %}{{ '' }}
before_install:
  - python --version
  - uname -a
  - lsb_release -a || true
install:
  - python -mpip install --progress-bar=off tox -rci/requirements.txt
  - virtualenv --version
  - easy_install --version
  - pip --version
  - tox --version
script:
  - tox -v
after_failure:
  - cat .tox/log/*
  - cat .tox/*/log/*
notifications:
  email:
    on_success: never
    on_failure: always

[tox]
envlist =
    clean,
    check,
{% for env in tox_environments|sort %}
    {{ env }},
{% endfor %}
    report

[testenv]
basepython =
    {bootstrap,clean,check,report,codecov,coveralls,extension-coveralls}: {env:TOXPYTHON:python3}
setenv =
    PYTHONPATH={toxinidir}/tests
    PYTHONUNBUFFERED=yes
passenv =
    *
deps =
    pytest
    pytest-travis-fold
commands =
    python setup.py clean --all build_ext --force --inplace
    {posargs:pytest -vv --ignore=src}

[testenv:bootstrap]
deps =
    jinja2
    matrix
skip_install = true
commands =
    python ci/bootstrap.py --no-env

[testenv:check]
deps =
    docutils
    check-manifest
    flake8
    readme-renderer
    pygments
    isort
skip_install = true
commands =
    python setup.py check --strict --metadata --restructuredtext
    check-manifest {toxinidir}
    flake8
    isort --verbose --check-only --diff --filter-files .


[testenv:coveralls]
deps =
    coveralls
skip_install = true
commands =
    coveralls --merge=extension-coveralls.json []


[testenv:extension-coveralls]
deps =
    cpp-coveralls
skip_install = true
commands =
    coveralls --build-root=. --include=src --dump=extension-coveralls.json []


[testenv:codecov]
deps =
    codecov
skip_install = true
commands =
    codecov --gcov-root=. []

[testenv:report]
deps = coverage
skip_install = true
commands =
    coverage report
    coverage html

[testenv:clean]
commands = coverage erase
skip_install = true
deps = coverage
{% for env, config in tox_environments|dictsort %}

[testenv:{{ env }}]
basepython = {env:TOXPYTHON:{{ env.split("-")[0] if env.startswith("pypy") else "python{0[2]}.{0[3]}".format(env) }}}
{% if config.cover or config.env_vars %}
setenv =
    {[testenv]setenv}
{% endif %}
{% for var in config.env_vars %}
    {{ var }}
{% endfor %}
{% if config.cover %}
    SETUP_PY_EXT_COVERAGE=yes
usedevelop = true
commands =
    python setup.py clean --all build_ext --force --inplace
    {posargs:pytest --cov --cov-report=term-missing -vv}
{% endif %}
{% if config.cover or config.deps %}
deps =
    {[testenv]deps}
{% endif %}
{% if config.cover %}
    pytest-cov
{% endif %}
{% for dep in config.deps %}
    {{ dep }}
{% endfor -%}
{% endfor -%}

version: '{branch}-{build}'
build: off
environment:
  global:
    COVERALLS_EXTRAS: '-v'
    COVERALLS_REPO_TOKEN: IoRlAEvnKbwbhBJ2jrWPqzAnE2jobA0I3
  matrix:
    - TOXENV: check
      TOXPYTHON: C:\Python36\python.exe
      PYTHON_HOME: C:\Python36
      PYTHON_VERSION: '3.6'
      PYTHON_ARCH: '32'
{% for env, config in tox_environments|dictsort %}
{% if env.startswith(('py2', 'py3')) %}
    - TOXENV: {{ env }}{% if config.cover %},codecov,coveralls{% endif %}{{ "" }}
      TOXPYTHON: C:\Python{{ env[2:4] }}\python.exe
      PYTHON_HOME: C:\Python{{ env[2:4] }}
      PYTHON_VERSION: '{{ env[2] }}.{{ env[3] }}'
      PYTHON_ARCH: '32'
{% if 'nocov' in env %}
      WHEEL_PATH: .tox/dist
{% endif %}
    - TOXENV: {{ env }}{% if config.cover %},codecov,coveralls{% endif %}{{ "" }}
      TOXPYTHON: C:\Python{{ env[2:4] }}-x64\python.exe
      PYTHON_HOME: C:\Python{{ env[2:4] }}-x64
      PYTHON_VERSION: '{{ env[2] }}.{{ env[3] }}'
      PYTHON_ARCH: '64'
{% if 'nocov' in env %}
      WHEEL_PATH: .tox/dist
{% endif %}
{% if env.startswith('py2') %}
      WINDOWS_SDK_VERSION: v7.0
{% endif %}
{% endif %}{% endfor %}
init:
  - ps: echo $env:TOXENV
  - ps: ls C:\Python*
install:
  - '%PYTHON_HOME%\python -mpip install --progress-bar=off tox -rci/requirements.txt'
  - '%PYTHON_HOME%\Scripts\virtualenv --version'
  - '%PYTHON_HOME%\Scripts\easy_install --version'
  - '%PYTHON_HOME%\Scripts\pip --version'
  - '%PYTHON_HOME%\Scripts\tox --version'
test_script:
  - cmd /E:ON /V:ON /C .\ci\appveyor-with-compiler.cmd %PYTHON_HOME%\Scripts\tox
on_failure:
  - ps: dir "env:"
  - ps: get-content .tox\*\log\*

### To enable remote debugging uncomment this (also, see: http://www.appveyor.com/docs/how-to/rdp-to-build-worker):
# on_finish:
#   - ps: $blockRdp = $true; iex ((new-object net.webclient).DownloadString('https://raw.githubusercontent.com/appveyor/ci/master/scripts/enable-rdp.ps1'))