NetAnalyzer 1.0.0__py3-none-any.whl

NetAnalyzer/performancer.py

@@ -0,0 +1,83 @@
+class Performancer:
+	def __init__(self):
+		self.control = {}
+
+	def load_control(self, ref_array):
+		for pair in ref_array:
+			node1, node2 = pair
+			if node2 != '-':
+				query = self.control.get(node1)
+				if query == None:
+					self.control[node1] = [node2]
+				else:
+					query.append(node2)
+
+	# Pandey 2007, Association Analysis-based Transformations for Protein Interaction Networks: A Function Prediction Case Study
+	def get_pred_rec(self, predictions, cut_number = 100, top_number = 10000):
+		preds, limits = self.load_prediction(predictions)
+		cuts = self.get_cuts(limits, cut_number)
+		performance = [] #cut, pred, rec
+		for cut in cuts:
+			prec, rec = self.pred_rec(preds, cut, top_number)
+			performance.append([cut, prec, rec])
+		return performance
+
+	def load_prediction(self, pairs_array):
+		pred = {}
+		min = None
+		max = None
+		for rec in pairs_array:
+			key, label, score = rec
+			if min != None and max != None:
+				if score < min: min = score 
+				if score > max: max = score 
+			else:
+				min = score; max = score
+			query = pred.get(key)
+			if query == None:
+				pred[key] = [[label], [score]]
+			else:
+				query[0].append(label)
+				query[1].append(score)
+		return pred, [min, max]
+
+	def pred_rec(self, preds, cut, top):
+		predicted_labels = 0 #m
+		true_labels = 0 #n
+		common_labels = 0 # k
+		for ctrl in self.control:
+			key, c_labels = ctrl
+			true_labels += len(c_labels) #n
+			pred_info = preds[key]
+			if pred_info != None:
+				labels, scores = pred_info
+				reliable_labels = self.get_reliable_labels(labels, scores, cut, top)
+				predicted_labels += len(reliable_labels) #m
+				common_labels += len(set(c_labels) & set(reliable_labels)) #k
+		if predicted_labels > 0:
+			prec = common_labels/predicted_labels
+		else:
+			prec = 0.0
+
+		if true_labels > 0:
+			rec = common_labels/true_labels
+		else:
+			rec = 0.0
+
+		return prec, rec
+
+
+	def get_cuts(self, limits, n_cuts):
+		min, max = limits
+		span = (max - min)/n_cuts
+		cut = min
+		cuts = [ cut + n * span for n in range(n_cuts + 1) ]
+		return cuts
+
+	def get_reliable_labels(self, labels, scores, cut, top):
+		reliable_labels = [ [labels[i], score] for i, score in enumerable(scores) if score >= cut ]
+		def _(e):
+			return e[1]
+		reliable_labels.sort(reverse=True, key=_)
+		reliable_labels = [ pred[0] for pred in reliable_labels[0:top-1:1] ]
+		return reliable_labels

NetAnalyzer/ranker.py

