easygraph.classes.graph module

class easygraph.classes.graph.Graph(incoming_graph_data=None, extra_selfloop=False, **graph_attr)

Bases: object

Base class for undirected graphs.

Nodes are allowed for any hashable Python objects, including int, string, dict, etc. Edges are stored as Python dict type, with optional key/value attributes.

Parameters:

graph_attr (keywords arguments, optional (default : None)) – Attributes to add to graph as key=value pairs.

See also

DiGraph

Examples

Create an empty undirected graph with no nodes and edges.

>>> G = eg.Graph()

Create a deep copy graph G2 from existing Graph G1.

>>> G2 = G1.copy()

Create an graph with attributes.

>>> G = eg.Graph(name='Karate Club', date='2020.08.21')

Attributes:

Returns the adjacency matrix of the graph.

>>> G.adj

Returns all the nodes with their attributes.

>>> G.nodes

Returns all the edges with their attributes.

>>> G.edges

Attributes:

A

Return the adjacency matrix \(\mathbf{A}\) of the sample graph with torch.sparse_coo_tensor format.

D_v

Return the diagonal matrix of vertex degree \(\mathbf{D}_v\) with torch.sparse_coo_tensor format.

D_v_neg_1_2

Return the normalized diagonal matrix of vertex degree \(\mathbf{D}_v^{-\frac{1}{2}}\) with torch.sparse_coo_tensor format.

L_GCN

Return the GCN Laplacian matrix \(\mathcal{L}_{GCN}\) of the graph with torch.sparse_coo_tensor format.

adj

Return the adjacency matrix

e

Return the edge list, weight list and property list in the graph.

e_both_side

Return the list of edges including both directions.

edges

Return an edge list

index2node

Assign an integer index for each node (start from 0)

name

String identifier of the graph.

ndata

node_index

Assign an integer index for each node (start from 0)

nodes

return [node for node in self._node]

Methods

add_edge(u_of_edge, v_of_edge, **edge_attr)	Add one edge.
add_edges(edges_for_adding[, edges_attr])	Add a list of edges.
add_edges_from(ebunch_to_add, **attr)	Add all the edges in ebunch_to_add.
add_edges_from_file(file[, weighted])	Added edges from file For example, txt files,
add_extra_selfloop()	Add extra selfloops to the graph.
add_node(node_for_adding, **node_attr)	Add one node
add_nodes(nodes_for_adding[, nodes_attr])	Add nodes with a list of nodes.
add_nodes_from(nodes_for_adding, **attr)	Add multiple nodes.
add_weighted_edge(u_of_edge, v_of_edge, weight)	Add a weighted edge
add_weighted_edges_from(ebunch_to_add[, weight])	Add weighted edges in ebunch_to_add with specified weight attr
adjlist_inner_dict_factory	alias of dict
adjlist_outer_dict_factory	alias of dict
all_neighbors(node)	Returns an iterator of a node's neighbors.
clone()	Clone the graph.
copy()	Return a deep copy of the graph.
degree([weight])	Returns the weighted degree of of each node.
edge_attr_dict_factory	alias of dict
ego_subgraph(center)	Returns an ego network graph of a node.
gnn_data_dict_factory	alias of dict
graph_attr_dict_factory	alias of dict
has_edge(u, v)	Returns whether an edge exists
has_node(node)	Returns whether a node exists
is_directed()	Returns True if graph is a directed_graph, False otherwise.
is_multigraph()	Returns True if graph is a multigraph, False otherwise.
nbr_v(v_idx)	Return a vertex list of the neighbors of the vertex v_idx.
nbunch_iter([nbunch])	Returns an iterator over nodes contained in nbunch that are also in the graph.
neighbors(node)	Returns an iterator of a node's neighbors.
node_attr_dict_factory	alias of dict
node_dict_factory	alias of dict
node_index_dict	alias of dict
nodes_subgraph(from_nodes)	Returns a subgraph of some nodes
number_of_edges([u, v])	Returns the number of edges between two nodes.
number_of_nodes()	Returns the number of nodes.
order()	Returns the number of nodes in the graph.
raw_selfloop_dict	alias of dict
remove_edge(u, v)	Remove one edge from your graph.
remove_edges(edges_to_remove)	Remove a list of edges from your graph.
remove_extra_selfloop()	Remove extra selfloops from the graph.
remove_node(node_to_remove)	Remove one node from your graph.
remove_nodes(nodes_to_remove)	Remove nodes from your graph.
remove_nodes_from(nodes)	Remove multiple nodes.
remove_selfloop()	Remove all selfloops from the graph.
size([weight])	Returns the number of edges or total of all edge weights.
smoothing_with_GCN(X[, drop_rate])	Return the smoothed feature matrix with GCN Laplacian matrix \(\mathcal{L}_{GCN}\).
to_directed()	Creates and returns a directed graph from self.
to_directed_class()	Returns the class to use for empty directed copies.
to_index_node_graph([begin_index])	Returns a deep copy of graph, with each node switched to its index.

