qiskit 1.0.2__cp38-abi3-win32.whl → 1.1.0rc1__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

@@ -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):

qiskit/providers/__init__.py

@@ -17,13 +17,13 @@ Providers Interface (:mod:`qiskit.providers`)
 
 .. currentmodule:: qiskit.providers
 
-This module contains the classes used to build external providers for Terra. A
-provider is anything that provides an external service to Terra. The typical
+This module contains the classes used to build external providers for Qiskit. A
+provider is anything that provides an external service to Qiskit. The typical
 example of this is a Backend provider which provides
 :class:`~qiskit.providers.Backend` objects which can be used for executing
 :class:`~qiskit.circuit.QuantumCircuit` and/or :class:`~qiskit.pulse.Schedule`
 objects. This module contains the abstract classes which are used to define the
-interface between a provider and terra.
+interface between a provider and Qiskit.
 
 Version Support
 ===============
@@ -36,17 +36,17 @@ backwards compatible between versions.
 Version Changes
 ----------------
 
-Each minor version release of qiskit-terra **may** increment the version of any
-providers interface a single version number. It will be an aggregate of all
+Each minor version release of ``qiskit`` **may** increment the version of any
+backend interface a single version number. It will be an aggregate of all
 the interface changes for that release on that interface.
 
 Version Support Policy
 ----------------------
 
 To enable providers to have time to adjust to changes in this interface
-Terra will support multiple versions of each class at once. Given the
+Qiskit will support multiple versions of each class at once. Given the
 nature of one version per release the version deprecation policy is a bit
-more conservative than the standard deprecation policy. Terra will support a
+more conservative than the standard deprecation policy. Qiskit will support a
 provider interface version for a minimum of 3 minor releases or the first
 release after 6 months from the release that introduced a version, whichever is
 longer, prior to a potential deprecation. After that the standard deprecation
@@ -57,17 +57,17 @@ the release of 0.19.0 we release 0.20.0, 0.21.0, and 0.22.0, then 7 months after
 0.19.0 we release 0.23.0. In 0.23.0 we can deprecate BackendV2, and it needs to
 still be supported and can't be removed until the deprecation policy completes.
 
-It's worth pointing out that Terra's version support policy doesn't mean
+It's worth pointing out that Qiskit's version support policy doesn't mean
 providers themselves will have the same support story, they can (and arguably
 should) update to newer versions as soon as they can, the support window is
-just for Terra's supported versions. Part of this lengthy window prior to
+just for Qiskit's supported versions. Part of this lengthy window prior to
 deprecation is to give providers enough time to do their own deprecation of a
 potential end user impacting change in a user facing part of the interface
 prior to bumping their version. For example, let's say we changed the signature
 to ``Backend.run()`` in ``BackendV34`` in a backwards incompatible way. Before
 Aer could update its :class:`~qiskit_aer.AerSimulator` class
 to be based on version 34 they'd need to deprecate the old signature prior to switching
-over. The changeover for Aer is not guaranteed to be lockstep with Terra so we
+over. The changeover for Aer is not guaranteed to be lockstep with Qiskit, so we
 need to ensure there is a sufficient amount of time for Aer to complete its
 deprecation cycle prior to removing version 33 (ie making version 34
 mandatory/the minimum version).
@@ -131,12 +131,13 @@ Exceptions
 .. autoexception:: JobTimeoutError
 .. autoexception:: BackendConfigurationError
 
-======================
-Writing a New Provider
-======================
+=====================
+Writing a New Backend
+=====================
 
 If you have a quantum device or simulator that you would like to integrate with
-Qiskit you will need to write a provider. A provider will provide Terra with a
+Qiskit you will need to write a backend. A provider is a collection of backends
+and will provide Qiskit with a
 method to get available :class:`~qiskit.providers.BackendV2` objects. The
 :class:`~qiskit.providers.BackendV2` object provides both information describing
 a backend and its operation for the :mod:`~qiskit.transpiler` so that circuits
@@ -149,8 +150,7 @@ executing circuits on devices in a standard
 fashion regardless of how the backend is implemented. At a high level the basic
 steps for writing a provider are:
 
