ReCoN

https://recon-doc.readthedocs.io/en/latest/
Admin
ReCoN is a tool for reconstructing multicellular models by combining gene regulatory networks and...
Tokens:65,204
Snippets:462
Trust Score:8.3
Update:7 months ago
Show doc for...
Tokens:
Raw
### Install ReCoN with GRN-lite

Source: https://recon-doc.readthedocs.io/en/latest/_sources/recon_explained/get_ready.rst

Installs the 'lite' branch of ReCoN directly using pip. This is a convenient way to get started with a specific version.

```bash
pip install recon[grn-lite]
```

--------------------------------

### Install ReCoN from GitHub (lite branch)

Source: https://recon-doc.readthedocs.io/en/latest/_sources/recon_explained/get_ready.rst

Installs the 'lite' branch of ReCoN directly from its GitHub repository. This is useful for installing a development version or when the package is not yet on PyPI.

```bash
pip install 'git+https://github.com/cantinilab/celloracle@lite'
```

--------------------------------

### Install ReCoN from Source for Development

Source: https://recon-doc.readthedocs.io/en/latest/_sources/recon_explained/get_ready.rst

Installs ReCoN directly from its GitHub repository, suitable for developers who need the latest code or wish to contribute. This method requires git and pip.

```bash
git clone https://github.com/cantinilab/recon.git
cd recon
pip install -e .
```

--------------------------------

### Correct genomepy Install Syntax

Source: https://recon-doc.readthedocs.io/en/latest/_sources/recon_explained/get_ready.rst

Demonstrates the correct syntax for the `genomepy install` command, specifically highlighting the use of the `-p` flag for specifying the genome provider. This resolves errors related to unexpected arguments.

```bash
# WRONG: genomepy install mm10 UCSC --annotation
# RIGHT:
genomepy install mm10 -p UCSC -a
```

--------------------------------

### Get ReCoN Version Info (Bash)

Source: https://recon-doc.readthedocs.io/en/latest/_sources/recon_explained/get_ready.rst

This snippet demonstrates how to retrieve version information for ReCoN and its dependencies using Python and bash commands. It's useful for bug reporting and understanding the installed environment.

```bash
# Get version info for bug report
python -c "import recon; print(recon.__version__)"
python --version
pip list | grep -E "recon|scanpy|numpy|pandas"
```

--------------------------------

### Troubleshoot gimmemotifs Installation Failure

Source: https://recon-doc.readthedocs.io/en/latest/_sources/recon_explained/get_ready.rst

Addresses installation issues with gimmemotifs by suggesting installation from conda-forge and bioconda channels. This method helps resolve C dependency problems that may arise during compilation.

```bash
conda install -c conda-forge -c bioconda gimmemotifs
```

--------------------------------

### Run ATAC-seq Tests After Genome Installation

Source: https://recon-doc.readthedocs.io/en/latest/_sources/recon_explained/get_ready.rst

Guides users on how to run ATAC-seq specific tests after ensuring the necessary genome (e.g., mm10) is installed. This includes installing celloracle, installing the genome, and then executing the relevant pytest command.

```bash
# Install celloracle
pip install 'git+https://github.com/cantinilab/celloracle@lite'

# Install genome
genomepy install mm10 -p UCSC -a

# Verify installation
ls ~/.local/share/genomes/mm10/

# Run tests
pytest tests/test_infer_grn.py -v
```

--------------------------------

### Install Reference Genomes to Custom Directory

Source: https://recon-doc.readthedocs.io/en/latest/_sources/recon_explained/get_ready.rst

Customizes the installation location for reference genomes used in ATAC-seq analysis. This is useful for managing storage space or organizing genome files in a specific path.

```bash
# Install to custom directory
genomepy install mm10 -p UCSC -a -g /path/to/genomes

# Or set environment variable
export GENOMES_DIR=/path/to/genomes
genomepy install mm10 -p UCSC -a
```

--------------------------------

### Install ReCoN Dependencies

Source: https://recon-doc.readthedocs.io/en/latest/recon_examples/2.recon_multicellular_coordination

Instructions for installing necessary Python packages for ReCoN, including gseapy and liana. It also notes the requirement for 'lxml' for gseapy's MSigDB functionality.

```bash
pip install gseapy liana
```

```bash
pip install lxml
```

--------------------------------

### Install Reference Genomes for ATAC-seq Analysis

Source: https://recon-doc.readthedocs.io/en/latest/_sources/recon_explained/get_ready.rst

Installs reference genomes (e.g., mm10, hg38) required for ATAC-seq data analysis, specifically for TF-to-peak motif scanning. This involves installing genomepy and then using it to download specific genomes.

