qiskit 1.2.0__tar.gz → 1.2.0rc1__tar.gz

{qiskit-1.2.0 → qiskit-1.2.0rc1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: qiskit
-Version: 1.2.0
+Version: 1.2.0rc1
 Summary: An open-source SDK for working with quantum computers at the level of extended quantum circuits, operators, and primitives.
 Author-email: Qiskit Development Team <qiskit@us.ibm.com>
 License: Apache 2.0
@@ -77,7 +77,7 @@ For more details on how to use Qiskit, refer to the documentation located here:
 ## Installation
 
 > [!WARNING]
-> Do not try to upgrade an existing Qiskit 0.* environment to Qiskit 1.0 in-place. [Read more](https://docs.quantum.ibm.com/migration-guides/qiskit-1.0-installation).
+> Do not try to upgrade an existing Qiskit 0.* environment to Qiskit 1.0 in-place. [Read more](https://docs.quantum.ibm.com/api/migration-guides/qiskit-1.0-installation).
 
 We encourage installing Qiskit via ``pip``:
 
@@ -87,7 +87,7 @@ pip install qiskit
 
 Pip will handle all dependencies automatically and you will always install the latest (and well-tested) version.
 
-To install from source, follow the instructions in the [documentation](https://docs.quantum.ibm.com/guides/install-qiskit-source).
+To install from source, follow the instructions in the [documentation](https://docs.quantum.ibm.com/start/install-qiskit-source).
 
 ## Create your first quantum program in Qiskit
 

{qiskit-1.2.0 → qiskit-1.2.0rc1}/README.md

@@ -23,7 +23,7 @@ For more details on how to use Qiskit, refer to the documentation located here:
 ## Installation
 
 > [!WARNING]
-> Do not try to upgrade an existing Qiskit 0.* environment to Qiskit 1.0 in-place. [Read more](https://docs.quantum.ibm.com/migration-guides/qiskit-1.0-installation).
+> Do not try to upgrade an existing Qiskit 0.* environment to Qiskit 1.0 in-place. [Read more](https://docs.quantum.ibm.com/api/migration-guides/qiskit-1.0-installation).
 
 We encourage installing Qiskit via ``pip``:
 
@@ -33,7 +33,7 @@ pip install qiskit
 
 Pip will handle all dependencies automatically and you will always install the latest (and well-tested) version.
 
-To install from source, follow the instructions in the [documentation](https://docs.quantum.ibm.com/guides/install-qiskit-source).
+To install from source, follow the instructions in the [documentation](https://docs.quantum.ibm.com/start/install-qiskit-source).
 
 ## Create your first quantum program in Qiskit
 

{qiskit-1.2.0 → qiskit-1.2.0rc1}/crates/accelerate/src/convert_2q_block_matrix.rs

@@ -145,6 +145,7 @@ pub fn collect_2q_blocks_filter(node: &Bound<PyAny>) -> Option<bool> {
     }
 }
 
+#[pymodule]
 pub fn convert_2q_block_matrix(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(blocks_to_matrix))?;
     m.add_wrapped(wrap_pyfunction!(collect_2q_blocks_filter))?;

{qiskit-1.2.0 → qiskit-1.2.0rc1}/crates/accelerate/src/dense_layout.rs

@@ -244,6 +244,7 @@ pub fn best_subset_inner(
     [rows, cols, best_map]
 }
 
+#[pymodule]
 pub fn dense_layout(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(best_subset))?;
     Ok(())

{qiskit-1.2.0 → qiskit-1.2.0rc1}/crates/accelerate/src/error_map.rs

@@ -111,6 +111,7 @@ impl ErrorMap {
     }
 }
 
+#[pymodule]
 pub fn error_map(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_class::<ErrorMap>()?;
     Ok(())

{qiskit-1.2.0 → qiskit-1.2.0rc1}/crates/accelerate/src/euler_one_qubit_decomposer.rs

@@ -1059,6 +1059,7 @@ pub fn collect_1q_runs_filter(node: &Bound<PyAny>) -> bool {
         }
 }
 
+#[pymodule]
 pub fn euler_one_qubit_decomposer(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(params_zyz))?;
     m.add_wrapped(wrap_pyfunction!(params_xyx))?;

{qiskit-1.2.0 → qiskit-1.2.0rc1}/crates/accelerate/src/isometry.rs

@@ -345,6 +345,7 @@ fn b(k: usize, s: usize) -> usize {
     k - (a(k, s) * 2_usize.pow(s as u32))
 }
 
+#[pymodule]
 pub fn isometry(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(diag_is_identity_up_to_global_phase))?;
     m.add_wrapped(wrap_pyfunction!(find_squs_for_disentangling))?;

{qiskit-1.2.0 → qiskit-1.2.0rc1}/crates/accelerate/src/nlayout.rs

@@ -216,6 +216,7 @@ impl NLayout {
     }
 }
 
+#[pymodule]
 pub fn nlayout(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_class::<NLayout>()?;
     Ok(())

{qiskit-1.2.0 → qiskit-1.2.0rc1}/crates/accelerate/src/optimize_1q_gates.rs

@@ -90,6 +90,7 @@ pub fn compose_u3_rust(
     out_angles
 }
 
+#[pymodule]
 pub fn optimize_1q_gates(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(compose_u3_rust))?;
     Ok(())

{qiskit-1.2.0 → qiskit-1.2.0rc1}/crates/accelerate/src/pauli_exp_val.rs

@@ -193,6 +193,7 @@ pub fn density_expval_pauli_with_x(
     }
 }
 
+#[pymodule]
 pub fn pauli_expval(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(expval_pauli_no_x))?;
     m.add_wrapped(wrap_pyfunction!(expval_pauli_with_x))?;

{qiskit-1.2.0 → qiskit-1.2.0rc1}/crates/accelerate/src/results/mod.rs

@@ -16,6 +16,7 @@ pub mod marginalization;
 use pyo3::prelude::*;
 use pyo3::wrap_pyfunction;
 
+#[pymodule]
 pub fn results(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(marginalization::marginal_counts))?;
     m.add_wrapped(wrap_pyfunction!(marginalization::marginal_distribution))?;

{qiskit-1.2.0 → qiskit-1.2.0rc1}/crates/accelerate/src/sabre/mod.rs

@@ -106,6 +106,7 @@ impl BlockResult {
     }
 }
 
+#[pymodule]
 pub fn sabre(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(route::sabre_routing))?;
     m.add_wrapped(wrap_pyfunction!(layout::sabre_layout_and_routing))?;

{qiskit-1.2.0 → qiskit-1.2.0rc1}/crates/accelerate/src/sampled_exp_val.rs

@@ -87,6 +87,7 @@ pub fn sampled_expval_complex(
     Ok(out.re)
 }
 
+#[pymodule]
 pub fn sampled_exp_val(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(sampled_expval_float))?;
     m.add_wrapped(wrap_pyfunction!(sampled_expval_complex))?;

{qiskit-1.2.0 → qiskit-1.2.0rc1}/crates/accelerate/src/sparse_pauli_op.rs

@@ -819,6 +819,7 @@ impl_to_matrix_sparse!(
     u64
 );
 
+#[pymodule]
 pub fn sparse_pauli_op(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(unordered_unique))?;
     m.add_wrapped(wrap_pyfunction!(decompose_dense))?;

{qiskit-1.2.0 → qiskit-1.2.0rc1}/crates/accelerate/src/star_prerouting.rs

@@ -207,6 +207,7 @@ fn apply_swap(
     }
 }
 
+#[pymodule]
 pub fn star_prerouting(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(star_preroute))?;
     Ok(())

{qiskit-1.2.0 → qiskit-1.2.0rc1}/crates/accelerate/src/stochastic_swap.rs

@@ -335,6 +335,7 @@ pub fn swap_trials(
     Ok((best_edges, best_layout, best_depth))
 }
 
+#[pymodule]
 pub fn stochastic_swap(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(swap_trials))?;
     m.add_class::<EdgeCollection>()?;

{qiskit-1.2.0 → qiskit-1.2.0rc1}/crates/accelerate/src/synthesis/clifford/mod.rs

@@ -57,6 +57,7 @@ fn synth_clifford_bm(py: Python, clifford: PyReadonlyArray2<bool>) -> PyResult<C
     CircuitData::from_standard_gates(py, num_qubits as u32, clifford_gates, Param::Float(0.0))
 }
 
+#[pymodule]
 pub fn clifford(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(synth_clifford_greedy, m)?)?;
     m.add_function(wrap_pyfunction!(synth_clifford_bm, m)?)?;

{qiskit-1.2.0 → qiskit-1.2.0rc1}/crates/accelerate/src/synthesis/linear/mod.rs

@@ -175,6 +175,7 @@ fn check_invertible_binary_matrix(py: Python, mat: PyReadonlyArray2<bool>) -> Py
     Ok(out.to_object(py))
 }
 
+#[pymodule]
 pub fn linear(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(gauss_elimination_with_perm))?;
     m.add_wrapped(wrap_pyfunction!(gauss_elimination))?;

{qiskit-1.2.0 → qiskit-1.2.0rc1}/crates/accelerate/src/synthesis/mod.rs

@@ -15,19 +15,12 @@ pub mod linear;
 mod permutation;
 
 use pyo3::prelude::*;
+use pyo3::wrap_pymodule;
 
+#[pymodule]
 pub fn synthesis(m: &Bound<PyModule>) -> PyResult<()> {
-    let linear_mod = PyModule::new_bound(m.py(), "linear")?;
-    linear::linear(&linear_mod)?;
-    m.add_submodule(&linear_mod)?;
-
-    let permutation_mod = PyModule::new_bound(m.py(), "permutation")?;
-    permutation::permutation(&permutation_mod)?;
-    m.add_submodule(&permutation_mod)?;
-
-    let clifford_mod = PyModule::new_bound(m.py(), "clifford")?;
-    clifford::clifford(&clifford_mod)?;
-    m.add_submodule(&clifford_mod)?;
-
+    m.add_wrapped(wrap_pymodule!(linear::linear))?;
+    m.add_wrapped(wrap_pymodule!(permutation::permutation))?;
+    m.add_wrapped(wrap_pymodule!(clifford::clifford))?;
     Ok(())
 }

{qiskit-1.2.0 → qiskit-1.2.0rc1}/crates/accelerate/src/synthesis/permutation/mod.rs

@@ -114,6 +114,7 @@ pub fn _synth_permutation_depth_lnn_kms(
     )
 }
 
+#[pymodule]
 pub fn permutation(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(_validate_permutation, m)?)?;
     m.add_function(wrap_pyfunction!(_inverse_pattern, m)?)?;

{qiskit-1.2.0 → qiskit-1.2.0rc1}/crates/accelerate/src/two_qubit_decompose.rs

@@ -2254,6 +2254,7 @@ pub fn local_equivalence(weyl: PyReadonlyArray1<f64>) -> PyResult<[f64; 3]> {
     Ok([g0_equiv + 0., g1_equiv + 0., g2_equiv + 0.])
 }
 
+#[pymodule]
 pub fn two_qubit_decompose(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(_num_basis_gates))?;
     m.add_wrapped(wrap_pyfunction!(two_qubit_decompose_up_to_diagonal))?;

{qiskit-1.2.0 → qiskit-1.2.0rc1}/crates/accelerate/src/uc_gate.rs

@@ -156,6 +156,7 @@ pub fn dec_ucg_help(
     )
 }
 
