increase coverage for plots and debug tl tests

tests/conftest.py

@@ -46,7 +46,7 @@ def gen_zebrafish_test_data():
         del raw_adata
 
         preprocessor = dyn.pp.Preprocessor(cell_cycle_score_enable=True)
-        preprocessor.config_monocle_recipe(adata, n_top_genes=100)
+        preprocessor.config_monocle_recipe(adata, n_top_genes=40)
         preprocessor.filter_genes_by_outliers_kwargs["inplace"] = True
         preprocessor.select_genes_kwargs["keep_filtered"] = False
         preprocessor.pca_kwargs["n_pca_components"] = 5

tests/test_pl_utils.py

@@ -3,6 +3,7 @@
 
 import matplotlib.pyplot as plt
 import networkx as nx
+import numpy as np
 import pytest
 
 import dynamo as dyn
@@ -100,3 +101,156 @@ def test_nxviz7_circosplot(adata):
     dyn.pl.circosPlot(network, node_color_key="M_s", show_colorbar=False, edge_alpha_scale=1, edge_lw_scale=1)
     dyn.pl.circosPlot(network, node_color_key="M_s", show_colorbar=True, edge_alpha_scale=0.5, edge_lw_scale=0.4)
     # plt.show() # show via command line run.
+
+
+def test_scatters_markers_ezplots():
+    adata = dyn.sample_data.hematopoiesis()
+
+    ax = dyn.pl.cell_cycle_scores(adata, save_show_or_return="return")
+    assert isinstance(ax, plt.Axes)
+
+    ax = dyn.pl.pca(adata, color="cell_type", save_show_or_return="return")
+    assert isinstance(ax, plt.Axes)
+
+    ax = dyn.pl.umap(adata, color="cell_type", save_show_or_return="return")
+    assert isinstance(ax, plt.Axes)
+
+    ax = dyn.pl.cell_wise_vectors(adata, color=["cell_type"], basis="umap", save_show_or_return="return")
+    assert isinstance(ax, list)
+
+    ax = dyn.pl.streamline_plot(adata, color=["cell_type"], basis="umap", save_show_or_return="return")
+    assert isinstance(ax, list)
+
+    ax = dyn.pl.topography(adata, basis="umap", color=["ntr", "cell_type"], save_show_or_return="return")
+    assert isinstance(ax, list)
+
+    ax = dyn.pl.plot_X(adata.obsm["X_umap"], save_show_or_return="return")
+    assert isinstance(ax, plt.Axes)
+
+    ax = dyn.pl.plot_V(adata.obsm["X_pca"], adata.obsm["velocity_umap"], save_show_or_return="return")
+    assert isinstance(ax, plt.Axes)
+
+    ax = dyn.pl.zscatter(adata, save_show_or_return="return")
+    assert isinstance(ax, plt.Axes)
+
+    ax = dyn.pl.zstreamline(adata, save_show_or_return="return")
+    assert isinstance(ax, plt.Axes)
+
+    ax = dyn.pl.plot_jacobian_gene(adata, save_show_or_return="return")
+    assert isinstance(ax, list)
+
+    ax = dyn.pl.bubble(adata, genes=adata.var_names[:4], group="cell_type", save_show_or_return="return")
+    assert isinstance(ax, tuple)
+
+
+def test_lap_plots():
+    import numpy as np
+    import seaborn as sns
+
+    adata = dyn.sample_data.hematopoiesis()
+
+    progenitor = adata.obs_names[adata.obs.cell_type.isin(['HSC'])]
+
+    dyn.pd.fate(adata, basis='umap', init_cells=progenitor, interpolation_num=25, direction='forward',
+                inverse_transform=False, average=False)
+    ax = dyn.pl.fate_bias(adata, group="cell_type", basis="umap", save_show_or_return='return')
+    assert isinstance(ax, sns.matrix.ClusterGrid)
+
+    ax = dyn.pl.fate(adata, basis="umap", save_show_or_return='return')
+    assert isinstance(ax, plt.Axes)
+
+    # genes = adata.var_names[adata.var.use_for_dynamics]
+    # integer_pairs = [
+    #     (3, 21),
+    #     (2, 11),
+    # ]
+    # pair_matrix = [[genes[x[0]], genes[x[1]]] for x in integer_pairs]
+    # ax = dyn.pl.response(adata, pairs_mat=pair_matrix, return_data=True)
+    # assert isinstance(ax, tuple)
+
+    ax = dyn.plot.connectivity.plot_connectivity(adata, graph=adata.obsp["perturbation_transition_matrix"],
+                                            color=["cell_type"], save_show_or_return='return')
+    assert isinstance(ax, plt.Figure)
+
+    from dynamo.tools.utils import nearest_neighbors
+
+    fixed_points = np.array(
+        [
+            [8.45201833, 9.37697661],
+            [14.00630381, 2.53853712],
+        ]
+    )
+
+    HSC_cells_indices = nearest_neighbors(fixed_points[0], adata.obsm["X_umap"])
+    Meg_cells_indices = nearest_neighbors(fixed_points[1], adata.obsm["X_umap"])
+    dyn.pd.least_action(
+        adata,
+        [adata.obs_names[HSC_cells_indices[0]][0]],
+        [adata.obs_names[Meg_cells_indices[0]][0]],
+        basis="umap",
+        adj_key="X_umap_distances",
+        min_lap_t=True,
+        EM_steps=2,
+    )
+    ax = dyn.pl.least_action(adata, basis="umap", save_show_or_return="return")
+    assert isinstance(ax, plt.Axes)
+    ax = dyn.pl.lap_min_time(adata, basis="umap", save_show_or_return="return")
+    assert isinstance(ax, plt.Figure)
+
+
+def test_heatmaps():
+    import numpy as np
+    import pandas as pd
+
+    adata = dyn.sample_data.hematopoiesis()
+    genes = adata.var_names[adata.var.use_for_dynamics]
+    integer_pairs = [
+        (3, 21),
+        (2, 11),
+    ]
+    pair_matrix = [[genes[x[0]], genes[x[1]]] for x in integer_pairs]
+    ax = dyn.pl.response(adata, pairs_mat=pair_matrix, return_data=True)
+    assert isinstance(ax, tuple)
+    ax = dyn.pl.causality(adata, pairs_mat=np.array(pair_matrix), return_data=True)
+    assert isinstance(ax, pd.DataFrame)
+
+    integer_pairs = [
+        (3, 21, 23),
+        (2, 11, 7),
+    ]
+    pair_matrix = [[genes[x[0]], genes[x[1]], genes[x[2]]] for x in integer_pairs]
+    ax = dyn.pl.hessian(adata, pairs_mat=np.array(pair_matrix), return_data=True)
+    assert isinstance(ax, pd.DataFrame)
+
+    ax = dyn.pl.comb_logic(
+        adata, pairs_mat=np.array(pair_matrix), xkey="M_n", ykey="M_t", zkey="velocity_alpha_minus_gamma_s", return_data=True
+    )
+    assert isinstance(ax, pd.DataFrame)
+
+
+def test_preprocess(adata):
+    import seaborn as sns
+
+    ax = dyn.pl.basic_stats(adata, save_show_or_return="return")
+    assert isinstance(ax, sns.axisgrid.FacetGrid)
+
+    ax = dyn.pl.show_fraction(adata, save_show_or_return="return")
+    assert isinstance(ax, sns.axisgrid.FacetGrid)
+
+    ax = dyn.pl.variance_explained(adata, save_show_or_return="return")
+    assert isinstance(ax, plt.Axes)
+
+    ax = dyn.pl.biplot(adata, save_show_or_return="return")
+    assert isinstance(ax, plt.Axes)
+
+    ax = dyn.pl.loading(adata, n_pcs=4, ncol=2, save_show_or_return="return")
+    assert isinstance(ax, np.ndarray)
+
+    ax = dyn.pl.feature_genes(adata, save_show_or_return="return")
+    assert isinstance(ax, plt.Figure)
+
+    ax = dyn.pl.exp_by_groups(adata, genes=adata.var_names[:3], save_show_or_return="return")
+    assert isinstance(ax, sns.axisgrid.FacetGrid)
+
+    ax = dyn.pl.highest_frac_genes(adata)
+    assert isinstance(ax, plt.Axes)