```bash
# Install genomepy (included with celloracle)
pip install genomepy

# Install mouse genome (mm10)
genomepy install mm10 -p UCSC -a

# Install human genome (hg38)
genomepy install hg38 -p UCSC -a

# Check installed genomes
genomepy genomes

# List available genomes
genomepy search mouse
```

--------------------------------

### Install CellOracle for GRN Inference

Source: https://recon-doc.readthedocs.io/en/latest/recon_explained/get_ready

Explains how to install the CellOracle package, which is required for GRN inference with ATAC-seq data. It presents two options: installing ReCoN with 'grn-lite' extras or installing CellOracle separately from its lite branch.

```bash
# Option 1: Install our ‘lite’ branch direclty with recon: `pip install recon[grn-lite]`
# Option 2: Install it separately: `pip install 'git+https://github.com/cantinilab/celloracle@lite'`
```

--------------------------------

### Install ReCoN with GRN Inference (conda)

Source: https://recon-doc.readthedocs.io/en/latest/_sources/recon_explained/get_ready.rst

Installs ReCoN with optional GRN inference capabilities, requiring specific versions of gimmemotifs, celloracle (lite branch), and llvmlite. This installation uses conda for environment management and pip for package installation.

```bash
# Create environment with required dependencies
conda create -n recon  python=3.10
conda activate recon

# Install ReCoN with GRN extras
pip install recon[grn-lite]
```

--------------------------------

### Parallelize ReCoN Analysis Across Multiple Conditions (Python)

Source: https://recon-doc.readthedocs.io/en/latest/_sources/recon_explained/get_ready.rst

This example demonstrates how to parallelize the ReCoN analysis across multiple conditions using Python's `multiprocessing` module. It defines a function to run ReCoN for a given seed set and then uses a `Pool` to execute this function concurrently for different seed sets, improving performance for multiple condition comparisons.

```python
from multiprocessing import Pool

def run_recon(seed_set):
    return celltype.Multixrank(seeds=seed_set, alpha=0.8)

with Pool(4) as p:
    results = p.map(run_recon, [seeds1, seeds2, seeds3, seeds4])
```

--------------------------------

### Install Reference Genome with Genomepy

Source: https://recon-doc.readthedocs.io/en/latest/recon_examples/4.recon_hummus

Installs a reference genome and its annotation using the genomepy library. This is a prerequisite for downstream analyses like computing bipartite links.

```python
import genomepy
genomepy.install_genome("hg19", "UCSC", annotation=True)
```

--------------------------------

### Compare Conditions using ReCoN in Python

Source: https://recon-doc.readthedocs.io/en/latest/recon_explained/get_ready

Illustrates how to compare results between different conditions (e.g., control vs. treated) by running ReCoN's Multixrank analysis separately for each condition and then comparing the output scores.

```python
# Run ReCoN on both conditions
results_control = celltype.Multixrank(seeds=control_seeds, alpha=0.8)
results_treated = celltype.Multixrank(seeds=treated_seeds, alpha=0.8)
```

--------------------------------

### Install ReCoN with GRN Inference on macOS (conda)

Source: https://recon-doc.readthedocs.io/en/latest/_sources/recon_explained/get_ready.rst

Installs ReCoN with GRN inference capabilities on macOS, leveraging conda to manage system library dependencies for gimmemotifs and llvmlite. This ensures compatibility and proper compilation of C/C++ extensions.

```bash
# Create environment with required dependencies
conda create -n recon -c bioconda -c conda-forge python=3.10 gimmemotifs llvmlite cmake

conda activate recon

# Install ReCoN with GRN extras
pip install recon[grn-lite]
```

--------------------------------

### Troubleshoot llvmlite Build Failure on macOS

Source: https://recon-doc.readthedocs.io/en/latest/_sources/recon_explained/get_ready.rst

Provides a solution for llvmlite build failures on macOS by recommending installation via conda instead of pip. This ensures that necessary system LLVM libraries are correctly handled.

```bash
# Install via conda instead of pip
conda install -c conda-forge llvmlite numba
```

--------------------------------

### Initialize Multixrank Object with Seed Dictionary

Source: https://recon-doc.readthedocs.io/en/latest/recon_examples/2.recon_multicellular_coordination

Demonstrates the creation of a Multixrank object when seeds are provided as a dictionary, mapping seeds to their respective weights. This is a prerequisite for running the RWR algorithm with specific starting points.

