"""Class representing a sequence of vertices in the graph.

def attributes(self):

"""Returns the list of all the vertex attributes in the graph

return self.graph.vertex_attributes()

def find(self, *args, **kwds):

"""Returns the first vertex of the vertex sequence that matches some

# Shortcut: if "name" is in kwds, there are no positional arguments,

# and the specified name is a string, we try that first because that

# attribute is indexed. Note that we cannot do this if name is an

# integer, because it would then translate to g.vs.select(name), which

# searches by _index_ if the argument is an integer

if not args:

if "name" in kwds:

name = kwds.pop("name")

elif "name_eq" in kwds:

name = kwds.pop("name_eq")

else:

name = None

if name is not None:

if isinstance(name, str):

args = [name]

else:

# put back what we popped

kwds["name"] = name

if args:

# Selecting first based on positional arguments, then checking

# the criteria specified by the (remaining) keyword arguments

vertex = _VertexSeq.find(self, *args)

if not kwds:

return vertex

vs = self.graph.vs.select(vertex.index)

else:

vs = self

# Selecting based on keyword arguments

vs = vs.select(**kwds)

if vs:

return vs[0]

raise ValueError("no such vertex")

def select(self, *args, **kwds):

"""Selects a subset of the vertex sequence based on some criteria

vs = _VertexSeq.select(self, *args)

operators = {

"lt": operator.lt,

"gt": operator.gt,

"le": operator.le,

"ge": operator.ge,

"eq": operator.eq,

"ne": operator.ne,

"in": lambda a, b: a in b,

"notin": lambda a, b: a not in b,

}

for keyword, value in kwds.items():

if "_" not in keyword or keyword.rindex("_") == 0:

keyword += "_eq"

attr, _, op = keyword.rpartition("_")

try:

func = operators[op]

except KeyError:

# No such operator, assume that it's part of the attribute name

attr, op, func = keyword, "eq", operators["eq"]

if attr[0] == "_":

# Method call, not an attribute

values = getattr(vs.graph, attr[1:])(vs)

else:

values = vs[attr]

filtered_idxs = [i for i, v in enumerate(values) if func(v, value)]

vs = vs.select(filtered_idxs)

return vs

def __call__(self, *args, **kwds):

"""Shorthand notation to select()

"""Class representing a sequence of edges in the graph.

def attributes(self):

"""Returns the list of all the edge attributes in the graph

return self.graph.edge_attributes()

def find(self, *args, **kwds):

"""Returns the first edge of the edge sequence that matches some

if args:

# Selecting first based on positional arguments, then checking

# the criteria specified by the keyword arguments

edge = _EdgeSeq.find(self, *args)

if not kwds:

return edge

es = self.graph.es.select(edge.index)

else:

es = self

# Selecting based on positional arguments

es = es.select(**kwds)

if es:

return es[0]

raise ValueError("no such edge")

def select(self, *args, **kwds):

