Working on removing fancy.py

abp/__init__.py

@@ -1,5 +1,6 @@
 # Alias some stuff to make imports cleaner
 from abp.graphstate import GraphState
+from abp.nxgraphstate import NXGraphState
 from abp.qi import CircuitModel
 
 DETERMINISTIC = False

abp/fancy.py

@@ -1,64 +0,0 @@
-import time, atexit, json
-import sys
-import networkx as nx
-import numpy as np
-import websocket
-from socket import error as socket_error
-import graphstate
-import clifford
-import util
-
-class GraphState(graphstate.GraphState, nx.Graph):
-    def __init__(self, *args, **kwargs):
-        graphstate.GraphState.__init__(self, *args, **kwargs)
-        self.connect_to_server()
-
-    def connect_to_server(self, uri = "ws://localhost:5000"):
-        """ Attempt to connect to the websocket server """
-        try:
-            self.ws = websocket.create_connection(uri, timeout=0.1)
-            atexit.register(self.shutdown)
-        except: #TODO: bad practice
-            self.ws = None
-
-    def shutdown(self):
-        """ Close the connection to the websocket """
-        if not self.ws:
-            return
-        self.ws.close()
-
-    def update(self, delay = 0.5):
-        """ Call this function when you are ready to send data to the browser """
-        if not self.ws:
-            return
-
-        # Automatically perform layout if position is not provided
-        if not all(("position" in node) for node in self.node.values()):
-            self.layout()
-
-        # Send data to browser and rate-limit
-        try:
-            self.ws.send(json.dumps(self.to_json(stringify=True)))
-            self.ws.recv()
-            time.sleep(delay)
-        except websocket._exceptions.WebSocketTimeoutException:
-            print "Timed out ... you might be pushing a bit hard"
-            time.sleep(delay)
-            #self.ws.close()
-            #self.connect_to_server()
-
-    def layout(self):
-        """ Automatically lay out the graph """
-        pos = nx.spring_layout(self, dim=3, scale=np.sqrt(self.order()))
-        middle = np.average(pos.values(), axis=0)
-        pos = {key: value - middle for key, value in pos.items()}
-        for key, (x, y, z) in pos.items():
-            self.node[key]["position"] = util.xyz(x, y, z)
-
-    def add_vops(self):
-        """ Automatically add vops if they're not present """
-        for key in self.node:
-            if not "vop" in self.node[key]:
-                self.node[key]["vop"] = clifford.identity
-
-        

abp/graphstate.py

@@ -276,41 +276,15 @@ class GraphState(object):
             return int(result)
 
     def measure_x(self, node, force=None, detail=False, friend=None):
-        """ Measure in the X basis
-
-        :param node: The name of the qubit to measure.
-        :param force: Measurements in quantum mechanics are probabilistic. If you want to force a particular outcome, use the ``force``.
-        :type force: boolean
-        :param detail: Provide detailed information
-        :type detail: boolean
-        :param friend: Specify a node to toggle about
-        :type friend: Any neighbour of ``node``.
-
-        """
+        """ Measure in the X basis """
         return self.measure(node, "px", force, detail, friend)
 
     def measure_y(self, node, force=None, detail=False):
-        """ Measure in the Y basis
-
-        :param node: The name of the qubit to measure.
-        :param force: Measurements in quantum mechanics are probabilistic. If you want to force a particular outcome, use the ``force``.
-        :type force: boolean
-        :param detail: Provide detailed information
-        :type detail: boolean
-
-        """
+        """ Measure in the Y basis """
         return self.measure(node, "py", force, detail)
 
     def measure_z(self, node, force=None, detail=False):
-        """ Measure in the Z basis
-
-        :param node: The name of the qubit to measure.
-        :param force: Measurements in quantum mechanics are probabilistic. If you want to force a particular outcome, use the ``force``.
-        :type force: boolean
-        :param detail: Provide detailed information
-        :type detail: boolean
-
-        """
+        """ Measure in the Z basis """
         return self.measure(node, "pz", force, detail)
 
     def measure_sequence(self, measurements, forces=None, detail=False):
@@ -512,3 +486,4 @@ class GraphState(object):
         g.node = self.node.copy()
         g.adj = self.adj.copy()
         return g
+

abp/nxgraphstate.py

@@ -0,0 +1,24 @@
+import networkx as nx
+import graphstate
+import clifford
+
+class NXGraphState(graphstate.GraphState, nx.Graph):
+    """ This is GraphState with NetworkX-like abilities """
+    def __init__(self, *args, **kwargs):
+        graphstate.GraphState.__init__(self, *args, **kwargs)
+
+    def layout(self):
+        """ Automatically lay out the graph """
+        pos = nx.spring_layout(self, dim=3, scale=np.sqrt(self.order()))
+        middle = np.average(pos.values(), axis=0)
+        pos = {key: value - middle for key, value in pos.items()}
+        for key, (x, y, z) in pos.items():
+            self.node[key]["position"] = util.xyz(x, y, z)
+
+    def add_vops(self):
+        """ Automatically add vops if they're not present """
+        for key in self.node:
+            if not "vop" in self.node[key]:
+                self.node[key]["vop"] = clifford.identity
+
+        

doc/abp.rst

@@ -35,10 +35,10 @@ abp.clifford module
     :undoc-members:
     :show-inheritance:
 
-abp.fancy module
+abp.nxgraphstate module
 ----------------
 
-.. automodule:: abp.fancy
+.. automodule:: abp.nxgraphstate
     :members:
     :undoc-members:
     :show-inheritance:

examples/visualization/stress_test.py

@@ -31,8 +31,8 @@ def lattice(unit_cell, size):
 
 nodes, edges = lattice(threedee_unit_cell, (4, 4, 4))
 
+psi = GraphState()
 while True:
-    psi = GraphState()
     for node in nodes:
         psi.add_qubit(str(node), position=xyz(node[0], node[1], node[2]), vop="identity")
     psi.update(0.1)

tests/test_fancy.py → tests/test_nx.py

@@ -1,6 +1,6 @@
 import json
 import networkx as nx
-from abp import GraphState, fancy
+from abp import GraphState, NXGraphState
 from abp import clifford
 from abp.util import xyz
 from mock import simple_graph
@@ -16,7 +16,7 @@ def test_json_basic():
 
 def test_tuple_keys():
     """ Test that we can use tuple-ish keys """
-    g = fancy.GraphState()
+    g = NXGraphState()
     g.add_qubit("string")
     g.add_qubit((1, 2, 3))
     g.add_edge((1, 2, 3), "string")
@@ -24,8 +24,8 @@ def test_tuple_keys():
 
 
 def networkx_test():
-    """ Test that fancy graph states really behave like networkx graphs """
-    g = fancy.GraphState()
+    """ Test that NXGraphStates really behave like networkx graphs """
+    g = NXGraphState()
     g.add_qubit(0, position=xyz(10, 0, 0))
     g.add_qubit(1, position=xyz(1, 0, 0))
     g.act_hadamard(0)
@@ -37,9 +37,9 @@ def networkx_test():
 def test_from_nx():
     """ Test that making graphs from networkx objects goes smoothly """
     g = nx.random_geometric_graph(100, 2)
-    psi = fancy.GraphState(g)
+    psi = NXGraphState(g)
     assert psi.node[0]["vop"] == 0
     assert len(psi.edges()) > 0
     psi.measure(0, "px", detail=True)
 
-    psi = fancy.GraphState(nx.Graph(((0, 1),)))
+    psi = NXGraphState(nx.Graph(((0, 1),)))