DeConveil 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

deconveil/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.1.2"

{DeConveil → deconveil}/dds.py

@@ -1,11 +1,7 @@
 import sys
 import time
 import warnings
-from typing import List
-from typing import Literal
-from typing import Optional
-from typing import Union
-from typing import cast
+from typing import List, Literal, Optional, Union, cast
 
 import numpy as np
 import pandas as pd
@@ -16,15 +12,15 @@ from scipy.stats import trim_mean  # type: ignore
 
 from deconveil.default_inference import DefInference                              
 from deconveil.inference import Inference                                     
-from deconveil import utils_CNaware
-from deconveil.utils_CNaware import fit_rough_dispersions
-from deconveil.utils_CNaware import fit_moments_dispersions2
-from deconveil.utils_CNaware import grid_fit_beta
-from deconveil.utils_CNaware import irls_glm
+from deconveil import utils_fit
+from deconveil.utils_fit import fit_rough_dispersions
+from deconveil.utils_fit import fit_moments_dispersions2
+from deconveil.utils_fit import grid_fit_beta
+from deconveil.utils_fit import irls_glm
+from deconveil.utils_fit import build_design_matrix
 
 from pydeseq2.preprocessing import deseq2_norm_fit
 from pydeseq2.preprocessing import deseq2_norm_transform
-from pydeseq2.utils import build_design_matrix
 from pydeseq2.utils import dispersion_trend
 from pydeseq2.utils import mean_absolute_deviation
 from pydeseq2.utils import n_or_more_replicates

{DeConveil → deconveil}/default_inference.py

@@ -1,17 +1,13 @@
-from typing import Literal
-from typing import Optional
-from typing import Tuple
+from typing import Literal, Optional, Tuple
 
 import numpy as np
 import pandas as pd
-from joblib import Parallel  # type: ignore
-from joblib import delayed
-from joblib import parallel_backend
+from joblib import Parallel, delayed, parallel_backend  # type: ignore
 from scipy.optimize import minimize  # type: ignore
 
 from deconveil import inference
-from deconveil import utils_CNaware 
-from deconveil.utils_CNaware import fit_lin_mu
+from deconveil import utils_fit 
+from deconveil.utils_fit import fit_lin_mu
 
 from pydeseq2 import utils
 from pydeseq2.utils import get_num_processes
@@ -42,8 +38,8 @@ class DefInference(inference.Inference):
         Joblib backend.
     """
     
-    fit_rough_dispersions = staticmethod(utils_CNaware.fit_rough_dispersions)  # type: ignore
-    fit_moments_dispersions2 = staticmethod(utils_CNaware.fit_moments_dispersions2)  # type: ignore
+    fit_rough_dispersions = staticmethod(utils_fit.fit_rough_dispersions)  # type: ignore
+    fit_moments_dispersions2 = staticmethod(utils_fit.fit_moments_dispersions2)  # type: ignore
     
     def __init__(
         self,
@@ -79,7 +75,7 @@ class DefInference(inference.Inference):
                     verbose=self._joblib_verbosity,
                     batch_size=self._batch_size,
                 )(
-                    delayed(utils_CNaware.fit_lin_mu)(
+                    delayed(utils_fit.fit_lin_mu)(
                         counts=counts[:, i],
                         size_factors=size_factors,
                         design_matrix=design_matrix,
@@ -110,7 +106,7 @@ class DefInference(inference.Inference):
                 verbose=self._joblib_verbosity,
                 batch_size=self._batch_size,
             )(
-                delayed(utils_CNaware.irls_glm)(
+                delayed(utils_fit.irls_glm)(
                     counts=counts[:, i],
                     size_factors=size_factors,
                     design_matrix=design_matrix,
@@ -262,7 +258,7 @@ class DefInference(inference.Inference):
                 verbose=self._joblib_verbosity,
                 batch_size=self._batch_size,
             )(
-                delayed(utils_CNaware.nbinomGLM)(
+                delayed(utils_fit.nbinomGLM)(
                     design_matrix=design_matrix,
                     counts=counts[:, i],
                     cnv=cnv[:, i],
@@ -278,7 +274,3 @@ class DefInference(inference.Inference):
         res = zip(*res)
         lfcs, inv_hessians, l_bfgs_b_converged_ = (np.array(m) for m in res)
         return lfcs, inv_hessians, l_bfgs_b_converged_
-
-
-
-

{DeConveil → deconveil}/ds.py

@@ -1,8 +1,6 @@
 import sys
 import time
-from typing import List
-from typing import Literal
-from typing import Optional
+from typing import List, Literal, Optional
 
 import numpy as np
 import pandas as pd

{DeConveil → deconveil}/grid_search.py

@@ -3,7 +3,7 @@ from typing import Optional
 import numpy as np
 from scipy.special import gammaln  # type: ignore
 
-from deconveil import utils_CNaware
+from deconveil import utils_fit
 
 
 def grid_fit_beta(
@@ -156,7 +156,7 @@ def grid_fit_shrink_beta(
     def loss(beta: np.ndarray) -> float:
         # closure to minimize
         return (
-            utils_CNaware.nbinomFn(
+            utils_fit.nbinomFn(
                 beta,
                 design_matrix,
                 counts,

{DeConveil → deconveil}/inference.py

@@ -1,8 +1,6 @@
 from abc import ABC
 from abc import abstractmethod
-from typing import Literal
-from typing import Optional
-from typing import Tuple
+from typing import Literal, Optional, Tuple
 
 import numpy as np
 import pandas as pd
@@ -365,9 +363,4 @@ class Inference(ABC):
         converged: ndarray
             Whether L-BFGS-B converged for each optimization problem.
         """
-        
-    
-
-     
-
-
+        

deconveil/utils_clustering.py

