qiskit 1.4.1__cp39-abi3-macosx_11_0_arm64.whl → 2.0.0__cp39-abi3-macosx_11_0_arm64.whl

qiskit/qpy/binary_io/value.py

@@ -23,7 +23,7 @@ import numpy as np
 import symengine
 
 
-from qiskit.circuit import CASE_DEFAULT, Clbit, ClassicalRegister
+from qiskit.circuit import CASE_DEFAULT, Clbit, ClassicalRegister, Duration
 from qiskit.circuit.classical import expr, types
 from qiskit.circuit.parameter import Parameter
 from qiskit.circuit.parameterexpression import (
@@ -34,6 +34,7 @@ from qiskit.circuit.parameterexpression import (
 )
 from qiskit.circuit.parametervector import ParameterVector, ParameterVectorElement
 from qiskit.qpy import common, formats, exceptions, type_keys
+from qiskit.qpy.binary_io.parse_sympy_repr import parse_sympy_repr
 
 
 def _write_parameter(file_obj, obj):
@@ -165,17 +166,9 @@ def _write_parameter_expression_v13(file_obj, obj, version):
 
 def _write_parameter_expression(file_obj, obj, use_symengine, *, version):
     extra_symbols = None
-    if version < 13:
-        if use_symengine:
-            expr_bytes = obj._symbol_expr.__reduce__()[1][0]
-        else:
-            from sympy import srepr, sympify
-
-            expr_bytes = srepr(sympify(obj._symbol_expr)).encode(common.ENCODE)
-    else:
-        with io.BytesIO() as buf:
-            extra_symbols = _write_parameter_expression_v13(buf, obj, version)
-            expr_bytes = buf.getvalue()
+    with io.BytesIO() as buf:
+        extra_symbols = _write_parameter_expression_v13(buf, obj, version)
+        expr_bytes = buf.getvalue()
     symbol_table_len = len(obj._parameter_symbols)
     if extra_symbols:
         symbol_table_len += 2 * len(extra_symbols)
@@ -271,12 +264,15 @@ class _ExprWriter(expr.ExprVisitor[None]):
         self.standalone_var_indices = standalone_var_indices
         self.version = version
 
+    def _write_expr_type(self, type_, /):
+        _write_expr_type(self.file_obj, type_, self.version)
+
     def visit_generic(self, node, /):
         raise exceptions.QpyError(f"unhandled Expr object '{node}'")
 
     def visit_var(self, node, /):
         self.file_obj.write(type_keys.Expression.VAR)
-        _write_expr_type(self.file_obj, node.type)
+        self._write_expr_type(node.type)
         if node.standalone:
             self.file_obj.write(type_keys.ExprVar.UUID)
             self.file_obj.write(
@@ -304,9 +300,19 @@ class _ExprWriter(expr.ExprVisitor[None]):
         else:
             raise exceptions.QpyError(f"unhandled Var object '{node.var}'")
 
+    def visit_stretch(self, node, /):
+        self.file_obj.write(type_keys.Expression.STRETCH)
+        self._write_expr_type(node.type)
+        self.file_obj.write(
+            struct.pack(
+                formats.EXPRESSION_STRETCH_PACK,
+                *formats.EXPRESSION_STRETCH(self.standalone_var_indices[node]),
+            )
+        )
+
     def visit_value(self, node, /):
         self.file_obj.write(type_keys.Expression.VALUE)
-        _write_expr_type(self.file_obj, node.type)
+        self._write_expr_type(node.type)
         if node.value is True or node.value is False:
             self.file_obj.write(type_keys.ExprValue.BOOL)
             self.file_obj.write(
@@ -327,12 +333,20 @@ class _ExprWriter(expr.ExprVisitor[None]):
                 struct.pack(formats.EXPR_VALUE_INT_PACK, *formats.EXPR_VALUE_INT(num_bytes))
             )
             self.file_obj.write(buffer)
+        elif isinstance(node.value, float):
+            self.file_obj.write(type_keys.ExprValue.FLOAT)
+            self.file_obj.write(
+                struct.pack(formats.EXPR_VALUE_FLOAT_PACK, *formats.EXPR_VALUE_FLOAT(node.value))
+            )
+        elif isinstance(node.value, Duration):
+            self.file_obj.write(type_keys.ExprValue.DURATION)
+            _write_duration(self.file_obj, node.value)
         else:
             raise exceptions.QpyError(f"unhandled Value object '{node.value}'")
 
     def visit_cast(self, node, /):
         self.file_obj.write(type_keys.Expression.CAST)
-        _write_expr_type(self.file_obj, node.type)
+        self._write_expr_type(node.type)
         self.file_obj.write(
             struct.pack(formats.EXPRESSION_CAST_PACK, *formats.EXPRESSION_CAST(node.implicit))
         )
@@ -340,7 +354,7 @@ class _ExprWriter(expr.ExprVisitor[None]):
 
     def visit_unary(self, node, /):
         self.file_obj.write(type_keys.Expression.UNARY)
-        _write_expr_type(self.file_obj, node.type)
+        self._write_expr_type(node.type)
         self.file_obj.write(
             struct.pack(formats.EXPRESSION_UNARY_PACK, *formats.EXPRESSION_UNARY(node.op.value))
         )
@@ -348,7 +362,7 @@ class _ExprWriter(expr.ExprVisitor[None]):
 
     def visit_binary(self, node, /):
         self.file_obj.write(type_keys.Expression.BINARY)
-        _write_expr_type(self.file_obj, node.type)
+        self._write_expr_type(node.type)
         self.file_obj.write(
             struct.pack(formats.EXPRESSION_BINARY_PACK, *formats.EXPRESSION_BINARY(node.op.value))
         )
@@ -361,7 +375,7 @@ class _ExprWriter(expr.ExprVisitor[None]):
                 "the 'Index' expression", required=12, target=self.version
             )
         self.file_obj.write(type_keys.Expression.INDEX)
-        _write_expr_type(self.file_obj, node.type)
+        self._write_expr_type(node.type)
         node.target.accept(self)
         node.index.accept(self)
 
@@ -376,7 +390,7 @@ def _write_expr(
     node.accept(_ExprWriter(file_obj, clbit_indices, standalone_var_indices, version))
 
 
-def _write_expr_type(file_obj, type_: types.Type):
+def _write_expr_type(file_obj, type_: types.Type, version: int):
     if type_.kind is types.Bool:
         file_obj.write(type_keys.ExprType.BOOL)
     elif type_.kind is types.Uint:
@@ -384,10 +398,51 @@ def _write_expr_type(file_obj, type_: types.Type):
         file_obj.write(
             struct.pack(formats.EXPR_TYPE_UINT_PACK, *formats.EXPR_TYPE_UINT(type_.width))
         )
+    elif type_.kind is types.Float:
+        if version < 14:
+            raise exceptions.UnsupportedFeatureForVersion(
+                "float-typed expressions", required=14, target=version
+            )
+        file_obj.write(type_keys.ExprType.FLOAT)
+    elif type_.kind is types.Duration:
+        if version < 14:
+            raise exceptions.UnsupportedFeatureForVersion(
+                "duration-typed expressions", required=14, target=version
+            )
+        file_obj.write(type_keys.ExprType.DURATION)
     else:
         raise exceptions.QpyError(f"unhandled Type object '{type_};")
 
 
+def _write_duration(file_obj, duration: Duration):
+    unit = duration.unit()
+    if unit == "dt":
+        file_obj.write(type_keys.CircuitDuration.DT)
+        file_obj.write(
+            struct.pack(formats.DURATION_DT_PACK, *formats.DURATION_DT(duration.value()))
+        )
+    elif unit == "ns":
+        file_obj.write(type_keys.CircuitDuration.NS)
+        file_obj.write(
+            struct.pack(formats.DURATION_NS_PACK, *formats.DURATION_NS(duration.value()))
+        )
+    elif unit == "us":
+        file_obj.write(type_keys.CircuitDuration.US)
+        file_obj.write(
+            struct.pack(formats.DURATION_US_PACK, *formats.DURATION_US(duration.value()))
+        )
+    elif unit == "ms":
+        file_obj.write(type_keys.CircuitDuration.MS)
+        file_obj.write(
+            struct.pack(formats.DURATION_MS_PACK, *formats.DURATION_MS(duration.value()))
+        )
+    elif unit == "s":
+        file_obj.write(type_keys.CircuitDuration.S)
+        file_obj.write(struct.pack(formats.DURATION_S_PACK, *formats.DURATION_S(duration.value())))
+    else:
+        raise exceptions.QpyError(f"unhandled Duration object '{duration};")
+
+
 def _read_parameter(file_obj):
     data = formats.PARAMETER(
         *struct.unpack(formats.PARAMETER_PACK, file_obj.read(formats.PARAMETER_SIZE))
@@ -419,9 +474,9 @@ def _read_parameter_expression(file_obj):
     data = formats.PARAMETER_EXPR(
         *struct.unpack(formats.PARAMETER_EXPR_PACK, file_obj.read(formats.PARAMETER_EXPR_SIZE))
     )
-    from sympy.parsing.sympy_parser import parse_expr
 
-    expr_ = symengine.sympify(parse_expr(file_obj.read(data.expr_size).decode(common.ENCODE)))
+    sympy_str = file_obj.read(data.expr_size).decode(common.ENCODE)
+    expr_ = symengine.sympify(parse_sympy_repr(sympy_str))
     symbol_map = {}
     for _ in range(data.map_elements):
         elem_data = formats.PARAM_EXPR_MAP_ELEM(
@@ -460,9 +515,8 @@ def _read_parameter_expression_v3(file_obj, vectors, use_symengine):
     if use_symengine:
         expr_ = common.load_symengine_payload(payload)
     else:
-        from sympy.parsing.sympy_parser import parse_expr
-
-        expr_ = symengine.sympify(parse_expr(payload.decode(common.ENCODE)))
+        sympy_str = payload.decode(common.ENCODE)
+        expr_ = symengine.sympify(parse_sympy_repr(sympy_str))
 
     symbol_map = {}
     for _ in range(data.map_elements):
@@ -676,6 +730,13 @@ def _read_expr(
             name = file_obj.read(payload.reg_name_size).decode(common.ENCODE)
             return expr.Var(cregs[name], type_)
         raise exceptions.QpyError("Invalid classical-expression Var key '{var_type_key}'")
+    if type_key == type_keys.Expression.STRETCH:
+        payload = formats.EXPRESSION_STRETCH._make(
+            struct.unpack(
+                formats.EXPRESSION_STRETCH_PACK, file_obj.read(formats.EXPRESSION_STRETCH_SIZE)
+            )
+        )
+        return standalone_vars[payload.var_index]
     if type_key == type_keys.Expression.VALUE:
         value_type_key = file_obj.read(formats.EXPR_VALUE_DISCRIMINATOR_SIZE)
         if value_type_key == type_keys.ExprValue.BOOL:
@@ -694,6 +755,16 @@ def _read_expr(
             return expr.Value(
                 int.from_bytes(file_obj.read(payload.num_bytes), "big", signed=True), type_
             )
+        if value_type_key == type_keys.ExprValue.FLOAT:
+            payload = formats.EXPR_VALUE_FLOAT._make(
+                struct.unpack(
+                    formats.EXPR_VALUE_FLOAT_PACK, file_obj.read(formats.EXPR_VALUE_FLOAT_SIZE)
+                )
+            )
+            return expr.Value(payload.value, type_)
+        if value_type_key == type_keys.ExprValue.DURATION:
+            value = _read_duration(file_obj)
+            return expr.Value(value, type_)
         raise exceptions.QpyError("Invalid classical-expression Value key '{value_type_key}'")
     if type_key == type_keys.Expression.CAST:
         payload = formats.EXPRESSION_CAST._make(
@@ -743,9 +814,43 @@ def _read_expr_type(file_obj) -> types.Type:
             struct.unpack(formats.EXPR_TYPE_UINT_PACK, file_obj.read(formats.EXPR_TYPE_UINT_SIZE))
         )
         return types.Uint(elem.width)
+    if type_key == type_keys.ExprType.FLOAT:
+        return types.Float()
+    if type_key == type_keys.ExprType.DURATION:
+        return types.Duration()
     raise exceptions.QpyError(f"Invalid classical-expression Type key '{type_key}'")
 
 
+def _read_duration(file_obj) -> Duration:
+    type_key = file_obj.read(formats.DURATION_DISCRIMINATOR_SIZE)
+    if type_key == type_keys.CircuitDuration.DT:
+        elem = formats.DURATION_DT._make(
+            struct.unpack(formats.DURATION_DT_PACK, file_obj.read(formats.DURATION_DT_SIZE))
+        )
+        return Duration.dt(elem.value)
+    if type_key == type_keys.CircuitDuration.NS:
+        elem = formats.DURATION_NS._make(
+            struct.unpack(formats.DURATION_NS_PACK, file_obj.read(formats.DURATION_NS_SIZE))
+        )
+        return Duration.ns(elem.value)
+    if type_key == type_keys.CircuitDuration.US:
+        elem = formats.DURATION_US._make(
+            struct.unpack(formats.DURATION_US_PACK, file_obj.read(formats.DURATION_US_SIZE))
+        )
+        return Duration.us(elem.value)
+    if type_key == type_keys.CircuitDuration.MS:
+        elem = formats.DURATION_MS._make(
+            struct.unpack(formats.DURATION_MS_PACK, file_obj.read(formats.DURATION_MS_SIZE))
+        )
+        return Duration.ms(elem.value)
+    if type_key == type_keys.CircuitDuration.S:
+        elem = formats.DURATION_S._make(
+            struct.unpack(formats.DURATION_S_PACK, file_obj.read(formats.DURATION_S_SIZE))
+        )
+        return Duration.s(elem.value)
+    raise exceptions.QpyError(f"Invalid duration Type key '{type_key}'")
+
+
 def read_standalone_vars(file_obj, num_vars):
     """Read the ``num_vars`` standalone variable declarations from the file.
 
@@ -762,6 +867,8 @@ def read_standalone_vars(file_obj, num_vars):
         type_keys.ExprVarDeclaration.INPUT: [],
         type_keys.ExprVarDeclaration.CAPTURE: [],
         type_keys.ExprVarDeclaration.LOCAL: [],
+        type_keys.ExprVarDeclaration.STRETCH_CAPTURE: [],
+        type_keys.ExprVarDeclaration.STRETCH_LOCAL: [],
     }
     var_order = []
     for _ in range(num_vars):
@@ -773,13 +880,19 @@ def read_standalone_vars(file_obj, num_vars):
         )
         type_ = _read_expr_type(file_obj)
         name = file_obj.read(data.name_size).decode(common.ENCODE)
-        var = expr.Var(uuid.UUID(bytes=data.uuid_bytes), type_, name=name)
+        if data.usage in {
+            type_keys.ExprVarDeclaration.STRETCH_CAPTURE,
+            type_keys.ExprVarDeclaration.STRETCH_LOCAL,
+        }:
+            var = expr.Stretch(uuid.UUID(bytes=data.uuid_bytes), name)
+        else:
+            var = expr.Var(uuid.UUID(bytes=data.uuid_bytes), type_, name=name)
         read_vars[data.usage].append(var)
         var_order.append(var)
     return read_vars, var_order
 
 
-def _write_standalone_var(file_obj, var, type_key):
+def _write_standalone_var(file_obj, var, type_key, version):
     name = var.name.encode(common.ENCODE)
     file_obj.write(
         struct.pack(
@@ -787,33 +900,46 @@ def _write_standalone_var(file_obj, var, type_key):
             *formats.EXPR_VAR_DECLARATION(var.var.bytes, type_key, len(name)),
         )
     )
-    _write_expr_type(file_obj, var.type)
+    _write_expr_type(file_obj, var.type, version)
     file_obj.write(name)
 
 
-def write_standalone_vars(file_obj, circuit):
+def write_standalone_vars(file_obj, circuit, version):
     """Write the standalone variables out from a circuit.
 
     Args:
         file_obj (File): the file-like object to write to.
         circuit (QuantumCircuit): the circuit to take the variables from.
+        version (int): the QPY target version.
 
     Returns:
-        dict[expr.Var, int]: a mapping of the variables written to the index that they were written
-        at.
+        dict[expr.Var | expr.Stretch, int]: a mapping of the variables written to the
+            index that they were written at.
     """
     index = 0
     out = {}
     for var in circuit.iter_input_vars():
-        _write_standalone_var(file_obj, var, type_keys.ExprVarDeclaration.INPUT)
+        _write_standalone_var(file_obj, var, type_keys.ExprVarDeclaration.INPUT, version)
         out[var] = index
         index += 1
     for var in circuit.iter_captured_vars():
-        _write_standalone_var(file_obj, var, type_keys.ExprVarDeclaration.CAPTURE)
+        _write_standalone_var(file_obj, var, type_keys.ExprVarDeclaration.CAPTURE, version)
         out[var] = index
         index += 1
     for var in circuit.iter_declared_vars():
-        _write_standalone_var(file_obj, var, type_keys.ExprVarDeclaration.LOCAL)
+        _write_standalone_var(file_obj, var, type_keys.ExprVarDeclaration.LOCAL, version)
+        out[var] = index
+        index += 1
+    if version < 14 and circuit.num_stretches:
+        raise exceptions.UnsupportedFeatureForVersion(
+            "circuits containing stretch variables", required=14, target=version
+        )
+    for var in circuit.iter_captured_stretches():
+        _write_standalone_var(file_obj, var, type_keys.ExprVarDeclaration.STRETCH_CAPTURE, version)
+        out[var] = index
+        index += 1
+    for var in circuit.iter_declared_stretches():
+        _write_standalone_var(file_obj, var, type_keys.ExprVarDeclaration.STRETCH_LOCAL, version)
         out[var] = index
         index += 1
     return out

qiskit/qpy/common.py

@@ -18,15 +18,12 @@ Common functions across several serialization and deserialization modules.
 import io
 import struct
 
-import symengine
-from symengine.lib.symengine_wrapper import (  # pylint: disable = no-name-in-module
-    load_basic,
-)
+from qiskit.utils.optionals import HAS_SYMENGINE
 
 from qiskit.qpy import formats, exceptions
 
-QPY_VERSION = 13
-QPY_COMPATIBILITY_VERSION = 10
+QPY_VERSION = 14
+QPY_COMPATIBILITY_VERSION = 13
 ENCODE = "utf8"
 
 
@@ -311,13 +308,19 @@ def mapping_from_binary(binary_data, deserializer, **kwargs):
     return mapping
 
 
-def load_symengine_payload(payload: bytes) -> symengine.Expr:
+@HAS_SYMENGINE.require_in_call("QPY versions 10 through 12 with symengine parameter serialization")
+def load_symengine_payload(payload: bytes):
     """Load a symengine expression from it's serialized cereal payload."""
     # This is a horrible hack to workaround the symengine version checking
     # it's deserialization does. There were no changes to the serialization
     # format between 0.11 and 0.13 but the deserializer checks that it can't
     # load across a major or minor version boundary. This works around it
     # by just lying about the generating version.
+    import symengine
+    from symengine.lib.symengine_wrapper import (  # pylint: disable = no-name-in-module
+        load_basic,
+    )
+
     symengine_version = symengine.__version__.split(".")
     major = payload[2]
     minor = payload[3]

qiskit/qpy/formats.py

@@ -357,11 +357,23 @@ EXPRESSION_BINARY = namedtuple("EXPRESSION_BINARY", ["opcode"])
 EXPRESSION_BINARY_PACK = "!B"
 EXPRESSION_BINARY_SIZE = struct.calcsize(EXPRESSION_BINARY_PACK)
 
+EXPRESSION_STRETCH = namedtuple("EXPRESSION_STRETCH", ["var_index"])
+EXPRESSION_STRETCH_PACK = "!H"
+EXPRESSION_STRETCH_SIZE = struct.calcsize(EXPRESSION_STRETCH_PACK)
+
 
 # EXPR_TYPE
 
 EXPR_TYPE_DISCRIMINATOR_SIZE = 1
 
+EXPR_TYPE_DURATION = namedtuple("EXPR_TYPE_DURATION", [])
+EXPR_TYPE_DURATION_PACK = "!"
+EXPR_TYPE_DURATION_SIZE = struct.calcsize(EXPR_TYPE_DURATION_PACK)
+
+EXPR_TYPE_FLOAT = namedtuple("EXPR_TYPE_FLOAT", [])
+EXPR_TYPE_FLOAT_PACK = "!"
+EXPR_TYPE_FLOAT_SIZE = struct.calcsize(EXPR_TYPE_FLOAT_PACK)
+
 EXPR_TYPE_BOOL = namedtuple("EXPR_TYPE_BOOL", [])
 EXPR_TYPE_BOOL_PACK = "!"
 EXPR_TYPE_BOOL_SIZE = struct.calcsize(EXPR_TYPE_BOOL_PACK)
@@ -392,6 +404,10 @@ EXPR_VAR_UUID_SIZE = struct.calcsize(EXPR_VAR_UUID_PACK)
 
 EXPR_VALUE_DISCRIMINATOR_SIZE = 1
 
+EXPR_VALUE_FLOAT = namedtuple("EXPR_VALUE_FLOAT", ["value"])
+EXPR_VALUE_FLOAT_PACK = "!d"
+EXPR_VALUE_FLOAT_SIZE = struct.calcsize(EXPR_VALUE_FLOAT_PACK)
+
 EXPR_VALUE_BOOL = namedtuple("EXPR_VALUE_BOOL", ["value"])
 EXPR_VALUE_BOOL_PACK = "!?"
 EXPR_VALUE_BOOL_SIZE = struct.calcsize(EXPR_VALUE_BOOL_PACK)
@@ -399,3 +415,28 @@ EXPR_VALUE_BOOL_SIZE = struct.calcsize(EXPR_VALUE_BOOL_PACK)
 EXPR_VALUE_INT = namedtuple("EXPR_VALUE_INT", ["num_bytes"])
 EXPR_VALUE_INT_PACK = "!B"
 EXPR_VALUE_INT_SIZE = struct.calcsize(EXPR_VALUE_INT_PACK)
+
+
+# DURATION
+
+DURATION_DISCRIMINATOR_SIZE = 1
+
+DURATION_DT = namedtuple("DURATION_DT", ["value"])
+DURATION_DT_PACK = "!Q"
+DURATION_DT_SIZE = struct.calcsize(DURATION_DT_PACK)
+
+DURATION_NS = namedtuple("DURATION_NS", ["value"])
+DURATION_NS_PACK = "!d"
+DURATION_NS_SIZE = struct.calcsize(DURATION_NS_PACK)
+
+DURATION_US = namedtuple("DURATION_US", ["value"])
+DURATION_US_PACK = "!d"
+DURATION_US_SIZE = struct.calcsize(DURATION_US_PACK)
+
+DURATION_MS = namedtuple("DURATION_MS", ["value"])
+DURATION_MS_PACK = "!d"
+DURATION_MS_SIZE = struct.calcsize(DURATION_MS_PACK)
+
+DURATION_S = namedtuple("DURATION_S", ["value"])
+DURATION_S_PACK = "!d"
+DURATION_S_SIZE = struct.calcsize(DURATION_S_PACK)

qiskit/qpy/interface.py

@@ -22,16 +22,14 @@ import warnings
 import re
 
 from qiskit.circuit import QuantumCircuit
-from qiskit.pulse import ScheduleBlock
 from qiskit.exceptions import QiskitError
 from qiskit.qpy import formats, common, binary_io, type_keys
-from qiskit.qpy.exceptions import QPYLoadingDeprecatedFeatureWarning, QpyError
+from qiskit.qpy.exceptions import QpyError
 from qiskit.version import __version__
-from qiskit.utils.deprecate_pulse import deprecate_pulse_arg
 
 
 # pylint: disable=invalid-name
-QPY_SUPPORTED_TYPES = Union[QuantumCircuit, ScheduleBlock]
+QPY_SUPPORTED_TYPES = QuantumCircuit
 
 # This version pattern is taken from the pypa packaging project:
 # https://github.com/pypa/packaging/blob/21.3/packaging/version.py#L223-L254
@@ -74,16 +72,11 @@ VERSION_PATTERN = (
 VERSION_PATTERN_REGEX = re.compile(VERSION_PATTERN, re.VERBOSE | re.IGNORECASE)
 
 
-@deprecate_pulse_arg(
-    "programs",
-    deprecation_description="Passing `ScheduleBlock` to `programs`",
-    predicate=lambda p: isinstance(p, ScheduleBlock),
-)
 def dump(
     programs: Union[List[QPY_SUPPORTED_TYPES], QPY_SUPPORTED_TYPES],
     file_obj: BinaryIO,
     metadata_serializer: Optional[Type[JSONEncoder]] = None,
-    use_symengine: bool = True,
+    use_symengine: bool = False,
     version: int = common.QPY_VERSION,
 ):
     """Write QPY binary data to a file
@@ -94,7 +87,10 @@ def dump(
 
     For example:
 
-    .. code-block:: python
+    .. plot::
+       :include-source:
+       :nofigs:
+       :context: reset
 
         from qiskit.circuit import QuantumCircuit
         from qiskit import qpy
@@ -124,18 +120,14 @@ def dump(
 
     Args:
         programs: QPY supported object(s) to store in the specified file like object.
-            QPY supports :class:`.QuantumCircuit` and :class:`.ScheduleBlock`.
-            Different data types must be separately serialized.
-            Support for :class:`.ScheduleBlock` is deprecated since Qiskit 1.3.0.
+            QPY supports :class:`.QuantumCircuit`.
         file_obj: The file like object to write the QPY data too
         metadata_serializer: An optional JSONEncoder class that
             will be passed the ``.metadata`` attribute for each program in ``programs`` and will be
             used as the ``cls`` kwarg on the `json.dump()`` call to JSON serialize that dictionary.
-        use_symengine: If True, all objects containing symbolic expressions will be serialized
-            using symengine's native mechanism. This is a faster serialization alternative,
-            but not supported in all platforms. This flag only has an effect if the emitted QPY format
-            version is 10, 11, or 12. For QPY format version >= 13 (which is the default starting in
-            Qiskit 1.3.0) this flag is no longer used.
+        use_symengine: This flag is no longer used by QPY versions supported by this function and
+            will have no impact on the generated QPY payload except to set a field in a QPY v13 file
+            header which is unused.
         version: The QPY format version to emit. By default this defaults to
             the latest supported format of :attr:`~.qpy.QPY_VERSION`, however for
             compatibility reasons if you need to load the generated QPY payload with an older
@@ -153,7 +145,7 @@ def dump(
 
             .. note::
 
-                If serializing a :class:`.QuantumCircuit` or :class:`.ScheduleBlock` that contain
+                If serializing a :class:`.QuantumCircuit` that contains
                 :class:`.ParameterExpression` objects with ``version`` set low with the intent to
                 load the payload using a historical release of Qiskit, it is safest to set the
                 ``use_symengine`` flag to ``False``.  Versions of Qiskit prior to 1.2.4 cannot load
@@ -163,32 +155,19 @@ def dump(
 
 
     Raises:
-        QpyError: When multiple data format is mixed in the output.
         TypeError: When invalid data type is input.
-        ValueError: When an unsupported version number is passed in for the ``version`` argument
+        ValueError: When an unsupported version number is passed in for the ``version`` argument.
     """
     if not isinstance(programs, Iterable):
         programs = [programs]
 
-    program_types = set()
+    # dump accepts only QuantumCircuit typed objects
     for program in programs:
-        program_types.add(type(program))
+        if not issubclass(type(program), QuantumCircuit):
+            raise TypeError(f"'{type(program)}' is not a supported data type.")
 
-    if len(program_types) > 1:
-        raise QpyError(
-            "Input programs contain multiple data types. "
-            "Different data type must be serialized separately."
-        )
-    program_type = next(iter(program_types))
-
-    if issubclass(program_type, QuantumCircuit):
-        type_key = type_keys.Program.CIRCUIT
-        writer = binary_io.write_circuit
-    elif program_type is ScheduleBlock:
-        type_key = type_keys.Program.SCHEDULE_BLOCK
-        writer = binary_io.write_schedule_block
-    else:
-        raise TypeError(f"'{program_type}' is not supported data type.")
+    type_key = type_keys.Program.CIRCUIT
+    writer = binary_io.write_circuit
 
     if version is None:
         version = common.QPY_VERSION
@@ -215,10 +194,7 @@ def dump(
     file_obj.write(header)
     common.write_type_key(file_obj, type_key)
 
-    pulse_gates = False
     for program in programs:
-        if type_key == type_keys.Program.CIRCUIT and program._calibrations_prop:
-            pulse_gates = True
         writer(
             file_obj,
             program,
@@ -227,13 +203,6 @@ def dump(
             version=version,
         )
 
-    if pulse_gates:
-        warnings.warn(
-            category=DeprecationWarning,
-            message="Pulse gates serialization is deprecated as of Qiskit 1.3. "
-            "It will be removed in Qiskit 2.0.",
-        )
-
 
 def load(
     file_obj: BinaryIO,
@@ -242,8 +211,7 @@ def load(
     """Load a QPY binary file
 
     This function is used to load a serialized QPY Qiskit program file and create
-    :class:`~qiskit.circuit.QuantumCircuit` objects or
-    :class:`~qiskit.pulse.schedule.ScheduleBlock` objects from its contents.
+    :class:`~qiskit.circuit.QuantumCircuit` objects from its contents.
     For example:
 
     .. code-block:: python
@@ -264,12 +232,11 @@ def load(
             circuits = qpy.load(fd)
 
     which will read the contents of the qpy and return a list of
-    :class:`~qiskit.circuit.QuantumCircuit` objects or
-    :class:`~qiskit.pulse.schedule.ScheduleBlock` objects from the file.
+    :class:`~qiskit.circuit.QuantumCircuit` objects from the file.
 
     Args:
         file_obj: A file like object that contains the QPY binary
-            data for a circuit or pulse schedule.
+            data for a circuit.
         metadata_deserializer: An optional JSONDecoder class
             that will be used for the ``cls`` kwarg on the internal
             ``json.load`` call used to deserialize the JSON payload used for
@@ -285,6 +252,11 @@ def load(
     Raises:
         QiskitError: if ``file_obj`` is not a valid QPY file
         TypeError: When invalid data type is loaded.
+        MissingOptionalLibraryError: If the ``symengine`` engine library is
+            not installed when loading a QPY version 10, 11, or 12 payload
+            that is using symengine symbolic encoding and contains
+            :class:`.ParameterExpression` instances.
+        QpyError: if known but unsupported data type is loaded.
     """
 
     # identify file header version
@@ -347,15 +319,10 @@ def load(
     if type_key == type_keys.Program.CIRCUIT:
         loader = binary_io.read_circuit
     elif type_key == type_keys.Program.SCHEDULE_BLOCK:
-        loader = binary_io.read_schedule_block
-        warnings.warn(
-            category=QPYLoadingDeprecatedFeatureWarning,
-            message="Pulse gates deserialization is deprecated as of Qiskit 1.3 and "
-            "will be removed in Qiskit 2.0. This is part of the deprecation plan for "
-            "the entire Qiskit Pulse package. Once Pulse is removed, `ScheduleBlock` "
-            "sections will be ignored when loading QPY files with pulse data.",
+        raise QpyError(
+            "Payloads of type `ScheduleBlock` cannot be loaded as of Qiskit 2.0. "
+            "Use an earlier version of Qiskit if you want to load `ScheduleBlock` payloads."
         )
-
     else:
         raise TypeError(f"Invalid payload format data kind '{type_key}'.")