pyCoReGraph 0.0.1a1__tar.gz

pycoregraph-0.0.1a1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 JosephLeger
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pycoregraph-0.0.1a1/PKG-INFO

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: pyCoReGraph
+Version: 0.0.1a1
+Summary: CoReGraph : Correlation-based dynamic gene Regulatory Graphs
+Author-email: Joseph Léger <josephleger@outlook.fr>
+License: MIT
+Project-URL: Homepage, https://github.com/JosephLeger/CoReGraph
+Project-URL: Repository, https://github.com/JosephLeger/CoReGraph
+Project-URL: Issues, https://github.com/JosephLeger/CoReGraph/issues
+Keywords: bioinformatics,single-cell,gene-regulatory-network,pseudotime,correlation,network-analysis,visualization
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24
+Requires-Dist: pandas>=2.0
+Requires-Dist: matplotlib>=3.7
+Requires-Dist: networkx>=3.0
+Requires-Dist: scipy>=1.10
+Requires-Dist: tqdm>=4.65
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: build>=1.0; extra == "dev"
+Requires-Dist: twine>=5.0; extra == "dev"
+Requires-Dist: ruff>=0.4; extra == "dev"
+Requires-Dist: black>=24.0; extra == "dev"
+Requires-Dist: ipykernel>=6.0; extra == "dev"
+Provides-Extra: notebook
+Requires-Dist: jupyter>=1.0; extra == "notebook"
+Requires-Dist: ipython>=8.0; extra == "notebook"
+Provides-Extra: all
+Requires-Dist: pytest>=8.0; extra == "all"
+Requires-Dist: build>=1.0; extra == "all"
+Requires-Dist: twine>=5.0; extra == "all"
+Requires-Dist: ruff>=0.4; extra == "all"
+Requires-Dist: black>=24.0; extra == "all"
+Requires-Dist: ipykernel>=6.0; extra == "all"
+Requires-Dist: jupyter>=1.0; extra == "all"
+Requires-Dist: ipython>=8.0; extra == "all"
+Dynamic: license-file
+
+# CoReGraph : **Co**rrelation-based dynamic gene **Re**gulatory **Graph**s
+
+A Python package for dynamic lagged gene correlation analysis along pseudotime trajectories.
+
+## Requirments
+
+```bash
+python >= 3.10
+```
+
+## Installation
+
+```bash
+pip install coregraph
+```

pycoregraph-0.0.1a1/README.md

@@ -0,0 +1,15 @@
+# CoReGraph : **Co**rrelation-based dynamic gene **Re**gulatory **Graph**s
+
+A Python package for dynamic lagged gene correlation analysis along pseudotime trajectories.
+
+## Requirments
+
+```bash
+python >= 3.10
+```
+
+## Installation
+
+```bash
+pip install coregraph
+```

pycoregraph-0.0.1a1/pyproject.toml

@@ -0,0 +1,102 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pyCoReGraph"
+version = "0.0.1a1"
+description = "CoReGraph : Correlation-based dynamic gene Regulatory Graphs"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+
+authors = [
+    { name = "Joseph Léger", email = "josephleger@outlook.fr" }
+]
+
+keywords = [
+    "bioinformatics",
+    "single-cell",
+    "gene-regulatory-network",
+    "pseudotime",
+    "correlation",
+    "network-analysis",
+    "visualization"
+]
+
+classifiers = [
+    "Development Status :: 3 - Alpha",
+
+    "Intended Audience :: Science/Research",
+    "Topic :: Scientific/Engineering :: Bio-Informatics",
+
+    "License :: OSI Approved :: MIT License",
+
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+
+    "Operating System :: OS Independent"
+]
+
+dependencies = [
+    "numpy>=1.24",
+    "pandas>=2.0",
+    "matplotlib>=3.7",
+    "networkx>=3.0",
+    "scipy>=1.10",
+    "tqdm>=4.65"
+]
+
+[project.optional-dependencies]
+
+dev = [
+    "pytest>=8.0",
+    "build>=1.0",
+    "twine>=5.0",
+    "ruff>=0.4",
+    "black>=24.0",
+    "ipykernel>=6.0"
+]
+
+notebook = [
+    "jupyter>=1.0",
+    "ipython>=8.0"
+]
+
+all = [
+    "pytest>=8.0",
+    "build>=1.0",
+    "twine>=5.0",
+    "ruff>=0.4",
+    "black>=24.0",
+    "ipykernel>=6.0",
+    "jupyter>=1.0",
+    "ipython>=8.0"
+]
+
+[project.urls]
+Homepage = "https://github.com/JosephLeger/CoReGraph"
+Repository = "https://github.com/JosephLeger/CoReGraph"
+Issues = "https://github.com/JosephLeger/CoReGraph/issues"
+
+[tool.setuptools]
+include-package-data = true
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["coregraph*"]
+
+[tool.black]
+line-length = 88
+target-version = ["py310"]
+
+[tool.ruff]
+line-length = 88
+target-version = "py310"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

