using for loop to install conda package

.CondaPkg/env/Lib/site-packages/skimage/_shared/tests/test_coord.py

@@ -0,0 +1,94 @@
+import time
+
+import numpy as np
+import pytest
+from scipy.spatial.distance import pdist, minkowski
+
+from skimage._shared.coord import ensure_spacing
+
+
+@pytest.mark.parametrize("p", [1, 2, np.inf])
+@pytest.mark.parametrize("size", [30, 50, None])
+def test_ensure_spacing_trivial(p, size):
+    # --- Empty input
+    assert ensure_spacing([], p_norm=p) == []
+
+    # --- A unique point
+    coord = np.random.randn(1, 2)
+    assert np.array_equal(coord, ensure_spacing(coord, p_norm=p,
+                                                min_split_size=size))
+
+    # --- Verified spacing
+    coord = np.random.randn(100, 2)
+
+    # --- 0 spacing
+    assert np.array_equal(coord, ensure_spacing(coord, spacing=0, p_norm=p,
+                                                min_split_size=size))
+
+    # Spacing is chosen to be half the minimum distance
+    spacing = pdist(coord, metric=minkowski, p=p).min() * 0.5
+
+    out = ensure_spacing(coord, spacing=spacing, p_norm=p,
+                         min_split_size=size)
+
+    assert np.array_equal(coord, out)
+
+
+@pytest.mark.parametrize("ndim", [1, 2, 3, 4, 5])
+@pytest.mark.parametrize("size", [2, 10, None])
+def test_ensure_spacing_nD(ndim, size):
+    coord = np.ones((5, ndim))
+
+    expected = np.ones((1, ndim))
+
+    assert np.array_equal(ensure_spacing(coord, min_split_size=size), expected)
+
+
+@pytest.mark.parametrize("p", [1, 2, np.inf])
+@pytest.mark.parametrize("size", [50, 100, None])
+def test_ensure_spacing_batch_processing(p, size):
+    coord = np.random.randn(100, 2)
+
+    # --- Consider the average distance btween the point as spacing
+    spacing = np.median(pdist(coord, metric=minkowski, p=p))
+
+    expected = ensure_spacing(coord, spacing=spacing, p_norm=p)
+
+    assert np.array_equal(ensure_spacing(coord, spacing=spacing, p_norm=p,
+                                         min_split_size=size),
+                          expected)
+
+
+def test_max_batch_size():
+    """Small batches are slow, large batches -> large allocations -> also slow.
+
+    https://github.com/scikit-image/scikit-image/pull/6035#discussion_r751518691
+    """
+    coords = np.random.randint(low=0, high=1848, size=(40000, 2))
+    tstart = time.time()
+    ensure_spacing(coords, spacing=100, min_split_size=50,
+                   max_split_size=2000)
+    dur1 = time.time() - tstart
+
+    tstart = time.time()
+    ensure_spacing(coords, spacing=100, min_split_size=50,
+                   max_split_size=20000)
+    dur2 = time.time() - tstart
+
+    # Originally checked dur1 < dur2 to assert that the default batch size was
+    # faster than a much larger batch size. However, on rare occasion a CI test
+    # case would fail with dur1 ~5% larger than dur2. To be more robust to
+    # variable load or differences across architectures, we relax this here.
+    assert dur1 < 1.33 * dur2
+
+
+@pytest.mark.parametrize("p", [1, 2, np.inf])
+@pytest.mark.parametrize("size", [30, 50, None])
+def test_ensure_spacing_p_norm(p, size):
+    coord = np.random.randn(100, 2)
+
+    # --- Consider the average distance btween the point as spacing
+    spacing = np.median(pdist(coord, metric=minkowski, p=p))
+    out = ensure_spacing(coord, spacing=spacing, p_norm=p, min_split_size=size)
+
+    assert pdist(out, metric=minkowski, p=p).min() > spacing

.CondaPkg/env/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

.CondaPkg/env/Lib/site-packages/skimage/_shared/tests/test_geometry.py