- * Implement a :class:`~qiskit.providers.ProviderV1` subclass that handles
-   access to the backend(s).
+ * Implement a ``Provider`` class that handles access to the backend(s).
  * Implement a :class:`~qiskit.providers.BackendV2` subclass and its
    :meth:`~qiskit.providers.BackendV2.run` method.
 
@@ -173,12 +173,11 @@ of a provider object. The provider object will then provide a list of backends,
 and methods to filter and acquire backends (using the provided credentials if
 required). An example provider class looks like::
 
-    from qiskit.providers import ProviderV1 as Provider
     from qiskit.providers.providerutils import filter_backends
 
     from .backend import MyBackend
 
-    class MyProvider(Provider):
+    class MyProvider:
 
         def __init__(self, token=None):
             super().__init__()

qiskit/providers/backend.py

@@ -40,8 +40,8 @@ class Backend:
 class BackendV1(Backend, ABC):
     """Abstract class for Backends
 
-    This abstract class is to be used for all Backend objects created by a
-    provider. There are several classes of information contained in a Backend.
+    This abstract class is to be used for Backend objects.
+    There are several classes of information contained in a Backend.
     The first are the attributes of the class itself. These should be used to
     defined the immutable characteristics of the backend. The ``options``
     attribute of the backend is used to contain the dynamic user configurable

qiskit/providers/backend_compat.py

@@ -1,6 +1,6 @@
 # This code is part of Qiskit.
 #
-# (C) Copyright IBM 2020.
+# (C) Copyright IBM 2020, 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
@@ -57,7 +57,7 @@ def convert_to_target(
         A ``Target`` instance.
     """
 
-    # importing pacakges where they are needed, to avoid cyclic-import.
+    # importing packages where they are needed, to avoid cyclic-import.
     # pylint: disable=cyclic-import
     from qiskit.transpiler.target import (
         Target,
@@ -82,7 +82,7 @@ def convert_to_target(
         "switch_case": SwitchCaseOp,
     }
 
-    in_data = {"num_qubits": configuration.n_qubits}
+    in_data = {"num_qubits": configuration.num_qubits}
 
     # Parse global configuration properties
     if hasattr(configuration, "dt"):
@@ -97,7 +97,6 @@ def convert_to_target(
     all_instructions = set.union(
         basis_gates, set(required), supported_instructions.intersection(CONTROL_FLOW_OP_NAMES)
     )
-
     inst_name_map = {}  # type: Dict[str, Instruction]
 
     faulty_ops = set()
@@ -244,10 +243,8 @@ def convert_to_target(
 
         for name in inst_sched_map.instructions:
             for qubits in inst_sched_map.qubits_with_instruction(name):
-
                 if not isinstance(qubits, tuple):
                     qubits = (qubits,)
-
                 if (
                     name not in all_instructions
                     or name not in prop_name_map
@@ -267,17 +264,18 @@ def convert_to_target(
                     continue
 
                 entry = inst_sched_map._get_calibration_entry(name, qubits)
-
                 try:
                     prop_name_map[name][qubits].calibration = entry
                 except AttributeError:
+                    # if instruction properties are "None", add entry
+                    prop_name_map[name].update({qubits: InstructionProperties(None, None, entry)})
                     logger.info(
                         "The PulseDefaults payload received contains an instruction %s on "
-                        "qubits %s which is not present in the configuration or properties payload.",
+                        "qubits %s which is not present in the configuration or properties payload."
+                        "A new properties entry will be added to include the new calibration data.",
                         name,
                         qubits,
                     )
-
     # Add parsed properties to target
     target = Target(**in_data)
     for inst_name in all_instructions:
@@ -384,7 +382,7 @@ class BackendV2Converter(BackendV2):
         super().__init__(
             provider=backend.provider,
             name=backend.name(),
-            description=self._config.description,
+            description=getattr(self._config, "description", None),
             online_date=getattr(self._config, "online_date", None),
             backend_version=self._config.backend_version,
         )