@@ -0,0 +1,353 @@
+import numpy as np
+import os
+from itertools import combinations
+from sklearn.model_selection import KFold, LeaveOneOut
+from NetAnalyzer.adv_mat_calc import Adv_mat_calc
+from NetAnalyzer.seed_parser import SeedParser
+import py_exp_calc.exp_calc as pxc
+    
+class Ranker:
+
+    def __init__(self):
+        self.matrix = None
+        self.nodes = []  # kernel nodes
+        self.seeds = {}  # node seeds 
+        self.weights = {}
+        self.negatives = None # Could be 'all' or a dict with the negative nodes
+        self.seed_nodes2idx = {} 
+        self.reference_nodes = {} 
+        self.ranking = {} 
+        self.discarded_seeds = {}
+        self.in_names = True
+        self.seed_presence = True
+        self.attributes = {"header": ["candidates", "score", "normalized_rank", "rank", "uniq_rank"]}
+
+    # Normalization and filtering matrix
+    def normalize_matrix(self, mode="by_column"):
+        degree_matrix = self.matrix.sum(0)
+        inv_degree_matrix = np.diag(1/degree_matrix)
+        if mode == "by_column":
+            self.matrix = self.matrix @ inv_degree_matrix
+        elif mode == "by_row":
+            self.matrix = inv_degree_matrix  @ self.matrix
+        elif mode == "by_row_col":
+            self.matrix = np.sqrt(
+                inv_degree_matrix) @ self.matrix @ np.sqrt(inv_degree_matrix)
+
+    def filter_matrix(self, whitelist):
+        self.matrix, self.nodes, _ = Adv_mat_calc.filter_rowcols_by_whitelist(
+            self.matrix, self.nodes, self.nodes, whitelist, symmetric=True)
+
+    # loading and cleaning list of nodes
+    def load_nodes_from_file(self, file):
+        with open(file) as f:
+            for line in f:
+                self.nodes.append(line.rstrip())
+
+    def load_seeds(self, node_groups, sep=',', uniq=True):
+        self.seeds, self.weights = SeedParser.load_nodes_by_group(node_groups, sep=sep)
+        if uniq:
+            self.seeds = {seed: pxc.uniq(nodes) for seed, nodes in self.seeds.items()}
+    
+    def load_negatives(self, negative_file, sep=','):
+        if  os.path.exists(negative_file):
+            self.negatives, _ = SeedParser.load_node_groups_from_file(negative_file, sep=sep)
+        elif negative_file == "all":
+            self.negatives = negative_file
+
+    def load_references(self, node_groups, sep=','):
+        self.reference_nodes, _ = SeedParser.load_nodes_by_group(node_groups, sep=sep)
+
+    def clean_seeds(self, minimum_size = 1):
+        cleaned_seeds = {}
+        cleaned_weights = {}
+        for seed_name, seed in self.seeds.items():
+            cleaned_seed = [ node for node in seed if node in self.nodes ]
+            if len(cleaned_seed) < minimum_size:
+                self.discarded_seeds[seed_name] = seed
+            else:
+                cleaned_seeds[seed_name] = cleaned_seed
+            if self.weights.get(seed_name) is not None: 
+                cleaned_weights[seed_name] = { node: self.weights[seed_name][node] for node in cleaned_seed }
+        self.seeds = cleaned_seeds
+        self.weights = cleaned_weights
+
+
+    # id <-> name translation
+    def get_nodes_indexes(self, nodes):
+        node_indxs = []
+        #if type(nodes) == int: nodes = [nodes]
+        for node in nodes:
+            index_node = self.seed_nodes2idx[node]
+            node_indxs.append(index_node)
+
+        return node_indxs
+
+    def get_seed_indexes(self):
+        indexes = {}
+        for node in sum(self.seeds.values(), []):
+            if indexes.get(node) is None:
+                indx = self.nodes.index(node)
+                indexes[node] = indx
+        self.seed_nodes2idx = indexes
+
+    def translate2idx(self):
+        self.in_names = False
+        for seed_name, seed in self.seeds.items():
+            self.seeds[seed_name] = self.get_nodes_indexes(seed)
+        for seed_name, node2weight in self.weights.items():
+            node2weight = { self.seed_nodes2idx[node]: weight for node, weight in node2weight.items()}
+            self.weights[seed_name] = node2weight
+
+    def translate2names(self):
+        self.in_names = True
+        for seed_name, seed in self.seeds.items():
+            self.seeds[seed_name] = [self.nodes[node] for node in seed]
+        for seed_name, node2weight in self.weights.items():
+            node2weight = { self.nodes[node]: weight for node, weight in node2weight.items()}
+            self.weights[seed_name] = node2weight
+
+    # Ranking
+    ## Cross validation
+
+    def get_seed_cross_validation(self, k_fold=None):
+        new_seeds = {}
+        new_weights = {}
+        genes2predict = {}
+
+        for seed_name, seed in self.seeds.items():
+            if k_fold != None:
+                cv = KFold(n_splits=k_fold)
+            else:
+                cv = LeaveOneOut()
+
+            for indx, (train_index, test_index) in enumerate(cv.split(seed)):
+                seed_name_one_out = str(seed_name) + "_iteration_" + str(indx)
+                #print("train index is:", train_index)
+                new_seeds[seed_name_one_out] = [seed[i] for i in train_index]
+
+                if self.weights.get(seed_name):
+                    new_weights[seed_name_one_out] = {node: self.weights[seed_name][node] for node in new_seeds[seed_name_one_out]}
+
+                if self.in_names:
+                    genes2predict[seed_name_one_out] = [seed[i] for i in test_index]
+                else:
+                    genes2predict[seed_name_one_out] = [seed[i] for i in test_index]
+                    genes2predict[seed_name_one_out] = [self.nodes[idx] for idx in genes2predict[seed_name_one_out]]
+                if self.reference_nodes.get(seed_name) is not None:
+                    genes2predict[seed_name_one_out] += self.reference_nodes[seed_name]
+
+                genes2predict[seed_name_one_out] = list(
+                    set(genes2predict[seed_name_one_out]))
+
+        self.seeds = new_seeds
+        self.reference_nodes = genes2predict
+        self.weights = new_weights
+
+    def get_loo_ranking(self, seed_name, seed, metric = "mean"):
+         # Generate new seeds
+         # Get matrix values
+         cv = LeaveOneOut()
+         ncols= len(self.nodes)
+         nrows = len(seed)
+         W = np.zeros((nrows,ncols))
+         nodes2predict_pos = []
+         nodes2predict_names = []
+         new_seed_names = []
+         for indx, (train_index, test_index) in enumerate(cv.split(seed)):
+            new_seed_names.append(str(seed_name) + "_iteration_" + str(indx))
+            nodes = [seed[i] for i in train_index]
+            if self.weights.get(seed_name):
+                w = [self.weights[seed_name][node] for node in nodes]
+                W[indx, nodes] = w
+            else:
+                W[indx, nodes] = 1
+            #print(W)
+            node2predict = seed[test_index[0]]
+            nodes2predict_pos.append(node2predict)
+            nodes2predict_names.append(self.nodes[node2predict])
+         # recoger los valores correspondientes
+         # Calcular los score
+         if metric == "mean":
+            R = W @ self.matrix / (nrows - 1)
+         elif metric == "max":
+            R = np.zeros(sel.matrix.shape)
+            for row in range(0,self.matrix.shape[0]):
+                R[row] = (W[row,:] * sefl.matrix).max(0)
+         scores = R[range(0,nrows), nodes2predict_pos]
+         # Calcular los members_below
+         if self.seed_presence:
+           members_below = (R >= scores.reshape(nrows,1)).sum(1)
+           # Calcular los porcentage
+           rank_percentage = members_below/ncols
+         else:
+            R[W != 0] =  np.min(scores) -1
+            members_below = (R >= scores.reshape(nrows, 1)).sum(1)
+            rank_percentage = members_below/(ncols-nrows+1)
+         # Calcular los absolute rank
+         return list(zip(new_seed_names, nodes2predict_names, scores, rank_percentage, members_below))
+
+    ## Ranking by seed
+    def do_ranking(self, cross_validation=False, k_fold=None, propagate=False,  metric = "mean", options={"tolerance": 1e-9, "iteration_limit": 100, "with_restart": 0}):
+        self.get_seed_indexes()
+        self.translate2idx()
+
+        if cross_validation and k_fold is not None:
+            self.get_seed_cross_validation(k_fold=k_fold)
+
+        ranked_lists = []
+        for seed_name, seed in self.seeds.items():
+            # The code in this block CANNOT modify nothing outside
+            if cross_validation and k_fold is None:
+                self.attributes["header"] = ["candidates", "score", "normalized_rank", "rank"]
+                rank_list = self.get_loo_ranking(seed_name, seed, metric=metric)
+                print(rank_list)
+                for row in rank_list:
+                    ranked_lists.append([row[0], [list(row[1:])]])
+            else:
+                rank_list = self.rank_by_seed(seed, weights=self.weights.get(seed_name), propagate=propagate, metric = metric, options=options)  # Production mode
+                if cross_validation and k_fold is not None:
+                    rank_list = self.delete_seed_from_rank(rank_list, [self.nodes[pos] for pos in self.seeds[seed_name]])
+                ranked_lists.append([seed_name, rank_list])
+
+        for seed_name, rank_list in ranked_lists:  # Transfer resuls to hash
+            self.ranking[seed_name] = rank_list
+
+        self.translate2names()
+
+    def rank_by_seed(self, seed, weights=None, propagate=False, metric = "mean", options={"tolerance": 1e-9, "iteration_limit": 100, "with_restart": 0}):
+        ordered_gene_score = []
+        genes_pos = seed
+        number_of_all_nodes = len(self.nodes)
+        if self.seed_presence:
+            genes_of_interest = list(range(0,number_of_all_nodes))
+            nodes = self.nodes
+        else:
+            genes_of_interest = list(set(range(0,number_of_all_nodes))-set(genes_pos))
+            nodes = [self.nodes[idx] for idx in genes_of_interest]
+        if weights: weights = np.array([weights[s] for s in seed])
+        number_of_seed_genes = len(genes_pos)
+
+        if number_of_seed_genes > 0:
+            gen_list = self.update_seed(
+                genes_pos, genes_of_interest, weights=weights, propagate=propagate, metric = metric, options=options)
+            ordered_gene_score = pxc.get_rank_metrics(gen_list, ids=nodes)
+
+        return ordered_gene_score
+
+    def update_seed(self, genes_pos, genes_of_interest, weights=None, propagate=False, metric = "mean", options={"tolerance": 1e-9, "iteration_limit": 100, "with_restart": 0}):
+        number_of_seed_genes = len(genes_pos)
+        number_of_all_nodes = len(self.nodes)
+
+        if propagate:
+            # TODO: Weight extension on this area
+            # TODO: This option soe not accept remove the seeds.
+            seed_vector = np.zeros((number_of_all_nodes))
+            seed_vector[genes_pos] = 1
+            updated_seed = self.propagate_seed(
+                self.matrix, seed_attr=seed_vector, tol=options["tolerance"], n=options["iteration_limit"], restart_factor=options["with_restart"])
+            gen_list = updated_seed[genes_of_interest]
+        else:
+            subsets_gen_values = self.matrix[genes_pos,:][:,genes_of_interest]
+
+            if metric == "max":
+                gen_list = subsets_gen_values.max(0)
+            elif metric == "mean": 
+                if weights is not None:         
+                    integrated_gen_values = weights @ subsets_gen_values
+                    gen_list = (1/weights.sum()) * integrated_gen_values
+                else:
+                    integrated_gen_values = subsets_gen_values.sum(0)
+                    gen_list = (1/number_of_seed_genes) * integrated_gen_values
+        return gen_list
+
+    def propagate_seed(self, matrix, seed_attr, tol=1e-6, n=1000, restart_factor=0):
+        seed_attr_old = seed_attr
+        error = tol + 1  # Now error is more than tol
+        k = 0
+        while error > tol and k < n:
+            if restart_factor > 0:
+                seed_attr_new = (1 - restart_factor) * \
+                    matrix@seed_attr_old + restart_factor*seed_attr
+            else:
+                seed_attr_new = matrix @ seed_attr_old
+            # Normalization
+            seed_attr_new = seed_attr_new / seed_attr_new.sum(0)
+            # Take error
+            error = np.linalg.norm(seed_attr_new - seed_attr_old, ord=np.inf)
+            seed_attr_old = seed_attr_new
+            k += 1
+
+        if k >= n:  # TODO, let see the error.
+            print("Convergence not achieved")
+
+        return seed_attr_old
+
+    # Output and parsing ranking
+
+    def get_filtered_ranks_by_reference(self):
+        filtered_ranked_genes = {}
+
+        for seed_name, ranking in self.ranking.items():
+            if self.reference_nodes.get(seed_name) is None or not ranking:
+                continue
+
+            ranking = self.array2hash(ranking, 0, range(0, len(ranking[0])))
+            references = self.reference_nodes[seed_name]
+            filtered_ranked_genes[seed_name] = []
+
+            for reference in references:
+                rank = ranking.get(reference)
+                if rank is not None:
+                    filtered_ranked_genes[seed_name].append(rank)
+
+            filtered_ranked_genes[seed_name] = sorted(
+                filtered_ranked_genes[seed_name], key=lambda rank: -rank[1])
+
+        return filtered_ranked_genes
+
+    def write_ranking(self, output_name, add_header=True, top_n=None): 
+        if add_header:
+            header = self.attributes["header"]
+            header.append("seed_group")
+        if top_n is not None:
+            rankings = self.get_top(top_n)
+        else:
+            rankings = self.ranking
+        with open(output_name, 'w') as f:
+            if add_header: f.write('\t'.join(header)+"\n")
+            for seed_name, ranking in rankings.items():
+                for row in ranking:
+                    f.write('\t'.join(map(str,row)) + "\t" + f"{seed_name}" + "\n")  
+
+    def add_candidate_tag_types(self):
+        rankings = {}
+        for seed_name, rankings_by_seed in self.ranking.items():
+            added_ranking_column = []
+            for ranking in rankings_by_seed:
+                if ranking[0] in self.seeds[seed_name]:
+                    ranking.insert(5, "seed")
+                else:
+                    ranking.insert(5, "new")
+                added_ranking_column.append(ranking)
+            rankings[seed_name] = added_ranking_column
+        self.ranking = rankings
+        self.attributes["header"].insert(5,"type")
+
+    def get_top(self, top_n):
+        top_ranked_genes = {}
+        for seed_name, ranking in self.ranking.items():
+            if ranking is not None:
+                top_ranked_genes[seed_name] = ranking[0:top_n]
+        return top_ranked_genes
+
+    # Auxiliar methods
+    def array2hash(self, arr, key, values):  # 2exp?
+        h = {}
+        for els in arr:
+            h[els[0]] = [els[value] for value in values]
+        return h
+
+    def delete_seed_from_rank(self, rank_list, seed):
+        rank_list = [row for row in rank_list if row[0] not in seed]
+        return rank_list

