pyCoReGraph 0.0.1a1__py3-none-any.whl

coregraph/graphics/network.py

@@ -0,0 +1,214 @@
+## NETWORK ##
+
+from __future__ import annotations
+
+import numpy as np
+import networkx as nx
+import matplotlib.pyplot as plt
+import matplotlib.cm as cm
+import matplotlib.colors as mcolors
+
+from matplotlib.animation import FuncAnimation
+
+from coregraph.analysis.queries import (get_all_correlations, get_mac)
+from coregraph.utils.decorators import (requires_cors, requires_FDR)
+
+
+def _build_correlation_tensor(C, genes, correlation_threshold):
+    '''
+    Build tensor (n_genes, n_genes, n_steps) containing all dynamic correlations.
+    '''
+    n          = len(genes)
+    cor_tensor = np.zeros((n, n, C.cors.n_steps), dtype=C.cors.dtype)
+
+    for i, regulator in enumerate(genes):
+        for j, target in enumerate(genes):
+            if i == j:
+                continue
+    
+            ref_lag_cor = get_mac(C, regulator, target)
+            ref         = ref_lag_cor["ref"]
+
+            all_cors = get_all_correlations(C, regulator, target, ref)
+            all_cors[np.abs(all_cors) < correlation_threshold] = 0
+
+            cor_tensor[i, j, :] = all_cors[:C.cors.n_steps]
+
+    return cor_tensor
+
+
+def _build_adjacency_tensor(cor_tensor):
+    '''
+    Keep strongest direction only between pairs.
+    '''
+    adjacency = np.abs(cor_tensor) > np.abs(cor_tensor.transpose(1, 0, 2))
+    filtered  = cor_tensor.copy()
+    filtered[~adjacency] = 0
+
+    return filtered
+
+
+def _compute_node_sizes(C, genes, node_ratio=1):
+    '''
+    Compute node size evolution through time.
+    '''
+    gene_indices = [C.gene_to_idx[g] for g in genes]
+
+    return (node_ratio * 1000 * C.cors.LAG_scaled[:C.cors.n_steps, gene_indices])
+
+
+def _build_graph_layout(genes):
+    '''
+    Create stable graph layout.
+    '''
+    G = nx.DiGraph()
+    G.add_nodes_from(range(len(genes)))
+    pos = nx.spring_layout(G, seed=33)
+
+    return G, pos
+
+
+def _compute_edge_style(G, cmap, norm, edge_ratio):
+    '''
+    Compute edge colors and widths.
+    '''
+    weights     = nx.get_edge_attributes(G, 'weight')
+    edge_colors = [cmap(norm(w)) for w in weights.values()]
+    edge_widths = [abs(w) * edge_ratio for w in weights.values()]
+
+    return (weights, edge_colors, edge_widths)
+
+
+def _draw_network_frame(ax, G, pos, genes, adjacency_matrix, node_sizes, cmap, norm, edge_ratio, font_size, min_target_margin, min_source_margin):
+    '''
+    Draw single network frame.
+    '''
+    ax.clear()
+    G.clear_edges()
+    n = len(genes)
+
+    # Add edges
+    for i in range(n):
+        for j in range(n):
+            weight = adjacency_matrix[i, j]
+            if weight != 0:
+                G.add_edge(i, j, weight=weight)
+
+    # Edge style
+    (weights, edge_colors, edge_widths) = _compute_edge_style(G, cmap, norm, edge_ratio)
+
+    # Draw nodes
+    nx.draw_networkx_nodes(G, pos, ax=ax, node_size=node_sizes, node_color='skyblue')
+
+    # Draw labels
+    nx.draw_networkx_labels(G, pos, labels={i: gene for i, gene in enumerate(genes)}, ax=ax, font_size=font_size)
+
+    # Draw edges
+    edges = nx.draw_networkx_edges(G, pos, ax=ax, edge_color=edge_colors, width=edge_widths, arrowstyle='-|>', min_target_margin=min_target_margin, min_source_margin=min_source_margin,)
+
+    for edge in edges:
+        edge.set_joinstyle("miter")
+        edge.set_capstyle("butt")
+
+
+@requires_cors
+@requires_FDR
+def animate_network(
+    C: CoReGraph,
+    genes: list[str],
+    fdr_threshold: float=0.01,
+    correlation_threshold: float | None = None,
+    edge_ratio: float=1,
+    node_ratio: float=1,
+    min_target_margin: float=15,
+    min_source_margin: float=15,
+    font_size: int=8,
+    figsize: tuple=(6, 6)
+):
+    '''
+    Animate dynamic gene regulatory network.
+
+    Parameters
+    ----------
+    C : CoreGraph
+        CoreGraph object.
+
+    genes : list[str]
+        Genes to include in network.
+
+    fdr_threshold : float
+        FDR threshold used to infer minimum correlation threshold.
+
+    correlation_threshold : float | None
+        Correlation threshold.
+
+    edge_ratio : float
+        Edge width scaling factor.
+
+    node_ratio : float
+        Node size scaling factor.
+
+    figsize : tuple
+        Figure size.
+   '''
+    # Validate threshold
+    if correlation_threshold is None:
+        correlation_threshold = np.min(C.cors.FDR.loc[C.cors.FDR["FDR"] < fdr_threshold, "cors"])
+
+    # Filter genes
+    genes = [g for g in genes if g in C.gene_to_idx]
+
+    # Build correlation tensor and graph
+    cor_tensor = _build_correlation_tensor(C, genes, correlation_threshold)
+    cor_tensor = _build_adjacency_tensor(cor_tensor)
+    node_sizes = _compute_node_sizes(C, genes, node_ratio=node_ratio)
+    G, pos     = _build_graph_layout(genes)
+
+    # Figure
+    fig, ax = plt.subplots(figsize=figsize)
+    cmap    = cm.bwr
+    vmin    = cor_tensor.min()
+    vmax    = cor_tensor.max()
+
+    if vmin == vmax:
+        vmax += 1e-10
+
+    norm = mcolors.TwoSlopeNorm(vmin=vmin, vcenter=0.0, vmax=vmax)
+
+    # Edge normalization
+    if C.cors.dtype == np.int64:
+        edge_ratio *= 0.01
+    else:
+        edge_ratio *= 10
+
+
+    # Update function
+    def update(frame):
+        adjacency_matrix = cor_tensor[:, :, frame]
+        _draw_network_frame(
+            ax=ax,
+            G=G,
+            pos=pos,
+            genes=genes,
+            adjacency_matrix=adjacency_matrix,
+            node_sizes=node_sizes[frame],
+            cmap=cmap,
+            norm=norm,
+            edge_ratio=edge_ratio,
+            font_size=font_size,
+            min_target_margin=min_target_margin,
+            min_source_margin=min_source_margin,
+        )
+
+        ax.set_title(f"Time step {frame * C.cors.step}")
+
+        return ax
+
+    # Create animation
+    if plt.rcParams["animation.embed_limit"] < 250:
+        plt.rcParams["animation.embed_limit"] = 250
+
+    ani = FuncAnimation(fig, update, frames=C.cors.n_steps, interval=1000, repeat=True, blit=False)
+    plt.close(fig)
+    # HTML(ani.to_jshtml())
+    return ani

