Fixed database typo and removed unnecessary class identifier.

venv/Lib/site-packages/skimage/_shared/tests/__init__.py

@@ -0,0 +1,9 @@
+from ..testing import setup_test, teardown_test
+
+
+def setup():
+    setup_test()
+
+
+def teardown():
+    teardown_test()

venv/Lib/site-packages/skimage/_shared/tests/test_fast_exp.py

@@ -0,0 +1,21 @@
+from ..fast_exp import fast_exp
+import numpy as np
+
+
+def test_fast_exp():
+
+    X = np.linspace(-5, 0, 5000, endpoint=True)
+
+    # Ground truth
+    Y = np.exp(X)
+
+    # Approximation at double precision
+    _y_f64 = np.array([fast_exp['float64_t'](x) for x in X])
+
+    # Approximation at single precision
+    _y_f32 = np.array([fast_exp['float32_t'](x) for x in X.astype('float32')],
+                      dtype='float32')
+
+    for _y in [_y_f64, _y_f32]:
+
+        assert np.abs(Y - _y).mean() < 3e-3

venv/Lib/site-packages/skimage/_shared/tests/test_geometry.py

@@ -0,0 +1,75 @@
+from skimage._shared._geometry import polygon_clip, polygon_area
+
+import numpy as np
+from numpy.testing import assert_equal, assert_almost_equal
+
+
+hand = np.array(
+    [[ 1.64516129,  1.16145833 ],
+     [ 1.64516129,  1.59375    ],
+     [ 1.35080645,  1.921875   ],
+     [ 1.375     ,  2.18229167 ],
+     [ 1.68548387,  1.9375     ],
+     [ 1.60887097,  2.55208333 ],
+     [ 1.68548387,  2.69791667 ],
+     [ 1.76209677,  2.56770833 ],
+     [ 1.83064516,  1.97395833 ],
+     [ 1.89516129,  2.75       ],
+     [ 1.9516129 ,  2.84895833 ],
+     [ 2.01209677,  2.76041667 ],
+     [ 1.99193548,  1.99479167 ],
+     [ 2.11290323,  2.63020833 ],
+     [ 2.2016129 ,  2.734375   ],
+     [ 2.25403226,  2.60416667 ],
+     [ 2.14919355,  1.953125   ],
+     [ 2.30645161,  2.36979167 ],
+     [ 2.39112903,  2.36979167 ],
+     [ 2.41532258,  2.1875     ],
+     [ 2.1733871 ,  1.703125   ],
+     [ 2.07782258,  1.16666667 ]])
+
+
+def test_polygon_area():
+    x = [0, 0, 1, 1]
+    y = [0, 1, 1, 0]
+
+    assert_almost_equal(polygon_area(y, x), 1)
+
+    x = [0, 0, 1]
+    y = [0, 1, 1]
+
+    assert_almost_equal(polygon_area(y, x), 0.5)
+
+    x = [0, 0, 0.5, 1, 1, 0.5]
+    y = [0, 1, 0.5, 1, 0, 0.5]
+
+    assert_almost_equal(polygon_area(y, x), 0.5)
+
+
+def test_poly_clip():
+    x = [0,  1, 2, 1]
+    y = [0, -1, 0, 1]
+
+    yc, xc = polygon_clip(y, x, 0, 0, 1, 1)
+    assert_equal(polygon_area(yc, xc), 0.5)
+
+    x = [-1, 1.5, 1.5, -1]
+    y = [.5, 0.5, 1.5, 1.5]
+    yc, xc = polygon_clip(y, x, 0, 0, 1, 1)
+    assert_equal(polygon_area(yc, xc), 0.5)
+
+
+def test_hand_clip():
+    (r0, c0, r1, c1) = (1.0, 1.5, 2.1, 2.5)
+    clip_r, clip_c = polygon_clip(hand[:, 1], hand[:, 0], r0, c0, r1, c1)
+    assert_equal(clip_r.size, 19)
+    assert_equal(clip_r[0], clip_r[-1])
+    assert_equal(clip_c[0], clip_c[-1])
+
+    (r0, c0, r1, c1) = (1.0, 1.5, 1.7, 2.5)
+    clip_r, clip_c = polygon_clip(hand[:, 1], hand[:, 0], r0, c0, r1, c1)
+    assert_equal(clip_r.size, 6)
+
+    (r0, c0, r1, c1) = (1.0, 1.5, 1.5, 2.5)
+    clip_r, clip_c = polygon_clip(hand[:, 1], hand[:, 0], r0, c0, r1, c1)
+    assert_equal(clip_r.size, 5)