tests/test_simulation.py

@@ -50,3 +50,41 @@ def test_simulate_anndata():
     kin_simulator.simulate(label_time=5)
     adata2 = kin_simulator.write_to_anndata(adata)
     assert adata2.n_vars == 2 and adata2.n_obs == 1000
+
+
+def test_Gillespie():
+    adata, adata2 = dyn.sim.Gillespie(
+        method="basic",
+        a=[0.8, 0.8],
+        b=[0.8, 0.8],
+        la=[0.8, 0.8],
+        aa=[0.8, 0.8],
+        ai=[0.8, 0.8],
+        si=[0.8, 0.8],
+        be=[1, 1],
+        ga=[1, 1],
+    )
+    assert adata.n_vars == 2
+
+    adata, adata2 = dyn.sim.Gillespie(
+        method="simulate_2bifurgenes",
+    )
+    assert adata.n_vars == 2
+
+    adata, adata2 = dyn.sim.Gillespie(
+        method="differentiation",
+    )
+    assert adata.n_vars == 2
+
+    adata, adata2 = dyn.sim.Gillespie(
+        method="oscillation",
+        a=[0.8, 0.8],
+        b=[0.8, 0.8],
+        la=[0.8, 0.8],
+        aa=[0.8, 0.8],
+        ai=[0.8, 0.8],
+        si=[0.8, 0.8],
+        be=[1, 1],
+        ga=[1, 1],
+    )
+    assert adata.n_vars == 2

tests/test_tl.py

@@ -6,7 +6,7 @@
 
 import dynamo as dyn
 from dynamo.tools.connectivity import (
-    _gen_neighbor_keys,
+    generate_neighbor_keys,
     check_and_recompute_neighbors,
     check_neighbors_completeness,
 )