coregraph/graphics/plots.py

@@ -0,0 +1,85 @@
+## PLOTS ##
+
+from __future__ import annotations
+
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib.patches as patches
+
+from coregraph.graphics.colors import ColorBlind
+from coregraph.analysis.queries import (get_correlation)
+from coregraph.utils.decorators import (requires_cors, requires_bins)
+
+
+@requires_bins
+def plot_expression(C: CoReGraph, genes: str | list[str], scaled: bool=False, std: bool=False, color=None, linewidth: float=1, figsize: tuple=(8,4)):
+    '''Plot gene expression along pseudotime.'''
+
+    ### TODO : make std parameter functional ###
+
+    if C.graphics.n_bins is None:
+        raise ValueError("Bins have not been calculated.")
+    
+    if isinstance(genes, str):
+        genes = [genes]
+
+    # Handle colors — one per gene if not specified
+    if color is None:
+        colors = plt.cm.tab10(np.linspace(0, 1, len(genes)))
+    elif isinstance(color, str):
+        colors = [color] * len(genes)
+    else:
+        colors = color
+
+    values  = (C.graphics.scaled if scaled else C.graphics.mean)
+    fig, ax = plt.subplots(figsize=figsize)
+    x       = np.unique(C.graphics.bin_id)
+
+    for gene, colo in zip(genes, colors):
+        if (gene not in C.gene_to_idx):
+            raise ValueError(f"Unknown gene: {gene}")
+
+        idx = C.gene_to_idx[gene]
+        ax.plot(x, values[idx, :], label=gene, color=colo, linewidth=linewidth)
+
+    ax.set_xlabel("Pseudotime")
+    ax.set_ylabel("Scaled Expression" if scaled else "Expression")
+    ax.legend()
+
+    fig.tight_layout()
+    return ax
+
+
+@requires_bins
+@requires_cors
+def plot_correlations(C: CoReGraph, regulator: str, target: str, ref_lag: tuple[int, int], scaled: bool=False, decimals: int=15, color: list=(ColorBlind[0], ColorBlind[3]), linewidth: float=1, figsize: tuple=(8,4)) :
+    '''Plot lagged correlations between genes.'''
+    if C.graphics.n_bins is None:
+        raise ValueError("Bins have not been calculated.")
+    
+    values  = (C.graphics.scaled if scaled else C.graphics.mean)
+    reg_idx = C.gene_to_idx[regulator]
+    tar_idx = C.gene_to_idx[target]
+    y_max   = np.max([values[reg_idx, :], values[tar_idx, :]]) * 1.1
+
+    fig, ax = plt.subplots(figsize=figsize)
+    x       = np.unique(C.graphics.bin_id)
+    
+    ax.plot(x, values[reg_idx, :], color=color[0], linewidth=linewidth)
+    ax.plot(x, values[tar_idx, :], color=color[1], linewidth=linewidth)
+
+    ref, lag = ref_lag
+    ax.add_patch(patches.Rectangle((ref, 0), C.cors.window, y_max, facecolor=color[0], alpha=0.1,))
+    ax.add_patch(patches.Rectangle((lag, 0), C.cors.window, y_max, facecolor=color[1], alpha=0.1,))
+
+    cor = get_correlation(C, regulator, target, ref_lag)
+    ax.annotate(f"cor = {np.round(cor, decimals)}", (C.n_cells * 0.01, y_max * 0.85,))
+    ax.set_xlim(0, C.n_cells)
+    ax.set_ylim(0, y_max)
+    ax.set_xlabel("Pseudotime")
+    ax.set_ylabel("Scaled Expression" if scaled else "Expression")
+    ax.set_title(f'{regulator} [{ref_lag[0]}] -> {target} [{ref_lag[1]}]')
+
+    ax.legend([regulator, target])
+
+    return ax

