qiskit 1.0.2__cp38-abi3-win32.whl → 1.1.0__cp38-abi3-win32.whl

qiskit/primitives/containers/data_bin.py

@@ -15,78 +15,151 @@ Dataclass tools for data namespaces (bins)
 """
 from __future__ import annotations
 
-from collections.abc import Iterable
-from dataclasses import make_dataclass
+from typing import Any, ItemsView, Iterable, KeysView, ValuesView
 
+import numpy as np
 
-class DataBinMeta(type):
-    """Metaclass for :class:`DataBin` that adds the shape to the type name.
+from .shape import ShapedMixin, ShapeInput, shape_tuple
+
+
+def _value_repr(value: Any) -> str:
+    """Helper function for :meth:`DataBin.__repr__`."""
+    if isinstance(value, np.ndarray):
+        return f"np.ndarray(<shape={value.shape}, dtype={value.dtype}>)"
+    return repr(value)
 
-    This is so that the class has a custom repr with DataBin<*shape> notation.
-    """
 
-    def __repr__(cls):
-        name = cls.__name__
-        if cls._SHAPE is None:
-            return name
-        shape = ",".join(map(str, cls._SHAPE))
-        return f"{name}<{shape}>"
+class DataBin(ShapedMixin):
+    """Namespace for storing data.
 
+    .. code-block:: python
+
+        data = DataBin(
+            alpha=BitArray.from_bitstrings(["0010"]),
+            beta=np.array([1.2])
+        )
 
-class DataBin(metaclass=DataBinMeta):
-    """Base class for data bin containers.
+        print("alpha data:", data.alpha)
+        print("beta data:", data.beta)
 
-    Subclasses are typically made via :class:`~make_data_bin`, which is a specialization of
-    :class:`make_dataclass`.
     """
 
-    _RESTRICTED_NAMES = ("_RESTRICTED_NAMES", "_SHAPE", "_FIELDS", "_FIELD_TYPES")
-    _SHAPE: tuple[int, ...] | None = None
-    _FIELDS: tuple[str, ...] = ()
-    """The fields allowed in this data bin."""
-    _FIELD_TYPES: tuple[type, ...] = ()
-    """The types of each field."""
+    __slots__ = ("_data", "_shape")
+
+    _RESTRICTED_NAMES = frozenset(
+        {
+            "_RESTRICTED_NAMES",
+            "_SHAPE",
+            "_FIELDS",
+            "_FIELD_TYPES",
+            "_data",
+            "_shape",
+            "keys",
+            "values",
+            "items",
+            "shape",
+            "ndim",
+            "size",
+        }
+    )
+
+    def __init__(self, *, shape: ShapeInput = (), **data):
+        """
+        Args:
+            data: Name/value data to place in the data bin.
+            shape: The leading shape common to all entries in the data bin. This defaults to
+                the trivial leading shape of ``()`` that is compatible with all objects.
+
+        Raises:
+            ValueError: If a name overlaps with a method name on this class.
+            ValueError: If some value is inconsistent with the provided shape.
+        """
+        if not self._RESTRICTED_NAMES.isdisjoint(data):
+            bad_names = sorted(self._RESTRICTED_NAMES.intersection(data))
+            raise ValueError(f"Cannot assign with these field names: {bad_names}")
+
+        _setattr = super().__setattr__
+        _setattr("_shape", shape_tuple(shape))
+        _setattr("_data", data)
+
+        ndim = len(self._shape)
+        for name, value in data.items():
+            if getattr(value, "shape", shape)[:ndim] != shape:
+                raise ValueError(f"The value of '{name}' does not lead with the shape {shape}.")
+            _setattr(name, value)
+
+        super().__init__()
 
     def __len__(self):
-        return len(self._FIELDS)
+        return len(self._data)
+
+    def __setattr__(self, *_):
+        raise NotImplementedError
 
     def __repr__(self):
-        vals = (f"{name}={getattr(self, name)}" for name in self._FIELDS if hasattr(self, name))
-        return f"{type(self)}({', '.join(vals)})"
+        vals = [f"{name}={_value_repr(val)}" for name, val in self.items()]
+        if self.ndim:
+            vals.append(f"shape={self.shape}")
+        return f"{type(self).__name__}({', '.join(vals)})"
 
+    def __getitem__(self, key: str) -> Any:
+        try:
+            return self._data[key]
+        except KeyError as ex:
+            raise KeyError(f"Key ({key}) does not exist in this data bin.") from ex
 