```python
Seeds are provided as a dictionary with weights per seed.
Creating a multixrank object with seeds as a dictionary.
cell_communication
receptor
gene
receptor
gene
receptor
gene
receptor
gene
receptor
gene
receptor
gene
Identifying produced ligands in response to the perturbation.


```

--------------------------------

### Provide Custom GRN to ReCoN

Source: https://recon-doc.readthedocs.io/en/latest/_sources/recon_explained/get_ready.rst

Demonstrates how to create and use a custom Gene Regulatory Network (GRN) within ReCoN. This allows users to incorporate prior biological knowledge from sources like literature or ChIP-seq experiments.

```python
import pandas as pd
from recon.explore import Celltype

# Custom GRN from literature or ChIP-seq
custom_grn = pd.DataFrame({
    'source': ['TF1', 'TF1', 'TF2'],
    'target': ['GENE1', 'GENE2', 'GENE3'],
    'weight': [0.8, 0.6, 0.9]
})

celltype = Celltype(
    grn=custom_grn,
    receptor_grn=receptor_grn,
    name="MyCell"
)
```

--------------------------------

### Resolve "Genomes_dir does not exist" Error

Source: https://recon-doc.readthedocs.io/en/latest/_sources/recon_explained/get_ready.rst

Offers solutions for the "Genomes_dir does not exist" error when installing reference genomes. It suggests either creating the default directory or specifying a custom location using the `-g` flag.

```bash
# Option 1: Create default directory
mkdir -p ~/.local/share/genomes

# Option 2: Use custom directory
genomepy install mm10 -p UCSC -a -g /path/to/genomes
```

--------------------------------

### Install ReCoN with GRN dependencies (Python)

Source: https://recon-doc.readthedocs.io/en/latest/index

Installs the ReCoN Python package along with necessary dependencies for GRN generation using Conda and Pip. It sets up a dedicated Conda environment for ReCoN.

```bash
conda create -n recon python=3.10
conda activate recon
pip install recon[grn-lite]
```

--------------------------------

### Define Seeds for ReCoN Analysis

Source: https://recon-doc.readthedocs.io/en/latest/_sources/recon_explained/get_ready.rst

Shows two common ways to define 'seeds' for ReCoN analysis: as a dictionary mapping genes to scores, or as a simple list of genes. Seeds represent the entry points of a treatment or perturbation in the network.

```python
# Dictionary format: {gene: score}
seeds = {'RECEPTOR1': 1.0, 'TF1': 0.8}

# Or list format (all seeds weighted equally)seeds = ['RECEPTOR1', 'TF1', 'GENE1']
```

--------------------------------

### Save ReCoN Configuration for Reproducibility (Python)

Source: https://recon-doc.readthedocs.io/en/latest/_sources/recon_explained/get_ready.rst

This code snippet details how to save the complete configuration of a ReCoN analysis to a JSON file. This is crucial for ensuring reproducibility by archiving parameters such as ReCoN version, alpha value, seeds, graph types, and the number of genes used.

```python
# Save complete configuration
import json

config = {
    'recon_version': '0.1.0',
    'alpha': 0.8,
    'seeds': seeds,
    'graph_types': {'GRN': '01', 'Receptor': '01'},
    'n_genes': len(celltype.multiplexes['GRN'])
}

with open('recon_config.json', 'w') as f:
    json.dump(config, f, indent=2)
```

--------------------------------

### JavaScript: Making an HTTP GET Request

Source: https://recon-doc.readthedocs.io/en/latest/_sources/recon_examples/1.recon_molecular_treatment.ipynb

This JavaScript code snippet illustrates how to perform an HTTP GET request to a given URL using the 'fetch' API. It processes the response, checks for errors, and returns the data as JSON. This is commonly used in front-end or Node.js applications.

```javascript
async function fetchData(url) {
  try {
    const response = await fetch(url);
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    const data = await response.json();
    return data;
  } catch (error) {
    console.error('Error fetching data:', error);
    return null;
  }
}

// Example usage:
// const apiUrl = 'https://api.example.com/data';
// fetchData(apiUrl).then(data => {
//   if (data) {
//     console.log(data);
//   }
// });
```

--------------------------------

### Create Gene Seed Dictionary with Equal Weights (Python)

Source: https://recon-doc.readthedocs.io/en/latest/_sources/recon_examples/2.recon_multicellular_coordination.ipynb

Initializes a dictionary where each gene is assigned a score of 1, indicating equal importance for all genes. This is a starting point for defining gene seeds.

```python
# Create seed dictionary with equal weights (all genes equally important)
gene_seeds = {seed: 1 for seed in gene_seeds}
```