pycoregraph-0.0.1a1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pycoregraph-0.0.1a1/src/coregraph/__init__.py

@@ -0,0 +1,57 @@
+__version__ = "0.0.1a1"
+
+# Models
+from coregraph.models import (
+    CoReGraph_Cors,
+    CoReGraph_Graphics,
+    CoReGraph,
+    StarGraph,
+)
+
+# Analysis
+from coregraph.analysis.queries import (
+    get_correlation,
+    get_all_correlations,
+    get_mac,
+    get_mac_results,
+    get_regulated_genes,
+    get_regulator_genes,
+)
+
+# Graphics
+from coregraph.graphics.plots import (
+    plot_expression,
+    plot_correlations,
+)
+
+from coregraph.graphics.animations import (
+    animate_correlations,
+)
+
+from coregraph.graphics.network import (
+    animate_network,
+)
+
+from coregraph.analysis.subset import (
+    starry,
+    subset_coregraph,
+)
+
+__all__ = [
+    "CoReGraph",
+    "CoReGraph_Cors",
+    "CoReGraph_Graphics",
+    "StarGraph",
+    "get_correlation",
+    "get_all_correlations",
+    "get_mac",
+    "get_mac_results",
+    "get_regulated_genes",
+    "get_regulator_genes",
+    "plot_expression",
+    "plot_correlations",
+    "animate_correlations",
+    "animate_network",
+    "starry",
+    "subset_coregraph"
+]

pycoregraph-0.0.1a1/src/coregraph/analysis/__init__.py

@@ -0,0 +1,45 @@
+from .correlations import (
+    _calculate_all_cors,
+    _calculate_LEAP_cors,
+    _calculate_star_cors,
+)
+
+from .bins import (
+    _calculate_bins,
+)
+
+from .fdr import (
+    _calculate_FDR,
+    _calculate_star_FDR
+)
+
+from .queries import (
+    get_correlation,
+    get_all_correlations,
+    get_mac,
+    get_mac_results,
+    get_regulated_genes,
+    get_regulator_genes,
+)
+
+__all__ = [
+    # Correlations
+    "_calculate_all_cors",
+    "_calculate_LEAP_cors",
+    "_calculate_star_cors",
+
+    # FDR
+    "_calculate_FDR",
+    "_calculate_star_FDR",
+
+    # Bins
+    "_calculate_bins",
+
+    # Queries
+    "get_correlation",
+    "get_all_correlations",
+    "get_mac",
+    "get_mac_results",
+    "get_regulated_genes",
+    "get_regulator_genes",
+]

pycoregraph-0.0.1a1/src/coregraph/analysis/bins.py