NetAnalyzer/seed_parser.py

@@ -0,0 +1,27 @@
+import os
+    
+class SeedParser:
+
+    @staticmethod
+    def load_nodes_by_group(node_groups, sep= ','):
+        group_nodes = {}
+        weights_nodes = {}
+        if os.path.exists(node_groups):
+            group_nodes, weights_nodes = SeedParser.load_node_groups_from_file(node_groups, sep=sep)
+        else:
+            group_nodes = {"seed_genes": node_groups.split(sep)}
+        return group_nodes, weights_nodes
+
+    @staticmethod
+    def load_node_groups_from_file(file, sep=','):
+        group_nodes = {}
+        weights_nodes = {}
+        with open(file) as f:
+            for line in f:
+                fields = line.rstrip().split("\t")
+                set_name, nodes, *weights = fields
+                group_nodes[set_name] = nodes.split(sep)
+                if weights:
+                    weights = weights[0].split(sep)
+                    weights_nodes[set_name] = {group_nodes[set_name][i]: float(weight) for i, weight in enumerate(weights)} # TODO: check this section
+        return group_nodes, weights_nodes

NetAnalyzer/templates/net_explorer.txt

@@ -0,0 +1,83 @@
+<%
+    import pandas as pd
+    def plot_embdedding(data, plotter_list):
+        plotter_list["sns"].scatterplot(data=data[data['group_seed'] == 'background'], x='coord1', y='coord2', color='lightgrey', label='background', zorder=1)
+        plotter_list["sns"].scatterplot(data=df[df['group_seed'] != 'background'], x='coord1', y='coord2', hue='group_seed', palette='Set2', legend=True, zorder=2)
+    
+    node2seed = {}
+    for seed, nodes in plotter.hash_vars["seeds2explore"].items():
+        for node in nodes:
+            if not node2seed.get(node): node2seed[node] = seed
+%>
+
+## Seeds LCC.
+% if plotter.hash_vars.get("seeds2lcc"):
+${plotter.create_title("LCC by seed", id='net_study', hlevel=1, indexable=True, clickable=False)}
+<div style="overflow: hidden; display: flex; flex-direction: col; justify-content: center;">
+<%
+table_lcc = [["seed_name","net","lcc"]]
+for seed, net_lcc in plotter.hash_vars["seeds2lcc"].items():
+    for net, lcc in net_lcc.items():
+        table_lcc.append([seed, net, lcc])
+plotter.hash_vars["table_lcc"] = table_lcc
+%>
+${plotter.barplot(id='table_lcc', responsive= False, header=True,
+                         fields = [0,2],
+                         x_label = 'LCC size',
+                         height = '400px', width= '400px',
+                         var_attr = [0,1],
+                         config = {
+                                'showLegend' : True,
+                                'colorBy' : 'seed_name',
+                                'setMinX': 0,
+                                "titleFontStyle": "italic",
+                                "titleScaleFontFactor": 0.7,
+                                "smpLabelScaleFontFactor": 1,
+                                "axisTickScaleFontFactor": 0.7,
+                                "segregateSamplesBy": "net"
+                                })}
+</div>
+%endif
+## Seeds subgraphs.
+% if plotter.hash_vars.get("seeds2subgraph"):
+<% plotter.set_header() %>
+${plotter.create_title("Network study on every group of genes", id='net_study', hlevel=1, indexable=True, clickable=False)}
+% for seed, net2subgraph in plotter.hash_vars["seeds2subgraph"].items():
+${plotter.create_title(f"Group of genes: {seed}", id='net_study', hlevel=2, indexable=True, clickable=False)}
+% for net, subgraph in net2subgraph.items():
+${plotter.create_title(f"<b>{net}</b>", id='net_study', hlevel=3, indexable=True, clickable=False)}
+<% key = net+"_"+seed
+plotter.hash_vars[key] = {"graph": subgraph, "layers": ["layer", "layer"], "reference_nodes": plotter.hash_vars["seeds2explore"][seed], "group_nodes": []}  
+layout = "forcedir" if plotter.hash_vars["plot_method"] == "elgrapho" else None
+%>
+${plotter.network(id = key, method = plotter.hash_vars["plot_method"], layout=layout)} 
+%endfor
+%endfor
+%endif
+
+% if plotter.hash_vars["net2embedding_proj"]:
+${plotter.create_title("Network embedding and projection", id='net_emb', hlevel=1, indexable=True, clickable=False)}
+% for graph, embedding in plotter.hash_vars["net2embedding_proj"].items():
+${plotter.create_title(f"embedding in {graph}", id=f"net_emb_{graph}", hlevel=2, indexable=True, clickable=False)}
+<% 
+coords, nodes = embedding 
+df = pd.DataFrame(coords, columns= ["coord1","coord2"])
+df = df.assign(group_seed=[node2seed[node] if node2seed.get(node) else "background" for node in nodes]) 
+plotter.hash_vars["net_proj"] = df
+%>
+${plotter.static_plot_main(id="net_proj", raw= True, plotting_function= lambda data, plotter_list: plot_embdedding(data, plotter_list))} 
+% endfor
+% endif
+
+## Net sims
+% if plotter.hash_vars.get("net_sims"):
+${plotter.create_title("Network similarity edge", id='net_edge', hlevel=1, indexable=True, clickable=False)}
+<%
+sim_nets, network_ids = plotter.hash_vars["net_sims"]
+table_sims = [["",*network_ids]]
+for i, net_id in enumerate(network_ids):
+    table_sims.append([net_id,*sim_nets[i,:].tolist()])
+plotter.hash_vars["table_sims"] = table_sims
+%>
+${plotter.corplot(id = 'table_sims', header = True, row_names = True, correlationAxis = 'variables', config= {"correlationType":"circle"})}
+%endif

