Datasets:

google

/

code_x_glue_tc_nl_code_search_adv

like 6

[ "def", "load_parcellation_coords", "(", "parcellation_name", ")", ":", "path", "=", "tenetopath", "[", "0", "]", "+", "'/data/parcellation/'", "+", "parcellation_name", "+", "'.csv'", "parc", "=", "np", ".", "loadtxt", "(", "path", ",", "skiprows", "=", "1", ",", "delimiter", "=", "','", ",", "usecols", "=", "[", "1", ",", "2", ",", "3", "]", ")", "return", "parc" ]

[ "Loads", "coordinates", "of", "included", "parcellations", "." ]

[ "def", "create_traj_ranges", "(", "start", ",", "stop", ",", "N", ")", ":", "steps", "=", "(", "1.0", "/", "(", "N", "-", "1", ")", ")", "*", "(", "stop", "-", "start", ")", "if", "np", ".", "isscalar", "(", "steps", ")", ":", "return", "steps", "*", "np", ".", "arange", "(", "N", ")", "+", "start", "else", ":", "return", "steps", "[", ":", ",", "None", "]", "*", "np", ".", "arange", "(", "N", ")", "+", "start", "[", ":", ",", "None", "]" ]

[ "Fills", "in", "the", "trajectory", "range", "." ]

[ "def", "get_dimord", "(", "measure", ",", "calc", "=", "None", ",", "community", "=", "None", ")", ":", "if", "not", "calc", ":", "calc", "=", "''", "else", ":", "calc", "=", "'_'", "+", "calc", "if", "not", "community", ":", "community", "=", "''", "else", ":", "community", "=", "'community'", "if", "'community'", "in", "calc", "and", "'community'", "in", "community", ":", "community", "=", "''", "if", "calc", "==", "'community_avg'", "or", "calc", "==", "'community_pairs'", ":", "community", "=", "''", "dimord_dict", "=", "{", "'temporal_closeness_centrality'", ":", "'node'", ",", "'temporal_degree_centrality'", ":", "'node'", ",", "'temporal_degree_centralit_avg'", ":", "'node'", ",", "'temporal_degree_centrality_time'", ":", "'node,time'", ",", "'temporal_efficiency'", ":", "'global'", ",", "'temporal_efficiency_global'", ":", "'global'", ",", "'temporal_efficiency_node'", ":", "'node'", ",", "'temporal_efficiency_to'", ":", "'node'", ",", "'sid_global'", ":", "'global,time'", ",", "'community_pairs'", ":", "'community,community,time'", ",", "'community_avg'", ":", "'community,time'", ",", "'sid'", ":", "'community,community,time'", ",", "'reachability_latency_global'", ":", "'global'", ",", "'reachability_latency'", ":", "'global'", ",", "'reachability_latency_node'", ":", "'node'", ",", "'fluctuability'", ":", "'node'", ",", "'fluctuability_global'", ":", "'global'", ",", "'bursty_coeff'", ":", "'edge,edge'", ",", "'bursty_coeff_edge'", ":", "'edge,edge'", ",", "'bursty_coeff_node'", ":", "'node'", ",", "'bursty_coeff_meanEdgePerNode'", ":", "'node'", ",", "'volatility_global'", ":", "'time'", ",", "}", "if", "measure", "+", "calc", "+", "community", "in", "dimord_dict", ":", "return", "dimord_dict", "[", "measure", "+", "calc", "+", "community", "]", "else", ":", "print", "(", "'WARNINGL: get_dimord() returned unknown dimension labels'", ")", "return", "'unknown'" ]

[ "Get", "the", "dimension", "order", "of", "a", "network", "measure", "." ]

[ "def", "create_supraadjacency_matrix", "(", "tnet", ",", "intersliceweight", "=", "1", ")", ":", "newnetwork", "=", "tnet", ".", "network", ".", "copy", "(", ")", "newnetwork", "[", "'i'", "]", "=", "(", "tnet", ".", "network", "[", "'i'", "]", ")", "+", "(", "(", "tnet", ".", "netshape", "[", "0", "]", ")", "*", "(", "tnet", ".", "network", "[", "'t'", "]", ")", ")", "newnetwork", "[", "'j'", "]", "=", "(", "tnet", ".", "network", "[", "'j'", "]", ")", "+", "(", "(", "tnet", ".", "netshape", "[", "0", "]", ")", "*", "(", "tnet", ".", "network", "[", "'t'", "]", ")", ")", "if", "'weight'", "not", "in", "newnetwork", ".", "columns", ":", "newnetwork", "[", "'weight'", "]", "=", "1", "newnetwork", ".", "drop", "(", "'t'", ",", "axis", "=", "1", ",", "inplace", "=", "True", ")", "timepointconns", "=", "pd", ".", "DataFrame", "(", ")", "timepointconns", "[", "'i'", "]", "=", "np", ".", "arange", "(", "0", ",", "(", "tnet", ".", "N", "*", "tnet", ".", "T", ")", "-", "tnet", ".", "N", ")", "timepointconns", "[", "'j'", "]", "=", "np", ".", "arange", "(", "tnet", ".", "N", ",", "(", "tnet", ".", "N", "*", "tnet", ".", "T", ")", ")", "timepointconns", "[", "'weight'", "]", "=", "intersliceweight", "supranet", "=", "pd", ".", "concat", "(", "[", "newnetwork", ",", "timepointconns", "]", ")", ".", "reset_index", "(", "drop", "=", "True", ")", "return", "supranet" ]

[ "Returns", "a", "supraadjacency", "matrix", "from", "a", "temporal", "network", "structure" ]

[ "def", "tnet_to_nx", "(", "df", ",", "t", "=", "None", ")", ":", "if", "t", "is", "not", "None", ":", "df", "=", "get_network_when", "(", "df", ",", "t", "=", "t", ")", "if", "'weight'", "in", "df", ".", "columns", ":", "nxobj", "=", "nx", ".", "from_pandas_edgelist", "(", "df", ",", "source", "=", "'i'", ",", "target", "=", "'j'", ",", "edge_attr", "=", "'weight'", ")", "else", ":", "nxobj", "=", "nx", ".", "from_pandas_edgelist", "(", "df", ",", "source", "=", "'i'", ",", "target", "=", "'j'", ")", "return", "nxobj" ]

[ "Creates", "undirected", "networkx", "object" ]

[ "def", "temporal_louvain", "(", "tnet", ",", "resolution", "=", "1", ",", "intersliceweight", "=", "1", ",", "n_iter", "=", "100", ",", "negativeedge", "=", "'ignore'", ",", "randomseed", "=", "None", ",", "consensus_threshold", "=", "0.5", ",", "temporal_consensus", "=", "True", ",", "njobs", "=", "1", ")", ":", "tnet", "=", "process_input", "(", "tnet", ",", "[", "'C'", ",", "'G'", ",", "'TN'", "]", ",", "'TN'", ")", "# Divide resolution by the number of timepoints", "resolution", "=", "resolution", "/", "tnet", ".", "T", "supranet", "=", "create_supraadjacency_matrix", "(", "tnet", ",", "intersliceweight", "=", "intersliceweight", ")", "if", "negativeedge", "==", "'ignore'", ":", "supranet", "=", "supranet", "[", "supranet", "[", "'weight'", "]", ">", "0", "]", "nxsupra", "=", "tnet_to_nx", "(", "supranet", ")", "np", ".", "random", ".", "seed", "(", "randomseed", ")", "while", "True", ":", "comtmp", "=", "[", "]", "with", "ProcessPoolExecutor", "(", "max_workers", "=", "njobs", ")", "as", "executor", ":", "job", "=", "{", "executor", ".", "submit", "(", "_run_louvain", ",", "nxsupra", ",", "resolution", ",", "tnet", ".", "N", ",", "tnet", ".", "T", ")", "for", "n", "in", "range", "(", "n_iter", ")", "}", "for", "j", "in", "as_completed", "(", "job", ")", ":", "comtmp", ".", "append", "(", "j", ".", "result", "(", ")", ")", "comtmp", "=", "np", ".", "stack", "(", "comtmp", ")", "comtmp", "=", "comtmp", ".", "transpose", "(", ")", "comtmp", "=", "np", ".", "reshape", "(", "comtmp", ",", "[", "tnet", ".", "N", ",", "tnet", ".", "T", ",", "n_iter", "]", ",", "order", "=", "'F'", ")", "if", "n_iter", "==", "1", ":", "break", "nxsupra_old", "=", "nxsupra", "nxsupra", "=", "make_consensus_matrix", "(", "comtmp", ",", "consensus_threshold", ")", "# If there was no consensus, there are no communities possible, return", "if", "nxsupra", "is", "None", ":", "break", "if", "(", "nx", ".", "to_numpy_array", "(", "nxsupra", ",", "nodelist", "=", "np", ".", "arange", "(", "tnet", ".", "N", "*", "tnet", ".", "T", ")", ")", "==", "nx", ".", "to_numpy_array", "(", "nxsupra_old", ",", "nodelist", "=", "np", ".", "arange", "(", "tnet", ".", "N", "*", "tnet", ".", "T", ")", ")", ")", ".", "all", "(", ")", ":", "break", "communities", "=", "comtmp", "[", ":", ",", ":", ",", "0", "]", "if", "temporal_consensus", "==", "True", ":", "communities", "=", "make_temporal_consensus", "(", "communities", ")", "return", "communities" ]

[ "r", "Louvain", "clustering", "for", "a", "temporal", "network", "." ]

[ "def", "make_temporal_consensus", "(", "com_membership", ")", ":", "com_membership", "=", "np", ".", "array", "(", "com_membership", ")", "# make first indicies be between 0 and 1.", "com_membership", "[", ":", ",", "0", "]", "=", "clean_community_indexes", "(", "com_membership", "[", ":", ",", "0", "]", ")", "# loop over all timepoints, get jacccard distance in greedy manner for largest community to time period before", "for", "t", "in", "range", "(", "1", ",", "com_membership", ".", "shape", "[", "1", "]", ")", ":", "ct", ",", "counts_t", "=", "np", ".", "unique", "(", "com_membership", "[", ":", ",", "t", "]", ",", "return_counts", "=", "True", ")", "ct", "=", "ct", "[", "np", ".", "argsort", "(", "counts_t", ")", "[", ":", ":", "-", "1", "]", "]", "c1back", "=", "np", ".", "unique", "(", "com_membership", "[", ":", ",", "t", "-", "1", "]", ")", "new_index", "=", "np", ".", "zeros", "(", "com_membership", ".", "shape", "[", "0", "]", ")", "for", "n", "in", "ct", ":", "if", "len", "(", "c1back", ")", ">", "0", ":", "d", "=", "np", ".", "ones", "(", "int", "(", "c1back", ".", "max", "(", ")", ")", "+", "1", ")", "for", "m", "in", "c1back", ":", "v1", "=", "np", ".", "zeros", "(", "com_membership", ".", "shape", "[", "0", "]", ")", "v2", "=", "np", ".", "zeros", "(", "com_membership", ".", "shape", "[", "0", "]", ")", "v1", "[", "com_membership", "[", ":", ",", "t", "]", "==", "n", "]", "=", "1", "v2", "[", "com_membership", "[", ":", ",", "t", "-", "1", "]", "==", "m", "]", "=", "1", "d", "[", "int", "(", "m", ")", "]", "=", "jaccard", "(", "v1", ",", "v2", ")", "bestval", "=", "np", ".", "argmin", "(", "d", ")", "else", ":", "bestval", "=", "new_index", ".", "max", "(", ")", "+", "1", "new_index", "[", "com_membership", "[", ":", ",", "t", "]", "==", "n", "]", "=", "bestval", "c1back", "=", "np", ".", "array", "(", "np", ".", "delete", "(", "c1back", ",", "np", ".", "where", "(", "c1back", "==", "bestval", ")", ")", ")", "com_membership", "[", ":", ",", "t", "]", "=", "new_index", "return", "com_membership" ]

[ "r", "Matches", "community", "labels", "accross", "time", "-", "points" ]

[ "def", "flexibility", "(", "communities", ")", ":", "# Preallocate", "flex", "=", "np", ".", "zeros", "(", "communities", ".", "shape", "[", "0", "]", ")", "# Go from the second time point to last, compare with time-point before", "for", "t", "in", "range", "(", "1", ",", "communities", ".", "shape", "[", "1", "]", ")", ":", "flex", "[", "communities", "[", ":", ",", "t", "]", "!=", "communities", "[", ":", ",", "t", "-", "1", "]", "]", "+=", "1", "# Normalize", "flex", "=", "flex", "/", "(", "communities", ".", "shape", "[", "1", "]", "-", "1", ")", "return", "flex" ]

[ "Amount", "a", "node", "changes", "community" ]

[ "def", "load_tabular_file", "(", "fname", ",", "return_meta", "=", "False", ",", "header", "=", "True", ",", "index_col", "=", "True", ")", ":", "if", "index_col", ":", "index_col", "=", "0", "else", ":", "index_col", "=", "None", "if", "header", ":", "header", "=", "0", "else", ":", "header", "=", "None", "df", "=", "pd", ".", "read_csv", "(", "fname", ",", "header", "=", "header", ",", "index_col", "=", "index_col", ",", "sep", "=", "'\\t'", ")", "if", "return_meta", ":", "json_fname", "=", "fname", ".", "replace", "(", "'tsv'", ",", "'json'", ")", "meta", "=", "pd", ".", "read_json", "(", "json_fname", ")", "return", "df", ",", "meta", "else", ":", "return", "df" ]

[ "Given", "a", "file", "name", "loads", "as", "a", "pandas", "data", "frame" ]

[ "def", "get_sidecar", "(", "fname", ",", "allowedfileformats", "=", "'default'", ")", ":", "if", "allowedfileformats", "==", "'default'", ":", "allowedfileformats", "=", "[", "'.tsv'", ",", "'.nii.gz'", "]", "for", "f", "in", "allowedfileformats", ":", "fname", "=", "fname", ".", "split", "(", "f", ")", "[", "0", "]", "fname", "+=", "'.json'", "if", "os", ".", "path", ".", "exists", "(", "fname", ")", ":", "with", "open", "(", "fname", ")", "as", "fs", ":", "sidecar", "=", "json", ".", "load", "(", "fs", ")", "else", ":", "sidecar", "=", "{", "}", "if", "'filestatus'", "not", "in", "sidecar", ":", "sidecar", "[", "'filestatus'", "]", "=", "{", "}", "sidecar", "[", "'filestatus'", "]", "[", "'reject'", "]", "=", "False", "sidecar", "[", "'filestatus'", "]", "[", "'reason'", "]", "=", "[", "]", "return", "sidecar" ]

