NetAnalyzer 1.0.0__tar.gz → 1.1.0__tar.gz

{netanalyzer-1.0.0 → netanalyzer-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: NetAnalyzer
-Version: 1.0.0
+Version: 1.1.0
 Summary: Python package for network analysis, operations and priorization.
 Home-page: https://github.com/seoanezonjic/NetAnalyzer/
 Author: seoanezonjic
@@ -15,7 +15,7 @@ License-File: LICENSE.txt
 Requires-Dist: importlib-metadata; python_version < "3.8"
 Requires-Dist: NetworkX
 Requires-Dist: numpy
-Requires-Dist: scipy==1.10.1
+Requires-Dist: scipy==1.13.1
 Requires-Dist: statsmodels
 Requires-Dist: graphviz
 Requires-Dist: mako
@@ -25,15 +25,19 @@ Requires-Dist: scikit-learn
 Requires-Dist: py_semtools
 Requires-Dist: umap-learn
 Requires-Dist: py_report_html
+Requires-Dist: gensim==4.3.3
 Requires-Dist: pecanpy
 Requires-Dist: typing_extensions
 Requires-Dist: py_cmdtabs
 Requires-Dist: py_exp_calc
 Requires-Dist: clusim
+Requires-Dist: nodevectors
+Requires-Dist: torch
 Provides-Extra: testing
 Requires-Dist: setuptools; extra == "testing"
 Requires-Dist: pytest; extra == "testing"
 Requires-Dist: pytest-cov; extra == "testing"
+Dynamic: license-file
 
 .. These are examples of badges you might want to add to your README:
    please update the URLs accordingly

{netanalyzer-1.0.0 → netanalyzer-1.1.0}/setup.cfg

@@ -25,7 +25,7 @@ install_requires =
 	importlib-metadata; python_version<"3.8"
 	NetworkX
 	numpy
-	scipy==1.10.1
+	scipy==1.13.1 #Version specified to be compatible with gensim (it allows a version lower than 1.14)
 	statsmodels
 	graphviz
 	mako
@@ -35,11 +35,14 @@ install_requires =
 	py_semtools
 	umap-learn
 	py_report_html
+	gensim==4.3.3 #Forcing to this version because it solves "triu" function importing error (it allows to be imported both from numpy and scipy)
 	pecanpy
 	typing_extensions
 	py_cmdtabs
 	py_exp_calc
 	clusim
+	nodevectors
+	torch
 
 [options.packages.find]
 where = src
@@ -55,7 +58,7 @@ testing =
 [options.entry_points]
 console_scripts = 
 	netanalyzer = NetAnalyzer.cli_manager:netanalyzer
-	integrate_kernels = NetAnalyzer.cli_manager:integrate_kernels
+	embedding_integrator = NetAnalyzer.cli_manager:embedding_integrator
 	randomize_clustering = NetAnalyzer.cli_manager:randomize_clustering
 	randomize_network = NetAnalyzer.cli_manager:randomize_network
 	ranker = NetAnalyzer.cli_manager:ranker

{netanalyzer-1.0.0 → netanalyzer-1.1.0}/src/NetAnalyzer/__init__.py

@@ -1,7 +1,7 @@
 from NetAnalyzer.netanalyzer import NetAnalyzer
 from NetAnalyzer.net_parser import Net_parser
 from NetAnalyzer.adv_mat_calc import Adv_mat_calc
-from NetAnalyzer.graph2sim import Graph2sim
+#from NetAnalyzer.graph2sim import Graph2sim
 from NetAnalyzer.net_plotter import Net_plotter
 from NetAnalyzer.ranker import Ranker
 from NetAnalyzer.performancer import Performancer

{netanalyzer-1.0.0 → netanalyzer-1.1.0}/src/NetAnalyzer/adv_mat_calc.py

@@ -2,17 +2,9 @@ import sys
 import numpy as np
 from scipy import linalg
 import scipy.stats as stats
-import umap
 from warnings import warn
 class Adv_mat_calc:
 
-	
-	@staticmethod
-	def data2umap(data, n_neighbors = 15, min_dist = 0.1, n_components = 2, metric = 'euclidean', random_seed = None): #2exp?
-	    reducer = umap.UMAP(n_neighbors=n_neighbors, min_dist=min_dist, n_components=n_components, metric=metric, random_state= random_seed)
-	    umap_coords = reducer.fit_transform(data)
-	    return umap_coords
-
 	# Alaimo 2014, doi: 10.3389/fbioe.2014.00071
 	@staticmethod
 	def tranference_resources(matrix1, matrix2, lambda_value1 = 0.5, lambda_value2 = 0.5): #2exp?

{netanalyzer-1.0.0 → netanalyzer-1.1.0}/src/NetAnalyzer/cli_manager.py

@@ -34,6 +34,33 @@ def group_nodes_parse(string):
 	
 	return group_nodes
 
+def reference_nodes_parse(string):
+    references_nodes = []
+    if os.path.isfile(string):
+        with open(string) as file:
+            for line in file:
+                node = line.strip()
+                references_nodes.append(node)
+    else:
+        references_nodes = single_split(string, sep=",")
+    return references_nodes
+
+
+def external_cluster_metadata(string):
+	metadata = loading_dic(string)
+	if metadata.get("sim"): 
+		parsed_sim = {} 
+		with open(metadata["sim"]) as file:
+			for line in file:
+				line = line.strip().split("\t")
+				parsed_sim[(line[0],line[1])] = float(line[2])
+				parsed_sim[(line[1],line[0])] =	float(line[2])
+		metadata["sim"] = parsed_sim
+	if metadata.get("metadata_classify"): 
+		metadata["metadata_classify"] = group_nodes_parse(metadata["metadata_classify"])
+	return metadata
+
+
 def graph_options_parse(string):
     graph_options = {}
     for pair in string.split(','):
@@ -72,7 +99,7 @@ def add_output_flags(parser, default_opt={"output_file": "output_file"}):
 def add_input_graph_flags(parser, multinet = False):
     if multinet:
         parser.add_argument("-i", "--input_file", dest="input_file", default= None, type = lambda string: loading_dic(string, sep1=";", sep2=","), 
-                    help="Input file to create networks for further analysis")
+                    help="Input file to create networks for further analysis, specify NULL if no network needed")
         parser.add_argument("-n","--node_names_file", dest="node_files", default=None, type = lambda string: loading_dic(string, sep1=";", sep2=","),
                     help="Files with node names corresponding to the input matrix, only use when -i is set to bin or matrix, could be two paths, indicating rows and cols, respectively. If just one path added, it is assumed to be for rows and cols")
         # parser.add_argument("-l","--layers", dest="layers", default=[['layer', '-']], type= lambda x: double_split(x, sep1=";",sep2=","),
