def test_column_subset_boolean_invalid_dim(self):
x = np.random.random((10, 3))
l = Lineage(
x,
names=["foo", "bar", "baz"],
colors=[(0, 0, 0), (0.5, 0.5, 0.5), (1, 1, 1)],
)
with pytest.raises(IndexError):
y = l[:, [True]]
def test_names_setter_wrong_type(self):
l = Lineage(
np.random.random((10, 3)),
names=["foo", "bar", "baz"],
colors=[(0, 0, 0), (0.5, 0.5, 0.5), (1, 1, 1)],
)
l.names = ["foo1", "bar1", 3]
np.testing.assert_array_equal(l.names, np.array(["foo1", "bar1", "3"]))
def test_reordering(self):
x = np.random.random((10, 3))
l = Lineage(
x, names=["foo", "bar", "baz"], colors=["#ff0000", "#00ff00", "#0000ff"]
)
y = l[["baz", "bar", "foo"]]
np.testing.assert_array_equal(y.names, ["baz", "bar", "foo"])
np.testing.assert_array_equal(y.colors, ["#0000ff", "#00ff00", "#ff0000"])
def test_others(self):
names = ["foo", "bar", "baz", "quux"]
x = Lineage(np.random.random((10, 4)), names=names)
y = x[["foo, baz"] + [Lin.OTHERS]]
expected = x[["foo, baz", "bar", "quux"]]
np.testing.assert_array_equal(y.X, expected.X)
np.testing.assert_array_equal(y.names, expected.names)
np.testing.assert_array_equal(y.colors, expected.colors)
def test_column_invalid_name(self):
x = np.random.random((10, 3))
l = Lineage(
x,
names=["foo", "bar", "baz"],
colors=[(0, 0, 0), (0.5, 0.5, 0.5), (1, 1, 1)],
)
with pytest.raises(KeyError):
y = l["quux"]
def test_singleton_column_name(self):
x = np.random.random((10, 3))
l = Lineage(
x,
names=["foo", "bar", "baz"],
colors=[(0, 0, 0), (0.5, 0.5, 0.5), (1, 1, 1)],
)
y = l[:, "foo"]
np.testing.assert_array_equal(x[:, 0], np.array(y)[:, 0])
def test_subset_same_instance(self):
x = np.random.random((10, 3))
l = Lineage(
x,
names=["foo", "bar", "baz"],
colors=[(0, 0, 0), (0.5, 0.5, 0.5), (1, 1, 1)],
)
y = l[0, 0]
assert isinstance(y, Lineage)
def test_names_setter(self):
l = Lineage(
np.random.random((10, 3)),
names=["foo", "bar", "baz"],
colors=[(0, 0, 0), (0.5, 0.5, 0.5), (1, 1, 1)],
)
names = ["foo1", "bar1", "baz1"]
l.names = names
np.testing.assert_array_equal(l.names, np.array(names))
def test_colors_setter(self):
l = Lineage(
np.random.random((10, 3)),
names=["foo", "bar", "baz"],
colors=[(0, 0, 0), (0.5, 0.5, 0.5), (1, 1, 1)],
)
colors = ["#ffffff", "#ffffff", "#ffffff"]
l.colors = colors
np.testing.assert_array_equal(l.colors, np.array(colors))
def test_same_names(self):
x = Lineage(np.random.random((10, 4)),
names=["foo", "bar", "baz", "quux"])
y = x[np.arange(len(x)), ["foo"] * len(x)]
expected = x["foo"]
assert y.shape == (10, 1)
np.testing.assert_array_equal(y.X, expected.X)
np.testing.assert_array_equal(y.names, ["mixture"])
np.testing.assert_array_equal(y.colors, ["#000000"])
def test_row_subset_with_ints(self):
x = np.random.random((10, 3))
l = Lineage(
x,
names=["foo", "bar", "baz"],
colors=[(0, 0, 0), (0.5, 0.5, 0.5), (1, 1, 1)],
)
y = l[[1, 2, 3], :]
np.testing.assert_array_equal(x[[1, 2, 3], :], np.array(y))
def test_same_indices(self):
x = Lineage(np.random.random((10, 4)), names=["foo", "bar", "baz", "quux"])
half = len(x) // 2
y = x[[0] * len(x), ["foo"] * half + ["bar"] * half]
expected = np.array([x[0, "foo"].X[0, 0]] * half + [x[0, "bar"].X[0, 0]] * half)
assert y.shape == (10, 1)
np.testing.assert_array_equal(y.X.squeeze(), expected)
np.testing.assert_array_equal(y.names, ["mixture"])
np.testing.assert_array_equal(y.colors, ["#000000"])
def test_comb_row_int_col_names(self):
x = np.random.random((10, 3))
l = Lineage(
x,
names=["foo", "bar", "baz"],
colors=[(0, 0, 0), (0.5, 0.5, 0.5), (1, 1, 1)],
)
y = l[[0, 1], "baz"]
np.testing.assert_array_equal(x[[0, 1], :][:, [2]], np.array(y))
def test_stripped(self):
lineage = Lineage(np.zeros((1000, 4)),
names=["foo", "bar", "baz", "quux"])
# +2 for header and ...
p = SimpleHTMLValidator(
n_expected_rows=_HT_CELLS * 2 + 2,
n_expected_cells=(_HT_CELLS * 2 + 1) * lineage.shape[1],
)
p.feed(lineage._repr_html_())
p.validate()
def test_remove_duplicates(self):
x = np.random.random((10, 3))
l = Lineage(
x,
names=["foo", "bar", "baz"],
colors=[(0, 0, 0), (0.5, 0.5, 0.5), (1, 1, 1)],
)
y = l[0, ["foo", 2, "bar", 0, 0, "foo"]]
np.testing.assert_array_equal(x[[[0]], [0, 2, 1]], np.array(y))
def test_column_subset_with_names(self):
x = np.random.random((10, 3))
l = Lineage(
x,
names=["foo", "bar", "baz"],
colors=[(0, 0, 0), (0.5, 0.5, 0.5), (1, 1, 1)],
)
y = l[:, ["foo", "bar"]]
np.testing.assert_array_equal(x[:, [0, 1]], np.array(y))
def test_column_subset_boolean(self):
x = np.random.random((10, 3))
l = Lineage(
x,
names=["foo", "bar", "baz"],
colors=[(0, 0, 0), (0.5, 0.5, 0.5), (1, 1, 1)],
)
y = l[:, [False, False, True]]
np.testing.assert_array_equal(x[:, -1], y.X.squeeze())
def test_no_mixing(self):
x = Lineage(np.random.random((10, 4)), names=["foo", "bar", "baz", "quux"])
y = x[["foo", Lin.REST]]
expected = np.c_[np.sum(x.X[:, [0]], axis=1), np.sum(x.X[:, [1, 2, 3]], axis=1)]
assert y.shape == (10, 2)
np.testing.assert_array_equal(y.X, expected)
np.testing.assert_array_equal(y.names, ["foo", "rest"])
np.testing.assert_array_equal(
y.colors, [x.colors[0], _compute_mean_color(x.colors[1:])]
)
def test_row_subset(self):
x = Lineage(np.random.random((10, 4)),
names=["foo", "bar", "baz", "quux"])
y = x[:5, ["foo, bar"]]
expected = np.sum(x.X[:5, [0, 1]], axis=1)[..., np.newaxis]
assert y.shape == (5, 1)
np.testing.assert_array_equal(y.X, expected)
np.testing.assert_array_equal(y.names, ["bar or foo"])
np.testing.assert_array_equal(y.colors,
[_compute_mean_color(x.colors[:2])])
def test_singleton_column_first_index_assignment(self):
x = np.random.random((10, 3))
l = Lineage(
x,
names=["foo", "bar", "baz"],
colors=[(0, 0, 0), (0.5, 0.5, 0.5), (1, 1, 1)],
)
y = l["baz"]
np.testing.assert_array_equal(x[:, 2], np.array(y)[:, 0])
np.testing.assert_array_equal(y.names, ["baz"])
def test_singleton_row_and_column(self):
x = np.random.random((10, 3))
l = Lineage(
x,
names=["foo", "bar", "baz"],
colors=[(0, 0, 0), (0.5, 0.5, 0.5), (1, 1, 1)],
)
y = l[0, "foo"]
assert isinstance(l, Lineage)
assert y.shape == (1, 1)
assert x[0, 0] == y[0, 0]
def test_rest(self):
x = Lineage(np.random.random((10, 4)), names=["foo", "bar", "baz", "quux"])
y = x[["foo, bar", Lin.REST]]
expected = np.c_[np.sum(x.X[:, [0, 1]], axis=1), np.sum(x.X[:, [2, 3]], axis=1)]
assert y.shape == (10, 2)
np.testing.assert_array_equal(y.X, expected)
np.testing.assert_array_equal(y.names, ["bar or foo", "rest"])
np.testing.assert_array_equal(
y.colors,
[_compute_mean_color(x.colors[:2]), _compute_mean_color(x.colors[2:])],
)
def test_col_order(self):
x = np.random.random((10, 5))
l = Lineage(
x,
names=["foo", "bar", "baz", "quux", "wex"],
colors=["#ff0000", "#00ff00", "#0000ff", "#aaaaaa", "#bbbbbb"],
)
y = l[["wex", "quux"]]
np.testing.assert_array_equal(x[:, [4, 3]], y)
np.testing.assert_array_equal(y.names, ["wex", "quux"])
np.testing.assert_array_equal(y.colors, ["#bbbbbb", "#aaaaaa"])
def test_non_trivial_subset(self):
x = np.random.random((10, 3))
l = Lineage(
x, names=["foo", "bar", "baz"], colors=["#ff0000", "#00ff00", "#0000ff"]
)
mask = np.ones((x.shape[0]), dtype=np.bool)
mask[5:] = False
y = l[mask, :][:, ["baz", "bar", "foo"]]
np.testing.assert_array_equal(y, x[mask, :][:, ::-1])
np.testing.assert_array_equal(y.names, ["baz", "bar", "foo"])
np.testing.assert_array_equal(y.colors, ["#0000ff", "#00ff00", "#ff0000"])
def test_comb_row_mask_col_names(self):
x = np.random.random((10, 3))
l = Lineage(
x,
names=["foo", "bar", "baz"],
colors=[(0, 0, 0), (0.5, 0.5, 0.5), (1, 1, 1)],
)
mask = np.ones((x.shape[0]), dtype=np.bool)
mask[5:] = False
y = l[mask, ["baz", "bar"]]
np.testing.assert_array_equal(x[mask, :][:, [2, 1]], np.array(y))
def test_comb_row_int_col_mask(self):
x = np.random.random((10, 3))
l = Lineage(
x,
names=["foo", "bar", "baz"],
colors=[(0, 0, 0), (0.5, 0.5, 0.5), (1, 1, 1)],
)
mask = np.ones((x.shape[1]), dtype=np.bool)
mask[0] = False
y = l[[0, 1], mask]
np.testing.assert_array_equal(x[[0, 1], :][:, mask], np.array(y))
def test_row_subset_with_mask(self):
x = np.random.random((10, 3))
l = Lineage(
x,
names=["foo", "bar", "baz"],
colors=[(0, 0, 0), (0.5, 0.5, 0.5), (1, 1, 1)],
)
mask = np.ones((x.shape[0]), dtype=np.bool)
mask[:5] = False
y = l[mask, :]
np.testing.assert_array_equal(x[mask, :], np.array(y))
def test_mask_x_full_names_y(self):
x = np.random.random((10, 3))
l = Lineage(x, names=["Beta", "Epsilon", "Alpha"])
cmapper = dict(zip(l.names, l.colors))
mask = np.zeros(l.shape[0], dtype=np.bool)
mask[0] = True
mask[-1] = True
y = l[mask, ["Epsilon", "Alpha", "Beta"]]
assert y.shape == (2, 3)
np.testing.assert_array_equal(y.names, ["Epsilon", "Alpha", "Beta"])
np.testing.assert_array_equal(y.colors, [cmapper[n] for n in y.names])
np.testing.assert_array_equal(y.X, x[[0, -1], :][:, [1, 2, 0]])
def test_model_1_lineage(self, adata_cflare):
adata_cflare.obsm[AbsProbKey.FORWARD.s] = Lineage(np.ones(
(adata_cflare.n_obs, 1)),
names=["foo"])
model = create_model(adata_cflare)
model = model.prepare(adata_cflare.var_names[0],
"foo",
n_test_points=100).fit()
_ = model.predict()
assert model.x_test.shape == (100, 1)
xtest, xall = model.x_test, model.x_all
np.testing.assert_allclose(np.r_[xtest[0], xtest[-1]],
np.r_[np.min(xall),
np.max(xall)])
def test_passing_lineage_object(self):
a_fuzzy = np.array([
[0.3, 0.7, 0],
[0.2, 0.5, 0.3],
[0.1, 0.8, 0.1],
[0.4, 0.4, 0.2],
[0.5, 0.3, 0.2],
[0.6, 0.3, 0.1],
[0.3, 0.3, 0.4],
[0.2, 0.2, 0.6],
])
a_fuzzy_lin = Lineage(a_fuzzy, names=["0", "1", "2"])
b_np, c_np = _fuzzy_to_discrete(a_fuzzy=a_fuzzy, n_most_likely=2)
b_l, c_l = _fuzzy_to_discrete(a_fuzzy=a_fuzzy_lin, n_most_likely=2)
np.testing.assert_array_equal(b_np, b_l)
assert len(c_np) == 0
assert len(c_l) == 0