[ "Loads", "sidecar", "or", "creates", "one" ]

[ "def", "process_exclusion_criteria", "(", "exclusion_criteria", ")", ":", "relfun", "=", "[", "]", "threshold", "=", "[", "]", "for", "ec", "in", "exclusion_criteria", ":", "if", "ec", "[", "0", ":", "2", "]", "==", "'>='", ":", "relfun", ".", "append", "(", "np", ".", "greater_equal", ")", "threshold", ".", "append", "(", "float", "(", "ec", "[", "2", ":", "]", ")", ")", "elif", "ec", "[", "0", ":", "2", "]", "==", "'<='", ":", "relfun", ".", "append", "(", "np", ".", "less_equal", ")", "threshold", ".", "append", "(", "float", "(", "ec", "[", "2", ":", "]", ")", ")", "elif", "ec", "[", "0", "]", "==", "'>'", ":", "relfun", ".", "append", "(", "np", ".", "greater", ")", "threshold", ".", "append", "(", "float", "(", "ec", "[", "1", ":", "]", ")", ")", "elif", "ec", "[", "0", "]", "==", "'<'", ":", "relfun", ".", "append", "(", "np", ".", "less", ")", "threshold", ".", "append", "(", "float", "(", "ec", "[", "1", ":", "]", ")", ")", "else", ":", "raise", "ValueError", "(", "'exclusion crieria must being with >,<,>= or <='", ")", "return", "relfun", ",", "threshold" ]

[ "Parses", "an", "exclusion", "critera", "string", "to", "get", "the", "function", "and", "threshold", "." ]

[ "def", "reachability_latency", "(", "tnet", "=", "None", ",", "paths", "=", "None", ",", "rratio", "=", "1", ",", "calc", "=", "'global'", ")", ":", "if", "tnet", "is", "not", "None", "and", "paths", "is", "not", "None", ":", "raise", "ValueError", "(", "'Only network or path input allowed.'", ")", "if", "tnet", "is", "None", "and", "paths", "is", "None", ":", "raise", "ValueError", "(", "'No input.'", ")", "# if shortest paths are not calculated, calculate them", "if", "tnet", "is", "not", "None", ":", "paths", "=", "shortest_temporal_path", "(", "tnet", ")", "pathmat", "=", "np", ".", "zeros", "(", "[", "paths", "[", "[", "'from'", ",", "'to'", "]", "]", ".", "max", "(", ")", ".", "max", "(", ")", "+", "1", ",", "paths", "[", "[", "'from'", ",", "'to'", "]", "]", ".", "max", "(", ")", ".", "max", "(", ")", "+", "1", ",", "paths", "[", "[", "'t_start'", "]", "]", ".", "max", "(", ")", ".", "max", "(", ")", "+", "1", "]", ")", "*", "np", ".", "nan", "pathmat", "[", "paths", "[", "'from'", "]", ".", "values", ",", "paths", "[", "'to'", "]", ".", "values", ",", "paths", "[", "'t_start'", "]", ".", "values", "]", "=", "paths", "[", "'temporal-distance'", "]", "netshape", "=", "pathmat", ".", "shape", "edges_to_reach", "=", "netshape", "[", "0", "]", "-", "np", ".", "round", "(", "netshape", "[", "0", "]", "*", "rratio", ")", "reach_lat", "=", "np", ".", "zeros", "(", "[", "netshape", "[", "1", "]", ",", "netshape", "[", "2", "]", "]", ")", "*", "np", ".", "nan", "for", "t_ind", "in", "range", "(", "0", ",", "netshape", "[", "2", "]", ")", ":", "paths_sort", "=", "-", "np", ".", "sort", "(", "-", "pathmat", "[", ":", ",", ":", ",", "t_ind", "]", ",", "axis", "=", "1", ")", "reach_lat", "[", ":", ",", "t_ind", "]", "=", "paths_sort", "[", ":", ",", "edges_to_reach", "]", "if", "calc", "==", "'global'", ":", "reach_lat", "=", "np", ".", "nansum", "(", "reach_lat", ")", "reach_lat", "=", "reach_lat", "/", "(", "(", "netshape", "[", "0", "]", ")", "*", "netshape", "[", "2", "]", ")", "elif", "calc", "==", "'nodes'", ":", "reach_lat", "=", "np", ".", "nansum", "(", "reach_lat", ",", "axis", "=", "1", ")", "reach_lat", "=", "reach_lat", "/", "(", "netshape", "[", "2", "]", ")", "return", "reach_lat" ]

[ "Reachability", "latency", ".", "This", "is", "the", "r", "-", "th", "longest", "temporal", "path", "." ]

[ "def", "recruitment", "(", "temporalcommunities", ",", "staticcommunities", ")", ":", "# make sure the static and temporal communities have the same number of nodes", "if", "staticcommunities", ".", "shape", "[", "0", "]", "!=", "temporalcommunities", ".", "shape", "[", "0", "]", ":", "raise", "ValueError", "(", "'Temporal and static communities have different dimensions'", ")", "alleg", "=", "allegiance", "(", "temporalcommunities", ")", "Rcoeff", "=", "np", ".", "zeros", "(", "len", "(", "staticcommunities", ")", ")", "for", "i", ",", "statcom", "in", "enumerate", "(", "staticcommunities", ")", ":", "Rcoeff", "[", "i", "]", "=", "np", ".", "mean", "(", "alleg", "[", "i", ",", "staticcommunities", "==", "statcom", "]", ")", "return", "Rcoeff" ]

[ "Calculates", "recruitment", "coefficient", "for", "each", "node", ".", "Recruitment", "coefficient", "is", "the", "average", "probability", "of", "nodes", "from", "the", "same", "static", "communities", "being", "in", "the", "same", "temporal", "communities", "at", "other", "time", "-", "points", "or", "during", "different", "tasks", "." ]

[ "def", "integration", "(", "temporalcommunities", ",", "staticcommunities", ")", ":", "# make sure the static and temporal communities have the same number of nodes", "if", "staticcommunities", ".", "shape", "[", "0", "]", "!=", "temporalcommunities", ".", "shape", "[", "0", "]", ":", "raise", "ValueError", "(", "'Temporal and static communities have different dimensions'", ")", "alleg", "=", "allegiance", "(", "temporalcommunities", ")", "Icoeff", "=", "np", ".", "zeros", "(", "len", "(", "staticcommunities", ")", ")", "# calc integration for each node", "for", "i", ",", "statcom", "in", "enumerate", "(", "len", "(", "staticcommunities", ")", ")", ":", "Icoeff", "[", "i", "]", "=", "np", ".", "mean", "(", "alleg", "[", "i", ",", "staticcommunities", "!=", "statcom", "]", ")", "return", "Icoeff" ]

[ "Calculates", "the", "integration", "coefficient", "for", "each", "node", ".", "Measures", "the", "average", "probability", "that", "a", "node", "is", "in", "the", "same", "community", "as", "nodes", "from", "other", "systems", "." ]

[ "def", "intercontacttimes", "(", "tnet", ")", ":", "# Process input", "tnet", "=", "process_input", "(", "tnet", ",", "[", "'C'", ",", "'G'", ",", "'TN'", "]", ",", "'TN'", ")", "if", "tnet", ".", "nettype", "[", "0", "]", "==", "'w'", ":", "print", "(", "'WARNING: assuming connections to be binary when computing intercontacttimes'", ")", "# Each time series is padded with a 0 at the start and end. Then t[0:-1]-[t:].", "# Then discard the noninformative ones (done automatically)", "# Finally return back as np array", "contacts", "=", "np", ".", "array", "(", "[", "[", "None", "]", "*", "tnet", ".", "netshape", "[", "0", "]", "]", "*", "tnet", ".", "netshape", "[", "0", "]", ")", "if", "tnet", ".", "nettype", "[", "1", "]", "==", "'u'", ":", "for", "i", "in", "range", "(", "0", ",", "tnet", ".", "netshape", "[", "0", "]", ")", ":", "for", "j", "in", "range", "(", "i", "+", "1", ",", "tnet", ".", "netshape", "[", "0", "]", ")", ":", "edge_on", "=", "tnet", ".", "get_network_when", "(", "i", "=", "i", ",", "j", "=", "j", ")", "[", "'t'", "]", ".", "values", "if", "len", "(", "edge_on", ")", ">", "0", ":", "edge_on_diff", "=", "edge_on", "[", "1", ":", "]", "-", "edge_on", "[", ":", "-", "1", "]", "contacts", "[", "i", ",", "j", "]", "=", "np", ".", "array", "(", "edge_on_diff", ")", "contacts", "[", "j", ",", "i", "]", "=", "np", ".", "array", "(", "edge_on_diff", ")", "else", ":", "contacts", "[", "i", ",", "j", "]", "=", "[", "]", "contacts", "[", "j", ",", "i", "]", "=", "[", "]", "elif", "tnet", ".", "nettype", "[", "1", "]", "==", "'d'", ":", "for", "i", "in", "range", "(", "0", ",", "tnet", ".", "netshape", "[", "0", "]", ")", ":", "for", "j", "in", "range", "(", "0", ",", "tnet", ".", "netshape", "[", "0", "]", ")", ":", "edge_on", "=", "tnet", ".", "get_network_when", "(", "i", "=", "i", ",", "j", "=", "j", ")", "[", "'t'", "]", ".", "values", "if", "len", "(", "edge_on", ")", ">", "0", ":", "edge_on_diff", "=", "edge_on", "[", "1", ":", "]", "-", "edge_on", "[", ":", "-", "1", "]", "contacts", "[", "i", ",", "j", "]", "=", "np", ".", "array", "(", "edge_on_diff", ")", "else", ":", "contacts", "[", "i", ",", "j", "]", "=", "[", "]", "out", "=", "{", "}", "out", "[", "'intercontacttimes'", "]", "=", "contacts", "out", "[", "'nettype'", "]", "=", "tnet", ".", "nettype", "return", "out" ]

[ "Calculates", "the", "intercontacttimes", "of", "each", "edge", "in", "a", "network", "." ]

[ "def", "gen_report", "(", "report", ",", "sdir", "=", "'./'", ",", "report_name", "=", "'report.html'", ")", ":", "# Create report directory", "if", "not", "os", ".", "path", ".", "exists", "(", "sdir", ")", ":", "os", ".", "makedirs", "(", "sdir", ")", "# Add a slash to file directory if not included to avoid DirNameFleName", "# instead of DirName/FileName being creaated", "if", "sdir", "[", "-", "1", "]", "!=", "'/'", ":", "sdir", "+=", "'/'", "report_html", "=", "'<html><body>'", "if", "'method'", "in", "report", ".", "keys", "(", ")", ":", "report_html", "+=", "\"<h1>Method: \"", "+", "report", "[", "'method'", "]", "+", "\"</h1><p>\"", "for", "i", "in", "report", "[", "report", "[", "'method'", "]", "]", ":", "if", "i", "==", "'taper_window'", ":", "fig", ",", "ax", "=", "plt", ".", "subplots", "(", "1", ")", "ax", ".", "plot", "(", "report", "[", "report", "[", "'method'", "]", "]", "[", "'taper_window'", "]", ",", "report", "[", "report", "[", "'method'", "]", "]", "[", "'taper'", "]", ")", "ax", ".", "set_xlabel", "(", "'Window (time). 0 in middle of window.'", ")", "ax", ".", "set_title", "(", "'Taper from '", "+", "report", "[", "report", "[", "'method'", "]", "]", "[", "'distribution'", "]", "+", "' distribution (PDF).'", ")", "fig", ".", "savefig", "(", "sdir", "+", "'taper.png'", ")", "report_html", "+=", "\"<img src='./taper.png' width=500>\"", "+", "\"<p>\"", "else", ":", "report_html", "+=", "\"- <b>\"", "+", "i", "+", "\"</b>: \"", "+", "str", "(", "report", "[", "report", "[", "'method'", "]", "]", "[", "i", "]", ")", "+", "\"<br>\"", "if", "'postprocess'", "in", "report", ".", "keys", "(", ")", ":", "report_html", "+=", "\"<p><h2>Postprocessing:</h2><p>\"", "report_html", "+=", "\"<b>Pipeline: </b>\"", "for", "i", "in", "report", "[", "'postprocess'", "]", ":", "report_html", "+=", "\" \"", "+", "i", "+", "\",\"", "for", "i", "in", "report", "[", "'postprocess'", "]", ":", "report_html", "+=", "\"<p><h3>\"", "+", "i", "+", "\"</h3><p>\"", "for", "j", "in", "report", "[", "i", "]", ":", "if", "j", "==", "'lambda'", ":", "report_html", "+=", "\"- <b>\"", "+", "j", "+", "\"</b>: \"", "+", "\"<br>\"", "lambda_val", "=", "np", ".", "array", "(", "report", "[", "'boxcox'", "]", "[", "'lambda'", "]", ")", "fig", ",", "ax", "=", "plt", ".", "subplots", "(", "1", ")", "ax", ".", "hist", "(", "lambda_val", "[", ":", ",", "-", "1", "]", ")", "ax", ".", "set_xlabel", "(", "'lambda'", ")", "ax", ".", "set_ylabel", "(", "'frequency'", ")", "ax", ".", "set_title", "(", "'Histogram of lambda parameter'", ")", "fig", ".", "savefig", "(", "sdir", "+", "'boxcox_lambda.png'", ")", "report_html", "+=", "\"<img src='./boxcox_lambda.png' width=500>\"", "+", "\"<p>\"", "report_html", "+=", "\"Data located in \"", "+", "sdir", "+", "\"boxcox_lambda.csv <p>\"", "np", ".", "savetxt", "(", "sdir", "+", "\"boxcox_lambda.csv\"", ",", "lambda_val", ",", "delimiter", "=", "\",\"", ")", "else", ":", "report_html", "+=", "\"- <b>\"", "+", "j", "+", "\"</b>: \"", "+", "str", "(", "report", "[", "i", "]", "[", "j", "]", ")", "+", "\"<br>\"", "report_html", "+=", "'</body></html>'", "with", "open", "(", "sdir", "+", "report_name", ",", "'w'", ")", "as", "file", ":", "file", ".", "write", "(", "report_html", ")", "file", ".", "close", "(", ")" ]

