Upgrade QISKit depdencies (#261)

* Bumped to version: 0.4.6
* Upgraded external dependencies
* Make graph code in QISKit compatible with NetworkX 2.0
   NetworkX 1.11 which is required by qiskit uses some deprecated
   functions for plotting that generate a warning with matplotlib. The
   proposed changes make QISKit compatible with both versions of NetworkX.
   In a second step we should upgrade the code to use only NetworkX 2.0
   and later since some functions were added that make things more
   elegant. See
   https://networkx.github.io/documentation/stable/release/migration_guide_from_1.x_to_2.0.html
* Reintroduce AppVeyor (#252)
  Re-enable the AppVeyor CI, as the conflicts with the version were
  hopefully solved after bumping the scipy dependency and others.

Author: atilag

appveyor.yml

@@ -15,10 +15,6 @@
 
 version: 1.0.{build}
 
-branches:
-    only:
-        - invalidbranch
-
 environment:
     matrix:
         - PYTHON_VERSION: 3.5
@@ -45,7 +41,7 @@ install:
 
 # Use py.test for output of xunit test results.
 test_script:
-    - py.test -s -v --junit-xml=test_results.xml
+    - py.test -v --junit-xml=test_results.xml
 
 # Upload the test results to appveyor so they are shown on the "Tests" tab.
 on_finish:

qiskit/__init__.py

@@ -41,6 +41,6 @@
 from ._result import Result
 from ._util import _check_ibmqe_version
 
-__version__ = '0.4.5'
+__version__ = '0.4.6'
 
 _check_ibmqe_version()

qiskit/dagcircuit/_dagcircuit.py

@@ -120,7 +120,7 @@ def rename_register(self, regname, newname):
             self.output_map[(newname, i)] = self.output_map[(regname, i)]
             self.output_map.pop((regname, i), None)
         # n node d = data
-        for _, d in self.multi_graph.nodes_iter(data=True):
+        for _, d in self.multi_graph.nodes(data=True):
             if d["type"] == "in" or d["type"] == "out":
                 if d["name"][0] == regname:
                     d["name"] = (newname, d["name"][1])
@@ -141,7 +141,7 @@ def rename_register(self, regname, newname):
                     if d["condition"][0] == regname:
                         d["condition"] = (newname, d["condition"][1])
         # eX = edge, d= data
-        for _, _, d in self.multi_graph.edges_iter(data=True):
+        for _, _, d in self.multi_graph.edges(data=True):
             if d["name"][0] == regname:
                 d["name"] = (newname, d["name"][1])
 
@@ -195,7 +195,7 @@ def _add_wire(self, name, isClassical=False):
             self.multi_graph.node[out_node]["type"] = "out"
             self.multi_graph.node[in_node]["name"] = name
             self.multi_graph.node[out_node]["name"] = name
-            self.multi_graph.edge[in_node][out_node][0]["name"] = name
+            self.multi_graph.adj[in_node][out_node][0]["name"] = name
         else:
             raise DAGCircuitError("duplicate wire %s" % name)
 
@@ -369,7 +369,7 @@ def apply_operation_back(self, name, qargs, cargs=None, params=None,
         # and adding new edges from the operation node to each output node
         al = [qargs, all_cbits]
         for q in itertools.chain(*al):
-            ie = self.multi_graph.predecessors(self.output_map[q])
+            ie = list(self.multi_graph.predecessors(self.output_map[q]))
             assert len(ie) == 1, "output node has multiple in-edges"
             self.multi_graph.add_edge(ie[0], self.node_counter, name=q)
             self.multi_graph.remove_edge(ie[0], self.output_map[q])
@@ -581,8 +581,7 @@ def compose_back(self, input_circuit, wire_map=None):
         # Compose
         self.basis = union_basis
         self.gates = union_gates
-        topological_sort = nx.topological_sort(input_circuit.multi_graph)
-        for node in topological_sort:
+        for node in nx.topological_sort(input_circuit.multi_graph):
             nd = input_circuit.multi_graph.node[node]
             if nd["type"] == "in":
                 # if in wire_map, get new name, else use existing name
@@ -640,8 +639,7 @@ def compose_front(self, input_circuit, wire_map=None):
         # Compose
         self.basis = union_basis
         self.gates = union_gates
-        ts = nx.topological_sort(input_circuit.multi_graph, reverse=True)
-        for n in ts:
+        for n in reversed(list(nx.topological_sort(input_circuit.multi_graph))):
             nd = input_circuit.multi_graph.node[n]
             if nd["type"] == "out":
                 # if in wire_map, get new name, else use existing name
@@ -769,8 +767,7 @@ def qasm(self, decls_only=False, add_swap=False,
                 out += "gate swap a,b { cx a,b; cx b,a; cx a,b; }\n"
         # Write the instructions
         if not decls_only:
-            ts = nx.topological_sort(self.multi_graph)
-            for n in ts:
+            for n in nx.topological_sort(self.multi_graph):
                 nd = self.multi_graph.node[n]
                 if nd["type"] == "op":
                     if nd["condition"] is not None:
@@ -843,9 +840,9 @@ def _make_pred_succ_maps(self, n):
         nodes for the operation node n in self.multi_graph.
         """
         pred_map = {e[2]['name']: e[0] for e in
-                    self.multi_graph.in_edges_iter(nbunch=n, data=True)}
+                    self.multi_graph.in_edges(nbunch=n, data=True)}
         succ_map = {e[2]['name']: e[1] for e in
-                    self.multi_graph.out_edges_iter(nbunch=n, data=True)}
+                    self.multi_graph.out_edges(nbunch=n, data=True)}
         return pred_map, succ_map
 
     def _full_pred_succ_maps(self, pred_map, succ_map, input_circuit,
@@ -874,7 +871,7 @@ def _full_pred_succ_maps(self, pred_map, succ_map, input_circuit,
                 full_succ_map[w] = self.output_map[w]
                 full_pred_map[w] = self.multi_graph.predecessors(
                     self.output_map[w])[0]
-                assert len(self.multi_graph.predecessors(self.output_map[w])) == 1,\
+                assert len(list(self.multi_graph.predecessors(self.output_map[w]))) == 1,\
                     "too many predecessors for (%s,%d) output node" % (
                         w[0], w[1])
         return full_pred_map, full_succ_map
@@ -913,8 +910,7 @@ def substitute_circuit_all(self, name, input_circuit, wires=None):
         #       that we add from the input_circuit.
         self.basis = union_basis
         self.gates = union_gates
-        ts = nx.topological_sort(self.multi_graph)
-        for n in ts:
+        for n in nx.topological_sort(self.multi_graph):
             nd = self.multi_graph.node[n]
             if nd["type"] == "op" and nd["name"] == name:
                 if nd["condition"] is None:
@@ -930,8 +926,7 @@ def substitute_circuit_all(self, name, input_circuit, wires=None):
                     # Now that we know the connections, delete node
                     self.multi_graph.remove_node(n)
                     # Iterate over nodes of input_circuit
-                    tsin = nx.topological_sort(input_circuit.multi_graph)
-                    for m in tsin:
+                    for m in nx.topological_sort(input_circuit.multi_graph):
                         md = input_circuit.multi_graph.node[m]
                         if md["type"] == "op":
                             # Insert a new node
@@ -955,8 +950,8 @@ def substitute_circuit_all(self, name, input_circuit, wires=None):
                     for w in full_pred_map:
                         self.multi_graph.add_edge(full_pred_map[w], full_succ_map[w],
                                                   name=w)
-                        o_pred = self.multi_graph.predecessors(
-                            self.output_map[w])
+                        o_pred = list(self.multi_graph.predecessors(
+                            self.output_map[w]))
                         if len(o_pred) > 1:
                             assert len(o_pred) == 2, \
                                 "expected 2 predecessors here"
@@ -1023,8 +1018,7 @@ def substitute_circuit_one(self, node, input_circuit, wires=None):
             # Now that we know the connections, delete node
             self.multi_graph.remove_node(node)
             # Iterate over nodes of input_circuit
-            tsin = nx.topological_sort(input_circuit.multi_graph)
-            for m in tsin:
+            for m in nx.topological_sort(input_circuit.multi_graph):
                 md = input_circuit.multi_graph.node[m]
                 if md["type"] == "op":
                     # Insert a new node
@@ -1049,7 +1043,7 @@ def substitute_circuit_one(self, node, input_circuit, wires=None):
             for w in full_pred_map:
                 self.multi_graph.add_edge(
                     full_pred_map[w], full_succ_map[w], name=w)
-                o_pred = self.multi_graph.predecessors(self.output_map[w])
+                o_pred = list(self.multi_graph.predecessors(self.output_map[w]))
                 if len(o_pred) > 1:
                     assert len(o_pred) == 2, "expected 2 predecessors here"
                     p = [x for x in o_pred if x != full_pred_map[w]]
@@ -1064,8 +1058,7 @@ def get_named_nodes(self, name):
                                   % name)
 
         # Iterate through the nodes of self in topological order
-        ts = nx.topological_sort(self.multi_graph)
-        for n in ts:
+        for n in nx.topological_sort(self.multi_graph):
             nd = self.multi_graph.node[n]
             if nd["type"] == "op" and nd["name"] == name:
                 nlist.append(n)
@@ -1213,8 +1206,7 @@ def serial_layers(self):
         same structure as in layers().
         """
         layers_list = []
-        ts = nx.topological_sort(self.multi_graph)
-        for n in ts:
+        for n in nx.topological_sort(self.multi_graph):
             nxt_nd = self.multi_graph.node[n]
             if nxt_nd["type"] == "op":
                 new_layer = DAGCircuit()
@@ -1260,21 +1252,21 @@ def collect_runs(self, namelist):
         # Iterate through the nodes of self in topological order
         # and form tuples containing sequences of gates
         # on the same qubit(s).
-        ts = nx.topological_sort(self.multi_graph)
+        ts = list(nx.topological_sort(self.multi_graph))
         nodes_seen = dict(zip(ts, [False] * len(ts)))
         for node in ts:
             nd = self.multi_graph.node[node]
             if nd["type"] == "op" and nd["name"] in namelist \
                and not nodes_seen[node]:
                 group = [node]
                 nodes_seen[node] = True
-                s = self.multi_graph.successors(node)
+                s = list(self.multi_graph.successors(node))
                 while len(s) == 1 and \
                         self.multi_graph.node[s[0]]["type"] == "op" and \
                         self.multi_graph.node[s[0]]["name"] in namelist:
                     group.append(s[0])
                     nodes_seen[s[0]] = True
-                    s = self.multi_graph.successors(s[0])
+                    s = list(self.multi_graph.successors(s[0]))
                 if len(group) > 1:
                     group_list.append(tuple(group))
         return set(group_list)
@@ -1285,8 +1277,7 @@ def count_ops(self):
         Returns a dictionary of counts keyed on the operation name.
         """
         op_dict = {}
-        ts = nx.topological_sort(self.multi_graph)
-        for node in ts:
+        for node in nx.topological_sort(self.multi_graph):
             nd = self.multi_graph.node[node]
             name = nd["name"]
             if nd["type"] == "op":

qiskit/mapper/_coupling.py

@@ -165,7 +165,7 @@ def compute_distance(self):
         """
         if not self.connected():
             raise CouplingError("coupling graph not connected")
-        lengths = nx.all_pairs_shortest_path_length(self.G.to_undirected())
+        lengths = dict(nx.all_pairs_shortest_path_length(self.G.to_undirected()))
         self.dist = {}
         for i in self.qubits.keys():
             self.dist[i] = {}

qiskit/mapper/_mapping.py

@@ -778,16 +778,15 @@ def optimize_1q_gates(circuit):
         if right_name == "u3":
             new_params = list(right_parameters)
 
-        nx.set_node_attributes(unrolled.multi_graph, 'name',
-                               {run[0]: right_name})
+        nx.set_node_attributes(unrolled.multi_graph, name='name',
+                               values={run[0]: right_name})
         # params is a list of sympy symbols and the str() method
         # will return Python expressions. To get the correct
         # OpenQASM expression, we need to replace "**" with "^".
-        nx.set_node_attributes(unrolled.multi_graph, 'params',
-                               {run[0]: tuple(map(lambda x:
-                                                  str(x).replace("**", "^"),
-                                                  new_params))})
-
+        nx.set_node_attributes(unrolled.multi_graph, name='params',
+                               values={run[0]: tuple(map(lambda x:
+                                                         str(x).replace("**", "^"),
+                                                         new_params))})
         # Delete the other nodes in the run
         for node in run[1:]:
             unrolled._remove_op_node(node)

requirements.txt

@@ -1,8 +1,8 @@
 IBMQuantumExperience>=1.8.26
-matplotlib>=2.0,<=2.1
-networkx>=1.11,<1.12
-numpy>=1.13,<=1.14
+matplotlib>=2.1,<2.2
+networkx>=1.11,<2.1
+numpy>=1.13,<1.15
 ply==3.10
-scipy>=0.19,<=1.0
+scipy>=0.19,<1.1
 Sphinx>=1.6,<1.7
-sympy>=1.0
+sympy>=1.0

setup.py

@@ -10,11 +10,11 @@
 
 requirements = [
     "IBMQuantumExperience>=1.8.26",
-    "matplotlib>=2.0,<=2.1",
-    "networkx>=1.11,<1.12",
-    "numpy>=1.13,<=1.14",
+    "matplotlib>=2.1,<2.2",
+    "networkx>=1.11,<2.1",
+    "numpy>=1.13,<1.15",
     "ply==3.10",
-    "scipy>=0.19,<=1.0",
+    "scipy>=0.19,<1.1",
     "Sphinx>=1.6,<1.7",
     "sympy>=1.0"
 ]
@@ -79,7 +79,7 @@ def compile():
 
 setup(
     name="qiskit",
-    version="0.4.5",
+    version="0.4.6",
     description="Software for developing quantum computing programs",
     long_description="""QISKit is a software development kit for writing
         quantum computing experiments, programs, and applications. Works with

test/python/test_mapper.py

@@ -62,7 +62,7 @@ def test_math_domain_error(self):
         if version_info.minor == 5:  # Python 3.5
             self.assertEqual(result1.get_counts("test"), {'0001': 507, '0101': 517})
         else:  # Python 3.6 and higher
-            self.assertEqual(result1.get_counts("test"), {'0001': 480, '0101': 544})
+            self.assertEqual(result1.get_counts("test"), {'0001': 517, '0101': 507})
 
     def test_optimize_1q_gates_issue159(self):
         """Test change in behavior for optimize_1q_gates that removes u1(2*pi) rotations.
@@ -96,31 +96,46 @@ def test_random_parameter_circuit(self):
         result1 = self.qp.execute(["rand"], backend="local_qasm_simulator",
                                   coupling_map=coupling_map, seed=self.seed)
         res = result1.get_counts("rand")
+
+        expected_result = {'10000': 97, '00011': 24, '01000': 120, '10111': 59,
+                           '01111': 37, '11010': 14, '00001': 34, '00100': 42,
+                           '10110': 41, '00010': 102, '00110': 48, '10101': 19,
+                           '01101': 61, '00111': 46, '11100': 28, '01100': 1,
+                           '00000': 86, '11111': 14, '11011': 9, '10010': 35,
+                           '10100': 20, '01001': 21, '01011': 19, '10011': 10,
+                           '11001': 13, '00101': 4, '01010': 2, '01110': 17,
+                           '11000': 1}
+
         # TODO: the circuit produces different results under different versions
-        # of Python, which defeats the purpose of the "seed" parameter. A proper
-        # fix should be issued - this is a workaround for this particular test.
+        # of Python and NetworkX package, which defeats the purpose of the
+        # "seed" parameter. A proper fix should be issued - this is a workaround
+        # for this particular test.
         if version_info.minor == 5:  # Python 3.5
-            self.assertEqual(res, {'00101': 3, '00011': 22, '11100': 27,
-                                   '01100': 1, '10011': 15, '00111': 53,
-                                   '01000': 110, '11111': 19, '00100': 54,
-                                   '01111': 17, '10101': 11, '11010': 20,
-                                   '10111': 60, '01110': 6, '00110': 40,
-                                   '11001': 16, '11011': 9, '01010': 9,
-                                   '01011': 16, '11110': 4, '00000': 89,
-                                   '10110': 34, '00010': 113, '10010': 25,
-                                   '00001': 25, '01001': 41, '10000': 96,
-                                   '11000': 1, '10100': 20, '01101': 68})
-        else:
-            self.assertEqual(res, {'10000': 98, '11010': 22, '00000': 88,
-                                   '00010': 120, '10110': 55, '01111': 26,
-                                   '00100': 51, '10111': 62, '01101': 70,
-                                   '01000': 95, '01100': 6, '01011': 13,
-                                   '00111': 45, '00110': 30, '10011': 14,
-                                   '10100': 21, '11100': 28, '00001': 26,
-                                   '01001': 33, '00101': 5, '11001': 7,
-                                   '10101': 20, '11110': 1, '11111': 20,
-                                   '00011': 15, '11000': 2, '10010': 27,
-                                   '01010': 4, '11011': 6, '01110': 14})
+            import networkx
+            if networkx.__version__ == '1.11':
+                expected_result = {'01001': 41, '10010': 25, '00111': 53,
+                                   '01101': 68, '10101': 11, '10110': 34,
+                                   '01110': 6, '11100': 27, '00100': 54,
+                                   '11010': 20, '10100': 20, '01100': 1,
+                                   '10000': 96, '11000': 1, '11011': 9,
+                                   '10011': 15, '00101': 3, '00001': 25,
+                                   '00010': 113, '01011': 16, '11111': 19,
+                                   '11001': 16, '00011': 22, '00000': 89,
+                                   '00110': 40, '01000': 110, '10111': 60,
+                                   '11110': 4, '01010': 9, '01111': 17}
+            else:
+                expected_result = {'01001': 32, '11110': 1, '10010': 36,
+                                   '11100': 34, '11011': 10, '00001': 41,
+                                   '00000': 83, '10000': 94, '11001': 15,
+                                   '01011': 24, '00100': 43, '11000': 5,
+                                   '11010': 9, '01100': 5, '10100': 23,
+                                   '01101': 54, '01110': 6, '00011': 13,
+                                   '10101': 12, '00111': 36, '00110': 40,
+                                   '01000': 119, '11111': 19, '01010': 8,
+                                   '10111': 61, '10110': 52, '01111': 23,
+                                   '00010': 110, '00101': 2, '10011': 14}
+
+        self.assertEqual(res, expected_result)
 
     def test_symbolic_unary(self):
         """Test symbolic math in DAGBackend and optimizer with a prefix.