Merge 6e1e5c0 into d8d83e6

networkx/algorithms/distance_regular.py

@@ -148,7 +148,7 @@ def intersection_array(G):
     global_parameters
     """
     # test for regular graph (all degrees must be equal)
-    degree = G.degree()
+    degree = iter(G.degree())
     (_, k) = next(degree)
     for _, knext in degree:
         if knext != k:

networkx/algorithms/euler.py

@@ -74,7 +74,7 @@ def _simplegraph_eulerian_circuit(G, source):
             last_vertex = current_vertex
             vertex_stack.pop()
         else:
-            _, next_vertex = next(edges(current_vertex))
+            _, next_vertex = arbitrary_element(edges(current_vertex))
             vertex_stack.append(next_vertex)
             G.remove_edge(current_vertex, next_vertex)
 
@@ -97,7 +97,7 @@ def _multigraph_eulerian_circuit(G, source):
             last_vertex, last_key = current_vertex, current_key
             vertex_stack.pop()
         else:
-            _, next_vertex, next_key = next(edges(current_vertex, keys=True))
+            _, next_vertex, next_key = arbitrary_element(edges(current_vertex, keys=True))
             vertex_stack.append((next_vertex, next_key))
             G.remove_edge(current_vertex, next_vertex, next_key)
 

networkx/algorithms/traversal/edgedfs.py

@@ -167,7 +167,7 @@ def edge_dfs(G, source=None, orientation='original'):
         while stack:
             current_node = stack[-1]
             if current_node not in visited_nodes:
-                edges[current_node] = out_edges(current_node, **kwds)
+                edges[current_node] = iter(out_edges(current_node, **kwds))
                 visited_nodes.add(current_node)
 
             try:

networkx/classes/__init__.py

@@ -2,6 +2,7 @@
 from .digraph import DiGraph
 from .multigraph import MultiGraph
 from .multidigraph import MultiDiGraph
+from .views import *
 from .ordered import *
 
 from .function import *

networkx/classes/digraph.py

@@ -8,6 +8,8 @@
 from copy import deepcopy
 import networkx as nx
 from networkx.classes.graph import Graph
+from networkx.classes.views import OutEdgeView, InEdgeView, \
+        DiDegreeView, InDegreeView, OutDegreeView
 from networkx.exception import NetworkXError
 import networkx.convert as convert
 __author__ = """\n""".join(['Aric Hagberg (hagberg@lanl.gov)',
@@ -787,23 +789,7 @@ def edges(self, nbunch=None, data=False, default=None):
         [(0, 1)]
 
         """
-        if nbunch is None:
-            nodes_nbrs=self.adj.items()
-        else:
-            nodes_nbrs=((n,self.adj[n]) for n in self.nbunch_iter(nbunch))
-        if data is True:
-            for n,nbrs in nodes_nbrs:
-                for nbr,ddict in nbrs.items():
-                    yield (n,nbr,ddict)
-        elif data is not False:
-            for n,nbrs in nodes_nbrs:
-                for nbr,ddict in nbrs.items():
-                    d=ddict[data] if data in ddict else default
-                    yield (n,nbr,d)
-        else:
-            for n,nbrs in nodes_nbrs:
-                for nbr in nbrs:
-                    yield (n,nbr)
+        return OutEdgeView(self, nbunch, data, default)
 
     # alias out_edges to edges
     out_edges = edges
@@ -824,8 +810,6 @@ def in_edges(self, nbunch=None, data=False, default=None):
             Value used for edges that dont have the requested attribute.
             Only relevant if data is not True or False.
 
-
-
         Returns
         -------
         in_edge : iterator