--------------------------------

### Check bedtools Installation and PATH Configuration

Source: https://recon-doc.readthedocs.io/en/latest/recon_examples/4.recon_hummus

This Python script checks for the 'bedtools' executable and attempts to add its directory to the system's PATH if not found. It's crucial for ATAC-seq processing and relies on `os` and `shutil` modules.

```python
import os
import shutil

# Check if bedtools is available
if shutil.which("bedtools") is None:
    # Try to find bedtools in common conda locations
    conda_prefix = os.environ.get("CONDA_PREFIX", "")
    possible_paths = [
        f"{conda_prefix}/bin",
        os.path.expanduser("~/miniconda3/bin"),
        os.path.expanduser("~/anaconda3/bin"),
        "/usr/local/bin",
    ]
    for path in possible_paths:
        bedtools_path = os.path.join(path, "bedtools")
        if os.path.exists(bedtools_path):
            os.environ["PATH"] = path + ":" + os.environ["PATH"]
            print(f"Added {path} to PATH")
            break
    
# Verify bedtools is now available
!which bedtools && bedtools --version
```

--------------------------------

### Export ReCoN Results to CSV and Excel (Python)

Source: https://recon-doc.readthedocs.io/en/latest/_sources/recon_explained/get_ready.rst

This example shows how to export ReCoN results, specifically the Gene Regulatory Network (GRN) and Receptor scores, into pandas DataFrames. It demonstrates saving these DataFrames to both a CSV file and an Excel file with multiple sheets.

```python
# Save to CSV
results['GRN'].to_csv('recon_results.csv')

# Save to Excel with multiple sheets
with pd.ExcelWriter('recon_results.xlsx') as writer:
    results['GRN'].to_excel(writer, sheet_name='GRN')
    results['Receptor'].to_excel(writer, sheet_name='Receptors')
```

--------------------------------

### Fetch All Tutorial Data with ReCoN

Source: https://recon-doc.readthedocs.io/en/latest/API/load_data

Downloads all available tutorial data files for ReCoN. It allows specifying a directory to save the files and an option to force re-downloading even if files already exist. Returns a dictionary mapping filenames to their local paths.

```python
from recon.data.load_data import fetch_all_tutorial_data

# Download all tutorial data to the default directory
data_paths = fetch_all_tutorial_data()

# Download to a specific directory and force re-download
# custom_paths = fetch_all_tutorial_data(_data_dir='./my_data', _force=True)
```

--------------------------------

### Fetch Specific Tutorial Data with ReCoN

Source: https://recon-doc.readthedocs.io/en/latest/API/load_data

Downloads a specific tutorial data file from Zenodo for ReCoN. You can specify the filename, the base directory for saving, and whether to force re-download. It returns the local path to the downloaded file.

```python
from recon.data import fetch_tutorial_data
import scanpy as sc
import muon as mu

# Download and load RNA data for perturbation tutorial
rna_path = fetch_tutorial_data("perturbation_tuto/rna.h5ad")
rna = sc.read_h5ad(rna_path)

# Download and load multimodal data for GRN inference tutorial
mdata_path = fetch_tutorial_data("build_grn_tuto/pbmc10x.h5mu")
mdata = mu.read(mdata_path)

# Download a specific file to a custom directory
# treated_rna_path = fetch_tutorial_data("perturbation_tuto/rna_treated.h5ad", _data_dir='./custom_data', _force=True)
```

--------------------------------

### Download All Tutorial Data with ReCoN (Python)

Source: https://recon-doc.readthedocs.io/en/latest/index

This Python code snippet demonstrates how to download all available tutorial data for ReCoN. It uses the `fetch_all_tutorial_data` function from the `recon.data` module and specifies a directory to save the data.

```python
from recon.data import fetch_all_tutorial_data
fetch_all_tutorial_data(data_dir='./data')
```

--------------------------------

### Python: Basic Configuration Loading

Source: https://recon-doc.readthedocs.io/en/latest/_sources/recon_examples/1.recon_molecular_treatment.ipynb

This Python snippet shows a simple way to load configuration settings from a JSON file. It defines a function to read the file and return its contents as a dictionary. Error handling for file not found is included. This is useful for managing application settings.

```python
import json

def load_config(config_path):
    """Loads configuration from a JSON file.

    Args:
        config_path (str): The path to the JSON configuration file.

    Returns:
        dict: The configuration settings, or None if the file cannot be read.
    """
    try:
        with open(config_path, 'r') as f:
            config = json.load(f)
        return config
    except FileNotFoundError:
        print(f"Error: Configuration file not found at {config_path}")
        return None
    except json.JSONDecodeError:
        print(f"Error: Could not decode JSON from {config_path}")
        return None

# Example usage:
# config_file = 'config.json'
# settings = load_config(config_file)
# if settings:
#     print(settings)
```