[ "Generates", "report", "of", "derivation", "and", "postprocess", "steps", "in", "teneto", ".", "derive" ]

[ "def", "add_history", "(", "self", ",", "fname", ",", "fargs", ",", "init", "=", "0", ")", ":", "if", "init", "==", "1", ":", "self", ".", "history", "=", "[", "]", "self", ".", "history", ".", "append", "(", "[", "fname", ",", "fargs", "]", ")" ]

[ "Adds", "a", "processing", "step", "to", "TenetoBIDS", ".", "history", "." ]

[ "def", "derive_temporalnetwork", "(", "self", ",", "params", ",", "update_pipeline", "=", "True", ",", "tag", "=", "None", ",", "njobs", "=", "1", ",", "confound_corr_report", "=", "True", ")", ":", "if", "not", "njobs", ":", "njobs", "=", "self", ".", "njobs", "self", ".", "add_history", "(", "inspect", ".", "stack", "(", ")", "[", "0", "]", "[", "3", "]", ",", "locals", "(", ")", ",", "1", ")", "files", "=", "self", ".", "get_selected_files", "(", "quiet", "=", "1", ")", "confound_files", "=", "self", ".", "get_selected_files", "(", "quiet", "=", "1", ",", "pipeline", "=", "'confound'", ")", "if", "confound_files", ":", "confounds_exist", "=", "True", "else", ":", "confounds_exist", "=", "False", "if", "not", "confound_corr_report", ":", "confounds_exist", "=", "False", "if", "not", "tag", ":", "tag", "=", "''", "else", ":", "tag", "=", "'desc-'", "+", "tag", "with", "ProcessPoolExecutor", "(", "max_workers", "=", "njobs", ")", "as", "executor", ":", "job", "=", "{", "executor", ".", "submit", "(", "self", ".", "_derive_temporalnetwork", ",", "f", ",", "i", ",", "tag", ",", "params", ",", "confounds_exist", ",", "confound_files", ")", "for", "i", ",", "f", "in", "enumerate", "(", "files", ")", "if", "f", "}", "for", "j", "in", "as_completed", "(", "job", ")", ":", "j", ".", "result", "(", ")", "if", "update_pipeline", "==", "True", ":", "if", "not", "self", ".", "confound_pipeline", "and", "len", "(", "self", ".", "get_selected_files", "(", "quiet", "=", "1", ",", "pipeline", "=", "'confound'", ")", ")", ">", "0", ":", "self", ".", "set_confound_pipeline", "=", "self", ".", "pipeline", "self", ".", "set_pipeline", "(", "'teneto_'", "+", "teneto", ".", "__version__", ")", "self", ".", "set_pipeline_subdir", "(", "'tvc'", ")", "self", ".", "set_bids_suffix", "(", "'tvcconn'", ")" ]

[ "Derive", "time", "-", "varying", "connectivity", "on", "the", "selected", "files", "." ]

[ "def", "make_functional_connectivity", "(", "self", ",", "njobs", "=", "None", ",", "returngroup", "=", "False", ",", "file_hdr", "=", "None", ",", "file_idx", "=", "None", ")", ":", "if", "not", "njobs", ":", "njobs", "=", "self", ".", "njobs", "self", ".", "add_history", "(", "inspect", ".", "stack", "(", ")", "[", "0", "]", "[", "3", "]", ",", "locals", "(", ")", ",", "1", ")", "files", "=", "self", ".", "get_selected_files", "(", "quiet", "=", "1", ")", "R_group", "=", "[", "]", "with", "ProcessPoolExecutor", "(", "max_workers", "=", "njobs", ")", "as", "executor", ":", "job", "=", "{", "executor", ".", "submit", "(", "self", ".", "_run_make_functional_connectivity", ",", "f", ",", "file_hdr", ",", "file_idx", ")", "for", "f", "in", "files", "}", "for", "j", "in", "as_completed", "(", "job", ")", ":", "R_group", ".", "append", "(", "j", ".", "result", "(", ")", ")", "if", "returngroup", ":", "# Fisher tranform -> mean -> inverse fisher tranform", "R_group", "=", "np", ".", "tanh", "(", "np", ".", "mean", "(", "np", ".", "arctanh", "(", "np", ".", "array", "(", "R_group", ")", ")", ",", "axis", "=", "0", ")", ")", "return", "np", ".", "array", "(", "R_group", ")" ]

[ "Makes", "connectivity", "matrix", "for", "each", "of", "the", "subjects", "." ]

[ "def", "_save_namepaths_bids_derivatives", "(", "self", ",", "f", ",", "tag", ",", "save_directory", ",", "suffix", "=", "None", ")", ":", "file_name", "=", "f", ".", "split", "(", "'/'", ")", "[", "-", "1", "]", ".", "split", "(", "'.'", ")", "[", "0", "]", "if", "tag", "!=", "''", ":", "tag", "=", "'_'", "+", "tag", "if", "suffix", ":", "file_name", ",", "_", "=", "drop_bids_suffix", "(", "file_name", ")", "save_name", "=", "file_name", "+", "tag", "save_name", "+=", "'_'", "+", "suffix", "else", ":", "save_name", "=", "file_name", "+", "tag", "paths_post_pipeline", "=", "f", ".", "split", "(", "self", ".", "pipeline", ")", "if", "self", ".", "pipeline_subdir", ":", "paths_post_pipeline", "=", "paths_post_pipeline", "[", "1", "]", ".", "split", "(", "self", ".", "pipeline_subdir", ")", "[", "0", "]", "else", ":", "paths_post_pipeline", "=", "paths_post_pipeline", "[", "1", "]", ".", "split", "(", "file_name", ")", "[", "0", "]", "base_dir", "=", "self", ".", "BIDS_dir", "+", "'/derivatives/'", "+", "'teneto_'", "+", "teneto", ".", "__version__", "+", "'/'", "+", "paths_post_pipeline", "+", "'/'", "save_dir", "=", "base_dir", "+", "'/'", "+", "save_directory", "+", "'/'", "if", "not", "os", ".", "path", ".", "exists", "(", "save_dir", ")", ":", "# A case has happened where this has been done in parallel and an error was raised. So do try/except", "try", ":", "os", ".", "makedirs", "(", "save_dir", ")", "except", ":", "# Wait 2 seconds so that the error does not try and save something in the directory before it is created", "time", ".", "sleep", "(", "2", ")", "if", "not", "os", ".", "path", ".", "exists", "(", "self", ".", "BIDS_dir", "+", "'/derivatives/'", "+", "'teneto_'", "+", "teneto", ".", "__version__", "+", "'/dataset_description.json'", ")", ":", "try", ":", "with", "open", "(", "self", ".", "BIDS_dir", "+", "'/derivatives/'", "+", "'teneto_'", "+", "teneto", ".", "__version__", "+", "'/dataset_description.json'", ",", "'w'", ")", "as", "fs", ":", "json", ".", "dump", "(", "self", ".", "tenetoinfo", ",", "fs", ")", "except", ":", "# Same as above, just in case parallel does duplicaiton", "time", ".", "sleep", "(", "2", ")", "return", "save_name", ",", "save_dir", ",", "base_dir" ]

[ "Creates", "output", "directory", "and", "output", "name" ]

[ "def", "get_tags", "(", "self", ",", "tag", ",", "quiet", "=", "1", ")", ":", "if", "not", "self", ".", "pipeline", ":", "print", "(", "'Please set pipeline first.'", ")", "self", ".", "get_pipeline_alternatives", "(", "quiet", ")", "else", ":", "if", "tag", "==", "'sub'", ":", "datapath", "=", "self", ".", "BIDS_dir", "+", "'/derivatives/'", "+", "self", ".", "pipeline", "+", "'/'", "tag_alternatives", "=", "[", "f", ".", "split", "(", "'sub-'", ")", "[", "1", "]", "for", "f", "in", "os", ".", "listdir", "(", "datapath", ")", "if", "os", ".", "path", ".", "isdir", "(", "datapath", "+", "f", ")", "and", "'sub-'", "in", "f", "]", "elif", "tag", "==", "'ses'", ":", "tag_alternatives", "=", "[", "]", "for", "sub", "in", "self", ".", "bids_tags", "[", "'sub'", "]", ":", "tag_alternatives", "+=", "[", "f", ".", "split", "(", "'ses-'", ")", "[", "1", "]", "for", "f", "in", "os", ".", "listdir", "(", "self", ".", "BIDS_dir", "+", "'/derivatives/'", "+", "self", ".", "pipeline", "+", "'/'", "+", "'sub-'", "+", "sub", ")", "if", "'ses'", "in", "f", "]", "tag_alternatives", "=", "set", "(", "tag_alternatives", ")", "else", ":", "files", "=", "self", ".", "get_selected_files", "(", "quiet", "=", "1", ")", "tag_alternatives", "=", "[", "]", "for", "f", "in", "files", ":", "f", "=", "f", ".", "split", "(", "'.'", ")", "[", "0", "]", "f", "=", "f", ".", "split", "(", "'/'", ")", "[", "-", "1", "]", "tag_alternatives", "+=", "[", "t", ".", "split", "(", "'-'", ")", "[", "1", "]", "for", "t", "in", "f", ".", "split", "(", "'_'", ")", "if", "t", ".", "split", "(", "'-'", ")", "[", "0", "]", "==", "tag", "]", "tag_alternatives", "=", "set", "(", "tag_alternatives", ")", "if", "quiet", "==", "0", ":", "print", "(", "tag", "+", "' alternatives: '", "+", "', '", ".", "join", "(", "tag_alternatives", ")", ")", "return", "list", "(", "tag_alternatives", ")" ]

[ "Returns", "which", "tag", "alternatives", "can", "be", "identified", "in", "the", "BIDS", "derivatives", "structure", "." ]

[ "def", "set_exclusion_file", "(", "self", ",", "confound", ",", "exclusion_criteria", ",", "confound_stat", "=", "'mean'", ")", ":", "self", ".", "add_history", "(", "inspect", ".", "stack", "(", ")", "[", "0", "]", "[", "3", "]", ",", "locals", "(", ")", ",", "1", ")", "if", "isinstance", "(", "confound", ",", "str", ")", ":", "confound", "=", "[", "confound", "]", "if", "isinstance", "(", "exclusion_criteria", ",", "str", ")", ":", "exclusion_criteria", "=", "[", "exclusion_criteria", "]", "if", "isinstance", "(", "confound_stat", ",", "str", ")", ":", "confound_stat", "=", "[", "confound_stat", "]", "if", "len", "(", "exclusion_criteria", ")", "!=", "len", "(", "confound", ")", ":", "raise", "ValueError", "(", "'Same number of confound names and exclusion criteria must be given'", ")", "if", "len", "(", "confound_stat", ")", "!=", "len", "(", "confound", ")", ":", "raise", "ValueError", "(", "'Same number of confound names and confound stats must be given'", ")", "relex", ",", "crit", "=", "process_exclusion_criteria", "(", "exclusion_criteria", ")", "files", "=", "sorted", "(", "self", ".", "get_selected_files", "(", "quiet", "=", "1", ")", ")", "confound_files", "=", "sorted", "(", "self", ".", "get_selected_files", "(", "quiet", "=", "1", ",", "pipeline", "=", "'confound'", ")", ")", "files", ",", "confound_files", "=", "confound_matching", "(", "files", ",", "confound_files", ")", "bad_files", "=", "[", "]", "bs", "=", "0", "foundconfound", "=", "[", "]", "foundreason", "=", "[", "]", "for", "s", ",", "cfile", "in", "enumerate", "(", "confound_files", ")", ":", "df", "=", "load_tabular_file", "(", "cfile", ",", "index_col", "=", "None", ")", "found_bad_subject", "=", "False", "for", "i", ",", "_", "in", "enumerate", "(", "confound", ")", ":", "if", "confound_stat", "[", "i", "]", "==", "'median'", ":", "if", "relex", "[", "i", "]", "(", "df", "[", "confound", "[", "i", "]", "]", ".", "median", "(", ")", ",", "crit", "[", "i", "]", ")", ":", "found_bad_subject", "=", "True", "elif", "confound_stat", "[", "i", "]", "==", "'mean'", ":", "if", "relex", "[", "i", "]", "(", "df", "[", "confound", "[", "i", "]", "]", ".", "mean", "(", ")", ",", "crit", "[", "i", "]", ")", ":", "found_bad_subject", "=", "True", "elif", "confound_stat", "[", "i", "]", "==", "'std'", ":", "if", "relex", "[", "i", "]", "(", "df", "[", "i", "]", "[", "confound", "[", "i", "]", "]", ".", "std", "(", ")", ",", "crit", "[", "i", "]", ")", ":", "found_bad_subject", "=", "True", "if", "found_bad_subject", ":", "foundconfound", ".", "append", "(", "confound", "[", "i", "]", ")", "foundreason", ".", "append", "(", "exclusion_criteria", "[", "i", "]", ")", "if", "found_bad_subject", ":", "bad_files", ".", "append", "(", "files", "[", "s", "]", ")", "bs", "+=", "1", "self", ".", "set_bad_files", "(", "bad_files", ",", "reason", "=", "'excluded file (confound over specfied stat threshold)'", ")", "for", "i", ",", "f", "in", "enumerate", "(", "bad_files", ")", ":", "sidecar", "=", "get_sidecar", "(", "f", ")", "sidecar", "[", "'file_exclusion'", "]", "=", "{", "}", "sidecar", "[", "'confound'", "]", "=", "foundconfound", "[", "i", "]", "sidecar", "[", "'threshold'", "]", "=", "foundreason", "[", "i", "]", "for", "af", "in", "[", "'.tsv'", ",", "'.nii.gz'", "]", ":", "f", "=", "f", ".", "split", "(", "af", ")", "[", "0", "]", "f", "+=", "'.json'", "with", "open", "(", "f", ",", "'w'", ")", "as", "fs", ":", "json", ".", "dump", "(", "sidecar", ",", "fs", ")", "print", "(", "'Removed '", "+", "str", "(", "bs", ")", "+", "' files from inclusion.'", ")" ]

[ "Excludes", "subjects", "given", "a", "certain", "exclusion", "criteria", "." ]