@@ -91,6 +118,14 @@ def add_input_graph_flags(parser, multinet = False):
     parser.add_argument("--both_repre_formats", dest="load_both", default=False, action='store_true',
                         help="If we need to load the adjacency matrixes and the graph object")
 
+def add_cluster_flags(parser):
+    parser.add_argument("-G","--group_nodes", dest="group_nodes", default=None,
+    help="File path or groups separated by ';' and group node ids comma separared")
+    parser.add_argument("--group_node_column", dest="group_node_index", default= 1, type=based_0, 
+    help="Number of the nodes column")
+    parser.add_argument("--group_cluster_column", dest="group_cluster_index", default= 0, type=based_0, 
+    help="Number of the clusters column")
+
 def add_resources_flags(parser, default_opt={"threads": 1}):
     parser.add_argument("-T", "--threads", dest="threads", default=default_opt["threads"], type=int,
         help="Number of threads to use in computation.")
@@ -99,10 +134,16 @@ def add_resources_flags(parser, default_opt={"threads": 1}):
 def add_common_relations_process(parser):
     parser.add_argument("-N","--no_autorelations", dest="no_autorelations", default=False, action='store_true',
                         help="No processing autorelations")
+    
+def add_plotting_options(parser, default_opt={"graph_file": None}):
+    parser.add_argument("-g", "--graph_file", dest="graph_file", default=default_opt["graph_file"],
+        help="Build a graphic representation of the network")
+    parser.add_argument("--graph_options", dest="graph_options", default={'method': 'elgrapho', 'layout': 'forcedir', 'steps': '30'}, type= graph_options_parse,
+        help="Set graph parameters as 'NAME1=value1,NAME2=value2,...")
 
 ##############################################
 