N_v
cpp

property A

Return the adjacency matrix \(\mathbf{A}\) of the sample graph with torch.sparse_coo_tensor format. Size \((|\mathcal{V}|, |\mathcal{V}|)\).

property D_v

Return the diagonal matrix of vertex degree \(\mathbf{D}_v\) with torch.sparse_coo_tensor format. Size \((|\mathcal{V}|, |\mathcal{V}|)\).

property D_v_neg_1_2

Return the normalized diagonal matrix of vertex degree \(\mathbf{D}_v^{-\frac{1}{2}}\) with torch.sparse_coo_tensor format. Size \((|\mathcal{V}|, |\mathcal{V}|)\).

property L_GCN

Return the GCN Laplacian matrix \(\mathcal{L}_{GCN}\) of the graph with torch.sparse_coo_tensor format. Size \((|\mathcal{V}|, |\mathcal{V}|)\).

\[\mathcal{L}_{GCN} = \mathbf{\hat{D}}_v^{-\frac{1}{2}} \mathbf{\hat{A}} \mathbf{\hat{D}}_v^{-\frac{1}{2}}\]

N_v(v_idx: int) → Tuple[List[int], List[float]]

add_edge(u_of_edge, v_of_edge, **edge_attr)

Add one edge.

Parameters:

• u_of_edge (object) – One end of this edge

• v_of_edge (object) – The other one end of this edge

• edge_attr (keywords arguments, optional) – The attribute of the edge.

Notes

Nodes of this edge will be automatically added to the graph, if they do not exist.

See also

add_edges

Examples

>>> G.add_edge(1,2)
>>> G.add_edge('Jack', 'Tom', weight=10)

Add edge with attributes, edge weight, for example,

>>> G.add_edge(1, 2, **{
...     'weight': 20
... })

add_edges(edges_for_adding, edges_attr: List[Dict] = [])

Add a list of edges.

Parameters:

• edges_for_adding (list of 2-element tuple) – The edges for adding. Each element is a (u, v) tuple, and u, v are two ends of the edge.

• edges_attr (list of dict, optional) – The corresponding attributes for each edge in edges_for_adding.

Examples

Add a list of edges into G

>>> G.add_edges([
...     (1, 2),
...     (3, 4),
...     ('Jack', 'Tom')
... ])

Add edge with attributes, for example, edge weight,

>>> G.add_edges([(1,2), (2, 3)], edges_attr=[
...     {
...         'weight': 20
...     },
...     {
...         'weight': 15
...     }
... ])

add_edges_from(ebunch_to_add, **attr)

Add all the edges in ebunch_to_add.

Parameters:

• ebunch_to_add (container of edges) – Each edge given in the container will be added to the graph. The edges must be given as 2-tuples (u, v) or 3-tuples (u, v, d) where d is a dictionary containing edge data.

• attr (keyword arguments, optional) – Edge data (or labels or objects) can be assigned using keyword arguments.

See also

add_edge

add a single edge

add_weighted_edges_from

convenient way to add weighted edges

Notes

Adding the same edge twice has no effect but any edge data will be updated when each duplicate edge is added.

Edge attributes specified in an ebunch take precedence over attributes specified via keyword arguments.

Examples

>>> G = eg.Graph()  # or DiGraph, MultiGraph, MultiDiGraph, etc
>>> G.add_edges_from([(0, 1), (1, 2)])  # using a list of edge tuples
>>> e = zip(range(0, 3), range(1, 4))
>>> G.add_edges_from(e)  # Add the path graph 0-1-2-3

Associate data to edges

>>> G.add_edges_from([(1, 2), (2, 3)], weight=3)
>>> G.add_edges_from([(3, 4), (1, 4)], label="WN2898")

