py3plex.core package

Submodules

py3plex.core.converters module

py3plex.core.converters.prepare_for_parsing(multinet)

Compute layout for a hairball visualization

Args:

param1 (obj): multilayer object

Returns:

tuple: (names, prepared network)

py3plex.core.converters.prepare_for_visualization(multinet, compute_layouts='force', layout_parameters=None, verbose=True, multiplex=False)

This functions takes a multilayer object and returns individual layers, their names, as well as multilayer edges spanning over multiple layers.

Args:

param1 (obj): multilayer object param2 (str): Layout algorithm param3 (dict): Optional layout parameters

Returns:

tuple: (names,networks,multiedges)

py3plex.core.converters.prepare_for_visualization_hairball(multinet, compute_layouts=False)

Compute layout for a hairball visualization

Args:

param1 (obj): multilayer object

Returns:

tuple: (names, prepared network)

py3plex.core.multinet module

class py3plex.core.multinet.multi_layer_network(verbose=True, network_type='multilayer', directed=True, dummy_layer='null', label_delimiter='---', coupling_weight=1)

Bases: object

add_dummy_layers()

Internal function, for conversion between objects

add_edges(edge_dict_list, input_type='dict')

A method for adding edges.. Types are: dict,list or px_edge. See examples for further use.

dict = {“source”: n1,”target”:n2,”type”:sth}

list = [[n1,t1,n2,t2] …]

px_edge = ((n1,t1)(n2,t2))

add_nodes(node_dict_list, input_type='dict')

A method for adding nodes..

aggregate_edges(metric='count', normalize_by='degree')
basic_stats(target_network=None)

A method for obtaining a network’s statistics

edges_from_temporal_table(edge_df)
fill_tmp_with_edges(edge_df)
get_decomposition(heuristic='all', cycle=None, parallel=True, alpha=1, beta=1)

Core method for obtaining a network’s decomposition in terms of relations

get_decomposition_cycles(cycle=None)

A supporting method for obtaining decomposition triplets

get_degrees()

A simple wrapper which computes node degrees.

get_edges(data=False, multiplex_edges=False)

A method for obtaining a network’s edges

get_label_matrix()

Return network labels

get_layers(style='diagonal', compute_layouts='force', layout_parameters=None, verbose=True)

A method for obtaining layerwise distributions

get_neighbors(node_id, layer_id=None)
get_nodes(data=False)

A method for obtaining a network’s nodes

get_nx_object()

Return only core network with proper annotations

get_supra_adjacency_matrix(mtype='sparse')

Get sparse representation of the supra matrix.

get_tensor(sparsity_type='bsr')

TODO

get_unique_entity_counts()
Input

self object

invert(override_core=False)

invert the nodes to edges. Get the “edge graph”. Each node is here an edge.

load_embedding(embedding_file)

Embedding loading method

load_layer_name_mapping(mapping_name, header=False)

Layer-node mapping loader method

Args:

param1: The name of the mapping file.

Returns:

self.layer_name_map is filled, returns nothing.

load_network(input_file=None, directed=False, input_type='gml', label_delimiter='---')

Main network loader

This method loads and prepares a given network.

Args:

param1: network name param2: direction param3: input_type

Returns:

self.core_network along with self.labels(optional), self.activity etc.

load_network_activity(activity_file)

Network activity loader

Args:

param1: The name of the generic activity file -> 65432 61888 1377688175 RE

, n1 n2 timestamp and layer name. Note that layer node mappings MUST be loaded in order to map nodes to activity properly.

Returns:

self.activity is filled.

load_temporal_edge_information(input_file=None, input_type='edge_activity', directxed=False, layer_mapping=None)

A method for loading temporal edge information

merge_with(target_px_object)

Merge two px objects.

monitor(message)

A simple monithor method

monoplex_nx_wrapper(method, kwargs=None)

a generic networkx function wrapper

read_ground_truth_communities(cfile)

Parse ground truth community file and make mappings to the original nodes. This works based on node ID mappings, exact node,layer tuplets are to be added. Args:

param1: ground truth communities.

Returns:

self.ground_truth_communities

remove_edges(edge_dict_list, input_type='list')

A method for removing edges..