coregraph/models/__init__.py

@@ -0,0 +1,11 @@
+from .coregraph import CoReGraph
+from .cors import CoReGraph_Cors
+from .graphics import CoReGraph_Graphics
+from .stargraph import StarGraph
+
+__all__ = [
+    "CoReGraph",
+    "CoReGraph_Cors",
+    "CoReGraph_Graphics",
+    "StarGraph",
+]

coregraph/models/coregraph.py

@@ -0,0 +1,221 @@
+## COREGRAPH ##
+
+from __future__ import annotations
+
+from typing import Optional
+
+import warnings
+import numpy as np
+import pandas as pd
+
+from tqdm import tqdm
+
+from coregraph.models.cors import (CoReGraph_Cors)
+from coregraph.models.graphics import (CoReGraph_Graphics)
+from coregraph.analysis.correlations import (_calculate_all_cors)
+from coregraph.analysis.bins import (_calculate_bins)
+from coregraph.analysis.fdr import (_calculate_FDR)
+
+from coregraph.utils.validation import (_solve_step, _solve_total_dim3)
+from coregraph.utils.formatting import (_set_numerical_format)
+from coregraph.utils.decorators import (requires_cors)
+
+class CoReGraph:
+    '''
+    Main CoreGraph object.
+
+    Attributes
+    ----------
+    data : ndarray
+        Original matrix with genes in rows and pseudotime-sorted cells in columns
+    n_genes : int 
+        Total number of genes
+    n_cells : int 
+        Total number of cells
+    pseudotime : ndarray
+        Pseudotime associated to each cells 
+    gene_id : list 
+        Vector of gene names
+    cell_id : list 
+        Vector of cell names
+    gene_to_idx : dict
+        Dictionnary of {gene: gene_id}
+    cell_to_idx : dict
+        Dictionnary of {cell: cell_id}
+    cors : CoReGraph_Cors
+        CoReGraph_Cors object containing correlations once calculated
+    graphics : CoReGraph_Graphics
+        CoReGraph_Graphics object containing binned epxressions once calculated to draw plots
+    '''  
+
+    ## INITIALIZATION AND CLASS METHODS ##
+
+    def __init__(self, matrix: np.ndarray, pseudotime: Optional[np.ndarray]=None, genes=None, cells=None):
+        self.data        = np.asarray(matrix)
+        self.n_genes     = self.data.shape[0]
+        self.n_cells     = self.data.shape[1]
+
+        self.pseudotime  = (np.asarray(pseudotime) if pseudotime is not None else np.arange(self.n_cells))
+        self.gene_id     = (list(genes) if genes is not None else list(range(self.n_genes)))
+        self.cell_id     = (list(cells) if cells is not None else list(range(self.n_cells)))
+        self.gene_to_idx = {str(gene): int(idx) for idx, gene in enumerate(self.gene_id)}
+        self.cell_to_idx = {str(cell): int(idx) for idx, cell in enumerate(self.cell_id)}
+
+        self.cors        = CoReGraph_Cors()
+        self.graphics    = CoReGraph_Graphics()
+
+    @classmethod
+    def from_pandas(cls, dataframe: pd.DataFrame, with_pseudotime: bool=False):
+        if with_pseudotime:
+            return cls(matrix=dataframe.iloc[1:], pseudotime=dataframe.iloc[0], genes=dataframe.index[1:], cells=dataframe.columns)
+
+        return cls(matrix=dataframe, genes=dataframe.index, cells=dataframe.columns)
+
+
+    ## __DUNDERS__ ##
+
+    def __repr__(self):
+        msg = f'CoReGraph({self.n_genes} genes, {self.n_cells} cells)'
+        if self.cors.window is not None:
+            msg += f'\n└ cors(window={self.cors.window})'
+        if self.graphics.n_bins is not None:
+            msg += f'\n└ graphics(n_bins={self.graphics.n_bins})'
+        return msg
+
+    def __str__(self):
+        msg = f'CoReGraph object with {self.n_genes} genes and {self.n_cells} cells.'
+        if self.cors.window is not None:
+            msg += f'\n-- Correlations calculated with a window of {self.cors.window} cells.'
+        if self.graphics.n_bins is not None:
+            msg += f'\n-- Discretized with {self.graphics.n_bins} bins.'
+        return msg
+
+    def __getattr__(self, name):
+        for target in [self.cors, self.graphics]:
+            attr = getattr(target, name, None)
+            if attr is not None:
+                return attr
+        raise AttributeError(f"'{type(self).__name__}' object has no attribute '{name}'")
+
+
+    ## CORRELATIONS CALCULATION METHOD ##
+
+    def calculate_all_cors(self, window: int, step: int | None = None, n_steps: int | None = None, verbose: bool=False, dtype: str="float"):
+        '''
+        Calculate all lagged correlations.
+
+        Parameters
+        ----------
+        window : int
+            Number of cells in the window for applying lags (usually n_cells*2/3)
+        step : int | None
+            Step to apply while shifting window
+        n_steps : int | None
+            Total number of steps to consider while shifting window
+        verbose : bool
+            Wether show progression bar (slightly slow down the process)
+        dtype : type
+            Data type used to store results. Should be 'float' or 'int' (recommanded to reduce memory use).
+
+        Return
+        ------
+        Update tensor, window, reflag, MAC, LAG_id, LAG, LAG_means, LAG_scaled attributes, as well as step, n_steps, dtype and num_format
+        '''
+
+        n_genes, n_cells           = self.data.shape
+        resolved_dtype, num_format = _set_numerical_format(dtype)
+        step, n_steps              = _solve_step(step, n_steps, window, n_cells)
+
+        # Initialize a new instance of CoReGraph_Cors object only if necessary
+        if (self.cors.window == window) and (self.cors.dtype == resolved_dtype[0]) and (self.cors.step == step):
+            raise ValueError(f'Correlation with window={window} and step={step} have already been calculated.')
+       
+       # Warning if some cells are excluded
+        excluded_cells =  n_cells - (window + ((n_steps-1) * step))
+        if excluded_cells != 0:
+            warnings.warn(f'Provided step and window exclude the last {excluded_cells} cells.')
+
+        # Remove warning while dividing by zero and managing defined num type
+        np.seterr(divide='ignore', invalid='ignore')
+        
+        # Initialize loops and empty objects
+        total_dim3 = _solve_total_dim3(step, window, n_cells)
+        tensor     = np.empty((n_genes, n_genes, total_dim3), dtype=resolved_dtype)
+        MAC        = np.zeros((n_genes, n_genes), dtype=resolved_dtype)
+        LAG_id     = np.empty((2, n_genes, n_genes), dtype=np.int64)
+        LAG        = np.zeros((n_genes, n_genes), dtype=np.int64)
+        reflag     = np.empty((total_dim3, 2))
+        dim3       = 0
+        LAG_means  = np.empty((total_dim3, n_genes), dtype=np.float64)
+
+        # Iterate through refs (iterator) and lags (inner function)
+        iterator = tqdm(range(0, n_cells-window+1, step), desc="Calculating Correlations", disable=not verbose)
+        for i in iterator:
+            dim3, MAC, LAG_id, LAG, LAG_means = _calculate_all_cors(self.data, window, i, tensor, reflag, MAC, LAG_id, LAG, LAG_means, dim3, step, num_format, resolved_dtype)
+        
+        # Fill in attributes
+        self.cors.MAC       = MAC
+        self.cors.LAG_id    = LAG_id
+        self.cors.LAG       = LAG
+        self.cors.LAG_means = LAG_means
+        self.cors.tensor    = tensor
+        self.cors.window    = window
+        self.cors.step      = step
+        self.cors.n_steps   = n_steps
+        self.cors.reflag    = reflag
+        max = np.max(self.cors.LAG_means.T, axis=1).T
+        min = np.min(self.cors.LAG_means.T, axis=1).T
+        self.cors.LAG_scaled = (self.cors.LAG_means - min) / (max - min)
+        self.cors.dtype      = resolved_dtype
+        self.cors.num_format = num_format
+
+
+    ## FDR CALCULATION METHOD ##
+
+    @requires_cors 
+    def calculate_FDR(self, n_perms = 100, FDR_cutoffs = 101):
+        '''
+        Calculate permutations to estimate False Discovery Rate (FDR).
+
+        Parameters
+        ----------
+        n_perms : int
+            Number of permutation to perform for estimation
+        FDR_cutoffs : int
+            Resolution of FDR estimate, number of bins between 0 to 1 that are displayed in results.
+
+        Return
+        ------
+        Update FDR attribute
+
+        '''
+
+        FDR = _calculate_FDR(self.data, self.cors.MAC/self.cors.num_format[0], self.cors.window, n_perms, FDR_cutoffs, self.cors.step)
+        FDR = pd.DataFrame(FDR, columns=["cors", "MACs_observed", "MACs_ave_perm", "FDR"])
+        FDR[["MACs_observed"]] = FDR[["MACs_observed"]].astype(int)
+        self.cors.FDR = FDR
+
+
+    ## BIN DISCRETIZATION METHOD ##
+
+    def calculate_bins(self, n_bins: int):
+        '''
+        Calculate pseudotime bins.
+
+        Parameters
+        ----------
+        n_bins : int
+            Number of bins to consider for pseudotime discretization
+        '''
+        # Initialize a new instance of CoReGraph_Graphics object only if necessary
+        if self.graphics.n_bins == n_bins:
+            raise ValueError(f'Bins for n_bins={n_bins} have already been calculated.')
+
+        self.graphics.bin_id, self.graphics.mean, self.graphics.std, self.graphics.scaled = _calculate_bins(self.data, self.pseudotime, n_bins)
+        self.graphics.n_bins = n_bins
+
+
+
+  
+
+   