+#[pymodule]
 pub fn uc_gate(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(dec_ucg_help))?;
     Ok(())

{qiskit-1.2.0 → qiskit-1.2.0rc1}/crates/accelerate/src/utils.rs

@@ -41,6 +41,7 @@ pub fn eigenvalues(py: Python, unitary: PyReadonlyArray2<Complex<f64>>) -> PyObj
         .into()
 }
 
+#[pymodule]
 pub fn utils(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(eigenvalues))?;
     Ok(())

{qiskit-1.2.0 → qiskit-1.2.0rc1}/crates/accelerate/src/vf2_layout.rs

@@ -106,6 +106,7 @@ pub fn score_layout(
     Ok(1. - fidelity)
 }
 
+#[pymodule]
 pub fn vf2_layout(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(score_layout))?;
     m.add_class::<EdgeList>()?;

{qiskit-1.2.0 → qiskit-1.2.0rc1}/crates/circuit/src/circuit_data.rs

@@ -343,7 +343,7 @@ impl CircuitData {
     /// Get a (cached) sorted list of the Python-space `Parameter` instances tracked by this circuit
     /// data's parameter table.
     #[getter]
-    pub fn get_parameters<'py>(&self, py: Python<'py>) -> Bound<'py, PyList> {
+    pub fn get_parameters<'py>(&mut self, py: Python<'py>) -> Bound<'py, PyList> {
         self.param_table.py_parameters(py)
     }
 
