qiskit 1.3.0__cp39-abi3-win32.whl → 1.3.0b1__cp39-abi3-win32.whl

qiskit/compiler/sequencer.py

@@ -21,10 +21,8 @@ from qiskit.providers.backend import Backend
 from qiskit.pulse import InstructionScheduleMap, Schedule
 from qiskit.scheduler import ScheduleConfig
 from qiskit.scheduler.sequence import sequence as _sequence
-from qiskit.utils.deprecate_pulse import deprecate_pulse_dependency
 
 
-@deprecate_pulse_dependency(moving_to_dynamics=True)
 def sequence(
     scheduled_circuits: Union[QuantumCircuit, List[QuantumCircuit]],
     backend: Optional[Backend] = None,

qiskit/compiler/transpiler.py

@@ -32,41 +32,12 @@ from qiskit.transpiler.instruction_durations import InstructionDurationsType
 from qiskit.transpiler.passes.synthesis.high_level_synthesis import HLSConfig
 from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
 from qiskit.transpiler.target import Target
-from qiskit.utils import deprecate_arg
-from qiskit.utils.deprecate_pulse import deprecate_pulse_arg
 
 logger = logging.getLogger(__name__)
 
 _CircuitT = TypeVar("_CircuitT", bound=Union[QuantumCircuit, List[QuantumCircuit]])
 
 
-@deprecate_arg(
-    name="instruction_durations",
-    since="1.3",
-    package_name="Qiskit",
-    removal_timeline="in Qiskit 2.0",
-    additional_msg="The `target` parameter should be used instead. You can build a `Target` instance "
-    "with defined instruction durations with "
-    "`Target.from_configuration(..., instruction_durations=...)`",
-)
-@deprecate_arg(
-    name="timing_constraints",
-    since="1.3",
-    package_name="Qiskit",
-    removal_timeline="in Qiskit 2.0",
-    additional_msg="The `target` parameter should be used instead. You can build a `Target` instance "
-    "with defined timing constraints with "
-    "`Target.from_configuration(..., timing_constraints=...)`",
-)
-@deprecate_arg(
-    name="backend_properties",
-    since="1.3",
-    package_name="Qiskit",
-    removal_timeline="in Qiskit 2.0",
-    additional_msg="The `target` parameter should be used instead. You can build a `Target` instance "
-    "with defined properties with Target.from_configuration(..., backend_properties=...)",
-)
-@deprecate_pulse_arg("inst_map", predicate=lambda inst_map: inst_map is not None)
 def transpile(  # pylint: disable=too-many-return-statements
     circuits: _CircuitT,
     backend: Optional[Backend] = None,
@@ -133,7 +104,7 @@ def transpile(  # pylint: disable=too-many-return-statements
             will override the backend's.
         basis_gates: List of basis gate names to unroll to
             (e.g: ``['u1', 'u2', 'u3', 'cx']``). If ``None``, do not unroll.
-        inst_map: DEPRECATED. Mapping of unrolled gates to pulse schedules. If this is not provided,
+        inst_map: Mapping of unrolled gates to pulse schedules. If this is not provided,
             transpiler tries to get from the backend. If any user defined calibration
             is found in the map and this is used in a circuit, transpiler attaches
             the custom gate definition to the circuit. This enables one to flexibly
@@ -394,57 +365,31 @@ def transpile(  # pylint: disable=too-many-return-statements
     # Edge cases require using the old model (loose constraints) instead of building a target,
     # but we don't populate the passmanager config with loose constraints unless it's one of
     # the known edge cases to control the execution path.
-    # Filter instruction_durations, timing_constraints, backend_properties and inst_map deprecation
-    with warnings.catch_warnings():
-        warnings.filterwarnings(
-            "ignore",
-            category=DeprecationWarning,
-            message=".*``inst_map`` is deprecated as of Qiskit 1.3.*",
-            module="qiskit",
-        )
-        warnings.filterwarnings(
-            "ignore",
-            category=DeprecationWarning,
-            message=".*``timing_constraints`` is deprecated as of Qiskit 1.3.*",
-            module="qiskit",
-        )
-        warnings.filterwarnings(
-            "ignore",
-            category=DeprecationWarning,
-            message=".*``instruction_durations`` is deprecated as of Qiskit 1.3.*",
-            module="qiskit",
-        )
-        warnings.filterwarnings(
-            "ignore",
-            category=DeprecationWarning,
-            message=".*``backend_properties`` is deprecated as of Qiskit 1.3.*",
-            module="qiskit",
-        )
-        pm = generate_preset_pass_manager(
-            optimization_level,
-            target=target,
-            backend=backend,
-            basis_gates=basis_gates,
-            coupling_map=coupling_map,
-            instruction_durations=instruction_durations,
-            backend_properties=backend_properties,
-            timing_constraints=timing_constraints,
-            inst_map=inst_map,
-            initial_layout=initial_layout,
-            layout_method=layout_method,
-            routing_method=routing_method,
-            translation_method=translation_method,
-            scheduling_method=scheduling_method,
-            approximation_degree=approximation_degree,
-            seed_transpiler=seed_transpiler,
-            unitary_synthesis_method=unitary_synthesis_method,
-            unitary_synthesis_plugin_config=unitary_synthesis_plugin_config,
-            hls_config=hls_config,
-            init_method=init_method,
-            optimization_method=optimization_method,
-            dt=dt,
-            qubits_initially_zero=qubits_initially_zero,
-        )
+    pm = generate_preset_pass_manager(
+        optimization_level,
+        target=target,
+        backend=backend,
+        basis_gates=basis_gates,
+        coupling_map=coupling_map,
+        instruction_durations=instruction_durations,
+        backend_properties=backend_properties,
+        timing_constraints=timing_constraints,
+        inst_map=inst_map,
+        initial_layout=initial_layout,
+        layout_method=layout_method,
+        routing_method=routing_method,
+        translation_method=translation_method,
+        scheduling_method=scheduling_method,
+        approximation_degree=approximation_degree,
+        seed_transpiler=seed_transpiler,
+        unitary_synthesis_method=unitary_synthesis_method,
+        unitary_synthesis_plugin_config=unitary_synthesis_plugin_config,
+        hls_config=hls_config,
+        init_method=init_method,
+        optimization_method=optimization_method,
+        dt=dt,
+        qubits_initially_zero=qubits_initially_zero,
+    )
 
     out_circuits = pm.run(circuits, callback=callback, num_processes=num_processes)
 

qiskit/converters/circuit_to_dag.py

@@ -73,6 +73,6 @@ def circuit_to_dag(circuit, copy_operations=True, *, qubit_order=None, clbit_ord
 
     dagcircuit = core_circuit_to_dag(circuit, copy_operations, qubit_order, clbit_order)
 
-    dagcircuit.duration = circuit._duration
-    dagcircuit.unit = circuit._unit
+    dagcircuit.duration = circuit.duration
+    dagcircuit.unit = circuit.unit
     return dagcircuit

qiskit/converters/circuit_to_dagdependency.py

@@ -46,6 +46,6 @@ def circuit_to_dagdependency(circuit, create_preds_and_succs=True):
         dagdependency._add_predecessors()
         dagdependency._add_successors()
 
-    dagdependency._calibrations = circuit._calibrations_prop
+    dagdependency.calibrations = circuit.calibrations
 
     return dagdependency

qiskit/converters/circuit_to_dagdependency_v2.py

@@ -27,7 +27,7 @@ def _circuit_to_dagdependency_v2(circuit):
     dagdependency = _DAGDependencyV2()
     dagdependency.name = circuit.name
     dagdependency.metadata = circuit.metadata
-    dagdependency._calibrations = circuit._calibrations_prop
+    dagdependency.calibrations = circuit.calibrations
     dagdependency.global_phase = circuit.global_phase
 
     dagdependency.add_qubits(circuit.qubits)

qiskit/converters/circuit_to_instruction.py

@@ -125,7 +125,7 @@ def circuit_to_instruction(circuit, parameter_map=None, equivalence_library=None
         if (out := operation_map.get(original_id)) is not None:
             return out
 
-        condition = getattr(op, "_condition", None)
+        condition = getattr(op, "condition", None)
         if condition:
             reg, val = condition
             if isinstance(reg, Clbit):

qiskit/converters/dag_to_circuit.py

@@ -13,7 +13,6 @@
 """Helper function for converting a dag to a circuit."""
 
 from qiskit.circuit import QuantumCircuit
-from qiskit._accelerate.converters import dag_to_circuit as dag_to_circuit_rs
 
 
 def dag_to_circuit(dag, copy_operations=True):
@@ -55,8 +54,6 @@ def dag_to_circuit(dag, copy_operations=True):
     """
 
     name = dag.name or None
-
-    circuit_data = dag_to_circuit_rs(dag, copy_operations)
     circuit = QuantumCircuit(
         dag.qubits,
         dag.clbits,
@@ -70,10 +67,11 @@ def dag_to_circuit(dag, copy_operations=True):
     for var in dag.iter_declared_vars():
         circuit.add_uninitialized_var(var)
     circuit.metadata = dag.metadata
-    circuit._calibrations_prop = dag._calibrations_prop
+    circuit.calibrations = dag.calibrations
 
-    circuit._data = circuit_data
+    for node in dag.topological_op_nodes():
+        circuit._append(node._to_circuit_instruction(deepcopy=copy_operations))
 
-    circuit._duration = dag.duration
-    circuit._unit = dag.unit
+    circuit.duration = dag.duration
+    circuit.unit = dag.unit
     return circuit

qiskit/converters/dag_to_dagdependency.py

@@ -50,6 +50,6 @@ def dag_to_dagdependency(dag, create_preds_and_succs=True):
 
     # copy metadata
     dagdependency.global_phase = dag.global_phase
-    dagdependency._calibrations_prop = dag._calibrations_prop
+    dagdependency.calibrations = dag.calibrations
 
     return dagdependency

qiskit/converters/dag_to_dagdependency_v2.py

@@ -27,7 +27,7 @@ def _dag_to_dagdependency_v2(dag):
     dagdependency.name = dag.name
     dagdependency.metadata = dag.metadata
     dagdependency.global_phase = dag.global_phase
-    dagdependency.calibrations = dag._calibrations_prop
+    dagdependency.calibrations = dag.calibrations
 
     dagdependency.add_qubits(dag.qubits)
     dagdependency.add_clbits(dag.clbits)

qiskit/converters/dagdependency_to_circuit.py

@@ -34,11 +34,7 @@ def dagdependency_to_circuit(dagdependency):
     )
     circuit.metadata = dagdependency.metadata
 
-    if hasattr(dagdependency, "_calibrations_prop"):
-        circuit._calibrations_prop = dagdependency._calibrations_prop
-    else:
-        # This can be _DAGDependencyV2
-        circuit._calibrations_prop = dagdependency.calibrations
+    circuit.calibrations = dagdependency.calibrations
 
     for node in dagdependency.topological_nodes():
         circuit._append(CircuitInstruction(node.op.copy(), node.qargs, node.cargs))

qiskit/converters/dagdependency_to_dag.py

@@ -12,7 +12,6 @@
 
 """Helper function for converting a dag dependency to a dag circuit"""
 from qiskit.dagcircuit.dagcircuit import DAGCircuit
-from qiskit.dagcircuit.dagdependency import DAGDependency
 
 
 def dagdependency_to_dag(dagdependency):
@@ -45,10 +44,6 @@ def dagdependency_to_dag(dagdependency):
 
     # copy metadata
     dagcircuit.global_phase = dagdependency.global_phase
-    if isinstance(dagdependency, DAGDependency):
-        dagcircuit._calibrations_prop = dagdependency._calibrations_prop
-    else:
-        # This can be _DAGDependencyV2
-        dagcircuit._calibrations_prop = dagdependency.calibrations
+    dagcircuit.calibrations = dagdependency.calibrations
 
     return dagcircuit

qiskit/dagcircuit/collect_blocks.py

@@ -306,7 +306,7 @@ def split_block_into_layers(block: list[DAGOpNode | DAGDepNode]):
         cur_bits = set(node.qargs)
         cur_bits.update(node.cargs)
 
-        cond = getattr(node.op, "_condition", None)
+        cond = getattr(node.op, "condition", None)
         if cond is not None:
             cur_bits.update(condition_resources(cond).clbits)
 
@@ -356,7 +356,7 @@ class BlockCollapser:
             for node in block:
                 cur_qubits.update(node.qargs)
                 cur_clbits.update(node.cargs)
-                cond = getattr(node.op, "_condition", None)
+                cond = getattr(node.op, "condition", None)
                 if cond is not None:
                     cur_clbits.update(condition_resources(cond).clbits)
                     if isinstance(cond[0], ClassicalRegister):
@@ -378,7 +378,7 @@ class BlockCollapser:
 
             for node in block:
                 instructions = qc.append(CircuitInstruction(node.op, node.qargs, node.cargs))
-                cond = getattr(node.op, "_condition", None)
+                cond = getattr(node.op, "condition", None)
                 if cond is not None:
                     instructions.c_if(*cond)
 

qiskit/dagcircuit/dagdependency.py

@@ -29,7 +29,6 @@ from qiskit.circuit.classicalregister import ClassicalRegister, Clbit
 from qiskit.dagcircuit.exceptions import DAGDependencyError
 from qiskit.dagcircuit.dagdepnode import DAGDepNode
 from qiskit.pulse import Schedule
-from qiskit.utils.deprecate_pulse import deprecate_pulse_dependency
 
 if typing.TYPE_CHECKING:
     from qiskit.circuit.parameterexpression import ParameterExpression
@@ -72,7 +71,7 @@ class DAGDependency:
 
     Bell circuit with no measurement.
 
-    .. code-block:: text
+    .. parsed-literal::
 
               ┌───┐
         qr_0: ┤ H ├──■──
@@ -147,17 +146,15 @@ class DAGDependency:
                 self._global_phase = angle % (2 * math.pi)
 
     @property
-    @deprecate_pulse_dependency(is_property=True)
     def calibrations(self) -> dict[str, dict[tuple, Schedule]]:
         """Return calibration dictionary.
 
         The custom pulse definition of a given gate is of the form
         ``{'gate_name': {(qubits, params): schedule}}``.
         """
-        return self._calibrations_prop
+        return dict(self._calibrations)
 
     @calibrations.setter
-    @deprecate_pulse_dependency(is_property=True)
     def calibrations(self, calibrations: dict[str, dict[tuple, Schedule]]):
         """Set the circuit calibration data from a dictionary of calibration definition.
 
@@ -165,16 +162,6 @@ class DAGDependency:
             calibrations (dict): A dictionary of input in the format
                 {'gate_name': {(qubits, gate_params): schedule}}
         """
-        self._calibrations_prop = calibrations
-
-    @property
-    def _calibrations_prop(self) -> dict[str, dict[tuple, Schedule]]:
-        """An alternative path to be used internally to avoid deprecation warnings"""
-        return dict(self._calibrations)
-
-    @_calibrations_prop.setter
-    def _calibrations_prop(self, calibrations: dict[str, dict[tuple, Schedule]]):
-        """An alternative path to be used internally to avoid deprecation warnings"""
         self._calibrations = defaultdict(dict, calibrations)
 
     def to_retworkx(self):
@@ -409,13 +396,13 @@ class DAGDependency:
             for elem in qargs:
                 qindices_list.append(self.qubits.index(elem))
 
-            if getattr(operation, "_condition", None):
+            if getattr(operation, "condition", None):
                 # The change to handling operation.condition follows code patterns in quantum_circuit.py.
                 # However:
                 #   (1) cindices_list are specific to template optimization and should not be computed
                 #       in this place.
                 #   (2) Template optimization pass needs currently does not handle general conditions.
-                cond_bits = condition_resources(operation._condition).clbits
+                cond_bits = condition_resources(operation.condition).clbits
                 cindices_list = [self.clbits.index(clbit) for clbit in cond_bits]
             else:
                 cindices_list = []
@@ -609,7 +596,7 @@ class DAGDependency:
         for nd in node_block:
             block_qargs |= set(nd.qargs)
             block_cargs |= set(nd.cargs)
-            cond = getattr(nd.op, "_condition", None)
+            cond = getattr(nd.op, "condition", None)
             if cond is not None:
                 block_cargs.update(condition_resources(cond).clbits)
 

qiskit/dagcircuit/dagdependency_v2.py

@@ -56,7 +56,7 @@ class _DAGDependencyV2:
 
     Bell circuit with no measurement.
 
-    .. code-block:: text
+    .. parsed-literal::
 
               ┌───┐
         qr_0: ┤ H ├──■──

qiskit/dagcircuit/dagnode.py

@@ -92,8 +92,8 @@ def _make_expr_key(bit_indices):
 
 
 def _condition_op_eq(node1, node2, bit_indices1, bit_indices2):
-    cond1 = node1.condition
-    cond2 = node2.condition
+    cond1 = node1.op.condition
+    cond2 = node2.op.condition
     if isinstance(cond1, expr.Expr) and isinstance(cond2, expr.Expr):
         if not expr.structurally_equivalent(
             cond1, cond2, _make_expr_key(bit_indices1), _make_expr_key(bit_indices2)

qiskit/passmanager/__init__.py

@@ -133,7 +133,7 @@ new numbers that don't contain five.
 
 Output:
 
-.. code-block:: text
+.. parsed-literal::
 
     [12346789, 464, 36784]
 
@@ -178,7 +178,7 @@ As before, we schedule these passes with the pass manager and run.
 
 Output:
 
-.. code-block:: text
+.. parsed-literal::
 
     [12346789, 45654, 36784]
 

qiskit/primitives/backend_estimator.py

@@ -44,15 +44,13 @@ from .utils import _circuit_key, _observable_key, init_observable
 def _run_circuits(
     circuits: QuantumCircuit | list[QuantumCircuit],
     backend: BackendV1 | BackendV2,
-    clear_metadata: bool = True,
     **run_options,
 ) -> tuple[list[Result], list[dict]]:
     """Remove metadata of circuits and run the circuits on a backend.
     Args:
         circuits: The circuits
         backend: The backend
-        clear_metadata: Clear circuit metadata before passing to backend.run if
-            True.
+        monitor: Enable job minotor if True
         **run_options: run_options
     Returns:
         The result and the metadata of the circuits
@@ -62,8 +60,7 @@ def _run_circuits(
     metadata = []
     for circ in circuits:
         metadata.append(circ.metadata)
-        if clear_metadata:
-            circ.metadata = {}
+        circ.metadata = {}
     if isinstance(backend, BackendV1):
         max_circuits = getattr(backend.configuration(), "max_experiments", None)
     elif isinstance(backend, BackendV2):

qiskit/primitives/backend_sampler_v2.py

@@ -17,13 +17,12 @@ from __future__ import annotations
 import warnings
 from collections import defaultdict
 from dataclasses import dataclass
-from typing import Any, Iterable, Union
+from typing import Iterable
 
 import numpy as np
 from numpy.typing import NDArray
 
 from qiskit.circuit import QuantumCircuit
-from qiskit.exceptions import QiskitError
 from qiskit.primitives.backend_estimator import _run_circuits
 from qiskit.primitives.base import BaseSamplerV2
 from qiskit.primitives.containers import (
@@ -54,11 +53,6 @@ class Options:
     Default: None.
     """
 
-    run_options: dict[str, Any] | None = None
-    """A dictionary of options to pass to the backend's ``run()`` method.
-    Default: None (no option passed to backend's ``run`` method)
-    """
-
 
 @dataclass
 class _MeasureInfo:
@@ -68,16 +62,6 @@ class _MeasureInfo:
     start: int
 
 
-ResultMemory = Union[list[str], list[list[float]], list[list[list[float]]]]
-"""Type alias for possible level 2 and level 1 result memory formats. For level
-2, the format is a list of bit strings. For level 1, format can be either a
-list of I/Q pairs (list with two floats) for each memory slot if using
-``meas_return=avg`` or a list of of lists of I/Q pairs if using
-``meas_return=single`` with the outer list indexing shot number and the inner
-list indexing memory slot.
-"""
-
-
 class BackendSamplerV2(BaseSamplerV2):
     """Evaluates bitstrings for provided quantum circuits
 
@@ -107,9 +91,6 @@ class BackendSamplerV2(BaseSamplerV2):
     * ``seed_simulator``: The seed to use in the simulator. If None, a random seed will be used.
       Default: None.
 
-    * ``run_options``: A dictionary of options to pass through to the ``run()``
-      method of the wrapped :class:`~.BackendV2` instance.
-
     .. note::
 
         This class requires a backend that supports ``memory`` option.
@@ -184,27 +165,19 @@ class BackendSamplerV2(BaseSamplerV2):
         for circuits in bound_circuits:
             flatten_circuits.extend(np.ravel(circuits).tolist())
 
-        run_opts = self._options.run_options or {}
         # run circuits
         results, _ = _run_circuits(
             flatten_circuits,
             self._backend,
-            clear_metadata=False,
             memory=True,
             shots=shots,
             seed_simulator=self._options.seed_simulator,
-            **run_opts,
         )
         result_memory = _prepare_memory(results)
 
         # pack memory to an ndarray of uint8
         results = []
         start = 0
-        meas_level = (
-            None
-            if self._options.run_options is None
-            else self._options.run_options.get("meas_level")
-        )
         for pub, bound in zip(pubs, bound_circuits):
             meas_info, max_num_bytes = _analyze_circuit(pub.circuit)
             end = start + bound.size
@@ -216,7 +189,6 @@ class BackendSamplerV2(BaseSamplerV2):
                     meas_info,
                     max_num_bytes,
                     pub.circuit.metadata,
-                    meas_level,
                 )
             )
             start = end
@@ -225,43 +197,28 @@ class BackendSamplerV2(BaseSamplerV2):
 
     def _postprocess_pub(
         self,
-        result_memory: list[ResultMemory],
+        result_memory: list[list[str]],
         shots: int,
         shape: tuple[int, ...],
         meas_info: list[_MeasureInfo],
         max_num_bytes: int,
         circuit_metadata: dict,
-        meas_level: int | None,
     ) -> SamplerPubResult:
-        """Converts the memory data into a sampler pub result
-
-        For level 2 data, the memory data are stored in an array of bit arrays
-        with the shape of the pub. For level 1 data, the data are stored in a
-        complex numpy array.
-        """
-        if meas_level == 2 or meas_level is None:
-            arrays = {
-                item.creg_name: np.zeros(shape + (shots, item.num_bytes), dtype=np.uint8)
-                for item in meas_info
-            }
-            memory_array = _memory_array(result_memory, max_num_bytes)
-
-            for samples, index in zip(memory_array, np.ndindex(*shape)):
-                for item in meas_info:
-                    ary = _samples_to_packed_array(samples, item.num_bits, item.start)
-                    arrays[item.creg_name][index] = ary
-
-            meas = {
-                item.creg_name: BitArray(arrays[item.creg_name], item.num_bits)
-                for item in meas_info
-            }
-        elif meas_level == 1:
-            raw = np.array(result_memory)
-            cplx = raw[..., 0] + 1j * raw[..., 1]
-            cplx = np.reshape(cplx, (*shape, *cplx.shape[1:]))
-            meas = {item.creg_name: cplx for item in meas_info}
-        else:
-            raise QiskitError(f"Unsupported meas_level: {meas_level}")
+        """Converts the memory data into an array of bit arrays with the shape of the pub."""
+        arrays = {
+            item.creg_name: np.zeros(shape + (shots, item.num_bytes), dtype=np.uint8)
+            for item in meas_info
+        }
+        memory_array = _memory_array(result_memory, max_num_bytes)
+
+        for samples, index in zip(memory_array, np.ndindex(*shape)):
+            for item in meas_info:
+                ary = _samples_to_packed_array(samples, item.num_bits, item.start)
+                arrays[item.creg_name][index] = ary
+
+        meas = {
+            item.creg_name: BitArray(arrays[item.creg_name], item.num_bits) for item in meas_info
+        }
         return SamplerPubResult(
             DataBin(**meas, shape=shape),
             metadata={"shots": shots, "circuit_metadata": circuit_metadata},
@@ -291,7 +248,7 @@ def _analyze_circuit(circuit: QuantumCircuit) -> tuple[list[_MeasureInfo], int]:
     return meas_info, _min_num_bytes(max_num_bits)
 
 
-def _prepare_memory(results: list[Result]) -> list[ResultMemory]:
+def _prepare_memory(results: list[Result]) -> list[list[str]]:
     """Joins splitted results if exceeding max_experiments"""
     lst = []
     for res in results:

qiskit/primitives/base/base_estimator.py

@@ -92,7 +92,7 @@ class BaseEstimatorV1(BasePrimitive, Generic[T]):
         # calculate [ <psi1(theta1)|H1|psi1(theta1)> ]
         job = estimator.run([psi1], [H1], [theta1])
         job_result = job.result() # It will block until the job finishes.
-        print(f"The primitive-job finished with result {job_result}")
+        print(f"The primitive-job finished with result {job_result}"))
 
         # calculate [ <psi1(theta1)|H1|psi1(theta1)>,
         #             <psi2(theta2)|H2|psi2(theta2)>,
@@ -144,7 +144,7 @@ class BaseEstimatorV1(BasePrimitive, Generic[T]):
 
         .. code-block:: python
 
-            values = parameter_values[i]
+            values = parameter_values[i].
 
         Args:
             circuits: one or more circuit objects.

qiskit/primitives/containers/data_bin.py

@@ -34,22 +34,14 @@ class DataBin(ShapedMixin):
 
     .. code-block:: python
 
-        import numpy as np
-        from qiskit.primitives import DataBin, BitArray
-
         data = DataBin(
-            alpha=BitArray.from_samples(["0010"]),
+            alpha=BitArray.from_bitstrings(["0010"]),
             beta=np.array([1.2])
         )
 
         print("alpha data:", data.alpha)
         print("beta data:", data.beta)
 
-    .. code-block::
-
-        alpha data: BitArray(<shape=(), num_shots=1, num_bits=2>)
-        beta data: [1.2]
-
     """
 
     __slots__ = ("_data", "_shape")

qiskit/primitives/statevector_sampler.py

@@ -287,6 +287,6 @@ def _final_measurement_mapping(circuit: QuantumCircuit) -> dict[tuple[ClassicalR
 
 def _has_control_flow(circuit: QuantumCircuit) -> bool:
     return any(
-        isinstance((op := instruction.operation), ControlFlowOp) or op._condition
+        isinstance((op := instruction.operation), ControlFlowOp) or op.condition
         for instruction in circuit
     )