add_edges_from_file(file, weighted=False)

Added edges from file For example, txt files,

Each line is in form like: a b 23.0 which denotes an edge (a, b) with weight 23.0.

Parameters:

• file (string) – The file path.

• weighted (boolean, optional (default : False)) – If the file consists of weight information, set True. The weight key will be set as ‘weight’.

Examples

If ./club_network.txt is:

Jack Mary 23.0

Mary Tom 15.0

Tom Ben 20.0

Then add them to G

>>> G.add_edges_from_file(file='./club_network.txt', weighted=True)

add_extra_selfloop()

Add extra selfloops to the graph.

add_node(node_for_adding, **node_attr)

Add one node

Add one node, type of which is any hashable Python object, such as int, string, dict, or even Graph itself. You can add with node attributes using Python dict type.

Parameters:

• node_for_adding (any hashable Python object) – Nodes for adding.

• node_attr (keywords arguments, optional) – The node attributes. You can customize them with different key-value pairs.

See also

add_nodes

Examples

>>> G.add_node('a')
>>> G.add_node('hello world')
>>> G.add_node('Jack', age=10)

>>> G.add_node('Jack', **{
...     'age': 10,
...     'gender': 'M'
... })

add_nodes(nodes_for_adding: list, nodes_attr: List[Dict] = [])

Add nodes with a list of nodes.

Parameters:

• nodes_for_adding (list) –

• nodes_attr (list of dict) – The corresponding attribute for each of nodes_for_adding.

See also

add_node

Examples

Add nodes with a list of nodes. You can add with node attributes using a list of Python dict type, each of which is the attribute of each node, respectively.

>>> G.add_nodes([1, 2, 'a', 'b'])
>>> G.add_nodes(range(1, 200))

>>> G.add_nodes(['Jack', 'Tom', 'Lily'], nodes_attr=[
...     {
...         'age': 10,
...         'gender': 'M'
...     },
...     {
...         'age': 11,
...         'gender': 'M'
...     },
...     {
...         'age': 10,
...         'gender': 'F'
...     }
... ])

add_nodes_from(nodes_for_adding, **attr)

Add multiple nodes.

Parameters:

• nodes_for_adding (iterable container) – A container of nodes (list, dict, set, etc.). OR A container of (node, attribute dict) tuples. Node attributes are updated using the attribute dict.

• attr (keyword arguments, optional (default= no attributes)) – Update attributes for all nodes in nodes. Node attributes specified in nodes as a tuple take precedence over attributes specified via keyword arguments.

See also

add_node

Examples

>>> G = eg.Graph()  # or DiGraph, MultiGraph, MultiDiGraph, etc
>>> G.add_nodes_from("Hello")
>>> K3 = eg.Graph([(0, 1), (1, 2), (2, 0)])
>>> G.add_nodes_from(K3)
>>> sorted(G.nodes(), key=str)
[0, 1, 2, 'H', 'e', 'l', 'o']

Use keywords to update specific node attributes for every node.

>>> G.add_nodes_from([1, 2], size=10)
>>> G.add_nodes_from([3, 4], weight=0.4)

Use (node, attrdict) tuples to update attributes for specific nodes.

>>> G.add_nodes_from([(1, dict(size=11)), (2, {"color": "blue"})])
>>> G.nodes[1]["size"]
11
>>> H = eg.Graph()
>>> H.add_nodes_from(G.nodes(data=True))
>>> H.nodes[1]["size"]
11

add_weighted_edge(u_of_edge, v_of_edge, weight)

Add a weighted edge

Parameters:

• u_of_edge (start node) –

• v_of_edge (end node) –

• weight (weight value) –

Examples

Add a weighted edge

>>> G.add_weighted_edge( 1 , 3 , 1.0)

add_weighted_edges_from(ebunch_to_add, weight='weight', **attr)

Add weighted edges in ebunch_to_add with specified weight attr

Parameters:

• ebunch_to_add (container of edges) – Each edge given in the list or container will be added to the graph. The edges must be given as 3-tuples (u, v, w) where w is a number.

• weight (string, optional (default= 'weight')) – The attribute name for the edge weights to be added.

• attr (keyword arguments, optional (default= no attributes)) – Edge attributes to add/update for all edges.

See also

add_edge

add a single edge

add_edges_from

add multiple edges

Notes