--------------------------------

### Download Tutorial Data with ReCoN

Source: https://recon-doc.readthedocs.io/en/latest/recon_examples/4.recon_hummus

Provides Python code to download all tutorial data or specific files like RNA data for use with ReCoN. It utilizes functions from the `recon.data` module.

```python
from recon.data import fetch_all_tutorial_data
fetch_all_tutorial_data(data_dir='./data')
```

```python
from recon.data import fetch_tutorial_data
fetch_tutorial_data('perturbation_tuto/rna.h5ad', data_dir='./data')
```

--------------------------------

### Download Specific Tutorial Data File with ReCoN (Python)

Source: https://recon-doc.readthedocs.io/en/latest/index

This Python code snippet shows how to download a specific tutorial data file, such as RNA data, using ReCoN. It utilizes the `fetch_tutorial_data` function from `recon.data`, specifying the file path and the data directory.

```python
from recon.data import fetch_tutorial_data
fetch_tutorial_data('perturbation_tuto/rna.h5ad', data_dir='./data')
```

--------------------------------

### Install ReCoN without GRN dependencies (Python)

Source: https://recon-doc.readthedocs.io/en/latest/index

Installs the ReCoN Python package without the GRN generation dependencies. This is useful if you are generating GRNs externally. It allows for the use of more recent Python versions.

```bash
pip install recon
```

--------------------------------

### Get Unique Cell Types from RNA Data

Source: https://recon-doc.readthedocs.io/en/latest/recon_examples/3.recon_molecular_cascades

Retrieves a list of unique cell types present in the 'celltype' observation column of the loaded scRNA-seq data (anndata object).

```python
# Check available cell types
rna.obs["celltype"].unique().tolist()
```

--------------------------------

### Run Random Walk with Restart using Multixrank in Python

Source: https://recon-doc.readthedocs.io/en/latest/_sources/recon_examples/2.recon_multicellular_coordination.ipynb

This code snippet illustrates the execution of the Random Walk with Restart (RWR) algorithm using the Multixrank library in Python. It initializes a Multixrank object with a specified restart probability and then runs the random walk to obtain ranked results. The output is typically a DataFrame containing scores for nodes, indicating their relevance based on the RWR process.

```python
# Create multiXrank object
multilayer = generic_multicell.Multixrank(
    restart_proba=restart_proba
)

# Run random walk with restart
results = multilayer.random_walk_rank()
```

--------------------------------

### Python: Data Processing Utility

Source: https://recon-doc.readthedocs.io/en/latest/_sources/recon_examples/1.recon_molecular_treatment.ipynb

A Python utility function for processing a list of dictionaries. This example focuses on filtering and transforming data based on specific criteria. It assumes the input is a list of dictionaries and returns a processed list. No external libraries are strictly required for this basic version.

```python
def process_data_list(data_list, filter_key, filter_value, transform_key):
    """Processes a list of dictionaries by filtering and transforming.

    Args:
        data_list (list): A list of dictionaries.
        filter_key (str): The key to filter by.
        filter_value (any): The value to match for filtering.
        transform_key (str): The key whose value will be returned after filtering.

    Returns:
        list: A list of transformed values.
    """
    processed_items = []
    for item in data_list:
        if item.get(filter_key) == filter_value and transform_key in item:
            processed_items.append(item[transform_key])
    return processed_items

# Example usage:
# sample_data = [
#     {'id': 1, 'name': 'Alice', 'status': 'active'},
#     {'id': 2, 'name': 'Bob', 'status': 'inactive'},
#     {'id': 3, 'name': 'Charlie', 'status': 'active'}
# ]
# active_names = process_data_list(sample_data, 'status', 'active', 'name')
# print(active_names) # Output: ['Alice', 'Charlie']
```

--------------------------------

### Import Libraries for Multi-omics Data Handling

Source: https://recon-doc.readthedocs.io/en/latest/recon_examples/4.recon_hummus

Imports libraries for handling multi-omics data (`muon`) and single-cell analysis (`scanpy`). The `scanpy` import may trigger a `FutureWarning` regarding version checking.

```python
import muon as mu   # Multi-omics data handling
import scanpy as sc # Single-cell analysis
```

--------------------------------

### Initialize Multixrank Object for RWR

Source: https://recon-doc.readthedocs.io/en/latest/recon_examples/2.recon_multicellular_coordination

