diff options
Diffstat (limited to 'meta-openembedded/meta-python/recipes-devtools/python/python3-pystache/0001-Modernize-python-versions-remove-py2x-and-fix-tests-.patch')
| -rw-r--r-- | meta-openembedded/meta-python/recipes-devtools/python/python3-pystache/0001-Modernize-python-versions-remove-py2x-and-fix-tests-.patch | 4150 |
1 files changed, 4150 insertions, 0 deletions
diff --git a/meta-openembedded/meta-python/recipes-devtools/python/python3-pystache/0001-Modernize-python-versions-remove-py2x-and-fix-tests-.patch b/meta-openembedded/meta-python/recipes-devtools/python/python3-pystache/0001-Modernize-python-versions-remove-py2x-and-fix-tests-.patch new file mode 100644 index 0000000000..d268cc5cd9 --- /dev/null +++ b/meta-openembedded/meta-python/recipes-devtools/python/python3-pystache/0001-Modernize-python-versions-remove-py2x-and-fix-tests-.patch @@ -0,0 +1,4150 @@ +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. --> +- ++[](https://github.com/sarnold/pystache/actions/workflows/ci.yml) ++[](https://github.com/sarnold/pystache/actions/workflows/conda.yml) ++[](https://github.com/sarnold/pystache/actions/workflows/wheels.yml) ++[](https://github.com/sarnold/pystache/actions/workflows/release.yml) ++[](https://www.python.org/downloads/) + +- ++[](https://github.com/sarnold/pystache/releases/latest) ++[](https://github.com/sarnold/pystache/blob/master/LICENSE) ++[](https://codeclimate.com/github/sarnold/pystache/maintainability) ++[](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). ++ ++ ++ ++[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"<") ++ self.assertString(actual, "<") + + 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 > Shark</h1>") ++ self._assert(Escaped(), "<h1>Bear > 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'<>', template, context) ++ self._assert_render('<>', 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: <', template, context, engine=engine, partials=partials) ++ self._assert_render( ++ 'unescaped: < escaped: <', ++ 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: <', template, context, engine=engine) ++ self._assert_render('unescaped: < escaped: <', 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 + |