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