path: root/meta-python/recipes-devtools/python/python3-pystache/0001-Modernize-python-versions-remove-py2x-and-fix-tests-.patch

From 8bb1ac2d81f697598a766714f2c439d78c85d71e Mon Sep 17 00:00:00 2001
From: Stephen L Arnold <nerdboy@gentoo.org>
Date: Sat, 7 Nov 2020 12:38:33 -0800
Subject: [PATCH] Modernize python versions (remove py2x) and fix tests, update
 spec

* migrate to github actions for CI, add conda recipe/workflow
* fix document processing, update pandoc args and history
* convert doctests and modules to py3
* convert packaging/setup.py to pep517, keep doc processing
* cleanup tox cfg, add coverage, readme status
* add pep8speaks cfg, cleanup warnings, use correct env
* update setup_description.rst for packaging
* set version for test release => 0.6.0 and deploy

Upstream-Status: Backport [https://github.com/defunkt/pystache/pull/214]
Signed-off-by: Stephen L Arnold <nerdboy@gentoo.org>
---
 .coveragerc                               |  38 +++
 .gitchangelog.rc                          | 295 +++++++++++++++++++++
 .github/workflows/ci.yml                  |  73 ++++++
 .github/workflows/conda.yml               |  55 ++++
 .github/workflows/release.yml             |  94 +++++++
 .github/workflows/wheels.yml              |  82 ++++++
 .pep8speaks.yml                           |  15 ++
 HISTORY.md                                |  37 ++-
 MANIFEST.in                               |   8 +-
 README.md                                 | 141 +++++-----
 TODO.md                                   |   5 +-
 conda/meta.yaml                           |  50 ++++
 pyproject.toml                            |   3 +
 pystache/__init__.py                      |   2 +-
 pystache/commands/render.py               |   4 +-
 pystache/common.py                        |  13 +-
 pystache/defaults.py                      |   2 +-
 pystache/loader.py                        |  14 +-
 pystache/parsed.py                        |   6 +-
 pystache/parser.py                        |  20 +-
 pystache/renderengine.py                  |   2 +-
 pystache/renderer.py                      |  22 +-
 pystache/specloader.py                    |   2 +-
 pystache/tests/benchmark.py               |  15 +-
 pystache/tests/common.py                  |  10 +-
 pystache/tests/examples/unicode_output.py |   2 +-
 pystache/tests/main.py                    |  28 +-
 pystache/tests/spectesting.py             |  16 +-
 pystache/tests/test___init__.py           |   4 +-
 pystache/tests/test_commands.py           |   2 +-
 pystache/tests/test_defaults.py           |  18 +-
 pystache/tests/test_examples.py           |  40 +--
 pystache/tests/test_loader.py             |  46 ++--
 pystache/tests/test_pystache.py           |   6 +-
 pystache/tests/test_renderengine.py       | 148 +++++------
 pystache/tests/test_renderer.py           |  86 +++----
 pystache/tests/test_simple.py             |  20 +-
 pystache/tests/test_specloader.py         |  60 ++---
 setup.cfg                                 |  74 +++++-
 setup.py                                  | 134 +---------
 setup_description.rst                     | 297 +++++++++++++---------
 tox.ini                                   | 118 +++++++--
 travis.yml_disabled                       |  52 ++++
 43 files changed, 1487 insertions(+), 672 deletions(-)
 create mode 100644 .coveragerc
 create mode 100644 .gitchangelog.rc
 create mode 100644 .github/workflows/ci.yml
 create mode 100644 .github/workflows/conda.yml
 create mode 100644 .github/workflows/release.yml
 create mode 100644 .github/workflows/wheels.yml
 create mode 100644 .pep8speaks.yml
 create mode 100644 conda/meta.yaml
 create mode 100644 pyproject.toml
 create mode 100644 travis.yml_disabled

diff --git a/.coveragerc b/.coveragerc
new file mode 100644
index 0000000..9a336dd
--- /dev/null
+++ b/.coveragerc
@@ -0,0 +1,38 @@
+# .coveragerc to control coverage.py
+[run]
+branch = True
+
+source = pystache
+
+omit =
+    .tox/*
+    setup.py
+    pystache/tests/*
+
+#plugins =
+#    coverage_python_version
+
+[report]
+# must set this to True to see missing
+#show_missing = True
+
+# Regexes for lines to exclude from consideration
+exclude_lines =
+    # Have to re-enable the standard pragma
+    pragma: no cover
+
+    # Don't complain about missing debug-only code:
+    def __repr__
+    if self\.debug
+
+    # Don't complain if tests don't hit defensive assertion code:
+    raise AssertionError
+    raise NotImplementedError
+
+    # Don't complain if non-runnable code isn't run:
+    if 0:
+
+ignore_errors = True
+
+[html]
+directory = cover
diff --git a/.gitchangelog.rc b/.gitchangelog.rc
new file mode 100644
index 0000000..5cf63a0
--- /dev/null
+++ b/.gitchangelog.rc
@@ -0,0 +1,295 @@
+# -*- coding: utf-8; mode: python -*-
+##
+## Format
+##
+##   ACTION: [AUDIENCE:] COMMIT_MSG [!TAG ...]
+##
+## Description
+##
+##   ACTION is one of 'chg', 'fix', 'new'
+##
+##       Is WHAT the change is about.
+##
+##       'chg' is for refactor, small improvement, cosmetic changes...
+##       'fix' is for bug fixes
+##       'new' is for new features, big improvement
+##
+##   AUDIENCE is optional and one of 'dev', 'usr', 'pkg', 'test', 'doc'
+##
+##       Is WHO is concerned by the change.
+##
+##       'dev'  is for developpers (API changes, refactors...)
+##       'usr'  is for final users (UI changes)
+##       'pkg'  is for packagers   (packaging changes)
+##       'test' is for testers     (test only related changes)
+##       'doc'  is for doc guys    (doc only changes)
+##
+##   COMMIT_MSG is ... well ... the commit message itself.
+##
+##   TAGs are additionnal adjective as 'refactor' 'minor' 'cosmetic'
+##
+##       They are preceded with a '!' or a '@' (prefer the former, as the
+##       latter is wrongly interpreted in github.) Commonly used tags are:
+##
+##       'refactor' is obviously for refactoring code only
+##       'minor' is for a very meaningless change (a typo, adding a comment)
+##       'cosmetic' is for cosmetic driven change (re-indentation, 80-col...)
+##       'wip' is for partial functionality but complete subfunctionality.
+##
+## Example:
+##
+##   new: usr: support of bazaar implemented
+##   chg: re-indentend some lines !cosmetic
+##   new: dev: updated code to be compatible with last version of killer lib.
+##   fix: pkg: updated year of licence coverage.
+##   new: test: added a bunch of test around user usability of feature X.
+##   fix: typo in spelling my name in comment. !minor
+##
+##   Please note that multi-line commit message are supported, and only the
+##   first line will be considered as the "summary" of the commit message. So
+##   tags, and other rules only applies to the summary.  The body of the commit
+##   message will be displayed in the changelog without reformatting.
+
+
+##
+## ``ignore_regexps`` is a line of regexps
+##
+## Any commit having its full commit message matching any regexp listed here
+## will be ignored and won't be reported in the changelog.
+##
+ignore_regexps = [
+    r'@minor', r'!minor',
+    r'@cosmetic', r'!cosmetic',
+    r'@refactor', r'!refactor',
+    r'@wip', r'!wip',
+    r'^([cC]hg|[fF]ix|[nN]ew)\s*:\s*[p|P]kg:',
+    r'^([cC]hg|[fF]ix|[nN]ew)\s*:\s*[d|D]ev:',
+    r'^(.{3,3}\s*:)?\s*[fF]irst commit.?\s*$',
+    r'^$',  ## ignore commits with empty messages
+]
+
+
+## ``section_regexps`` is a list of 2-tuples associating a string label and a
+## list of regexp
+##
+## Commit messages will be classified in sections thanks to this. Section
+## titles are the label, and a commit is classified under this section if any
+## of the regexps associated is matching.
+##
+## Please note that ``section_regexps`` will only classify commits and won't
+## make any changes to the contents. So you'll probably want to go check
+## ``subject_process`` (or ``body_process``) to do some changes to the subject,
+## whenever you are tweaking this variable.
+##
+section_regexps = [
+    ('New', [
+        r'^[nN]ew\s*:\s*((dev|use?r|pkg|test|doc)\s*:\s*)?([^\n]*)$',
+     ]),
+    ('Features', [
+       r'^([nN]ew|[fF]eat)\s*:\s*((dev|use?r|pkg|test|doc)\s*:\s*)?([^\n]*)$',
+     ]),
+    ('Changes', [
+        r'^[cC]hg\s*:\s*((dev|use?r|pkg|test|doc)\s*:\s*)?([^\n]*)$',
+     ]),
+    ('Fixes', [
+        r'^[fF]ix\s*:\s*((dev|use?r|pkg|test|doc)\s*:\s*)?([^\n]*)$',
+     ]),
+
+    ('Other', None ## Match all lines
+     ),
+]
+
+
+## ``body_process`` is a callable
+##
+## This callable will be given the original body and result will
+## be used in the changelog.
+##
+## Available constructs are:
+##
+##   - any python callable that take one txt argument and return txt argument.
+##
+##   - ReSub(pattern, replacement): will apply regexp substitution.
+##
+##   - Indent(chars="  "): will indent the text with the prefix
+##     Please remember that template engines gets also to modify the text and
+##     will usually indent themselves the text if needed.
+##
+##   - Wrap(regexp=r"\n\n"): re-wrap text in separate paragraph to fill 80-Columns
+##
+##   - noop: do nothing
+##
+##   - ucfirst: ensure the first letter is uppercase.
+##     (usually used in the ``subject_process`` pipeline)
+##
+##   - final_dot: ensure text finishes with a dot
+##     (usually used in the ``subject_process`` pipeline)
+##
+##   - strip: remove any spaces before or after the content of the string
+##
+##   - SetIfEmpty(msg="No commit message."): will set the text to
+##     whatever given ``msg`` if the current text is empty.
+##
+## Additionally, you can `pipe` the provided filters, for instance:
+#body_process = Wrap(regexp=r'\n(?=\w+\s*:)') | Indent(chars="  ")
+#body_process = Wrap(regexp=r'\n(?=\w+\s*:)')
+#body_process = noop
+body_process = ReSub(r'((^|\n)[A-Z]\w+(-\w+)*: .*(\n\s+.*)*)+$', r'') | strip
+
+
+## ``subject_process`` is a callable
+##
+## This callable will be given the original subject and result will
+## be used in the changelog.
+##
+## Available constructs are those listed in ``body_process`` doc.
+subject_process = (strip |
+    ReSub(r'^([cC]hg|[fF]ix|[nN]ew)\s*:\s*((dev|use?r|pkg|test|doc)\s*:\s*)?([^\n@]*)(@[a-z]+\s+)*$', r'\4') |
+    SetIfEmpty("No commit message.") | ucfirst | final_dot)
+
+
+## ``tag_filter_regexp`` is a regexp
+##
+## Tags that will be used for the changelog must match this regexp.
+##
+#tag_filter_regexp = r'^v?[0-9]+\.[0-9]+(\.[0-9]+)?$'
+tag_filter_regexp = r'^[0-9]+\.[0-9]+(\.[0-9]+)?$'
+
+
+## ``unreleased_version_label`` is a string or a callable that outputs a string
+##
+## This label will be used as the changelog Title of the last set of changes
+## between last valid tag and HEAD if any.
+unreleased_version_label = "(unreleased)"
+#unreleased_version_label = lambda: swrap(
+#    ["git", "describe", "--tags"],
+#shell=False)
+
+
+## ``output_engine`` is a callable
+##
+## This will change the output format of the generated changelog file
+##
+## Available choices are:
+##
+##   - rest_py
+##
+##        Legacy pure python engine, outputs ReSTructured text.
+##        This is the default.
+##
+##   - mustache(<template_name>)
+##
+##        Template name could be any of the available templates in
+##        ``templates/mustache/*.tpl``.
+##        Requires python package ``pystache``.
+##        Examples:
+##           - mustache("markdown")
+##           - mustache("restructuredtext")
+##
+##   - makotemplate(<template_name>)
+##
+##        Template name could be any of the available templates in
+##        ``templates/mako/*.tpl``.
+##        Requires python package ``mako``.
+##        Examples:
+##           - makotemplate("restructuredtext")
+##
+#output_engine = rest_py
+#output_engine = mustache("restructuredtext")
+output_engine = mustache("markdown")
+#output_engine = makotemplate("restructuredtext")
+
+
+## ``include_merge`` is a boolean
+##
+## This option tells git-log whether to include merge commits in the log.
+## The default is to include them.
+include_merge = True
+
+
+## ``log_encoding`` is a string identifier
+##
+## This option tells gitchangelog what encoding is outputed by ``git log``.
+## The default is to be clever about it: it checks ``git config`` for
+## ``i18n.logOutputEncoding``, and if not found will default to git's own
+## default: ``utf-8``.
+#log_encoding = 'utf-8'
+
+
+## ``publish`` is a callable
+##
+## Sets what ``gitchangelog`` should do with the output generated by
+## the output engine. ``publish`` is a callable taking one argument
+## that is an interator on lines from the output engine.
+##
+## Some helper callable are provided:
+##
+## Available choices are:
+##
+##   - stdout
+##
+##        Outputs directly to standard output
+##        (This is the default)
+##
+##   - FileInsertAtFirstRegexMatch(file, pattern, idx=lamda m: m.start(), flags)
+##
+##        Creates a callable that will parse given file for the given
+##        regex pattern and will insert the output in the file.
+##        ``idx`` is a callable that receive the matching object and
+##        must return a integer index point where to insert the
+##        the output in the file. Default is to return the position of
+##        the start of the matched string.
+##
+##   - FileRegexSubst(file, pattern, replace, flags)
+##
+##        Apply a replace inplace in the given file. Your regex pattern must
+##        take care of everything and might be more complex. Check the README
+##        for a complete copy-pastable example.
+##
+# publish = FileInsertIntoFirstRegexMatch(
+#     "CHANGELOG.rst",
+#     r'/(?P<rev>[0-9]+\.[0-9]+(\.[0-9]+)?)\s+\([0-9]+-[0-9]{2}-[0-9]{2}\)\n--+\n/',
+#     idx=lambda m: m.start(1)
+# )
+#publish = stdout
+
+
+## ``revs`` is a list of callable or a list of string
+##
+## callable will be called to resolve as strings and allow dynamical
+## computation of these. The result will be used as revisions for
+## gitchangelog (as if directly stated on the command line). This allows
+## to filter exaclty which commits will be read by gitchangelog.
+##
+## To get a full documentation on the format of these strings, please
+## refer to the ``git rev-list`` arguments. There are many examples.
+##
+## Using callables is especially useful, for instance, if you
+## are using gitchangelog to generate incrementally your changelog.
+##
+## Some helpers are provided, you can use them::
+##
+##   - FileFirstRegexMatch(file, pattern): will return a callable that will
+##     return the first string match for the given pattern in the given file.
+##     If you use named sub-patterns in your regex pattern, it'll output only
+##     the string matching the regex pattern named "rev".
+##
+##   - Caret(rev): will return the rev prefixed by a "^", which is a
+##     way to remove the given revision and all its ancestor.
+##
+## Please note that if you provide a rev-list on the command line, it'll
+## replace this value (which will then be ignored).
+##
+## If empty, then ``gitchangelog`` will act as it had to generate a full
+## changelog.
+##
+## The default is to use all commits to make the changelog.
+#revs = ["^1.0.3", ]
+#revs = [
+#    Caret(
+#        FileFirstRegexMatch(
+#            "CHANGELOG.rst",
+#            r"(?P<rev>[0-9]+\.[0-9]+(\.[0-9]+)?)\s+\([0-9]+-[0-9]{2}-[0-9]{2}\)\n--+\n")),
+#    "HEAD"
+#]
+revs = []
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 0000000..356dd2c
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,73 @@
+# This workflow will install Python dependencies, run tests and lint with a variety of Python versions
+# For more information see: https://help.github.com/actions/language-and-framework-guides/using-python-with-github-actions
+
+name: ci
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build:
+
+    runs-on: ${{ matrix.os }}
+    defaults:
+      run:
+        shell: bash
+    env:
+      OS: ${{ matrix.os }}
+      PYTHON: ${{ matrix.python-version }}
+      PYTHONIOENCODING: utf-8
+      PIP_DOWNLOAD_CACHE: ${{ github.workspace }}/../.pip_download_cache
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-20.04, macos-latest, windows-latest]
+        python-version: [3.6, 3.7, 3.8, 3.9]
+    steps:
+    - name: Set git crlf/eol
+      run: |
+        git config --global core.autocrlf false
+        git config --global core.eol lf
+
+    - uses: actions/checkout@v2
+      with:
+        submodules: True
+
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v2
+      with:
+        python-version: ${{ matrix.python-version }}
+
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install tox tox-gh-actions
+
+    - name: Run tests with coverage
+      run: |
+        tox
+      env:
+        PLATFORM: ${{ matrix.os }}
+
+    - name: Upload coverage to Codecov
+      uses: codecov/codecov-action@v1
+      with:
+        env_vars: OS,PYTHON
+
+    - name: Test with specs and pystache-test
+      run: |
+        tox -e setup . ext/spec/specs
+
+    - name: Check pkg builds
+      run: |
+        tox -e deploy
+
+    - name: Check docs
+      if: runner.os == 'Linux'
+      run: |
+        sudo apt-get -qq update
+        sudo apt-get install -y pandoc
+        tox -e docs
diff --git a/.github/workflows/conda.yml b/.github/workflows/conda.yml
new file mode 100644
index 0000000..261f9ad
--- /dev/null
+++ b/.github/workflows/conda.yml
@@ -0,0 +1,55 @@
+name: Conda
+
+on:
+  workflow_dispatch:
+  pull_request:
+  push:
+    branches:
+      - master
+
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        platform: [ubuntu-18.04, windows-latest, macos-latest]
+        python-version: [3.6, 3.7, 3.8, 3.9]
+
+    runs-on: ${{ matrix.platform }}
+
+    # The setup-miniconda action needs this to activate miniconda
+    defaults:
+      run:
+        shell: "bash -l {0}"
+
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+
+      - name: Cache conda
+        uses: actions/cache@v1
+        with:
+          path: ~/conda_pkgs_dir
+          key: ${{matrix.os}}-conda-pkgs-${{hashFiles('**/conda/meta.yaml')}}
+
+      - name: Get conda
+        uses: conda-incubator/setup-miniconda@v2
+        with:
+          python-version: ${{ matrix.python-version }}
+          channels: conda-forge
+          channel-priority: strict
+          use-only-tar-bz2: true
+          auto-activate-base: true
+
+      - name: Prepare
+        run: conda install conda-build conda-verify
+
+      - name: Build
+        run: conda build conda
+
+      - name: Install
+        run: conda install -c ${CONDA_PREFIX}/conda-bld/ pystache
+
+      - name: Test
+        run: python test_pystache.py
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
new file mode 100644
index 0000000..f33c4b5
--- /dev/null
+++ b/.github/workflows/release.yml
@@ -0,0 +1,94 @@
+name: Release
+
+on:
+  push:
+    # release on tag push
+    tags:
+      - '*'
+
+jobs:
+  wheels:
+
+    runs-on: ${{ matrix.os }}
+    defaults:
+      run:
+        shell: bash
+    env:
+      PYTHONIOENCODING: utf-8
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-18.04, macos-latest, windows-latest]
+        python-version: [3.6, 3.7, 3.8, 3.9]
+        exclude:
+          - os: windows-latest
+            python-version: 2.7
+
+    steps:
+    - name: Set git crlf/eol
+      run: |
+        git config --global core.autocrlf false
+        git config --global core.eol lf
+
+    - uses: actions/checkout@v2
+      with:
+        fetch-depth: 0
+
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v2
+      with:
+        python-version: ${{ matrix.python-version }}
+
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip wheel
+        pip install tox tox-gh-actions
+
+    - name: Build dist pkgs
+      run: |
+        tox -e deploy
+
+    - name: Upload artifacts
+      if: matrix.python-version == 3.7 && runner.os == 'Linux'
+      uses: actions/upload-artifact@v2
+      with:
+        name: wheels
+        path: ./dist/*.whl
+
+  create_release:
+    name: Create Release
+    needs: [wheels]
+    runs-on: ubuntu-18.04
+
+    steps:
+      - name: Get version
+        id: get_version
+        run: |
+          echo "VERSION=${GITHUB_REF/refs\/tags\//}" >> $GITHUB_ENV
+          echo ${{ env.VERSION }}
+
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+
+      # download all artifacts to project dir
+      - uses: actions/download-artifact@v2
+
+      - name: Generate changes file
+        uses: sarnold/gitchangelog-action@master
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN}}
+
+      - name: Create release
+        id: create_release
+        uses: softprops/action-gh-release@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          tag_name: ${{ env.VERSION }}
+          name: Release v${{ env.VERSION }}
+          body_path: CHANGES.md
+          draft: false
+          prerelease: false
+          files: |
+            wheels/pystache*.whl
diff --git a/.github/workflows/wheels.yml b/.github/workflows/wheels.yml
new file mode 100644
index 0000000..58f0c5e
--- /dev/null
+++ b/.github/workflows/wheels.yml
@@ -0,0 +1,82 @@
+name: Wheels
+
+on:
+  workflow_dispatch:
+  pull_request:
+  #push:
+    #branches: [ master ]
+
+jobs:
+  build:
+
+    runs-on: ${{ matrix.os }}
+    defaults:
+      run:
+        shell: bash
+    env:
+      PYTHONIOENCODING: utf-8
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-18.04, macos-latest, windows-latest]
+        python-version: [3.6, 3.7, 3.8, 3.9]
+
+    steps:
+      - name: Set git crlf/eol
+        run: |
+          git config --global core.autocrlf false
+          git config --global core.eol lf
+
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v2
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip wheel
+          pip install tox tox-gh-actions
+
+      - name: Build dist pkgs
+        run: |
+          tox -e deploy
+
+      - name: Upload artifacts
+        if: matrix.python-version == 3.7 && runner.os == 'Linux'
+        uses: actions/upload-artifact@v2
+        with:
+          name: wheels
+          path: ./dist/*.whl
+
+  check_artifact:
+    name: Check wheel artifact
+    needs: [build]
+    runs-on: ${{ matrix.os }}
+    defaults:
+      run:
+        shell: bash
+    env:
+      PYTHONIOENCODING: utf-8
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-18.04, macos-latest, windows-latest]
+        python-version: [3.6, 3.8, 3.9]
+
+    steps:
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v2
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      # download all artifacts to project dir
+      - uses: actions/download-artifact@v2
+
+      - name: Check wheel install
+        run: |
+          bash -c 'export WHL=$(ls wheels/*.whl); python -m pip install $WHL'
+          pystache-test
diff --git a/.pep8speaks.yml b/.pep8speaks.yml
new file mode 100644
index 0000000..e841b66
--- /dev/null
+++ b/.pep8speaks.yml
@@ -0,0 +1,15 @@
+scanner:
+    linter: flake8  # Other option is pycodestyle
+
+no_blank_comment: False  # If True, no comment is made on PR without any errors.
+descending_issues_order: True  # If True, PEP 8 issues in message will be displayed in descending order of line numbers in the file
+
+[flake8]
+exclude =
+    .git,
+    .github,
+    __pycache__,
+    build,
+    dist
+
+max-line-length = 110
diff --git a/HISTORY.md b/HISTORY.md
index e5b7638..60b6308 100644
--- a/HISTORY.md
+++ b/HISTORY.md
@@ -1,7 +1,42 @@
 History
 =======
 
-**Note:** Official support for Python 2.4 will end with Pystache version 0.6.0.
+**Note:** Official support for Python 2.7 will end with Pystache version 0.6.0.
+
+0.6.0 (2021-03-04)
+------------------
+
+-   Bump spec versions to latest => v1.1.3
+-   Modernize python and CI tools, update docs/doctests
+-   Update unicode conversion test for py3-only
+-   Add pep8speaks cfg, cleanup warnings
+-   Remove superfluous setup test/unused imports
+-   Add conda recipe/CI build
+
+0.5.6 (2021-02-28)
+------------------
+
+-   Use correct wheel name in release workflow, limit wheels
+-   Add install check/test of downloaded wheel
+-   Update/add ci workflows and tox cfg, bump to next dev0 version
+
+0.5.5 (2020-12-16)
+------------------
+
+-   fix document processing, update pandoc args and history
+-   add release.yml to CI, test env settings
+-   fix bogus commit message, update versions and tox cf
+-   add post-test steps for building pkgs with/without doc updates
+-   add CI build check, fix MANIFEST.in pruning
+
+0.5.4-2 (2020-11-09)
+--------------------
+
+-   Merge pull request #1 from sarnold/rebase-up
+-   Bugfix: test_specloader.py: fix test_find__with_directory on other OSs
+-   Bugfix: pystache/loader.py: remove stray windows line-endings
+-   fix crufty (and insecure) http urls
+-   Bugfix: modernize python versions (keep py27) and fix spec_test load cmd
 
 0.5.4 (2014-07-11)
 ------------------
diff --git a/MANIFEST.in b/MANIFEST.in
index bdc64bf..1593143 100644
--- a/MANIFEST.in
+++ b/MANIFEST.in
@@ -1,7 +1,4 @@
-include README.md
-include HISTORY.md
-include LICENSE
-include TODO.md
+include README.md HISTORY.md TODO.md LICENSE
 include setup_description.rst
 include tox.ini
 include test_pystache.py
@@ -11,3 +8,6 @@ recursive-include pystache/tests *.mustache *.txt
 # We deliberately exclude the gh/ directory because it contains copies
 # of resources needed only for the web page hosted on GitHub (via the
 # gh-pages branch).
+exclude *.ini *travis*
+prune gh
+prune .git*
diff --git a/README.md b/README.md
index 54a9608..1203b7a 100644
--- a/README.md
+++ b/README.md
@@ -10,11 +10,25 @@ Pystache
 <!-- -->
 <!-- We leave the leading brackets empty here.  Otherwise, unwanted -->
 <!-- caption text shows up in the reST version converted by pandoc. -->
-![](http://defunkt.github.com/pystache/images/logo_phillips.png "mustachioed, monocled snake by David Phillips")
+[![ci](https://github.com/sarnold/pystache/actions/workflows/ci.yml/badge.svg)](https://github.com/sarnold/pystache/actions/workflows/ci.yml)
+[![Conda](https://github.com/sarnold/pystache/actions/workflows/conda.yml/badge.svg)](https://github.com/sarnold/pystache/actions/workflows/conda.yml)
+[![Wheels](https://github.com/sarnold/pystache/actions/workflows/wheels.yml/badge.svg)](https://github.com/sarnold/pystache/actions/workflows/wheels.yml)
+[![Release](https://github.com/sarnold/pystache/actions/workflows/release.yml/badge.svg)](https://github.com/sarnold/pystache/actions/workflows/release.yml)
+[![Python](https://img.shields.io/badge/python-3.6+-blue.svg)](https://www.python.org/downloads/)
 
-![](https://secure.travis-ci.org/defunkt/pystache.png "Travis CI current build status")
+[![Latest release](https://img.shields.io/github/v/release/sarnold/pystache?include_prereleases)](https://github.com/sarnold/pystache/releases/latest)
+[![License](https://img.shields.io/github/license/sarnold/pystache)](https://github.com/sarnold/pystache/blob/master/LICENSE)
+[![Maintainability](https://api.codeclimate.com/v1/badges/a8fa1bf4638bfc6581b6/maintainability)](https://codeclimate.com/github/sarnold/pystache/maintainability)
+[![codecov](https://codecov.io/gh/sarnold/pystache/branch/master/graph/badge.svg?token=5PZNMZBI6K)](https://codecov.io/gh/sarnold/pystache)
 
-[Pystache](http://defunkt.github.com/pystache) is a Python
+
+
+This updated fork of Pystache is currently tested on Python 3.6+ and in
+Conda, on Linux, Macos, and Windows (Python 2.7 support has been removed).
+
+![](gh/images/logo_phillips_small.png "mustachioed, monocled snake by David Phillips")
+
+[Pystache](http://sarnold.github.com/pystache) is a Python
 implementation of [Mustache](http://mustache.github.com/). Mustache is a
 framework-agnostic, logic-free templating system inspired by
 [ctemplate](http://code.google.com/p/google-ctemplate/) and
@@ -27,10 +41,10 @@ provides a good introduction to Mustache's syntax. For a more complete
 (and more current) description of Mustache's behavior, see the official
 [Mustache spec](https://github.com/mustache/spec).
 
-Pystache is [semantically versioned](http://semver.org) and can be found
-on [PyPI](http://pypi.python.org/pypi/pystache). This version of
-Pystache passes all tests in [version
-1.1.2](https://github.com/mustache/spec/tree/v1.1.2) of the spec.
+Pystache is [semantically versioned](http://semver.org) and older versions
+can still be found on [PyPI](http://pypi.python.org/pypi/pystache). This
+version of Pystache now passes all tests in [version
+1.1.3](https://github.com/mustache/spec/tree/v1.1.3) of the spec.
 
 
 Requirements
@@ -38,41 +52,25 @@ Requirements
 
 Pystache is tested with--
 
--   Python 2.4 (requires simplejson [version
-    2.0.9](http://pypi.python.org/pypi/simplejson/2.0.9) or earlier)
--   Python 2.5 (requires
-    [simplejson](http://pypi.python.org/pypi/simplejson/))
--   Python 2.6
--   Python 2.7
--   Python 3.1
--   Python 3.2
--   Python 3.3
--   [PyPy](http://pypy.org/)
+-   Python 3.6
+-   Python 3.7
+-   Python 3.8
+-   Python 3.9
+-   Conda (py36-py39)
 
 [Distribute](http://packages.python.org/distribute/) (the setuptools fork)
-is recommended over [setuptools](http://pypi.python.org/pypi/setuptools),
-and is required in some cases (e.g. for Python 3 support).
-If you use [pip](http://www.pip-installer.org/), you probably already satisfy
-this requirement.
+is no longer required over [setuptools](http://pypi.python.org/pypi/setuptools),
+as the current packaging is now PEP517-compliant.
 
 JSON support is needed only for the command-line interface and to run
-the spec tests. We require simplejson for earlier versions of Python
-since Python's [json](http://docs.python.org/library/json.html) module
-was added in Python 2.6.
-
-For Python 2.4 we require an earlier version of simplejson since
-simplejson stopped officially supporting Python 2.4 in simplejson
-version 2.1.0. Earlier versions of simplejson can be installed manually,
-as follows:
+the spec tests; PyYAML can still be used (see the Develop section).
 
-    pip install 'simplejson<2.1.0'
-
-Official support for Python 2.4 will end with Pystache version 0.6.0.
+Official support for Python 2 will end with Pystache version 0.6.0.
 
 Install It
 ----------
 
-    pip install pystache
+    pip install -U pystache -f https://github.com/sarnold/pystache/releases/
 
 And test it--
 
@@ -85,12 +83,12 @@ Use It
 ------
 
     >>> import pystache
-    >>> print pystache.render('Hi {{person}}!', {'person': 'Mom'})
+    >>> print(pystache.render('Hi {{person}}!', {'person': 'Mom'}))
     Hi Mom!
 
 You can also create dedicated view classes to hold your view logic.
 
-Here's your view class (in .../examples/readme.py):
+Here's your view class (in ../pystache/tests/examples/readme.py):
 
     class SayHello(object):
         def to(self):
@@ -109,7 +107,7 @@ directory as your class definition):
 Pull it together:
 
     >>> renderer = pystache.Renderer()
-    >>> print renderer.render(hello)
+    >>> print(renderer.render(hello))
     Hello, Pizza!
 
 For greater control over rendering (e.g. to specify a custom template
@@ -117,22 +115,22 @@ directory), use the `Renderer` class like above. One can pass attributes
 to the Renderer class constructor or set them on a Renderer instance. To
 customize template loading on a per-view basis, subclass `TemplateSpec`.
 See the docstrings of the
-[Renderer](https://github.com/defunkt/pystache/blob/master/pystache/renderer.py)
+[Renderer](https://github.com/sarnold/pystache/blob/master/pystache/renderer.py)
 class and
-[TemplateSpec](https://github.com/defunkt/pystache/blob/master/pystache/template_spec.py)
+[TemplateSpec](https://github.com/sarnold/pystache/blob/master/pystache/template_spec.py)
 class for more information.
 
 You can also pre-parse a template:
 
     >>> parsed = pystache.parse(u"Hey {{#who}}{{.}}!{{/who}}")
-    >>> print parsed
-    [u'Hey ', _SectionNode(key=u'who', index_begin=12, index_end=18, parsed=[_EscapeNode(key=u'.'), u'!'])]
+    >>> print(parsed)
+    ['Hey ', _SectionNode(key='who', index_begin=12, index_end=18, parsed=[_EscapeNode(key='.'), '!'])]
 
 And then:
 
-    >>> print renderer.render(parsed, {'who': 'Pops'})
+    >>> print(renderer.render(parsed, {'who': 'Pops'}))
     Hey Pops!
-    >>> print renderer.render(parsed, {'who': 'you'})
+    >>> print(renderer.render(parsed, {'who': 'you'}))
     Hey you!
 
 Python 3
@@ -194,15 +192,16 @@ To test from a source distribution (without installing)--
     python test_pystache.py
 
 To test Pystache with multiple versions of Python (with a single
-command!), you can use [tox](http://pypi.python.org/pypi/tox):
+command!) and different platforms, you can use [tox](http://pypi.python.org/pypi/tox):
+
+    pip install tox
+    tox -e setup
 
-    pip install 'virtualenv<1.8'  # Version 1.8 dropped support for Python 2.4.
-    pip install 'tox<1.4'  # Version 1.4 dropped support for Python 2.4.
-    tox
+To run tests on multiple versions with coverage, run:
 
-If you do not have all Python versions listed in `tox.ini`--
+    tox -e py38-linux,py39-linux  # for example
 
-    tox -e py26,py32  # for example
+(substitute your platform above, eg, macos or windows)
 
 The source distribution tests also include doctests and tests from the
 Mustache spec. To include tests from the Mustache spec in your test
@@ -217,57 +216,33 @@ parses the json files. To install PyYAML--
 
     pip install pyyaml
 
+Once the submodule is available, you can run the full test set with:
+
+    tox -e setup . ext/spec/specs
+
 To run a subset of the tests, you can use
 [nose](http://somethingaboutorange.com/mrl/projects/nose/0.11.1/testing.html):
 
     pip install nose
     nosetests --tests pystache/tests/test_context.py:GetValueTests.test_dictionary__key_present
 
-### Using Python 3 with Pystache from source
-
-Pystache is written in Python 2 and must be converted to Python 3 prior to
-using it with Python 3.  The installation process (and tox) do this
-automatically.
 
-To convert the code to Python 3 manually (while using Python 3)--
+Mailing List (old)
+------------------
 
-    python setup.py build
-
-This writes the converted code to a subdirectory called `build`.
-By design, Python 3 builds
-[cannot](https://bitbucket.org/tarek/distribute/issue/292/allow-use_2to3-with-python-2)
-be created from Python 2.
-
-To convert the code without using setup.py, you can use
-[2to3](http://docs.python.org/library/2to3.html) as follows (two steps)--
-
-    2to3 --write --nobackups --no-diffs --doctests_only pystache
-    2to3 --write --nobackups --no-diffs pystache
-
-This converts the code (and doctests) in place.
-
-To `import pystache` from a source distribution while using Python 3, be
-sure that you are importing from a directory containing a converted
-version of the code (e.g. from the `build` directory after converting),
-and not from the original (unconverted) source directory.  Otherwise, you will
-get a syntax error.  You can help prevent this by not running the Python
-IDE from the project directory when importing Pystache while using Python 3.
-
-
-Mailing List
-------------
-
-There is a [mailing list](http://librelist.com/browser/pystache/). Note
+There is(was) a [mailing list](http://librelist.com/browser/pystache/). Note
 that there is a bit of a delay between posting a message and seeing it
 appear in the mailing list archive.
 
 Credits
 -------
 
-    >>> context = { 'author': 'Chris Wanstrath', 'maintainer': 'Chris Jerdonek' }
-    >>> print pystache.render("Author: {{author}}\nMaintainer: {{maintainer}}", context)
+    >>> import pystache
+    >>> context = { 'author': 'Chris Wanstrath', 'maintainer': 'Chris Jerdonek','refurbisher': 'Steve Arnold' }
+    >>> print(pystache.render("Author: {{author}}\nMaintainer: {{maintainer}}\nRefurbisher: {{refurbisher}}", context))
     Author: Chris Wanstrath
     Maintainer: Chris Jerdonek
+    Refurbisher: Steve Arnold
 
 Pystache logo by [David Phillips](http://davidphillips.us/) is licensed
 under a [Creative Commons Attribution-ShareAlike 3.0 Unported
diff --git a/TODO.md b/TODO.md
index cd82417..76853a4 100644
--- a/TODO.md
+++ b/TODO.md
@@ -6,11 +6,10 @@ In development branch:
 * Figure out a way to suppress center alignment of images in reST output.
 * Add a unit test for the change made in 7ea8e7180c41.  This is with regard
   to not requiring spec tests when running tests from a downloaded sdist.
-* End support for Python 2.4.
-* Add Python 3.3 to tox file (after deprecating 2.4).
+* End support for Python 2.7 (done as of 03/03/21 - SA)
+* Release 0.6.0 on github, make a pypi account (SA)
 * Turn the benchmarking script at pystache/tests/benchmark.py into a command
   in pystache/commands, or make it a subcommand of one of the existing
   commands (i.e. using a command argument).
 * Provide support for logging in at least one of the commands.
-* Make sure command parsing to pystache-test doesn't break with Python 2.4 and earlier.
 * Combine pystache-test with the main command.
diff --git a/conda/meta.yaml b/conda/meta.yaml
new file mode 100644
index 0000000..e7f4fd9
--- /dev/null
+++ b/conda/meta.yaml
@@ -0,0 +1,50 @@
+{% set name = "pystache" %}
+{% set version = "0.6.0.dev0" %}
+
+package:
+  name: {{ name|lower }}
+  version: {{ version }}
+
+source:
+  path: ..
+
+build:
+  number: 0
+  script: {{ PYTHON }} -m pip install . --no-deps --ignore-installed -vvv
+  noarch: python
+  entry_points:
+    - pystache = pystache.commands.render:main
+    - pystache-test = pystache.commands.test:main
+
+requirements:
+  build:
+    - python
+    - setuptools
+
+  run:
+    - python
+
+test:
+  imports:
+    - pystache
+    - pystache.commands
+    - pystache.tests
+    - pystache.tests.data
+    - pystache.tests.data.locator
+    - pystache.tests.examples
+
+  commands:
+    - pystache --help
+    - pystache-test
+
+
+about:
+  home: https://github.com/sarnold/pystache
+  license: MIT
+  license_family: MIT
+  license_file: LICENSE
+  summary: Mustache for Python
+
+extra:
+  recipe-maintainers:
+    - sarnold
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 0000000..2f21011
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=40.8.0", "wheel"]
+build-backend = "setuptools.build_meta"
diff --git a/pystache/__init__.py b/pystache/__init__.py
index 4cf2434..5edc1c5 100644
--- a/pystache/__init__.py
+++ b/pystache/__init__.py
@@ -10,4 +10,4 @@ from pystache.init import parse, render, Renderer, TemplateSpec
 
 __all__ = ['parse', 'render', 'Renderer', 'TemplateSpec']
 
-__version__ = '0.5.4'  # Also change in setup.py.
+__version__ = '0.6.0'
diff --git a/pystache/commands/render.py b/pystache/commands/render.py
index 1a9c309..9c913e7 100644
--- a/pystache/commands/render.py
+++ b/pystache/commands/render.py
@@ -22,7 +22,7 @@ except:
         from sys import exc_info
         ex_type, ex_value, tb = exc_info()
         new_ex = Exception("%s: %s" % (ex_type.__name__, ex_value))
-        raise new_ex.__class__, new_ex, tb
+        raise new_ex.__class__(new_ex).with_traceback(tb)
 
 # The optparse module is deprecated in Python 2.7 in favor of argparse.
 # However, argparse is not available in Python 2.6 and earlier.
@@ -88,7 +88,7 @@ def main(sys_argv=sys.argv):
         context = json.loads(context)
 
     rendered = renderer.render(template, context)
-    print rendered
+    print(rendered)
 
 
 if __name__=='__main__':
diff --git a/pystache/common.py b/pystache/common.py
index fb266dd..0e9b091 100644
--- a/pystache/common.py
+++ b/pystache/common.py
@@ -5,17 +5,12 @@ Exposes functionality needed throughout the project.
 
 """
 
-from sys import version_info
 
 def _get_string_types():
-    # TODO: come up with a better solution for this.  One of the issues here
-    #   is that in Python 3 there is no common base class for unicode strings
-    #   and byte strings, and 2to3 seems to convert all of "str", "unicode",
-    #   and "basestring" to Python 3's "str".
-    if version_info < (3, ):
-         return basestring
-    # The latter evaluates to "bytes" in Python 3 -- even after conversion by 2to3.
-    return (unicode, type(u"a".encode('utf-8')))
+    """
+    Return the Python3 string type (no more python2)
+    """
+    return (str, type("a".encode('utf-8')))
 
 
 _STRING_TYPES = _get_string_types()
diff --git a/pystache/defaults.py b/pystache/defaults.py
index bcfdf4c..2fab0e0 100644
--- a/pystache/defaults.py
+++ b/pystache/defaults.py
@@ -39,7 +39,7 @@ STRING_ENCODING = sys.getdefaultencoding()
 FILE_ENCODING = sys.getdefaultencoding()
 
 # The delimiters to start with when parsing.
-DELIMITERS = (u'{{', u'}}')
+DELIMITERS = ('{{', '}}')
 
 # How to handle missing tags when rendering a template.
 MISSING_TAGS = MissingTags.ignore
diff --git a/pystache/loader.py b/pystache/loader.py
index d4a7e53..ea01d17 100644
--- a/pystache/loader.py
+++ b/pystache/loader.py
@@ -6,6 +6,7 @@ This module provides a Loader class for locating and reading templates.
 """
 
 import os
+import platform
 import sys
 
 from pystache import common
@@ -24,7 +25,7 @@ def _make_to_unicode():
         """
         if encoding is None:
             encoding = defaults.STRING_ENCODING
-        return unicode(s, encoding, defaults.DECODE_ERRORS)
+        return str(s, encoding, defaults.DECODE_ERRORS)
     return to_unicode
 
 
@@ -86,7 +87,7 @@ class Loader(object):
     def _make_locator(self):
         return Locator(extension=self.extension)
 
-    def unicode(self, s, encoding=None):
+    def str(self, s, encoding=None):
         """
         Convert a string to unicode using the given encoding, and return it.
 
@@ -104,8 +105,8 @@ class Loader(object):
             Defaults to None.
 
         """
-        if isinstance(s, unicode):
-            return unicode(s)
+        if isinstance(s, str):
+            return str(s)
 
         return self.to_unicode(s, encoding)
 
@@ -118,8 +119,9 @@ class Loader(object):
 
         if encoding is None:
             encoding = self.file_encoding
-
-        return self.unicode(b, encoding)
+        if platform.system() == "Windows":
+            return self.str(b, encoding).replace('\r', '')
+        return self.str(b, encoding)
 
     def load_file(self, file_name):
         """
diff --git a/pystache/parsed.py b/pystache/parsed.py
index 372d96c..75d417d 100644
--- a/pystache/parsed.py
+++ b/pystache/parsed.py
@@ -41,10 +41,10 @@ class ParsedTemplate(object):
         """
         # We avoid use of the ternary operator for Python 2.4 support.
         def get_unicode(node):
-            if type(node) is unicode:
+            if type(node) is str:
                 return node
             return node.render(engine, context)
-        parts = map(get_unicode, self._parse_tree)
+        parts = list(map(get_unicode, self._parse_tree))
         s = ''.join(parts)
 
-        return unicode(s)
+        return str(s)
diff --git a/pystache/parser.py b/pystache/parser.py
index c6a171f..1afd50a 100644
--- a/pystache/parser.py
+++ b/pystache/parser.py
@@ -11,8 +11,8 @@ from pystache import defaults
 from pystache.parsed import ParsedTemplate
 
 
-END_OF_LINE_CHARACTERS = [u'\r', u'\n']
-NON_BLANK_RE = re.compile(ur'^(.)', re.M)
+END_OF_LINE_CHARACTERS = ['\r', '\n']
+NON_BLANK_RE = re.compile(r'^(.)', re.M)
 
 
 # TODO: add some unit tests for this.
@@ -30,12 +30,12 @@ def parse(template, delimiters=None):
 
     Examples:
 
-    >>> parsed = parse(u"Hey {{#who}}{{name}}!{{/who}}")
-    >>> print str(parsed).replace('u', '')  # This is a hack to get the test to pass both in Python 2 and 3.
+    >>> parsed = parse("Hey {{#who}}{{name}}!{{/who}}")
+    >>> print(str(parsed).replace('u', ''))  # This is an old hack.
     ['Hey ', _SectionNode(key='who', index_begin=12, index_end=21, parsed=[_EscapeNode(key='name'), '!'])]
 
     """
-    if type(template) is not unicode:
+    if type(template) is not str:
         raise Exception("Template is not unicode: %s" % type(template))
     parser = _Parser(delimiters)
     return parser.parse(template)
@@ -94,7 +94,7 @@ class _CommentNode(object):
         return _format(self)
 
     def render(self, engine, context):
-        return u''
+        return ''
 
 
 class _ChangeNode(object):
@@ -106,7 +106,7 @@ class _ChangeNode(object):
         return _format(self)
 
     def render(self, engine, context):
-        return u''
+        return ''
 
 
 class _EscapeNode(object):
@@ -147,7 +147,7 @@ class _PartialNode(object):
     def render(self, engine, context):
         template = engine.resolve_partial(self.key)
         # Indent before rendering.
-        template = re.sub(NON_BLANK_RE, self.indent + ur'\1', template)
+        template = re.sub(NON_BLANK_RE, self.indent + r'\1', template)
 
         return engine.render(template, context)
 
@@ -168,7 +168,7 @@ class _InvertedNode(object):
         # Note that lambdas are considered truthy for inverted sections
         # per the spec.
         if data:
-            return u''
+            return ''
         return self.parsed_section.render(engine, context)
 
 
@@ -218,7 +218,7 @@ class _SectionNode(object):
             parts.append(self.parsed.render(engine, context))
             context.pop()
 
-        return unicode(''.join(parts))
+        return str(''.join(parts))
 
 
 class _Parser(object):
diff --git a/pystache/renderengine.py b/pystache/renderengine.py
index c797b17..2f1e341 100644
--- a/pystache/renderengine.py
+++ b/pystache/renderengine.py
@@ -160,7 +160,7 @@ class RenderEngine(object):
         if not is_string(val):
             # In case the template is an integer, for example.
             val = self.to_str(val)
-        if type(val) is not unicode:
+        if type(val) is not str:
             val = self.literal(val)
         return self.render(val, context, delimiters)
 
diff --git a/pystache/renderer.py b/pystache/renderer.py
index ff6a90c..064f040 100644
--- a/pystache/renderer.py
+++ b/pystache/renderer.py
@@ -32,7 +32,7 @@ class Renderer(object):
     >>> partials = {'partial': 'Hello, {{thing}}!'}
     >>> renderer = Renderer(partials=partials)
     >>> # We apply print to make the test work in Python 3 after 2to3.
-    >>> print renderer.render('{{>partial}}', {'thing': 'world'})
+    >>> print(renderer.render('{{>partial}}', {'thing': 'world'}))
     Hello, world!
 
     To customize string coercion (e.g. to render False values as ''), one can
@@ -130,7 +130,7 @@ class Renderer(object):
         if string_encoding is None:
             string_encoding = defaults.STRING_ENCODING
 
-        if isinstance(search_dirs, basestring):
+        if isinstance(search_dirs, str):
             search_dirs = [search_dirs]
 
         self._context = None
@@ -177,16 +177,16 @@ class Renderer(object):
         """
         # We type-check to avoid "TypeError: decoding Unicode is not supported".
         # We avoid the Python ternary operator for Python 2.4 support.
-        if isinstance(s, unicode):
+        if isinstance(s, str):
             return s
-        return self.unicode(s)
+        return self.str(s)
 
     def _to_unicode_hard(self, s):
         """
         Convert a basestring to a string with type unicode (not subclass).
 
         """
-        return unicode(self._to_unicode_soft(s))
+        return str(self._to_unicode_soft(s))
 
     def _escape_to_unicode(self, s):
         """
@@ -195,9 +195,9 @@ class Renderer(object):
         Returns a unicode string (not subclass).
 
         """
-        return unicode(self.escape(self._to_unicode_soft(s)))
+        return str(self.escape(self._to_unicode_soft(s)))
 
-    def unicode(self, b, encoding=None):
+    def str(self, b, encoding=None):
         """
         Convert a byte string to unicode, using string_encoding and decode_errors.
 
@@ -222,7 +222,7 @@ class Renderer(object):
 
         # TODO: Wrap UnicodeDecodeErrors with a message about setting
         # the string_encoding and decode_errors attributes.
-        return unicode(b, encoding, self.decode_errors)
+        return str(b, encoding, self.decode_errors)
 
     def _make_loader(self):
         """
@@ -230,7 +230,7 @@ class Renderer(object):
 
         """
         return Loader(file_encoding=self.file_encoding, extension=self.file_extension,
-                      to_unicode=self.unicode, search_dirs=self.search_dirs)
+                      to_unicode=self.str, search_dirs=self.search_dirs)
 
     def _make_load_template(self):
         """
@@ -299,7 +299,7 @@ class Renderer(object):
             try:
                 return load_partial(name)
             except TemplateNotFoundError:
-                return u''
+                return ''
 
         return resolve_partial
 
@@ -316,7 +316,7 @@ class Renderer(object):
             try:
                 return context_get(stack, name)
             except KeyNotFoundError:
-                return u''
+                return ''
 
         return resolve_context
 
diff --git a/pystache/specloader.py b/pystache/specloader.py
index 3a77d4c..a82d52a 100644
--- a/pystache/specloader.py
+++ b/pystache/specloader.py
@@ -83,7 +83,7 @@ class SpecLoader(object):
 
         """
         if spec.template is not None:
-            return self.loader.unicode(spec.template, spec.template_encoding)
+            return self.loader.str(spec.template, spec.template_encoding)
 
         path = self._find(spec)
 
diff --git a/pystache/tests/benchmark.py b/pystache/tests/benchmark.py
index d46e973..6cb54f8 100755
--- a/pystache/tests/benchmark.py
+++ b/pystache/tests/benchmark.py
@@ -13,6 +13,13 @@ tests/benchmark.py 10000
 import sys
 from timeit import Timer
 
+try:
+    import chevron as pystache
+    print('Using module: chevron')
+except (ImportError):
+    import pystache
+    print('Using module: pystache')
+
 import pystache
 
 # TODO: make the example realistic.
@@ -76,17 +83,17 @@ def main(sys_argv):
     args = sys_argv[1:]
     count = int(args[0])
 
-    print "Benchmarking: %sx" % count
-    print
+    print("Benchmarking: %sx" % count)
+    print()
 
     for example in examples:
 
         test = make_test_function(example)
 
         t = Timer(test,)
-        print min(t.repeat(repeat=3, number=count))
+        print(min(t.repeat(repeat=3, number=count)))
 
-    print "Done"
+    print("Done")
 
 
 if __name__ == '__main__':
diff --git a/pystache/tests/common.py b/pystache/tests/common.py
index 222e14f..12b76b5 100644
--- a/pystache/tests/common.py
+++ b/pystache/tests/common.py
@@ -72,8 +72,8 @@ def _find_files(root_dir, should_include):
     #   http://docs.python.org/library/os.html#os.walk
     for dir_path, dir_names, file_names in os.walk(root_dir):
         new_paths = [os.path.join(dir_path, file_name) for file_name in file_names]
-        new_paths = filter(is_module, new_paths)
-        new_paths = filter(should_include, new_paths)
+        new_paths = list(filter(is_module, new_paths))
+        new_paths = list(filter(should_include, new_paths))
         paths.extend(new_paths)
 
     return paths
@@ -183,7 +183,7 @@ class AssertExceptionMixin:
         try:
             callable(*args, **kwds)
             raise Exception("Expected exception: %s: %s" % (exception_type, repr(msg)))
-        except exception_type, err:
+        except exception_type as err:
             self.assertEqual(str(err), msg)
 
 
@@ -228,10 +228,10 @@ class Attachable(object):
     """
     def __init__(self, **kwargs):
         self.__args__ = kwargs
-        for arg, value in kwargs.iteritems():
+        for arg, value in kwargs.items():
             setattr(self, arg, value)
 
     def __repr__(self):
         return "%s(%s)" % (self.__class__.__name__,
                            ", ".join("%s=%s" % (k, repr(v))
-                                     for k, v in self.__args__.iteritems()))
+                                     for k, v in self.__args__.items()))
diff --git a/pystache/tests/examples/unicode_output.py b/pystache/tests/examples/unicode_output.py
index da0e1d2..7bdea36 100644
--- a/pystache/tests/examples/unicode_output.py
+++ b/pystache/tests/examples/unicode_output.py
@@ -8,4 +8,4 @@ TODO: add a docstring.
 class UnicodeOutput(object):
 
     def name(self):
-        return u'Henri Poincaré'
+        return 'Henri Poincaré'
diff --git a/pystache/tests/main.py b/pystache/tests/main.py
index 8af6b2e..17f2fb2 100644
--- a/pystache/tests/main.py
+++ b/pystache/tests/main.py
@@ -88,7 +88,7 @@ def main(sys_argv):
 
     """
     # TODO: use logging module
-    print "pystache: running tests: argv: %s" % repr(sys_argv)
+    print("pystache: running tests: argv: %s" % repr(sys_argv))
 
     should_source_exist = False
     spec_test_dir = None
@@ -131,11 +131,9 @@ def main(sys_argv):
         module_names = _discover_test_modules(PACKAGE_DIR)
         sys_argv.extend(module_names)
         if project_dir is not None:
-            # Add the current module for unit tests contained here (e.g.
-            # to include SetupTests).
+            # Add the current module for unit tests contained here
             sys_argv.append(__name__)
 
-    SetupTests.project_dir = project_dir
 
     extra_tests = make_extra_tests(project_dir, spec_test_dir)
     test_program_class = make_test_program_class(extra_tests)
@@ -166,25 +164,3 @@ def _discover_test_modules(package_dir):
         raise Exception("No unit-test modules found--\n  in %s" % package_dir)
 
     return names
-
-
-class SetupTests(TestCase):
-
-    """Tests about setup.py."""
-
-    project_dir = None
-
-    def test_version(self):
-        """
-        Test that setup.py's version matches the package's version.
-
-        """
-        original_path = list(sys.path)
-
-        sys.path.insert(0, self.project_dir)
-
-        try:
-            from setup import VERSION
-            self.assertEqual(VERSION, pystache.__version__)
-        finally:
-            sys.path = original_path
diff --git a/pystache/tests/spectesting.py b/pystache/tests/spectesting.py
index ec8a08d..2dd57e8 100644
--- a/pystache/tests/spectesting.py
+++ b/pystache/tests/spectesting.py
@@ -37,7 +37,7 @@ except ImportError:
             from sys import exc_info
             ex_type, ex_value, tb = exc_info()
             new_ex = Exception("%s: %s" % (ex_type.__name__, ex_value))
-            raise new_ex.__class__, new_ex, tb
+            raise new_ex.__class__(new_ex).with_traceback(tb)
     file_extension = 'json'
     parser = json
 else:
@@ -62,7 +62,7 @@ def get_spec_tests(spec_test_dir):
 
     """
     # TODO: use logging module instead.
-    print "pystache: spec tests: using %s" % _get_parser_info()
+    print("pystache: spec tests: using %s" % _get_parser_info())
 
     cases = []
 
@@ -103,7 +103,7 @@ def _read_spec_tests(path):
 
     """
     b = common.read(path)
-    u = unicode(b, encoding=FILE_ENCODING)
+    u = str(b, encoding=FILE_ENCODING)
     spec_data = parse(u)
     tests = spec_data['tests']
 
@@ -133,7 +133,7 @@ def _convert_children(node):
         return
     # Otherwise, node is a dict, so attempt the conversion.
 
-    for key in node.keys():
+    for key in list(node.keys()):
         val = node[key]
 
         if not isinstance(val, dict) or val.get('__tag__') != 'code':
@@ -158,9 +158,9 @@ def _deserialize_spec_test(data, file_path):
     context = data['data']
     description = data['desc']
     # PyYAML seems to leave ASCII strings as byte strings.
-    expected = unicode(data['expected'])
+    expected = str(data['expected'])
     # TODO: switch to using dict.get().
-    partials = data.has_key('partials') and data['partials'] or {}
+    partials = 'partials' in data and data['partials'] or {}
     template = data['template']
     test_name = data['name']
 
@@ -237,8 +237,8 @@ def parse(u):
         value = loader.construct_mapping(node)
         return eval(value['python'], {})
 
-    yaml.add_constructor(u'!code', code_constructor)
-    return yaml.load(u)
+    yaml.add_constructor('!code', code_constructor)
+    return yaml.full_load(u)
 
 
 class SpecTestBase(unittest.TestCase, AssertStringMixin):
diff --git a/pystache/tests/test___init__.py b/pystache/tests/test___init__.py
index eae42c1..63d2c3b 100644
--- a/pystache/tests/test___init__.py
+++ b/pystache/tests/test___init__.py
@@ -6,9 +6,9 @@ Tests of __init__.py.
 """
 
 # Calling "import *" is allowed only at the module level.
-GLOBALS_INITIAL = globals().keys()
+GLOBALS_INITIAL = list(globals().keys())
 from pystache import *
-GLOBALS_PYSTACHE_IMPORTED = globals().keys()
+GLOBALS_PYSTACHE_IMPORTED = list(globals().keys())
 
 import unittest
 
diff --git a/pystache/tests/test_commands.py b/pystache/tests/test_commands.py
index 2529d25..34fe8ba 100644
--- a/pystache/tests/test_commands.py
+++ b/pystache/tests/test_commands.py
@@ -39,7 +39,7 @@ class CommandsTestCase(unittest.TestCase):
 
         """
         actual = self.callScript("Hi {{thing}}", '{"thing": "world"}')
-        self.assertEqual(actual, u"Hi world\n")
+        self.assertEqual(actual, "Hi world\n")
 
     def tearDown(self):
         sys.stdout = ORIGINAL_STDOUT
diff --git a/pystache/tests/test_defaults.py b/pystache/tests/test_defaults.py
index c78ea7c..5399bb0 100644
--- a/pystache/tests/test_defaults.py
+++ b/pystache/tests/test_defaults.py
@@ -31,37 +31,37 @@ class DefaultsConfigurableTestCase(unittest.TestCase, AssertStringMixin):
             self.saved[e] = getattr(pystache.defaults, e)
 
     def tearDown(self):
-        for key, value in self.saved.items():
+        for key, value in list(self.saved.items()):
             setattr(pystache.defaults, key, value)
 
     def test_tag_escape(self):
         """Test that changes to defaults.TAG_ESCAPE take effect."""
-        template = u"{{foo}}"
+        template = "{{foo}}"
         context = {'foo': '<'}
         actual = pystache.render(template, context)
-        self.assertString(actual, u"&lt;")
+        self.assertString(actual, "&lt;")
 
         pystache.defaults.TAG_ESCAPE = lambda u: u
         actual = pystache.render(template, context)
-        self.assertString(actual, u"<")
+        self.assertString(actual, "<")
 
     def test_delimiters(self):
         """Test that changes to defaults.DELIMITERS take effect."""
-        template = u"[[foo]]{{foo}}"
+        template = "[[foo]]{{foo}}"
         context = {'foo': 'FOO'}
         actual = pystache.render(template, context)
-        self.assertString(actual, u"[[foo]]FOO")
+        self.assertString(actual, "[[foo]]FOO")
 
         pystache.defaults.DELIMITERS = ('[[', ']]')
         actual = pystache.render(template, context)
-        self.assertString(actual, u"FOO{{foo}}")
+        self.assertString(actual, "FOO{{foo}}")
 
     def test_missing_tags(self):
         """Test that changes to defaults.MISSING_TAGS take effect."""
-        template = u"{{foo}}"
+        template = "{{foo}}"
         context = {}
         actual = pystache.render(template, context)
-        self.assertString(actual, u"")
+        self.assertString(actual, "")
 
         pystache.defaults.MISSING_TAGS = 'strict'
         self.assertRaises(pystache.context.KeyNotFoundError,
diff --git a/pystache/tests/test_examples.py b/pystache/tests/test_examples.py
index 5c9f74d..9f93de3 100644
--- a/pystache/tests/test_examples.py
+++ b/pystache/tests/test_examples.py
@@ -7,15 +7,15 @@ TODO: add a docstring.
 
 import unittest
 
-from examples.comments import Comments
-from examples.double_section import DoubleSection
-from examples.escaped import Escaped
-from examples.unescaped import Unescaped
-from examples.template_partial import TemplatePartial
-from examples.delimiters import Delimiters
-from examples.unicode_output import UnicodeOutput
-from examples.unicode_input import UnicodeInput
-from examples.nested_context import NestedContext
+from .examples.comments import Comments
+from .examples.double_section import DoubleSection
+from .examples.escaped import Escaped
+from .examples.unescaped import Unescaped
+from .examples.template_partial import TemplatePartial
+from .examples.delimiters import Delimiters
+from .examples.unicode_output import UnicodeOutput
+from .examples.unicode_input import UnicodeInput
+from .examples.nested_context import NestedContext
 from pystache import Renderer
 from pystache.tests.common import EXAMPLES_DIR
 from pystache.tests.common import AssertStringMixin
@@ -29,34 +29,34 @@ class TestView(unittest.TestCase, AssertStringMixin):
         self.assertString(actual, expected)
 
     def test_comments(self):
-        self._assert(Comments(), u"<h1>A Comedy of Errors</h1>")
+        self._assert(Comments(), "<h1>A Comedy of Errors</h1>")
 
     def test_double_section(self):
-        self._assert(DoubleSection(), u"* first\n* second\n* third")
+        self._assert(DoubleSection(), "* first\n* second\n* third")
 
     def test_unicode_output(self):
         renderer = Renderer()
         actual = renderer.render(UnicodeOutput())
-        self.assertString(actual, u'<p>Name: Henri Poincaré</p>')
+        self.assertString(actual, '<p>Name: Henri Poincaré</p>')
 
     def test_unicode_input(self):
         renderer = Renderer()
         actual = renderer.render(UnicodeInput())
-        self.assertString(actual, u'abcdé')
+        self.assertString(actual, 'abcdé')
 
     def test_escaping(self):
-        self._assert(Escaped(), u"<h1>Bear &gt; Shark</h1>")
+        self._assert(Escaped(), "<h1>Bear &gt; Shark</h1>")
 
     def test_literal(self):
         renderer = Renderer()
         actual = renderer.render(Unescaped())
-        self.assertString(actual, u"<h1>Bear > Shark</h1>")
+        self.assertString(actual, "<h1>Bear > Shark</h1>")
 
     def test_template_partial(self):
         renderer = Renderer(search_dirs=EXAMPLES_DIR)
         actual = renderer.render(TemplatePartial(renderer=renderer))
 
-        self.assertString(actual, u"""<h1>Welcome</h1>
+        self.assertString(actual, """<h1>Welcome</h1>
 Again, Welcome!""")
 
     def test_template_partial_extension(self):
@@ -65,7 +65,7 @@ Again, Welcome!""")
         view = TemplatePartial(renderer=renderer)
 
         actual = renderer.render(view)
-        self.assertString(actual, u"""Welcome
+        self.assertString(actual, """Welcome
 -------
 
 ## Again, Welcome! ##""")
@@ -73,7 +73,7 @@ Again, Welcome!""")
     def test_delimiters(self):
         renderer = Renderer()
         actual = renderer.render(Delimiters())
-        self.assertString(actual, u"""\
+        self.assertString(actual, """\
 * It worked the first time.
 * And it worked the second time.
 * Then, surprisingly, it worked the third time.
@@ -82,7 +82,7 @@ Again, Welcome!""")
     def test_nested_context(self):
         renderer = Renderer()
         actual = renderer.render(NestedContext(renderer))
-        self.assertString(actual, u"one and foo and two")
+        self.assertString(actual, "one and foo and two")
 
     def test_nested_context_is_available_in_view(self):
         renderer = Renderer()
@@ -91,7 +91,7 @@ Again, Welcome!""")
         view.template = '{{#herp}}{{#derp}}{{nested_context_in_view}}{{/derp}}{{/herp}}'
 
         actual = renderer.render(view)
-        self.assertString(actual, u'it works!')
+        self.assertString(actual, 'it works!')
 
     def test_partial_in_partial_has_access_to_grand_parent_context(self):
         renderer = Renderer(search_dirs=EXAMPLES_DIR)
diff --git a/pystache/tests/test_loader.py b/pystache/tests/test_loader.py
index f2c2187..315daff 100644
--- a/pystache/tests/test_loader.py
+++ b/pystache/tests/test_loader.py
@@ -55,23 +55,23 @@ class LoaderTests(unittest.TestCase, AssertStringMixin, SetupDefaults):
 
     def test_init__to_unicode__default(self):
         loader = Loader()
-        self.assertRaises(TypeError, loader.to_unicode, u"abc")
+        self.assertRaises(TypeError, loader.to_unicode, "abc")
 
         decode_errors = defaults.DECODE_ERRORS
         string_encoding = defaults.STRING_ENCODING
 
-        nonascii = u'abcdé'.encode('utf-8')
+        nonascii = 'abcdé'.encode('utf-8')
 
         loader = Loader()
         self.assertRaises(UnicodeDecodeError, loader.to_unicode, nonascii)
 
         defaults.DECODE_ERRORS = 'ignore'
         loader = Loader()
-        self.assertString(loader.to_unicode(nonascii), u'abcd')
+        self.assertString(loader.to_unicode(nonascii), 'abcd')
 
         defaults.STRING_ENCODING = 'utf-8'
         loader = Loader()
-        self.assertString(loader.to_unicode(nonascii), u'abcdé')
+        self.assertString(loader.to_unicode(nonascii), 'abcdé')
 
 
     def _get_path(self, filename):
@@ -83,9 +83,9 @@ class LoaderTests(unittest.TestCase, AssertStringMixin, SetupDefaults):
 
         """
         loader = Loader()
-        actual = loader.unicode("foo")
+        actual = loader.str("foo")
 
-        self.assertString(actual, u"foo")
+        self.assertString(actual, "foo")
 
     def test_unicode__basic__input_unicode(self):
         """
@@ -93,24 +93,24 @@ class LoaderTests(unittest.TestCase, AssertStringMixin, SetupDefaults):
 
         """
         loader = Loader()
-        actual = loader.unicode(u"foo")
+        actual = loader.str("foo")
 
-        self.assertString(actual, u"foo")
+        self.assertString(actual, "foo")
 
     def test_unicode__basic__input_unicode_subclass(self):
         """
         Test unicode(): default arguments with unicode-subclass input.
 
         """
-        class UnicodeSubclass(unicode):
+        class UnicodeSubclass(str):
             pass
 
-        s = UnicodeSubclass(u"foo")
+        s = UnicodeSubclass("foo")
 
         loader = Loader()
-        actual = loader.unicode(s)
+        actual = loader.str(s)
 
-        self.assertString(actual, u"foo")
+        self.assertString(actual, "foo")
 
     def test_unicode__to_unicode__attribute(self):
         """
@@ -119,16 +119,16 @@ class LoaderTests(unittest.TestCase, AssertStringMixin, SetupDefaults):
         """
         loader = Loader()
 
-        non_ascii = u'abcdé'.encode('utf-8')
-        self.assertRaises(UnicodeDecodeError, loader.unicode, non_ascii)
+        non_ascii = 'abcdé'.encode('utf-8')
+        self.assertRaises(UnicodeDecodeError, loader.str, non_ascii)
 
         def to_unicode(s, encoding=None):
             if encoding is None:
                 encoding = 'utf-8'
-            return unicode(s, encoding)
+            return str(s, encoding)
 
         loader.to_unicode = to_unicode
-        self.assertString(loader.unicode(non_ascii), u"abcdé")
+        self.assertString(loader.str(non_ascii), "abcdé")
 
     def test_unicode__encoding_argument(self):
         """
@@ -137,12 +137,12 @@ class LoaderTests(unittest.TestCase, AssertStringMixin, SetupDefaults):
         """
         loader = Loader()
 
-        non_ascii = u'abcdé'.encode('utf-8')
+        non_ascii = 'abcdé'.encode('utf-8')
 
-        self.assertRaises(UnicodeDecodeError, loader.unicode, non_ascii)
+        self.assertRaises(UnicodeDecodeError, loader.str, non_ascii)
 
-        actual = loader.unicode(non_ascii, encoding='utf-8')
-        self.assertString(actual, u'abcdé')
+        actual = loader.str(non_ascii, encoding='utf-8')
+        self.assertString(actual, 'abcdé')
 
     # TODO: check the read() unit tests.
     def test_read(self):
@@ -153,7 +153,7 @@ class LoaderTests(unittest.TestCase, AssertStringMixin, SetupDefaults):
         loader = Loader()
         path = self._get_path('ascii.mustache')
         actual = loader.read(path)
-        self.assertString(actual, u'ascii: abc')
+        self.assertString(actual, 'ascii: abc')
 
     def test_read__file_encoding__attribute(self):
         """
@@ -167,7 +167,7 @@ class LoaderTests(unittest.TestCase, AssertStringMixin, SetupDefaults):
 
         loader.file_encoding = 'utf-8'
         actual = loader.read(path)
-        self.assertString(actual, u'non-ascii: é')
+        self.assertString(actual, 'non-ascii: é')
 
     def test_read__encoding__argument(self):
         """
@@ -180,7 +180,7 @@ class LoaderTests(unittest.TestCase, AssertStringMixin, SetupDefaults):
         self.assertRaises(UnicodeDecodeError, loader.read, path)
 
         actual = loader.read(path, encoding='utf-8')
-        self.assertString(actual, u'non-ascii: é')
+        self.assertString(actual, 'non-ascii: é')
 
     def test_read__to_unicode__attribute(self):
         """
diff --git a/pystache/tests/test_pystache.py b/pystache/tests/test_pystache.py
index 5447f8d..cf5d6af 100644
--- a/pystache/tests/test_pystache.py
+++ b/pystache/tests/test_pystache.py
@@ -71,14 +71,14 @@ class PystacheTests(unittest.TestCase):
         template = "{{#stats}}({{key}} & {{value}}){{/stats}}"
         stats = []
         stats.append({'key': 123, 'value': ['something']})
-        stats.append({'key': u"chris", 'value': 0.900})
+        stats.append({'key': "chris", 'value': 0.900})
         context = { 'stats': stats }
         self._assert_rendered(self.non_strings_expected, template, context)
 
     def test_unicode(self):
         template = 'Name: {{name}}; Age: {{age}}'
-        context = {'name': u'Henri Poincaré', 'age': 156 }
-        self._assert_rendered(u'Name: Henri Poincaré; Age: 156', template, context)
+        context = {'name': 'Henri Poincaré', 'age': 156}
+        self._assert_rendered('Name: Henri Poincaré; Age: 156', template, context)
 
     def test_sections(self):
         template = """<ul>{{#users}}<li>{{name}}</li>{{/users}}</ul>"""
diff --git a/pystache/tests/test_renderengine.py b/pystache/tests/test_renderengine.py
index db916f7..ed604c5 100644
--- a/pystache/tests/test_renderengine.py
+++ b/pystache/tests/test_renderengine.py
@@ -33,11 +33,11 @@ def mock_literal(s):
       s: a byte string or unicode string.
 
     """
-    if isinstance(s, unicode):
+    if isinstance(s, str):
         # Strip off unicode super classes, if present.
-        u = unicode(s)
+        u = str(s)
     else:
-        u = unicode(s, encoding='ascii')
+        u = str(s, encoding='ascii')
 
     # We apply upper() to make sure we are actually using our custom
     # function in the tests
@@ -94,17 +94,17 @@ class RenderTests(unittest.TestCase, AssertStringMixin, AssertExceptionMixin):
         engine = kwargs.get('engine', self._engine())
 
         if partials is not None:
-            engine.resolve_partial = lambda key: unicode(partials[key])
+            engine.resolve_partial = lambda key: str(partials[key])
 
         context = ContextStack(*context)
 
         # RenderEngine.render() only accepts unicode template strings.
-        actual = engine.render(unicode(template), context)
+        actual = engine.render(str(template), context)
 
         self.assertString(actual=actual, expected=expected)
 
     def test_render(self):
-        self._assert_render(u'Hi Mom', 'Hi {{person}}', {'person': 'Mom'})
+        self._assert_render('Hi Mom', 'Hi {{person}}', {'person': 'Mom'})
 
     def test__resolve_partial(self):
         """
@@ -112,10 +112,10 @@ class RenderTests(unittest.TestCase, AssertStringMixin, AssertExceptionMixin):
 
         """
         engine = self._engine()
-        partials = {'partial': u"{{person}}"}
+        partials = {'partial': "{{person}}"}
         engine.resolve_partial = lambda key: partials[key]
 
-        self._assert_render(u'Hi Mom', 'Hi {{>partial}}', {'person': 'Mom'}, engine=engine)
+        self._assert_render('Hi Mom', 'Hi {{>partial}}', {'person': 'Mom'}, engine=engine)
 
     def test__literal(self):
         """
@@ -125,13 +125,13 @@ class RenderTests(unittest.TestCase, AssertStringMixin, AssertExceptionMixin):
         engine = self._engine()
         engine.literal = lambda s: s.upper()
 
-        self._assert_render(u'BAR', '{{{foo}}}', {'foo': 'bar'}, engine=engine)
+        self._assert_render('BAR', '{{{foo}}}', {'foo': 'bar'}, engine=engine)
 
     def test_literal__sigil(self):
         template = "<h1>{{& thing}}</h1>"
         context = {'thing': 'Bear > Giraffe'}
 
-        expected = u"<h1>Bear > Giraffe</h1>"
+        expected = "<h1>Bear > Giraffe</h1>"
 
         self._assert_render(expected, template, context)
 
@@ -143,7 +143,7 @@ class RenderTests(unittest.TestCase, AssertStringMixin, AssertExceptionMixin):
         engine = self._engine()
         engine.escape = lambda s: "**" + s
 
-        self._assert_render(u'**bar', '{{foo}}', {'foo': 'bar'}, engine=engine)
+        self._assert_render('**bar', '{{foo}}', {'foo': 'bar'}, engine=engine)
 
     def test__escape_does_not_call_literal(self):
         """
@@ -157,7 +157,7 @@ class RenderTests(unittest.TestCase, AssertStringMixin, AssertExceptionMixin):
         template = 'literal: {{{foo}}} escaped: {{foo}}'
         context = {'foo': 'bar'}
 
-        self._assert_render(u'literal: BAR escaped: **bar', template, context, engine=engine)
+        self._assert_render('literal: BAR escaped: **bar', template, context, engine=engine)
 
     def test__escape_preserves_unicode_subclasses(self):
         """
@@ -167,7 +167,7 @@ class RenderTests(unittest.TestCase, AssertStringMixin, AssertExceptionMixin):
         variable value is markupsafe.Markup when escaping.
 
         """
-        class MyUnicode(unicode):
+        class MyUnicode(str):
             pass
 
         def escape(s):
@@ -182,7 +182,7 @@ class RenderTests(unittest.TestCase, AssertStringMixin, AssertExceptionMixin):
         template = '{{foo1}} {{foo2}}'
         context = {'foo1': MyUnicode('bar'), 'foo2': 'bar'}
 
-        self._assert_render(u'**bar bar**', template, context, engine=engine)
+        self._assert_render('**bar bar**', template, context, engine=engine)
 
     # Custom to_str for testing purposes.
     def _to_str(self, val):
@@ -197,9 +197,9 @@ class RenderTests(unittest.TestCase, AssertStringMixin, AssertExceptionMixin):
         template = '{{value}}'
         context = {'value': None}
 
-        self._assert_render(u'None', template, context, engine=engine)
+        self._assert_render('None', template, context, engine=engine)
         engine.to_str = self._to_str
-        self._assert_render(u'', template, context, engine=engine)
+        self._assert_render('', template, context, engine=engine)
 
     def test_to_str__lambda(self):
         """Test the to_str attribute for a lambda."""
@@ -207,9 +207,9 @@ class RenderTests(unittest.TestCase, AssertStringMixin, AssertExceptionMixin):
         template = '{{value}}'
         context = {'value': lambda: None}
 
-        self._assert_render(u'None', template, context, engine=engine)
+        self._assert_render('None', template, context, engine=engine)
         engine.to_str = self._to_str
-        self._assert_render(u'', template, context, engine=engine)
+        self._assert_render('', template, context, engine=engine)
 
     def test_to_str__section_list(self):
         """Test the to_str attribute for a section list."""
@@ -217,9 +217,9 @@ class RenderTests(unittest.TestCase, AssertStringMixin, AssertExceptionMixin):
         template = '{{#list}}{{.}}{{/list}}'
         context = {'list': [None, None]}
 
-        self._assert_render(u'NoneNone', template, context, engine=engine)
+        self._assert_render('NoneNone', template, context, engine=engine)
         engine.to_str = self._to_str
-        self._assert_render(u'', template, context, engine=engine)
+        self._assert_render('', template, context, engine=engine)
 
     def test_to_str__section_lambda(self):
         # TODO: add a test for a "method with an arity of 1".
@@ -239,7 +239,7 @@ class RenderTests(unittest.TestCase, AssertStringMixin, AssertExceptionMixin):
         template = '{{text}} {{int}} {{{int}}}'
         context = {'int': 100, 'text': 'foo'}
 
-        self._assert_render(u'FOO 100 100', template, context, engine=engine)
+        self._assert_render('FOO 100 100', template, context, engine=engine)
 
     def test_tag__output_not_interpolated(self):
         """
@@ -248,7 +248,7 @@ class RenderTests(unittest.TestCase, AssertStringMixin, AssertExceptionMixin):
         """
         template = '{{template}}: {{planet}}'
         context = {'template': '{{planet}}', 'planet': 'Earth'}
-        self._assert_render(u'{{planet}}: Earth', template, context)
+        self._assert_render('{{planet}}: Earth', template, context)
 
     def test_tag__output_not_interpolated__section(self):
         """
@@ -257,7 +257,7 @@ class RenderTests(unittest.TestCase, AssertStringMixin, AssertExceptionMixin):
         """
         template = '{{test}}'
         context = {'test': '{{#hello}}'}
-        self._assert_render(u'{{#hello}}', template, context)
+        self._assert_render('{{#hello}}', template, context)
 
     ## Test interpolation with "falsey" values
     #
@@ -268,17 +268,17 @@ class RenderTests(unittest.TestCase, AssertStringMixin, AssertExceptionMixin):
     def test_interpolation__falsey__zero(self):
         template = '{{.}}'
         context = 0
-        self._assert_render(u'0', template, context)
+        self._assert_render('0', template, context)
 
     def test_interpolation__falsey__none(self):
         template = '{{.}}'
         context = None
-        self._assert_render(u'None', template, context)
+        self._assert_render('None', template, context)
 
     def test_interpolation__falsey__zero(self):
         template = '{{.}}'
         context = False
-        self._assert_render(u'False', template, context)
+        self._assert_render('False', template, context)
 
     # Built-in types:
     #
@@ -310,7 +310,7 @@ class RenderTests(unittest.TestCase, AssertStringMixin, AssertExceptionMixin):
         Check tag interpolation with a built-in type: string.
 
         """
-        self._assert_builtin_type('abc', 'upper', 'ABC', u'xyz')
+        self._assert_builtin_type('abc', 'upper', 'ABC', 'xyz')
 
     def test_interpolation__built_in_type__integer(self):
         """
@@ -324,7 +324,7 @@ class RenderTests(unittest.TestCase, AssertStringMixin, AssertExceptionMixin):
         #
         # we need to resort to built-in attributes (double-underscored) on
         # the integer type.
-        self._assert_builtin_type(15, '__neg__', -15, u'999')
+        self._assert_builtin_type(15, '__neg__', -15, '999')
 
     def test_interpolation__built_in_type__list(self):
         """
@@ -338,7 +338,7 @@ class RenderTests(unittest.TestCase, AssertStringMixin, AssertExceptionMixin):
 
         template = '{{#section}}{{%s}}{{/section}}' % attr_name
         context = {'section': item, attr_name: 7}
-        self._assert_render(u'7', template, context)
+        self._assert_render('7', template, context)
 
     # This test is also important for testing 2to3.
     def test_interpolation__nonascii_nonunicode(self):
@@ -347,8 +347,8 @@ class RenderTests(unittest.TestCase, AssertStringMixin, AssertExceptionMixin):
 
         """
         template = '{{nonascii}}'
-        context = {'nonascii': u'abcdé'.encode('utf-8')}
-        self._assert_render(u'abcdé', template, context)
+        context = {'nonascii': 'abcdé'.encode('utf-8')}
+        self._assert_render('abcdé', template, context)
 
     def test_implicit_iterator__literal(self):
         """
@@ -358,7 +358,7 @@ class RenderTests(unittest.TestCase, AssertStringMixin, AssertExceptionMixin):
         template = """{{#test}}{{{.}}}{{/test}}"""
         context = {'test': ['<', '>']}
 
-        self._assert_render(u'<>', template, context)
+        self._assert_render('<>', template, context)
 
     def test_implicit_iterator__escaped(self):
         """
@@ -368,7 +368,7 @@ class RenderTests(unittest.TestCase, AssertStringMixin, AssertExceptionMixin):
         template = """{{#test}}{{.}}{{/test}}"""
         context = {'test': ['<', '>']}
 
-        self._assert_render(u'&lt;&gt;', template, context)
+        self._assert_render('&lt;&gt;', template, context)
 
     def test_literal__in_section(self):
         """
@@ -378,7 +378,7 @@ class RenderTests(unittest.TestCase, AssertStringMixin, AssertExceptionMixin):
         template = '{{#test}}1 {{{less_than}}} 2{{/test}}'
         context = {'test': {'less_than': '<'}}
 
-        self._assert_render(u'1 < 2', template, context)
+        self._assert_render('1 < 2', template, context)
 
     def test_literal__in_partial(self):
         """
@@ -389,11 +389,11 @@ class RenderTests(unittest.TestCase, AssertStringMixin, AssertExceptionMixin):
         partials = {'partial': '1 {{{less_than}}} 2'}
         context = {'less_than': '<'}
 
-        self._assert_render(u'1 < 2', template, context, partials=partials)
+        self._assert_render('1 < 2', template, context, partials=partials)
 
     def test_partial(self):
         partials = {'partial': "{{person}}"}
-        self._assert_render(u'Hi Mom', 'Hi {{>partial}}', {'person': 'Mom'}, partials=partials)
+        self._assert_render('Hi Mom', 'Hi {{>partial}}', {'person': 'Mom'}, partials=partials)
 
     def test_partial__context_values(self):
         """
@@ -406,7 +406,9 @@ class RenderTests(unittest.TestCase, AssertStringMixin, AssertExceptionMixin):
         partials = {'partial': 'unescaped: {{{foo}}} escaped: {{foo}}'}
         context = {'foo': '<'}
 
-        self._assert_render(u'unescaped: < escaped: &lt;', template, context, engine=engine, partials=partials)
+        self._assert_render(
+            'unescaped: < escaped: &lt;',
+            template, context, engine=engine, partials=partials)
 
     ## Test cases related specifically to lambdas.
 
@@ -417,8 +419,8 @@ class RenderTests(unittest.TestCase, AssertStringMixin, AssertExceptionMixin):
 
         """
         template = '{{#nonascii}}{{.}}{{/nonascii}}'
-        context = {'nonascii': u'abcdé'.encode('utf-8')}
-        self._assert_render(u'abcdé', template, context)
+        context = {'nonascii': 'abcdé'.encode('utf-8')}
+        self._assert_render('abcdé', template, context)
 
     # This test is also important for testing 2to3.
     def test_lambda__returning_nonascii_nonunicode(self):
@@ -427,8 +429,8 @@ class RenderTests(unittest.TestCase, AssertStringMixin, AssertExceptionMixin):
 
         """
         template = '{{lambda}}'
-        context = {'lambda': lambda: u'abcdé'.encode('utf-8')}
-        self._assert_render(u'abcdé', template, context)
+        context = {'lambda': lambda: 'abcdé'.encode('utf-8')}
+        self._assert_render('abcdé', template, context)
 
     ## Test cases related specifically to sections.
 
@@ -440,7 +442,7 @@ class RenderTests(unittest.TestCase, AssertStringMixin, AssertExceptionMixin):
         template = '{{/section}}'
         try:
             self._assert_render(None, template)
-        except ParsingError, err:
+        except ParsingError as err:
             self.assertEqual(str(err), "Section end tag mismatch: section != None")
 
     def test_section__end_tag_mismatch(self):
@@ -451,7 +453,7 @@ class RenderTests(unittest.TestCase, AssertStringMixin, AssertExceptionMixin):
         template = '{{#section_start}}{{/section_end}}'
         try:
             self._assert_render(None, template)
-        except ParsingError, err:
+        except ParsingError as err:
             self.assertEqual(str(err), "Section end tag mismatch: section_end != section_start")
 
     def test_section__context_values(self):
@@ -464,7 +466,7 @@ class RenderTests(unittest.TestCase, AssertStringMixin, AssertExceptionMixin):
         template = '{{#test}}unescaped: {{{foo}}} escaped: {{foo}}{{/test}}'
         context = {'test': {'foo': '<'}}
 
-        self._assert_render(u'unescaped: < escaped: &lt;', template, context, engine=engine)
+        self._assert_render('unescaped: < escaped: &lt;', template, context, engine=engine)
 
     def test_section__context_precedence(self):
         """
@@ -473,7 +475,7 @@ class RenderTests(unittest.TestCase, AssertStringMixin, AssertExceptionMixin):
         """
         template = '{{entree}} : {{#vegetarian}}{{entree}}{{/vegetarian}}'
         context = {'entree': 'chicken', 'vegetarian': {'entree': 'beans and rice'}}
-        self._assert_render(u'chicken : beans and rice', template, context)
+        self._assert_render('chicken : beans and rice', template, context)
 
     def test_section__list_referencing_outer_context(self):
         """
@@ -491,7 +493,7 @@ class RenderTests(unittest.TestCase, AssertStringMixin, AssertExceptionMixin):
 
         template = "{{#list}}{{greeting}} {{name}}, {{/list}}"
 
-        self._assert_render(u"Hi Al, Hi Bob, ", template, context)
+        self._assert_render("Hi Al, Hi Bob, ", template, context)
 
     def test_section__output_not_interpolated(self):
         """
@@ -500,7 +502,7 @@ class RenderTests(unittest.TestCase, AssertStringMixin, AssertExceptionMixin):
         """
         template = '{{#section}}{{template}}{{/section}}: {{planet}}'
         context = {'section': True, 'template': '{{planet}}', 'planet': 'Earth'}
-        self._assert_render(u'{{planet}}: Earth', template, context)
+        self._assert_render('{{planet}}: Earth', template, context)
 
     # TODO: have this test case added to the spec.
     def test_section__string_values_not_lists(self):
@@ -511,7 +513,7 @@ class RenderTests(unittest.TestCase, AssertStringMixin, AssertExceptionMixin):
         template = '{{#section}}foo{{/section}}'
         context = {'section': '123'}
         # If strings were interpreted as lists, this would give "foofoofoo".
-        self._assert_render(u'foo', template, context)
+        self._assert_render('foo', template, context)
 
     def test_section__nested_truthy(self):
         """
@@ -525,7 +527,7 @@ class RenderTests(unittest.TestCase, AssertStringMixin, AssertExceptionMixin):
         """
         template = '| A {{#bool}}B {{#bool}}C{{/bool}} D{{/bool}} E |'
         context = {'bool': True}
-        self._assert_render(u'| A B C D E |', template, context)
+        self._assert_render('| A B C D E |', template, context)
 
     def test_section__nested_with_same_keys(self):
         """
@@ -537,16 +539,16 @@ class RenderTests(unittest.TestCase, AssertStringMixin, AssertExceptionMixin):
         # Start with an easier, working case.
         template = '{{#x}}{{#z}}{{y}}{{/z}}{{/x}}'
         context = {'x': {'z': {'y': 1}}}
-        self._assert_render(u'1', template, context)
+        self._assert_render('1', template, context)
 
         template = '{{#x}}{{#x}}{{y}}{{/x}}{{/x}}'
         context = {'x': {'x': {'y': 1}}}
-        self._assert_render(u'1', template, context)
+        self._assert_render('1', template, context)
 
     def test_section__lambda(self):
         template = '{{#test}}Mom{{/test}}'
         context = {'test': (lambda text: 'Hi %s' % text)}
-        self._assert_render(u'Hi Mom', template, context)
+        self._assert_render('Hi Mom', template, context)
 
     # This test is also important for testing 2to3.
     def test_section__lambda__returning_nonascii_nonunicode(self):
@@ -555,8 +557,8 @@ class RenderTests(unittest.TestCase, AssertStringMixin, AssertExceptionMixin):
 
         """
         template = '{{#lambda}}{{/lambda}}'
-        context = {'lambda': lambda text: u'abcdé'.encode('utf-8')}
-        self._assert_render(u'abcdé', template, context)
+        context = {'lambda': lambda text: 'abcdé'.encode('utf-8')}
+        self._assert_render('abcdé', template, context)
 
     def test_section__lambda__returning_nonstring(self):
         """
@@ -565,7 +567,7 @@ class RenderTests(unittest.TestCase, AssertStringMixin, AssertExceptionMixin):
         """
         template = '{{#lambda}}foo{{/lambda}}'
         context = {'lambda': lambda text: len(text)}
-        self._assert_render(u'3', template, context)
+        self._assert_render('3', template, context)
 
     def test_section__iterable(self):
         """
@@ -575,10 +577,10 @@ class RenderTests(unittest.TestCase, AssertStringMixin, AssertExceptionMixin):
         template = '{{#iterable}}{{.}}{{/iterable}}'
 
         context = {'iterable': (i for i in range(3))}  # type 'generator'
-        self._assert_render(u'012', template, context)
+        self._assert_render('012', template, context)
 
-        context = {'iterable': xrange(4)}  # type 'xrange'
-        self._assert_render(u'0123', template, context)
+        context = {'iterable': range(4)}  # type 'xrange'
+        self._assert_render('0123', template, context)
 
         d = {'foo': 0, 'bar': 0}
         # We don't know what order of keys we'll be given, but from the
@@ -586,8 +588,8 @@ class RenderTests(unittest.TestCase, AssertStringMixin, AssertExceptionMixin):
         #  "If items(), keys(), values(), iteritems(), iterkeys(), and
         #   itervalues() are called with no intervening modifications to
         #   the dictionary, the lists will directly correspond."
-        expected = u''.join(d.keys())
-        context = {'iterable': d.iterkeys()}  # type 'dictionary-keyiterator'
+        expected = ''.join(list(d.keys()))
+        context = {'iterable': iter(d.keys())}  # type 'dictionary-keyiterator'
         self._assert_render(expected, template, context)
 
     def test_section__lambda__tag_in_output(self):
@@ -605,7 +607,7 @@ class RenderTests(unittest.TestCase, AssertStringMixin, AssertExceptionMixin):
         """
         template = '{{#test}}Hi {{person}}{{/test}}'
         context = {'person': 'Mom', 'test': (lambda text: text + " :)")}
-        self._assert_render(u'Hi Mom :)', template, context)
+        self._assert_render('Hi Mom :)', template, context)
 
     def test_section__lambda__list(self):
         """
@@ -621,7 +623,7 @@ class RenderTests(unittest.TestCase, AssertStringMixin, AssertExceptionMixin):
                    'lambdas': [lambda text: "~{{%s}}~" % text,
                                lambda text: "#{{%s}}#" % text]}
 
-        self._assert_render(u'<~bar~#bar#>', template, context)
+        self._assert_render('<~bar~#bar#>', template, context)
 
     def test_section__lambda__mixed_list(self):
         """
@@ -636,7 +638,7 @@ class RenderTests(unittest.TestCase, AssertStringMixin, AssertExceptionMixin):
         context = {'foo': 'bar',
                    'lambdas': [lambda text: "~{{%s}}~" % text, 1]}
 
-        self._assert_render(u'<~bar~foo>', template, context)
+        self._assert_render('<~bar~foo>', template, context)
 
     def test_section__lambda__not_on_context_stack(self):
         """
@@ -653,7 +655,7 @@ class RenderTests(unittest.TestCase, AssertStringMixin, AssertExceptionMixin):
         """
         context = {'foo': 'bar', 'lambda': (lambda text: "{{.}}")}
         template = '{{#foo}}{{#lambda}}blah{{/lambda}}{{/foo}}'
-        self._assert_render(u'bar', template, context)
+        self._assert_render('bar', template, context)
 
     def test_section__lambda__no_reinterpolation(self):
         """
@@ -670,15 +672,15 @@ class RenderTests(unittest.TestCase, AssertStringMixin, AssertExceptionMixin):
         """
         template = '{{#planet}}{{#lambda}}dot{{/lambda}}{{/planet}}'
         context = {'planet': 'Earth', 'dot': '~{{.}}~', 'lambda': (lambda text: "#{{%s}}#" % text)}
-        self._assert_render(u'#~{{.}}~#', template, context)
+        self._assert_render('#~{{.}}~#', template, context)
 
     def test_comment__multiline(self):
         """
         Check that multiline comments are permitted.
 
         """
-        self._assert_render(u'foobar', 'foo{{! baz }}bar')
-        self._assert_render(u'foobar', 'foo{{! \nbaz }}bar')
+        self._assert_render('foobar', 'foo{{! baz }}bar')
+        self._assert_render('foobar', 'foo{{! \nbaz }}bar')
 
     def test_custom_delimiters__sections(self):
         """
@@ -689,7 +691,7 @@ class RenderTests(unittest.TestCase, AssertStringMixin, AssertExceptionMixin):
         """
         template = '{{=[[ ]]=}}[[#foo]]bar[[/foo]]'
         context = {'foo': True}
-        self._assert_render(u'bar', template, context)
+        self._assert_render('bar', template, context)
 
     def test_custom_delimiters__not_retroactive(self):
         """
@@ -698,7 +700,7 @@ class RenderTests(unittest.TestCase, AssertStringMixin, AssertExceptionMixin):
         Test case for issue #35: https://github.com/defunkt/pystache/issues/35
 
         """
-        expected = u' {{foo}} '
+        expected = ' {{foo}} '
         self._assert_render(expected, '{{=$ $=}} {{foo}} ')
         self._assert_render(expected, '{{=$ $=}} {{foo}} $={{ }}=$')  # was yielding u'  '.
 
@@ -713,7 +715,7 @@ class RenderTests(unittest.TestCase, AssertStringMixin, AssertExceptionMixin):
         template = 'Hello, {{person.name}}. I see you are {{person.details.age}}.'
         person = Attachable(name='Biggles', details={'age': 42})
         context = {'person': person}
-        self._assert_render(u'Hello, Biggles. I see you are 42.', template, context)
+        self._assert_render('Hello, Biggles. I see you are 42.', template, context)
 
     def test_dot_notation__multiple_levels(self):
         """
@@ -722,7 +724,7 @@ class RenderTests(unittest.TestCase, AssertStringMixin, AssertExceptionMixin):
         """
         template = """Hello, Mr. {{person.name.lastname}}.
         I see you're back from {{person.travels.last.country.city}}."""
-        expected = u"""Hello, Mr. Pither.
+        expected = """Hello, Mr. Pither.
         I see you're back from Cornwall."""
         context = {'person': {'name': {'firstname': 'unknown', 'lastname': 'Pither'},
                             'travels': {'last': {'country': {'city': 'Cornwall'}}},
@@ -758,10 +760,10 @@ class RenderTests(unittest.TestCase, AssertStringMixin, AssertExceptionMixin):
         context = {'a': {'b': 'A.B'}, 'c': {'a': 'A'} }
 
         template = '{{a.b}}'
-        self._assert_render(u'A.B', template, context)
+        self._assert_render('A.B', template, context)
 
         template = '{{#c}}{{a}}{{/c}}'
-        self._assert_render(u'A', template, context)
+        self._assert_render('A', template, context)
 
         template = '{{#c}}{{a.b}}{{/c}}'
         self.assertException(KeyNotFoundError, "Key %(unicode)s'a.b' not found: missing %(unicode)s'b'" %
diff --git a/pystache/tests/test_renderer.py b/pystache/tests/test_renderer.py
index 0dbe0d9..e0d2448 100644
--- a/pystache/tests/test_renderer.py
+++ b/pystache/tests/test_renderer.py
@@ -10,7 +10,7 @@ import os
 import sys
 import unittest
 
-from examples.simple import Simple
+from .examples.simple import Simple
 from pystache import Renderer
 from pystache import TemplateSpec
 from pystache.common import TemplateNotFoundError
@@ -33,7 +33,7 @@ def _make_renderer():
 def mock_unicode(b, encoding=None):
     if encoding is None:
         encoding = 'ascii'
-    u = unicode(b, encoding=encoding)
+    u = str(b, encoding=encoding)
     return u.upper()
 
 
@@ -197,13 +197,13 @@ class RendererTests(unittest.TestCase, AssertStringMixin):
 
         """
         renderer = self._renderer()
-        b = u"é".encode('utf-8')
+        b = "é".encode('utf-8')
 
         renderer.string_encoding = "ascii"
-        self.assertRaises(UnicodeDecodeError, renderer.unicode, b)
+        self.assertRaises(UnicodeDecodeError, renderer.str, b)
 
         renderer.string_encoding = "utf-8"
-        self.assertEqual(renderer.unicode(b), u"é")
+        self.assertEqual(renderer.str(b), "é")
 
     def test_unicode__decode_errors(self):
         """
@@ -212,14 +212,14 @@ class RendererTests(unittest.TestCase, AssertStringMixin):
         """
         renderer = self._renderer()
         renderer.string_encoding = "ascii"
-        b = u"déf".encode('utf-8')
+        b = "déf".encode('utf-8')
 
         renderer.decode_errors = "ignore"
-        self.assertEqual(renderer.unicode(b), "df")
+        self.assertEqual(renderer.str(b), "df")
 
         renderer.decode_errors = "replace"
         # U+FFFD is the official Unicode replacement character.
-        self.assertEqual(renderer.unicode(b), u'd\ufffd\ufffdf')
+        self.assertEqual(renderer.str(b), u'd\ufffd\ufffdf')
 
     ## Test the _make_loader() method.
 
@@ -243,7 +243,7 @@ class RendererTests(unittest.TestCase, AssertStringMixin):
         renderer = self._renderer()
         renderer.file_encoding = 'enc'
         renderer.file_extension = 'ext'
-        renderer.unicode = unicode_
+        renderer.str = unicode_
 
         loader = renderer._make_loader()
 
@@ -260,12 +260,12 @@ class RendererTests(unittest.TestCase, AssertStringMixin):
         """
         renderer = self._renderer()
         rendered = renderer.render('foo')
-        self.assertEqual(type(rendered), unicode)
+        self.assertEqual(type(rendered), str)
 
     def test_render__unicode(self):
         renderer = self._renderer()
-        actual = renderer.render(u'foo')
-        self.assertEqual(actual, u'foo')
+        actual = renderer.render('foo')
+        self.assertEqual(actual, 'foo')
 
     def test_render__str(self):
         renderer = self._renderer()
@@ -274,8 +274,8 @@ class RendererTests(unittest.TestCase, AssertStringMixin):
 
     def test_render__non_ascii_character(self):
         renderer = self._renderer()
-        actual = renderer.render(u'Poincaré')
-        self.assertEqual(actual, u'Poincaré')
+        actual = renderer.render('Poincaré')
+        self.assertEqual(actual, 'Poincaré')
 
     def test_render__context(self):
         """
@@ -326,7 +326,7 @@ class RendererTests(unittest.TestCase, AssertStringMixin):
 
         """
         renderer = _make_renderer()
-        template = u"déf".encode("utf-8")
+        template = "déf".encode("utf-8")
 
         # Check that decode_errors and string_encoding are both respected.
         renderer.decode_errors = 'ignore'
@@ -334,7 +334,7 @@ class RendererTests(unittest.TestCase, AssertStringMixin):
         self.assertEqual(renderer.render(template), "df")
 
         renderer.string_encoding = 'utf_8'
-        self.assertEqual(renderer.render(template), u"déf")
+        self.assertEqual(renderer.render(template), "déf")
 
     def test_make_resolve_partial(self):
         """
@@ -347,7 +347,7 @@ class RendererTests(unittest.TestCase, AssertStringMixin):
 
         actual = resolve_partial('foo')
         self.assertEqual(actual, 'bar')
-        self.assertEqual(type(actual), unicode, "RenderEngine requires that "
+        self.assertEqual(type(actual), str, "RenderEngine requires that "
             "resolve_partial return unicode strings.")
 
     def test_make_resolve_partial__unicode(self):
@@ -362,7 +362,7 @@ class RendererTests(unittest.TestCase, AssertStringMixin):
         self.assertEqual(resolve_partial("partial"), "foo")
 
         # Now with a value that is already unicode.
-        renderer.partials = {'partial': u'foo'}
+        renderer.partials = {'partial': 'foo'}
         resolve_partial = renderer._make_resolve_partial()
         # If the next line failed, we would get the following error:
         #   TypeError: decoding Unicode is not supported
@@ -373,7 +373,7 @@ class RendererTests(unittest.TestCase, AssertStringMixin):
         data_dir = get_data_path()
         renderer = Renderer(search_dirs=data_dir)
         actual = renderer.render_name("say_hello", to='foo')
-        self.assertString(actual, u"Hello, foo")
+        self.assertString(actual, "Hello, foo")
 
     def test_render_path(self):
         """
@@ -412,7 +412,7 @@ class RendererTests(unittest.TestCase, AssertStringMixin):
 
         spec = Spec()
         actual = renderer.render(spec)
-        self.assertString(actual, u'hello, world')
+        self.assertString(actual, 'hello, world')
 
     def test_render__view(self):
         """
@@ -484,7 +484,7 @@ class Renderer_MakeRenderEngineTests(unittest.TestCase, AssertStringMixin, Asser
         Check that resolve_partial returns unicode (and not a subclass).
 
         """
-        class MyUnicode(unicode):
+        class MyUnicode(str):
             pass
 
         renderer = Renderer()
@@ -495,12 +495,12 @@ class Renderer_MakeRenderEngineTests(unittest.TestCase, AssertStringMixin, Asser
 
         actual = engine.resolve_partial('str')
         self.assertEqual(actual, "foo")
-        self.assertEqual(type(actual), unicode)
+        self.assertEqual(type(actual), str)
 
         # Check that unicode subclasses are not preserved.
         actual = engine.resolve_partial('subclass')
         self.assertEqual(actual, "abc")
-        self.assertEqual(type(actual), unicode)
+        self.assertEqual(type(actual), str)
 
     def test__resolve_partial__not_found(self):
         """
@@ -512,7 +512,7 @@ class Renderer_MakeRenderEngineTests(unittest.TestCase, AssertStringMixin, Asser
         engine = renderer._make_render_engine()
         resolve_partial = engine.resolve_partial
 
-        self.assertString(resolve_partial('foo'), u'')
+        self.assertString(resolve_partial('foo'), '')
 
     def test__resolve_partial__not_found__missing_tags_strict(self):
         """
@@ -539,7 +539,7 @@ class Renderer_MakeRenderEngineTests(unittest.TestCase, AssertStringMixin, Asser
         engine = renderer._make_render_engine()
         resolve_partial = engine.resolve_partial
 
-        self.assertString(resolve_partial('foo'), u'')
+        self.assertString(resolve_partial('foo'), '')
 
     def test__resolve_partial__not_found__partials_dict__missing_tags_strict(self):
         """
@@ -566,12 +566,12 @@ class Renderer_MakeRenderEngineTests(unittest.TestCase, AssertStringMixin, Asser
 
         """
         renderer = self._make_renderer()
-        renderer.unicode = mock_unicode
+        renderer.str = mock_unicode
 
         engine = renderer._make_render_engine()
         literal = engine.literal
 
-        b = u"foo".encode("ascii")
+        b = "foo".encode("ascii")
         self.assertEqual(literal(b), "FOO")
 
     def test__literal__handles_unicode(self):
@@ -585,7 +585,7 @@ class Renderer_MakeRenderEngineTests(unittest.TestCase, AssertStringMixin, Asser
         engine = renderer._make_render_engine()
         literal = engine.literal
 
-        self.assertEqual(literal(u"foo"), "foo")
+        self.assertEqual(literal("foo"), "foo")
 
     def test__literal__returns_unicode(self):
         """
@@ -598,16 +598,16 @@ class Renderer_MakeRenderEngineTests(unittest.TestCase, AssertStringMixin, Asser
         engine = renderer._make_render_engine()
         literal = engine.literal
 
-        self.assertEqual(type(literal("foo")), unicode)
+        self.assertEqual(type(literal("foo")), str)
 
-        class MyUnicode(unicode):
+        class MyUnicode(str):
             pass
 
         s = MyUnicode("abc")
 
         self.assertEqual(type(s), MyUnicode)
-        self.assertTrue(isinstance(s, unicode))
-        self.assertEqual(type(literal(s)), unicode)
+        self.assertTrue(isinstance(s, str))
+        self.assertEqual(type(literal(s)), str)
 
     ## Test the engine's escape attribute.
 
@@ -630,12 +630,12 @@ class Renderer_MakeRenderEngineTests(unittest.TestCase, AssertStringMixin, Asser
 
         """
         renderer = Renderer()
-        renderer.unicode = mock_unicode
+        renderer.str = mock_unicode
 
         engine = renderer._make_render_engine()
         escape = engine.escape
 
-        b = u"foo".encode('ascii')
+        b = "foo".encode('ascii')
         self.assertEqual(escape(b), "FOO")
 
     def test__escape__has_access_to_original_unicode_subclass(self):
@@ -644,16 +644,16 @@ class Renderer_MakeRenderEngineTests(unittest.TestCase, AssertStringMixin, Asser
 
         """
         renderer = Renderer()
-        renderer.escape = lambda s: unicode(type(s).__name__)
+        renderer.escape = lambda s: str(type(s).__name__)
 
         engine = renderer._make_render_engine()
         escape = engine.escape
 
-        class MyUnicode(unicode):
+        class MyUnicode(str):
             pass
 
-        self.assertEqual(escape(u"foo".encode('ascii')), unicode.__name__)
-        self.assertEqual(escape(u"foo"), unicode.__name__)
+        self.assertEqual(escape("foo".encode('ascii')), str.__name__)
+        self.assertEqual(escape("foo"), str.__name__)
         self.assertEqual(escape(MyUnicode("foo")), MyUnicode.__name__)
 
     def test__escape__returns_unicode(self):
@@ -667,17 +667,17 @@ class Renderer_MakeRenderEngineTests(unittest.TestCase, AssertStringMixin, Asser
         engine = renderer._make_render_engine()
         escape = engine.escape
 
-        self.assertEqual(type(escape("foo")), unicode)
+        self.assertEqual(type(escape("foo")), str)
 
         # Check that literal doesn't preserve unicode subclasses.
-        class MyUnicode(unicode):
+        class MyUnicode(str):
             pass
 
         s = MyUnicode("abc")
 
         self.assertEqual(type(s), MyUnicode)
-        self.assertTrue(isinstance(s, unicode))
-        self.assertEqual(type(escape(s)), unicode)
+        self.assertTrue(isinstance(s, str))
+        self.assertEqual(type(escape(s)), str)
 
     ## Test the missing_tags attribute.
 
@@ -706,7 +706,7 @@ class Renderer_MakeRenderEngineTests(unittest.TestCase, AssertStringMixin, Asser
         stack = ContextStack({'foo': 'bar'})
 
         self.assertEqual('bar', engine.resolve_context(stack, 'foo'))
-        self.assertString(u'', engine.resolve_context(stack, 'missing'))
+        self.assertString('', engine.resolve_context(stack, 'missing'))
 
     def test__resolve_context__missing_tags_strict(self):
         """
diff --git a/pystache/tests/test_simple.py b/pystache/tests/test_simple.py
index 07b059f..b88bf35 100644
--- a/pystache/tests/test_simple.py
+++ b/pystache/tests/test_simple.py
@@ -2,11 +2,11 @@ import unittest
 
 import pystache
 from pystache import Renderer
-from examples.nested_context import NestedContext
-from examples.complex import Complex
-from examples.lambdas import Lambdas
-from examples.template_partial import TemplatePartial
-from examples.simple import Simple
+from .examples.nested_context import NestedContext
+from .examples.complex import Complex
+from .examples.lambdas import Lambdas
+from .examples.template_partial import TemplatePartial
+from .examples.simple import Simple
 
 from pystache.tests.common import EXAMPLES_DIR
 from pystache.tests.common import AssertStringMixin
@@ -20,7 +20,7 @@ class TestSimple(unittest.TestCase, AssertStringMixin):
         view.template = '{{#foo}}{{thing1}} and {{thing2}} and {{outer_thing}}{{/foo}}{{^foo}}Not foo!{{/foo}}'
 
         actual = renderer.render(view)
-        self.assertString(actual, u"one and foo and two")
+        self.assertString(actual, "one and foo and two")
 
     def test_looping_and_negation_context(self):
         template = '{{#item}}{{header}}: {{name}} {{/item}}{{^item}} Shouldnt see me{{/item}}'
@@ -40,7 +40,7 @@ class TestSimple(unittest.TestCase, AssertStringMixin):
 
         renderer = Renderer()
         actual = renderer.render(view)
-        self.assertString(actual, u'bar != bar. oh, it does!')
+        self.assertString(actual, 'bar != bar. oh, it does!')
 
     def test_rendering_partial(self):
         renderer = Renderer(search_dirs=EXAMPLES_DIR)
@@ -49,11 +49,11 @@ class TestSimple(unittest.TestCase, AssertStringMixin):
         view.template = '{{>inner_partial}}'
 
         actual = renderer.render(view)
-        self.assertString(actual, u'Again, Welcome!')
+        self.assertString(actual, 'Again, Welcome!')
 
         view.template = '{{#looping}}{{>inner_partial}} {{/looping}}'
         actual = renderer.render(view)
-        self.assertString(actual, u"Again, Welcome! Again, Welcome! Again, Welcome! ")
+        self.assertString(actual, "Again, Welcome! Again, Welcome! Again, Welcome! ")
 
     def test_non_existent_value_renders_blank(self):
         view = Simple()
@@ -77,7 +77,7 @@ class TestSimple(unittest.TestCase, AssertStringMixin):
         view = TemplatePartial(renderer=renderer)
 
         actual = renderer.render(view)
-        self.assertString(actual, u"""Welcome
+        self.assertString(actual, """Welcome
 -------
 
 ## Again, Welcome! ##""")
diff --git a/pystache/tests/test_specloader.py b/pystache/tests/test_specloader.py
index cacc0fc..dcdc55f 100644
--- a/pystache/tests/test_specloader.py
+++ b/pystache/tests/test_specloader.py
@@ -9,11 +9,11 @@ import os.path
 import sys
 import unittest
 
-import examples
-from examples.simple import Simple
-from examples.complex import Complex
-from examples.lambdas import Lambdas
-from examples.inverted import Inverted, InvertedLists
+from . import examples
+from .examples.simple import Simple
+from .examples.complex import Complex
+from .examples.lambdas import Lambdas
+from .examples.inverted import Inverted, InvertedLists
 from pystache import Renderer
 from pystache import TemplateSpec
 from pystache.common import TemplateNotFoundError
@@ -70,7 +70,7 @@ class ViewTestCase(unittest.TestCase, AssertStringMixin):
         renderer2 = Renderer(search_dirs=EXAMPLES_DIR)
 
         actual = renderer1.render(spec)
-        self.assertString(actual, u"Partial: ")
+        self.assertString(actual, "Partial: ")
 
         actual = renderer2.render(spec)
         self.assertEqual(actual, "Partial: No tags...")
@@ -79,7 +79,7 @@ class ViewTestCase(unittest.TestCase, AssertStringMixin):
         renderer = Renderer()
         actual = renderer.render(Simple())
 
-        self.assertString(actual, u"Hi pizza!")
+        self.assertString(actual, "Hi pizza!")
 
     def test_non_callable_attributes(self):
         view = Simple()
@@ -92,7 +92,7 @@ class ViewTestCase(unittest.TestCase, AssertStringMixin):
     def test_complex(self):
         renderer = Renderer()
         actual = renderer.render(Complex())
-        self.assertString(actual, u"""\
+        self.assertString(actual, """\
 <h1>Colors</h1>
 <ul>
 <li><strong>red</strong></li>
@@ -111,7 +111,7 @@ class ViewTestCase(unittest.TestCase, AssertStringMixin):
 
         renderer = Renderer()
         actual = renderer.render(view)
-        self.assertString(actual, u'nopqrstuvwxyz')
+        self.assertString(actual, 'nopqrstuvwxyz')
 
     def test_higher_order_lambda(self):
         view = Lambdas()
@@ -119,7 +119,7 @@ class ViewTestCase(unittest.TestCase, AssertStringMixin):
 
         renderer = Renderer()
         actual = renderer.render(view)
-        self.assertString(actual, u'abcdefghijklmnopqrstuvwxyz')
+        self.assertString(actual, 'abcdefghijklmnopqrstuvwxyz')
 
     def test_partials_with_lambda(self):
         view = Lambdas()
@@ -127,7 +127,7 @@ class ViewTestCase(unittest.TestCase, AssertStringMixin):
 
         renderer = Renderer(search_dirs=EXAMPLES_DIR)
         actual = renderer.render(view)
-        self.assertEqual(actual, u'nopqrstuvwxyz')
+        self.assertEqual(actual, 'nopqrstuvwxyz')
 
     def test_hierarchical_partials_with_lambdas(self):
         view = Lambdas()
@@ -135,12 +135,12 @@ class ViewTestCase(unittest.TestCase, AssertStringMixin):
 
         renderer = Renderer(search_dirs=EXAMPLES_DIR)
         actual = renderer.render(view)
-        self.assertString(actual, u'nopqrstuvwxyznopqrstuvwxyz')
+        self.assertString(actual, 'nopqrstuvwxyznopqrstuvwxyz')
 
     def test_inverted(self):
         renderer = Renderer()
         actual = renderer.render(Inverted())
-        self.assertString(actual, u"""one, two, three, empty list""")
+        self.assertString(actual, """one, two, three, empty list""")
 
     def test_accessing_properties_on_parent_object_from_child_objects(self):
         parent = Thing()
@@ -152,12 +152,12 @@ class ViewTestCase(unittest.TestCase, AssertStringMixin):
         renderer = Renderer()
         actual = renderer.render(view, {'parent': parent})
 
-        self.assertString(actual, u'derp')
+        self.assertString(actual, 'derp')
 
     def test_inverted_lists(self):
         renderer = Renderer()
         actual = renderer.render(InvertedLists())
-        self.assertString(actual, u"""one, two, three, empty list""")
+        self.assertString(actual, """one, two, three, empty list""")
 
 
 def _make_specloader():
@@ -176,7 +176,7 @@ def _make_specloader():
         """
         if encoding is None:
             encoding = 'ascii'
-        return unicode(s, encoding, 'strict')
+        return str(s, encoding, 'strict')
 
     loader = Loader(file_encoding='ascii', to_unicode=to_unicode)
     return SpecLoader(loader=loader)
@@ -222,7 +222,7 @@ class SpecLoaderTests(unittest.TestCase, AssertIsMixin, AssertStringMixin,
         custom.template = "abc"
 
         spec_loader = self._make_specloader()
-        self._assert_template(spec_loader, custom, u"abc")
+        self._assert_template(spec_loader, custom, "abc")
 
     def test_load__template__type_unicode(self):
         """
@@ -230,10 +230,10 @@ class SpecLoaderTests(unittest.TestCase, AssertIsMixin, AssertStringMixin,
 
         """
         custom = TemplateSpec()
-        custom.template = u"abc"
+        custom.template = "abc"
 
         spec_loader = self._make_specloader()
-        self._assert_template(spec_loader, custom, u"abc")
+        self._assert_template(spec_loader, custom, "abc")
 
     def test_load__template__unicode_non_ascii(self):
         """
@@ -241,10 +241,10 @@ class SpecLoaderTests(unittest.TestCase, AssertIsMixin, AssertStringMixin,
 
         """
         custom = TemplateSpec()
-        custom.template = u"é"
+        custom.template = "é"
 
         spec_loader = self._make_specloader()
-        self._assert_template(spec_loader, custom, u"é")
+        self._assert_template(spec_loader, custom, "é")
 
     def test_load__template__with_template_encoding(self):
         """
@@ -252,14 +252,14 @@ class SpecLoaderTests(unittest.TestCase, AssertIsMixin, AssertStringMixin,
 
         """
         custom = TemplateSpec()
-        custom.template = u'é'.encode('utf-8')
+        custom.template = 'é'.encode('utf-8')
 
         spec_loader = self._make_specloader()
 
-        self.assertRaises(UnicodeDecodeError, self._assert_template, spec_loader, custom, u'é')
+        self.assertRaises(UnicodeDecodeError, self._assert_template, spec_loader, custom, 'é')
 
         custom.template_encoding = 'utf-8'
-        self._assert_template(spec_loader, custom, u'é')
+        self._assert_template(spec_loader, custom, 'é')
 
     # TODO: make this test complete.
     def test_load__template__correct_loader(self):
@@ -279,10 +279,10 @@ class SpecLoaderTests(unittest.TestCase, AssertIsMixin, AssertStringMixin,
                 self.encoding = None
 
             # Overrides the existing method.
-            def unicode(self, s, encoding=None):
+            def str(self, s, encoding=None):
                 self.s = s
                 self.encoding = encoding
-                return u"foo"
+                return "foo"
 
         loader = MockLoader()
         custom_loader = SpecLoader()
@@ -293,7 +293,7 @@ class SpecLoaderTests(unittest.TestCase, AssertIsMixin, AssertStringMixin,
         view.template_encoding = "encoding-foo"
 
         # Check that our unicode() above was called.
-        self._assert_template(custom_loader, view, u'foo')
+        self._assert_template(custom_loader, view, 'foo')
         self.assertEqual(loader.s, "template-foo")
         self.assertEqual(loader.encoding, "encoding-foo")
 
@@ -410,7 +410,7 @@ class TemplateSpecTests(unittest.TestCase, AssertPathsMixin):
         loader = self._make_loader()
         actual = loader.load(custom)
 
-        self.assertEqual(type(actual), unicode)
+        self.assertEqual(type(actual), str)
         self.assertEqual(actual, expected)
 
     def test_get_template(self):
@@ -420,7 +420,7 @@ class TemplateSpecTests(unittest.TestCase, AssertPathsMixin):
         """
         view = SampleView()
 
-        self._assert_get_template(view, u"ascii: abc")
+        self._assert_get_template(view, "ascii: abc")
 
     def test_get_template__template_encoding(self):
         """
@@ -432,4 +432,4 @@ class TemplateSpecTests(unittest.TestCase, AssertPathsMixin):
         self.assertRaises(UnicodeDecodeError, self._assert_get_template, view, 'foo')
 
         view.template_encoding = 'utf-8'
-        self._assert_get_template(view, u"non-ascii: é")
+        self._assert_get_template(view, "non-ascii: é")
diff --git a/setup.cfg b/setup.cfg
index 861a9f5..f6f1279 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -1,5 +1,71 @@
-[egg_info]
-tag_build = 
-tag_date = 0
-tag_svn_revision = 0
+[metadata]
+name = pystache
+version = attr: pystache.__version__
+author = Chris Wanstrath
+author_email = chris@ozmm.org
+maintainer = Steve Arnold
+maintainer_email = nerdboy@gentoo.org
+description = Mustache for Python
+url = https://github.com/sarnold/pystache
+license = MIT
+license_files = LICENSE
+classifiers =
+    Development Status :: 4 - Beta
+    Intended Audience :: Developers
+    License :: OSI Approved :: MIT License
+    Programming Language :: Python :: 3
+    Programming Language :: Python :: 3.6
+    Programming Language :: Python :: 3.7
+    Programming Language :: Python :: 3.8
+    Programming Language :: Python :: 3.9
 
+[options]
+python_requires = >=3.6
+zip_safe = True
+include_package_data = True
+packages = find:
+
+[options.package_data]
+* = *.mustache, *.txt
+
+[options.entry_points]
+console_scripts =
+    pystache=pystache.commands.render:main
+    pystache-test=pystache.commands.test:main
+
+[options.extras_require]
+test =
+    nose
+
+cov =
+    coverage
+
+[bdist_wheel]
+universal = 0
+
+[check-manifest]
+ignore =
+    .codeclimate.yml
+    .gitattributes
+    .coveragerc
+    .gitignore
+    .pep8speaks.yml
+    codecov.yml
+
+[flake8]
+exclude =
+    .git,
+    __pycache__,
+    build,
+    dist
+
+max-line-length = 110
+
+[nosetests]
+traverse-namespace = 1
+verbosity = 3
+with-coverage = 1
+with-doctest = 1
+doctest-extension = rst
+cover-package = pystache
+cover-xml = 1
diff --git a/setup.py b/setup.py
index 0d99aae..f0b7d7f 100644
--- a/setup.py
+++ b/setup.py
@@ -28,7 +28,7 @@ it on the PyPI project page.  If PyPI finds any issues, it will render it
 instead as plain-text, which we do not want.
 
 To check in advance that PyPI will accept and parse the reST file as HTML,
-you can use the rst2html program installed by the docutils package
+you can use the rst2html.py program installed by the docutils package
 (http://docutils.sourceforge.net/).  To install docutils:
 
     $ pip install docutils
@@ -89,30 +89,7 @@ import os
 import shutil
 import sys
 
-
-py_version = sys.version_info
-
-# distutils does not seem to support the following setup() arguments.
-# It displays a UserWarning when setup() is passed those options:
-#
-#  * entry_points
-#  * install_requires
-#
-# distribute works with Python 2.3.5 and above:
-#
-#   http://packages.python.org/distribute/setuptools.html#building-and-distributing-packages-with-distribute
-#
-if py_version < (2, 3, 5):
-    # TODO: this might not work yet.
-    import distutils as dist
-    from distutils import core
-    setup = core.setup
-else:
-    import setuptools as dist
-    setup = dist.setup
-
-
-VERSION = '0.5.4'  # Also change in pystache/__init__.py.
+from setuptools import setup
 
 FILE_ENCODING = 'utf-8'
 
@@ -126,22 +103,6 @@ TEMP_EXTENSION = '.temp'
 
 PREP_COMMAND = 'prep'
 
-CLASSIFIERS = (
-    'Development Status :: 4 - Beta',
-    'License :: OSI Approved :: MIT License',
-    'Programming Language :: Python',
-    'Programming Language :: Python :: 2',
-    'Programming Language :: Python :: 2.4',
-    'Programming Language :: Python :: 2.5',
-    'Programming Language :: Python :: 2.6',
-    'Programming Language :: Python :: 2.7',
-    'Programming Language :: Python :: 3',
-    'Programming Language :: Python :: 3.1',
-    'Programming Language :: Python :: 3.2',
-    'Programming Language :: Python :: 3.3',
-    'Programming Language :: Python :: Implementation :: PyPy',
-)
-
 # Comments in reST begin with two dots.
 RST_LONG_DESCRIPTION_INTRO = """\
 .. Do not edit this file.  This file is auto-generated for PyPI by setup.py
@@ -221,7 +182,7 @@ def convert_md_to_rst(md_path, rst_temp_path):
 
     """
     # Pandoc uses the UTF-8 character encoding for both input and output.
-    command = "pandoc --write=rst --output=%s %s" % (rst_temp_path, md_path)
+    command = "pandoc -f markdown-smart --write=rst --output=%s %s" % (rst_temp_path, md_path)
     print("converting with pandoc: %s to %s\n-->%s" % (md_path, rst_temp_path,
                                                        command))
 
@@ -308,65 +269,9 @@ Run the following command and commit the changes--
     os.system('python setup.py sdist upload')
 
 
-# We use the package simplejson for older Python versions since Python
-# does not contain the module json before 2.6:
-#
-#   http://docs.python.org/library/json.html
-#
-# Moreover, simplejson stopped officially support for Python 2.4 in version 2.1.0:
-#
-#   https://github.com/simplejson/simplejson/blob/master/CHANGES.txt
-#
-requires = []
-if py_version < (2, 5):
-    requires.append('simplejson<2.1')
-elif py_version < (2, 6):
-    requires.append('simplejson')
-
-INSTALL_REQUIRES = requires
-
-# TODO: decide whether to use find_packages() instead.  I'm not sure that
-#   find_packages() is available with distutils, for example.
-PACKAGES = [
-    'pystache',
-    'pystache.commands',
-    # The following packages are only for testing.
-    'pystache.tests',
-    'pystache.tests.data',
-    'pystache.tests.data.locator',
-    'pystache.tests.examples',
-]
-
-
-# The purpose of this function is to follow the guidance suggested here:
-#
-#   http://packages.python.org/distribute/python3.html#note-on-compatibility-with-setuptools
-#
-# The guidance is for better compatibility when using setuptools (e.g. with
-# earlier versions of Python 2) instead of Distribute, because of new
-# keyword arguments to setup() that setuptools may not recognize.
-def get_extra_args():
-    """
-    Return a dictionary of extra args to pass to setup().
-
-    """
-    extra = {}
-    # TODO: it might be more correct to check whether we are using
-    #   Distribute instead of setuptools, since use_2to3 doesn't take
-    #   effect when using Python 2, even when using Distribute.
-    if py_version >= (3, ):
-        # Causes 2to3 to be run during the build step.
-        extra['use_2to3'] = True
-
-    return extra
-
-
 def main(sys_argv):
 
     # TODO: use the logging module instead of printing.
-    # TODO: include the following in a verbose mode.
-    sys.stderr.write("pystache: using: version %s of %s\n" % (repr(dist.__version__), repr(dist)))
-
     command = sys_argv[-1]
 
     if command == 'publish':
@@ -377,35 +282,10 @@ def main(sys_argv):
         sys.exit()
 
     long_description = read(RST_DESCRIPTION_PATH)
-    template_files = ['*.mustache', '*.txt']
-    extra_args = get_extra_args()
-
-    setup(name='pystache',
-          version=VERSION,
-          license='MIT',
-          description='Mustache for Python',
-          long_description=long_description,
-          author='Chris Wanstrath',
-          author_email='chris@ozmm.org',
-          maintainer='Chris Jerdonek',
-          maintainer_email='chris.jerdonek@gmail.com',
-          url='http://github.com/defunkt/pystache',
-          install_requires=INSTALL_REQUIRES,
-          packages=PACKAGES,
-          package_data = {
-              # Include template files so tests can be run.
-              'pystache.tests.data': template_files,
-              'pystache.tests.data.locator': template_files,
-              'pystache.tests.examples': template_files,
-          },
-          entry_points = {
-            'console_scripts': [
-                'pystache=pystache.commands.render:main',
-                'pystache-test=pystache.commands.test:main',
-            ],
-          },
-          classifiers = CLASSIFIERS,
-          **extra_args
+
+    setup(
+        long_description=long_description,
+        long_description_content_type='text/x-rst',
     )
 
 
diff --git a/setup_description.rst b/setup_description.rst
index 724c457..d7f1bc0 100644
--- a/setup_description.rst
+++ b/setup_description.rst
@@ -4,13 +4,17 @@
 Pystache
 ========
 
-.. figure:: http://defunkt.github.com/pystache/images/logo_phillips.png
-   :alt: mustachioed, monocled snake by David Phillips
+|ci| |Conda| |Wheels| |Release| |Python|
 
-.. figure:: https://secure.travis-ci.org/defunkt/pystache.png
-   :alt: Travis CI current build status
+|Latest release| |License| |Maintainability| |codecov|
 
-`Pystache <http://defunkt.github.com/pystache>`__ is a Python
+This updated fork of Pystache is currently tested on Python 3.6+ and in
+Conda, on Linux, Macos, and Windows (Python 2.7 support has been
+removed).
+
+|image9|
+
+`Pystache <http://sarnold.github.com/pystache>`__ is a Python
 implementation of `Mustache <http://mustache.github.com/>`__. Mustache
 is a framework-agnostic, logic-free templating system inspired by
 `ctemplate <http://code.google.com/p/google-ctemplate/>`__ and
@@ -23,62 +27,45 @@ page provides a good introduction to Mustache's syntax. For a more
 complete (and more current) description of Mustache's behavior, see the
 official `Mustache spec <https://github.com/mustache/spec>`__.
 
-Pystache is `semantically versioned <http://semver.org>`__ and can be
-found on `PyPI <http://pypi.python.org/pypi/pystache>`__. This version
-of Pystache passes all tests in `version
-1.1.2 <https://github.com/mustache/spec/tree/v1.1.2>`__ of the spec.
+Pystache is `semantically versioned <http://semver.org>`__ and older
+versions can still be found on
+`PyPI <http://pypi.python.org/pypi/pystache>`__. This version of
+Pystache now passes all tests in `version
+1.1.3 <https://github.com/mustache/spec/tree/v1.1.3>`__ of the spec.
 
 Requirements
 ------------
 
 Pystache is tested with--
 
--  Python 2.4 (requires simplejson `version
-   2.0.9 <http://pypi.python.org/pypi/simplejson/2.0.9>`__ or earlier)
--  Python 2.5 (requires
-   `simplejson <http://pypi.python.org/pypi/simplejson/>`__)
--  Python 2.6
--  Python 2.7
--  Python 3.1
--  Python 3.2
--  Python 3.3
--  `PyPy <http://pypy.org/>`__
+-  Python 3.6
+-  Python 3.7
+-  Python 3.8
+-  Python 3.9
+-  Conda (py36-py39)
 
 `Distribute <http://packages.python.org/distribute/>`__ (the setuptools
-fork) is recommended over
-`setuptools <http://pypi.python.org/pypi/setuptools>`__, and is required
-in some cases (e.g. for Python 3 support). If you use
-`pip <http://www.pip-installer.org/>`__, you probably already satisfy
-this requirement.
+fork) is no longer required over
+`setuptools <http://pypi.python.org/pypi/setuptools>`__, as the current
+packaging is now PEP517-compliant.
 
 JSON support is needed only for the command-line interface and to run
-the spec tests. We require simplejson for earlier versions of Python
-since Python's `json <http://docs.python.org/library/json.html>`__
-module was added in Python 2.6.
-
-For Python 2.4 we require an earlier version of simplejson since
-simplejson stopped officially supporting Python 2.4 in simplejson
-version 2.1.0. Earlier versions of simplejson can be installed manually,
-as follows:
-
-::
-
-    pip install 'simplejson<2.1.0'
+the spec tests; PyYAML can still be used (see the Develop section).
 
-Official support for Python 2.4 will end with Pystache version 0.6.0.
+Official support for Python 2 will end with Pystache version 0.6.0.
 
 Install It
 ----------
 
 ::
 
-    pip install pystache
+   pip install -U pystache -f https://github.com/sarnold/pystache/releases/
 
 And test it--
 
 ::
 
-    pystache-test
+   pystache-test
 
 To install and test from source (e.g. from GitHub), see the Develop
 section.
@@ -88,68 +75,68 @@ Use It
 
 ::
 
-    >>> import pystache
-    >>> print pystache.render('Hi {{person}}!', {'person': 'Mom'})
-    Hi Mom!
+   >>> import pystache
+   >>> print(pystache.render('Hi {{person}}!', {'person': 'Mom'}))
+   Hi Mom!
 
 You can also create dedicated view classes to hold your view logic.
 
-Here's your view class (in .../examples/readme.py):
+Here's your view class (in ../pystache/tests/examples/readme.py):
 
 ::
 
-    class SayHello(object):
-        def to(self):
-            return "Pizza"
+   class SayHello(object):
+       def to(self):
+           return "Pizza"
 
 Instantiating like so:
 
 ::
 
-    >>> from pystache.tests.examples.readme import SayHello
-    >>> hello = SayHello()
+   >>> from pystache.tests.examples.readme import SayHello
+   >>> hello = SayHello()
 
-Then your template, say\_hello.mustache (by default in the same
-directory as your class definition):
+Then your template, say_hello.mustache (by default in the same directory
+as your class definition):
 
 ::
 
-    Hello, {{to}}!
+   Hello, {{to}}!
 
 Pull it together:
 
 ::
 
-    >>> renderer = pystache.Renderer()
-    >>> print renderer.render(hello)
-    Hello, Pizza!
+   >>> renderer = pystache.Renderer()
+   >>> print(renderer.render(hello))
+   Hello, Pizza!
 
 For greater control over rendering (e.g. to specify a custom template
 directory), use the ``Renderer`` class like above. One can pass
 attributes to the Renderer class constructor or set them on a Renderer
 instance. To customize template loading on a per-view basis, subclass
 ``TemplateSpec``. See the docstrings of the
-`Renderer <https://github.com/defunkt/pystache/blob/master/pystache/renderer.py>`__
+`Renderer <https://github.com/sarnold/pystache/blob/master/pystache/renderer.py>`__
 class and
-`TemplateSpec <https://github.com/defunkt/pystache/blob/master/pystache/template_spec.py>`__
+`TemplateSpec <https://github.com/sarnold/pystache/blob/master/pystache/template_spec.py>`__
 class for more information.
 
 You can also pre-parse a template:
 
 ::
 
-    >>> parsed = pystache.parse(u"Hey {{#who}}{{.}}!{{/who}}")
-    >>> print parsed
-    [u'Hey ', _SectionNode(key=u'who', index_begin=12, index_end=18, parsed=[_EscapeNode(key=u'.'), u'!'])]
+   >>> parsed = pystache.parse(u"Hey {{#who}}{{.}}!{{/who}}")
+   >>> print(parsed)
+   ['Hey ', _SectionNode(key='who', index_begin=12, index_end=18, parsed=[_EscapeNode(key='.'), '!'])]
 
 And then:
 
 ::
 
-    >>> print renderer.render(parsed, {'who': 'Pops'})
-    Hey Pops!
-    >>> print renderer.render(parsed, {'who': 'you'})
-    Hey you!
+   >>> print(renderer.render(parsed, {'who': 'Pops'}))
+   Hey Pops!
+   >>> print(renderer.render(parsed, {'who': 'you'}))
+   Hey you!
 
 Python 3
 --------
@@ -211,22 +198,24 @@ To test from a source distribution (without installing)--
 
 ::
 
-    python test_pystache.py
+   python test_pystache.py
 
 To test Pystache with multiple versions of Python (with a single
-command!), you can use `tox <http://pypi.python.org/pypi/tox>`__:
+command!) and different platforms, you can use
+`tox <http://pypi.python.org/pypi/tox>`__:
 
 ::
 
-    pip install 'virtualenv<1.8'  # Version 1.8 dropped support for Python 2.4.
-    pip install 'tox<1.4'  # Version 1.4 dropped support for Python 2.4.
-    tox
+   pip install tox
+   tox -e setup
 
-If you do not have all Python versions listed in ``tox.ini``--
+To run tests on multiple versions with coverage, run:
 
 ::
 
-    tox -e py26,py32  # for example
+   tox -e py38-linux,py39-linux  # for example
+
+(substitute your platform above, eg, macos or windows)
 
 The source distribution tests also include doctests and tests from the
 Mustache spec. To include tests from the Mustache spec in your test
@@ -234,8 +223,8 @@ runs:
 
 ::
 
-    git submodule init
-    git submodule update
+   git submodule init
+   git submodule update
 
 The test harness parses the spec's (more human-readable) yaml files if
 `PyYAML <http://pypi.python.org/pypi/PyYAML>`__ is present. Otherwise,
@@ -243,94 +232,113 @@ it parses the json files. To install PyYAML--
 
 ::
 
-    pip install pyyaml
+   pip install pyyaml
+
+Once the submodule is available, you can run the full test set with:
+
+::
+
+   tox -e setup . ext/spec/specs
 
 To run a subset of the tests, you can use
 `nose <http://somethingaboutorange.com/mrl/projects/nose/0.11.1/testing.html>`__:
 
 ::
 
-    pip install nose
-    nosetests --tests pystache/tests/test_context.py:GetValueTests.test_dictionary__key_present
+   pip install nose
+   nosetests --tests pystache/tests/test_context.py:GetValueTests.test_dictionary__key_present
 
-Using Python 3 with Pystache from source
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Mailing List (old)
+------------------
 
-Pystache is written in Python 2 and must be converted to Python 3 prior
-to using it with Python 3. The installation process (and tox) do this
-automatically.
+There is(was) a `mailing
+list <http://librelist.com/browser/pystache/>`__. Note that there is a
+bit of a delay between posting a message and seeing it appear in the
+mailing list archive.
 
-To convert the code to Python 3 manually (while using Python 3)--
+Credits
+-------
 
 ::
 
-    python setup.py build
+   >>> import pystache
+   >>> context = { 'author': 'Chris Wanstrath', 'maintainer': 'Chris Jerdonek','refurbisher': 'Steve Arnold' }
+   >>> print(pystache.render("Author: {{author}}\nMaintainer: {{maintainer}}\nRefurbisher: {{refurbisher}}", context))
+   Author: Chris Wanstrath
+   Maintainer: Chris Jerdonek
+   Refurbisher: Steve Arnold
 
-This writes the converted code to a subdirectory called ``build``. By
-design, Python 3 builds
-`cannot <https://bitbucket.org/tarek/distribute/issue/292/allow-use_2to3-with-python-2>`__
-be created from Python 2.
+Pystache logo by `David Phillips <http://davidphillips.us/>`__ is
+licensed under a `Creative Commons Attribution-ShareAlike 3.0 Unported
+License <http://creativecommons.org/licenses/by-sa/3.0/deed.en_US>`__.
+|image10|
 
-To convert the code without using setup.py, you can use
-`2to3 <http://docs.python.org/library/2to3.html>`__ as follows (two
-steps)--
+History
+=======
 
-::
+**Note:** Official support for Python 2.7 will end with Pystache version
+0.6.0.
 
-    2to3 --write --nobackups --no-diffs --doctests_only pystache
-    2to3 --write --nobackups --no-diffs pystache
+0.6.0 (2021-03-04)
+------------------
 
-This converts the code (and doctests) in place.
+-  Bump spec versions to latest => v1.1.3
+-  Modernize python and CI tools, update docs/doctests
+-  Update unicode conversion test for py3-only
+-  Add pep8speaks cfg, cleanup warnings
+-  Remove superfluous setup test/unused imports
+-  Add conda recipe/CI build
 
-To ``import pystache`` from a source distribution while using Python 3,
-be sure that you are importing from a directory containing a converted
-version of the code (e.g. from the ``build`` directory after
-converting), and not from the original (unconverted) source directory.
-Otherwise, you will get a syntax error. You can help prevent this by not
-running the Python IDE from the project directory when importing
-Pystache while using Python 3.
+.. _section-1:
 
-Mailing List
-------------
+0.5.6 (2021-02-28)
+------------------
 
-There is a `mailing list <http://librelist.com/browser/pystache/>`__.
-Note that there is a bit of a delay between posting a message and seeing
-it appear in the mailing list archive.
+-  Use correct wheel name in release workflow, limit wheels
+-  Add install check/test of downloaded wheel
+-  Update/add ci workflows and tox cfg, bump to next dev0 version
 
-Credits
--------
+.. _section-2:
 
-::
+0.5.5 (2020-12-16)
+------------------
 
-    >>> context = { 'author': 'Chris Wanstrath', 'maintainer': 'Chris Jerdonek' }
-    >>> print pystache.render("Author: {{author}}\nMaintainer: {{maintainer}}", context)
-    Author: Chris Wanstrath
-    Maintainer: Chris Jerdonek
+-  fix document processing, update pandoc args and history
+-  add release.yml to CI, test env settings
+-  fix bogus commit message, update versions and tox cf
+-  add post-test steps for building pkgs with/without doc updates
+-  add CI build check, fix MANIFEST.in pruning
 
-Pystache logo by `David Phillips <http://davidphillips.us/>`__ is
-licensed under a `Creative Commons Attribution-ShareAlike 3.0 Unported
-License <http://creativecommons.org/licenses/by-sa/3.0/deed.en_US>`__.
-|image0|
+.. _section-3:
 
-History
-=======
+0.5.4-2 (2020-11-09)
+--------------------
 
-**Note:** Official support for Python 2.4 will end with Pystache version
-0.6.0.
+-  Merge pull request #1 from sarnold/rebase-up
+-  Bugfix: test_specloader.py: fix test_find__with_directory on other
+   OSs
+-  Bugfix: pystache/loader.py: remove stray windows line-endings
+-  fix crufty (and insecure) http urls
+-  Bugfix: modernize python versions (keep py27) and fix spec_test load
+   cmd
+
+.. _section-4:
 
 0.5.4 (2014-07-11)
 ------------------
 
 -  Bugfix: made test with filenames OS agnostic (issue #162).
 
+.. _section-5:
+
 0.5.3 (2012-11-03)
 ------------------
 
 -  Added ability to customize string coercion (e.g. to have None render
    as ``''``) (issue #130).
--  Added Renderer.render\_name() to render a template by name (issue
+-  Added Renderer.render_name() to render a template by name (issue
    #122).
--  Added TemplateSpec.template\_path to specify an absolute path to a
+-  Added TemplateSpec.template_path to specify an absolute path to a
    template (issue #41).
 -  Added option of raising errors on missing tags/partials:
    ``Renderer(missing_tags='strict')`` (issue #110).
@@ -355,6 +363,8 @@ History
 -  More robust handling of byte strings in Python 3.
 -  Added Creative Commons license for David Phillips's logo.
 
+.. _section-6:
+
 0.5.2 (2012-05-03)
 ------------------
 
@@ -367,16 +377,20 @@ History
    context stack (issue #113).
 -  Bugfix: lists of lambdas for sections were not rendered (issue #114).
 
+.. _section-7:
+
 0.5.1 (2012-04-24)
 ------------------
 
 -  Added support for Python 3.1 and 3.2.
 -  Added tox support to test multiple Python versions.
 -  Added test script entry point: pystache-test.
--  Added \_\_version\_\_ package attribute.
+-  Added \__version_\_ package attribute.
 -  Test harness now supports both YAML and JSON forms of Mustache spec.
 -  Test harness no longer requires nose.
 
+.. _section-8:
+
 0.5.0 (2012-04-03)
 ------------------
 
@@ -435,11 +449,15 @@ Bug fixes:
 -  Passing ``**kwargs`` to ``Template()`` with no context no longer
    raises an exception.
 
+.. _section-9:
+
 0.4.1 (2012-03-25)
 ------------------
 
 -  Added support for Python 2.4. [wangtz, jvantuyl]
 
+.. _section-10:
+
 0.4.0 (2011-01-12)
 ------------------
 
@@ -447,19 +465,25 @@ Bug fixes:
 -  Add support for inverted lists
 -  Decoupled template loading
 
+.. _section-11:
+
 0.3.1 (2010-05-07)
 ------------------
 
 -  Fix package
 
+.. _section-12:
+
 0.3.0 (2010-05-03)
 ------------------
 
--  View.template\_path can now hold a list of path
+-  View.template_path can now hold a list of path
 -  Add {{& blah}} as an alias for {{{ blah }}}
 -  Higher Order Sections
 -  Inverted sections
 
+.. _section-13:
+
 0.2.0 (2010-02-15)
 ------------------
 
@@ -473,12 +497,16 @@ Bug fixes:
    [enaeseth]
 -  Template file encoding awareness. [enaeseth]
 
+.. _section-14:
+
 0.1.1 (2009-11-13)
 ------------------
 
 -  Ensure we're dealing with strings, always
 -  Tests can be run by executing the test file directly
 
+.. _section-15:
+
 0.1.0 (2009-11-12)
 ------------------
 
@@ -510,4 +538,23 @@ CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-.. |image0| image:: http://i.creativecommons.org/l/by-sa/3.0/88x31.png
+.. |ci| image:: https://github.com/sarnold/pystache/actions/workflows/ci.yml/badge.svg
+   :target: https://github.com/sarnold/pystache/actions/workflows/ci.yml
+.. |Conda| image:: https://github.com/sarnold/pystache/actions/workflows/conda.yml/badge.svg
+   :target: https://github.com/sarnold/pystache/actions/workflows/conda.yml
+.. |Wheels| image:: https://github.com/sarnold/pystache/actions/workflows/wheels.yml/badge.svg
+   :target: https://github.com/sarnold/pystache/actions/workflows/wheels.yml
+.. |Release| image:: https://github.com/sarnold/pystache/actions/workflows/release.yml/badge.svg
+   :target: https://github.com/sarnold/pystache/actions/workflows/release.yml
+.. |Python| image:: https://img.shields.io/badge/python-3.6+-blue.svg
+   :target: https://www.python.org/downloads/
+.. |Latest release| image:: https://img.shields.io/github/v/release/sarnold/pystache?include_prereleases
+   :target: https://github.com/sarnold/pystache/releases/latest
+.. |License| image:: https://img.shields.io/github/license/sarnold/pystache
+   :target: https://github.com/sarnold/pystache/blob/master/LICENSE
+.. |Maintainability| image:: https://api.codeclimate.com/v1/badges/a8fa1bf4638bfc6581b6/maintainability
+   :target: https://codeclimate.com/github/sarnold/pystache/maintainability
+.. |codecov| image:: https://codecov.io/gh/sarnold/pystache/branch/master/graph/badge.svg?token=5PZNMZBI6K
+   :target: https://codecov.io/gh/sarnold/pystache
+.. |image9| image:: gh/images/logo_phillips_small.png
+.. |image10| image:: http://i.creativecommons.org/l/by-sa/3.0/88x31.png
diff --git a/tox.ini b/tox.ini
index d1eaebf..66c4515 100644
--- a/tox.ini
+++ b/tox.ini
@@ -1,36 +1,110 @@
-# A tox configuration file to test across multiple Python versions.
-#
-#   http://pypi.python.org/pypi/tox
-#
 [tox]
-# Tox 1.4 drops py24 and adds py33.  In the current version, we want to
-# support 2.4, so we can't simultaneously support 3.3.
-envlist = py24,py25,py26,py27,py27-yaml,py27-noargs,py31,py32,pypy
+envlist = py{36,37,38,39}-{linux,macos,windows}
+skip_missing_interpreters = true
+isolated_build = true
+#skipsdist = true
+
+[gh-actions]
+python =
+    3.6: py36
+    3.7: py37
+    3.8: py38
+    3.9: py39
+
+[gh-actions:env]
+PLATFORM =
+    ubuntu-18.04: linux
+    macos-latest: macos
+    windows-latest: windows
 
 [testenv]
+passenv = CI PYTHON PYTHONIOENCODING
+
+deps =
+    pip>=20.0.1
+    nose
+    coverage
+
+commands =
+    nosetests -sx . {posargs}
+
+[testenv:bare]
 # Change the working directory so that we don't import the pystache located
 # in the original location.
+deps =
+    pip>=20.0.1
+    -e .
+
 changedir =
     {envbindir}
+
 commands =
-    pystache-test {toxinidir}
+    pystache-test
+
+[testenv:bench]
+passenv = CI PYTHON PYTHONIOENCODING
 
-# Check that the spec tests work with PyYAML.
-[testenv:py27-yaml]
-basepython =
-    python2.7
 deps =
-    PyYAML
-changedir =
-    {envbindir}
+    pip>=20.0.1
+    # uncomment for comparison, posargs expects a number, eg, 10000
+    #chevron
+
+commands_pre =
+    pip install .
+
 commands =
-    pystache-test {toxinidir}
+    python pystache/tests/benchmark.py {posargs}
+
+[testenv:setup]
+passenv = CI PYTHON PYTHONIOENCODING
+
+deps =
+    pyyaml
+    twine
+
+commands =
+    python setup.py install
+    twine check dist/*
+    pystache-test {posargs}
+
+[testenv:deploy]
+passenv = CI PYTHON PYTHONIOENCODING
+allowlist_externals = bash
+
+deps =
+    pip>=19.0.1
+    wheel
+    pep517
+    twine
+
+commands =
+    python -m pep517.build .
+    twine check dist/*
+
+[testenv:check]
+passenv = CI PYTHON PYTHONIOENCODING
+skip_install = true
+
+allowlist_externals = bash
+
+deps =
+    pip>=20.0.1
 
-# Check that pystache-test works from an install with no arguments.
-[testenv:py27-noargs]
-basepython =
-    python2.7
-changedir =
-    {envbindir}
 commands =
+    bash -c 'export WHL_FILE=$(ls dist/*.whl); \
+        python -m pip install $WHL_FILE'
     pystache-test
+
+[testenv:docs]
+passenv = CI PYTHON PYTHONIOENCODING
+allowlist_externals = bash
+
+deps =
+    pip>=19.0.1
+    wheel
+    docutils
+    # apt/emerge pandoc first
+
+commands =
+    python setup.py prep
+    bash -c 'python setup.py --long-description | rst2html.py -v --no-raw > out.html'
diff --git a/travis.yml_disabled b/travis.yml_disabled
new file mode 100644
index 0000000..f0b4042
--- /dev/null
+++ b/travis.yml_disabled
@@ -0,0 +1,52 @@
+dist: xenial
+language: python
+
+# Travis CI has no plans to support Jython and no longer supports Python 2.5.
+python:
+  - "2.7"
+  - "3.5"
+  - "3.6"
+  - "3.7"
+  - "3.8"
+  - "3.9-dev"
+  - "nightly"
+
+matrix:
+  fast_finish: true
+  include:
+    - os: osx
+      # osx is goofy, ``python`` is always py2, images mutate fast
+      language: shell
+      before_install:
+        - pip3 install --upgrade pip wheel
+      install:
+        - python3 setup.py install
+      script:
+        - pystache-test . ext/spec/specs
+    - os: windows
+      # windows is even goofier, install path is different for python/python3
+      # but either way you get python3 and the cmd is always ``python``  o.O 
+      # (also versions mutuate like bacteria)
+      language: shell
+      before_install:
+        - choco install python3 --params "/InstallDir:C:\\Python"
+        - python -m pip install --upgrade pip wheel
+      env: PATH="/c/Python:/c/Python/Scripts:$PATH"
+      install:
+        - python setup.py install
+      script:
+        - pystache-test . ext/spec/specs
+  allow_failures:
+    - python: "nightly"
+
+# command to install dependencies
+install:
+  - pip install --upgrade pip
+  - pip install codecov
+
+script:
+  - python setup.py install
+  # Include the spec tests directory for Mustache spec tests and the
+  # project directory for doctests.
+  - pystache-test . ext/spec/specs
+  #- tox
-- 
2.33.0