@@ -0,0 +1,201 @@
+import numpy as np
+import pandas as pd
+from sklearn.decomposition import PCA
+from sklearn.cluster import KMeans, AgglomerativeClustering
+from sklearn.metrics import silhouette_score
+from scipy.spatial.distance import pdist, squareform
+import random
+
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+
+def pca_cluster_cn(
+    gene_cn: pd.DataFrame,
+    n_components: int = 20,
+    k: int = 2,
+    method: str = "kmeans",
+    random_state: int = 0,
+) -> dict:
+    """
+    Perform PCA on gene-level CN and cluster patients in PCA space.
+
+    Parameters
+    ----------
+    gene_cn : DataFrame
+        Gene x Sample matrix of CN values (log2 ratios).
+    n_components : int
+        Number of PCA components to keep.
+    k : int
+        Number of clusters.
+    method : str
+        'kmeans' or 'hierarchical'.
+    random_state : int
+        For reproducibility.
+
+    Returns
+    -------
+    dict with:
+        - labels: pd.Series (sample -> cluster)
+        - pca_coords: DataFrame of PCA coords
+        - explained_var: explained variance ratios
+    """
+    X = gene_cn.fillna(0).T  # samples × genes
+    pca = PCA(n_components=min(n_components, X.shape[1]))
+    coords = pca.fit_transform(X)
+    coords_df = pd.DataFrame(
+        coords, index=X.index, columns=[f"PC{i+1}" for i in range(coords.shape[1])]
+    )
+
+    if method == "kmeans":
+        model = KMeans(n_clusters=k, n_init=20, random_state=random_state)
+        labels = model.fit_predict(coords)
+    elif method == "hierarchical":
+        model = AgglomerativeClustering(n_clusters=k)
+        labels = model.fit_predict(coords)
+    else:
+        raise ValueError("method must be 'kmeans' or 'hierarchical'")
+
+    labels = pd.Series(labels, index=X.index, name="cluster")
+    return {
+        "labels": labels,
+        "pca_coords": coords_df,
+        "explained_var": pca.explained_variance_ratio_,
+    }
+
+
+def consensus_cluster_cn(
+    gene_cn: pd.DataFrame,
+    k: int = 2,
+    n_resamples: int = 50,
+    sample_fraction: float = 0.8,
+    feature_fraction: float = 0.8,
+    top_genes: int = 2000,
+    random_state: int = 0,
+) -> dict:
+    """
+    Consensus clustering of patients based on CN profiles.
+
+    Parameters
+    ----------
+    gene_cn : DataFrame
+        Gene x Sample CN matrix.
+    k : int
+        Number of clusters.
+    n_resamples : int
+        Number of resampling iterations.
+    sample_fraction : float
+        Fraction of patients sampled each iteration.
+    feature_fraction : float
+        Fraction of genes sampled each iteration.
+    top_genes : int
+        Use top variable genes only.
+    random_state : int
+        For reproducibility.
+
+    Returns
+    -------
+    dict with:
+        - labels: pd.Series (sample -> cluster) from consensus
+        - consensus_matrix: DataFrame (samples × samples) with co-clustering frequencies
+    """
+    rng = np.random.RandomState(random_state)
+
+    # Select top variable genes
+    var_genes = gene_cn.var(axis=1).sort_values(ascending=False).index[:top_genes]
+    data = gene_cn.loc[var_genes].fillna(0).values  # genes × samples
+    samples = gene_cn.columns.tolist()
+    n = len(samples)
+
+    co_mat = np.zeros((n, n))
+    counts = np.zeros((n, n))
+
+    for r in range(n_resamples):
+        samp_idx = rng.choice(n, size=int(sample_fraction * n), replace=False)
+        feat_idx = rng.choice(
+            data.shape[0], size=int(feature_fraction * data.shape[0]), replace=False
+        )
+        X = data[feat_idx][:, samp_idx].T  # subsampled patients × genes
+
+        # k-means in subsample
+        km = KMeans(n_clusters=k, n_init=10, random_state=rng).fit(X)
+        labels_sub = km.labels_
+
+        # update co-occurrence
+        for i, si in enumerate(samp_idx):
+            for j, sj in enumerate(samp_idx):
+                counts[si, sj] += 1
+                if labels_sub[i] == labels_sub[j]:
+                    co_mat[si, sj] += 1
+
+    consensus = np.divide(co_mat, counts, out=np.zeros_like(co_mat), where=counts > 0)
+    consensus_df = pd.DataFrame(consensus, index=samples, columns=samples)
+
+    # Cluster consensus matrix
+    dist = 1 - consensus
+    agg = AgglomerativeClustering(n_clusters=k, affinity="precomputed", linkage="average")
+    labels = agg.fit_predict(dist)
+    labels = pd.Series(labels, index=samples, name="cluster")
+
+    return {"labels": labels, "consensus_matrix": consensus_df}
+
+
+def consensus_cdf_range(
+    gene_cn, k_values=(2,3,4,5,6),
+    n_resamples=50, sample_fraction=0.8, feature_fraction=0.8,
+    top_genes=2000, random_state=0
+):
+    """
+    Run consensus clustering across multiple k and plot CDFs.
+
+    Parameters
+    ----------
+    gene_cn : DataFrame
+        Gene × Sample CN matrix.
+    k_values : list/tuple
+        Range of k to test.
+    n_resamples, sample_fraction, feature_fraction, top_genes, random_state
+        Passed to consensus_cluster_cn().
+
+    Returns
+    -------
+    dict
+        {k: {"labels", "consensus_matrix", "auc"}}
+    """
+    results = {}
+
+    plt.figure(figsize=(7,5))
+
+    for k in k_values:
+        res = consensus_cluster_cn(
+            gene_cn, k=k,
+            n_resamples=n_resamples,
+            sample_fraction=sample_fraction,
+            feature_fraction=feature_fraction,
+            top_genes=top_genes,
+            random_state=random_state
+        )
+
+        mat = res["consensus_matrix"].values
+        mask = ~np.eye(mat.shape[0], dtype=bool)
+        vals = mat[mask]
+
+        sorted_vals = np.sort(vals)
+        cdf = np.arange(1, len(sorted_vals)+1) / len(sorted_vals)
+
+        # Compute area under CDF (AUC)
+        auc = np.trapz(cdf, sorted_vals)
+        res["auc"] = auc
+        results[k] = res
+
+        plt.plot(sorted_vals, cdf, lw=2, label=f"k={k} (AUC={auc:.3f})")
+
+    plt.xlabel("Consensus value")
+    plt.ylabel("Cumulative fraction")
+    plt.title("Consensus CDF across k", fontsize=14)
+    plt.legend()
+    plt.grid(True, alpha=0.3)
+    plt.tight_layout()
+    plt.show()
+
+    return results

DeConveil/utils_CNaware.py → deconveil/utils_fit.py

@@ -1,30 +1,20 @@
 import os
 import multiprocessing
 import warnings
-from math import ceil
-from math import floor
+from math import ceil, floor
 from pathlib import Path
-from typing import List
-from typing import Literal
-from typing import Optional
-from typing import Tuple
-from typing import Union
-from typing import cast
+from typing import List, Literal, Optional, Tuple, Union, cast, Dict, Any
 
 import numpy as np
 import pandas as pd
