networks per sample done with loading of the edges

Author: OwenGriere

package/core/NAS/niches_per_sample.py

@@ -1,4 +1,75 @@
+import pandas as pd
 from mosna import mosna
+from package.utils.emit_qt_progress import emit_qt_progress, emit_qt_info
+from package.core.NAS.merge_niche_pheno import merge_niche_pheno
+from package.core.NAS.mosna_figures import mosna_figures
 
-def niches_per_sample():
-    return 0
+def niches_per_sample(method, net_dir, save_dir, data_info ,pheno_col, uniq_phenotype, stat_funcs, stat_names, id_level_1, id_level_2, 
+                     reducer_type, clusterer_type, n_neighbors, metric, n_clusters, resolution, min_dist, dim_clust, 
+                     min_cluster_size, k_cluster, normalize):
+    
+    emit_qt_info("[PROCESS] Spatial Omic Features for all networks")
+    emit_qt_progress(0,3, "[PROCESS] Niches Analysis")
+
+    var_aggreg = mosna.compute_spatial_omic_features_single_network(
+            method=method,
+            net_dir=net_dir,
+            attributes_col=pheno_col,
+            data_info=data_info,
+            use_attributes=uniq_phenotype, 
+            make_onehot=True,
+            stat_funcs=stat_funcs,
+            stat_names=stat_names,
+            id_level_1=id_level_1,
+            id_level_2=id_level_2,
+            parallel_groups='max',
+            memory_limit='max',
+            save_intermediate_results=False, 
+            dir_save_interm=None,
+            verbose=0,
+    )
+
+    emit_qt_progress(1,3, "[PROCESS] Niches Analysis")
+
+    emit_qt_info("[PROCESS] Reduction and Clustering of Spatial Niches")
+    cluster_labels, _, _, _ = mosna.get_clusterer(
+        data=var_aggreg.values,
+        data_dir=save_dir,
+        reducer_type=reducer_type,
+        clusterer_type=clusterer_type,
+        n_neighbors=n_neighbors,
+        metric=metric,
+        n_clusters=n_clusters,
+        resolution=resolution,
+        min_dist=min_dist,
+        dim_clust=dim_clust,
+        min_cluster_size=min_cluster_size,
+        use_gpu=False,
+        k_cluster=k_cluster,
+        verbose=0,
+    )
+    emit_qt_progress(2,3, "[PROCESS] Niches Analysis")
+
+    cell_types = merge_niche_pheno(net_dir, pheno_col, cluster_labels)
+
+    emit_qt_info("[PROCESS] Generate Niches Composition")
+    if normalize == 'all':
+        for normalization in ['total', 'niche', 'obs', 'clr', 'niche&obs']:
+            counts = mosna.make_niches_composition(
+                    var=cell_types,
+                    niches=cluster_labels,
+                    var_label=pheno_col,
+                    normalize=normalization
+            )
+            save_dir_norm = save_dir / f'{normalization}'
+            save_dir_norm.mkdir(exist_ok=True, parents=True)
+            mosna_figures(cluster_labels, counts, save_dir_norm)
+    else:
+        counts = mosna.make_niches_composition(
+                    var=cell_types,
+                    niches=cluster_labels,
+                    var_label=pheno_col,
+                    normalize=normalize
+        )
+        mosna_figures(cluster_labels, counts, save_dir)
+    emit_qt_progress(3,3, "[PROCESS] Niches Analysis")

package/core/tysserand/draw_per_sample.py

@@ -20,7 +20,7 @@
 from ...utils.read_extension import get_opener
 from ...utils.find_sample_from_file import find_sample_from_file
 