@@ -834,19 +834,19 @@ impl CircuitData {
         Ok(())
     }
 
-    /// Assign all the circuit parameters, given an iterable input of `Param` instances.
-    fn assign_parameters_iterable(&mut self, sequence: Bound<PyAny>) -> PyResult<()> {
+    /// Assign all the circuit parameters, given a sequence-like input of `Param` instances.
+    fn assign_parameters_sequence(&mut self, sequence: Bound<PyAny>) -> PyResult<()> {
+        if sequence.len()? != self.param_table.num_parameters() {
+            return Err(PyValueError::new_err(concat!(
+                "Mismatching number of values and parameters. For partial binding ",
+                "please pass a dictionary of {parameter: value} pairs."
+            )));
+        }
+        let mut old_table = std::mem::take(&mut self.param_table);
         if let Ok(readonly) = sequence.extract::<PyReadonlyArray1<f64>>() {
             // Fast path for Numpy arrays; in this case we can easily handle them without copying
             // the data across into a Rust-space `Vec` first.
             let array = readonly.as_array();
-            if array.len() != self.param_table.num_parameters() {
-                return Err(PyValueError::new_err(concat!(
-                    "Mismatching number of values and parameters. For partial binding ",
-                    "please pass a dictionary of {parameter: value} pairs."
-                )));
-            }
-            let mut old_table = std::mem::take(&mut self.param_table);
             self.assign_parameters_inner(
                 sequence.py(),
                 array
@@ -855,23 +855,13 @@ impl CircuitData {
                     .map(|(value, (param_ob, uses))| (param_ob, Param::Float(*value), uses)),
             )
         } else {
-            let values = sequence
-                .iter()?
-                .map(|ob| Param::extract_no_coerce(&ob?))
-                .collect::<PyResult<Vec<_>>>()?;
-            if values.len() != self.param_table.num_parameters() {
-                return Err(PyValueError::new_err(concat!(
-                    "Mismatching number of values and parameters. For partial binding ",
-                    "please pass a dictionary of {parameter: value} pairs."
-                )));
-            }
-            let mut old_table = std::mem::take(&mut self.param_table);
+            let values = sequence.extract::<Vec<AssignParam>>()?;
             self.assign_parameters_inner(
                 sequence.py(),
                 values
                     .into_iter()
                     .zip(old_table.drain_ordered())
-                    .map(|(value, (param_ob, uses))| (param_ob, value, uses)),
+                    .map(|(value, (param_ob, uses))| (param_ob, value.0, uses)),
             )
         }
     }

{qiskit-1.2.0 → qiskit-1.2.0rc1}/crates/circuit/src/lib.rs

@@ -56,7 +56,8 @@ impl From<Clbit> for BitType {
     }
 }
 
-pub fn circuit(m: &Bound<PyModule>) -> PyResult<()> {
+#[pymodule]
+pub fn circuit(m: Bound<PyModule>) -> PyResult<()> {
     m.add_class::<circuit_data::CircuitData>()?;
     m.add_class::<dag_node::DAGNode>()?;
     m.add_class::<dag_node::DAGInNode>()?;

{qiskit-1.2.0 → qiskit-1.2.0rc1}/crates/circuit/src/parameter_table.rs

@@ -10,8 +10,6 @@
 // copyright notice, and modified files need to carry a notice indicating
 // that they have been altered from the originals.
 
-use std::cell::OnceCell;
-
 use hashbrown::hash_map::Entry;
 use hashbrown::{HashMap, HashSet};
 use thiserror::Error;
@@ -125,17 +123,18 @@ pub struct ParameterTable {
     by_name: HashMap<PyBackedStr, ParameterUuid>,
     /// Additional information on any `ParameterVector` instances that have elements in the circuit.
     vectors: HashMap<VectorUuid, VectorInfo>,
-    /// Cache of the sort order of the parameters.  This is lexicographical for most parameters,
-    /// except elements of a `ParameterVector` are sorted within the vector by numerical index.  We
-    /// calculate this on demand and cache it.
+    /// Sort order of the parameters.  This is lexicographical for most parameters, except elements
+    /// of a `ParameterVector` are sorted within the vector by numerical index.  We calculate this
+    /// on demand and cache it; an empty `order` implies it is not currently calculated.  We don't
+    /// use `Option<Vec>` so we can re-use the allocation for partial parameter bindings.
     ///
-    /// Any method that adds or removes a parameter needs to invalidate this.
-    order_cache: OnceCell<Vec<ParameterUuid>>,
+    /// Any method that adds or a removes a parameter is responsible for invalidating this cache.
+    order: Vec<ParameterUuid>,
     /// Cache of a Python-space list of the parameter objects, in order.  We only generate this
     /// specifically when asked.
     ///
-    /// Any method that adds or removes a parameter needs to invalidate this.
-    py_parameters_cache: OnceCell<Py<PyList>>,
+    /// Any method that adds or a removes a parameter is responsible for invalidating this cache.
+    py_parameters: Option<Py<PyList>>,
 }
 
 impl ParameterTable {
@@ -195,6 +194,8 @@ impl ParameterTable {
                     None
                 };
                 self.by_name.insert(name.clone(), uuid);
+                self.order.clear();
+                self.py_parameters = None;
                 let mut uses = HashSet::new();
                 if let Some(usage) = usage {
                     uses.insert_unique_unchecked(usage);
@@ -205,7 +206,6 @@ impl ParameterTable {
                     element,
                     object: param_ob.clone().unbind(),
                 });
-                self.invalidate_cache();
             }
         }
         Ok(uuid)
@@ -226,20 +226,19 @@ impl ParameterTable {
     }
 
     /// Get the (maybe cached) Python list of the sorted `Parameter` objects.
-    pub fn py_parameters<'py>(&self, py: Python<'py>) -> Bound<'py, PyList> {
-        self.py_parameters_cache
-            .get_or_init(|| {
-                PyList::new_bound(
-                    py,
-                    self.order_cache
-                        .get_or_init(|| self.sorted_order())
-                        .iter()
-                        .map(|uuid| self.by_uuid[uuid].object.bind(py).clone()),
-                )
-                .unbind()
-            })
-            .bind(py)
-            .clone()
+    pub fn py_parameters<'py>(&mut self, py: Python<'py>) -> Bound<'py, PyList> {
+        if let Some(py_parameters) = self.py_parameters.as_ref() {
+            return py_parameters.clone_ref(py).into_bound(py);
+        }
+        self.ensure_sorted();
+        let out = PyList::new_bound(
+            py,
+            self.order
+                .iter()
+                .map(|uuid| self.by_uuid[uuid].object.clone_ref(py).into_bound(py)),
+        );
+        self.py_parameters = Some(out.clone().unbind());
+        out
     }
 
     /// Get a Python set of all tracked `Parameter` objects.