@@ -0,0 +1,23 @@
+## BINS ##
+
+import numpy as np
+
+
+def _calculate_bins(data, pseudotime, n_bins):
+    '''Discretize pseudotime expression in bins'''
+    
+    bin_range = (pseudotime.max() - pseudotime.min())/n_bins
+    bin_seq   = pseudotime.min() + np.arange(1,n_bins)*bin_range
+    bins      = (np.digitize(pseudotime, bin_seq)*bin_range)+(bin_range/2)
+    
+    mean_res  = np.empty((data.shape[0], n_bins), dtype=np.float64)
+    std_res   = np.empty((data.shape[0], n_bins), dtype=np.float64)
+    for i, b in enumerate(np.unique(bins)):
+        mean_res[:,i] = np.mean(data[:,bins==b], axis=1)
+        std_res[:,i]  = np.mean(data[:,bins==b], axis=1)
+
+    mean    = mean_res
+    std     = std_res
+    scaled  = mean/np.max(mean, axis=1)[:, None]
+
+    return bins, mean, std, scaled

pycoregraph-0.0.1a1/src/coregraph/analysis/correlations.py

@@ -0,0 +1,110 @@
+## CORRELATIONS ##
+
+import numpy as np
+
+
+def _calculate_all_cors(data, window, i, tensor, reflag, MAC, LAG_id, LAG, LAG_means, dim3_start, step=1, num_format=np.array([1,15]), dtype=np.float64):
+    '''Calculate all lagged correlations for a unique given reference i'''
+    dim3 = dim3_start
+    n_genes, n_cells = data.shape
+
+    data_ref     = data[:,i:window+i]
+    mean_ref     = np.mean(data_ref, axis=1)
+    cent_ref     = data_ref.T - mean_ref
+    rowsumx_ref  = np.sum(cent_ref, axis=0).reshape(1, -1)
+    rowsumx2_ref = np.sum(np.square(cent_ref), axis=0).reshape(1, -1)
+
+    for j in range(i, n_cells-window+1, step):
+        data_lag     = data[:,j:window+j]
+        mean_lag     = np.mean(data_lag, axis=1)
+        cent_lag     = data_lag.T - mean_lag
+        rowsumx_lag  = np.sum(cent_lag, axis=0).reshape(1, -1)
+        rowsumx2_lag = np.sum(np.square(cent_lag), axis=0).reshape(1, -1)
+
+        Cor = (np.dot(cent_ref.T, cent_lag) - (1 / window) * np.dot(rowsumx_ref.T, rowsumx_lag)) / \
+            np.dot(np.sqrt(rowsumx2_ref - rowsumx_ref**2 / window).T, np.sqrt(rowsumx2_lag - rowsumx_lag**2 / window))
+        
+        np.fill_diagonal(Cor, 1)
+        Cor              = np.round(np.nan_to_num(Cor, nan=0)*num_format[0], num_format[1])
+        Cor              = Cor.astype(dtype)
+        tensor[:,:,dim3] = Cor
+        LAG_means[dim3]  = mean_lag
+        reflag[dim3,0]   = i
+        reflag[dim3,1]   = j
+
+        # Update MAC
+        ind       = np.abs(MAC) < np.abs(Cor)
+        MAC[ind]         = Cor[ind]
+        LAG[ind]         = j-i
+        LAG_id[0][ind]   = i
+        LAG_id[1][ind]   = j
+        #
+        dim3 += 1
+
+    return dim3, MAC, LAG_id, LAG, LAG_means
+
+def _calculate_LEAP_cors(data, window, i=0, step=1, num_format=np.array([1,15]), dtype=np.float64):
+    '''Calculate all lagged correlations for a unique given reference i using LEAP traditional algorithm'''
+    n_genes, n_cells = data.shape
+    MAC              = np.zeros((n_genes, n_genes))
+    LAG              = np.zeros((n_genes, n_genes))
+
+    data_ref     = data[:,i:window+i]
+    mean_ref     = np.mean(data_ref, axis=1)
+    cent_ref     = data_ref.T - mean_ref
+    rowsumx_ref  = np.sum(cent_ref, axis=0).reshape(1, -1)
+    rowsumx2_ref = np.sum(np.square(cent_ref), axis=0).reshape(1, -1)
+
+    for j in range(i, n_cells - window, step):
+        data_lag     = data[:,j:window+j]
+        mean_lag     = np.mean(data_lag, axis=1)
+        cent_lag     = data_lag.T - mean_lag
+        rowsumx_lag  = np.sum(cent_lag, axis=0).reshape(1, -1)
+        rowsumx2_lag = np.sum(np.square(cent_lag), axis=0).reshape(1, -1)
+
+        Cor = np.dot(cent_ref.T, cent_lag) - (1 / window) * np.dot(rowsumx_ref.T, rowsumx_lag) / \
+            np.dot(np.sqrt(rowsumx2_ref - rowsumx_ref**2 / window).T, np.sqrt(rowsumx2_lag - rowsumx_lag**2 / window))
+        
+        np.fill_diagonal(Cor, 1)
+        Cor              = np.round(np.nan_to_num(Cor, nan=0)*num_format[0], num_format[1])
+        Cor              = Cor.astype(dtype)
+        # Update MAC
+        ind = np.where(np.abs(MAC) > np.abs(Cor))
+        LAG[ind] = j - i
+        MAC[ind] = Cor[ind]
+
+    return MAC, LAG
+
+
+def _calculate_star_cors(data, target_row, MAC, window, i, step=1, num_format=np.array([1,15]), dtype=np.float64):
+    '''Calculate all lagged correlations for a unique given reference i using a single reference row against all rows.'''
+
+    n_genes, n_cells = data.shape
+
+    # Take reference row only
+    data_ref = data[target_row, i:window+i]
+    mean_ref = np.mean(data_ref)
+    cent_ref = data_ref - mean_ref
+
+    sum_ref  = np.sum(cent_ref)
+    sum_ref2 = np.sum(np.square(cent_ref), axis=0)
+
+    for j in range(i, n_cells - window, step):
+        data_lag = data[:, j:window+j]
+        mean_lag = np.mean(data_lag, axis=1)
+        cent_lag = data_lag - mean_lag[:, None]
+
+        rowsumx_lag  = np.sum(cent_lag, axis=1)
+        rowsumx2_lag = np.sum(cent_lag * cent_lag, axis=1)
+        cross = np.dot(cent_lag, cent_ref)
+
+        Cor = (cross - (rowsumx_lag * sum_ref) / window) / \
+            (np.sqrt(rowsumx2_lag - (rowsumx_lag * rowsumx_lag) / window) * np.sqrt(sum_ref2 - (sum_ref * sum_ref) / window))
+        
+        Cor = np.round(np.nan_to_num(Cor, nan=0)*num_format[0], num_format[1])
+        Cor = Cor.astype(dtype)
+
+        ind      = np.where(np.abs(MAC) < np.abs(Cor))
+        MAC[ind] = Cor[ind]
+
+    return MAC