NetAnalyzer/templates/network.txt

@@ -0,0 +1 @@
+${plotter.network(id = 'net_data', **build_options) }

NetAnalyzer-1.0.0.dist-info/LICENSE.txt

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

NetAnalyzer-1.0.0.dist-info/METADATA

@@ -0,0 +1,86 @@
+Metadata-Version: 2.1
+Name: NetAnalyzer
+Version: 1.0.0
+Summary: Python package for network analysis, operations and priorization.
+Home-page: https://github.com/seoanezonjic/NetAnalyzer/
+Author: seoanezonjic
+Author-email: seoanezonjic@uma.es
+License: MIT
+Project-URL: Documentation, https://github.com/seoanezonjic/NetAnalyzer/
+Platform: any
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python
+Description-Content-Type: text/x-rst; charset=UTF-8
+License-File: LICENSE.txt
+Requires-Dist: NetworkX
+Requires-Dist: numpy
+Requires-Dist: scipy ==1.10.1
+Requires-Dist: statsmodels
+Requires-Dist: graphviz
+Requires-Dist: mako
+Requires-Dist: matplotlib
+Requires-Dist: cdlib
+Requires-Dist: scikit-learn
+Requires-Dist: py-semtools
+Requires-Dist: umap-learn
+Requires-Dist: py-report-html
+Requires-Dist: pecanpy
+Requires-Dist: typing-extensions
+Requires-Dist: py-cmdtabs
+Requires-Dist: py-exp-calc
+Requires-Dist: clusim
+Requires-Dist: importlib-metadata ; python_version < "3.8"
+Provides-Extra: testing
+Requires-Dist: setuptools ; extra == 'testing'
+Requires-Dist: pytest ; extra == 'testing'
+Requires-Dist: pytest-cov ; extra == 'testing'
+
+.. These are examples of badges you might want to add to your README:
+   please update the URLs accordingly
+
+    .. image:: https://api.cirrus-ci.com/github/<USER>/NetAnalyzer.svg?branch=main
+        :alt: Built Status
+        :target: https://cirrus-ci.com/github/<USER>/NetAnalyzer
+    .. image:: https://readthedocs.org/projects/NetAnalyzer/badge/?version=latest
+        :alt: ReadTheDocs
+        :target: https://NetAnalyzer.readthedocs.io/en/stable/
+    .. image:: https://img.shields.io/coveralls/github/<USER>/NetAnalyzer/main.svg
+        :alt: Coveralls
+        :target: https://coveralls.io/r/<USER>/NetAnalyzer
+    .. image:: https://img.shields.io/pypi/v/NetAnalyzer.svg
+        :alt: PyPI-Server
+        :target: https://pypi.org/project/NetAnalyzer/
+    .. image:: https://img.shields.io/conda/vn/conda-forge/NetAnalyzer.svg
+        :alt: Conda-Forge
+        :target: https://anaconda.org/conda-forge/NetAnalyzer
+    .. image:: https://pepy.tech/badge/NetAnalyzer/month
+        :alt: Monthly Downloads
+        :target: https://pepy.tech/project/NetAnalyzer
+    .. image:: https://img.shields.io/twitter/url/http/shields.io.svg?style=social&label=Twitter
+        :alt: Twitter
+        :target: https://twitter.com/NetAnalyzer
+
+.. image:: https://img.shields.io/badge/-PyScaffold-005CA0?logo=pyscaffold
+    :alt: Project generated with PyScaffold
+    :target: https://pyscaffold.org/
+
+|
+
+===========
+NetAnalyzer
+===========
+
+
+    Python library for network analysis, operations and priorization.
+
+This package is designed to perform various steps in network analysis and processing through a modular design. Key features include:
+
+* Randomization: Enables randomization of both clustered and individual nodes or edges within networks.
+* Projections: Simplifies network complexity by reducing the number of layers based on connections from an excluded layer. For example, it can transition from a Phenotype-Patient-Mutation network to a Patient-Mutation network, connecting layers based on common nodes between patients and mutations.
+* Topological Analysis: Computes various topological metrics for nodes (e.g., degree, betweenness) and provides summary statistics for entire networks.
+* Cluster analysis: Performs metrics on predefined clusters and applies clustering algorithms based on the cdlib library.
+* Embedding of networks (Kernels and node2vec): Defines node similarity using methods for processing context information in networks, including classical Kernel approaches and node2vec. It also supports integration of multiple layers.
+* Prioritization: Applies propagation algorithms to prioritize nodes based on similarity metrics, such as the adjacency matrix, and a set of seed nodes.
+* Net plotting: Provides several tools for graphing networks from different net plotter packages (igraph, cytoscape, graphviz).
+
+Please, cite this library as: Rojano E., Seoane-Zonjic P., Bueno-Amorós A., Perkins JR., and Ranea JAG. Revealing the Relationship Between Human Genome Regions and Pathological Phenotypes Through Network Analysis. Lecture Notes in Computer Science, DOI: 10.1007/978-3-319-56148-6_17.