Initializes the Multixrank object with a specified restart probability. This object is then used to perform the random walk with restart algorithm on a multilayer network.

```python
# Create multiXrank object
multilayer = generic_multicell.Multixrank(
    restart_proba=restart_proba
)

# Run random walk with restart
results = multilayer.random_walk_rank()

```

--------------------------------

### Initialize Gene Seeds for Macrophages in Python

Source: https://recon-doc.readthedocs.io/en/latest/recon_examples/2.recon_multicellular_coordination

This snippet initializes gene seeds specifically for Macrophages based on provided gene scores. It filters genes with positive scores and creates a dictionary mapping gene names to scores, appending '::Macrophage' to each gene. It then prints the first three example seeds.

```python
seeds = {f"{gene}::Macrophage": score for gene, score in gene_seeds.items() if score > 0}

print(f"Example seeds: {dict(list(seeds.items())[:3])}")
```

--------------------------------

### Compare RWR Scores Between Conditions (Python)

Source: https://recon-doc.readthedocs.io/en/latest/_sources/recon_explained/get_ready.rst

This snippet demonstrates how to compare Random Walk with Restart (RWR) scores between control and treated conditions using ReCoN. It involves running ReCoN on both sets of seeds, then creating a pandas DataFrame to calculate and identify genes with the largest score changes.

```python
# Run ReCoN on both conditions
results_control = celltype.Multixrank(seeds=control_seeds, alpha=0.8)
results_treated = celltype.Multixrank(seeds=treated_seeds, alpha=0.8)

# Compare scores
import pandas as pd
comparison = pd.DataFrame({
    'control': results_control['GRN'],
    'treated': results_treated['GRN']
})
comparison['delta'] = comparison['treated'] - comparison['control']

# Genes with largest changes
top_changes = comparison.nlargest(20, 'delta')
```

--------------------------------

### Initialize Cell Type Suffix and Network Parameters

Source: https://recon-doc.readthedocs.io/en/latest/recon_examples/3.recon_molecular_cascades

This snippet initializes a dictionary for cell type suffixes and sets various parameters for network construction, including graph directionality and weighting, and restart probability for random walks.

```python
# Add celltype suffix for seeds
seeds_with_suffix = {f"{g}::{focal_celltype}": 1.0 for g in seed_genes}

# Network parameters
cell_communication_graph_directed = False
cell_communication_graph_weighted = True
restart_proba = 0.6
grn_graph_weighted = True
grn_graph_directed = False
```

--------------------------------

### Generate Sankey Diagram for Treatment Flow (Python)

Source: https://recon-doc.readthedocs.io/en/latest/_sources/recon_explained/get_ready.rst

This code snippet illustrates how to generate a Sankey diagram using ReCoN's plotting functionality. The diagram visualizes the flow of treatment effects from source cell types to target cell types through the network, highlighting the top N connections.

```python
from recon.plot import plot_sankey

plot_sankey(
    multicell=multicell,
    results=results,
    source_celltype='Tumor',
    target_celltype='T_cell',
    top_n=10
)
```

--------------------------------

### Import Necessary Libraries for GRN Inference

Source: https://recon-doc.readthedocs.io/en/latest/recon_examples/4.recon_hummus

Imports essential Python libraries for Gene Regulatory Network (GRN) inference, including HuMMuS utilities, CIRCE for ATAC-seq data, and ReCoN for GRN inference. It also shows the output of CellOracle and ReCoN initialization.

```python
import hummuspy.loader  # HuMMuS multilayer network utilities
import circe as ci       # ATAC-seq co-accessibility networks
import recon             # ReCoN GRN inference
import recon.infer_grn   # ReCoN GRN inference
```

--------------------------------

### Plotly Graph Configuration and Initialization (HTML/JavaScript)

Source: https://recon-doc.readthedocs.io/en/latest/_sources/recon_examples/3.recon_molecular_cascades.ipynb

This snippet demonstrates how to embed and initialize a Plotly graph within an HTML document. It includes the necessary Plotly.js library and a JavaScript call to `Plotly.newPlot` to render a graph with specific data and layout configurations. The configuration defines link colors, source and target data, and values for the plot.