venv/Lib/site-packages/skimage/_shared/tests/test_interpolation.py

@@ -0,0 +1,27 @@
+from skimage._shared.interpolation import coord_map_py
+from skimage._shared.testing import assert_array_equal
+
+def test_coord_map():
+    symmetric = [coord_map_py(4, n, 'S') for n in range(-6, 6)]
+    expected_symmetric = [2, 3, 3, 2, 1, 0, 0, 1, 2, 3, 3, 2]
+    assert_array_equal(symmetric, expected_symmetric)
+
+    wrap = [coord_map_py(4, n, 'W') for n in range(-6, 6)]
+    expected_wrap = [2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1]
+    assert_array_equal(wrap, expected_wrap)
+
+    edge = [coord_map_py(4, n, 'E') for n in range(-6, 6)]
+    expected_edge = [0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 3, 3]
+    assert_array_equal(edge, expected_edge)
+
+    reflect = [coord_map_py(4, n, 'R') for n in range(-6, 6)]
+    expected_reflect = [0, 1, 2, 3, 2, 1, 0, 1, 2, 3, 2, 1]
+    assert_array_equal(reflect, expected_reflect)
+
+    reflect = [coord_map_py(1, n, 'R') for n in range(-6, 6)]
+    expected_reflect = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+    assert_array_equal(reflect, expected_reflect)
+
+    other = [coord_map_py(4, n, 'undefined') for n in range(-6, 6)]
+    expected_other = list(range(-6, 6))
+    assert_array_equal(other, expected_other)

venv/Lib/site-packages/skimage/_shared/tests/test_safe_as_int.py

@@ -0,0 +1,42 @@
+import numpy as np
+from skimage._shared.utils import safe_as_int
+from skimage._shared import testing
+
+
+def test_int_cast_not_possible():
+    with testing.raises(ValueError):
+        safe_as_int(7.1)
+    with testing.raises(ValueError):
+        safe_as_int([7.1, 0.9])
+    with testing.raises(ValueError):
+        safe_as_int(np.r_[7.1, 0.9])
+    with testing.raises(ValueError):
+        safe_as_int((7.1, 0.9))
+    with testing.raises(ValueError):
+        safe_as_int(((3,   4,   1),
+                     (2, 7.6, 289)))
+    with testing.raises(ValueError):
+        safe_as_int(7.1, 0.09)
+    with testing.raises(ValueError):
+        safe_as_int([7.1, 0.9], 0.09)
+    with testing.raises(ValueError):
+        safe_as_int(np.r_[7.1, 0.9], 0.09)
+    with testing.raises(ValueError):
+        safe_as_int((7.1, 0.9), 0.09)
+    with testing.raises(ValueError):
+        safe_as_int(((3,   4,   1),
+                     (2, 7.6, 289)), 0.25)
+
+
+def test_int_cast_possible():
+    testing.assert_equal(safe_as_int(7.1, atol=0.11), 7)
+    testing.assert_equal(safe_as_int(-7.1, atol=0.11), -7)
+    testing.assert_equal(safe_as_int(41.9, atol=0.11), 42)
+    testing.assert_array_equal(safe_as_int([2, 42, 5789234.0, 87, 4]),
+                               np.r_[2, 42, 5789234, 87, 4])
+    testing.assert_array_equal(safe_as_int(np.r_[[[3, 4,  1.000000001],
+                                                  [7, 2, -8.999999999],
+                                                  [6, 9, -4234918347.]]]),
+                               np.r_[[[3, 4,           1],
+                                      [7, 2,          -9],
+                                      [6, 9, -4234918347]]])

