811 lines
26 KiB
Python
811 lines
26 KiB
Python
import itertools
|
|
import pickle
|
|
|
|
from weakref import ref
|
|
from unittest.mock import patch, Mock
|
|
|
|
from datetime import datetime
|
|
|
|
import numpy as np
|
|
from numpy.testing import (assert_array_equal, assert_approx_equal,
|
|
assert_array_almost_equal)
|
|
import pytest
|
|
|
|
from matplotlib import _api
|
|
import matplotlib.cbook as cbook
|
|
import matplotlib.colors as mcolors
|
|
from matplotlib.cbook import delete_masked_points
|
|
|
|
|
|
class Test_delete_masked_points:
|
|
def test_bad_first_arg(self):
|
|
with pytest.raises(ValueError):
|
|
delete_masked_points('a string', np.arange(1.0, 7.0))
|
|
|
|
def test_string_seq(self):
|
|
a1 = ['a', 'b', 'c', 'd', 'e', 'f']
|
|
a2 = [1, 2, 3, np.nan, np.nan, 6]
|
|
result1, result2 = delete_masked_points(a1, a2)
|
|
ind = [0, 1, 2, 5]
|
|
assert_array_equal(result1, np.array(a1)[ind])
|
|
assert_array_equal(result2, np.array(a2)[ind])
|
|
|
|
def test_datetime(self):
|
|
dates = [datetime(2008, 1, 1), datetime(2008, 1, 2),
|
|
datetime(2008, 1, 3), datetime(2008, 1, 4),
|
|
datetime(2008, 1, 5), datetime(2008, 1, 6)]
|
|
a_masked = np.ma.array([1, 2, 3, np.nan, np.nan, 6],
|
|
mask=[False, False, True, True, False, False])
|
|
actual = delete_masked_points(dates, a_masked)
|
|
ind = [0, 1, 5]
|
|
assert_array_equal(actual[0], np.array(dates)[ind])
|
|
assert_array_equal(actual[1], a_masked[ind].compressed())
|
|
|
|
def test_rgba(self):
|
|
a_masked = np.ma.array([1, 2, 3, np.nan, np.nan, 6],
|
|
mask=[False, False, True, True, False, False])
|
|
a_rgba = mcolors.to_rgba_array(['r', 'g', 'b', 'c', 'm', 'y'])
|
|
actual = delete_masked_points(a_masked, a_rgba)
|
|
ind = [0, 1, 5]
|
|
assert_array_equal(actual[0], a_masked[ind].compressed())
|
|
assert_array_equal(actual[1], a_rgba[ind])
|
|
|
|
|
|
class Test_boxplot_stats:
|
|
def setup(self):
|
|
np.random.seed(937)
|
|
self.nrows = 37
|
|
self.ncols = 4
|
|
self.data = np.random.lognormal(size=(self.nrows, self.ncols),
|
|
mean=1.5, sigma=1.75)
|
|
self.known_keys = sorted([
|
|
'mean', 'med', 'q1', 'q3', 'iqr',
|
|
'cilo', 'cihi', 'whislo', 'whishi',
|
|
'fliers', 'label'
|
|
])
|
|
self.std_results = cbook.boxplot_stats(self.data)
|
|
|
|
self.known_nonbootstrapped_res = {
|
|
'cihi': 6.8161283264444847,
|
|
'cilo': -0.1489815330368689,
|
|
'iqr': 13.492709959447094,
|
|
'mean': 13.00447442387868,
|
|
'med': 3.3335733967038079,
|
|
'fliers': np.array([
|
|
92.55467075, 87.03819018, 42.23204914, 39.29390996
|
|
]),
|
|
'q1': 1.3597529879465153,
|
|
'q3': 14.85246294739361,
|
|
'whishi': 27.899688243699629,
|
|
'whislo': 0.042143774965502923
|
|
}
|
|
|
|
self.known_bootstrapped_ci = {
|
|
'cihi': 8.939577523357828,
|
|
'cilo': 1.8692703958676578,
|
|
}
|
|
|
|
self.known_whis3_res = {
|
|
'whishi': 42.232049135969874,
|
|
'whislo': 0.042143774965502923,
|
|
'fliers': np.array([92.55467075, 87.03819018]),
|
|
}
|
|
|
|
self.known_res_percentiles = {
|
|
'whislo': 0.1933685896907924,
|
|
'whishi': 42.232049135969874
|
|
}
|
|
|
|
self.known_res_range = {
|
|
'whislo': 0.042143774965502923,
|
|
'whishi': 92.554670752188699
|
|
|
|
}
|
|
|
|
def test_form_main_list(self):
|
|
assert isinstance(self.std_results, list)
|
|
|
|
def test_form_each_dict(self):
|
|
for res in self.std_results:
|
|
assert isinstance(res, dict)
|
|
|
|
def test_form_dict_keys(self):
|
|
for res in self.std_results:
|
|
assert set(res) <= set(self.known_keys)
|
|
|
|
def test_results_baseline(self):
|
|
res = self.std_results[0]
|
|
for key, value in self.known_nonbootstrapped_res.items():
|
|
assert_array_almost_equal(res[key], value)
|
|
|
|
def test_results_bootstrapped(self):
|
|
results = cbook.boxplot_stats(self.data, bootstrap=10000)
|
|
res = results[0]
|
|
for key, value in self.known_bootstrapped_ci.items():
|
|
assert_approx_equal(res[key], value)
|
|
|
|
def test_results_whiskers_float(self):
|
|
results = cbook.boxplot_stats(self.data, whis=3)
|
|
res = results[0]
|
|
for key, value in self.known_whis3_res.items():
|
|
assert_array_almost_equal(res[key], value)
|
|
|
|
def test_results_whiskers_range(self):
|
|
results = cbook.boxplot_stats(self.data, whis=[0, 100])
|
|
res = results[0]
|
|
for key, value in self.known_res_range.items():
|
|
assert_array_almost_equal(res[key], value)
|
|
|
|
def test_results_whiskers_percentiles(self):
|
|
results = cbook.boxplot_stats(self.data, whis=[5, 95])
|
|
res = results[0]
|
|
for key, value in self.known_res_percentiles.items():
|
|
assert_array_almost_equal(res[key], value)
|
|
|
|
def test_results_withlabels(self):
|
|
labels = ['Test1', 2, 'ardvark', 4]
|
|
results = cbook.boxplot_stats(self.data, labels=labels)
|
|
for lab, res in zip(labels, results):
|
|
assert res['label'] == lab
|
|
|
|
results = cbook.boxplot_stats(self.data)
|
|
for res in results:
|
|
assert 'label' not in res
|
|
|
|
def test_label_error(self):
|
|
labels = [1, 2]
|
|
with pytest.raises(ValueError):
|
|
cbook.boxplot_stats(self.data, labels=labels)
|
|
|
|
def test_bad_dims(self):
|
|
data = np.random.normal(size=(34, 34, 34))
|
|
with pytest.raises(ValueError):
|
|
cbook.boxplot_stats(data)
|
|
|
|
def test_boxplot_stats_autorange_false(self):
|
|
x = np.zeros(shape=140)
|
|
x = np.hstack([-25, x, 25])
|
|
bstats_false = cbook.boxplot_stats(x, autorange=False)
|
|
bstats_true = cbook.boxplot_stats(x, autorange=True)
|
|
|
|
assert bstats_false[0]['whislo'] == 0
|
|
assert bstats_false[0]['whishi'] == 0
|
|
assert_array_almost_equal(bstats_false[0]['fliers'], [-25, 25])
|
|
|
|
assert bstats_true[0]['whislo'] == -25
|
|
assert bstats_true[0]['whishi'] == 25
|
|
assert_array_almost_equal(bstats_true[0]['fliers'], [])
|
|
|
|
|
|
class Test_callback_registry:
|
|
def setup(self):
|
|
self.signal = 'test'
|
|
self.callbacks = cbook.CallbackRegistry()
|
|
|
|
def connect(self, s, func, pickle):
|
|
cid = self.callbacks.connect(s, func)
|
|
if pickle:
|
|
self.callbacks._pickled_cids.add(cid)
|
|
return cid
|
|
|
|
def disconnect(self, cid):
|
|
return self.callbacks.disconnect(cid)
|
|
|
|
def count(self):
|
|
count1 = len(self.callbacks._func_cid_map.get(self.signal, []))
|
|
count2 = len(self.callbacks.callbacks.get(self.signal))
|
|
assert count1 == count2
|
|
return count1
|
|
|
|
def is_empty(self):
|
|
assert self.callbacks._func_cid_map == {}
|
|
assert self.callbacks.callbacks == {}
|
|
assert self.callbacks._pickled_cids == set()
|
|
|
|
def is_not_empty(self):
|
|
assert self.callbacks._func_cid_map != {}
|
|
assert self.callbacks.callbacks != {}
|
|
|
|
@pytest.mark.parametrize('pickle', [True, False])
|
|
def test_callback_complete(self, pickle):
|
|
# ensure we start with an empty registry
|
|
self.is_empty()
|
|
|
|
# create a class for testing
|
|
mini_me = Test_callback_registry()
|
|
|
|
# test that we can add a callback
|
|
cid1 = self.connect(self.signal, mini_me.dummy, pickle)
|
|
assert type(cid1) == int
|
|
self.is_not_empty()
|
|
|
|
# test that we don't add a second callback
|
|
cid2 = self.connect(self.signal, mini_me.dummy, pickle)
|
|
assert cid1 == cid2
|
|
self.is_not_empty()
|
|
assert len(self.callbacks._func_cid_map) == 1
|
|
assert len(self.callbacks.callbacks) == 1
|
|
|
|
del mini_me
|
|
|
|
# check we now have no callbacks registered
|
|
self.is_empty()
|
|
|
|
@pytest.mark.parametrize('pickle', [True, False])
|
|
def test_callback_disconnect(self, pickle):
|
|
# ensure we start with an empty registry
|
|
self.is_empty()
|
|
|
|
# create a class for testing
|
|
mini_me = Test_callback_registry()
|
|
|
|
# test that we can add a callback
|
|
cid1 = self.connect(self.signal, mini_me.dummy, pickle)
|
|
assert type(cid1) == int
|
|
self.is_not_empty()
|
|
|
|
self.disconnect(cid1)
|
|
|
|
# check we now have no callbacks registered
|
|
self.is_empty()
|
|
|
|
@pytest.mark.parametrize('pickle', [True, False])
|
|
def test_callback_wrong_disconnect(self, pickle):
|
|
# ensure we start with an empty registry
|
|
self.is_empty()
|
|
|
|
# create a class for testing
|
|
mini_me = Test_callback_registry()
|
|
|
|
# test that we can add a callback
|
|
cid1 = self.connect(self.signal, mini_me.dummy, pickle)
|
|
assert type(cid1) == int
|
|
self.is_not_empty()
|
|
|
|
self.disconnect("foo")
|
|
|
|
# check we still have callbacks registered
|
|
self.is_not_empty()
|
|
|
|
@pytest.mark.parametrize('pickle', [True, False])
|
|
def test_registration_on_non_empty_registry(self, pickle):
|
|
# ensure we start with an empty registry
|
|
self.is_empty()
|
|
|
|
# setup the registry with a callback
|
|
mini_me = Test_callback_registry()
|
|
self.connect(self.signal, mini_me.dummy, pickle)
|
|
|
|
# Add another callback
|
|
mini_me2 = Test_callback_registry()
|
|
self.connect(self.signal, mini_me2.dummy, pickle)
|
|
|
|
# Remove and add the second callback
|
|
mini_me2 = Test_callback_registry()
|
|
self.connect(self.signal, mini_me2.dummy, pickle)
|
|
|
|
# We still have 2 references
|
|
self.is_not_empty()
|
|
assert self.count() == 2
|
|
|
|
# Removing the last 2 references
|
|
mini_me = None
|
|
mini_me2 = None
|
|
self.is_empty()
|
|
|
|
def dummy(self):
|
|
pass
|
|
|
|
def test_pickling(self):
|
|
assert hasattr(pickle.loads(pickle.dumps(cbook.CallbackRegistry())),
|
|
"callbacks")
|
|
|
|
|
|
def test_callbackregistry_default_exception_handler(capsys, monkeypatch):
|
|
cb = cbook.CallbackRegistry()
|
|
cb.connect("foo", lambda: None)
|
|
|
|
monkeypatch.setattr(
|
|
cbook, "_get_running_interactive_framework", lambda: None)
|
|
with pytest.raises(TypeError):
|
|
cb.process("foo", "argument mismatch")
|
|
outerr = capsys.readouterr()
|
|
assert outerr.out == outerr.err == ""
|
|
|
|
monkeypatch.setattr(
|
|
cbook, "_get_running_interactive_framework", lambda: "not-none")
|
|
cb.process("foo", "argument mismatch") # No error in that case.
|
|
outerr = capsys.readouterr()
|
|
assert outerr.out == ""
|
|
assert "takes 0 positional arguments but 1 was given" in outerr.err
|
|
|
|
|
|
def raising_cb_reg(func):
|
|
class TestException(Exception):
|
|
pass
|
|
|
|
def raise_runtime_error():
|
|
raise RuntimeError
|
|
|
|
def raise_value_error():
|
|
raise ValueError
|
|
|
|
def transformer(excp):
|
|
if isinstance(excp, RuntimeError):
|
|
raise TestException
|
|
raise excp
|
|
|
|
# old default
|
|
cb_old = cbook.CallbackRegistry(exception_handler=None)
|
|
cb_old.connect('foo', raise_runtime_error)
|
|
|
|
# filter
|
|
cb_filt = cbook.CallbackRegistry(exception_handler=transformer)
|
|
cb_filt.connect('foo', raise_runtime_error)
|
|
|
|
# filter
|
|
cb_filt_pass = cbook.CallbackRegistry(exception_handler=transformer)
|
|
cb_filt_pass.connect('foo', raise_value_error)
|
|
|
|
return pytest.mark.parametrize('cb, excp',
|
|
[[cb_old, RuntimeError],
|
|
[cb_filt, TestException],
|
|
[cb_filt_pass, ValueError]])(func)
|
|
|
|
|
|
@raising_cb_reg
|
|
def test_callbackregistry_custom_exception_handler(monkeypatch, cb, excp):
|
|
monkeypatch.setattr(
|
|
cbook, "_get_running_interactive_framework", lambda: None)
|
|
with pytest.raises(excp):
|
|
cb.process('foo')
|
|
|
|
|
|
def test_sanitize_sequence():
|
|
d = {'a': 1, 'b': 2, 'c': 3}
|
|
k = ['a', 'b', 'c']
|
|
v = [1, 2, 3]
|
|
i = [('a', 1), ('b', 2), ('c', 3)]
|
|
assert k == sorted(cbook.sanitize_sequence(d.keys()))
|
|
assert v == sorted(cbook.sanitize_sequence(d.values()))
|
|
assert i == sorted(cbook.sanitize_sequence(d.items()))
|
|
assert i == cbook.sanitize_sequence(i)
|
|
assert k == cbook.sanitize_sequence(k)
|
|
|
|
|
|
fail_mapping = (
|
|
({'a': 1}, {'forbidden': ('a')}),
|
|
({'a': 1}, {'required': ('b')}),
|
|
({'a': 1, 'b': 2}, {'required': ('a'), 'allowed': ()}),
|
|
({'a': 1, 'b': 2}, {'alias_mapping': {'a': ['b']}}),
|
|
({'a': 1, 'b': 2}, {'alias_mapping': {'a': ['b']}, 'allowed': ('a',)}),
|
|
({'a': 1, 'b': 2}, {'alias_mapping': {'a': ['a', 'b']}}),
|
|
({'a': 1, 'b': 2, 'c': 3},
|
|
{'alias_mapping': {'a': ['b']}, 'required': ('a', )}),
|
|
)
|
|
|
|
pass_mapping = (
|
|
(None, {}, {}),
|
|
({'a': 1, 'b': 2}, {'a': 1, 'b': 2}, {}),
|
|
({'b': 2}, {'a': 2}, {'alias_mapping': {'a': ['a', 'b']}}),
|
|
({'b': 2}, {'a': 2},
|
|
{'alias_mapping': {'a': ['b']}, 'forbidden': ('b', )}),
|
|
({'a': 1, 'c': 3}, {'a': 1, 'c': 3},
|
|
{'required': ('a', ), 'allowed': ('c', )}),
|
|
({'a': 1, 'c': 3}, {'a': 1, 'c': 3},
|
|
{'required': ('a', 'c'), 'allowed': ('c', )}),
|
|
({'a': 1, 'c': 3}, {'a': 1, 'c': 3},
|
|
{'required': ('a', 'c'), 'allowed': ('a', 'c')}),
|
|
({'a': 1, 'c': 3}, {'a': 1, 'c': 3},
|
|
{'required': ('a', 'c'), 'allowed': ()}),
|
|
({'a': 1, 'c': 3}, {'a': 1, 'c': 3}, {'required': ('a', 'c')}),
|
|
({'a': 1, 'c': 3}, {'a': 1, 'c': 3}, {'allowed': ('a', 'c')}),
|
|
)
|
|
|
|
|
|
@pytest.mark.parametrize('inp, kwargs_to_norm', fail_mapping)
|
|
def test_normalize_kwargs_fail(inp, kwargs_to_norm):
|
|
with pytest.raises(TypeError), \
|
|
_api.suppress_matplotlib_deprecation_warning():
|
|
cbook.normalize_kwargs(inp, **kwargs_to_norm)
|
|
|
|
|
|
@pytest.mark.parametrize('inp, expected, kwargs_to_norm',
|
|
pass_mapping)
|
|
def test_normalize_kwargs_pass(inp, expected, kwargs_to_norm):
|
|
with _api.suppress_matplotlib_deprecation_warning():
|
|
# No other warning should be emitted.
|
|
assert expected == cbook.normalize_kwargs(inp, **kwargs_to_norm)
|
|
|
|
|
|
def test_warn_external_frame_embedded_python():
|
|
with patch.object(cbook, "sys") as mock_sys:
|
|
mock_sys._getframe = Mock(return_value=None)
|
|
with pytest.warns(UserWarning, match=r"\Adummy\Z"):
|
|
_api.warn_external("dummy")
|
|
|
|
|
|
def test_to_prestep():
|
|
x = np.arange(4)
|
|
y1 = np.arange(4)
|
|
y2 = np.arange(4)[::-1]
|
|
|
|
xs, y1s, y2s = cbook.pts_to_prestep(x, y1, y2)
|
|
|
|
x_target = np.asarray([0, 0, 1, 1, 2, 2, 3], dtype=float)
|
|
y1_target = np.asarray([0, 1, 1, 2, 2, 3, 3], dtype=float)
|
|
y2_target = np.asarray([3, 2, 2, 1, 1, 0, 0], dtype=float)
|
|
|
|
assert_array_equal(x_target, xs)
|
|
assert_array_equal(y1_target, y1s)
|
|
assert_array_equal(y2_target, y2s)
|
|
|
|
xs, y1s = cbook.pts_to_prestep(x, y1)
|
|
assert_array_equal(x_target, xs)
|
|
assert_array_equal(y1_target, y1s)
|
|
|
|
|
|
def test_to_prestep_empty():
|
|
steps = cbook.pts_to_prestep([], [])
|
|
assert steps.shape == (2, 0)
|
|
|
|
|
|
def test_to_poststep():
|
|
x = np.arange(4)
|
|
y1 = np.arange(4)
|
|
y2 = np.arange(4)[::-1]
|
|
|
|
xs, y1s, y2s = cbook.pts_to_poststep(x, y1, y2)
|
|
|
|
x_target = np.asarray([0, 1, 1, 2, 2, 3, 3], dtype=float)
|
|
y1_target = np.asarray([0, 0, 1, 1, 2, 2, 3], dtype=float)
|
|
y2_target = np.asarray([3, 3, 2, 2, 1, 1, 0], dtype=float)
|
|
|
|
assert_array_equal(x_target, xs)
|
|
assert_array_equal(y1_target, y1s)
|
|
assert_array_equal(y2_target, y2s)
|
|
|
|
xs, y1s = cbook.pts_to_poststep(x, y1)
|
|
assert_array_equal(x_target, xs)
|
|
assert_array_equal(y1_target, y1s)
|
|
|
|
|
|
def test_to_poststep_empty():
|
|
steps = cbook.pts_to_poststep([], [])
|
|
assert steps.shape == (2, 0)
|
|
|
|
|
|
def test_to_midstep():
|
|
x = np.arange(4)
|
|
y1 = np.arange(4)
|
|
y2 = np.arange(4)[::-1]
|
|
|
|
xs, y1s, y2s = cbook.pts_to_midstep(x, y1, y2)
|
|
|
|
x_target = np.asarray([0, .5, .5, 1.5, 1.5, 2.5, 2.5, 3], dtype=float)
|
|
y1_target = np.asarray([0, 0, 1, 1, 2, 2, 3, 3], dtype=float)
|
|
y2_target = np.asarray([3, 3, 2, 2, 1, 1, 0, 0], dtype=float)
|
|
|
|
assert_array_equal(x_target, xs)
|
|
assert_array_equal(y1_target, y1s)
|
|
assert_array_equal(y2_target, y2s)
|
|
|
|
xs, y1s = cbook.pts_to_midstep(x, y1)
|
|
assert_array_equal(x_target, xs)
|
|
assert_array_equal(y1_target, y1s)
|
|
|
|
|
|
def test_to_midstep_empty():
|
|
steps = cbook.pts_to_midstep([], [])
|
|
assert steps.shape == (2, 0)
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"args",
|
|
[(np.arange(12).reshape(3, 4), 'a'),
|
|
(np.arange(12), 'a'),
|
|
(np.arange(12), np.arange(3))])
|
|
def test_step_fails(args):
|
|
with pytest.raises(ValueError):
|
|
cbook.pts_to_prestep(*args)
|
|
|
|
|
|
def test_grouper():
|
|
class Dummy:
|
|
pass
|
|
a, b, c, d, e = objs = [Dummy() for _ in range(5)]
|
|
g = cbook.Grouper()
|
|
g.join(*objs)
|
|
assert set(list(g)[0]) == set(objs)
|
|
assert set(g.get_siblings(a)) == set(objs)
|
|
|
|
for other in objs[1:]:
|
|
assert g.joined(a, other)
|
|
|
|
g.remove(a)
|
|
for other in objs[1:]:
|
|
assert not g.joined(a, other)
|
|
|
|
for A, B in itertools.product(objs[1:], objs[1:]):
|
|
assert g.joined(A, B)
|
|
|
|
|
|
def test_grouper_private():
|
|
class Dummy:
|
|
pass
|
|
objs = [Dummy() for _ in range(5)]
|
|
g = cbook.Grouper()
|
|
g.join(*objs)
|
|
# reach in and touch the internals !
|
|
mapping = g._mapping
|
|
|
|
for o in objs:
|
|
assert ref(o) in mapping
|
|
|
|
base_set = mapping[ref(objs[0])]
|
|
for o in objs[1:]:
|
|
assert mapping[ref(o)] is base_set
|
|
|
|
|
|
def test_flatiter():
|
|
x = np.arange(5)
|
|
it = x.flat
|
|
assert 0 == next(it)
|
|
assert 1 == next(it)
|
|
ret = cbook.safe_first_element(it)
|
|
assert ret == 0
|
|
|
|
assert 0 == next(it)
|
|
assert 1 == next(it)
|
|
|
|
|
|
def test_reshape2d():
|
|
|
|
class Dummy:
|
|
pass
|
|
|
|
xnew = cbook._reshape_2D([], 'x')
|
|
assert np.shape(xnew) == (1, 0)
|
|
|
|
x = [Dummy() for _ in range(5)]
|
|
|
|
xnew = cbook._reshape_2D(x, 'x')
|
|
assert np.shape(xnew) == (1, 5)
|
|
|
|
x = np.arange(5)
|
|
xnew = cbook._reshape_2D(x, 'x')
|
|
assert np.shape(xnew) == (1, 5)
|
|
|
|
x = [[Dummy() for _ in range(5)] for _ in range(3)]
|
|
xnew = cbook._reshape_2D(x, 'x')
|
|
assert np.shape(xnew) == (3, 5)
|
|
|
|
# this is strange behaviour, but...
|
|
x = np.random.rand(3, 5)
|
|
xnew = cbook._reshape_2D(x, 'x')
|
|
assert np.shape(xnew) == (5, 3)
|
|
|
|
# Test a list of lists which are all of length 1
|
|
x = [[1], [2], [3]]
|
|
xnew = cbook._reshape_2D(x, 'x')
|
|
assert isinstance(xnew, list)
|
|
assert isinstance(xnew[0], np.ndarray) and xnew[0].shape == (1,)
|
|
assert isinstance(xnew[1], np.ndarray) and xnew[1].shape == (1,)
|
|
assert isinstance(xnew[2], np.ndarray) and xnew[2].shape == (1,)
|
|
|
|
# Now test with a list of lists with different lengths, which means the
|
|
# array will internally be converted to a 1D object array of lists
|
|
x = [[1, 2, 3], [3, 4], [2]]
|
|
xnew = cbook._reshape_2D(x, 'x')
|
|
assert isinstance(xnew, list)
|
|
assert isinstance(xnew[0], np.ndarray) and xnew[0].shape == (3,)
|
|
assert isinstance(xnew[1], np.ndarray) and xnew[1].shape == (2,)
|
|
assert isinstance(xnew[2], np.ndarray) and xnew[2].shape == (1,)
|
|
|
|
# We now need to make sure that this works correctly for Numpy subclasses
|
|
# where iterating over items can return subclasses too, which may be
|
|
# iterable even if they are scalars. To emulate this, we make a Numpy
|
|
# array subclass that returns Numpy 'scalars' when iterating or accessing
|
|
# values, and these are technically iterable if checking for example
|
|
# isinstance(x, collections.abc.Iterable).
|
|
|
|
class ArraySubclass(np.ndarray):
|
|
|
|
def __iter__(self):
|
|
for value in super().__iter__():
|
|
yield np.array(value)
|
|
|
|
def __getitem__(self, item):
|
|
return np.array(super().__getitem__(item))
|
|
|
|
v = np.arange(10, dtype=float)
|
|
x = ArraySubclass((10,), dtype=float, buffer=v.data)
|
|
|
|
xnew = cbook._reshape_2D(x, 'x')
|
|
|
|
# We check here that the array wasn't split up into many individual
|
|
# ArraySubclass, which is what used to happen due to a bug in _reshape_2D
|
|
assert len(xnew) == 1
|
|
assert isinstance(xnew[0], ArraySubclass)
|
|
|
|
# check list of strings:
|
|
x = ['a', 'b', 'c', 'c', 'dd', 'e', 'f', 'ff', 'f']
|
|
xnew = cbook._reshape_2D(x, 'x')
|
|
assert len(xnew[0]) == len(x)
|
|
assert isinstance(xnew[0], np.ndarray)
|
|
|
|
|
|
def test_reshape2d_pandas(pd):
|
|
# separate to allow the rest of the tests to run if no pandas...
|
|
X = np.arange(30).reshape(10, 3)
|
|
x = pd.DataFrame(X, columns=["a", "b", "c"])
|
|
Xnew = cbook._reshape_2D(x, 'x')
|
|
# Need to check each row because _reshape_2D returns a list of arrays:
|
|
for x, xnew in zip(X.T, Xnew):
|
|
np.testing.assert_array_equal(x, xnew)
|
|
|
|
X = np.arange(30).reshape(10, 3)
|
|
x = pd.DataFrame(X, columns=["a", "b", "c"])
|
|
Xnew = cbook._reshape_2D(x, 'x')
|
|
# Need to check each row because _reshape_2D returns a list of arrays:
|
|
for x, xnew in zip(X.T, Xnew):
|
|
np.testing.assert_array_equal(x, xnew)
|
|
|
|
|
|
def test_contiguous_regions():
|
|
a, b, c = 3, 4, 5
|
|
# Starts and ends with True
|
|
mask = [True]*a + [False]*b + [True]*c
|
|
expected = [(0, a), (a+b, a+b+c)]
|
|
assert cbook.contiguous_regions(mask) == expected
|
|
d, e = 6, 7
|
|
# Starts with True ends with False
|
|
mask = mask + [False]*e
|
|
assert cbook.contiguous_regions(mask) == expected
|
|
# Starts with False ends with True
|
|
mask = [False]*d + mask[:-e]
|
|
expected = [(d, d+a), (d+a+b, d+a+b+c)]
|
|
assert cbook.contiguous_regions(mask) == expected
|
|
# Starts and ends with False
|
|
mask = mask + [False]*e
|
|
assert cbook.contiguous_regions(mask) == expected
|
|
# No True in mask
|
|
assert cbook.contiguous_regions([False]*5) == []
|
|
# Empty mask
|
|
assert cbook.contiguous_regions([]) == []
|
|
|
|
|
|
def test_safe_first_element_pandas_series(pd):
|
|
# deliberately create a pandas series with index not starting from 0
|
|
s = pd.Series(range(5), index=range(10, 15))
|
|
actual = cbook.safe_first_element(s)
|
|
assert actual == 0
|
|
|
|
|
|
def test_warn_external(recwarn):
|
|
_api.warn_external("oops")
|
|
assert len(recwarn) == 1
|
|
assert recwarn[0].filename == __file__
|
|
|
|
|
|
def test_array_patch_perimeters():
|
|
# This compares the old implementation as a reference for the
|
|
# vectorized one.
|
|
def check(x, rstride, cstride):
|
|
rows, cols = x.shape
|
|
row_inds = [*range(0, rows-1, rstride), rows-1]
|
|
col_inds = [*range(0, cols-1, cstride), cols-1]
|
|
polys = []
|
|
for rs, rs_next in zip(row_inds[:-1], row_inds[1:]):
|
|
for cs, cs_next in zip(col_inds[:-1], col_inds[1:]):
|
|
# +1 ensures we share edges between polygons
|
|
ps = cbook._array_perimeter(x[rs:rs_next+1, cs:cs_next+1]).T
|
|
polys.append(ps)
|
|
polys = np.asarray(polys)
|
|
assert np.array_equal(polys,
|
|
cbook._array_patch_perimeters(
|
|
x, rstride=rstride, cstride=cstride))
|
|
|
|
def divisors(n):
|
|
return [i for i in range(1, n + 1) if n % i == 0]
|
|
|
|
for rows, cols in [(5, 5), (7, 14), (13, 9)]:
|
|
x = np.arange(rows * cols).reshape(rows, cols)
|
|
for rstride, cstride in itertools.product(divisors(rows - 1),
|
|
divisors(cols - 1)):
|
|
check(x, rstride=rstride, cstride=cstride)
|
|
|
|
|
|
def test_setattr_cm():
|
|
class A:
|
|
cls_level = object()
|
|
override = object()
|
|
|
|
def __init__(self):
|
|
self.aardvark = 'aardvark'
|
|
self.override = 'override'
|
|
self._p = 'p'
|
|
|
|
def meth(self):
|
|
...
|
|
|
|
@classmethod
|
|
def classy(cls):
|
|
...
|
|
|
|
@staticmethod
|
|
def static():
|
|
...
|
|
|
|
@property
|
|
def prop(self):
|
|
return self._p
|
|
|
|
@prop.setter
|
|
def prop(self, val):
|
|
self._p = val
|
|
|
|
class B(A):
|
|
...
|
|
|
|
other = A()
|
|
|
|
def verify_pre_post_state(obj):
|
|
# When you access a Python method the function is bound
|
|
# to the object at access time so you get a new instance
|
|
# of MethodType every time.
|
|
#
|
|
# https://docs.python.org/3/howto/descriptor.html#functions-and-methods
|
|
assert obj.meth is not obj.meth
|
|
# normal attribute should give you back the same instance every time
|
|
assert obj.aardvark is obj.aardvark
|
|
assert a.aardvark == 'aardvark'
|
|
# and our property happens to give the same instance every time
|
|
assert obj.prop is obj.prop
|
|
assert obj.cls_level is A.cls_level
|
|
assert obj.override == 'override'
|
|
assert not hasattr(obj, 'extra')
|
|
assert obj.prop == 'p'
|
|
assert obj.monkey == other.meth
|
|
assert obj.cls_level is A.cls_level
|
|
assert 'cls_level' not in obj.__dict__
|
|
assert 'classy' not in obj.__dict__
|
|
assert 'static' not in obj.__dict__
|
|
|
|
a = B()
|
|
|
|
a.monkey = other.meth
|
|
verify_pre_post_state(a)
|
|
with cbook._setattr_cm(
|
|
a, prop='squirrel',
|
|
aardvark='moose', meth=lambda: None,
|
|
override='boo', extra='extra',
|
|
monkey=lambda: None, cls_level='bob',
|
|
classy='classy', static='static'):
|
|
# because we have set a lambda, it is normal attribute access
|
|
# and the same every time
|
|
assert a.meth is a.meth
|
|
assert a.aardvark is a.aardvark
|
|
assert a.aardvark == 'moose'
|
|
assert a.override == 'boo'
|
|
assert a.extra == 'extra'
|
|
assert a.prop == 'squirrel'
|
|
assert a.monkey != other.meth
|
|
assert a.cls_level == 'bob'
|
|
assert a.classy == 'classy'
|
|
assert a.static == 'static'
|
|
|
|
verify_pre_post_state(a)
|
|
|
|
|
|
def test_format_approx():
|
|
f = cbook._format_approx
|
|
assert f(0, 1) == '0'
|
|
assert f(0, 2) == '0'
|
|
assert f(0, 3) == '0'
|
|
assert f(-0.0123, 1) == '-0'
|
|
assert f(1e-7, 5) == '0'
|
|
assert f(0.0012345600001, 5) == '0.00123'
|
|
assert f(-0.0012345600001, 5) == '-0.00123'
|
|
assert f(0.0012345600001, 8) == f(0.0012345600001, 10) == '0.00123456'
|