-def draw_per_sample(file, 
+def draw_per_sample(node_file, 
                     X_position, 
                     Y_position, 
                     pheno_col, 
@@ -31,20 +31,24 @@ def draw_per_sample(file,
                     temp_folder, 
                     patient_colmun, 
                     sample_column, 
-                    extension):
+                    extension,
+                    edges_file = None):
 
     opener = get_opener(extension)
-    node = opener(file)
+    node = opener(node_file)
 
-    patient, sample = find_sample_from_file(file, patient_colmun, sample_column)
+    patient, sample = find_sample_from_file(node_file, patient_colmun, sample_column)
     patient = int("".join(c for c in patient if c.isdigit()))
 
     clustering = node[pheno_col]
 
     coords = node[[X_position,Y_position]].to_numpy()
-    pairs = ty.build_delaunay(coords)
-            
-    pairs = ty.link_solitaries(coords, pairs, method=method, min_neighbors=min_neighbors, verbose=0)
+
+    if edges_file is None:
+        pairs = ty.build_delaunay(coords)
+        pairs = ty.link_solitaries(coords, pairs, method=method, min_neighbors=min_neighbors, verbose=0)
+    else:
+        pairs = pd.read_parquet(edges_file)
 
     fig, ax = ty.plot_network(
                 coords, pairs,labels=clustering,

package/niche_analysis.py

@@ -14,6 +14,7 @@
 from package.core.tysserand.draw_per_sample import draw_per_sample
 from package.utils.find_sample import find_sample
 from package.core.tysserand.generate_cmap import generate_cmap
+from package.utils.find_sample_from_file import find_sample_from_file
 
 from mosna import mosna
 
@@ -129,15 +130,16 @@ def main():
             save_dir.mkdir(exist_ok=True, parents=True)
 
             args_list = [(
-                patient_sample,
+                node_file,
                 X,
                 Y,
                 'niches',
                 c_map,
                 'delaunay',3,
                 save_dir,'None',
                 kwargs['id_level_1'],kwargs['id_level_2'],
-                'parquet')for patient_sample in files]
+                'parquet', '/'.join(node_file.rsplit('/', 1)[:-1] + [node_file.rsplit('/', 1)[-1].replace('nodes_', 'edges_', 1)])
+                ) for node_file in files]
 
             process_map(
                 worker_draw_wrapper,
@@ -148,50 +150,89 @@ def main():
             )
 
     elif per_sample:
-
+        from package.core.NAS.niches_per_sample import niches_per_sample
         save_dir = save_dir = working_dir / "Niche_Analysis/Per_sample" / config['Saving directory']
         save_dir.mkdir(exist_ok=True, parents=True)