@@ -247,18 +246,23 @@ impl ParameterTable {
         PySet::new_bound(py, self.by_uuid.values().map(|info| &info.object))
     }
 
-    /// Get the sorted order of the `ParameterTable`.  This does not access the cache.
-    fn sorted_order(&self) -> Vec<ParameterUuid> {
-        let mut out = self.by_uuid.keys().copied().collect::<Vec<_>>();
-        out.sort_unstable_by_key(|uuid| {
+    /// Ensure that the `order` field is populated and sorted.
+    fn ensure_sorted(&mut self) {
+        // If `order` is already populated, it's sorted; it's the responsibility of the methods of
+        // this struct that mutate it to invalidate the cache.
+        if !self.order.is_empty() {
+            return;
+        }
+        self.order.reserve(self.by_uuid.len());
+        self.order.extend(self.by_uuid.keys());
+        self.order.sort_unstable_by_key(|uuid| {
             let info = &self.by_uuid[uuid];
             if let Some(vec) = info.element.as_ref() {
                 (&self.vectors[&vec.vector_uuid].name, vec.index)
             } else {
                 (&info.name, 0)
             }
-        });
-        out
+        })
     }
 
     /// Add a use of a parameter to the table.
@@ -301,8 +305,9 @@ impl ParameterTable {
                     vec_entry.remove_entry();
                 }
             }