pycoregraph-0.0.1a1/src/coregraph/analysis/fdr.py

@@ -0,0 +1,100 @@
+## FDR ##
+
+import numpy as np
+
+from coregraph.analysis.correlations import (_calculate_LEAP_cors, _calculate_star_cors)
+
+
+def _calculate_FDR(data, MAC, window, n_perms = 100, FDR_cutoffs = 101, step=1, num_format=np.array([1,15]), dtype=np.float64):
+    '''Calculate False Discovery Rate by permutations'''
+
+    MAC_true  = np.absolute(MAC.copy())
+    samp_size = np.minimum(100, data.shape[0])
+    MACs_perm = np.zeros((n_perms, samp_size, samp_size))
+    np.fill_diagonal(MAC_true, -1)
+
+    # simplified MAC_counter function
+    for n in range(0, n_perms):
+        np.random.seed(n)
+        data_perm = data[0:samp_size,:].copy()
+        inds      = np.random.choice(data.shape[0], size=samp_size, replace=False)
+
+        for z in range(0, samp_size):
+            data_perm[z,:] = np.random.permutation(data[inds[z],:])
+  
+        MAC_p, _ = _calculate_LEAP_cors(data_perm, window, 0, step, num_format, dtype)
+        MAC_p = np.absolute(MAC_p)
+        np.fill_diagonal(MAC_p, -1)
+        MACs_perm[n] = MAC_p
+
+    # Calculate FDR 
+    cors          = np.linspace(0, 1, FDR_cutoffs)
+    num_cors_perm = np.full(FDR_cutoffs, 0)
+    MACs_observed = np.full(FDR_cutoffs, 0)
+
+    for r in range(0, FDR_cutoffs):
+        num_cors_perm[r] += np.sum(MACs_perm >= cors[r])
+        MACs_observed[r] += np.sum(MAC_true >= cors[r])
+
+    perm_size     = samp_size*samp_size-samp_size
+    obs_size      = MAC_true.shape[0]*MAC_true.shape[1]-MAC_true.shape[0]
+    MACs_ave_perm = num_cors_perm/n_perms*(obs_size/perm_size)
+    fdr           = np.full(FDR_cutoffs, np.nan)
+
+    for s in range(0,FDR_cutoffs):
+        if MACs_observed[s] == 0:
+            fdr[s] = 0
+        else:
+            fdr[s] = MACs_ave_perm[s]/MACs_observed[s]
+
+    results = np.column_stack((cors, MACs_observed, MACs_ave_perm, fdr))
+       
+    return results[::-1]
+
+def _calculate_star_FDR(data, target_row, MAC, window, n_perms = 100, FDR_cutoffs = 101, step=1, num_format=np.array([1,15]), dtype=np.float64):
+    '''Calculate False Discovery Rate by permutations for a single reference row against all rows.'''
+
+    MAC_true  = np.absolute(MAC.copy())
+    samp_size = np.minimum(100, data.shape[0])
+    MACs_perm = np.zeros((n_perms, samp_size))
+    MAC_true[target_row] = -1
+
+    # simplified MAC_counter function
+    for n in range(0, n_perms):
+        np.random.seed(n)
+        ref_perm  = data[target_row,:].copy()
+        data_perm = data[0:samp_size-1,:].copy()
+        data_perm = np.concatenate((ref_perm.reshape((1,-1)), data_perm))
+        inds      = np.random.choice(data.shape[0], size=samp_size, replace=False)
+
+        for z in range(0, samp_size):
+            data_perm[z,:] = np.random.permutation(data[inds[z],:])
+  
+        MAC_p        = _calculate_star_cors(data_perm, 0, np.zeros((samp_size), dtype=dtype), window, i=0, step=step, num_format=num_format, dtype=dtype)
+        MAC_p        = np.absolute(MAC_p)
+        MAC_p[0]     = -1
+        MACs_perm[n] = MAC_p
+
+    ### Calculate FDR ###
+    cors          = np.linspace(0, 1, FDR_cutoffs)
+    num_cors_perm = np.full(FDR_cutoffs, 0)
+    MACs_observed = np.full(FDR_cutoffs, 0)
+
+    for r in range(0, FDR_cutoffs):
+        num_cors_perm[r] += np.sum(MACs_perm >= cors[r])
+        MACs_observed[r] += np.sum(MAC_true >= cors[r])
+
+    perm_size     = samp_size-1
+    obs_size      = MAC_true.shape[0]-1
+    MACs_ave_perm = num_cors_perm/n_perms*(obs_size/perm_size)
+    fdr           = np.full(FDR_cutoffs, np.nan)
+
+    for s in range(0,FDR_cutoffs):
+        if MACs_observed[s] == 0:
+            fdr[s] = 0
+        else:
+            fdr[s] = MACs_ave_perm[s]/MACs_observed[s]
+
+    results = np.column_stack((cors, MACs_observed, MACs_ave_perm, fdr))
+       
+    return results[::-1]