NetAnalyzer-1.0.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+NetAnalyzer/__init__.py,sha256=aZmS9IxJg31hnW_0-y1FOfHDKw3GatdL1IcDVMpQtks,501
+NetAnalyzer/adv_mat_calc.py,sha256=e5qnSFf9C74ZPh8VIfEvnAO5M6YLRKSGWF-an_oTSKg,4074
+NetAnalyzer/cli_manager.py,sha256=S6VTHuO2i-kV9pKxhC2iUgWb_gpJU0183GOTgUxD05U,22250
+NetAnalyzer/graph2sim.py,sha256=_Ww_DgdMkjU8SDOm8ww3uv7i-h_2dc6ZwqsHObU2134,6545
+NetAnalyzer/integration.py,sha256=24we4WBVo7F63PTydwBvT938DIJk4I-vgX7-TekPQUM,6343
+NetAnalyzer/main_modules.py,sha256=jinn3F9UfvPHjQY4PEKC-vv7_haWpG9-4opqFL7cmWI,26244
+NetAnalyzer/net_parser.py,sha256=Lgn7nS_J1RHGO2imiQzYmo6hd5zOTTBOYwU2_Ev91cs,3026
+NetAnalyzer/net_plotter.py,sha256=fXoO6-3SQQbI_s_bOaHXFTJfGDLvg3ywAkieH7j_7Bo,8310
+NetAnalyzer/netanalyzer.py,sha256=b1scKyvhwQhay3waBrLO4VxP6N-CnfTXOZFL11yMrn4,63194
+NetAnalyzer/performancer.py,sha256=Mw3hDOrEGJBVoOfxIdv88YCxmg9UUMWWfYTAvmikNHA,2428
+NetAnalyzer/ranker.py,sha256=eOSVH6GK0JaK2dXmcDCMSkgT0-7NPMdRIi_IpJD3isw,14978
+NetAnalyzer/seed_parser.py,sha256=zFhapldMenhEYto0FIDlcsUYU0HZmm_hDuU5s8lLGuU,1056
+NetAnalyzer/templates/net_explorer.txt,sha256=RdJBoK4ebxkJ6VJEcjUJHNeUgXS30xvw3nHMwYNAEqY,4146
+NetAnalyzer/templates/network.txt,sha256=df1AaGbrWqmnN6MI-EGIpu_6LA82SdMiPXiFT3B5U1w,54
+NetAnalyzer-1.0.0.dist-info/LICENSE.txt,sha256=o731a6_5f5RM3QnOR0gHLL2teNGoww7dsclPuUtm1NA,1076
+NetAnalyzer-1.0.0.dist-info/METADATA,sha256=Q6K0DFfwDYT8jj9yHU-dhRHmrQU7IfuGtNB0quMuUuQ,4282
+NetAnalyzer-1.0.0.dist-info/WHEEL,sha256=Wyh-_nZ0DJYolHNn1_hMa4lM7uDedD_RGVwbmTjyItk,91
+NetAnalyzer-1.0.0.dist-info/entry_points.txt,sha256=UuP_GLgeGGdZEvljM0q9oqsCMUxFQS3fEabGfXfx9NI,416
+NetAnalyzer-1.0.0.dist-info/top_level.txt,sha256=M2clp1DIUgApO2xUDyAUt49q5D8W37Sf_Vz5d_peO2o,12
+NetAnalyzer-1.0.0.dist-info/RECORD,,