[ "def", "make_parcellation", "(", "self", ",", "parcellation", ",", "parc_type", "=", "None", ",", "parc_params", "=", "None", ",", "network", "=", "'defaults'", ",", "update_pipeline", "=", "True", ",", "removeconfounds", "=", "False", ",", "tag", "=", "None", ",", "njobs", "=", "None", ",", "clean_params", "=", "None", ",", "yeonetworkn", "=", "None", ")", ":", "if", "not", "njobs", ":", "njobs", "=", "self", ".", "njobs", "self", ".", "add_history", "(", "inspect", ".", "stack", "(", ")", "[", "0", "]", "[", "3", "]", ",", "locals", "(", ")", ",", "1", ")", "parc_name", "=", "parcellation", ".", "split", "(", "'_'", ")", "[", "0", "]", ".", "lower", "(", ")", "# Check confounds have been specified", "if", "not", "self", ".", "confounds", "and", "removeconfounds", ":", "raise", "ValueError", "(", "'Specified confounds are not found. Make sure that you have run self.set_confunds([\\'Confound1\\',\\'Confound2\\']) first.'", ")", "# Check confounds have been specified", "if", "update_pipeline", "==", "False", "and", "removeconfounds", ":", "raise", "ValueError", "(", "'Pipeline must be updated in order to remove confounds within this funciton.'", ")", "# In theory these should be the same. So at the moment, it goes through each element and checks they are matched.", "# A matching algorithem may be needed if cases arise where this isnt the case", "files", "=", "self", ".", "get_selected_files", "(", "quiet", "=", "1", ")", "# Load network communities, if possible.", "self", ".", "set_network_communities", "(", "parcellation", ",", "netn", "=", "yeonetworkn", ")", "if", "not", "tag", ":", "tag", "=", "''", "else", ":", "tag", "=", "'desc-'", "+", "tag", "if", "not", "parc_params", ":", "parc_params", "=", "{", "}", "with", "ProcessPoolExecutor", "(", "max_workers", "=", "njobs", ")", "as", "executor", ":", "job", "=", "{", "executor", ".", "submit", "(", "self", ".", "_run_make_parcellation", ",", "f", ",", "i", ",", "tag", ",", "parcellation", ",", "parc_name", ",", "parc_type", ",", "parc_params", ")", "for", "i", ",", "f", "in", "enumerate", "(", "files", ")", "}", "for", "j", "in", "as_completed", "(", "job", ")", ":", "j", ".", "result", "(", ")", "if", "update_pipeline", "==", "True", ":", "if", "not", "self", ".", "confound_pipeline", "and", "len", "(", "self", ".", "get_selected_files", "(", "quiet", "=", "1", ",", "pipeline", "=", "'confound'", ")", ")", ">", "0", ":", "self", ".", "set_confound_pipeline", "(", "self", ".", "pipeline", ")", "self", ".", "set_pipeline", "(", "'teneto_'", "+", "teneto", ".", "__version__", ")", "self", ".", "set_pipeline_subdir", "(", "'parcellation'", ")", "if", "tag", ":", "self", ".", "set_bids_tags", "(", "{", "'desc'", ":", "tag", ".", "split", "(", "'-'", ")", "[", "1", "]", "}", ")", "self", ".", "set_bids_suffix", "(", "'roi'", ")", "if", "removeconfounds", ":", "self", ".", "removeconfounds", "(", "clean_params", "=", "clean_params", ",", "transpose", "=", "None", ",", "njobs", "=", "njobs", ")" ]

[ "Reduces", "the", "data", "from", "voxel", "to", "parcellation", "space", ".", "Files", "get", "saved", "in", "a", "teneto", "folder", "in", "the", "derivatives", "with", "a", "roi", "tag", "at", "the", "end", "." ]

[ "def", "communitydetection", "(", "self", ",", "community_detection_params", ",", "community_type", "=", "'temporal'", ",", "tag", "=", "None", ",", "file_hdr", "=", "False", ",", "file_idx", "=", "False", ",", "njobs", "=", "None", ")", ":", "if", "not", "njobs", ":", "njobs", "=", "self", ".", "njobs", "self", ".", "add_history", "(", "inspect", ".", "stack", "(", ")", "[", "0", "]", "[", "3", "]", ",", "locals", "(", ")", ",", "1", ")", "if", "not", "tag", ":", "tag", "=", "''", "else", ":", "tag", "=", "'desc-'", "+", "tag", "if", "community_type", "==", "'temporal'", ":", "files", "=", "self", ".", "get_selected_files", "(", "quiet", "=", "True", ")", "# Run check to make sure files are tvc input", "for", "f", "in", "files", ":", "if", "'tvc'", "not", "in", "f", ":", "raise", "ValueError", "(", "'tvc tag not found in filename. TVC data must be used in communitydetection (perhaps run TenetoBIDS.derive first?).'", ")", "elif", "community_type", "==", "'static'", ":", "files", "=", "self", ".", "get_selected_files", "(", "quiet", "=", "True", ",", "pipeline", "=", "'functionalconnectivity'", ")", "with", "ProcessPoolExecutor", "(", "max_workers", "=", "njobs", ")", "as", "executor", ":", "job", "=", "{", "executor", ".", "submit", "(", "self", ".", "_run_communitydetection", ",", "f", ",", "community_detection_params", ",", "community_type", ",", "file_hdr", ",", "file_idx", ",", "tag", ")", "for", "i", ",", "f", "in", "enumerate", "(", "files", ")", "if", "all", "(", "[", "t", "+", "'_'", "in", "f", "or", "t", "+", "'.'", "in", "f", "for", "t", "in", "tag", "]", ")", "}", "for", "j", "in", "as_completed", "(", "job", ")", ":", "j", ".", "result", "(", ")" ]

[ "Calls", "temporal_louvain_with_consensus", "on", "connectivity", "data" ]

[ "def", "removeconfounds", "(", "self", ",", "confounds", "=", "None", ",", "clean_params", "=", "None", ",", "transpose", "=", "None", ",", "njobs", "=", "None", ",", "update_pipeline", "=", "True", ",", "overwrite", "=", "True", ",", "tag", "=", "None", ")", ":", "if", "not", "njobs", ":", "njobs", "=", "self", ".", "njobs", "self", ".", "add_history", "(", "inspect", ".", "stack", "(", ")", "[", "0", "]", "[", "3", "]", ",", "locals", "(", ")", ",", "1", ")", "if", "not", "self", ".", "confounds", "and", "not", "confounds", ":", "raise", "ValueError", "(", "'Specified confounds are not found. Make sure that you have run self.set_confunds([\\'Confound1\\',\\'Confound2\\']) first or pass confounds as input to function.'", ")", "if", "not", "tag", ":", "tag", "=", "''", "else", ":", "tag", "=", "'desc-'", "+", "tag", "if", "confounds", ":", "self", ".", "set_confounds", "(", "confounds", ")", "files", "=", "sorted", "(", "self", ".", "get_selected_files", "(", "quiet", "=", "1", ")", ")", "confound_files", "=", "sorted", "(", "self", ".", "get_selected_files", "(", "quiet", "=", "1", ",", "pipeline", "=", "'confound'", ")", ")", "files", ",", "confound_files", "=", "confound_matching", "(", "files", ",", "confound_files", ")", "if", "not", "clean_params", ":", "clean_params", "=", "{", "}", "with", "ProcessPoolExecutor", "(", "max_workers", "=", "njobs", ")", "as", "executor", ":", "job", "=", "{", "executor", ".", "submit", "(", "self", ".", "_run_removeconfounds", ",", "f", ",", "confound_files", "[", "i", "]", ",", "clean_params", ",", "transpose", ",", "overwrite", ",", "tag", ")", "for", "i", ",", "f", "in", "enumerate", "(", "files", ")", "}", "for", "j", "in", "as_completed", "(", "job", ")", ":", "j", ".", "result", "(", ")", "self", ".", "set_pipeline", "(", "'teneto_'", "+", "teneto", ".", "__version__", ")", "self", ".", "set_bids_suffix", "(", "'roi'", ")", "if", "tag", ":", "self", ".", "set_bids_tags", "(", "{", "'desc'", ":", "tag", ".", "split", "(", "'-'", ")", "[", "1", "]", "}", ")" ]

[ "Removes", "specified", "confounds", "using", "nilearn", ".", "signal", ".", "clean" ]

[ "def", "networkmeasures", "(", "self", ",", "measure", "=", "None", ",", "measure_params", "=", "None", ",", "tag", "=", "None", ",", "njobs", "=", "None", ")", ":", "if", "not", "njobs", ":", "njobs", "=", "self", ".", "njobs", "self", ".", "add_history", "(", "inspect", ".", "stack", "(", ")", "[", "0", "]", "[", "3", "]", ",", "locals", "(", ")", ",", "1", ")", "# measure can be string or list", "if", "isinstance", "(", "measure", ",", "str", ")", ":", "measure", "=", "[", "measure", "]", "# measure_params can be dictionaary or list of dictionaries", "if", "isinstance", "(", "measure_params", ",", "dict", ")", ":", "measure_params", "=", "[", "measure_params", "]", "if", "measure_params", "and", "len", "(", "measure", ")", "!=", "len", "(", "measure_params", ")", ":", "raise", "ValueError", "(", "'Number of identified measure_params ('", "+", "str", "(", "len", "(", "measure_params", ")", ")", "+", "') differs from number of identified measures ('", "+", "str", "(", "len", "(", "measure", ")", ")", "+", "'). Leave black dictionary if default methods are wanted'", ")", "files", "=", "self", ".", "get_selected_files", "(", "quiet", "=", "1", ")", "if", "not", "tag", ":", "tag", "=", "''", "else", ":", "tag", "=", "'desc-'", "+", "tag", "with", "ProcessPoolExecutor", "(", "max_workers", "=", "njobs", ")", "as", "executor", ":", "job", "=", "{", "executor", ".", "submit", "(", "self", ".", "_run_networkmeasures", ",", "f", ",", "tag", ",", "measure", ",", "measure_params", ")", "for", "f", "in", "files", "}", "for", "j", "in", "as_completed", "(", "job", ")", ":", "j", ".", "result", "(", ")" ]

[ "Calculates", "a", "network", "measure" ]

[ "def", "set_bids_suffix", "(", "self", ",", "bids_suffix", ")", ":", "self", ".", "add_history", "(", "inspect", ".", "stack", "(", ")", "[", "0", "]", "[", "3", "]", ",", "locals", "(", ")", ",", "1", ")", "self", ".", "bids_suffix", "=", "bids_suffix" ]

[ "The", "last", "analysis", "step", "is", "the", "final", "tag", "that", "is", "present", "in", "files", "." ]

[ "def", "set_pipeline", "(", "self", ",", "pipeline", ")", ":", "self", ".", "add_history", "(", "inspect", ".", "stack", "(", ")", "[", "0", "]", "[", "3", "]", ",", "locals", "(", ")", ",", "1", ")", "if", "not", "os", ".", "path", ".", "exists", "(", "self", ".", "BIDS_dir", "+", "'/derivatives/'", "+", "pipeline", ")", ":", "print", "(", "'Specified direvative directory not found.'", ")", "self", ".", "get_pipeline_alternatives", "(", ")", "else", ":", "# Todo: perform check that pipeline is valid", "self", ".", "pipeline", "=", "pipeline" ]

[ "Specify", "the", "pipeline", ".", "See", "get_pipeline_alternatives", "to", "see", "what", "are", "avaialble", ".", "Input", "should", "be", "a", "string", "." ]

[ "def", "load_frompickle", "(", "cls", ",", "fname", ",", "reload_object", "=", "False", ")", ":", "if", "fname", "[", "-", "4", ":", "]", "!=", "'.pkl'", ":", "fname", "+=", "'.pkl'", "with", "open", "(", "fname", ",", "'rb'", ")", "as", "f", ":", "tnet", "=", "pickle", ".", "load", "(", "f", ")", "if", "reload_object", ":", "reloadnet", "=", "teneto", ".", "TenetoBIDS", "(", "tnet", ".", "BIDS_dir", ",", "pipeline", "=", "tnet", ".", "pipeline", ",", "pipeline_subdir", "=", "tnet", ".", "pipeline_subdir", ",", "bids_tags", "=", "tnet", ".", "bids_tags", ",", "bids_suffix", "=", "tnet", ".", "bids_suffix", ",", "bad_subjects", "=", "tnet", ".", "bad_subjects", ",", "confound_pipeline", "=", "tnet", ".", "confound_pipeline", ",", "raw_data_exists", "=", "tnet", ".", "raw_data_exists", ",", "njobs", "=", "tnet", ".", "njobs", ")", "reloadnet", ".", "histroy", "=", "tnet", ".", "history", "tnet", "=", "reloadnet", "return", "tnet" ]

[ "Loaded", "saved", "instance", "of" ]

[ "def", "temporal_closeness_centrality", "(", "tnet", "=", "None", ",", "paths", "=", "None", ")", ":", "if", "tnet", "is", "not", "None", "and", "paths", "is", "not", "None", ":", "raise", "ValueError", "(", "'Only network or path input allowed.'", ")", "if", "tnet", "is", "None", "and", "paths", "is", "None", ":", "raise", "ValueError", "(", "'No input.'", ")", "# if shortest paths are not calculated, calculate them", "if", "tnet", "is", "not", "None", ":", "paths", "=", "shortest_temporal_path", "(", "tnet", ")", "pathmat", "=", "np", ".", "zeros", "(", "[", "paths", "[", "[", "'from'", ",", "'to'", "]", "]", ".", "max", "(", ")", ".", "max", "(", ")", "+", "1", ",", "paths", "[", "[", "'from'", ",", "'to'", "]", "]", ".", "max", "(", ")", ".", "max", "(", ")", "+", "1", ",", "paths", "[", "[", "'t_start'", "]", "]", ".", "max", "(", ")", ".", "max", "(", ")", "+", "1", "]", ")", "*", "np", ".", "nan", "pathmat", "[", "paths", "[", "'from'", "]", ".", "values", ",", "paths", "[", "'to'", "]", ".", "values", ",", "paths", "[", "'t_start'", "]", ".", "values", "]", "=", "paths", "[", "'temporal-distance'", "]", "closeness", "=", "np", ".", "nansum", "(", "1", "/", "np", ".", "nanmean", "(", "pathmat", ",", "axis", "=", "2", ")", ",", "axis", "=", "1", ")", "/", "(", "pathmat", ".", "shape", "[", "1", "]", "-", "1", ")", "return", "closeness" ]

[ "Returns", "temporal", "closeness", "centrality", "per", "node", "." ]

