Adjust set operations for Views. Restructure edges.py

In nodes.py:
 - add __rand__ and friends so that "set|view" works like "view|set"
 - took care of some fixmes in other set operations
 - need to figure out how to do repr like ItemsView
In edges.py:
 - Views had no set operations. I created BaseEdgeView subclass of Set.
 - Put all functions that depend on "directed" into UndirectedEdges.
 - Edges subclasses from UndirectedEdges and Set.

Author: dschult

edges.py

@@ -1,12 +1,51 @@
-from collections import MappingView
+from collections import MappingView, Set
 from networkx.exception import NetworkXError
 
 
+class BaseEdgeView(Set):
+    __slots__ = ["_edgesobj"]
+    def __init__(self, edgesobj):
+        self._edgesobj = edgesobj
+    def __repr__(self):
+        return '{0.__class__.__name__}({1})'.format(self,list(self))
+    def __len__(self):
+        return len(self._edgesobj)
+    # Set also demands __iter__ and __contains__ be defined. 
+
+class EdgeKeys(BaseEdgeView):
+    __slots__ = ["_edgesobj"]
+    def __iter__(self):
+        return iter(self._edgesobj)
+    def __contains__(self, key):
+        u,v = key
+        return v in self._edgesobj._adj[u]
+
+class EdgeData(BaseEdgeView):
+    __slots__ = ["_edgesobj"]
+    def __iter__(self):
+        for e,d in self._edgesobj._items():
+            yield d
+    def __contains__(self, data):
+        # Do we need/want to provide ability to look up a datadict?
+        # need to look at all data
+        for d in self:
+            if d == data:
+                return True
+        return False
+
+class EdgeItems(BaseEdgeView):
+    __slots__ = ["_edgesobj"]
+    def __iter__(self):
+        return self._edgesobj._items()
+    def __contains__(self, key):
+        adj = self._edgesobj._adj
+        (u,v),d = key
+        return v in adj[u] and adj[u][v] == d
+
+
 class UndirectedEdges(object):
-    __slots__ = ('_adj','_node')
-    def __init__(self, node, adj):
-        self._adj = adj
-        self._node = node
+    def __len__(self):
+        return sum(len(nbrs) for n, nbrs in self._adj.items()) // 2
     def __iter__(self):
         seen = set()
         nodes_nbrs = self._adj.items()
@@ -16,8 +55,6 @@ def __iter__(self):
                     yield (n, nbr)
                     seen.add(n)
         del seen
-    def __len__(self):
-        return sum(len(nbrs) for n, nbrs in self._adj.items()) // 2
     def _items(self):
         seen = set()
         nodes_nbrs = self._adj.items()
@@ -27,35 +64,6 @@ def _items(self):
                     yield (n,nbr),ddict
                     seen.add(n)
         del seen
-
-class EdgeKeys(UndirectedEdges):
-    def __repr__(self):
-        return '{})'.format(list(self))
-
-class EdgeData(UndirectedEdges):
-    def __iter__(self):
-        for e,d in self._items():
-            yield d
-    def __repr__(self):
-        return '{})'.format(list(self))
-    def __contains__(self, key):
-        # need to look at all data
-        for k in self:
-            if k == key:
-                return True
-        return False
-
-class EdgeItems(UndirectedEdges):
-    def __iter__(self):
-        return self._items()
-    def __repr__(self):
-        return '{})'.format(list(self))
-    def __contains__(self, key):
-        (u,v),d = key
-        return v in self._adj[u] and self._adj[u][v] == d
-
-
-class Edges(UndirectedEdges):
     def __contains__(self, key):
         u,v = key
         return v in self._adj[u]
@@ -65,26 +73,7 @@ def __getitem__(self, key):
             return self._adj[u][v]
         except TypeError:
             raise NetworkXError('bad edge key: use edge key = (u,v)')