+            self.order.clear();
+            self.py_parameters = None;
             entry.remove_entry();
-            self.invalidate_cache();
         }
         Ok(())
     }
@@ -327,28 +332,26 @@ impl ParameterTable {
                     (vector_info.refcount > 0).then_some(vector_info)
                 });
         }
-        self.invalidate_cache();
+        self.order.clear();
+        self.py_parameters = None;
         Ok(info.uses)
     }
 
     /// Clear this table, yielding the Python parameter objects and their uses in sorted order.
-    ///
-    /// The clearing effect is eager and not dependent on the iteration.
     pub fn drain_ordered(
-        &mut self,
-    ) -> impl ExactSizeIterator<Item = (Py<PyAny>, HashSet<ParameterUse>)> {
-        let order = self
-            .order_cache
-            .take()
-            .unwrap_or_else(|| self.sorted_order());
-        let by_uuid = ::std::mem::take(&mut self.by_uuid);
+        &'_ mut self,
+    ) -> impl Iterator<Item = (Py<PyAny>, HashSet<ParameterUse>)> + '_ {
+        self.ensure_sorted();
         self.by_name.clear();
         self.vectors.clear();
-        self.py_parameters_cache.take();
-        ParameterTableDrain {
-            order: order.into_iter(),
-            by_uuid,
-        }
+        self.py_parameters = None;
+        self.order.drain(..).map(|uuid| {
+            let info = self
+                .by_uuid
+                .remove(&uuid)
+                .expect("tracked UUIDs should be consistent");
+            (info.object, info.uses)
+        })
     }
 
     /// Empty this `ParameterTable` of all its contents.  This does not affect the capacities of the