venv/Lib/site-packages/skimage/_shared/tests/test_testing.py

@@ -0,0 +1,129 @@
+""" Testing decorators module
+"""
+
+import numpy as np
+from numpy.testing import assert_equal
+from skimage._shared.testing import doctest_skip_parser, test_parallel
+from skimage._shared import testing
+import pytest
+
+from skimage._shared._warnings import expected_warnings
+from warnings import warn
+
+
+def test_skipper():
+    def f():
+        pass
+
+    class c():
+
+        def __init__(self):
+            self.me = "I think, therefore..."
+
+    docstring = \
+        """ Header
+
+            >>> something # skip if not HAVE_AMODULE
+            >>> something + else
+            >>> a = 1 # skip if not HAVE_BMODULE
+            >>> something2   # skip if HAVE_AMODULE
+        """
+    f.__doc__ = docstring
+    c.__doc__ = docstring
+
+    global HAVE_AMODULE, HAVE_BMODULE
+    HAVE_AMODULE = False
+    HAVE_BMODULE = True
+
+    f2 = doctest_skip_parser(f)
+    c2 = doctest_skip_parser(c)
+    assert f is f2
+    assert c is c2
+
+    expected = \
+        """ Header
+
+            >>> something # doctest: +SKIP
+            >>> something + else
+            >>> a = 1
+            >>> something2
+        """
+    assert_equal(f2.__doc__, expected)
+    assert_equal(c2.__doc__, expected)
+
+    HAVE_AMODULE = True
+    HAVE_BMODULE = False
+    f.__doc__ = docstring
+    c.__doc__ = docstring
+    f2 = doctest_skip_parser(f)
+    c2 = doctest_skip_parser(c)
+
+    assert f is f2
+    expected = \
+        """ Header
+
+            >>> something
+            >>> something + else
+            >>> a = 1 # doctest: +SKIP
+            >>> something2   # doctest: +SKIP
+        """
+    assert_equal(f2.__doc__, expected)
+    assert_equal(c2.__doc__, expected)
+
+    del HAVE_AMODULE
+    f.__doc__ = docstring
+    c.__doc__ = docstring
+    with testing.raises(NameError):
+        doctest_skip_parser(f)
+    with testing.raises(NameError):
+        doctest_skip_parser(c)
+
+
+def test_test_parallel():
+    state = []
+
+    @test_parallel()
+    def change_state1():
+        state.append(None)
+    change_state1()
+    assert len(state) == 2
+
+    @test_parallel(num_threads=1)
+    def change_state2():
+        state.append(None)
+    change_state2()
+    assert len(state) == 3
+
+    @test_parallel(num_threads=3)
+    def change_state3():
+        state.append(None)
+    change_state3()
+    assert len(state) == 6
+
+
+def test_parallel_warning():
+    @test_parallel()
+    def change_state_warns_fails():
+        warn("Test warning for test parallel", stacklevel=2)
+
+    with expected_warnings(['Test warning for test parallel']):
+        change_state_warns_fails()
+
+    @test_parallel(warnings_matching=['Test warning for test parallel'])
+    def change_state_warns_passes():
+        warn("Test warning for test parallel", stacklevel=2)
+
+    change_state_warns_passes()
+
+
+def test_expected_warnings_noop():
+    # This will ensure the line beolow it behaves like a no-op
+    with expected_warnings(['Expected warnings test']):
+
+        # This should behave as a no-op
+        with expected_warnings(None):
+            warn('Expected warnings test')
+
+
+if __name__ == '__main__':
+    np.testing.run_module_suite()

venv/Lib/site-packages/skimage/_shared/tests/test_utils.py