[ "def", "flatten", "(", "d", ",", "reducer", "=", "'tuple'", ",", "inverse", "=", "False", ")", ":", "if", "isinstance", "(", "reducer", ",", "str", ")", ":", "reducer", "=", "REDUCER_DICT", "[", "reducer", "]", "flat_dict", "=", "{", "}", "def", "_flatten", "(", "d", ",", "parent", "=", "None", ")", ":", "for", "key", ",", "value", "in", "six", ".", "viewitems", "(", "d", ")", ":", "flat_key", "=", "reducer", "(", "parent", ",", "key", ")", "if", "isinstance", "(", "value", ",", "Mapping", ")", ":", "_flatten", "(", "value", ",", "flat_key", ")", "else", ":", "if", "inverse", ":", "flat_key", ",", "value", "=", "value", ",", "flat_key", "if", "flat_key", "in", "flat_dict", ":", "raise", "ValueError", "(", "\"duplicated key '{}'\"", ".", "format", "(", "flat_key", ")", ")", "flat_dict", "[", "flat_key", "]", "=", "value", "_flatten", "(", "d", ")", "return", "flat_dict" ]

[ "Flatten", "dict", "-", "like", "object", "." ]

[ "def", "nested_set_dict", "(", "d", ",", "keys", ",", "value", ")", ":", "assert", "keys", "key", "=", "keys", "[", "0", "]", "if", "len", "(", "keys", ")", "==", "1", ":", "if", "key", "in", "d", ":", "raise", "ValueError", "(", "\"duplicated key '{}'\"", ".", "format", "(", "key", ")", ")", "d", "[", "key", "]", "=", "value", "return", "d", "=", "d", ".", "setdefault", "(", "key", ",", "{", "}", ")", "nested_set_dict", "(", "d", ",", "keys", "[", "1", ":", "]", ",", "value", ")" ]

[ "Set", "a", "value", "to", "a", "sequence", "of", "nested", "keys" ]

[ "def", "unflatten", "(", "d", ",", "splitter", "=", "'tuple'", ",", "inverse", "=", "False", ")", ":", "if", "isinstance", "(", "splitter", ",", "str", ")", ":", "splitter", "=", "SPLITTER_DICT", "[", "splitter", "]", "unflattened_dict", "=", "{", "}", "for", "flat_key", ",", "value", "in", "six", ".", "viewitems", "(", "d", ")", ":", "if", "inverse", ":", "flat_key", ",", "value", "=", "value", ",", "flat_key", "key_tuple", "=", "splitter", "(", "flat_key", ")", "nested_set_dict", "(", "unflattened_dict", ",", "key_tuple", ",", "value", ")", "return", "unflattened_dict" ]

[ "Unflatten", "dict", "-", "like", "object", "." ]

[ "def", "plot_track", "(", "track", ",", "filename", "=", "None", ",", "beat_resolution", "=", "None", ",", "downbeats", "=", "None", ",", "preset", "=", "'default'", ",", "cmap", "=", "'Blues'", ",", "xtick", "=", "'auto'", ",", "ytick", "=", "'octave'", ",", "xticklabel", "=", "True", ",", "yticklabel", "=", "'auto'", ",", "tick_loc", "=", "None", ",", "tick_direction", "=", "'in'", ",", "label", "=", "'both'", ",", "grid", "=", "'both'", ",", "grid_linestyle", "=", "':'", ",", "grid_linewidth", "=", ".5", ")", ":", "if", "not", "HAS_MATPLOTLIB", ":", "raise", "ImportError", "(", "\"matplotlib package is required for plotting \"", "\"supports.\"", ")", "fig", ",", "ax", "=", "plt", ".", "subplots", "(", ")", "plot_pianoroll", "(", "ax", ",", "track", ".", "pianoroll", ",", "track", ".", "is_drum", ",", "beat_resolution", ",", "downbeats", ",", "preset", "=", "preset", ",", "cmap", "=", "cmap", ",", "xtick", "=", "xtick", ",", "ytick", "=", "ytick", ",", "xticklabel", "=", "xticklabel", ",", "yticklabel", "=", "yticklabel", ",", "tick_loc", "=", "tick_loc", ",", "tick_direction", "=", "tick_direction", ",", "label", "=", "label", ",", "grid", "=", "grid", ",", "grid_linestyle", "=", "grid_linestyle", ",", "grid_linewidth", "=", "grid_linewidth", ")", "if", "filename", "is", "not", "None", ":", "plt", ".", "savefig", "(", "filename", ")", "return", "fig", ",", "ax" ]

[ "Plot", "the", "pianoroll", "or", "save", "a", "plot", "of", "the", "pianoroll", "." ]

[ "def", "append_track", "(", "self", ",", "track", "=", "None", ",", "pianoroll", "=", "None", ",", "program", "=", "0", ",", "is_drum", "=", "False", ",", "name", "=", "'unknown'", ")", ":", "if", "track", "is", "not", "None", ":", "if", "not", "isinstance", "(", "track", ",", "Track", ")", ":", "raise", "TypeError", "(", "\"`track` must be a pypianoroll.Track instance.\"", ")", "track", ".", "check_validity", "(", ")", "else", ":", "track", "=", "Track", "(", "pianoroll", ",", "program", ",", "is_drum", ",", "name", ")", "self", ".", "tracks", ".", "append", "(", "track", ")" ]

[ "Append", "a", "multitrack", ".", "Track", "instance", "to", "the", "track", "list", "or", "create", "a", "new", "multitrack", ".", "Track", "object", "and", "append", "it", "to", "the", "track", "list", "." ]

[ "def", "check_validity", "(", "self", ")", ":", "# tracks", "for", "track", "in", "self", ".", "tracks", ":", "if", "not", "isinstance", "(", "track", ",", "Track", ")", ":", "raise", "TypeError", "(", "\"`tracks` must be a list of \"", "\"`pypianoroll.Track` instances.\"", ")", "track", ".", "check_validity", "(", ")", "# tempo", "if", "not", "isinstance", "(", "self", ".", "tempo", ",", "np", ".", "ndarray", ")", ":", "raise", "TypeError", "(", "\"`tempo` must be int or a numpy array.\"", ")", "elif", "not", "np", ".", "issubdtype", "(", "self", ".", "tempo", ".", "dtype", ",", "np", ".", "number", ")", ":", "raise", "TypeError", "(", "\"Data type of `tempo` must be a subdtype of \"", "\"np.number.\"", ")", "elif", "self", ".", "tempo", ".", "ndim", "!=", "1", ":", "raise", "ValueError", "(", "\"`tempo` must be a 1D numpy array.\"", ")", "if", "np", ".", "any", "(", "self", ".", "tempo", "<=", "0.0", ")", ":", "raise", "ValueError", "(", "\"`tempo` should contain only positive numbers.\"", ")", "# downbeat", "if", "self", ".", "downbeat", "is", "not", "None", ":", "if", "not", "isinstance", "(", "self", ".", "downbeat", ",", "np", ".", "ndarray", ")", ":", "raise", "TypeError", "(", "\"`downbeat` must be a numpy array.\"", ")", "if", "not", "np", ".", "issubdtype", "(", "self", ".", "downbeat", ".", "dtype", ",", "np", ".", "bool_", ")", ":", "raise", "TypeError", "(", "\"Data type of `downbeat` must be bool.\"", ")", "if", "self", ".", "downbeat", ".", "ndim", "!=", "1", ":", "raise", "ValueError", "(", "\"`downbeat` must be a 1D numpy array.\"", ")", "# beat_resolution", "if", "not", "isinstance", "(", "self", ".", "beat_resolution", ",", "int", ")", ":", "raise", "TypeError", "(", "\"`beat_resolution` must be int.\"", ")", "if", "self", ".", "beat_resolution", "<", "1", ":", "raise", "ValueError", "(", "\"`beat_resolution` must be a positive integer.\"", ")", "# name", "if", "not", "isinstance", "(", "self", ".", "name", ",", "string_types", ")", ":", "raise", "TypeError", "(", "\"`name` must be a string.\"", ")" ]

[ "Raise", "an", "error", "if", "any", "invalid", "attribute", "found", "." ]

[ "def", "clip", "(", "self", ",", "lower", "=", "0", ",", "upper", "=", "127", ")", ":", "for", "track", "in", "self", ".", "tracks", ":", "track", ".", "clip", "(", "lower", ",", "upper", ")" ]

[ "Clip", "the", "pianorolls", "of", "all", "tracks", "by", "the", "given", "lower", "and", "upper", "bounds", "." ]

[ "def", "get_downbeat_steps", "(", "self", ")", ":", "if", "self", ".", "downbeat", "is", "None", ":", "return", "[", "]", "downbeat_steps", "=", "np", ".", "nonzero", "(", "self", ".", "downbeat", ")", "[", "0", "]", ".", "tolist", "(", ")", "return", "downbeat_steps" ]

[ "Return", "the", "indices", "of", "time", "steps", "that", "contain", "downbeats", "." ]

[ "def", "get_empty_tracks", "(", "self", ")", ":", "empty_track_indices", "=", "[", "idx", "for", "idx", ",", "track", "in", "enumerate", "(", "self", ".", "tracks", ")", "if", "not", "np", ".", "any", "(", "track", ".", "pianoroll", ")", "]", "return", "empty_track_indices" ]

[ "Return", "the", "indices", "of", "tracks", "with", "empty", "pianorolls", "." ]

[ "def", "get_merged_pianoroll", "(", "self", ",", "mode", "=", "'sum'", ")", ":", "stacked", "=", "self", ".", "get_stacked_pianoroll", "(", ")", "if", "mode", "==", "'any'", ":", "merged", "=", "np", ".", "any", "(", "stacked", ",", "axis", "=", "2", ")", "elif", "mode", "==", "'sum'", ":", "merged", "=", "np", ".", "sum", "(", "stacked", ",", "axis", "=", "2", ")", "elif", "mode", "==", "'max'", ":", "merged", "=", "np", ".", "max", "(", "stacked", ",", "axis", "=", "2", ")", "else", ":", "raise", "ValueError", "(", "\"`mode` must be one of {'max', 'sum', 'any'}.\"", ")", "return", "merged" ]

[ "Return", "the", "merged", "pianoroll", "." ]

[ "def", "merge_tracks", "(", "self", ",", "track_indices", "=", "None", ",", "mode", "=", "'sum'", ",", "program", "=", "0", ",", "is_drum", "=", "False", ",", "name", "=", "'merged'", ",", "remove_merged", "=", "False", ")", ":", "if", "mode", "not", "in", "(", "'max'", ",", "'sum'", ",", "'any'", ")", ":", "raise", "ValueError", "(", "\"`mode` must be one of {'max', 'sum', 'any'}.\"", ")", "merged", "=", "self", "[", "track_indices", "]", ".", "get_merged_pianoroll", "(", "mode", ")", "merged_track", "=", "Track", "(", "merged", ",", "program", ",", "is_drum", ",", "name", ")", "self", ".", "append_track", "(", "merged_track", ")", "if", "remove_merged", ":", "self", ".", "remove_tracks", "(", "track_indices", ")" ]

[ "Merge", "pianorolls", "of", "the", "tracks", "specified", "by", "track_indices", ".", "The", "merged", "track", "will", "have", "program", "number", "as", "given", "by", "program", "and", "drum", "indicator", "as", "given", "by", "is_drum", ".", "The", "merged", "track", "will", "be", "appended", "at", "the", "end", "of", "the", "track", "list", "." ]

[ "def", "pad_to_same", "(", "self", ")", ":", "max_length", "=", "self", ".", "get_max_length", "(", ")", "for", "track", "in", "self", ".", "tracks", ":", "if", "track", ".", "pianoroll", ".", "shape", "[", "0", "]", "<", "max_length", ":", "track", ".", "pad", "(", "max_length", "-", "track", ".", "pianoroll", ".", "shape", "[", "0", "]", ")" ]

[ "Pad", "shorter", "pianorolls", "with", "zeros", "at", "the", "end", "along", "the", "time", "axis", "to", "make", "the", "resulting", "pianoroll", "lengths", "the", "same", "as", "the", "maximum", "pianoroll", "length", "among", "all", "the", "tracks", "." ]

[ "def", "remove_tracks", "(", "self", ",", "track_indices", ")", ":", "if", "isinstance", "(", "track_indices", ",", "int", ")", ":", "track_indices", "=", "[", "track_indices", "]", "self", ".", "tracks", "=", "[", "track", "for", "idx", ",", "track", "in", "enumerate", "(", "self", ".", "tracks", ")", "if", "idx", "not", "in", "track_indices", "]" ]

[ "Remove", "tracks", "specified", "by", "track_indices", "." ]

[ "def", "transpose", "(", "self", ",", "semitone", ")", ":", "for", "track", "in", "self", ".", "tracks", ":", "if", "not", "track", ".", "is_drum", ":", "track", ".", "transpose", "(", "semitone", ")" ]

[ "Transpose", "the", "pianorolls", "of", "all", "tracks", "by", "a", "number", "of", "semitones", "where", "positive", "values", "are", "for", "higher", "key", "while", "negative", "values", "are", "for", "lower", "key", ".", "The", "drum", "tracks", "are", "ignored", "." ]

[ "def", "trim_trailing_silence", "(", "self", ")", ":", "active_length", "=", "self", ".", "get_active_length", "(", ")", "for", "track", "in", "self", ".", "tracks", ":", "track", ".", "pianoroll", "=", "track", ".", "pianoroll", "[", ":", "active_length", "]" ]

[ "Trim", "the", "trailing", "silences", "of", "the", "pianorolls", "of", "all", "tracks", ".", "Trailing", "silences", "are", "considered", "globally", "." ]

[ "def", "write", "(", "self", ",", "filename", ")", ":", "if", "not", "filename", ".", "endswith", "(", "(", "'.mid'", ",", "'.midi'", ",", "'.MID'", ",", "'.MIDI'", ")", ")", ":", "filename", "=", "filename", "+", "'.mid'", "pm", "=", "self", ".", "to_pretty_midi", "(", ")", "pm", ".", "write", "(", "filename", ")" ]

[ "Write", "the", "multitrack", "pianoroll", "to", "a", "MIDI", "file", "." ]