```html
<div>                        <script type="text/javascript">window.PlotlyConfig = {MathJaxConfig: 'local'};</script>
        <script charset="utf-8" src="https://cdn.plot.ly/plotly-3.3.1.min.js" integrity="sha256-4rD3fugVb/nVJYUv5Ky3v+fYXoouHaBSP20WIJuEiWg=" crossorigin="anonymous"></script>                <div id="50abd228-8394-48dc-b466-b15dbc7b4009" class="plotly-graph-div" style="height:100%; width:100%;"></div>            <script type="text/javascript">                window.PLOTLYENV=window.PLOTLYENV || {};                                if (document.getElementById("50abd228-8394-48dc-b466-b15dbc7b4009")) {                    Plotly.newPlot(
                        "50abd228-8394-48dc-b466-b15dbc7b4009",
                        [{"link":{"color":["rgba(50, 239, 197, 0.6)","rgba(79, 178, 195, 0.6)","rgba(50, 239, 197, 0.6)","rgba(50, 239, 197, 0.6)","rgba(50, 239, 197, 0.6)","rgba(50, 239, 197, 0.6)","rgba(50, 239, 197, 0.6)","rgba(13, 111, 88, 0.6)","rgba(26, 4, 86, 0.6)","rgba(26, 4, 86, 0.6)","rgba(79, 178, 195, 0.6)","rgba(79, 178, 195, 0.6)","rgba(55, 158, 221, 0.6)","rgba(55, 158, 221, 0.6)","rgba(26, 4, 86, 0.6)","rgba(55, 158, 221, 0.6)","rgba(100,200,100,1)","rgba(100,200,100,1)","rgba(100,200,100,1)","rgba(100,200,100,1)","rgba(100,200,100,1)","rgba(100,200,100,1)","rgba(100,200,100,1)","rgba(100,200,100,1)","rgba(100,200,100,1)","rgba(100,200,100,1)","rgba(100,200,100,1)","rgba(100,200,100,1)","rgba(100,200,100,1)","rgba(100,200,100,1)","rgba(100,200,100,1)","rgba(100,200,100,1)","rgba(100,200,100,1)","rgba(100,200,100,1)","rgba(100,200,100,1)","rgba(100,200,100,1)","rgba(100,200,100,1)","rgba(100,200,100,1)","rgba(100,200,100,1)","rgba(100,200,100,1)","rgba(100,200,100,1)","rgba(100,200,100,1)","rgba(100,200,100,1)","rgba(100,200,100,1)","rgba(100,200,100,1)","rgba(100,200,100,1)","rgba(100,200,100,1)","rgba(100,200,100,1)","rgba(100,200,100,1)","rgba(100,200,100,1)","rgba(100,200,100,1)"],"source":{"bdata":"AAIDBQcICAoLCwwNDg4PEQEBAQEBARAQCQkJCQkJBgYGBgQEFBcTEhgVEhYXFRUUGBMWFhg=","dtype":"i1"},"target":{"bdata":"AQEEBgYJCQYJCQYGCQkQEBITFBUWFxMWEhQYFRYXFBUWFxMWGRoZGhkZGRkZGxoaGhobGhs=","dtype":"i1"},"value":{"bdata":"AAAAIK+30T8AAABggobDPwAAAEB1X74\u002fAAAAoDLtrD8AAACgKCSnPwAAAICjP6Q\u002fAAAAgKM\u002fpD8AAACAoz+kPwAAAICjP6Q\u002fAAAAgKM\u002fpD8AAACAoz+kPwAAAICjP6Q\u002fAAAAoCgklz8AAACgKCSXPwAAAGAeW5E\u002fAAAAoCgkhz80UD6bY52uP2a7t8gZMtA\u002f7Qx6uWxzhD8j+7zsFHt6P1sembl1nqg\u002f4rubkqt1wD\u002f98SDk1vCZPynSyvBB8ac\u002fnixI\u002f3s1hD+zUGHglimHP8Mir\u002f2yx7E\u002fiO4W553JfD8goycOunOVPzxYHMBlroY\u002fBh7M6ePifz\u002ffMtaKYcd1P6bm4aQLs4Q\u002fpHMpmi1ngT9Caxyv\u002f2qwP9z9FOrEI8k\u002fxYq6T6QKwj\u002fqIdBS5+6+P3PHprSsp7k\u002fJ0eHKiJEtz8iYzLBZCW3PytXMwLqGbc\u002fOTQr3s0Hsz+B1xdla4+tP\u002f\u002fMugTtv6M\u002fpufoClAFnz9qtBfqDPSePzPALZJ4PJ0\u002fR+guqDLZmT9xNWwCYBWYP9tXqwqJ4pY\u002fqDWC2c5",
                        "dtype":"i1"}
                      ],
                        {
                         "bargap": 0.05,
                         "bargroupgap": 0.1,
                         "domain": {
                          "x": [0, 1],
                          "y": [0, 1]
                         },
                         "grid": {
                          "bordercolor": "#E5ECF6",
                          "color": "white",
                          "roworder": "reversed",
                          "showgrid": true,
                          "side": "all",
                          "width": 2
                         },
                         "legend": {
                          "traceorder": "normal"
                         },
                         "margin": {
                          "r": 100,
                          "t": 100
                         },
                         "paper_bgcolor": "#E5ECF6",
                         "plot_bgcolor": "white",
                         "scene": {
                          "aspectmode": "cube",
                          "camera": {
                           "center": {
                            "x": 0,
                            "y": 0,
                            "z": 0
                           },
                           "eye": {
                            "x": 1.25,
                            "y": 1.25,
                            "z": 1.25
                           },
                           "up": {
                            "x": 0,
                            "y": 0,
                            "z": 1
                           }
                          },
                          "xaxis": {
                           "backgroundcolor": "#E5ECF6",
                           "gridcolor": "white",
                           "gridwidth": 2,
                           "linecolor": "white",
                           "showbackground": true,
                           "ticks": "",
                           "zerolinecolor": "white"
                          },
                          "yaxis": {
                           "backgroundcolor": "#E5ECF6",
                           "gridcolor": "white",
                           "gridwidth": 2,
                           "linecolor": "white",
                           "showbackground": true,
                           "ticks": "",
                           "zerolinecolor": "white"
                          },
                          "zaxis": {
                           "backgroundcolor": "#E5ECF6",
                           "gridcolor": "white",
                           "gridwidth": 2,
                           "linecolor": "white",
                           "showbackground": true,
                           "ticks": "",
                           "zerolinecolor": "white"
                          }
                         },
                         "shapedefaults": {
                          "line": {
                           "color": "#2a3f5f"
                          }
                         },
                         "ternary": {
                          "aaxis": {
                           "gridcolor": "white",
                           "linecolor": "white",
                           "ticks": ""
                          },
                          "baxis": {
                           "gridcolor": "white",
                           "linecolor": "white",
                           "ticks": ""
                          },
                          "bgcolor": "#E5ECF6",
                          "caxis": {
                           "gridcolor": "white",
                           "linecolor": "white",
                           "ticks": ""
                          }
                         },
                         "title": {
                          "x": 0.05
                         },
                         "xaxis": {
                          "automargin": true,
                          "gridcolor": "white",
                          "linecolor": "white",
                          "ticks": "",
                          "title": {
                           "standoff": 15
                          },
                          "zerolinecolor": "white",
                          "zerolinewidth": 2
                         },
                         "yaxis": {
                          "automargin": true,
                          "gridcolor": "white",
                          "linecolor": "white",
                          "ticks": "",
                          "title": {
                           "standoff": 15
                          },
                          "zerolinecolor": "white",
                          "zerolinewidth": 2
                         }
                        }
                       },
                       {"title": {
                        "text": "Top regulators from other cell types:\n Ligand → Receptor → TF → Gene"
                       }
                      }
                    );
                }
            </script></div>
```