coregraph/models/cors.py

@@ -0,0 +1,63 @@
+## CORS ##
+
+from dataclasses import dataclass
+
+import numpy as np
+import pandas as pd
+
+
+@dataclass
+class CoReGraph_Cors:
+    '''
+    Container for correlation results.
+
+    Attributes
+    ----------
+    window : int
+        Window used for the current correlations
+    step : int
+        Step used while looping over pseudotime
+    n_steps : int
+        Total number of steps considered along pseudotime
+    tensor : (3D)ndarray
+        Result of all lagged or not correlations
+    reflag : ndarray
+        Vector of (ref,lag) corresponding to tensor dimensions
+    MAC : ndarray
+        Maximum Absolute Correlation values
+    LAG_id : ndarray
+        Reflag corresponding to the dimension used for MAC
+    LAG : ndarray
+        Number of cells corresponding to the lag used for MAC
+    LAG_means : (3D)ndarray 
+        Gene mean expressions calculated for each window
+    LAG_scaled : (3D)ndarray 
+        Gene scaled expressions calculated for each window
+    FDR : DataFrame
+        Pandas DataFrame recapitulating metrics for False Dicovery Rate estimation
+    dtype : str
+        Numpy type of object to store correlation values (should be 'int' or 'float')
+    num_format : ndarray
+        Numpy array of two elements used to define the numerical format [scale_factor, n_decimals]
+    '''
+
+    window: int | None = None
+    step: int | None = None
+    n_steps: int | None = None
+    tensor: np.ndarray | None = None
+    reflag: np.ndarray | None = None
+    MAC: np.ndarray | None = None
+    LAG_id: np.ndarray | None = None
+    LAG: np.ndarray | None = None
+    LAG_means: np.ndarray | None = None
+    LAG_scaled: np.ndarray | None = None
+    FDR: pd.DataFrame | None = None
+    dtype: np.dtype | None = None
+    num_format: np.ndarray | None = None
+
+
+    def __repr__(self):
+        return f'CoReGraph_Cors(window: {self.window}, step: {self.step})'
+
+    def __str__(self):
+        return f'CoReGraph_Cors object'