Adding the same edge twice for Graph/DiGraph simply updates the edge data. For MultiGraph/MultiDiGraph, duplicate edges are stored.

Examples

>>> G = eg.Graph()  # or DiGraph, MultiGraph, MultiDiGraph, etc
>>> G.add_weighted_edges_from([(0, 1, 3.0), (1, 2, 7.5)])

property adj

Return the adjacency matrix

adjlist_inner_dict_factory

alias of dict

adjlist_outer_dict_factory

alias of dict

all_neighbors(node)

Returns an iterator of a node’s neighbors.

Parameters:

node (Hashable) – The target node.

Returns:

neighbors – An iterator of a node’s neighbors.

Return type:

iterator

Examples

>>> G = eg.Graph()
>>> G.add_edges([(1,2), (2,3), (2,4)])
>>> for neighbor in G.neighbors(node=2):
...     print(neighbor)

clone()

Clone the graph.

copy()

Return a deep copy of the graph.

Returns:

copy – A deep copy of the original graph.

Return type:

easygraph.Graph

Examples

G2 is a deep copy of G1

>>> G2 = G1.copy()

cpp()

degree(weight='weight')

Returns the weighted degree of of each node.

Parameters:

weight (string, optional (default: 'weight')) – Weight key of the original weighted graph.

Returns:

degree – Each node’s (key) weighted degree (value).

Return type:

dict

Notes

If the graph is not weighted, all the weights will be regarded as 1.

Examples

You can call with no attributes, if ‘weight’ is the weight key:

>>> G.degree()

if you have customized weight key ‘weight_1’.

>>> G.degree(weight='weight_1')

property e: Tuple[List[List[int]], List[float]]

Return the edge list, weight list and property list in the graph.

property e_both_side: Tuple[List[List], List[float]]

Return the list of edges including both directions.

edge_attr_dict_factory

alias of dict

property edges

Return an edge list

ego_subgraph(center)

Returns an ego network graph of a node.

Parameters:

center (object) – The center node of the ego network graph

Returns:

ego_subgraph – The ego network graph of center.

Return type:

easygraph.Graph

Examples

>>> G = eg.Graph()
>>> G.add_edges([
...     ('Jack', 'Maria'),
...     ('Maria', 'Andy'),
...     ('Jack', 'Tom')
... ])
>>> G.ego_subgraph(center='Jack')

gnn_data_dict_factory

alias of dict

graph_attr_dict_factory

alias of dict

has_edge(u, v)

Returns whether an edge exists

Parameters:

• u (start node) –

• v (end node) –

Returns:

Bool

Return type:

True (exist) or False (not exists)

has_node(node)

Returns whether a node exists

Parameters:

node –

Returns:

Bool

Return type:

True (exist) or False (not exists)

property index2node

Assign an integer index for each node (start from 0)

is_directed()

Returns True if graph is a directed_graph, False otherwise.

is_multigraph()

Returns True if graph is a multigraph, False otherwise.

property name

String identifier of the graph.

This graph attribute appears in the attribute dict G.graph keyed by the string “name”. as well as an attribute (technically a property) G.name. This is entirely user controlled.

nbr_v(v_idx: int) → Tuple[List[int], List[float]]

Return a vertex list of the neighbors of the vertex v_idx.

Parameters:

v_idx (int) – The index of the vertex.

nbunch_iter(nbunch=None)

Returns an iterator over nodes contained in nbunch that are also in the graph.

The nodes in nbunch are checked for membership in the graph and if not are silently ignored.

Parameters:

nbunch (single node, container, or all nodes (default= all nodes)) – The view will only report edges incident to these nodes.

Returns:

niter – An iterator over nodes in nbunch that are also in the graph. If nbunch is None, iterate over all nodes in the graph.

Return type:

iterator

Raises:

EasyGraphError – If nbunch is not a node or sequence of nodes. If a node in nbunch is not hashable.

See also

Graph.__iter__

Notes

When nbunch is an iterator, the returned iterator yields values directly from nbunch, becoming exhausted when nbunch is exhausted.

To test whether nbunch is a single node, one can use “if nbunch in self:”, even after processing with this routine.

If nbunch is not a node or a (possibly empty) sequence/iterator or None, a EasyGraphError is raised. Also, if any object in nbunch is not hashable, a EasyGraphError is raised.

property ndata

neighbors(node)