-        kwargs = {
-            "method": config.get("method", "NAS"),
-            "net_dir": net_dir,
-            "save_dir": save_dir,
-            "temp_dir": net_dir,
-            "pheno_col": config["Phenotype column"], 
-            "uniq_phenotype": uniq_phenotype,    
-            "stat_funcs": config.get("stat_funcs", "default"),
-            "stat_names": config.get("stat_names", "default"),
-            "id_level_1": config.get("Patient column name", "patient"),
-            "id_level_2": config.get("Sample column name", "sample"),
 
-            ############# Clustering / réduction
-            "reducer_type": config["Per sample"].get("reducer_type", "umap"),
-            "clusterer_type": config["Per sample"].get("clusterer_type", "leiden"),
-            "n_neighbors": int(config["Per sample"].get("n_neighbors", 15)),
-            "metric": config["Per sample"].get("metric", "euclidean"),
-            "n_clusters": int(config["Per sample"].get("n_clusters", 15)),
-            "resolution": float(config["Per sample"].get("resolution", 0.005)),
-            "min_dist": float(config["Per sample"].get("min_dist", 0.0)),
-            "dim_clust": int(config["Per sample"].get("dim_clust", 2)),
-            "min_cluster_size": float(config["Per sample"].get("min_cluster_size", 0.001)),
-            "k_cluster": int(config["Per sample"].get("k_cluster", 8)),
-
-            ########## Normalisation composition niches
-            "normalize": config["Per sample"].get("normalize", "total"),
-        }
-        from package.core.NAS.niches_per_sample import niches_per_sample
-        niches_per_sample(**kwargs)
-
-        emit_qt_info('[INFO] Niches found for each samples')
-
-        for path in save_dir.glob("reducer-umap*"):
-            if path.is_dir():
-                shutil.rmtree(path)
-        save_config(save_dir, config)
-
-        X, Y = config['X coordinates column for niches'], config['Y coordinates column for niches']
-
-        if X is not None and Y is not None:
-            pass
+        files = find_sample(net_dir, 'parquet', config.get("Patient column name", "patient"), config.get("Sample column name", "sample"))
+        data_info = []
+        for file in files:
+            if config.get("Sample column name", "sample") is None:
+                patient = find_sample_from_file(file, config.get("Patient column name", "patient"), config.get("Sample column name", "sample"))
+                data_info.append([patient])
+            else:
+                patient, sample = find_sample_from_file(file, config.get("Patient column name", "patient"), config.get("Sample column name", "sample"))
+                data_info.append([patient, sample])
+
+        for sample in data_info:
+            if config.get("Sample column name", "sample") is None:
+                patient_sample = f'{config.get("Patient column name", "patient")}-{sample[0]}'
+            else:
+                patient_sample = f'{config.get("Patient column name", "patient")}-{sample[0]}_{config.get("Sample column name", "sample")}-{sample[1]}'
+            save_dir_sample = save_dir / f'{patient_sample}'
+
+            kwargs = {
+                "method": config.get("method", "NAS"),
+                "net_dir": net_dir,
+                "save_dir": save_dir_sample,
+                "data_info": sample,
+                "pheno_col": config["Phenotype column"], 
+                "uniq_phenotype": uniq_phenotype,    
+                "stat_funcs": config.get("stat_funcs", "default"),
+                "stat_names": config.get("stat_names", "default"),
+                "id_level_1": config.get("Patient column name", "patient"),
+                "id_level_2": config.get("Sample column name", "sample"),
+
+                ############# Clustering / réduction
+                "reducer_type": config["Per sample"].get("reducer_type", "umap"),
+                "clusterer_type": config["Per sample"].get("clusterer_type", "leiden"),
+                "n_neighbors": int(config["Per sample"].get("n_neighbors", 15)),
+                "metric": config["Per sample"].get("metric", "euclidean"),
+                "n_clusters": int(config["Per sample"].get("n_clusters", 15)),
+                "resolution": float(config["Per sample"].get("resolution", 0.005)),
+                "min_dist": float(config["Per sample"].get("min_dist", 0.0)),
+                "dim_clust": int(config["Per sample"].get("dim_clust", 2)),
+                "min_cluster_size": float(config["Per sample"].get("min_cluster_size", 0.001)),
+                "k_cluster": int(config["Per sample"].get("k_cluster", 8)),
+
+                ########## Normalisation composition niches
+                "normalize": config["Per sample"].get("normalize", "total"),
+            }
+            
+            niches_per_sample(**kwargs)
+
+            emit_qt_info('[INFO] Niches found for each samples')
+
+            for path in save_dir_sample.glob("reducer-umap*"):
+                if path.is_dir():
+                    shutil.rmtree(path)
+            save_config(save_dir_sample, config)
+
+            X, Y = config['X coordinates column for niches'], config['Y coordinates column for niches']
+
+            if X is not None and Y is not None:
+                c_map = generate_cmap(net_dir, 'niche', 'parquet', kwargs['id_level_1'], kwargs['id_level_2'])
+                files = find_sample(net_dir, 'parquet', kwargs['id_level_1'], kwargs['id_level_2'])
+                cpu_max = verif_cpu(config['CPU'], len(files))
+
+                save_dir_sample_tysserand = save_dir_sample / 'Tysserand_Network_Niches'
+                save_dir_sample_tysserand.mkdir(exist_ok=True, parents=True)
+
+                node_file = net_dir / f'nodes_{patient_sample}.parquet'
+                edge_file = net_dir / f'edges_{patient_sample}.parquet'
+
+                args_list = [
+                    node_file,
+                    X,
+                    Y,
+                    'niches',
+                    c_map,
+                    'delaunay',3,
+                    save_dir_sample_tysserand,'None',
+                    kwargs['id_level_1'],kwargs['id_level_2'],
+                    'parquet',
+                    edge_file]
+                draw_per_sample(args_list)
 
 if __name__ == '__main__':
     main()