-def make_data_bin(
-    fields: Iterable[tuple[str, type]], shape: tuple[int, ...] | None = None
-) -> DataBinMeta:
-    """Return a new subclass of :class:`~DataBin` with the provided fields and shape.
+    def __contains__(self, key: str) -> bool:
+        return key in self._data
 
-    .. code-block:: python
+    def __iter__(self) -> Iterable[str]:
+        return iter(self._data)
 
-        my_bin = make_data_bin([("alpha", np.NDArray[np.float64])], shape=(20, 30))
+    def keys(self) -> KeysView[str]:
+        """Return a view of field names."""
+        return self._data.keys()
 
-        # behaves like a dataclass
-        my_bin(alpha=np.empty((20, 30)))
+    def values(self) -> ValuesView[Any]:
+        """Return a view of values."""
+        return self._data.values()
+
+    def items(self) -> ItemsView[str, Any]:
+        """Return a view of field names and values"""
+        return self._data.items()
+
+    # The following properties exist to provide support to legacy private class attributes which
+    # gained widespread prior to qiskit 1.1. These properties will be removed once the internal
+    # projects have made the appropriate changes.
+
+    @property
+    def _FIELDS(self) -> tuple[str, ...]:  # pylint: disable=invalid-name
+        return tuple(self._data)
+
+    @property
+    def _FIELD_TYPES(self) -> tuple[Any, ...]:  # pylint: disable=invalid-name
+        return tuple(map(type, self.values()))
+
+    @property
+    def _SHAPE(self) -> tuple[int, ...]:  # pylint: disable=invalid-name
+        return self.shape
+
+
+# pylint: disable=unused-argument
+def make_data_bin(
+    fields: Iterable[tuple[str, type]], shape: tuple[int, ...] | None = None
+) -> type[DataBin]:
+    """Return the :class:`~DataBin` type.
+
+    .. note::
+        This class used to return a subclass of :class:`~DataBin`. However, that caused confusion
+        and didn't have a useful purpose. Several internal projects made use of this internal
+        function prior to qiskit 1.1. This function will be removed once these internal projects
+        have made the appropriate changes.
 
     Args:
         fields: Tuples ``(name, type)`` specifying the attributes of the returned class.
         shape: The intended shape of every attribute of this class.
 
     Returns:
-        A new class.
+        The :class:`DataBin` type.
     """
-    field_names, field_types = zip(*fields) if fields else ([], [])
-    for name in field_names:
-        if name in DataBin._RESTRICTED_NAMES:
-            raise ValueError(f"'{name}' is a restricted name for a DataBin.")
-    cls = make_dataclass(
-        "DataBin",
-        dict(zip(field_names, field_types)),
-        bases=(DataBin,),
-        frozen=True,
-        unsafe_hash=True,
-        repr=False,
-    )
-    cls._SHAPE = shape
-    cls._FIELDS = field_names
-    cls._FIELD_TYPES = field_types
-    return cls
+    return DataBin

qiskit/primitives/containers/estimator_pub.py

@@ -132,6 +132,15 @@ class EstimatorPub(ShapedMixin):
                     validate=False,  # Assume Pub is already validated
                 )
             return pub
+
+        if isinstance(pub, QuantumCircuit):
+            raise ValueError(
+                f"An invalid Estimator pub-like was given ({type(pub)}). "
+                "If you want to run a single pub, you need to wrap it with `[]` like "
+                "`estimator.run([(circuit, observables, param_values)])` "
+                "instead of `estimator.run((circuit, observables, param_values))`."
+            )
+
         if len(pub) not in [2, 3, 4]:
             raise ValueError(
                 f"The length of pub must be 2, 3 or 4, but length {len(pub)} is given."
@@ -208,8 +217,6 @@ estimator, if ``precision=None`` the estimator will determine the target precisi
     An Estimator Pub can also be initialized in the following formats which
     will be converted to the full Pub tuple:
 
-    * ``circuit
-    * ``(circuit,)``
     * ``(circuit, observables)``
-    * ``(circuit, observalbes, parameter_values)``
+    * ``(circuit, observables, parameter_values)``
 """

qiskit/primitives/containers/observables_array.py

@@ -101,10 +101,10 @@ class ObservablesArray(ShapedMixin):
         """Convert to a nested list"""
         return self._array.tolist()
 
-    def __array__(self, dtype=None):
+    def __array__(self, dtype=None, copy=None):
         """Convert to an Numpy.ndarray"""
         if dtype is None or dtype == object:
-            return self._array
+            return self._array.copy() if copy else self._array
         raise ValueError("Type must be 'None' or 'object'")
 
     @overload

qiskit/primitives/containers/pub_result.py

@@ -11,7 +11,7 @@
 # that they have been altered from the originals.
 
 """
-Base Pub class
+Base Pub result class
 """
 
 from __future__ import annotations