@@ -0,0 +1,78 @@
+import pytest
+from skimage._shared._geometry import polygon_clip, polygon_area
+
+import numpy as np
+from numpy.testing import assert_equal, assert_almost_equal
+
+pytest.importorskip("matplotlib")
+
+
+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)

.CondaPkg/env/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)

.CondaPkg/env/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]]])

.CondaPkg/env/Lib/site-packages/skimage/_shared/tests/test_testing.py

@@ -0,0 +1,123 @@
+""" Testing decorators module
+"""
+
+from numpy.testing import assert_equal
+from skimage._shared.testing import doctest_skip_parser, test_parallel
+from skimage._shared import testing
+
+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')

.CondaPkg/env/Lib/site-packages/skimage/_shared/tests/test_utils.py

@@ -0,0 +1,294 @@
+import sys
+import warnings
+import inspect
+
+import numpy as np
+import pytest
+
+from skimage._shared import testing
+from skimage._shared.utils import (check_nD, deprecate_kwarg,
+                                   _validate_interpolation_order,
+                                   change_default_value, remove_arg,
+                                   _supported_float_type,
+                                   channel_as_last_axis)
+
+complex_dtypes = [np.complex64, np.complex128]
+if hasattr(np, 'complex256'):
+    complex_dtypes += [np.complex256]
+
+have_numpydoc = False
+try:
+    import numpydoc  # noqa: F401
+    have_numpydoc = True
+except ImportError:
+    pass
+
+
+def test_remove_argument():
+
+    @remove_arg('arg1', changed_version='0.12')
+    def foo(arg0, arg1=0, arg2=1):
+        """Expected docstring"""
+        return arg0, arg1, arg2
+
+    @remove_arg('arg1', changed_version='0.12',
+                help_msg="Some indication on future behavior")
+    def bar(arg0, arg1=0, arg2=1):
+        """Expected docstring"""
+        return arg0, arg1, arg2
+
+    # Assert warning messages
+    expected_msg = ("arg1 argument is deprecated and will be removed "
+                    "in version 0.12. To avoid this warning, "
+                    "please do not use the arg1 argument. Please see "
+                    "foo documentation for more details.")
+
+    with pytest.warns(FutureWarning) as record:
+        assert foo(0, 1) == (0, 1, 1)
+
+    assert str(record[0].message) == expected_msg
+
+    with pytest.warns(FutureWarning) as record:
+        assert foo(0, arg1=1) == (0, 1, 1)
+
+    assert str(record[0].message) == expected_msg
+
+    expected_msg = ("arg1 argument is deprecated and will be removed "
+                    "in version 0.12. To avoid this warning, "
+                    "please do not use the arg1 argument. Please see "
+                    "bar documentation for more details."
+                    " Some indication on future behavior")
+
+    with pytest.warns(FutureWarning) as record:
+        assert bar(0, 1) == (0, 1, 1)
+
+    assert str(record[0].message) == expected_msg
+
+    with pytest.warns(FutureWarning) as record:
+        assert bar(0, arg1=1) == (0, 1, 1)
+
+    assert str(record[0].message) == expected_msg
+    with warnings.catch_warnings(record=True) as recorded:
+        # No kwargs
+        assert foo(0) == (0, 0, 1)
+        assert foo(0, arg2=0) == (0, 0, 0)
+
+        # 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 warnings were raised
+    assert len(recorded) == 0
+
+
+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 warnings.catch_warnings(record=True) as recorded:
+        # 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 warnings were raised
+    assert len(recorded) == 0
+
+
+def test_deprecate_kwarg():
+
+    @deprecate_kwarg({'old_arg1': 'new_arg1'}, '0.19')
+    def foo(arg0, new_arg1=1, arg2=None):
+        """Expected docstring"""
+        return arg0, new_arg1, arg2
+
+    @deprecate_kwarg({'old_arg1': 'new_arg1'},
+                     deprecated_version='0.19',
+                     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 warnings.catch_warnings(record=True) as recorded:
+        # 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
+            if not have_numpydoc:
+                assert foo.__doc__ == """Expected docstring"""
+            else:
+                assert foo.__doc__ == """Expected docstring
+
+
+    Other Parameters
+    ----------------
+    old_arg1 : DEPRECATED
+        Deprecated in favor of `new_arg1`.
+
+        .. deprecated:: 0.19
+"""
+
+    assert len(recorded) == 0
+
+
+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 pytest.raises(ValueError):
+            _validate_interpolation_order(bool, order)
+    else:
+        # Valid use case
+        assert _validate_interpolation_order(dtype, order) == order
+
+
+@pytest.mark.parametrize(
+    'dtype',
+    [bool, np.float16, np.float32, np.float64, np.uint8, np.uint16, np.uint32,
+     np.uint64, np.int8, np.int16, np.int32, np.int64]
+)
+def test_supported_float_dtype_real(dtype):
+    float_dtype = _supported_float_type(dtype)
+    if dtype in [np.float16, np.float32]:
+        assert float_dtype == np.float32
+    else:
+        assert float_dtype == np.float64
+
+
+@pytest.mark.parametrize('dtype', complex_dtypes)
+@pytest.mark.parametrize('allow_complex', [False, True])
+def test_supported_float_dtype_complex(dtype, allow_complex):
+    if allow_complex:
+        float_dtype = _supported_float_type(dtype, allow_complex=allow_complex)
+        if dtype == np.complex64:
+            assert float_dtype == np.complex64
+        else:
+            assert float_dtype == np.complex128
+    else:
+        with testing.raises(ValueError):
+            _supported_float_type(dtype, allow_complex=allow_complex)
+
+
+@pytest.mark.parametrize(
+    'dtype', ['f', 'float32', np.float32, np.dtype(np.float32)]
+)
+def test_supported_float_dtype_input_kinds(dtype):
+    assert _supported_float_type(dtype) == np.float32
+
+
+@pytest.mark.parametrize(
+    'dtypes, expected',
+    [
+        ((np.float16, np.float64), np.float64),
+        ([np.float32, np.uint16, np.int8], np.float64),
+        ({np.float32, np.float16}, np.float32),
+    ]
+)
+def test_supported_float_dtype_sequence(dtypes, expected):
+    float_dtype = _supported_float_type(dtypes)
+    assert float_dtype == expected
+
+
+@channel_as_last_axis(multichannel_output=False)
+def _decorated_channel_axis_size(x, *, channel_axis=None):
+    if channel_axis is None:
+        return None
+    assert channel_axis == -1
+    return x.shape[-1]
+
+
+@testing.parametrize('channel_axis', [None, 0, 1, 2, -1, -2, -3])
+def test_decorated_channel_axis_shape(channel_axis):
+    # Verify that channel_as_last_axis modifies the channel_axis as expected
+
+    # need unique size per axis here
+    x = np.zeros((2, 3, 4))
+
+    size = _decorated_channel_axis_size(x, channel_axis=channel_axis)
+    if channel_axis is None:
+        assert size is None
+    else:
+        assert size == x.shape[channel_axis]
+
+
+@deprecate_kwarg({"old_kwarg": "new_kwarg"}, deprecated_version="x.y.z")
+def _function_with_deprecated_kwarg(*, new_kwarg):
+    pass
+
+
+def test_deprecate_kwarg_location():
+    """Assert that warning message issued by deprecate_kwarg points to
+    file and line number where decorated function is called.
+    """
+    with pytest.warns(FutureWarning) as record:
+        _function_with_deprecated_kwarg(old_kwarg=True)
+        expected_lineno = inspect.currentframe().f_lineno - 1
+    assert record[0].lineno == expected_lineno
+    assert record[0].filename == __file__

.CondaPkg/env/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

.CondaPkg/env/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 doesn't wish to be strict about warnings
+    # the following shouldn't raise any error
+    os.environ['SKIMAGE_TEST_STRICT_WARNINGS'] = strictness
+    with expected_warnings(['some warnings']):
+        pass