@@ -0,0 +1,129 @@
+import sys
+import pytest
+import numpy as np
+import numpy.testing as npt
+from skimage._shared.utils import (check_nD, deprecate_kwarg,
+                                   _validate_interpolation_order,
+                                   change_default_value)
+from skimage._shared import testing
+from skimage._shared._warnings import expected_warnings
+
+
+def test_change_default_value():
+
+    @change_default_value('arg1', new_value=-1, changed_version='0.12')
+    def foo(arg0, arg1=0, arg2=1):
+        """Expected docstring"""
+        return arg0, arg1, arg2
+
+    @change_default_value('arg1', new_value=-1, changed_version='0.12',
+                          warning_msg="Custom warning message")
+    def bar(arg0, arg1=0, arg2=1):
+        """Expected docstring"""
+        return arg0, arg1, arg2
+
+    # Assert warning messages
+    with pytest.warns(FutureWarning) as record:
+        assert foo(0) == (0, 0, 1)
+        assert bar(0) == (0, 0, 1)
+
+    expected_msg = ("The new recommended value for arg1 is -1. Until "
+                    "version 0.12, the default arg1 value is 0. From "
+                    "version 0.12, the arg1 default value will be -1. "
+                    "To avoid this warning, please explicitly set arg1 value.")
+
+    assert str(record[0].message) == expected_msg
+    assert str(record[1].message) == "Custom warning message"
+
+    # Assert that nothing happens if arg1 is set
+    with pytest.warns(None) as record:
+        # No kwargs
+        assert foo(0, 2) == (0, 2, 1)
+        assert foo(0, arg1=0) == (0, 0, 1)
+
+        # Function name and doc is preserved
+        assert foo.__name__ == 'foo'
+        if sys.flags.optimize < 2:
+            # if PYTHONOPTIMIZE is set to 2, docstrings are stripped
+            assert foo.__doc__ == 'Expected docstring'
+
+    # Assert no warning was raised
+    assert not record.list
+
+
+def test_deprecated_kwarg():
+
+    @deprecate_kwarg({'old_arg1': 'new_arg1'})
+    def foo(arg0, new_arg1=1, arg2=None):
+        """Expected docstring"""
+        return arg0, new_arg1, arg2
+
+    @deprecate_kwarg({'old_arg1': 'new_arg1'},
+                     warning_msg="Custom warning message")
+    def bar(arg0, new_arg1=1, arg2=None):
+        """Expected docstring"""
+        return arg0, new_arg1, arg2
+
+    # Assert that the DeprecationWarning is raised when the deprecated
+    # argument name is used and that the reasult is valid
+    with pytest.warns(FutureWarning) as record:
+        assert foo(0, old_arg1=1) == (0, 1, None)
+        assert bar(0, old_arg1=1) == (0, 1, None)
+
+    msg = ("'old_arg1' is a deprecated argument name "
+           "for `foo`. Please use 'new_arg1' instead.")
+    assert str(record[0].message) == msg
+    assert str(record[1].message) == "Custom warning message"
+
+    # Assert that nothing happens when the function is called with the
+    # new API
+    with pytest.warns(None) as record:
+        # No kwargs
+        assert foo(0) == (0, 1, None)
+        assert foo(0, 2) == (0, 2, None)
+        assert foo(0, 1, 2) == (0, 1, 2)
+        # Kwargs without deprecated argument
+        assert foo(0, new_arg1=1, arg2=2) == (0, 1, 2)
+        assert foo(0, new_arg1=2) == (0, 2, None)
+        assert foo(0, arg2=2) == (0, 1, 2)
+        assert foo(0, 1, arg2=2) == (0, 1, 2)
+        # Function name and doc is preserved
+        assert foo.__name__ == 'foo'
+        if sys.flags.optimize < 2:
+            # if PYTHONOPTIMIZE is set to 2, docstrings are stripped
+            assert foo.__doc__ == 'Expected docstring'
+
+    # Assert no warning was raised
+    assert not record.list
+
+
+def test_check_nD():
+    z = np.random.random(200**2).reshape((200, 200))
+    x = z[10:30, 30:10]
+    with testing.raises(ValueError):
+        check_nD(x, 2)
+
+
+@pytest.mark.parametrize('dtype', [bool, int, np.uint8, np.uint16,
+                                   float, np.float32, np.float64])
+@pytest.mark.parametrize('order', [None, -1, 0, 1, 2, 3, 4, 5, 6])
+def test_validate_interpolation_order(dtype, order):
+    if order is None:
+        # Default order
+        assert (_validate_interpolation_order(dtype, None) == 0
+                if dtype == bool else 1)
+    elif order < 0 or order > 5:
+        # Order not in valid range
+        with testing.raises(ValueError):
+            _validate_interpolation_order(dtype, order)
+    elif dtype == bool and order != 0:
+        # Deprecated order for bool array
+        with expected_warnings(["Input image dtype is bool"]):
+            assert _validate_interpolation_order(bool, order) == order
+    else:
+        # Valid use case
+        assert _validate_interpolation_order(dtype, order) == order
+
+
+if __name__ == "__main__":
+    npt.run_module_suite()