[ "def", "check_pianoroll", "(", "arr", ")", ":", "if", "not", "isinstance", "(", "arr", ",", "np", ".", "ndarray", ")", ":", "raise", "TypeError", "(", "\"`arr` must be of np.ndarray type\"", ")", "if", "not", "(", "np", ".", "issubdtype", "(", "arr", ".", "dtype", ",", "np", ".", "bool_", ")", "or", "np", ".", "issubdtype", "(", "arr", ".", "dtype", ",", "np", ".", "number", ")", ")", ":", "return", "False", "if", "arr", ".", "ndim", "!=", "2", ":", "return", "False", "if", "arr", ".", "shape", "[", "1", "]", "!=", "128", ":", "return", "False", "return", "True" ]

[ "Return", "True", "if", "the", "array", "is", "a", "standard", "piano", "-", "roll", "matrix", ".", "Otherwise", "return", "False", ".", "Raise", "TypeError", "if", "the", "input", "object", "is", "not", "a", "numpy", "array", "." ]

[ "def", "pad", "(", "obj", ",", "pad_length", ")", ":", "_check_supported", "(", "obj", ")", "copied", "=", "deepcopy", "(", "obj", ")", "copied", ".", "pad", "(", "pad_length", ")", "return", "copied" ]

[ "Return", "a", "copy", "of", "the", "object", "with", "piano", "-", "roll", "padded", "with", "zeros", "at", "the", "end", "along", "the", "time", "axis", "." ]

[ "def", "pad_to_multiple", "(", "obj", ",", "factor", ")", ":", "_check_supported", "(", "obj", ")", "copied", "=", "deepcopy", "(", "obj", ")", "copied", ".", "pad_to_multiple", "(", "factor", ")", "return", "copied" ]

[ "Return", "a", "copy", "of", "the", "object", "with", "its", "piano", "-", "roll", "padded", "with", "zeros", "at", "the", "end", "along", "the", "time", "axis", "with", "the", "minimal", "length", "that", "make", "the", "length", "of", "the", "resulting", "piano", "-", "roll", "a", "multiple", "of", "factor", "." ]

[ "def", "pad_to_same", "(", "obj", ")", ":", "if", "not", "isinstance", "(", "obj", ",", "Multitrack", ")", ":", "raise", "TypeError", "(", "\"Support only `pypianoroll.Multitrack` class objects\"", ")", "copied", "=", "deepcopy", "(", "obj", ")", "copied", ".", "pad_to_same", "(", ")", "return", "copied" ]

[ "Return", "a", "copy", "of", "the", "object", "with", "shorter", "piano", "-", "rolls", "padded", "with", "zeros", "at", "the", "end", "along", "the", "time", "axis", "to", "the", "length", "of", "the", "piano", "-", "roll", "with", "the", "maximal", "length", "." ]

[ "def", "save", "(", "filepath", ",", "obj", ",", "compressed", "=", "True", ")", ":", "if", "not", "isinstance", "(", "obj", ",", "Multitrack", ")", ":", "raise", "TypeError", "(", "\"Support only `pypianoroll.Multitrack` class objects\"", ")", "obj", ".", "save", "(", "filepath", ",", "compressed", ")" ]

[ "Save", "the", "object", "to", "a", ".", "npz", "file", "." ]

[ "def", "write", "(", "obj", ",", "filepath", ")", ":", "if", "not", "isinstance", "(", "obj", ",", "Multitrack", ")", ":", "raise", "TypeError", "(", "\"Support only `pypianoroll.Multitrack` class objects\"", ")", "obj", ".", "write", "(", "filepath", ")" ]

[ "Write", "the", "object", "to", "a", "MIDI", "file", "." ]

[ "def", "_validate_pianoroll", "(", "pianoroll", ")", ":", "if", "not", "isinstance", "(", "pianoroll", ",", "np", ".", "ndarray", ")", ":", "raise", "TypeError", "(", "\"`pianoroll` must be of np.ndarray type.\"", ")", "if", "not", "(", "np", ".", "issubdtype", "(", "pianoroll", ".", "dtype", ",", "np", ".", "bool_", ")", "or", "np", ".", "issubdtype", "(", "pianoroll", ".", "dtype", ",", "np", ".", "number", ")", ")", ":", "raise", "TypeError", "(", "\"The data type of `pianoroll` must be np.bool_ or a \"", "\"subdtype of np.number.\"", ")", "if", "pianoroll", ".", "ndim", "!=", "2", ":", "raise", "ValueError", "(", "\"`pianoroll` must have exactly two dimensions.\"", ")", "if", "pianoroll", ".", "shape", "[", "1", "]", "!=", "128", ":", "raise", "ValueError", "(", "\"The length of the second axis of `pianoroll` must be \"", "\"128.\"", ")" ]

[ "Raise", "an", "error", "if", "the", "input", "array", "is", "not", "a", "standard", "pianoroll", "." ]

[ "def", "_to_chroma", "(", "pianoroll", ")", ":", "_validate_pianoroll", "(", "pianoroll", ")", "reshaped", "=", "pianoroll", "[", ":", ",", ":", "120", "]", ".", "reshape", "(", "-", "1", ",", "12", ",", "10", ")", "reshaped", "[", "...", ",", ":", "8", "]", "+=", "pianoroll", "[", ":", ",", "120", ":", "]", ".", "reshape", "(", "-", "1", ",", "1", ",", "8", ")", "return", "np", ".", "sum", "(", "reshaped", ",", "1", ")" ]

[ "Return", "the", "unnormalized", "chroma", "features", "of", "a", "pianoroll", "." ]

[ "def", "empty_beat_rate", "(", "pianoroll", ",", "beat_resolution", ")", ":", "_validate_pianoroll", "(", "pianoroll", ")", "reshaped", "=", "pianoroll", ".", "reshape", "(", "-", "1", ",", "beat_resolution", "*", "pianoroll", ".", "shape", "[", "1", "]", ")", "n_empty_beats", "=", "np", ".", "count_nonzero", "(", "reshaped", ".", "any", "(", "1", ")", ")", "return", "n_empty_beats", "/", "len", "(", "reshaped", ")" ]

[ "Return", "the", "ratio", "of", "empty", "beats", "to", "the", "total", "number", "of", "beats", "in", "a", "pianoroll", "." ]

[ "def", "n_pitche_classes_used", "(", "pianoroll", ")", ":", "_validate_pianoroll", "(", "pianoroll", ")", "chroma", "=", "_to_chroma", "(", "pianoroll", ")", "return", "np", ".", "count_nonzero", "(", "np", ".", "any", "(", "chroma", ",", "0", ")", ")" ]

[ "Return", "the", "number", "of", "unique", "pitch", "classes", "used", "in", "a", "pianoroll", "." ]

[ "def", "polyphonic_rate", "(", "pianoroll", ",", "threshold", "=", "2", ")", ":", "_validate_pianoroll", "(", "pianoroll", ")", "n_poly", "=", "np", ".", "count_nonzero", "(", "np", ".", "count_nonzero", "(", "pianoroll", ",", "1", ")", ">", "threshold", ")", "return", "n_poly", "/", "len", "(", "pianoroll", ")" ]

[ "Return", "the", "ratio", "of", "the", "number", "of", "time", "steps", "where", "the", "number", "of", "pitches", "being", "played", "is", "larger", "than", "threshold", "to", "the", "total", "number", "of", "time", "steps", "in", "a", "pianoroll", "." ]

[ "def", "in_scale_rate", "(", "pianoroll", ",", "key", "=", "3", ",", "kind", "=", "'major'", ")", ":", "if", "not", "isinstance", "(", "key", ",", "int", ")", ":", "raise", "TypeError", "(", "\"`key` must an integer.\"", ")", "if", "key", ">", "11", "or", "key", "<", "0", ":", "raise", "ValueError", "(", "\"`key` must be in an integer in between 0 and 11.\"", ")", "if", "kind", "not", "in", "(", "'major'", ",", "'minor'", ")", ":", "raise", "ValueError", "(", "\"`kind` must be one of 'major' or 'minor'.\"", ")", "_validate_pianoroll", "(", "pianoroll", ")", "def", "_scale_mask", "(", "key", ",", "kind", ")", ":", "\"\"\"Return a scale mask for the given key. Default to C major scale.\"\"\"", "if", "kind", "==", "'major'", ":", "a_scale_mask", "=", "np", ".", "array", "(", "[", "0", ",", "1", ",", "1", ",", "0", ",", "1", ",", "0", ",", "1", ",", "0", ",", "1", ",", "1", ",", "0", ",", "1", "]", ",", "bool", ")", "else", ":", "a_scale_mask", "=", "np", ".", "array", "(", "[", "1", ",", "0", ",", "1", ",", "0", ",", "1", ",", "1", ",", "0", ",", "1", ",", "0", ",", "1", ",", "0", ",", "1", "]", ",", "bool", ")", "return", "np", ".", "roll", "(", "a_scale_mask", ",", "key", ")", "chroma", "=", "_to_chroma", "(", "pianoroll", ")", "scale_mask", "=", "_scale_mask", "(", "key", ",", "kind", ")", "n_in_scale", "=", "np", ".", "sum", "(", "scale_mask", ".", "reshape", "(", "-", "1", ",", "12", ")", "*", "chroma", ")", "return", "n_in_scale", "/", "np", ".", "count_nonzero", "(", "pianoroll", ")" ]

[ "Return", "the", "ratio", "of", "the", "number", "of", "nonzero", "entries", "that", "lie", "in", "a", "specific", "scale", "to", "the", "total", "number", "of", "nonzero", "entries", "in", "a", "pianoroll", ".", "Default", "to", "C", "major", "scale", "." ]

[ "def", "assign_constant", "(", "self", ",", "value", ",", "dtype", "=", "None", ")", ":", "if", "not", "self", ".", "is_binarized", "(", ")", ":", "self", ".", "pianoroll", "[", "self", ".", "pianoroll", ".", "nonzero", "(", ")", "]", "=", "value", "return", "if", "dtype", "is", "None", ":", "if", "isinstance", "(", "value", ",", "int", ")", ":", "dtype", "=", "int", "elif", "isinstance", "(", "value", ",", "float", ")", ":", "dtype", "=", "float", "nonzero", "=", "self", ".", "pianoroll", ".", "nonzero", "(", ")", "self", ".", "pianoroll", "=", "np", ".", "zeros", "(", "self", ".", "pianoroll", ".", "shape", ",", "dtype", ")", "self", ".", "pianoroll", "[", "nonzero", "]", "=", "value" ]

[ "Assign", "a", "constant", "value", "to", "all", "nonzeros", "in", "the", "pianoroll", ".", "If", "the", "pianoroll", "is", "not", "binarized", "its", "data", "type", "will", "be", "preserved", ".", "If", "the", "pianoroll", "is", "binarized", "it", "will", "be", "casted", "to", "the", "type", "of", "value", "." ]

[ "def", "binarize", "(", "self", ",", "threshold", "=", "0", ")", ":", "if", "not", "self", ".", "is_binarized", "(", ")", ":", "self", ".", "pianoroll", "=", "(", "self", ".", "pianoroll", ">", "threshold", ")" ]

[ "Binarize", "the", "pianoroll", "." ]

[ "def", "check_validity", "(", "self", ")", ":", "# pianoroll", "if", "not", "isinstance", "(", "self", ".", "pianoroll", ",", "np", ".", "ndarray", ")", ":", "raise", "TypeError", "(", "\"`pianoroll` must be a numpy array.\"", ")", "if", "not", "(", "np", ".", "issubdtype", "(", "self", ".", "pianoroll", ".", "dtype", ",", "np", ".", "bool_", ")", "or", "np", ".", "issubdtype", "(", "self", ".", "pianoroll", ".", "dtype", ",", "np", ".", "number", ")", ")", ":", "raise", "TypeError", "(", "\"The data type of `pianoroll` must be np.bool_ or \"", "\"a subdtype of np.number.\"", ")", "if", "self", ".", "pianoroll", ".", "ndim", "!=", "2", ":", "raise", "ValueError", "(", "\"`pianoroll` must have exactly two dimensions.\"", ")", "if", "self", ".", "pianoroll", ".", "shape", "[", "1", "]", "!=", "128", ":", "raise", "ValueError", "(", "\"The length of the second axis of `pianoroll` \"", "\"must be 128.\"", ")", "# program", "if", "not", "isinstance", "(", "self", ".", "program", ",", "int", ")", ":", "raise", "TypeError", "(", "\"`program` must be int.\"", ")", "if", "self", ".", "program", "<", "0", "or", "self", ".", "program", ">", "127", ":", "raise", "ValueError", "(", "\"`program` must be in between 0 to 127.\"", ")", "# is_drum", "if", "not", "isinstance", "(", "self", ".", "is_drum", ",", "bool", ")", ":", "raise", "TypeError", "(", "\"`is_drum` must be bool.\"", ")", "# name", "if", "not", "isinstance", "(", "self", ".", "name", ",", "string_types", ")", ":", "raise", "TypeError", "(", "\"`name` must be a string.\"", ")" ]

[ "Raise", "error", "if", "any", "invalid", "attribute", "found", "." ]

[ "def", "clip", "(", "self", ",", "lower", "=", "0", ",", "upper", "=", "127", ")", ":", "self", ".", "pianoroll", "=", "self", ".", "pianoroll", ".", "clip", "(", "lower", ",", "upper", ")" ]

[ "Clip", "the", "pianoroll", "by", "the", "given", "lower", "and", "upper", "bounds", "." ]

[ "def", "is_binarized", "(", "self", ")", ":", "is_binarized", "=", "np", ".", "issubdtype", "(", "self", ".", "pianoroll", ".", "dtype", ",", "np", ".", "bool_", ")", "return", "is_binarized" ]

[ "Return", "True", "if", "the", "pianoroll", "is", "already", "binarized", ".", "Otherwise", "return", "False", "." ]

[ "def", "pad", "(", "self", ",", "pad_length", ")", ":", "self", ".", "pianoroll", "=", "np", ".", "pad", "(", "self", ".", "pianoroll", ",", "(", "(", "0", ",", "pad_length", ")", ",", "(", "0", ",", "0", ")", ")", ",", "'constant'", ")" ]

[ "Pad", "the", "pianoroll", "with", "zeros", "at", "the", "end", "along", "the", "time", "axis", "." ]

[ "def", "pad_to_multiple", "(", "self", ",", "factor", ")", ":", "remainder", "=", "self", ".", "pianoroll", ".", "shape", "[", "0", "]", "%", "factor", "if", "remainder", ":", "pad_width", "=", "(", "(", "0", ",", "(", "factor", "-", "remainder", ")", ")", ",", "(", "0", ",", "0", ")", ")", "self", ".", "pianoroll", "=", "np", ".", "pad", "(", "self", ".", "pianoroll", ",", "pad_width", ",", "'constant'", ")" ]