@@ -156,6 +156,8 @@ def test_leiden_membership_input(adata):
 
 
 def test_DDRTree_pseudotime(adata):
+    import matplotlib.pyplot as plt
+
     adata = adata.copy()
     dyn.tl.order_cells(adata, basis="umap", maxIter=3, ncenter=10)
     assert "Pseudotime" in adata.obs.keys()
@@ -173,6 +175,9 @@ def test_DDRTree_pseudotime(adata):
     dyn.tl.pseudotime_velocity(adata, pseudotime="Pseudotime")
     assert "velocity_S" in adata.layers.keys()
 
+    ax = dyn.pl.plot_dim_reduced_direct_graph(adata, graph=adata.uns["directed_velocity_tree"], save_show_or_return="return")
+    assert isinstance(ax, list)
+
 
 def test_psl():
     arr = np.random.rand(20, 10)

tests/test_vf.py

@@ -17,16 +17,16 @@ def test_vector_calculus_rank_vf(adata):
     dyn.vf.speed(adata)
     assert "speed_umap" in adata.obs.keys()
 
-    dyn.vf.jacobian(adata, basis="umap", regulators=["ptmaa", "tmsb4x"], effectors=["ptmaa", "tmsb4x"], cell_idx=progenitor)
+    dyn.vf.jacobian(adata, basis="umap", regulators=["ptmaa", "rpl5b"], effectors=["ptmaa", "rpl5b"], cell_idx=progenitor)
     assert "jacobian_umap" in adata.uns.keys()
 
-    dyn.vf.hessian(adata, basis="umap", regulators=["tmsb4x"], coregulators=["ptmaa"], effector=["ptmaa"], cell_idx=progenitor)
+    dyn.vf.hessian(adata, basis="umap", regulators=["rpl5b"], coregulators=["ptmaa"], effector=["ptmaa"], cell_idx=progenitor)
     assert "hessian_umap" in adata.uns.keys()
 
     dyn.vf.laplacian(adata, hkey="hessian_umap", basis="umap")
     assert "Laplacian_umap" in adata.obs.keys()
 
-    dyn.vf.sensitivity(adata, basis="umap", regulators=["tmsb4x"], effectors=["ptmaa"], cell_idx=progenitor)
+    dyn.vf.sensitivity(adata, basis="umap", regulators=["rpl5b"], effectors=["ptmaa"], cell_idx=progenitor)
     assert "sensitivity_umap" in adata.uns.keys()
 
     dyn.vf.acceleration(adata, basis="pca")
@@ -75,8 +75,8 @@ def test_vector_calculus_rank_vf(adata):
     rank = dyn.vf.rank_sensitivity_genes(adata, skey="sensitivity_umap")
     assert len(rank["all"]) == len(adata.uns["sensitivity_umap"]["regulators"])
 
-    reg_dict = {"ptmaa": "ptmaa", "tmsb4x": "tmsb4x"}
-    eff_dict = {"ptmaa": "ptmaa", "tmsb4x": "tmsb4x"}
+    reg_dict = {"ptmaa": "ptmaa", "rpl5b": "rpl5b"}
+    eff_dict = {"ptmaa": "ptmaa", "rpl5b": "rpl5b"}
     rank = dyn.vf.aggregateRegEffs(adata, basis="umap", reg_dict=reg_dict, eff_dict=eff_dict, store_in_adata=False)
     assert rank["aggregation_gene"].shape[2] == adata.n_obs
 
@@ -87,3 +87,34 @@ def test_cell_vectors(adata):
     dyn.vf.cell_curvatures(adata)
     assert "acceleration_pca" in adata.obsm.keys()
     assert "curvature_pca" in adata.obsm.keys()
+
+
+def test_potential(adata):
+    import matplotlib.pyplot as plt
+
+    adata = adata.copy()
+    dyn.vf.Potential(adata, basis="umap")
+    assert "grid_Pot_umap" in adata.uns.keys()
+    adata.uns.pop("grid_Pot_umap")
+
+    dyn.vf.Potential(adata, basis="umap", method="Bhattacharya")
+    assert "grid_Pot_umap" in adata.uns.keys()
+
+    # too time-consuming
+    # dyn.vf.Potential(adata, basis="umap", boundary=[0, 10], method="Tang")
+    # assert "grid_Pot_umap" in adata.uns.keys()
+
+    ax = dyn.pl.show_landscape(adata, basis="umap", save_show_or_return="return")
+    assert isinstance(ax, plt.Axes)
+
+
+def test_networks(adata):
+    adata = adata.copy()
+
+    dyn.vf.jacobian(adata, basis="pca", regulators=["ptmaa", "rpl5b"], effectors=["ptmaa", "rpl5b"], cell_idx=np.arange(adata.n_obs))
+
+    res = dyn.vf.build_network_per_cluster(adata, cluster="Cell_type", genes=adata.var_names)
+    assert isinstance(res, dict)
+
+    res = dyn.vf.adj_list_to_matrix(adj_list=res["Neuron"])
+    assert isinstance(res, pd.DataFrame)