"""Selects a subset of the edge sequence based on some criteria

es = _EdgeSeq.select(self, *args)

is_directed = self.graph.is_directed()

def _ensure_set(value):

if isinstance(value, VertexSeq):

value = {v.index for v in value}

elif not isinstance(value, (set, frozenset)):

value = set(value)

return value

operators = {

"lt": operator.lt,

"gt": operator.gt,

"le": operator.le,

"ge": operator.ge,

"eq": operator.eq,

"ne": operator.ne,

"in": lambda a, b: a in b,

"notin": lambda a, b: a not in b,

}

# TODO(ntamas): some keyword arguments should be prioritized over

# others; for instance, we have optimized code paths for _source and

# _target in directed and undirected graphs if es.is_all() is True;

# these should be executed first. This matters only if there are

# multiple keyword arguments and es.is_all() is True.

for keyword, value in kwds.items():

if "_" not in keyword or keyword.rindex("_") == 0:

keyword += "_eq"

pos = keyword.rindex("_")

attr, op = keyword[0:pos], keyword[pos + 1 :]

try:

func = operators[op]

except KeyError:

# No such operator, assume that it's part of the attribute name

attr, op, func = keyword, "eq", operators["eq"]

if attr[0] == "_":

if attr in ("_source", "_from", "_target", "_to") and not is_directed:

if op not in ("eq", "in"):

raise RuntimeError("unsupported for undirected graphs")

# translate to _incident to avoid confusion

attr = "_incident"

if func == operators["eq"]:

if hasattr(value, "__iter__") and not isinstance(value, str):

value = set(value)

else:

value = {value}

if attr in ("_source", "_from"):

if es.is_all() and op == "eq":

# shortcut here: use .incident() as it is much faster

filtered_idxs = sorted(es.graph.incident(value, mode="out"))

func = None

# TODO(ntamas): there are more possibilities; we could

# optimize "ne", "in" and "notin" in similar ways

else:

values = [e.source for e in es]

if op == "in" or op == "notin":

value = _ensure_set(value)

elif attr in ("_target", "_to"):

if es.is_all() and op == "eq":

# shortcut here: use .incident() as it is much faster

filtered_idxs = sorted(es.graph.incident(value, mode="in"))

func = None

# TODO(ntamas): there are more possibilities; we could

# optimize "ne", "in" and "notin" in similar ways

else:

values = [e.target for e in es]

if op == "in" or op == "notin":

value = _ensure_set(value)

elif attr == "_incident":

func = None # ignoring function, filtering here

value = _ensure_set(value)

# Fetch all the edges that are incident on at least one of

# the vertices specified

candidates = set()

for v in value:

candidates.update(es.graph.incident(v, mode="all"))

if not es.is_all():

# Find those that are in the current edge sequence

filtered_idxs = [

i for i, e in enumerate(es) if e.index in candidates

]

else:

# We are done, the filtered indexes are in the candidates set

filtered_idxs = sorted(candidates)

elif attr == "_within":

func = None # ignoring function, filtering here

value = _ensure_set(value)

# Fetch all the edges that are incident on at least one of

# the vertices specified

candidates = set()

for v in value:

candidates.update(es.graph.incident(v))

if not es.is_all():

# Find those where both endpoints are OK

filtered_idxs = [

i

for i, e in enumerate(es)

if e.index in candidates

and e.source in value

and e.target in value

]

else:

# Optimized version when the edge sequence contains all

# the edges exactly once in increasing order of edge IDs

filtered_idxs = [

i

for i in candidates

if es[i].source in value and es[i].target in value

]

elif attr == "_between":

if len(value) != 2:

raise ValueError(

"_between selector requires two vertex ID lists"

)

func = None # ignoring function, filtering here

set1 = _ensure_set(value[0])

set2 = _ensure_set(value[1])

# Fetch all the edges that are incident on at least one of

# the vertices specified

candidates = set()

for v in set1:

candidates.update(es.graph.incident(v))

for v in set2:

candidates.update(es.graph.incident(v))

if not es.is_all():

# Find those where both endpoints are OK

filtered_idxs = [

i

for i, e in enumerate(es)

if (e.source in set1 and e.target in set2)

or (e.target in set1 and e.source in set2)

]

else:

# Optimized version when the edge sequence contains all

# the edges exactly once in increasing order of edge IDs

filtered_idxs = [

i

for i in candidates

if (es[i].source in set1 and es[i].target in set2)

or (es[i].target in set1 and es[i].source in set2)

]

else:

# Method call, not an attribute

values = getattr(es.graph, attr[1:])(es)

else:

values = es[attr]

# If we have a function to apply on the values, do that; otherwise

# we assume that filtered_idxs has already been calculated.

if func is not None:

filtered_idxs = [i for i, v in enumerate(values) if func(v, value)]

es = es.select(filtered_idxs)

return es

def __call__(self, *args, **kwds):

"""Shorthand notation to select()

"""Auxiliary decorator

# Delay import to avoid cycles

from igraph import Graph

if name is None:

name = func.__name__

method = getattr(Graph, name)

if callable(func):

def decorated(*args, **kwds):

self = args[0].graph

return func(args[0], method(self, *args, **kwds))

else:

def decorated(*args, **kwds):

self = args[0].graph

return method(self, *args, **kwds)

decorated.__name__ = name

decorated.__doc__ = """Proxy method to L{Graph.%(name)s()}

""" % {"name": name}

# Proxy methods for VertexSeq and EdgeSeq that forward their arguments to

# the corresponding Graph method are constructed here. Proxy methods for

# Vertex and Edge are added in the C source code. Make sure that you update

# the C source whenever you add a proxy method here if that makes sense for

# an individual vertex or edge

decorated_methods = {}

decorated_methods[VertexSeq] = [

"degree",

"betweenness",

"bibcoupling",

"closeness",

"cocitation",

"constraint",

"distances",

"diversity",

"eccentricity",

"get_shortest_paths",

"maxdegree",

"pagerank",

"personalized_pagerank",

"shortest_paths",

"similarity_dice",

"similarity_jaccard",

"subgraph",

"indegree",

"outdegree",

"isoclass",

"delete_vertices",

"is_separator",

"is_minimal_separator",

]

decorated_methods[EdgeSeq] = [

"count_multiple",

"delete_edges",

"is_loop",

"is_multiple",

"is_mutual",

"subgraph_edges",

]

rename_methods = {}

rename_methods[VertexSeq] = {"delete_vertices": "delete"}

rename_methods[EdgeSeq] = {"delete_edges": "delete", "subgraph_edges": "subgraph"}

for cls, methods in decorated_methods.items():

for method in methods:

new_method_name = rename_methods[cls].get(method, method)

setattr(cls, new_method_name, _graphmethod(None, method))

EdgeSeq.edge_betweenness = _graphmethod(

lambda self, result: [result[i] for i in self.indices], "edge_betweenness"