[ "Pad", "the", "pianoroll", "with", "zeros", "at", "the", "end", "along", "the", "time", "axis", "with", "the", "minimum", "length", "that", "makes", "the", "resulting", "pianoroll", "length", "a", "multiple", "of", "factor", "." ]

[ "def", "transpose", "(", "self", ",", "semitone", ")", ":", "if", "semitone", ">", "0", "and", "semitone", "<", "128", ":", "self", ".", "pianoroll", "[", ":", ",", "semitone", ":", "]", "=", "self", ".", "pianoroll", "[", ":", ",", ":", "(", "128", "-", "semitone", ")", "]", "self", ".", "pianoroll", "[", ":", ",", ":", "semitone", "]", "=", "0", "elif", "semitone", "<", "0", "and", "semitone", ">", "-", "128", ":", "self", ".", "pianoroll", "[", ":", ",", ":", "(", "128", "+", "semitone", ")", "]", "=", "self", ".", "pianoroll", "[", ":", ",", "-", "semitone", ":", "]", "self", ".", "pianoroll", "[", ":", ",", "(", "128", "+", "semitone", ")", ":", "]", "=", "0" ]

[ "Transpose", "the", "pianoroll", "by", "a", "number", "of", "semitones", "where", "positive", "values", "are", "for", "higher", "key", "while", "negative", "values", "are", "for", "lower", "key", "." ]

[ "def", "trim_trailing_silence", "(", "self", ")", ":", "length", "=", "self", ".", "get_active_length", "(", ")", "self", ".", "pianoroll", "=", "self", ".", "pianoroll", "[", ":", "length", "]" ]

[ "Trim", "the", "trailing", "silence", "of", "the", "pianoroll", "." ]

[ "def", "plot_conv_weights", "(", "layer", ",", "figsize", "=", "(", "6", ",", "6", ")", ")", ":", "W", "=", "layer", ".", "W", ".", "get_value", "(", ")", "shape", "=", "W", ".", "shape", "nrows", "=", "np", ".", "ceil", "(", "np", ".", "sqrt", "(", "shape", "[", "0", "]", ")", ")", ".", "astype", "(", "int", ")", "ncols", "=", "nrows", "for", "feature_map", "in", "range", "(", "shape", "[", "1", "]", ")", ":", "figs", ",", "axes", "=", "plt", ".", "subplots", "(", "nrows", ",", "ncols", ",", "figsize", "=", "figsize", ",", "squeeze", "=", "False", ")", "for", "ax", "in", "axes", ".", "flatten", "(", ")", ":", "ax", ".", "set_xticks", "(", "[", "]", ")", "ax", ".", "set_yticks", "(", "[", "]", ")", "ax", ".", "axis", "(", "'off'", ")", "for", "i", ",", "(", "r", ",", "c", ")", "in", "enumerate", "(", "product", "(", "range", "(", "nrows", ")", ",", "range", "(", "ncols", ")", ")", ")", ":", "if", "i", ">=", "shape", "[", "0", "]", ":", "break", "axes", "[", "r", ",", "c", "]", ".", "imshow", "(", "W", "[", "i", ",", "feature_map", "]", ",", "cmap", "=", "'gray'", ",", "interpolation", "=", "'none'", ")", "return", "plt" ]

[ "Plot", "the", "weights", "of", "a", "specific", "layer", "." ]

[ "def", "plot_conv_activity", "(", "layer", ",", "x", ",", "figsize", "=", "(", "6", ",", "8", ")", ")", ":", "if", "x", ".", "shape", "[", "0", "]", "!=", "1", ":", "raise", "ValueError", "(", "\"Only one sample can be plotted at a time.\"", ")", "# compile theano function", "xs", "=", "T", ".", "tensor4", "(", "'xs'", ")", ".", "astype", "(", "theano", ".", "config", ".", "floatX", ")", "get_activity", "=", "theano", ".", "function", "(", "[", "xs", "]", ",", "get_output", "(", "layer", ",", "xs", ")", ")", "activity", "=", "get_activity", "(", "x", ")", "shape", "=", "activity", ".", "shape", "nrows", "=", "np", ".", "ceil", "(", "np", ".", "sqrt", "(", "shape", "[", "1", "]", ")", ")", ".", "astype", "(", "int", ")", "ncols", "=", "nrows", "figs", ",", "axes", "=", "plt", ".", "subplots", "(", "nrows", "+", "1", ",", "ncols", ",", "figsize", "=", "figsize", ",", "squeeze", "=", "False", ")", "axes", "[", "0", ",", "ncols", "//", "2", "]", ".", "imshow", "(", "1", "-", "x", "[", "0", "]", "[", "0", "]", ",", "cmap", "=", "'gray'", ",", "interpolation", "=", "'none'", ")", "axes", "[", "0", ",", "ncols", "//", "2", "]", ".", "set_title", "(", "'original'", ")", "for", "ax", "in", "axes", ".", "flatten", "(", ")", ":", "ax", ".", "set_xticks", "(", "[", "]", ")", "ax", ".", "set_yticks", "(", "[", "]", ")", "ax", ".", "axis", "(", "'off'", ")", "for", "i", ",", "(", "r", ",", "c", ")", "in", "enumerate", "(", "product", "(", "range", "(", "nrows", ")", ",", "range", "(", "ncols", ")", ")", ")", ":", "if", "i", ">=", "shape", "[", "1", "]", ":", "break", "ndim", "=", "activity", "[", "0", "]", "[", "i", "]", ".", "ndim", "if", "ndim", "!=", "2", ":", "raise", "ValueError", "(", "\"Wrong number of dimensions, image data should \"", "\"have 2, instead got {}\"", ".", "format", "(", "ndim", ")", ")", "axes", "[", "r", "+", "1", ",", "c", "]", ".", "imshow", "(", "-", "activity", "[", "0", "]", "[", "i", "]", ",", "cmap", "=", "'gray'", ",", "interpolation", "=", "'none'", ")", "return", "plt" ]

[ "Plot", "the", "acitivities", "of", "a", "specific", "layer", "." ]

[ "def", "occlusion_heatmap", "(", "net", ",", "x", ",", "target", ",", "square_length", "=", "7", ")", ":", "if", "(", "x", ".", "ndim", "!=", "4", ")", "or", "x", ".", "shape", "[", "0", "]", "!=", "1", ":", "raise", "ValueError", "(", "\"This function requires the input data to be of \"", "\"shape (1, c, x, y), instead got {}\"", ".", "format", "(", "x", ".", "shape", ")", ")", "if", "square_length", "%", "2", "==", "0", ":", "raise", "ValueError", "(", "\"Square length has to be an odd number, instead \"", "\"got {}.\"", ".", "format", "(", "square_length", ")", ")", "num_classes", "=", "get_output_shape", "(", "net", ".", "layers_", "[", "-", "1", "]", ")", "[", "1", "]", "img", "=", "x", "[", "0", "]", ".", "copy", "(", ")", "bs", ",", "col", ",", "s0", ",", "s1", "=", "x", ".", "shape", "heat_array", "=", "np", ".", "zeros", "(", "(", "s0", ",", "s1", ")", ")", "pad", "=", "square_length", "//", "2", "+", "1", "x_occluded", "=", "np", ".", "zeros", "(", "(", "s1", ",", "col", ",", "s0", ",", "s1", ")", ",", "dtype", "=", "img", ".", "dtype", ")", "probs", "=", "np", ".", "zeros", "(", "(", "s0", ",", "s1", ",", "num_classes", ")", ")", "# generate occluded images", "for", "i", "in", "range", "(", "s0", ")", ":", "# batch s1 occluded images for faster prediction", "for", "j", "in", "range", "(", "s1", ")", ":", "x_pad", "=", "np", ".", "pad", "(", "img", ",", "(", "(", "0", ",", "0", ")", ",", "(", "pad", ",", "pad", ")", ",", "(", "pad", ",", "pad", ")", ")", ",", "'constant'", ")", "x_pad", "[", ":", ",", "i", ":", "i", "+", "square_length", ",", "j", ":", "j", "+", "square_length", "]", "=", "0.", "x_occluded", "[", "j", "]", "=", "x_pad", "[", ":", ",", "pad", ":", "-", "pad", ",", "pad", ":", "-", "pad", "]", "y_proba", "=", "net", ".", "predict_proba", "(", "x_occluded", ")", "probs", "[", "i", "]", "=", "y_proba", ".", "reshape", "(", "s1", ",", "num_classes", ")", "# from predicted probabilities, pick only those of target class", "for", "i", "in", "range", "(", "s0", ")", ":", "for", "j", "in", "range", "(", "s1", ")", ":", "heat_array", "[", "i", ",", "j", "]", "=", "probs", "[", "i", ",", "j", ",", "target", "]", "return", "heat_array" ]

[ "An", "occlusion", "test", "that", "checks", "an", "image", "for", "its", "critical", "parts", "." ]

[ "def", "plot_occlusion", "(", "net", ",", "X", ",", "target", ",", "square_length", "=", "7", ",", "figsize", "=", "(", "9", ",", "None", ")", ")", ":", "return", "_plot_heat_map", "(", "net", ",", "X", ",", "figsize", ",", "lambda", "net", ",", "X", ",", "n", ":", "occlusion_heatmap", "(", "net", ",", "X", ",", "target", "[", "n", "]", ",", "square_length", ")", ")" ]

[ "Plot", "which", "parts", "of", "an", "image", "are", "particularly", "import", "for", "the", "net", "to", "classify", "the", "image", "correctly", "." ]

[ "def", "multiclass_logloss", "(", "actual", ",", "predicted", ",", "eps", "=", "1e-15", ")", ":", "# Convert 'actual' to a binary array if it's not already:", "if", "len", "(", "actual", ".", "shape", ")", "==", "1", ":", "actual2", "=", "np", ".", "zeros", "(", "(", "actual", ".", "shape", "[", "0", "]", ",", "predicted", ".", "shape", "[", "1", "]", ")", ")", "for", "i", ",", "val", "in", "enumerate", "(", "actual", ")", ":", "actual2", "[", "i", ",", "val", "]", "=", "1", "actual", "=", "actual2", "clip", "=", "np", ".", "clip", "(", "predicted", ",", "eps", ",", "1", "-", "eps", ")", "rows", "=", "actual", ".", "shape", "[", "0", "]", "vsota", "=", "np", ".", "sum", "(", "actual", "*", "np", ".", "log", "(", "clip", ")", ")", "return", "-", "1.0", "/", "rows", "*", "vsota" ]

[ "Multi", "class", "version", "of", "Logarithmic", "Loss", "metric", "." ]

[ "def", "objective", "(", "layers", ",", "loss_function", ",", "target", ",", "aggregate", "=", "aggregate", ",", "deterministic", "=", "False", ",", "l1", "=", "0", ",", "l2", "=", "0", ",", "get_output_kw", "=", "None", ")", ":", "if", "get_output_kw", "is", "None", ":", "get_output_kw", "=", "{", "}", "output_layer", "=", "layers", "[", "-", "1", "]", "network_output", "=", "get_output", "(", "output_layer", ",", "deterministic", "=", "deterministic", ",", "*", "*", "get_output_kw", ")", "loss", "=", "aggregate", "(", "loss_function", "(", "network_output", ",", "target", ")", ")", "if", "l1", ":", "loss", "+=", "regularization", ".", "regularize_layer_params", "(", "layers", ".", "values", "(", ")", ",", "regularization", ".", "l1", ")", "*", "l1", "if", "l2", ":", "loss", "+=", "regularization", ".", "regularize_layer_params", "(", "layers", ".", "values", "(", ")", ",", "regularization", ".", "l2", ")", "*", "l2", "return", "loss" ]

[ "Default", "implementation", "of", "the", "NeuralNet", "objective", "." ]

[ "def", "initialize", "(", "self", ")", ":", "if", "getattr", "(", "self", ",", "'_initialized'", ",", "False", ")", ":", "return", "out", "=", "getattr", "(", "self", ",", "'_output_layers'", ",", "None", ")", "if", "out", "is", "None", ":", "self", ".", "initialize_layers", "(", ")", "self", ".", "_check_for_unused_kwargs", "(", ")", "iter_funcs", "=", "self", ".", "_create_iter_funcs", "(", "self", ".", "layers_", ",", "self", ".", "objective", ",", "self", ".", "update", ",", "self", ".", "y_tensor_type", ",", ")", "self", ".", "train_iter_", ",", "self", ".", "eval_iter_", ",", "self", ".", "predict_iter_", "=", "iter_funcs", "self", ".", "_initialized", "=", "True" ]

[ "Initializes", "the", "network", ".", "Checks", "that", "no", "extra", "kwargs", "were", "passed", "to", "the", "constructor", "and", "compiles", "the", "train", "predict", "and", "evaluation", "functions", "." ]

[ "def", "fit", "(", "self", ",", "X", ",", "y", ",", "epochs", "=", "None", ")", ":", "if", "self", ".", "check_input", ":", "X", ",", "y", "=", "self", ".", "_check_good_input", "(", "X", ",", "y", ")", "if", "self", ".", "use_label_encoder", ":", "self", ".", "enc_", "=", "LabelEncoder", "(", ")", "y", "=", "self", ".", "enc_", ".", "fit_transform", "(", "y", ")", ".", "astype", "(", "np", ".", "int32", ")", "self", ".", "classes_", "=", "self", ".", "enc_", ".", "classes_", "self", ".", "initialize", "(", ")", "try", ":", "self", ".", "train_loop", "(", "X", ",", "y", ",", "epochs", "=", "epochs", ")", "except", "KeyboardInterrupt", ":", "pass", "return", "self" ]

[ "Runs", "the", "training", "loop", "for", "a", "given", "number", "of", "epochs" ]

[ "def", "partial_fit", "(", "self", ",", "X", ",", "y", ",", "classes", "=", "None", ")", ":", "return", "self", ".", "fit", "(", "X", ",", "y", ",", "epochs", "=", "1", ")" ]

[ "Runs", "a", "single", "epoch", "using", "the", "provided", "data" ]