@@ -835,23 +819,7 @@ def in_edges(self, nbunch=None, data=False, default=None):
         --------
         edges : return an iterator over edges
         """
-        if nbunch is None:
-            nodes_nbrs=self.pred.items()
-        else:
-            nodes_nbrs=((n,self.pred[n]) for n in self.nbunch_iter(nbunch))
-        if data is True:
-            for n,nbrs in nodes_nbrs:
-                for nbr,data in nbrs.items():
-                    yield (nbr,n,data)
-        elif data is not False:
-            for n,nbrs in nodes_nbrs:
-                for nbr,ddict in nbrs.items():
-                    d=ddict[data] if data in ddict else default
-                    yield (nbr,n,d)
-        else:
-            for n,nbrs in nodes_nbrs:
-                for nbr in nbrs:
-                    yield (nbr,n)
+        return InEdgeView(self, nbunch, data, default)
 
 
     def degree(self, nbunch=None, weight=None):
@@ -897,31 +865,11 @@ def degree(self, nbunch=None, weight=None):
 
         """
         # Test to see if nbunch is a single node, an iterator of nodes or
-        # None(indicating all nodes). (nbunch in self) is True when nbunch
-        # is a single node.
+        # None(indicating all nodes). (nbunch in self) means a single node.
         if nbunch in self:
-            succ = self.succ[nbunch]
-            pred = self.pred[nbunch]
-            if weight is None:
-                return len(succ) + len(pred)
-            return sum(data.get(weight, 1) for data in succ.values()) + \
-                   sum(data.get(weight, 1) for data in pred.values())
-
-        if nbunch is None:
-            nodes_nbrs=( (n,succs,self.pred[n]) for n,succs in self.succ.items())
-        else:
-            nodes_nbrs=( (n,self.succ[n],self.pred[n]) for n in self.nbunch_iter(nbunch))
-        if weight is None:
-            def d_iter():
-                for n,succ,pred in nodes_nbrs:
-                    yield (n,len(succ)+len(pred))
-        else:
-            def d_iter():
-                for n,succ,pred in nodes_nbrs:
-                    yield (n,
-                      sum((data.get(weight,1) for data in succ.values()))+
-                      sum((data.get(weight,1) for data in pred.values())))
-        return d_iter()
+            deg = DiDegreeView(self, weight)
+            return deg[nbunch]
+        return DiDegreeView(self, weight, nbunch)
 
 
     def in_degree(self, nbunch=None, weight=None):
@@ -967,29 +915,11 @@ def in_degree(self, nbunch=None, weight=None):
 
         """
         # Test to see if nbunch is a single node, an iterator of nodes or
-        # None(indicating all nodes). (nbunch in self) is True when nbunch
-        # is a single node.
+        # None(indicating all nodes). (nbunch in self) means a single node.
         if nbunch in self:
-            pred = self.pred[nbunch]
-            if weight is None:
-                return len(pred)
-            return sum(data.get(weight, 1) for data in pred.values())
-
-        if nbunch is None:
-            nodes_nbrs=self.pred.items()
-        else:
-            nodes_nbrs=((n,self.pred[n]) for n in self.nbunch_iter(nbunch))
-
-        if weight is None:
-            def d_iter():
-                for n,nbrs in nodes_nbrs:
-                    yield (n,len(nbrs))
-        else:
-        # edge weighted graph - degree is sum of edge weights
-            def d_iter():
-                for n,nbrs in nodes_nbrs:
-                    yield (n, sum(data.get(weight,1) for data in nbrs.values()))
-        return d_iter()
+            deg = InDegreeView(self, weight)
+            return deg[nbunch]
+        return InDegreeView(self, weight, nbunch)
 
 
     def out_degree(self, nbunch=None, weight=None):
@@ -1035,29 +965,11 @@ def out_degree(self, nbunch=None, weight=None):
 
         """
         # Test to see if nbunch is a single node, an iterator of nodes or
-        # None(indicating all nodes). (nbunch in self) is True when nbunch
-        # is a single node.
+        # None(indicating all nodes). (nbunch in self) means a single node.
         if nbunch in self:
-            succ = self.succ[nbunch]
-            if weight is None:
-                return len(succ)
-            return sum(data.get(weight, 1) for data in succ.values())
-
-        if nbunch is None:
-            nodes_nbrs=self.succ.items()
-        else:
-            nodes_nbrs=((n,self.succ[n]) for n in self.nbunch_iter(nbunch))
-
-        if weight is None:
-            def d_iter():
-                for n,nbrs in nodes_nbrs:
-                    yield (n,len(nbrs))
-        else:
-        # edge weighted graph - degree is sum of edge weights
-            def d_iter():
-                for n,nbrs in nodes_nbrs:
-                    yield (n, sum(data.get(weight,1) for data in nbrs.values()))
-        return d_iter()
+            deg = OutDegreeView(self, weight)
+            return deg[nbunch]
+        return OutDegreeView(self, weight, nbunch)
 
     def clear(self):
         """Remove all nodes and edges from the graph.

networkx/classes/graph.py

@@ -16,6 +16,7 @@
 from __future__ import division
 from copy import deepcopy
 import networkx as nx
+from networkx.classes.views import NodeView, EdgeView, DegreeView
 from networkx.exception import NetworkXError
 import networkx.convert as convert
 from networkx.utils import pairwise
@@ -669,16 +670,7 @@ def nodes(self, data=False, default=None):
             {0: 1, 1: 2, 2: 3}
 
         """
-        if data is True:
-            for n, ddict in self.node.items():
-                yield (n, ddict)
-        elif data is not False:
-            for n, ddict in self.node.items():
-                d = ddict[data] if data in ddict else default
-                yield (n, d)
-        else:
-            for n in self.node:
-                yield n
+        return NodeView(self, data, default)
 
     def number_of_nodes(self):
         """Return the number of nodes in the graph.
@@ -1095,31 +1087,7 @@ def edges(self, nbunch=None, data=False, default=None):
         [(0, 1)]
 
         """
-        seen = {}     # helper dict to keep track of multiply stored edges
-        if nbunch is None:
-            nodes_nbrs = self.adj.items()
-        else:
-            nodes_nbrs = ((n, self.adj[n]) for n in self.nbunch_iter(nbunch))
-        if data is True:
-            for n, nbrs in nodes_nbrs:
-                for nbr, ddict in nbrs.items():
-                    if nbr not in seen:
-                        yield (n, nbr, ddict)
-                seen[n] = 1
-        elif data is not False:
-            for n, nbrs in nodes_nbrs:
-                for nbr, ddict in nbrs.items():
-                    if nbr not in seen:
-                        d = ddict[data] if data in ddict else default
-                        yield (n, nbr, d)
-                seen[n] = 1
-        else:  # data is False
-            for n, nbrs in nodes_nbrs:
-                for nbr in nbrs:
-                    if nbr not in seen:
-                        yield (n, nbr)
-                seen[n] = 1
-        del seen
+        return EdgeView(self, nbunch, data, default)
 
     def get_edge_data(self, u, v, default=None):
         """Return the attribute dictionary associated with edge (u,v).
@@ -1226,29 +1194,11 @@ def degree(self, nbunch=None, weight=None):
         [(0, 1), (1, 2)]
         """
         # Test to see if nbunch is a single node, an iterator of nodes or
-        # None(indicating all nodes). (nbunch in self) is True when nbunch
-        # is a single node.
+        # None(indicating all nodes). (nbunch in self) means a single node.
         if nbunch in self:
-            nbrs = self.adj[nbunch]
-            if weight is None:
-                return len(nbrs) + (1 if nbunch in nbrs else 0) # handle self-loops
-            return sum(dd.get(weight, 1) for nbr,dd in nbrs.items()) +\
-                    (nbrs[nbunch].get(weight, 1) if nbunch in nbrs else 0)
-
-        if nbunch is None:
-            nodes_nbrs = self.adj.items()
-        else:
-            nodes_nbrs = ((n, self.adj[n]) for n in self.nbunch_iter(nbunch))
-        if weight is None:
-            def d_iter():
-                for n, nbrs in nodes_nbrs:
-                    yield (n, len(nbrs) + (1 if n in nbrs else 0))  # return tuple (n,degree)
-        else:
-            def d_iter():
-                for n, nbrs in nodes_nbrs:
-                    yield (n, sum((nbrs[nbr].get(weight, 1) for nbr in nbrs)) +
-                        (nbrs[n].get(weight, 1) if n in nbrs else 0))
-        return d_iter()
+            deg = DegreeView(self, weight)
+            return deg[nbunch]
+        return DegreeView(self, weight, nbunch)
 
     def clear(self):
         """Remove all nodes and edges from the graph.