Returns an iterator of a node’s neighbors.

Parameters:

node (Hashable) – The target node.

Returns:

neighbors – An iterator of a node’s neighbors.

Return type:

iterator

Examples

>>> G = eg.Graph()
>>> G.add_edges([(1,2), (2,3), (2,4)])
>>> for neighbor in G.neighbors(node=2):
...     print(neighbor)

node_attr_dict_factory

alias of dict

node_dict_factory

alias of dict

property node_index

Assign an integer index for each node (start from 0)

node_index_dict

alias of dict

property nodes

return [node for node in self._node]

nodes_subgraph(from_nodes: list)

Returns a subgraph of some nodes

Parameters:

from_nodes (list of object) – The nodes in subgraph.

Returns:

nodes_subgraph – The subgraph consisting of from_nodes.

Return type:

easygraph.Graph

Examples

>>> G = eg.Graph()
>>> G.add_edges([(1,2), (2,3), (2,4), (4,5)])
>>> G_sub = G.nodes_subgraph(from_nodes= [1,2,3])

number_of_edges(u=None, v=None)

Returns the number of edges between two nodes.

Parameters:

• u (nodes, optional (default=all edges)) – If u and v are specified, return the number of edges between u and v. Otherwise return the total number of all edges.

• v (nodes, optional (default=all edges)) – If u and v are specified, return the number of edges between u and v. Otherwise return the total number of all edges.

Returns:

nedges – The number of edges in the graph. If nodes u and v are specified return the number of edges between those nodes. If the graph is directed, this only returns the number of edges from u to v.

Return type:

int

See also

size

Examples

For undirected graphs, this method counts the total number of edges in the graph:

>>> G = eg.path_graph(4)
>>> G.number_of_edges()
3

If you specify two nodes, this counts the total number of edges joining the two nodes:

>>> G.number_of_edges(0, 1)
1

For directed graphs, this method can count the total number of directed edges from u to v:

>>> G = eg.DiGraph()
>>> G.add_edge(0, 1)
>>> G.add_edge(1, 0)
>>> G.number_of_edges(0, 1)
1

number_of_nodes()

Returns the number of nodes.

Returns:

number_of_nodes – The number of nodes.

Return type:

int

order()

Returns the number of nodes in the graph.

Returns:

nnodes – The number of nodes in the graph.

Return type:

int

See also

number_of_nodes

identical method

__len__

identical method

Examples

>>> G = eg.path_graph(3)  # or DiGraph, MultiGraph, MultiDiGraph, etc
>>> G.order()
3

raw_selfloop_dict

alias of dict

remove_edge(u, v)

Remove one edge from your graph.

Parameters:

• u (object) – One end of the edge.

• v (object) – The other end of the edge.

See also

remove_edges

Examples

Remove edge (1,2) from G

>>> G.remove_edge(1,2)

remove_edges(edges_to_remove: [<class 'tuple'>])

Remove a list of edges from your graph.

Parameters:

edges_to_remove (list of tuple) – The list of edges you want to remove, Each element is (u, v) tuple, which denote the two ends of the edge.

See also

remove_edge

Examples

Remove the edges (‘Jack’, ‘Mary’) and (‘Mary’, ‘Tom’) from G

>>> G.remove_edge([
...     ('Jack', 'Mary'),
...     ('Mary', 'Tom')
... ])

remove_extra_selfloop()

Remove extra selfloops from the graph.

remove_node(node_to_remove)

Remove one node from your graph.

Parameters:

node_to_remove (object) – The node you want to remove.

See also

remove_nodes

Examples

Remove node Jack from G

>>> G.remove_node('Jack')

remove_nodes(nodes_to_remove: list)

Remove nodes from your graph.

Parameters:

nodes_to_remove (list of object) – The list of nodes you want to remove.

See also

remove_node

Examples

Remove node [1, 2, ‘a’, ‘b’] from G

>>> G.remove_nodes([1, 2, 'a', 'b'])

remove_nodes_from(nodes)

Remove multiple nodes.

Parameters:

nodes (iterable container) – A container of nodes (list, dict, set, etc.). If a node in the container is not in the graph it is silently ignored.

See also

remove_node

Examples

>>> G = eg.path_graph(3)  # or DiGraph, MultiGraph, MultiDiGraph, etc
>>> e = list(G.nodes)
>>> e
[0, 1, 2]
>>> G.remove_nodes_from(e)
>>> list(G.nodes)
[]