-from matplotlib import pyplot as plt
 from scipy.linalg import solve  # type: ignore
 from scipy.optimize import minimize  # type: ignore
 from scipy.special import gammaln  # type: ignore
 from scipy.special import polygamma  # type: ignore
 from scipy.stats import norm  # type: ignore
 from sklearn.linear_model import LinearRegression  # type: ignore
-import matplotlib.pyplot as plt
-import seaborn as sns
 
 from deconveil.grid_search import grid_fit_beta
-
 from pydeseq2.utils import fit_alpha_mle
 from pydeseq2.utils import get_num_processes
 from pydeseq2.grid_search import grid_fit_alpha
@@ -209,7 +199,6 @@ def fit_rough_dispersions(
     return np.maximum(alpha_rde, 0)
 
 
-
 def fit_moments_dispersions2(
     normed_counts: np.ndarray, size_factors: np.ndarray
 ) -> np.ndarray:
@@ -470,6 +459,7 @@ def nbinomGLM(
     inv_hessian = np.linalg.inv(ddf(beta, 1))
 
     return beta, inv_hessian, converged
+    
 
 def nbinomFn(
     beta: np.ndarray,
@@ -535,275 +525,149 @@ def nbinomFn(
     return prior - nll
 
 
+def build_design_matrix(
+    metadata: pd.DataFrame,
+    design_factors: Union[str, List[str]] = "condition",
+    ref_level: Optional[List[str]] = None,
+    continuous_factors: Optional[List[str]] = None,
+    expanded: bool = False,
+    intercept: bool = True,
+) -> pd.DataFrame:
+    """Build design_matrix matrix for DEA.
 
-def process_results(file_path, method, lfc_cut = 1.0, pval_cut = 0.05):
-    df = pd.read_csv(file_path, index_col=0)
-    df['isDE'] = (np.abs(df['log2FoldChange']) >= lfc_cut) & (df['padj'] <= pval_cut)
-    df['DEtype'] = np.where(
-        ~df['isDE'], 
-        "n.s.", 
-        np.where(df['log2FoldChange'] > 0, "Up-reg", "Down-reg")
-    )
-    df['method'] = method
-    return df[['log2FoldChange', 'padj', 'isDE', 'DEtype', 'method']]
-    
+    Unless specified, the reference factor is chosen alphabetically.
 
-def define_gene_groups(res_joint):
-    DSGs = res_joint[
-        ((res_joint['DEtype_naive'] == "Up-reg") & (res_joint['DEtype_aware'] == "n.s.")) |
-        ((res_joint['DEtype_naive'] == "Down-reg") & (res_joint['DEtype_aware'] == "n.s."))
-    ].assign(gene_category='DSGs')
-    
-    DIGs = res_joint[
-        ((res_joint['DEtype_naive'] == "Up-reg") & (res_joint['DEtype_aware'] == "Up-reg")) |
-        ((res_joint['DEtype_naive'] == "Down-reg") & (res_joint['DEtype_aware'] == "Down-reg"))
-    ].assign(gene_category='DIGs')
-             
-    DCGs = res_joint[
-        ((res_joint['DEtype_naive'] == "n.s.") & (res_joint['DEtype_aware'] == "Up-reg")) |
-        ((res_joint['DEtype_naive'] == "n.s.") & (res_joint['DEtype_aware'] == "Down-reg"))
-    ].assign(gene_category='DCGs')
-             
-    non_DEGs = res_joint[
-        (res_joint['DEtype_naive'] == "n.s.") & (res_joint['DEtype_aware'] == "n.s.")
-    ].assign(gene_category='non-DEGs')
-             
-    return {
-        "DSGs": DSGs,
-        "DIGs": DIGs,
-        "DCGs": DCGs,
-        "non_DEGs": non_DEGs
-    }
-
-
-def generate_volcano_plot(plot_data, lfc_cut=1.0, pval_cut=0.05, xlim=None, ylim=None):
-    plot_data['gene_group'] = plot_data['gene_group'].astype('category')
-    
-    # Define gene group colors
-    gene_group_colors = {
-        "DIGs": "#8F3931FF",
-        "DSGs": "#FFB977",
-        "DCGs": "#FFC300"
-    }
-
-    # Create a FacetGrid for faceted plots
-    g = sns.FacetGrid(
-        plot_data, 
-        col="method", 
-        margin_titles=True, 
-        hue="gene_group", 
-        palette=gene_group_colors, 
-        sharey=False, 
-        sharex=True
-    )
+    Parameters
+    ----------
+    metadata : pandas.DataFrame
+        DataFrame containing metadata information.
+        Must be indexed by sample barcodes.
 
-    
-    # Add points for "DIGs" 
-    g.map_dataframe(
-        sns.scatterplot, 
-        x="log2FC", 
-        y="-log10(padj)", 
-        alpha=0.1, 
-        size=0.5, 
-        legend=False, 
-        data=plot_data[plot_data['gene_group'].isin(["DIGs"])]
-    )
+    design_factors : str or list
+        Name of the columns of metadata to be used as design_matrix variables.
+        (default: ``"condition"``).
 
-    # Add points for "DSGs" and "DCGs"
-    g.map_dataframe(
-        sns.scatterplot, 
-        x="log2FC", 
-        y="-log10(padj)", 
-        alpha=1.0, 
-        size=3.0, 
-        legend=False, 
-        data=plot_data[plot_data['gene_group'].isin(["DSGs", "DCGs"])]
-    )
-    
-    # Add vertical and horizontal dashed lines
-    for ax in g.axes.flat:
-        ax.axvline(x=-lfc_cut, color="gray", linestyle="dashed")
-        ax.axvline(x=lfc_cut, color="gray", linestyle="dashed")
-        ax.axhline(y=-np.log10(pval_cut), color="gray", linestyle="dashed")
-        
-        if xlim:
-            ax.set_xlim(xlim)
-        if ylim:
-            ax.set_ylim(ylim)
-    
-    # Set axis labels
-    g.set_axis_labels("Log2 FC", "-Log10 P-value")
-    
-    # Add titles, legends, and customize
-    g.add_legend(title="Gene category")
-    g.set_titles(row_template="{row_name}", col_template="{col_name}")
-    g.tight_layout()
-    
-    # Adjust font sizes for better readability
-    for ax in g.axes.flat:
-        ax.tick_params(axis='both', labelsize=12)
-        ax.set_xlabel("Log2 FC", fontsize=14)
-        ax.set_ylabel("-Log10 P-value", fontsize=14)
-    
-    # Save or display the plot
-    plt.show()
+    ref_level : dict or None
+        An optional list of two strings of the form ``["factor", "ref_level"]``
+        specifying the factor of interest and the desired reference level, e.g.
+        ``["condition", "A"]``. (default: ``None``).
 
+    continuous_factors : list or None
+        An optional list of continuous (as opposed to categorical) factors. Any factor
+        not in ``continuous_factors`` will be considered categorical (default: ``None``).
 
-def plot_cnv_hist(cnv_mean, binwidth=0.2):
-    """
-    Plots a histogram of the CNV mean distribution.
+    expanded : bool
+        If true, use one column per category. Else, use n-1 columns, for each n-level
+        categorical factor.
+        (default: ``False``).
 
-    Parameters:
-        cnv_mean (pd.Series or list): The CNV mean values to plot.
-        binwidth (float): The bin width for the histogram.
+    intercept : bool
+        If true, add an intercept (a column containing only ones). (default: ``True``).
+
+    Returns
+    -------
+    pandas.DataFrame
+        A DataFrame with experiment design information (to split cohorts).
+        Indexed by sample barcodes.
     """
-    # Convert to a DataFrame if it's not already
-    if isinstance(cnv_mean, list):
-        cnv_mean = pd.DataFrame({'cnv_mean': cnv_mean})
-    elif isinstance(cnv_mean, pd.Series):
-        cnv_mean = cnv_mean.to_frame(name='cnv_mean')
-
-    # Create the histogram plot
-    plt.figure(figsize=(5, 5))
-    sns.histplot(
-        cnv_mean['cnv_mean'],
-        bins=int((cnv_mean['cnv_mean'].max() - cnv_mean['cnv_mean'].min()) / binwidth),
-        kde=False,
-        color="#F39B7F",
-        edgecolor="black",
-        alpha=0.7
-    )
+    if isinstance(
+        design_factors, str
+    ):  # if there is a single factor, convert to singleton list
+        design_factors = [design_factors]
+
+    for factor in design_factors:
+        # Check that each factor has at least 2 levels
+        if len(np.unique(metadata[factor])) < 2:
+            raise ValueError(
+                f"Factors should take at least two values, but {factor} "
+                f"takes the single value '{np.unique(metadata[factor])}'."
+            )
 
-    # Add labels and titles
-    plt.title("", fontsize=14)
-    plt.xlabel("CN state", fontsize=14, labelpad=8)
-    plt.ylabel("Frequency", fontsize=14, labelpad=8)
+    # Check that level factors in the design don't contain underscores. If so, convert
+    # them to hyphens
+    warning_issued = False
+    for factor in design_factors:
+        if np.any(["_" in value for value in metadata[factor]]):
+            if not warning_issued:
+                warnings.warn(
+                    """Some factor levels in the design contain underscores ('_').
+                    They will be converted to hyphens ('-').""",
+                    UserWarning,
+                    stacklevel=2,
+                )
+                warning_issued = True
+            metadata[factor] = metadata[factor].apply(lambda x: x.replace("_", "-"))
 
-    # Customize the appearance of axes
-    plt.xticks(fontsize=12, color="black", rotation=45, ha="right")
-    plt.yticks(fontsize=12, color="black")
-    plt.gca().spines["top"].set_visible(False)
-    plt.gca().spines["right"].set_visible(False)
-    plt.gca().spines["left"].set_linewidth(1)
-    plt.gca().spines["bottom"].set_linewidth(1)
+    if continuous_factors is not None:
+        categorical_factors = [
+            factor for factor in design_factors if factor not in continuous_factors
+        ]
+    else:
+        categorical_factors = design_factors
 
-    # Add a grid
-    plt.grid(visible=False)
+    # Check that there is at least one categorical factor
+    if len(categorical_factors) > 0:
+        design_matrix = pd.get_dummies(
+            metadata[categorical_factors], drop_first=not expanded
+        )
 
-    # Show the plot
-    plt.tight_layout()
-    plt.show()
+        if ref_level is not None:
+            if len(ref_level) != 2:
+                raise KeyError("The reference level should contain 2 strings.")
+            if ref_level[1] not in metadata[ref_level[0]].values:
+                raise KeyError(
+                    f"The metadata data should contain a '{ref_level[0]}' column"
+                    f" with a '{ref_level[1]}' level."
+                )
 
+            # Check that the reference level is not in the matrix (if unexpanded design)
+            ref_level_name = "_".join(ref_level)
+            if (not expanded) and ref_level_name in design_matrix.columns:
+                # Remove the reference level and add one
+                factor_cols = [
+                    col for col in design_matrix.columns if col.startswith(ref_level[0])
+                ]
+                missing_level = next(
+                    level
+                    for level in np.unique(metadata[ref_level[0]])
+                    if f"{ref_level[0]}_{level}" not in design_matrix.columns
+                )
+                design_matrix[f"{ref_level[0]}_{missing_level}"] = 1 - design_matrix[
+                    factor_cols
+                ].sum(1)
+                design_matrix.drop(ref_level_name, axis="columns", inplace=True)
+
+        if not expanded:
+            # Add reference level as column name suffix
+            for factor in design_factors:
+                if ref_level is None or factor != ref_level[0]:
+                    # The reference is the unique level that is no longer there
+                    ref = next(
+                        level
+                        for level in np.unique(metadata[factor])
+                        if f"{factor}_{level}" not in design_matrix.columns
+                    )
+                else:
+                    # The reference level is given as an argument
+                    ref = ref_level[1]
+                design_matrix.columns = [
+                    f"{col}_vs_{ref}" if col.startswith(factor) else col
+                    for col in design_matrix.columns
+                ]
+    else:
+        # There is no categorical factor in the design
+        design_matrix = pd.DataFrame(index=metadata.index)
 
-def plot_stacked_bar(combined_data):
-    """
-    Creates a stacked bar plot of gene counts by CNV group for each tumor type.
-    
-    Parameters:
-    - combined_data: DataFrame containing the data to plot.
-    """
-    # Define CNV colors inside the function
-    cnv_colors = {
-        "loss": "#0000FF",
-        "neutral": "#808080",
-        "gain": "#00FF00",
-         "amplification": "#FF0000"
-    }
-    
-    tumor_types = combined_data['tumor_type'].unique()
-    
-    # Create subplots for each tumor type
-    fig, axes = plt.subplots(1, len(tumor_types), figsize=(5, 5), sharey=True)
-    
-    # If there's only one tumor type, axes will not be an array, so we convert it into a list
-    if len(tumor_types) == 1:
-        axes = [axes]
-    
-    for idx, tumor_type in enumerate(tumor_types):
-        ax = axes[idx]
-        tumor_data = combined_data[combined_data['tumor_type'] == tumor_type]
-        
-        # Create a table of counts for CNV group vs gene group
-        counts = pd.crosstab(tumor_data['gene_group'], tumor_data['cnv_group'])
-        
-        # Plot stacked bars
-        counts.plot(kind='bar', stacked=True, ax=ax, color=[cnv_colors[group] for group in counts.columns], width=0.6)
+    if intercept:
+        design_matrix.insert(0, "intercept", 1)
 
-        ax.set_title(tumor_type, fontsize=16)
-        ax.set_xlabel("")
-        ax.set_ylabel("Gene Counts", fontsize=16)
-        
-        # Customize axis labels and tick marks
-        ax.tick_params(axis='x', labelsize=16, labelcolor="black")
-        ax.tick_params(axis='y', labelsize=16, labelcolor="black")
-    
-    # Overall settings for layout and labels
-    plt.xticks(fontsize=12, color="black", rotation=45, ha="right")
-    plt.tight_layout()
-    plt.show()
-    
+    # Convert categorical factors one-hot encodings to int
+    design_matrix = design_matrix.astype("int")
 
-def plot_percentage_bar(barplot_data):
-    """
-    Creates a bar plot showing the percentage of genes for each gene group across tumor types.
-    
-    Parameters:
-    - barplot_data: DataFrame containing 'gene_group', 'percentage', and 'Count' columns.
-    """
-    # Define the gene group colors inside the function
-    gene_group_colors = {
-        "DIGs": "#8F3931FF",
-        "DSGs": "#FFB977",
-        "DCGs": "#FFC300"
-    }
-
-    tumor_types = barplot_data['tumor_type'].unique()
-    
-    plt.figure(figsize=(5, 5))
-    sns.set(style="whitegrid")
+    # Add continuous factors
+    if continuous_factors is not None:
+        for factor in continuous_factors:
+            # This factor should be numeric
+            design_matrix[factor] = pd.to_numeric(metadata[factor])
+    return design_matrix
 
-    # Create subplots for each tumor type
-    fig, axes = plt.subplots(1, len(tumor_types), figsize=(5, 5), sharey=True)
-    
-    # If only one tumor type, ensure axes is a list
-    if len(tumor_types) == 1:
-        axes = [axes]
-    
-    for idx, tumor_type in enumerate(tumor_types):
-        ax = axes[idx]
-        tumor_data = barplot_data[barplot_data['tumor_type'] == tumor_type]
-        
-        # Plot the percentage bar plot
-        sns.barplot(data=tumor_data, x="gene_group", y="percentage", hue="gene_group",
-                    palette=gene_group_colors, ax=ax, width=0.6)
-
-        # Add counts and percentages as labels
-        for p in ax.patches:
-            height = p.get_height()
-            gene_group = p.get_x() + p.get_width() / 2  # Get the x position of the patch (bar)
-
-            # Find the gene_group in the data based on its position
-            group_name = tumor_data.iloc[int(gene_group)]['gene_group']
-            count = tumor_data.loc[tumor_data['gene_group'] == group_name, 'Count'].values[0]
-            percentage = tumor_data.loc[tumor_data['gene_group'] == group_name, 'percentage'].values[0]
-
-            # Position the labels slightly above the bars
-            ax.text(p.get_x() + p.get_width() / 2, height + 0.5, f'{count} ({round(percentage, 1)}%)', 
-                    ha='center', va='bottom', fontsize=12, color="black")
-        
-        ax.set_title(tumor_type, fontsize=16)
-        ax.set_xlabel("")
-        ax.set_ylabel("Percentage of Genes", fontsize=16)
-
-        # Customize axis labels and tick marks
-        ax.tick_params(axis='x', labelsize=16, labelcolor="black", rotation=45)
-        ax.tick_params(axis='y', labelsize=16, labelcolor="black")
-
-        # Explicitly set the x-tick labels with proper rotation and alignment
-        for tick in ax.get_xticklabels():
-            tick.set_horizontalalignment('right')  # This ensures proper alignment for x-ticks
-            tick.set_rotation(45)
-
-    # Overall settings for layout and labels
-    plt.tight_layout()
-    plt.show()

deconveil/utils_plot.py

@@ -0,0 +1,308 @@
+import numpy as np
+import pandas as pd
+
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+
+def plot_volcano(plot_data, lfc_cut=1.0, pval_cut=0.05, xlim=None, ylim=None):
+    plot_data['gene_group'] = plot_data['gene_group'].astype('category')
+    
+    # Define gene group colors
+    gene_group_colors = {
+        "DIGs": "#8F3931FF",
+        "DSGs": "#FFB977",
+        "DCGs": "#FFC300"
+    }
+
+    # Create a FacetGrid for faceted plots
+    g = sns.FacetGrid(
+        plot_data, 
+        col="method", 
+        margin_titles=True, 
+        hue="gene_group", 
+        palette=gene_group_colors, 
+        sharey=False, 
+        sharex=True
+    )
+
+    
+    # Add points for "DIGs" 
+    g.map_dataframe(
+        sns.scatterplot, 
+        x="log2FC", 
+        y="-log10(padj)", 
+        alpha=0.2, 
+        size=0.5, 
+        legend=False, 
+        data=plot_data[plot_data['gene_group'] == "DIGs"]
+    )
+
+    # Add points for "DSGs" and "DCGs
+    g.map_dataframe(
+        sns.scatterplot, 
+        x="log2FC", 
+        y="-log10(padj)", 
+        alpha=0.8, 
+        s=3.0, 
+        legend=False, 
+        data=plot_data[plot_data['gene_group'] == "DSGs"]
+    )
+
+    g.map_dataframe(
+        sns.scatterplot, 
+        x="log2FC", 
+        y="-log10(padj)", 
+        alpha=1.0, 
+        s=3.0, 
+        legend=False, 
+        data=plot_data[plot_data['gene_group'] == "DCGs"],
+        zorder=5              # force to front
+    )
+    
+    # Threshold lines
+    for ax in g.axes.flat:
+        ax.axvline(x=-lfc_cut, color="gray", linestyle="dashed")
+        ax.axvline(x=lfc_cut, color="gray", linestyle="dashed")
+        ax.axhline(y=-np.log10(pval_cut), color="gray", linestyle="dashed")
+        
+        if xlim:
+            ax.set_xlim(xlim)
+        if ylim:
+            ax.set_ylim(ylim)
+    
+    # Labels and legend
+    g.set_axis_labels("Log2 FC", "-Log10 P-value")
+    g.add_legend(title="Gene category")
+    g.set_titles(row_template="{row_name}", col_template="{col_name}")
+    g.tight_layout()
+    
+    # Axis formatting
+    for ax in g.axes.flat:
+        ax.tick_params(axis='both', labelsize=12)
+        ax.set_xlabel("Log2 FC", fontsize=14)
+        ax.set_ylabel("-Log10 P-value", fontsize=14)
+    
+    # Save or display the plot
+    plt.show()
+
+
+def plot_cnv_hist(cnv_mean, binwidth=0.2, title="CNV Mean Distribution"):
+    """
+    Plots a histogram of the CNV mean distribution.
+
+    Parameters:
+        cnv_mean (pd.Series or list): The CNV mean values to plot.
+        binwidth (float): The bin width for the histogram.
+        title (str): The title of the plot.
+    """
+    # Convert to a DataFrame if it's not already
+    if isinstance(cnv_mean, list):
+        cnv_mean = pd.DataFrame({'cnv_mean': cnv_mean})
+    elif isinstance(cnv_mean, pd.Series):
+        cnv_mean = cnv_mean.to_frame(name='cnv_mean')
+
+    # Create the histogram plot
+    plt.figure(figsize=(5, 5))
+    sns.histplot(
+        cnv_mean['cnv_mean'],
+        bins=int((cnv_mean['cnv_mean'].max() - cnv_mean['cnv_mean'].min()) / binwidth),
+        kde=False,
+        color="#F39B7F",
+        edgecolor="black",
+        alpha=0.7
+    )
+
+    # Add labels and titles
+    plt.title(title, fontsize=14, pad=12)
+    plt.xlabel("CN state", fontsize=14, labelpad=8)
+    plt.ylabel("Frequency", fontsize=14, labelpad=8)
+
+    # Customize the appearance of axes
+    plt.xticks(fontsize=12, color="black", rotation=45, ha="right")
+    plt.yticks(fontsize=12, color="black")
+    plt.gca().spines["top"].set_visible(False)
+    plt.gca().spines["right"].set_visible(False)
+    plt.gca().spines["left"].set_linewidth(1)
+    plt.gca().spines["bottom"].set_linewidth(1)
+
+    # Add a grid
+    plt.grid(visible=False)
+
+    # Show the plot
+    plt.tight_layout()
+    plt.show()
+
+
+def plot_stacked_bar(combined_data):
+    """
+    Creates a stacked bar plot of gene counts by CNV group for each tumor type.
+    
+    Parameters:
+    - combined_data: DataFrame containing the data to plot.
+    """
+    # Define CNV colors inside the function
+    cnv_colors = {
+        "loss": "dodgerblue",
+        "neutral": "gray",
+        "gain": "yellowgreen",
+         "amplification": "coral"
+    }
+    
+    tumor_types = combined_data['tumor_type'].unique()
+    
+    # Create subplots for each tumor type
+    fig, axes = plt.subplots(1, len(tumor_types), figsize=(5, 5), sharey=True)
+    
+    # If there's only one tumor type, axes will not be an array, so we convert it into a list
+    if len(tumor_types) == 1:
+        axes = [axes]
+    
+    for idx, tumor_type in enumerate(tumor_types):
+        ax = axes[idx]
+        tumor_data = combined_data[combined_data['tumor_type'] == tumor_type]
+        
+        # Create a table of counts for CNV group vs gene group
+        counts = pd.crosstab(tumor_data['gene_group'], tumor_data['cnv_group'])
+        
+        # Plot stacked bars
+        counts.plot(kind='bar', stacked=True, ax=ax, color=[cnv_colors[group] for group in counts.columns], width=0.6)
+
+        ax.set_title(tumor_type, fontsize=16)
+        ax.set_xlabel("")
+        ax.set_ylabel("Gene Counts", fontsize=16)
+        
+        # Customize axis labels and tick marks
+        ax.tick_params(axis='x', labelsize=16, labelcolor="black")
+        ax.tick_params(axis='y', labelsize=16, labelcolor="black")
+    
+    # Overall settings for layout and labels
+    plt.xticks(fontsize=12, color="black", rotation=45, ha="right")
+    plt.tight_layout()
+    plt.show()
+    
+
+def plot_percentage_bar(barplot_data):
+    """
+    Creates a bar plot showing the percentage of genes for each gene group across tumor types.
+    
+    Parameters:
+    - barplot_data: DataFrame containing 'gene_group', 'percentage', and 'Count' columns.
+    """
+    # Define the gene group colors inside the function
+    gene_group_colors = {
+        "DIGs": "#8F3931FF",
+        "DSGs": "#FFB977",
+        "DCGs": "#FFC300"
+    }
+
+    tumor_types = barplot_data['tumor_type'].unique()
+    
+    plt.figure(figsize=(5, 5))
+    sns.set(style="whitegrid")
+
+    # Create subplots for each tumor type
+    fig, axes = plt.subplots(1, len(tumor_types), figsize=(5, 5), sharey=True)
+    
+    # If only one tumor type, ensure axes is a list
+    if len(tumor_types) == 1:
+        axes = [axes]
+    
+    for idx, tumor_type in enumerate(tumor_types):
+        ax = axes[idx]
+        tumor_data = barplot_data[barplot_data['tumor_type'] == tumor_type]
+        
+        # Plot the percentage bar plot
+        sns.barplot(data=tumor_data, x="gene_group", y="percentage", hue="gene_group",
+                    palette=gene_group_colors, ax=ax, width=0.6)
+
+        # Add counts and percentages as labels
+        for p in ax.patches:
+            height = p.get_height()
+            gene_group = p.get_x() + p.get_width() / 2  # Get the x position of the patch (bar)
+
+            # Find the gene_group in the data based on its position
+            group_name = tumor_data.iloc[int(gene_group)]['gene_group']
+            count = tumor_data.loc[tumor_data['gene_group'] == group_name, 'Count'].values[0]
+            percentage = tumor_data.loc[tumor_data['gene_group'] == group_name, 'percentage'].values[0]
+
+            # Position the labels slightly above the bars
+            ax.text(p.get_x() + p.get_width() / 2, height + 0.5, f'{count} ({round(percentage, 1)}%)', 
+                    ha='center', va='bottom', fontsize=12, color="black")
+        
+        ax.set_title(tumor_type, fontsize=16)
+        ax.set_xlabel("")
+        ax.set_ylabel("Percentage of Genes", fontsize=16)
+
+        # Customize axis labels and tick marks
+        ax.tick_params(axis='x', labelsize=16, labelcolor="black", rotation=45)
+        ax.tick_params(axis='y', labelsize=16, labelcolor="black")
+
+        # Explicitly set the x-tick labels with proper rotation and alignment
+        for tick in ax.get_xticklabels():
+            tick.set_horizontalalignment('right')  # This ensures proper alignment for x-ticks
+            tick.set_rotation(45)
+
+    # Overall settings for layout and labels
+    plt.tight_layout()
+    plt.show()
+
+
+def plot_pca_clusters(pca_coords, labels, explained_var, title="PCA Clustering"):
+    """
+    Scatterplot of first 2 PCs with cluster colors, showing variance explained.
+
+    Parameters
+    ----------
+    pca_coords : DataFrame
+        PCA coordinates (samples × PCs), from pca_cluster_cn().
+    labels : pd.Series
+        Cluster assignments (index must match pca_coords).
+    explained_var : array-like
+        Explained variance ratio for each PC.
+    title : str
+        Plot title.
+    """
+    df_plot = pca_coords.copy()
+    df_plot["cluster"] = labels.astype(str)
+
+    plt.figure(figsize=(7,6))
+    sns.scatterplot(
+        x="PC1", y="PC2", hue="cluster",
+        data=df_plot, palette="Set2", s=70, alpha=0.9, edgecolor="k"
+    )
+
+    # Format axis labels with variance %
+    pc1_var = explained_var[0] * 100
+    pc2_var = explained_var[1] * 100
+    plt.xlabel(f"PC1 ({pc1_var:.1f}% variance)")
+    plt.ylabel(f"PC2 ({pc2_var:.1f}% variance)")
+
+    plt.title(title, fontsize=14)
+    plt.legend(title="Cluster", bbox_to_anchor=(1.05, 1), loc="upper left")
+    plt.tight_layout()
+    plt.show()
+
+
+def plot_consensus_matrix(consensus_matrix, labels, title="Consensus Matrix"):
+    """
+    Heatmap of consensus matrix with samples ordered by cluster.
+    
+    Parameters
+    ----------
+    consensus_matrix : pd.DataFrame
+        Sample × Sample consensus values.
+    labels : pd.Series
+        Final cluster assignments (same sample index).
+    """
+    # Order samples by cluster
+    ordered_samples = labels.sort_values().index
+    mat = consensus_matrix.loc[ordered_samples, ordered_samples]
+
+    plt.figure(figsize=(7,6))
+    sns.heatmap(mat, cmap="viridis", square=True, cbar_kws={"label": "Consensus"})
+    plt.title(title, fontsize=14)
+    plt.xlabel("Samples")
+    plt.ylabel("Samples")
+    plt.tight_layout()
+    plt.show()

deconveil/utils_processing.py

@@ -0,0 +1,132 @@
+import os
+import warnings
+from math import ceil, floor
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+from typing import List, Literal, Optional, Dict, Any, cast
+
+
+
+def filter_low_count_genes(
+    df: pd.DataFrame,
+    other_dfs: Optional[List[pd.DataFrame]] = None,
+    min_count: int = 10,
+    min_samples: Optional[int] = 3,
+    min_frac: Optional[float] = None,
+    return_mask: bool = False
+) -> Dict[str, Any]:
+    """
+    Filter genes (columns) by expression thresholds.
+
+    Parameters
+    ----------
+    df : pd.DataFrame
+        Main dataframe (genes as columns, samples as rows).
+    other_dfs : list of pd.DataFrame, optional
+        Other dataframes with the same columns to filter in parallel.
+    min_count : int, default=10
+        Minimum expression/count threshold.
+    min_samples : int, default=3
+        Minimum number of samples meeting the threshold.
+    min_frac : float, optional
+        Fraction of samples that must meet the threshold.
+        If provided, overrides min_samples.
+    return_mask : bool, default=False
+        If True, also return the boolean mask of kept genes.
+
+    Returns
+    -------
+    result : dict
+        {
+            "filtered_df": pd.DataFrame,
+            "other_filtered": list[pd.DataFrame] or None,
+            "mask": pd.Series (if return_mask),
+            "stats": dict with counts
+        }
+    """
+    # compute required min_samples
+    if min_frac is not None:
+        min_samples = max(1, int(round(min_frac * df.shape[0])))
+
+    # gene-wise filter mask
+    mask = (df >= min_count).sum(axis=0) >= min_samples
+
+    # apply mask
+    filtered_df = df.loc[:, mask]
+    filtered_others = [odf.loc[:, mask] for odf in other_dfs] if other_dfs else None
+
+    # collect stats
+    stats = {
+        "n_total": df.shape[1],
+        "n_kept": int(mask.sum()),
+        "n_removed": int((~mask).sum()),
+        "min_count": min_count,
+        "min_samples": min_samples,
+    }
+
+    result = {
+        "filtered_df": filtered_df,
+        "other_filtered": filtered_others,
+        "stats": stats,
+    }
+    if return_mask:
+        result["mask"] = mask
+
+    return result
+
+
+def process_results(file_path, method, lfc_cut = 1.0, pval_cut = 0.05):
+    df = pd.read_csv(file_path, index_col=0)
+    df['isDE'] = (np.abs(df['log2FoldChange']) >= lfc_cut) & (df['padj'] <= pval_cut)
+    df['DEtype'] = np.where(
+        ~df['isDE'], 
+        "n.s.", 
+        np.where(df['log2FoldChange'] > 0, "Up-reg", "Down-reg")
+    )
+    df['method'] = method
+    return df[['log2FoldChange', 'padj', 'isDE', 'DEtype', 'method']]
+    
+
+def define_gene_groups(res_joint):
+    DSGs = res_joint[
+        ((res_joint['DEtype_naive'] == "Up-reg") & (res_joint['DEtype_aware'] == "n.s.")) |
+        ((res_joint['DEtype_naive'] == "Down-reg") & (res_joint['DEtype_aware'] == "n.s."))
+    ].assign(gene_category='DSGs')
+    
+    DIGs = res_joint[
+        ((res_joint['DEtype_naive'] == "Up-reg") & (res_joint['DEtype_aware'] == "Up-reg")) |
+        ((res_joint['DEtype_naive'] == "Down-reg") & (res_joint['DEtype_aware'] == "Down-reg"))
+    ].assign(gene_category='DIGs')
+             
+    DCGs = res_joint[
+        ((res_joint['DEtype_naive'] == "n.s.") & (res_joint['DEtype_aware'] == "Up-reg")) |
+        ((res_joint['DEtype_naive'] == "n.s.") & (res_joint['DEtype_aware'] == "Down-reg"))
+    ].assign(gene_category='DCGs')
+             
+    non_DEGs = res_joint[
+        (res_joint['DEtype_naive'] == "n.s.") & (res_joint['DEtype_aware'] == "n.s.")
+    ].assign(gene_category='non-DEGs')
+             
+    return {
+        "DSGs": DSGs,
+        "DIGs": DIGs,
+        "DCGs": DCGs,
+        "non_DEGs": non_DEGs
+    }
+
+
+def clean_gene_group(df, mode="naive"):
+    """Rename and subset a gene group dataframe for a given mode."""
+    suffix = f"_{mode}"
+    rename_map = {
+        f"logFC{suffix}": "log2FC",
+        f"padj{suffix}": "padj",
+        f"isDE{suffix}": "isDE",
+        f"DEtype{suffix}": "DEtype",
+        f"method{suffix}": "method",
+        "gene_category": "gene_group"
+    }
+    return df.rename(columns=rename_map)[["log2FC", "padj", "isDE", "DEtype", "method", "gene_group"]]

{DeConveil-0.1.0.dist-info → deconveil-0.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: DeConveil
-Version: 0.1.0
+Version: 0.1.2
 Summary: An extension of PyDESeq2/DESeq2 designed to account for genome aneuploidy
 Home-page: https://github.com/caravagnalab/DeConveil
 Author: Katsiaryna Davydzenka
@@ -29,6 +29,7 @@ Dynamic: author
 Dynamic: author-email
 Dynamic: home-page
 Dynamic: license
+Dynamic: license-file
 Dynamic: provides-extra
 Dynamic: requires-dist
 Dynamic: requires-python

deconveil-0.1.2.dist-info/RECORD

@@ -0,0 +1,16 @@
+deconveil/__init__.py,sha256=_6FL_AYiycv9nP3mKJiQ4zl4aU83YSWnV2YoIZr9Mv0,188
+deconveil/__version__.py,sha256=K5SiDdEGYMpdqXThrqwTqECJJBOQNTQDrnpc2K5mzKs,21
+deconveil/dds.py,sha256=0MNwtDzCjqjoJR-rrCmVu3JOaDd3gXuToOzTBXJMxak,49039
+deconveil/default_inference.py,sha256=J40O0-qZChLnLrLGmhwxjaTVsV7REWAUQOTf8qSwWk0,9466
+deconveil/ds.py,sha256=Vb9p152U1KXltrXFpMoBxY6YRW25dP4CO26_osbz6Aw,29476
+deconveil/grid_search.py,sha256=iOHR8ur10MyrrfEZHr409lGulGxODufsjG6j7lQ7tWs,5181
+deconveil/inference.py,sha256=B3zf3q_mbCTX3gHJwuXnTuy9uyXOxEjuWyaSR6VtVEo,10429
+deconveil/utils_clustering.py,sha256=twspPvXQ6pvw_NaY1ebyvswuH3ZvVBGn7DeOpZ1XatI,5939
+deconveil/utils_fit.py,sha256=SdGcBQjN3cyzbSFessufYOOOJAQCOjNcy3etbwmodsM,21583
+deconveil/utils_plot.py,sha256=1JQthYXaEUKUWa0fy8owkyJ1CTkQxlrSRAqPkXMk7Us,9857
+deconveil/utils_processing.py,sha256=CB99CwQst7eUiIgE58yl7_3E6uD9CgQoU_Qmprjyt-s,4141
+deconveil-0.1.2.dist-info/licenses/LICENSE,sha256=BJ0f3JRteiF7tjiARi8syxiu4yKmckc0nWlHCKXttKQ,1078
+deconveil-0.1.2.dist-info/METADATA,sha256=JqHZYXo0lLvPjoj_cDT-IwHADSKdESJQxorDbpsk3-k,1097
+deconveil-0.1.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+deconveil-0.1.2.dist-info/top_level.txt,sha256=yAWZbw0eg8XpbMsswoq-VzBGfQHrfWOqNHnu2qQ2xO4,10
+deconveil-0.1.2.dist-info/RECORD,,

{DeConveil-0.1.0.dist-info → deconveil-0.1.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

deconveil-0.1.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+deconveil

DeConveil-0.1.0.dist-info/RECORD

@@ -1,12 +0,0 @@
-DeConveil/__init__.py,sha256=_6FL_AYiycv9nP3mKJiQ4zl4aU83YSWnV2YoIZr9Mv0,188
-DeConveil/dds.py,sha256=gJDe6uoolAaS6v7C9DIRM_05LDuhlQO3u6WbMamMMbA,49126
-DeConveil/default_inference.py,sha256=Ym4mOq4yG7CbvtWF_HqibJrWQLTpUHRgsqGo2cKE5OA,9570
-DeConveil/ds.py,sha256=WUpSTCxMt1yeQf6zORmNUnz-whwyTaizmg0i_09v73c,29512
-DeConveil/grid_search.py,sha256=Gy9wLBe1YrJdimpTz4oFrTGv6pvhK3kVPa6FrI2vq8o,5189
-DeConveil/inference.py,sha256=fcvoL7KHuuLVxF8sz7QIT9A1o80sIRpOcIvyyF_rJGc,10480
-DeConveil/utils_CNaware.py,sha256=cRyPMNHW0JjXEonDHlRNAuzHrP9egJ2aERSRvp5ugGI,25182
-DeConveil-0.1.0.dist-info/LICENSE,sha256=BJ0f3JRteiF7tjiARi8syxiu4yKmckc0nWlHCKXttKQ,1078
-DeConveil-0.1.0.dist-info/METADATA,sha256=SNyxZkjZxPh2ZtIsAkGDlbgibe-AqGsPta6a10n65oc,1075
-DeConveil-0.1.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-DeConveil-0.1.0.dist-info/top_level.txt,sha256=LI9aJqnkaO3AawK0hV1oHW0dd6n16Jv3uZyQdC2n0bg,10
-DeConveil-0.1.0.dist-info/RECORD,,

DeConveil-0.1.0.dist-info/top_level.txt

@@ -1 +0,0 @@
-DeConveil