[ "def", "narrow", "(", "self", ",", "*", "*", "kwargs", ")", ":", "from_date", "=", "kwargs", ".", "pop", "(", "'from_date'", ",", "None", ")", "to_date", "=", "kwargs", ".", "pop", "(", "'to_date'", ",", "None", ")", "date", "=", "kwargs", ".", "pop", "(", "'date'", ",", "None", ")", "qs", "=", "self", "if", "from_date", ":", "qs", "=", "qs", ".", "filter", "(", "date__gte", "=", "from_date", ")", "if", "to_date", ":", "qs", "=", "qs", ".", "filter", "(", "date__lte", "=", "to_date", ")", "if", "date", ":", "qs", "=", "qs", ".", "filter", "(", "date", "=", "date", ")", "return", "super", "(", "ByDateQuerySetMixin", ",", "qs", ")", ".", "narrow", "(", "*", "*", "kwargs", ")" ]

[ "Up", "-", "to", "including" ]

[ "def", "set_environment_variables", "(", "json_file_path", ")", ":", "if", "json_file_path", ":", "with", "open", "(", "json_file_path", ")", "as", "json_file", ":", "env_vars", "=", "json", ".", "loads", "(", "json_file", ".", "read", "(", ")", ")", "export_variables", "(", "env_vars", ")" ]

[ "Read", "and", "set", "environment", "variables", "from", "a", "flat", "json", "file", "." ]

[ "def", "millis_interval", "(", "start", ",", "end", ")", ":", "diff", "=", "end", "-", "start", "millis", "=", "diff", ".", "days", "*", "24", "*", "60", "*", "60", "*", "1000", "millis", "+=", "diff", ".", "seconds", "*", "1000", "millis", "+=", "diff", ".", "microseconds", "/", "1000", "return", "millis" ]

[ "start", "and", "end", "are", "datetime", "instances" ]

[ "def", "_import_lua", "(", "load_dependencies", "=", "True", ")", ":", "try", ":", "import", "lua", "except", "ImportError", ":", "raise", "RuntimeError", "(", "\"Lua not installed\"", ")", "lua_globals", "=", "lua", ".", "globals", "(", ")", "if", "load_dependencies", ":", "Script", ".", "_import_lua_dependencies", "(", "lua", ",", "lua_globals", ")", "return", "lua", ",", "lua_globals" ]

[ "Import", "lua", "and", "dependencies", "." ]

[ "def", "_import_lua_dependencies", "(", "lua", ",", "lua_globals", ")", ":", "if", "sys", ".", "platform", "not", "in", "(", "'darwin'", ",", "'windows'", ")", ":", "import", "ctypes", "ctypes", ".", "CDLL", "(", "'liblua5.2.so'", ",", "mode", "=", "ctypes", ".", "RTLD_GLOBAL", ")", "try", ":", "lua_globals", ".", "cjson", "=", "lua", ".", "eval", "(", "'require \"cjson\"'", ")", "except", "RuntimeError", ":", "raise", "RuntimeError", "(", "\"cjson not installed\"", ")" ]

[ "Imports", "lua", "dependencies", "that", "are", "supported", "by", "redis", "lua", "scripts", "." ]

[ "def", "lock", "(", "self", ",", "key", ",", "timeout", "=", "0", ",", "sleep", "=", "0", ")", ":", "return", "MockRedisLock", "(", "self", ",", "key", ",", "timeout", ",", "sleep", ")" ]

[ "Emulate", "lock", "." ]

[ "def", "keys", "(", "self", ",", "pattern", "=", "'*'", ")", ":", "# making sure the pattern is unicode/str.", "try", ":", "pattern", "=", "pattern", ".", "decode", "(", "'utf-8'", ")", "# This throws an AttributeError in python 3, or an", "# UnicodeEncodeError in python 2", "except", "(", "AttributeError", ",", "UnicodeEncodeError", ")", ":", "pass", "# Make regex out of glob styled pattern.", "regex", "=", "fnmatch", ".", "translate", "(", "pattern", ")", "regex", "=", "re", ".", "compile", "(", "re", ".", "sub", "(", "r'(^|[^\\\\])\\.'", ",", "r'\\1[^/]'", ",", "regex", ")", ")", "# Find every key that matches the pattern", "return", "[", "key", "for", "key", "in", "self", ".", "redis", ".", "keys", "(", ")", "if", "regex", ".", "match", "(", "key", ".", "decode", "(", "'utf-8'", ")", ")", "]" ]

[ "Emulate", "keys", "." ]

[ "def", "delete", "(", "self", ",", "*", "keys", ")", ":", "key_counter", "=", "0", "for", "key", "in", "map", "(", "self", ".", "_encode", ",", "keys", ")", ":", "if", "key", "in", "self", ".", "redis", ":", "del", "self", ".", "redis", "[", "key", "]", "key_counter", "+=", "1", "if", "key", "in", "self", ".", "timeouts", ":", "del", "self", ".", "timeouts", "[", "key", "]", "return", "key_counter" ]

[ "Emulate", "delete", "." ]

[ "def", "do_expire", "(", "self", ")", ":", "# Deep copy to avoid RuntimeError: dictionary changed size during iteration", "_timeouts", "=", "deepcopy", "(", "self", ".", "timeouts", ")", "for", "key", ",", "value", "in", "_timeouts", ".", "items", "(", ")", ":", "if", "value", "-", "self", ".", "clock", ".", "now", "(", ")", "<", "timedelta", "(", "0", ")", ":", "del", "self", ".", "timeouts", "[", "key", "]", "# removing the expired key", "if", "key", "in", "self", ".", "redis", ":", "self", ".", "redis", ".", "pop", "(", "key", ",", "None", ")" ]

[ "Expire", "objects", "assuming", "now", "==", "time" ]

[ "def", "set", "(", "self", ",", "key", ",", "value", ",", "ex", "=", "None", ",", "px", "=", "None", ",", "nx", "=", "False", ",", "xx", "=", "False", ")", ":", "key", "=", "self", ".", "_encode", "(", "key", ")", "value", "=", "self", ".", "_encode", "(", "value", ")", "if", "nx", "and", "xx", ":", "return", "None", "mode", "=", "\"nx\"", "if", "nx", "else", "\"xx\"", "if", "xx", "else", "None", "if", "self", ".", "_should_set", "(", "key", ",", "mode", ")", ":", "expire", "=", "None", "if", "ex", "is", "not", "None", ":", "expire", "=", "ex", "if", "isinstance", "(", "ex", ",", "timedelta", ")", "else", "timedelta", "(", "seconds", "=", "ex", ")", "if", "px", "is", "not", "None", ":", "expire", "=", "px", "if", "isinstance", "(", "px", ",", "timedelta", ")", "else", "timedelta", "(", "milliseconds", "=", "px", ")", "if", "expire", "is", "not", "None", "and", "expire", ".", "total_seconds", "(", ")", "<=", "0", ":", "raise", "ResponseError", "(", "\"invalid expire time in SETEX\"", ")", "result", "=", "self", ".", "_set", "(", "key", ",", "value", ")", "if", "expire", ":", "self", ".", "_expire", "(", "key", ",", "expire", ")", "return", "result" ]

[ "Set", "the", "value", "for", "the", "key", "in", "the", "context", "of", "the", "provided", "kwargs", "." ]

[ "def", "_should_set", "(", "self", ",", "key", ",", "mode", ")", ":", "if", "mode", "is", "None", "or", "mode", "not", "in", "[", "\"nx\"", ",", "\"xx\"", "]", ":", "return", "True", "if", "mode", "==", "\"nx\"", ":", "if", "key", "in", "self", ".", "redis", ":", "# nx means set only if key is absent", "# false if the key already exists", "return", "False", "elif", "key", "not", "in", "self", ".", "redis", ":", "# at this point mode can only be xx", "# xx means set only if the key already exists", "# false if is absent", "return", "False", "# for all other cases, return true", "return", "True" ]

[ "Determine", "if", "it", "is", "okay", "to", "set", "a", "key", "." ]

[ "def", "setex", "(", "self", ",", "name", ",", "time", ",", "value", ")", ":", "if", "not", "self", ".", "strict", ":", "# when not strict mode swap value and time args order", "time", ",", "value", "=", "value", ",", "time", "return", "self", ".", "set", "(", "name", ",", "value", ",", "ex", "=", "time", ")" ]

[ "Set", "the", "value", "of", "name", "to", "value", "that", "expires", "in", "time", "seconds", ".", "time", "can", "be", "represented", "by", "an", "integer", "or", "a", "Python", "timedelta", "object", "." ]

[ "def", "psetex", "(", "self", ",", "key", ",", "time", ",", "value", ")", ":", "return", "self", ".", "set", "(", "key", ",", "value", ",", "px", "=", "time", ")" ]

[ "Set", "the", "value", "of", "key", "to", "value", "that", "expires", "in", "time", "milliseconds", ".", "time", "can", "be", "represented", "by", "an", "integer", "or", "a", "Python", "timedelta", "object", "." ]

[ "def", "setnx", "(", "self", ",", "key", ",", "value", ")", ":", "return", "self", ".", "set", "(", "key", ",", "value", ",", "nx", "=", "True", ")" ]

[ "Set", "the", "value", "of", "key", "to", "value", "if", "key", "doesn", "t", "exist" ]

[ "def", "setbit", "(", "self", ",", "key", ",", "offset", ",", "value", ")", ":", "key", "=", "self", ".", "_encode", "(", "key", ")", "index", ",", "bits", ",", "mask", "=", "self", ".", "_get_bits_and_offset", "(", "key", ",", "offset", ")", "if", "index", ">=", "len", "(", "bits", ")", ":", "bits", ".", "extend", "(", "b\"\\x00\"", "*", "(", "index", "+", "1", "-", "len", "(", "bits", ")", ")", ")", "prev_val", "=", "1", "if", "(", "bits", "[", "index", "]", "&", "mask", ")", "else", "0", "if", "value", ":", "bits", "[", "index", "]", "|=", "mask", "else", ":", "bits", "[", "index", "]", "&=", "~", "mask", "self", ".", "redis", "[", "key", "]", "=", "bytes", "(", "bits", ")", "return", "prev_val" ]

[ "Set", "the", "bit", "at", "offset", "in", "key", "to", "value", "." ]

[ "def", "getbit", "(", "self", ",", "key", ",", "offset", ")", ":", "key", "=", "self", ".", "_encode", "(", "key", ")", "index", ",", "bits", ",", "mask", "=", "self", ".", "_get_bits_and_offset", "(", "key", ",", "offset", ")", "if", "index", ">=", "len", "(", "bits", ")", ":", "return", "0", "return", "1", "if", "(", "bits", "[", "index", "]", "&", "mask", ")", "else", "0" ]

[ "Returns", "the", "bit", "value", "at", "offset", "in", "key", "." ]

[ "def", "hexists", "(", "self", ",", "hashkey", ",", "attribute", ")", ":", "redis_hash", "=", "self", ".", "_get_hash", "(", "hashkey", ",", "'HEXISTS'", ")", "return", "self", ".", "_encode", "(", "attribute", ")", "in", "redis_hash" ]

[ "Emulate", "hexists", "." ]

[ "def", "hget", "(", "self", ",", "hashkey", ",", "attribute", ")", ":", "redis_hash", "=", "self", ".", "_get_hash", "(", "hashkey", ",", "'HGET'", ")", "return", "redis_hash", ".", "get", "(", "self", ".", "_encode", "(", "attribute", ")", ")" ]

[ "Emulate", "hget", "." ]

[ "def", "hmset", "(", "self", ",", "hashkey", ",", "value", ")", ":", "redis_hash", "=", "self", ".", "_get_hash", "(", "hashkey", ",", "'HMSET'", ",", "create", "=", "True", ")", "for", "key", ",", "value", "in", "value", ".", "items", "(", ")", ":", "attribute", "=", "self", ".", "_encode", "(", "key", ")", "redis_hash", "[", "attribute", "]", "=", "self", ".", "_encode", "(", "value", ")", "return", "True" ]

[ "Emulate", "hmset", "." ]

[ "def", "hmget", "(", "self", ",", "hashkey", ",", "keys", ",", "*", "args", ")", ":", "redis_hash", "=", "self", ".", "_get_hash", "(", "hashkey", ",", "'HMGET'", ")", "attributes", "=", "self", ".", "_list_or_args", "(", "keys", ",", "args", ")", "return", "[", "redis_hash", ".", "get", "(", "self", ".", "_encode", "(", "attribute", ")", ")", "for", "attribute", "in", "attributes", "]" ]

[ "Emulate", "hmget", "." ]

[ "def", "hset", "(", "self", ",", "hashkey", ",", "attribute", ",", "value", ")", ":", "redis_hash", "=", "self", ".", "_get_hash", "(", "hashkey", ",", "'HSET'", ",", "create", "=", "True", ")", "attribute", "=", "self", ".", "_encode", "(", "attribute", ")", "attribute_present", "=", "attribute", "in", "redis_hash", "redis_hash", "[", "attribute", "]", "=", "self", ".", "_encode", "(", "value", ")", "return", "long", "(", "0", ")", "if", "attribute_present", "else", "long", "(", "1", ")" ]

[ "Emulate", "hset", "." ]

[ "def", "hsetnx", "(", "self", ",", "hashkey", ",", "attribute", ",", "value", ")", ":", "redis_hash", "=", "self", ".", "_get_hash", "(", "hashkey", ",", "'HSETNX'", ",", "create", "=", "True", ")", "attribute", "=", "self", ".", "_encode", "(", "attribute", ")", "if", "attribute", "in", "redis_hash", ":", "return", "long", "(", "0", ")", "else", ":", "redis_hash", "[", "attribute", "]", "=", "self", ".", "_encode", "(", "value", ")", "return", "long", "(", "1", ")" ]

[ "Emulate", "hsetnx", "." ]

[ "def", "hincrby", "(", "self", ",", "hashkey", ",", "attribute", ",", "increment", "=", "1", ")", ":", "return", "self", ".", "_hincrby", "(", "hashkey", ",", "attribute", ",", "'HINCRBY'", ",", "long", ",", "increment", ")" ]

[ "Emulate", "hincrby", "." ]

[ "def", "hincrbyfloat", "(", "self", ",", "hashkey", ",", "attribute", ",", "increment", "=", "1.0", ")", ":", "return", "self", ".", "_hincrby", "(", "hashkey", ",", "attribute", ",", "'HINCRBYFLOAT'", ",", "float", ",", "increment", ")" ]

[ "Emulate", "hincrbyfloat", "." ]