-def integrate_kernels(args=None):
+def embedding_integrator(args=None):
     parser = argparse.ArgumentParser(description='Integrate kernels or embedding in matrix format')
     add_kernel_flags(parser, multiple = True)
     add_output_flags(parser, default_opt={"output_file": "general_matrix"})
@@ -120,7 +161,7 @@ def integrate_kernels(args=None):
     # Resources
     add_resources_flags(parser=parser, default_opt={"threads": 8})  
     opts = parser.parse_args(args)
-    main_integrate_kernels(opts)
+    main_embedding_integrator(opts)
 
 def netanalyzer(args=None):
     parser = argparse.ArgumentParser(description='Perform Network analysis from NetAnalyzer package')
@@ -128,8 +169,12 @@ def netanalyzer(args=None):
     add_input_graph_flags(parser)
     add_output_flags(parser, default_opt={"output_file": "output_file"})
     add_random_seed(parser, default_seed=None)
+    add_cluster_flags(parser)
     parser.add_argument("-O", "--ontology", dest="ontologies", default=[], type=lambda x: double_split(x, sep1=";",sep2=","),
                         help="String that define which ontologies must be used with each layer. String definition:'layer_name1,path_to_obo_file1;layer_name2,path_to_obo_file2'")
+    # Filters
+    parser.add_argument("--filter_connected_components", dest="filter_connected_components", default=None, type= lambda x: int(x),
+        help= "Specify the minimim size of the connected component to be taken into account")
     # Assoc
     parser.add_argument("-P","--use_pairs", dest="use_pairs", default='conn',
     help="Which pairs must be computed. 'all' means all posible pair node combinations and 'conn' means the pair are truly connected in the network. Default 'conn' ")
@@ -139,7 +184,7 @@ def netanalyzer(args=None):
     help="Output file name for association values")
     parser.add_argument("-p","--performance_file", dest="performance_file", default='perf_values.txt',
     help="Output file name for performance values")
-    parser.add_argument("-u","--use_layers", dest="use_layers", default=[], type= lambda x: double_split(x, sep1=";",sep2=","),
+    parser.add_argument("-u","--use_layers", dest="use_layers", default=[['layer']], type= lambda x: double_split(x, sep1=";",sep2=","),
     help="Set which layers must be used on association methods: layer1,layer2;layerA,layerB")
     parser.add_argument("-c","--control_file", dest="control_file", default=None,
     help="Control file name")
@@ -148,23 +193,33 @@ def netanalyzer(args=None):
     help="Kernel operation to perform with the adjacency matrix")
     parser.add_argument("--embedding_add_options", dest="embedding_add_options", default="",
     help="Additional options for embedding kernel methods. It must be defines as '\"opt_name1\" : value1, \"opt_name2\" : value2,...' ")
+    parser.add_argument("--cluster_embedding", dest="cluster_embedding", default="", help="Generate clustering from network embedding")
+    parser.add_argument("--cluster_embedding_add_options", dest="cluster_embedding_add_options", default="", help="Select specific parameters for the clustering")
     parser.add_argument("-z","--normalize_kernel_values", dest="normalize_kernel", default=False, action='store_true',
     help="Apply cosine normalization to the obtained kernel")
     parser.add_argument("--coords2sim_type", dest="coords2sim_type", default="dotProduct", help= "Select the type of transformation from coords to similarity: dotProduct, normalizedScaling, infinity and int or float numbers")
+    parser.add_argument("--embedding_coords", dest= "embedding_coords", default=False, action="store_true", help="Use this flag in case of obtaining the coordinates of the system")
     parser.add_argument("-K","--kernel_file", dest="kernel_file", default='kernel_file',
     help="Output file name for kernel values")
+    parser.add_argument("--external_embedding", dest="external_embedding", default=None, type = lambda x: single_split(x, sep=","),
+        help="Use this flag when an external embedding is needed for posterior analysis. Format: matrix_path,row_path,col_path. col_path just for kernel format")
     # Plotting
-    parser.add_argument("-g", "--graph_file", dest="graph_file", default=None,
-    help="Build a graphic representation of the network")
-    parser.add_argument("--graph_options", dest="graph_options", default={'method': 'elgrapho', 'layout': 'forcedir', 'steps': '30'}, type= graph_options_parse,
-    help="Set graph parameters as 'NAME1=value1,NAME2=value2,...")
+    add_plotting_options(parser)
     # Nodes states