pycoregraph-0.0.1a1/src/coregraph/analysis/queries.py

@@ -0,0 +1,118 @@
+## QUERIES ##
+
+from __future__ import annotations
+
+import numpy as np
+import pandas as pd
+
+from coregraph.utils.decorators import (requires_cors, requires_FDR)
+
+
+@requires_cors
+def get_correlation(C: CoReGraph, regulator: str, target: str, ref_lag: tuple[int, int]) -> float:
+    '''Get correlation value between two genes at a specific (reference, lag) window pair.'''  
+    ref, lag = ref_lag
+
+    if (ref % C.cors.step != 0) or (lag % C.cors.step != 0):
+        raise ValueError(f"ref_lag must be multiples of step={C.cors.step}")
+
+    reg_idx = C.gene_to_idx[regulator]
+    tar_idx = C.gene_to_idx[target]
+
+    if ref <= lag:
+        tensor_i = reg_idx
+        tensor_j = tar_idx
+        search_ref = ref
+        search_lag = lag
+    else:
+        tensor_i = tar_idx
+        tensor_j = reg_idx
+        search_ref = lag
+        search_lag = ref
+
+    dim3 = np.argwhere((C.cors.reflag[:, 0] == search_ref) & (C.cors.reflag[:, 1] == search_lag))[0][0]
+
+    value = (C.cors.tensor[tensor_i, tensor_j, dim3] / C.cors.num_format[0])
+
+    return float(value)
+
+
+@requires_cors
+def get_all_correlations(C: CoReGraph, regulator: str, target: str, ref: int) -> np.ndarray:
+    '''Get all lagged correlations between two genes for a fixed reference window.'''
+    if (ref % C.cors.step != 0) :
+        raise ValueError(f"ref must be a multiple of step={C.cors.step}")
+
+    correlations = np.empty(C.cors.n_steps, dtype=C.cors.dtype)
+
+    for i in range(C.cors.n_steps):
+        lag = i * C.cors.step
+        correlations[i] = get_correlation(C,regulator,target,(ref, lag))
+
+    return correlations
+
+
+@requires_cors
+def get_mac(C: CoReGraph, regulator: str, target: str) -> dict:
+    '''Get maximal absolute correlation (MAC) and corresponding reference/lag pair for two genes.'''
+    reg_idx = C.gene_to_idx[regulator]
+    tar_idx = C.gene_to_idx[target]
+
+    return {
+        "ref": int(C.cors.LAG_id[0, reg_idx, tar_idx]), 
+        "lag": int(C.cors.LAG_id[1, reg_idx, tar_idx]),
+        "cor": float(C.cors.MAC[reg_idx, tar_idx] / C.cors.num_format[0])
+        }
+
+
+@requires_cors
+def get_mac_results(C: CoReGraph) -> tuple[pd.DataFrame, pd.DataFrame]:
+    '''Get MAC and LAG matrices.'''
+    mac_df = pd.DataFrame(C.cors.MAC / C.cors.num_format[0], index=C.gene_id, columns=C.gene_id)
+    lag_df = pd.DataFrame(C.cors.LAG, index=C.gene_id, columns=C.gene_id)
+
+    return mac_df, lag_df
+
+
+@requires_cors
+@requires_FDR
+def get_regulated_genes(C: CoReGraph, regulator: str, cor_threshold: float=0.0) -> pd.DataFrame:
+    '''Get genes regulated by a regulator gene.'''
+    reg_idx = C.gene_to_idx[regulator]
+
+    values = (C.cors.MAC[reg_idx, :] / C.cors.num_format[0])
+
+    df = pd.DataFrame({
+        "gene": C.gene_id,
+        "correlation": values,
+        "lag": C.cors.LAG[reg_idx, :]
+        })
+
+    df = df[np.abs(df["correlation"]) > cor_threshold]
+
+    df = df.sort_values(by="correlation", key=np.abs, ascending=False)
+
+    return df.set_index("gene")
+
+
+@requires_cors
+@requires_FDR
+def get_regulator_genes(C: CoReGraph, target: str, cor_threshold: float=0.0) -> pd.DataFrame:
+    '''Get genes regulated by a regulator gene.'''
+    tar_idx = C.gene_to_idx[target]
+
+    values = (C.cors.MAC[:, tar_idx] / C.cors.num_format[0])
+
+    df = pd.DataFrame({
+        "gene": C.gene_id,
+        "correlation": values,
+        "lag": C.cors.LAG[:, tar_idx]
+        })
+
+    df = df[np.abs(df["correlation"]) > cor_threshold]
+
+    df = df.sort_values(by="correlation", key=np.abs, ascending=False)
+
+    return df.set_index("gene")
+
+