--------------------------------

### Compare Scores and Identify Top Gene Changes with Pandas

Source: https://recon-doc.readthedocs.io/en/latest/recon_explained/get_ready

This snippet demonstrates how to create a pandas DataFrame to compare scores between control and treated groups, calculate the difference (delta), and identify the top 20 genes with the largest changes. It assumes 'results_control' and 'results_treated' are pandas DataFrames containing 'GRN' scores.

```python
import pandas as pd
comparison = pd.DataFrame({
    'control': results_control['GRN'],
    'treated': results_treated['GRN']
})
comparison['delta'] = comparison['treated'] - comparison['control']
top_changes = comparison.nlargest(20, 'delta')
```

--------------------------------

### Define Seed Genes and Focal Cell Type (Python)

Source: https://recon-doc.readthedocs.io/en/latest/_sources/recon_examples/3.recon_molecular_cascades.ipynb

This snippet defines initial parameters for network analysis. It sets a list of 'seed genes' (e.g., inflammatory signaling genes), specifies a 'focal cell type', and then creates a dictionary where seed genes are mapped to a weight of 1.0, with their cell type appended. This is crucial for initiating network propagation or analysis from specific starting points.

```python
# Define seed genes (example: inflammatory signaling genes)
seed_genes = ["Nfkb1", "Tnf", "Il6", "Ccl2", "Cxcl10"]

# Define focal cell type
focal_celltype = "Macrophage"

# Add celltype suffix for seeds
seeds_with_suffix = {f"{g}::{focal_celltype}": 1.0 for g in seed_genes}
```
Tokens:
Raw