Fixes test warnings (#128)

* Fixes test warnings

Author: ciaranra

python/quantum-pecos/src/pecos/decoders/mwpm2d/mwpm2d.py

@@ -93,7 +93,23 @@ def decode(self, measurements, error_params=None):
                             real_graph.add_edge(vi, vj, weight=0)
 
                 # Find a matching
-                matching_edges = nx.max_weight_matching(real_graph, maxcardinality=True)
+                # Handle different NetworkX versions
+                try:
+                    # For NetworkX >= 2.5
+                    matching_edges = nx.algorithms.matching.max_weight_matching(
+                        real_graph,
+                        maxcardinality=True,
+                    )
+                    # Convert to a list of tuples if it's a set of frozen sets (NetworkX 2.5+)
+                    if isinstance(matching_edges, set):
+                        matching_edges = list(matching_edges)
+                except (TypeError, AttributeError):
+                    # For older NetworkX versions
+                    matching_edges = nx.max_weight_matching(
+                        real_graph,
+                        maxcardinality=True,
+                    )
+
                 matching = {n1: n2 for n2, n1 in matching_edges}
                 matching.update(dict(matching_edges))
 

python/quantum-pecos/src/pecos/decoders/mwpm2d/precomputing.py

@@ -86,6 +86,29 @@ def code_surface4444medial(instr):
     return decoder_data
 
 
+def compute_all_shortest_paths(graph):
+    """
+    Compute all shortest paths in a graph, handling NetworkX API changes.
+
+    This function will explicitly generate the all-pairs shortest paths
+    to be compatible with different NetworkX versions.
+
+    Args:
+        graph: NetworkX graph
+
+    Returns:
+        Dictionary of dictionaries with path[source][target] = list of nodes in path
+    """
+    # Compute all-pairs shortest paths explicitly
+    all_paths = {}
+    for source in graph.nodes():
+        # For each source, get paths to all targets
+        source_paths = nx.single_source_shortest_path(graph, source)
+        all_paths[source] = source_paths
+
+    return all_paths
+
+
 def surface4444_identity(instr):
     """For X and Z decoding separately:
 
@@ -246,7 +269,8 @@ def surface4444_identity(instr):
             edge2d = edges_z
             virtual_edge_data = virtual_edge_data_z
 
-        paths = dict(nx.shortest_path(temp_graph))
+        # Use a future-proof approach to get all shortest paths
+        paths = compute_all_shortest_paths(temp_graph)
 
         for n1, wdict in paths.items():
             for n2, syn_path in wdict.items():
@@ -499,7 +523,8 @@ def surface4444medial_identity(instr):
             edge2d = edges_z
             virtual_edge_data = virtual_edge_data_z
 
-        paths = dict(nx.shortest_path(temp_graph))
+        # Use a future-proof approach to get all shortest paths
+        paths = compute_all_shortest_paths(temp_graph)
 
         for n1, wdict in paths.items():
             for n2, syn_path in wdict.items():

python/quantum-pecos/src/pecos/simulators/basic_sv/gates_two_qubit.py

@@ -35,7 +35,8 @@ def _apply_two_qubit_matrix(state, qubits: tuple[int, int], matrix: np.array) ->
         raise ValueError(msg)
 
     # Reshape the matrix into an ndarray of shape (2,2,2,2)
-    reshaped_matrix = np.reshape(matrix, newshape=(2, 2, 2, 2))
+    # Use positional argument for backward compatibility with NumPy < 2.0
+    reshaped_matrix = np.reshape(matrix, (2, 2, 2, 2))
 
     # Use np.einsum to apply the gate to `qubit`.
     # To do so, we need to assign subscript labels to each array axis.

python/quantum-pecos/src/pecos/simulators/basic_sv/state.py

@@ -106,12 +106,15 @@ def reset(self):
         self.internal_vector[0] = 1
         # Internally use a ndarray representation so that it's easier to apply gates
         # without needing to apply tensor products.
+
+        # Use positional argument for backward compatibility with NumPy < 2.0
         self.internal_vector = np.reshape(
             self.internal_vector,
-            newshape=[2] * self.num_qubits,
+            [2] * self.num_qubits,
         )
         return self
 
     @property
     def vector(self) -> ArrayLike:
-        return np.reshape(self.internal_vector, newshape=2**self.num_qubits)
+        # Use positional argument for backward compatibility with NumPy < 2.0
+        return np.reshape(self.internal_vector, 2**self.num_qubits)

python/tests/pytest.ini

@@ -18,6 +18,5 @@ markers =
 # ProjectQ has a bunch of deprecation warnings from NumPy because they still use np.matrix instead of np.array
 # TODO: comment this to deal with ProjectQ gate warnings
 filterwarnings =
-    ignore::PendingDeprecationWarning:projectq.ops._gates
-    ignore::DeprecationWarning:dateutil.tz.tz.*
+    ignore::PendingDeprecationWarning:projectq.*
     ignore::DeprecationWarning:cuquantum