qiskit/primitives/containers/sampler_pub.py

@@ -18,10 +18,11 @@ Sampler Pub class
 from __future__ import annotations
 
 from collections.abc import Mapping
-from typing import Tuple, Union
 from numbers import Integral
+from typing import Tuple, Union
 
 from qiskit import QuantumCircuit
+from qiskit.circuit import CircuitInstruction
 
 from .bindings_array import BindingsArray, BindingsArrayLike
 from .shape import ShapedMixin
@@ -113,6 +114,14 @@ class SamplerPub(ShapedMixin):
         if isinstance(pub, QuantumCircuit):
             return cls(circuit=pub, shots=shots, validate=True)
 
+        if isinstance(pub, CircuitInstruction):
+            raise ValueError(
+                f"An invalid Sampler pub-like was given ({type(pub)}). "
+                "If you want to run a single circuit, "
+                "you need to wrap it with `[]` like `sampler.run([circuit])` "
+                "instead of `sampler.run(circuit)`."
+            )
+
         if len(pub) not in [1, 2, 3]:
             raise ValueError(
                 f"The length of pub must be 1, 2 or 3, but length {len(pub)} is given."
@@ -147,10 +156,17 @@ class SamplerPub(ShapedMixin):
         # Cross validate circuits and parameter values
         num_parameters = self.parameter_values.num_parameters
         if num_parameters != self.circuit.num_parameters:
-            raise ValueError(
+            message = (
                 f"The number of values ({num_parameters}) does not match "
                 f"the number of parameters ({self.circuit.num_parameters}) for the circuit."
             )
+            if num_parameters == 0:
+                message += (
+                    " Note that if you want to run a single pub, you need to wrap it with `[]` like "
+                    "`sampler.run([(circuit, param_values)])` instead of "
+                    "`sampler.run((circuit, param_values))`."
+                )
+            raise ValueError(message)
 
 
 SamplerPubLike = Union[
@@ -171,7 +187,7 @@ if ``shots=None`` the number of run shots is determined by the sampler.
     A Sampler Pub can also be initialized in the following formats which
     will be converted to the full Pub tuple:
 
-    * ``circuit
+    * ``circuit``
     * ``(circuit,)``
     * ``(circuit, parameter_values)``
 """

qiskit/primitives/containers/sampler_pub_result.py

@@ -0,0 +1,74 @@
+# 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.
+
+"""
+Sampler Pub result class
+"""
+
+from __future__ import annotations
+
+from typing import Iterable
+
+import numpy as np
+
+from .bit_array import BitArray
+from .pub_result import PubResult
+
+
+class SamplerPubResult(PubResult):
+    """Result of Sampler Pub."""
+
+    def join_data(self, names: Iterable[str] | None = None) -> BitArray | np.ndarray:
+        """Join data from many registers into one data container.
+
+        Data is joined along the bits axis. For example, for :class:`~.BitArray` data, this corresponds
+        to bitstring concatenation.
+
+        Args:
+            names: Which registers to join. Their order is maintained, for example, given
+                ``["alpha", "beta"]``, the data from register ``alpha`` is placed to the left of the
+                data from register ``beta``. When ``None`` is given, this value is set to the
+                ordered list of register names, which will have been preserved from the input circuit
+                order.
+
+        Returns:
+            Joint data.
+
+        Raises:
+            ValueError: If specified names are empty.
+            ValueError: If specified name does not exist.
+            TypeError: If specified data comes from incompatible types.
+        """
+        if names is None:
+            names = list(self.data)
+            if not names:
+                raise ValueError("No entry exists in the data bin.")
+        else:
+            names = list(names)
+            if not names:
+                raise ValueError("An empty name list is given.")
+            for name in names:
+                if name not in self.data:
+                    raise ValueError(f"Name '{name}' does not exist.")
+
+        data = [self.data[name] for name in names]
+        if isinstance(data[0], BitArray):
+            if not all(isinstance(datum, BitArray) for datum in data):
+                raise TypeError("Data comes from incompatible types.")
+            joint_data = BitArray.concatenate_bits(data)
+        elif isinstance(data[0], np.ndarray):
+            if not all(isinstance(datum, np.ndarray) for datum in data):
+                raise TypeError("Data comes from incompatible types.")
+            joint_data = np.concatenate(data, axis=-1)
+        else:
+            raise TypeError("Data comes from incompatible types.")
+        return joint_data

qiskit/primitives/containers/shape.py

@@ -59,15 +59,15 @@ class ShapedMixin(Shaped):
         return f"{type(self).__name__}(<{self.shape}>)"
 
     @property
-    def shape(self):
+    def shape(self) -> tuple[int, ...]:
         return self._shape
 
     @property
-    def ndim(self):
+    def ndim(self) -> int:
         return len(self._shape)
 
     @property
-    def size(self):
+    def size(self) -> int:
         return int(np.prod(self._shape, dtype=int))
 
 
@@ -85,7 +85,7 @@ def array_coerce(arr: ArrayLike | Shaped) -> NDArray | Shaped:
     """
     if isinstance(arr, Shaped):
         return arr
-    return np.array(arr, copy=False)
+    return np.asarray(arr)
 
 
 def _flatten_to_ints(arg: ShapeInput) -> Iterable[int]:

qiskit/primitives/statevector_estimator.py

@@ -22,7 +22,7 @@ import numpy as np
 from qiskit.quantum_info import SparsePauliOp, Statevector
 
 from .base import BaseEstimatorV2
-from .containers import EstimatorPubLike, PrimitiveResult, PubResult
+from .containers import DataBin, EstimatorPubLike, PrimitiveResult, PubResult
 from .containers.estimator_pub import EstimatorPub
 from .primitive_job import PrimitiveJob
 from .utils import bound_circuit_to_instruction
@@ -160,6 +160,6 @@ class StatevectorEstimator(BaseEstimatorV2):
                     raise ValueError("Given operator is not Hermitian and noise cannot be added.")
                 expectation_value = rng.normal(expectation_value, precision)
             evs[index] = expectation_value
-        data_bin_cls = self._make_data_bin(pub)
-        data_bin = data_bin_cls(evs=evs, stds=stds)
-        return PubResult(data_bin, metadata={"precision": precision})
+
+        data = DataBin(evs=evs, stds=stds, shape=evs.shape)
+        return PubResult(data, metadata={"precision": precision})

qiskit/primitives/statevector_sampler.py

@@ -15,9 +15,9 @@ Statevector Sampler class
 
 from __future__ import annotations
 
+import warnings
 from dataclasses import dataclass
 from typing import Iterable
-import warnings
 
 import numpy as np
 from numpy.typing import NDArray
@@ -30,10 +30,10 @@ from .base import BaseSamplerV2
 from .base.validation import _has_measure
 from .containers import (
     BitArray,
+    DataBin,
     PrimitiveResult,
-    PubResult,
+    SamplerPubResult,
     SamplerPubLike,
-    make_data_bin,
 )
 from .containers.sampler_pub import SamplerPub
 from .containers.bit_array import _min_num_bytes
@@ -154,7 +154,7 @@ class StatevectorSampler(BaseSamplerV2):
 
     def run(
         self, pubs: Iterable[SamplerPubLike], *, shots: int | None = None
-    ) -> PrimitiveJob[PrimitiveResult[PubResult]]:
+    ) -> PrimitiveJob[PrimitiveResult[SamplerPubResult]]:
         if shots is None:
             shots = self._default_shots
         coerced_pubs = [SamplerPub.coerce(pub, shots) for pub in pubs]
@@ -169,11 +169,11 @@ class StatevectorSampler(BaseSamplerV2):
         job._submit()
         return job
 
-    def _run(self, pubs: Iterable[SamplerPub]) -> PrimitiveResult[PubResult]:
+    def _run(self, pubs: Iterable[SamplerPub]) -> PrimitiveResult[SamplerPubResult]:
         results = [self._run_pub(pub) for pub in pubs]
         return PrimitiveResult(results)
 
-    def _run_pub(self, pub: SamplerPub) -> PubResult:
+    def _run_pub(self, pub: SamplerPub) -> SamplerPubResult:
         circuit, qargs, meas_info = _preprocess_circuit(pub.circuit)
         bound_circuits = pub.parameter_values.bind_all(circuit)
         arrays = {
@@ -194,15 +194,10 @@ class StatevectorSampler(BaseSamplerV2):
                 ary = _samples_to_packed_array(samples_array, item.num_bits, item.qreg_indices)
                 arrays[item.creg_name][index] = ary
 
-        data_bin_cls = make_data_bin(
-            [(item.creg_name, BitArray) for item in meas_info],
-            shape=bound_circuits.shape,
-        )
         meas = {
             item.creg_name: BitArray(arrays[item.creg_name], item.num_bits) for item in meas_info
         }
-        data_bin = data_bin_cls(**meas)
-        return PubResult(data_bin, metadata={"shots": pub.shots})
+        return SamplerPubResult(DataBin(**meas, shape=pub.shape), metadata={"shots": pub.shots})
 
 
 def _preprocess_circuit(circuit: QuantumCircuit):