-    parser.add_argument("-r","--reference_nodes", dest="reference_nodes", default=[], type= lambda x: single_split(x, sep=","),
-    help="Node ids comma separared")
-    parser.add_argument("-G","--group_nodes", dest="group_nodes", default={}, type= group_nodes_parse,
-    help="File path or groups separated by ';' and group node ids comma separared")
+    parser.add_argument("-r","--reference_nodes", dest="reference_nodes", default=[], type= lambda x: reference_nodes_parse(x),
+    help="Files to a column of nodes or node ids comma separared format in terminal")
+    parser.add_argument("--split_groups", dest="split_groups", default=False, action= "store_true",  
+        help="Split groups in subgroups based on clustering methods")
     parser.add_argument("-d","--delete", dest="delete_nodes", default=[], type= lambda x: single_split(x, sep=";"),
     help="Remove nodes from file. If PATH;r then nodes not included in file are removed")
+    # Extract subgraph
+    parser.add_argument("--extract_subgraphs", dest="extract_subgraphs", default=False, action="store_true",
+                        help="Add this flag in case you want to create subgraphs from different communities")
+    # parittion metric
+    parser.add_argument("--external_metadata_cluster", dest="external_metadata_cluster", default = None, type = lambda x: external_cluster_metadata(x),
+    	help="Adding external metadata cluster to evaluate with external metrics. You can add similarity between nodes 'sim' or node classification 'metadata_classify' in a two level format with ; and ,")
+    parser.add_argument("--partition_metrics", dest="partition_metrics", default=False, action='store_true',
+    	help="Select this option to obatin global partition metrics")
     # Compare cluster
     parser.add_argument("--overlapping_communities", dest ="overlapping_communities", default=False, action="store_true",
         help=" This is needed to activate overlapping sensitive operations in communities analysis")
@@ -177,7 +232,7 @@ def netanalyzer(args=None):
     help="Type of cluster algorithm")
     parser.add_argument("-B", "--build_clusters_add_options", dest="build_clusters_add_options", default="",
     help="Additional options for clustering methods. It must be defines as '\"opt_name1\" : value1, \"opt_name2\" : value2,...'")
-    parser.add_argument("--output_build_clusters", dest="output_build_clusters", default=None, help= "output name for discovered clusters")
+    parser.add_argument("--output_build_clusters", dest="output_build_clusters", default="discovered_clusters.txt", help= "output name for discovered clusters")
     # Expand cluster
     parser.add_argument("-x","--expand_clusters", dest="expand_clusters", default=None,
     help="Method to expand clusters Available methods: sht_path")
@@ -187,7 +242,7 @@ def netanalyzer(args=None):
     # Cluster metrics
     parser.add_argument("-M", "--group_metrics", dest="group_metrics", default=None, type= lambda x: single_split(x, sep=";"),
     help="Perform group group_metrics")
-    parser.add_argument("--output_metrics_by_cluster", dest="output_metrics_by_cluster", default='group_metrics.txt', help= "output name for metrics by cluster file")
+    parser.add_argument("--output_metrics_by_cluster", dest="output_metrics_by_cluster", default='group_metrics.txt', help= "output name for metrics by cluster file, by default: group_metrics.txt")
     parser.add_argument("-S", "--summarize_metrics", dest="summarize_metrics", default=None, type= lambda x: single_split(x, sep=";"),
     help="Summarize metrics from groups")
     parser.add_argument("--output_summarized_metrics", dest="output_summarized_metrics", default='group_metrics_summarized.txt', help= "output name for summarized metrics file")
@@ -200,27 +255,21 @@ def netanalyzer(args=None):
     # DSL section
     parser.add_argument("--dsl_script", dest="dsl_script", default=None,
     help="Path to dsl script to perform complex analysis")
+    # output network
+    parser.add_argument("--output_network", dest="output_network", default=None,
+        help="Output of the network modified during process")
     # Resources
     add_resources_flags(parser=parser, default_opt={"threads": 2})
 
     opts = parser.parse_args(args)
     main_netanalyzer(opts)
