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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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
def test_pretty_naming_axis_None(self, lineage: Lineage):
y = lineage.sum(axis=None)
np.testing.assert_array_equal(y.names, ["sum"])
def test_pretty_naming_axis_1(self, lineage: Lineage):
y = lineage.max(axis=1)
np.testing.assert_array_equal(y.names, ["max of foo, bar, baz, quux"])
def test_return_weights_mode_dist(self, lineage: Lineage):
lin, weights = lineage.reduce("foo", "bar", mode="dist", return_weights=True)
assert isinstance(lin, Lineage)
assert isinstance(weights, DataFrame)
def test_return_weights_mode_scale(self, lineage: Lineage):
lin, weights = lineage.reduce("foo", "bar", mode="scale", return_weights=True)
assert isinstance(lin, Lineage)
assert weights is None
def test_invalid_weight_normalize(self, lineage: Lineage):
with pytest.raises(ValueError):
lineage.reduce("foo", "bar", normalize_weights="foo")
def test_invalid_dist_measure(self, lineage: Lineage):
with pytest.raises(ValueError):
lineage.reduce("foo", "bar", dist_measure="foo")
def test_invalid_mode(self, lineage: Lineage):
with pytest.raises(ValueError):
lineage.reduce("foo", "bar", mode="foo")
def test_all_names(self, lineage: Lineage):
lin = lineage.reduce(*lineage.names)
np.testing.assert_array_equal(lin.X, lineage.X)
def test_invalid_key(self, lineage: Lineage):
with pytest.raises(KeyError):
lineage.reduce("non_existent")