remove_layer_edges()
remove_nodes(node_dict_list, input_type='dict')

Remove nodes from the network

save_network(output_file=None, output_type='edgelist')

A method for saving the network :param output_type – edgelist, multiedgelist or gpickle

serialize_to_edgelist(edgelist_file='./tmp/tmpedgelist.txt', tmp_folder='tmp', out_folder='out', multiplex=False)
sparse_to_px(directed=None)

convert to px format

split_to_layers(style='diagonal', compute_layouts='force', layout_parameters=None, verbose=True, multiplex=False, convert_to_simple=False)

A method for obtaining layerwise distributions

subnetwork(input_list=None, subset_by='node_layer_names')

Construct a subgraph based on a set of nodes.

summary()

Generate a short summary of the network in form of a dict.

test_scale_free()

Test the scale-free-nness of the network

to_json()

A method for exporting the graph to a json file

Args: self

to_sparse_matrix(replace_core=False, return_only=False)

Conver the matrix to scipy-sparse version. This is useful for classification.

visualize_matrix(kwargs={})

Plot the matrix – this plots the supra-adjacency matrix

visualize_network(style='diagonal', parameters_layers=None, parameters_multiedges=None, show=False, compute_layouts='force', layouts_parameters=None, verbose=True, orientation='upper', resolution=0.01, axis=None, fig=None, no_labels=False)

py3plex.core.parsers module

py3plex.core.parsers.load_edge_activity_file(fname, layer_mapping=None)
py3plex.core.parsers.load_edge_activity_raw(activity_file, layer_mappings)

Basic parser for loading generic activity files. Here, temporal edges are given as tuples -> this can be easily transformed for example into a pandas dataframe!

py3plex.core.parsers.load_temporal_edge_information(input_network, input_type, layer_mapping=None)
py3plex.core.parsers.parse_detangler_json(file_path)

Parser for generic Detangler files :input: Detangler JSON

py3plex.core.parsers.parse_edgelist_multi_types(input_name, directed)
py3plex.core.parsers.parse_embedding(input_name)

Loader for generic embedding as outputed by GenSim

py3plex.core.parsers.parse_gml(file_name, directed)

parse a gml network

Args:

param1 (obj): file name param2 (obj): directed?

Returns: (multigraph, possible labels)

py3plex.core.parsers.parse_gpickle(file_name, directed=False, layer_separator=None)

A parser for generic Gpickle as stored by Py3plex. :input: gpickle object

py3plex.core.parsers.parse_gpickle_biomine(file_name, directed)

Gpickle parser for biomine graphs :input: Gpickle containing BioMine data

py3plex.core.parsers.parse_matrix(file_name, directed)

Parser for matrices :input: a SciPy sparse matrix

py3plex.core.parsers.parse_multi_edgelist(input_name, directed)

A generic multiedgelist parser n l n l w :input: a text file containing multiedges

py3plex.core.parsers.parse_multiedge_tuple_list(network, directed)
py3plex.core.parsers.parse_multiplex_edges(input_name, directed)
py3plex.core.parsers.parse_multiplex_folder(input_folder, directed)
py3plex.core.parsers.parse_network(input_name, f_type='gml', directed=False, label_delimiter=None, network_type='multilayer')

A wrapper method for available parsers!

py3plex.core.parsers.parse_nx(nx_object, directed)

Core parser for networkx objects :input: a networkx graph

py3plex.core.parsers.parse_simple_edgelist(input_name, directed)

Simple edgelist n n w :input: a text file

py3plex.core.parsers.parse_spin_edgelist(input_name, directed)
py3plex.core.parsers.save_edgelist(input_network, output_file, attributes=False)
py3plex.core.parsers.save_gpickle(input_network, output_file)
py3plex.core.parsers.save_multiedgelist(input_network, output_file, attributes=False, encode_with_ints=False)

Save multiedgelist – as n1, l1, n2, l2, w

py3plex.core.supporting module

py3plex.core.supporting.add_mpx_edges(input_network)
py3plex.core.supporting.parse_gaf_to_uniprot_GO(gaf_mappings, filter_terms=None)
py3plex.core.supporting.split_to_layers(input_network)

Module contents