-	
+
 def randomize_clustering(args=None):
     parser = argparse.ArgumentParser(description='Perform clusters randomization')
     add_output_flags(parser, default_opt={"output_file": "random_clusters.txt"})
-    parser.add_argument("-i", "--input_file", dest="input_file", default= None, 
-    help="Input file to create networks for further analysis")
-    parser.add_argument("-S", "--split_char", dest="column_sep", default = "\t", 
-    help="Character for splitting input file. Default: tab")
+    add_cluster_flags(parser)
     parser.add_argument("-a", "--aggregate_sep", dest="aggregate_sep", default = None, 
     help="This option activates aggregation in output. Separator character must be provided")
-    parser.add_argument("-N", "--node_column", dest="node_index", default= 1, type=based_0, 
-    help="Number of the nodes column")
-    parser.add_argument("-C", "--cluster_column", dest="cluster_index", default= 0, type=based_0, 
-    help="Number of the clusters column")
-    parser.add_argument("-s", "--node_sep", dest="node_sep", default = None, 
-    help="Node split character. This option must to be used when input file is aggregated")
     # random conf
     parser.add_argument("-r", "--random_type", dest="random_type", default = ["hard_fixed"], type = lambda x: single_split(x,sep=":"), 
     help="""Indicate random mode. First, the not custom randomization, where cluster size is the same: 
@@ -278,7 +327,12 @@ def ranker(args=None):
     help="File to save Top N genes")
     parser.add_argument("--add_tags", dest="add_tags", default=None, help="Adding node attribute by seed: format seed\\tnode\\tattr")
     parser.add_argument("--representation_seed_metric", dest = "representation_seed_metric", default = "mean", 
-        help = "select the type of representation on seed, default mean, options: mean and max")
+        help = "select the type of representation on seed, default mean, options: mean, max, bayesian, stouffer, fisher")
+    parser.add_argument("--score2pvalue", dest="score2pvalue", default=None, help="""Passing score matrix to pvalue matrix to use as new scores
+        , the modes to pass to pvalues are: znormalization, quantile, logistic. When using logistic systems would train a logistic regression model.""",)
+    parser.add_argument("--training_dataset", dest="training_dataset", default=None, help="""Path to training 
+        dataset must be specified, where the format is: node1\\tnode2\\tP (Positive) or N (Negative)""")
+    parser.add_argument("--adj_matrix", dest="adj_matrix", default=None, help="""Path to the original adjacency matrix""")
     # Resources
     add_resources_flags(parser=parser, default_opt={"threads": 1})
     opts = parser.parse_args(args)
@@ -289,42 +343,60 @@ def text2binary_matrix(args=None):
     add_output_flags(parser, default_opt={"output_file": None})
     parser.add_argument('-i', '--input_file', dest="input_file", default=None,
     help="input file")
-    parser.add_argument('-b', '--byte_format', dest="byte_format", default="float64",
-    help='Format of the numeric values stored in matrix. Default: float64, warning set this to less precission can modify computation results using this matrix.')
+    parser.add_argument("-n","--node_names_file", dest="node_files", default=None, type = lambda x: single_split(x, sep=","),
+                        help="Files with node names corresponding to the input matrix, only use when -i is set to bin or matrix, could be two paths, indicating rows and cols, respectively. If just one path added, it is assumed to be for rows and cols")
     parser.add_argument('-t', '--input_type', dest="input_type", default='pair',
-    help='Set input format file. "pair", "matrix" or "bin"')
+            help='Set input format file. "pair", "matrix" or "bin"')
     parser.add_argument('-O', '--output_type', dest="output_type", default='bin',
-    help='Set output format file. "bin" for binary (default) or "mat" for tabulated text file matrix')
+            help='Set output format file. "bin" for binary (default) or "mat" for tabulated text file matrix')
     # Process matrix
     parser.add_argument('-d', '--set_diagonal', dest="set_diagonal", default=False, action='store_true',
-    help='Set to 1.0 the main diagonal')
+            help='Set to 1.0 the main diagonal')
     parser.add_argument('-B', '--binarize', dest="binarize", default=None, type = float,
-    help='Binarize matrix changin x >= thr to one and any other to zero into matrix given')
+            help='Binarize matrix changing x >= thr to one and any other to zero into matrix given')
     parser.add_argument('-c', '--cutoff', dest="cutoff", default=None, type = float,
-    help='Cutoff matrix values keeping just x >= and setting any other to zero into matrix given')
+            help='Cutoff matrix values keeping just x >= and setting any other to zero into matrix given')
     # Get stats
     parser.add_argument('-s', '--get_stats', dest="stats", default=None,
-    help='Get stats from the processed matrix')
-    
+            help='Get stats from the processed matrix')
+    parser.add_argument('--non_symmetric', dest="symmetric", default=True, action='store_false',
+            help='Set to use non symmetric matrix. By default is symmetric')    
+    parser.add_argument('--coords2kernel', dest="coords2kernel",help="passing coordinates to kernel",default=None)
+    parser.add_argument('--umap', dest='umap', help="projects coords in umap",default=False, action="store_true")
+    parser.add_argument('--sparse_type', dest="sparse_type", default=None, help="""The type of sparse matrix for the output, this option is useful when output type is 
+         set to bin. The options are: bsr, coo, csc, csr, dia, dok, lil""")
+    parser.add_argument("--round", dest="round", default=None, type=int, help="choose this to round in the i-th digit for all the values in the matrix or relations")
+    # normalize matrix
+    parser.add_argument("--normalize_by", dest="normalize_by", default=None, type=str, help="Type of normalization for matrix: cosine, rows_cols, min_max")
+    # order
+    parser.add_argument('--matrix_row_index', dest="rowids_index", default=None,
+            help='File with ROW names to use as index to build the matrix. Order is take into account')
+    parser.add_argument('--matrix_col_index', dest="colids_index", default=None,
+            help='File with COLUMN names to use as index to build the matrix. Order is take into account')
+    parser.add_argument('--init_matrix_type', dest="init_matrix_type", default="dense",
+            help='Select this to specify which is the matrix type during the intitialization of the matrix. Possible values: dense or an sparse type of scipy (bsr, coo, csc, csr, dia, dok, lil).')
+    parser.add_argument('--output_matrix_type', dest="output_matrix_type", default="dense",
+            help='Select this to specify which is the matrix type during the intitialization of the matrix. Possible values: dense or an sparse type of scipy (bsr, coo, csc, csr, dia, dok, lil).')
     opts = parser.parse_args(args)
     main_text2binary_matrix(opts)
 
 def net_explorer(args=None, test=False):
-    parser = argparse.ArgumentParser(description="Transforming matrix format and obtaining statistics")
+    parser = argparse.ArgumentParser(description="Exploring different networks attributes")
     add_common_relations_process(parser) # Common relations options
     add_input_graph_flags(parser, multinet = True) # Input graph
     add_seed_flags(parser) # Adding seeds
-    add_output_flags(parser, default_opt={"output_file": "output_file"})
+    add_cluster_flags(parser)
+    add_plotting_options(parser, default_opt={"graph_file": "output_file"})
+    add_resources_flags(parser)
+    add_random_seed(parser)
     # layer processing
     parser.add_argument('-c', '--layer_cutoff', dest="layer_cutoff", default={}, type = lambda string: loading_dic(string, sep1=";", sep2=","),
-    help='Cutoff to apply to every layer in the multiplexed one')
+        help='Cutoff to apply to every layer in the multiplexed one')
     # Analysis options
-    parser.add_argument("-l", "--neigh_level", dest="neigh_level", default={}, type = lambda string: loading_dic(string, sep1=";", sep2=","),
-    help="Defining the level of neighbourhood on the initial set of nodes")
-    parser.add_argument("--plot_network_method", dest="plot_network_method", default="pyvis",
-    help="Defining the plot method used on report")
+    parser.add_argument("--neigh_level", dest="neigh_level", default={}, type = lambda string: loading_dic(string, sep1=";", sep2=","),
+        help="Defining the level of neighbourhood on the initial set of nodes")
     parser.add_argument("--embedding_proj", dest="embedding_proj", default=None,
-    help="Select different projections methods: umap")
+        help="Select different projections methods: umap")
     parser.add_argument("--compare_nets", dest="compare_nets", default=False, action="store_true")
     opts = parser.parse_args(args)
     to_test = main_net_explorer(opts, test)