@@ -357,12 +360,8 @@ impl ParameterTable {
         self.by_uuid.clear();
         self.by_name.clear();
         self.vectors.clear();
-        self.invalidate_cache();
-    }
-
-    fn invalidate_cache(&mut self) {
-        self.order_cache.take();
-        self.py_parameters_cache.take();
+        self.order.clear();
+        self.py_parameters = None;
     }
 
     /// Expose the tracked data for a given parameter as directly as possible to Python space.
@@ -397,33 +396,9 @@ impl ParameterTable {
             visit.call(&info.object)?
         }
         // We don't need to / can't visit the `PyBackedStr` stores.
-        if let Some(list) = self.py_parameters_cache.get() {
+        if let Some(list) = self.py_parameters.as_ref() {
             visit.call(list)?
         }
         Ok(())
     }
 }
-
-struct ParameterTableDrain {
-    order: ::std::vec::IntoIter<ParameterUuid>,
-    by_uuid: HashMap<ParameterUuid, ParameterInfo>,
-}
-impl Iterator for ParameterTableDrain {
-    type Item = (Py<PyAny>, HashSet<ParameterUse>);
-
-    fn next(&mut self) -> Option<Self::Item> {
-        self.order.next().map(|uuid| {
-            let info = self
-                .by_uuid
-                .remove(&uuid)
-                .expect("tracked UUIDs should be consistent");
-            (info.object, info.uses)
-        })
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.order.size_hint()
-    }
-}
-impl ExactSizeIterator for ParameterTableDrain {}
-impl ::std::iter::FusedIterator for ParameterTableDrain {}

qiskit-1.2.0rc1/crates/pyext/src/lib.rs

@@ -0,0 +1,52 @@
+// This code is part of Qiskit.
+//
+// (C) Copyright IBM 2024
+//
+// This code is licensed under the Apache License, Version 2.0. You may
+// obtain a copy of this license in the LICENSE.txt file in the root directory
+// of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+//
+// Any modifications or derivative works of this code must retain this
+// copyright notice, and modified files need to carry a notice indicating
+// that they have been altered from the originals.
+
+use pyo3::prelude::*;
+use pyo3::wrap_pymodule;
+
+use qiskit_accelerate::{
+    convert_2q_block_matrix::convert_2q_block_matrix, dense_layout::dense_layout,
+    error_map::error_map, euler_one_qubit_decomposer::euler_one_qubit_decomposer,
+    isometry::isometry, nlayout::nlayout, optimize_1q_gates::optimize_1q_gates,
+    pauli_exp_val::pauli_expval, results::results, sabre::sabre, sampled_exp_val::sampled_exp_val,
+    sparse_pauli_op::sparse_pauli_op, star_prerouting::star_prerouting,
+    stochastic_swap::stochastic_swap, synthesis::synthesis,
+    two_qubit_decompose::two_qubit_decompose, uc_gate::uc_gate, utils::utils,
+    vf2_layout::vf2_layout,
+};
+
+#[pymodule]
+fn _accelerate(m: &Bound<PyModule>) -> PyResult<()> {
+    m.add_wrapped(wrap_pymodule!(qiskit_circuit::circuit))?;
+    m.add_wrapped(wrap_pymodule!(qiskit_qasm2::qasm2))?;
+    m.add_wrapped(wrap_pymodule!(qiskit_qasm3::qasm3))?;
+    m.add_wrapped(wrap_pymodule!(convert_2q_block_matrix))?;
+    m.add_wrapped(wrap_pymodule!(dense_layout))?;
+    m.add_wrapped(wrap_pymodule!(error_map))?;
+    m.add_wrapped(wrap_pymodule!(euler_one_qubit_decomposer))?;
+    m.add_wrapped(wrap_pymodule!(isometry))?;
+    m.add_wrapped(wrap_pymodule!(nlayout))?;
+    m.add_wrapped(wrap_pymodule!(optimize_1q_gates))?;
+    m.add_wrapped(wrap_pymodule!(pauli_expval))?;
+    m.add_wrapped(wrap_pymodule!(synthesis))?;
+    m.add_wrapped(wrap_pymodule!(results))?;
+    m.add_wrapped(wrap_pymodule!(sabre))?;
+    m.add_wrapped(wrap_pymodule!(sampled_exp_val))?;
+    m.add_wrapped(wrap_pymodule!(sparse_pauli_op))?;
+    m.add_wrapped(wrap_pymodule!(star_prerouting))?;
+    m.add_wrapped(wrap_pymodule!(stochastic_swap))?;
+    m.add_wrapped(wrap_pymodule!(two_qubit_decompose))?;
+    m.add_wrapped(wrap_pymodule!(uc_gate))?;
+    m.add_wrapped(wrap_pymodule!(utils))?;
+    m.add_wrapped(wrap_pymodule!(vf2_layout))?;
+    Ok(())
+}

