Merge pull request #40 from tacaswell/fix_py311

API: drop py27 + support py311 + migrate nose -> pytest + migrate travis -> GHA

Author: danielballan

.codecov.yml

@@ -0,0 +1,10 @@
+# show coverage in CI status, not as a comment.
+comment: off
+coverage:
+  status:
+    project:
+      default:
+        target: auto
+    patch:
+      default:
+        target: auto

.coveragerc

@@ -0,0 +1,13 @@
+[run]
+source =
+    slicerator
+[report]
+omit =
+    */python?.?/*
+    */site-packages/nose/*
+    # ignore _version.py and versioneer.py
+    .*version.*
+    *_version.py
+
+exclude_lines =
+    if __name__ == '__main__':

.github/workflows/testing.yml

@@ -0,0 +1,44 @@
+name: Unit Tests
+
+on:
+  push:
+  pull_request:
+  schedule:
+      - cron: '00 4 * * *'  # daily at 4AM
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ['3.7', '3.8', '3.9', '3.10']
+      fail-fast: false
+    steps:
+
+    - 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 test requirements
+      shell: bash -l {0}
+      run: |
+        set -vxeuo pipefail
+        python -m pip install -r requirements-dev.txt
+        python -m pip install -v .
+        python -m pip list
+
+    - name: Test with pytest
+      shell: bash -l {0}
+      run: |
+        set -vxeuo pipefail
+        coverage run -m pytest -v
+        coverage report
+
+    - name: Upload code coverage
+      uses: codecov/codecov-action@v1

.travis.yml

@@ -0,0 +1,8 @@
+# These are required for developing the package (running the tests, building
+# the documentation) but not necessarily required for _using_ it.
+black
+codecov
+coverage
+flake8
+numpy
+pytest

requirements-dev.txt

@@ -20,7 +20,6 @@
       packages=['slicerator'],
       description='A lazy-loading, fancy-sliceable iterable.',
       url='http://github.com/soft-matter/slicerator',
-      install_requires=['six'],
       cmdclass=versioneer.get_cmdclass(),
       platforms='Cross platform (Linux, Mac OSX, Windows)',
       license="BSD",

run_tests.py

@@ -1,7 +1,6 @@
 from __future__ import (absolute_import, division, print_function,
                         unicode_literals)
 
-from six.moves import range
 import collections.abc
 import itertools
 from functools import wraps

setup.py

@@ -5,10 +5,9 @@
 import numpy as np
 import random
 import types
-import nose
-from six import BytesIO
+from io import BytesIO
 import pickle
-from nose.tools import assert_true, assert_false, assert_equal, assert_raises
+import pytest
 from numpy.testing import assert_array_equal
 from slicerator import Slicerator, Pipeline, pipeline, index_attr, propagate_attr
 
@@ -18,9 +17,9 @@
 
 def assert_letters_equal(actual, expected):
     # check if both lengths are equal
-    assert_equal(len(actual), len(expected))
+    assert len(actual) == len(expected)
     for actual_, expected_ in zip(actual, expected):
-        assert_equal(actual_, expected_)
+        assert actual_ == expected_
 
 
 def compare_slice_to_list(actual, expected):
@@ -134,11 +133,11 @@ def test_slice_with_generator():
     compare_slice_to_list(slice1, list('bcdefghij'))
     slice2 = slice1[(i for i in range(2, 5))]
     assert_letters_equal(list(slice2), list('def'))
-    assert_true(isinstance(slice2, types.GeneratorType))
+    assert isinstance(slice2, types.GeneratorType)
 
 
 def test_no_len_raises():
-    with assert_raises(ValueError):
+    with pytest.raises(ValueError):
         Slicerator((i for i in range(5)), (i for i in range(5)))
 
 def test_from_func():
@@ -174,8 +173,8 @@ def test_inplace_pipeline():
     n_mutable = Slicerator([list([i]) for i in range(10)])
     appended = append_zero_inplace(n_mutable)
 
-    assert_equal(appended[5], [5, 0])  # execute the function
-    assert_equal(n_mutable[5], [5])    # check the original
+    assert appended[5] == [5, 0]  # execute the function
+    assert n_mutable[5] == [5]    # check the original
 
 
 def test_pipeline_simple():
@@ -231,12 +230,12 @@ def close(self):
 
     a = Slicerator(MyList('abcdefghij'), propagate_attrs=['attr1', 's'])
     assert_letters_equal(a, list('abcdefghij'))
-    assert_true(hasattr(a, 'attr1'))
-    assert_false(hasattr(a, 'attr2'))
-    assert_true(hasattr(a, 's'))
-    assert_false(hasattr(a, 'close'))
-    assert_equal(a.attr1, 'hello')
-    with assert_raises(AttributeError):
+    assert hasattr(a, 'attr1')
+    assert not hasattr(a, 'attr2')
+    assert hasattr(a, 's')
+    assert not hasattr(a, 'close')
+    assert a.attr1 == 'hello'
+    with pytest.raises(AttributeError):
         a[:5].nonexistent_attr
 
     compare_slice_to_list(list(a.s), list('ABCDEFGHIJ'))
@@ -246,12 +245,12 @@ def close(self):
     capitalize = pipeline(_capitalize)
     b = capitalize(a)
     assert_letters_equal(b, list('ABCDEFGHIJ'))
-    assert_true(hasattr(b, 'attr1'))
-    assert_false(hasattr(b, 'attr2'))
-    assert_true(hasattr(b, 's'))
-    assert_false(hasattr(b, 'close'))
-    assert_equal(b.attr1, 'hello')
-    with assert_raises(AttributeError):
+    assert hasattr(b, 'attr1')
+    assert not hasattr(b, 'attr2')
+    assert hasattr(b, 's')
+    assert not hasattr(b, 'close')
+    assert b.attr1 == 'hello'
+    with pytest.raises(AttributeError):
         b[:5].nonexistent_attr
 
     compare_slice_to_list(list(b.s), list('ABCDEFGHIJ'))
@@ -299,35 +298,35 @@ def attr4(self):
 
     dummy = Dummy()
     subclass = SubClass()
-    assert_true(hasattr(dummy, 'attr1'))
-    assert_true(hasattr(dummy, 'attr2'))
-    assert_true(hasattr(dummy, 'attr3'))
-    assert_false(hasattr(dummy, 'attr4'))
+    assert hasattr(dummy, 'attr1')
+    assert hasattr(dummy, 'attr2')
+    assert hasattr(dummy, 'attr3')
+    assert not hasattr(dummy, 'attr4')
 
-    assert_true(hasattr(dummy[1:], 'attr1'))
-    assert_true(hasattr(dummy[1:], 'attr2'))
-    assert_false(hasattr(dummy[1:], 'attr3'))
-    assert_false(hasattr(dummy[1:], 'attr4'))
+    assert hasattr(dummy[1:], 'attr1')
+    assert hasattr(dummy[1:], 'attr2')
+    assert not hasattr(dummy[1:], 'attr3')
+    assert not hasattr(dummy[1:], 'attr4')
 
-    assert_true(hasattr(dummy[1:][1:], 'attr1'))
-    assert_true(hasattr(dummy[1:][1:], 'attr2'))
-    assert_false(hasattr(dummy[1:][1:], 'attr3'))
-    assert_false(hasattr(dummy[1:][1:], 'attr4'))
+    assert hasattr(dummy[1:][1:], 'attr1')
+    assert hasattr(dummy[1:][1:], 'attr2')
+    assert not hasattr(dummy[1:][1:], 'attr3')
+    assert not hasattr(dummy[1:][1:], 'attr4')
 
-    assert_true(hasattr(subclass, 'attr1'))
-    assert_true(hasattr(subclass, 'attr2'))
-    assert_true(hasattr(subclass, 'attr3'))
-    assert_true(hasattr(subclass, 'attr4'))
+    assert hasattr(subclass, 'attr1')
+    assert hasattr(subclass, 'attr2')
+    assert hasattr(subclass, 'attr3')
+    assert hasattr(subclass, 'attr4')
 
-    assert_false(hasattr(subclass[1:], 'attr1'))
-    assert_true(hasattr(subclass[1:], 'attr2'))
-    assert_false(hasattr(subclass[1:], 'attr3'))
-    assert_true(hasattr(subclass[1:], 'attr4'))
+    assert not hasattr(subclass[1:], 'attr1')
+    assert hasattr(subclass[1:], 'attr2')
+    assert not hasattr(subclass[1:], 'attr3')
+    assert hasattr(subclass[1:], 'attr4')
 
-    assert_false(hasattr(subclass[1:][1:], 'attr1'))
-    assert_true(hasattr(subclass[1:][1:], 'attr2'))
-    assert_false(hasattr(subclass[1:][1:], 'attr3'))
-    assert_true(hasattr(subclass[1:][1:], 'attr4'))
+    assert not hasattr(subclass[1:][1:], 'attr1')
+    assert hasattr(subclass[1:][1:], 'attr2')
+    assert not hasattr(subclass[1:][1:], 'attr3')
+    assert hasattr(subclass[1:][1:], 'attr4')
 
 
 def test_pipeline_with_args():
@@ -552,8 +551,3 @@ def test_pipeline_propagate_attrs():
         pass
     else:
         raise AssertionError("attr2 should not exist")
-
-
-if __name__ == '__main__':
-    nose.runmodule(argv=[__file__, '-vvs', '-x', '--pdb', '--pdb-failure'],
-                   exit=False)

slicerator/__init__.py

@@ -339,9 +339,8 @@ def get_config_from_root(root):
     # configparser.NoOptionError (if it lacks "VCS="). See the docstring at
     # the top of versioneer.py for instructions on writing your setup.cfg .
     setup_cfg = os.path.join(root, "setup.cfg")
-    parser = configparser.SafeConfigParser()
-    with open(setup_cfg, "r") as f:
-        parser.readfp(f)
+    parser = configparser.ConfigParser()
+    parser.read(setup_cfg)
     VCS = parser.get("versioneer", "VCS")  # mandatory
 
     def get(parser, name):