venv/Lib/site-packages/skimage/_shared/tests/test_version_requirements.py

@@ -0,0 +1,41 @@
+"""Tests for the version requirement functions.
+
+"""
+import numpy as np
+from numpy.testing import assert_equal
+from skimage._shared import version_requirements as version_req
+from skimage._shared import testing
+
+
+def test_get_module_version():
+    assert version_req.get_module_version('numpy')
+    assert version_req.get_module_version('scipy')
+    with testing.raises(ImportError):
+        version_req.get_module_version('fakenumpy')
+
+
+def test_is_installed():
+    assert version_req.is_installed('python', '>=2.7')
+    assert not version_req.is_installed('numpy', '<1.0')
+
+
+def test_require():
+    # A function that only runs on Python >2.7 and numpy > 1.5 (should pass)
+    @version_req.require('python', '>2.7')
+    @version_req.require('numpy', '>1.5')
+    def foo():
+        return 1
+
+    assert_equal(foo(), 1)
+
+    # function that requires scipy < 0.1 (should fail)
+    @version_req.require('scipy', '<0.1')
+    def bar():
+        return 0
+
+    with testing.raises(ImportError):
+        bar()
+
+
+def test_get_module():
+    assert version_req.get_module("numpy") is np

venv/Lib/site-packages/skimage/_shared/tests/test_warnings.py

@@ -0,0 +1,37 @@
+import os
+from skimage._shared._warnings import expected_warnings
+import pytest
+
+
+@pytest.fixture(scope='function')
+def setup():
+    # Remove any environment variable if it exists
+    old_strictness = os.environ.pop('SKIMAGE_TEST_STRICT_WARNINGS', None)
+    yield
+    # Add the user's desired strictness
+    if old_strictness is not None:
+        os.environ['SKIMAGE_TEST_STRICT_WARNINGS'] = old_strictness
+
+
+def test_strict_warnigns_default(setup):
+    # By default we should fail on missing expected warnings
+    with pytest.raises(ValueError):
+        with expected_warnings(['some warnings']):
+            pass
+
+
+@pytest.mark.parametrize('strictness', ['1', 'true', 'True', 'TRUE'])
+def test_strict_warning_true(setup, strictness):
+    os.environ['SKIMAGE_TEST_STRICT_WARNINGS'] = strictness
+    with pytest.raises(ValueError):
+        with expected_warnings(['some warnings']):
+            pass
+
+
+@pytest.mark.parametrize('strictness', ['0', 'false', 'False', 'FALSE'])
+def test_strict_warning_false(setup, strictness):
+    # If the user doesnn't wish to be strict about warnigns
+    # the following shouldn't raise any error
+    os.environ['SKIMAGE_TEST_STRICT_WARNINGS'] = strictness
+    with expected_warnings(['some warnings']):
+        pass