-    def __and__(self, other):
-        return set(self) & set(other)
-    def __or__(self, other):
-        return set(self) | set(other)
-    def __xor__(self, other):
-        return set(self) ^ set(other)
-    def __sub__(self, other):
-        return set(self) - set(other)
-    def __repr__(self):
-        return '{0.__class__.__name__}({1})'.format(self,list(self))
-    def keys(self):
-        return EdgeKeys(self._node, self._adj)
-    def data(self):
-        return EdgeData(self._node, self._adj)
-    def items(self):
-        return EdgeItems(self._node, self._adj)
-    def selfloops(self):
-        return ((n, n)
-                for n, nbrs in self._adj.items() if n in nbrs)
-
+    # Mutating Methods
     def add(self, u, v, attr_dict=None, **attr):
         if attr_dict is None:
             attr_dict = attr
@@ -106,8 +95,6 @@ def add(self, u, v, attr_dict=None, **attr):
         datadict.update(attr_dict)
         self._adj[u][v] = datadict
         self._adj[v][u] = datadict
-
-
     def update(self, ebunch, attr_dict=None, **attr):
         # set up attribute dict
         if attr_dict is None:
@@ -140,7 +127,6 @@ def update(self, ebunch, attr_dict=None, **attr):
             datadict.update(dd)
             self._adj[u][v] = datadict
             self._adj[v][u] = datadict
-
     def remove(self, u, v):
         try:
             del self._adj[u][v]
@@ -151,3 +137,20 @@ def remove(self, u, v):
     def clear(self):
         for n in self._adj:
             self._adj[n].clear()
+
+class Edges(UndirectedEdges, Set):
+    __slots__ = ('_adj','_node')
+    def __init__(self, node, adj):
+        self._adj = adj
+        self._node = node
+    def __repr__(self):
+        return '{0.__class__.__name__}({1})'.format(self,list(self))
+    def keys(self):
+        return EdgeKeys(self)
+    def data(self):
+        return EdgeData(self)
+    def items(self):
+        return EdgeItems(self)
+    def selfloops(self):
+        return ((n, n)
+                for n, nbrs in self._adj.items() if n in nbrs)

nodes.py

@@ -3,6 +3,8 @@
 
 class NodeKeys(KeysView):
     def __repr__(self):
+        # If we remove this def, the result is:
+        # return '{0.__class__.__name__}({1})'.format(self,self._mapping)
         return '{}'.format(list(self._mapping))
 
 class NodeData(ValuesView):
@@ -25,7 +27,7 @@ def __iter__(self):
     def __contains__(self, key):
         return key in self._nodes
     def __repr__(self):
-        return '{0.__class__.__name__}({1})'.format(self,list(self._nodes))
+        return '{0.__class__.__name__}({1})'.format(self,self._nodes)
     def __len__(self):
         return len(self._nodes)
     def clear(self):
@@ -40,6 +42,16 @@ def __xor__(self, other):
         return set(self._nodes) ^ set(other)
     def __sub__(self, other):
         return set(self._nodes) - set(other)
+    # reverse set methods (so set | me works same as me | set)
+    def __rand__(self, other):
+        return set(self._nodes) & set(other)
+    def __ror__(self, other):
+        return set(self._nodes) | set(other)
+    def __rxor__(self, other):
+        return set(self._nodes) ^ set(other)
+    def __rsub__(self, other):
+        return set(self._nodes) - set(other)
+    # inplace mass adds and removes
     def update(self, nodes, **attr):
         for n in nodes:
             try:
@@ -51,20 +63,17 @@ def update(self, nodes, **attr):
                 self.add(n, attr_dict=None, **attr)
         return self
     def intersection_update(self, nodes):
-        # fixme: make work for node tuples?
-        for n in self - nodes:
+        for n in self - set(nodes):
             self.discard(n)
         return self
     def symmetric_difference_update(self, nodes):
-        # fixme: make work for node tuples?
         for n in nodes:
             if n in self:
                 self.discard(n)
             else:
                 self.add(n)
         return self
     def difference_update(self, nodes):
-        # fixme: make work for node tuples?
         for n in nodes:
             self.discard(n)
         return self
@@ -77,10 +86,10 @@ def difference_update(self, nodes):
     def discard(self, n):
         adj = self._adj
         try:
-            # keys handles self-loops (allow mutation later)
+            # list handles self-loops (allow mutation later)
             nbrs = list(adj[n].keys())
             del self._nodes[n]
-        except KeyError:  # NetworkXError if n not in self
+        except KeyError:  # silently ignore if n not in self
             return
         for u in nbrs:
             del adj[u][n]   # remove all edges n-u in graph