remove_selfloop()

Remove all selfloops from the graph.

size(weight=None)

Returns the number of edges or total of all edge weights.

Parameters:

weight (String or None, optional) – The weight key. If None, it will calculate the number of edges, instead of total of all edge weights.

Returns:

size – The number of edges or total of all edge weights.

Return type:

int or float, optional (default: None)

Examples

Returns the number of edges in G:

>>> G.size()

Returns the total of all edge weights in G:

>>> G.size(weight='weight')

smoothing_with_GCN(X, drop_rate=0.0)

Return the smoothed feature matrix with GCN Laplacian matrix \(\mathcal{L}_{GCN}\).

Parameters:

• X (torch.Tensor) – Vertex feature matrix. Size \((|\mathcal{V}|, C)\).

• drop_rate (float) – Dropout rate. Randomly dropout the connections in adjacency matrix with probability drop_rate. Default: 0.0.

to_directed()

Creates and returns a directed graph from self.

Returns:

G – A directed graph with identical name and nodes. Each undirected edge (u, v, data) in the original graph is replaced by two directed edges (u, v, data) and (v, u, data).

Return type:

DiGraph

Notes

This function returns a deepcopy of the original graph, including all nodes, edges, and graph. As a result, it fully duplicates the data and references in the original graph.

This function differs from D=DiGraph(G) which returns a shallow copy.

For more details on shallow and deep copies, refer to the Python copy module: https://docs.python.org/3/library/copy.html.

Warning: If the original graph is a subclass of Graph using custom dict-like objects for its data structure, those customizations will not be preserved in the DiGraph created by this function.

Examples

Converting an undirected graph to a directed graph:

>>> G = eg.Graph()  # or MultiGraph, etc
>>> G.add_edge(0, 1)
>>> H = G.to_directed()
>>> list(H.edges)
[(0, 1), (1, 0)]

Creating a deep copy of an already directed graph:

>>> G = eg.DiGraph()  # or MultiDiGraph, etc
>>> G.add_edge(0, 1)
>>> H = G.to_directed()
>>> list(H.edges)
[(0, 1)]

to_directed_class()

Returns the class to use for empty directed copies.

If you subclass the base classes, use this to designate what directed class to use for to_directed() copies.

to_index_node_graph(begin_index=0)

Returns a deep copy of graph, with each node switched to its index.

Considering that the nodes of your graph may be any possible hashable Python object, you can get an isomorphic graph of the original one, with each node switched to its index.

Parameters:

begin_index (int) – The begin index of the index graph.

Returns:

• G (easygraph.Graph) – Deep copy of graph, with each node switched to its index.

• index_of_node (dict) – Index of node

• node_of_index (dict) – Node of index

Examples

The following method returns this isomorphic graph and index-to-node dictionary as well as node-to-index dictionary.

>>> G = eg.Graph()
>>> G.add_edges([
...     ('Jack', 'Maria'),
...     ('Maria', 'Andy'),
...     ('Jack', 'Tom')
... ])
>>> G_index_graph, index_of_node, node_of_index = G.to_index_node_graph()

class easygraph.classes.graph.GraphC

Bases: Graph

Attributes:

adj

edges

graph

name

node_index

nodes

Methods

add_edge(*args, **kwargs)
add_edges(self, edges_for_adding[, edges_attr])
add_edges_from(*args, **kwargs)
add_edges_from_file(self, file[, weighted, ...])
add_node(*args, **kwargs)
add_nodes(self, nodes_for_adding[, nodes_attr])
add_nodes_from(*args, **kwargs)
add_weighted_edge(self, u_of_edge, ...)
all_neighbors(self, node)
copy(self)
degree(self[, weight])
ego_subgraph(self, center)
generate_linkgraph(self[, weight])
has_edge(self, u, y)
has_node(self, node)
is_directed(self)
is_multigraph(self)
nbunch_iter(self[, nbunch])
neighbors(self, node)
nodes_subgraph(self, from_nodes)
number_of_edges(self[, u, v])
number_of_nodes(self)
py(self)
remove_edge(self, u, v)
remove_edges(self, edges_to_remove)
remove_node(self, node_to_remove)
remove_nodes(self, nodes_to_remove)
size(self[, weight])
to_index_node_graph(self[, begin_index])

cflag = 1