coregraph/models/graphics.py

@@ -0,0 +1,38 @@
+## GRAPHICS ##
+
+from dataclasses import dataclass
+
+import numpy as np
+
+
+@dataclass
+class CoReGraph_Graphics:
+    '''
+    Container for graphical data.
+
+    Attributes
+    ----------
+    n_bins : int
+        Bin number used to discretize pseudotime
+    bin_id : ndarray
+        Vector of bin attributed to each cell
+    mean : ndarray
+        Binned mean expression
+    std : ndarray
+        Binned standard deviation 
+    scaled : ndarray
+        Binned scaled expression
+    '''
+
+    n_bins: int | None = None
+    bin_id: np.ndarray | None = None
+    mean: np.ndarray | None = None
+    std: np.ndarray | None = None
+    scaled: np.ndarray | None = None
+
+
+    def __repr__(self):
+        return f'CoReGraph_Graphics(n_bins: {self.n_bins})'
+
+    def __str__(self):
+        return f'CoReGraph_Graphics object'

coregraph/models/stargraph.py

@@ -0,0 +1,41 @@
+## STARGRAPH ##
+
+from dataclasses import dataclass
+
+import numpy as np
+import pandas as pd
+
+
+@dataclass
+class StarGraph:
+    '''
+    Local star-shaped regulatory network.
+    '''
+
+    central_gene: str | None = None
+    window: int | None = None
+    step: int | None = None
+    n_steps: int | None = None
+    FDR_thr: float | None = None
+    cors_thr: float | None = None
+    MAC: pd.DataFrame | None = None
+    FDR: pd.DataFrame | None = None
+    gene_list: list[str] | None = None
+
+
+    def __repr__(self):
+        return f'StarGraph(central_gene: {self.central_gene}, window: {self.window})'
+
+    def __str__(self):
+        return f'StarGraph object'
+
+
+    def set_correlation_threshold(self, threshold: float):
+        self.cors_thr = threshold
+        self.FDR_thr = np.max(self.FDR.loc[self.FDR['cors'] > threshold, 'FDR'])
+        self.gene_list = (self.MAC.loc[np.abs(self.MAC['MAC']) >= threshold].index.tolist())
+
+    def set_FDR_threshold(self, threshold: float):
+        self.fdr_threshold = threshold
+        self.correlation_threshold = np.min(self.FDR.loc[self.FDR['FDR'] < threshold, 'cors'])
+        self.gene_list = (self.MAC.loc[np.abs(self.MAC['MAC']) >= self.correlation_threshold].index.tolist())

coregraph/utils/__init__.py

@@ -0,0 +1,23 @@
+from .decorators import (
+    requires_cors,
+    requires_FDR,
+    requires_bins,
+)
+
+from .formatting import (
+    _set_numerical_format,
+)
+
+from .validation import (
+    _solve_step,
+    _solve_total_dim3,
+)
+
+__all__ = [
+    "requires_cors",
+    "requires_FDR",
+    "requires_bins",
+    "_set_numerical_format",
+    "_solve_step",
+    "_solve_total_dim3",
+]