{qiskit-1.2.0 → qiskit-1.2.0rc1}/crates/qasm2/src/lib.rs

@@ -123,6 +123,7 @@ fn bytecode_from_file(
 /// An interface to the Rust components of the parser stack, and the types it uses to represent the
 /// output.  The principal entry points for Python are :func:`bytecode_from_string` and
 /// :func:`bytecode_from_file`, which produce iterables of :class:`Bytecode` objects.
+#[pymodule]
 pub fn qasm2(module: &Bound<PyModule>) -> PyResult<()> {
     module.add_class::<bytecode::OpCode>()?;
     module.add_class::<bytecode::UnaryOpCode>()?;

{qiskit-1.2.0 → qiskit-1.2.0rc1}/crates/qasm3/src/lib.rs

@@ -153,6 +153,7 @@ pub fn load(
 
 /// Internal module supplying the OpenQASM 3 import capabilities.  The entries in it should largely
 /// be re-exposed directly to public Python space.
+#[pymodule]
 pub fn qasm3(module: &Bound<PyModule>) -> PyResult<()> {
     module.add_function(wrap_pyfunction!(loads, module)?)?;
     module.add_function(wrap_pyfunction!(load, module)?)?;

{qiskit-1.2.0 → qiskit-1.2.0rc1}/pyproject.toml

@@ -156,14 +156,14 @@ environment = 'RUSTUP_TOOLCHAIN="stable"'
 [tool.cibuildwheel.linux]
 before-all = "yum install -y wget && {package}/tools/install_rust.sh"
 environment = 'PATH="$PATH:$HOME/.cargo/bin" CARGO_NET_GIT_FETCH_WITH_CLI="true" RUSTUP_TOOLCHAIN="stable"'
-repair-wheel-command = "auditwheel repair -w {dest_dir} {wheel} && pipx run abi3audit --strict --report {wheel}"
+repair-wheel-command = "auditwheel repair -w {dest_dir} {wheel} && pip install 'abi3audit==0.0.10' && abi3audit --strict --report {wheel}"
 
 [tool.cibuildwheel.macos]
 environment = "MACOSX_DEPLOYMENT_TARGET=10.12"
-repair-wheel-command = "delocate-wheel --require-archs {delocate_archs} -w {dest_dir} -v {wheel} && pipx run abi3audit --strict --report {wheel}"
+repair-wheel-command = "delocate-wheel --require-archs {delocate_archs} -w {dest_dir} -v {wheel} && pip install 'abi3audit==0.0.10' && abi3audit --strict --report {wheel}"
 
 [tool.cibuildwheel.windows]
-repair-wheel-command = "cp {wheel} {dest_dir}/. && pipx run abi3audit --strict --report {wheel}"
+repair-wheel-command = "cp {wheel} {dest_dir}/. && pip install abi3audit==0.0.10 && abi3audit --strict --report {wheel}"
 
 [tool.ruff]
 select = [

qiskit-1.2.0rc1/qiskit/VERSION.txt

@@ -0,0 +1 @@
+1.2.0rc1