qiskit 2.0.3__cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl

qiskit/qpy/binary_io/parse_sympy_repr.py

@@ -0,0 +1,121 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2025.
+#
+# 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.
+
+"""Parser for sympy expressions srepr from ParameterExpression internals."""
+
+import ast
+
+from qiskit.qpy.exceptions import QpyError
+
+
+ALLOWED_CALLERS = {
+    "Abs",
+    "Add",
+    "Sub",
+    "Mul",
+    "Div",
+    "Pow",
+    "Symbol",
+    "Integer",
+    "Rational",
+    "Complex",
+    "Float",
+    "log",
+    "sin",
+    "cos",
+    "tan",
+    "atan",
+    "acos",
+    "asin",
+    "exp",
+    "conjugate",
+}
+
+UNARY = {
+    "sin",
+    "cos",
+    "tan",
+    "atan",
+    "acos",
+    "asin",
+    "conjugate",
+    "Symbol",
+    "Integer",
+    "Complex",
+    "Abs",
+    "Float",
+}
+
+
+class ParseSympyWalker(ast.NodeVisitor):
+    """A custom ast walker that is passed the sympy srepr from QPY < 13 and creates a custom
+    expression."""
+
+    def __init__(self):
+        self.stack = []
+
+    def visit_UnaryOp(self, node: ast.UnaryOp):  # pylint: disable=invalid-name
+        """Visit a python unary op node"""
+        self.visit(node.operand)
+        arg = self.stack.pop()
+        if isinstance(node.op, ast.UAdd):
+            self.stack.append(+arg)
+        elif isinstance(node.op, ast.USub):
+            self.stack.append(-arg)
+        elif isinstance(node.op, ast.Not):
+            self.stack.append(not arg)
+        elif isinstance(node.op, ast.Invert):
+            self.stack.append(~arg)
+        else:
+            raise QpyError(f"Invalid unary op as part of sympy srepr: {node.op}")
+
+    def visit_Constant(self, node: ast.Constant):  # pylint: disable=invalid-name
+        """Visit a constant node."""
+        self.stack.append(node.value)
+
+    def visit_Call(self, node: ast.Call):  # pylint: disable=invalid-name
+        """Visit a call node
+
+        This can only be parameter expression allowed sympy call types.
+        """
+        import sympy
+
+        if isinstance(node.func, ast.Name):
+            name = node.func.id
+        else:
+            raise QpyError("Unknown node type")
+
+        if name not in ALLOWED_CALLERS:
+            raise QpyError(f"{name} is not part of a valid sympy expression srepr")
+
+        args = node.args
+        if name in UNARY:
+            if len(args) != 1:
+                raise QpyError(f"{name} has an invalid number of args in sympy srepr")
+            self.visit(args[0])
+            obj = getattr(sympy, name)(self.stack.pop())
+            self.stack.append(obj)
+        else:
+            for arg in args:
+                self.visit(arg)
+            out_args = [self.stack.pop() for _ in range(len(args))]
+            out_args.reverse()
+            obj = getattr(sympy, name)(*out_args)
+            self.stack.append(obj)
+
+
+def parse_sympy_repr(sympy_repr: str):
+    """Parse a given sympy srepr into a symbolic expression object."""
+    tree = ast.parse(sympy_repr, mode="eval")
+    visitor = ParseSympyWalker()
+    visitor.visit(tree)
+    return visitor.stack.pop()

qiskit/qpy/binary_io/schedules.py

@@ -0,0 +1,308 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021.
+#
+# 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.
+
+"""Read schedule and schedule instructions.
+
+This module is kept post pulse-removal to allow reading legacy
+payloads containing pulse gates without breaking the load flow.
+The purpose of the `_read` and `_load` methods below is just to advance
+the file handle while consuming pulse data."""
+import json
+import struct
+import zlib
+
+from io import BytesIO
+
+import numpy as np
+import symengine as sym
+
+from qiskit.exceptions import QiskitError
+from qiskit.qpy import formats, common, type_keys
+from qiskit.qpy.binary_io import value
+from qiskit.qpy.exceptions import QpyError
+
+
+def _read_channel(file_obj, version) -> None:
+    common.read_type_key(file_obj)  # read type_key
+    value.read_value(file_obj, version, {})  # read index
+
+
+def _read_waveform(file_obj, version) -> None:
+    header = formats.WAVEFORM._make(
+        struct.unpack(
+            formats.WAVEFORM_PACK,
+            file_obj.read(formats.WAVEFORM_SIZE),
+        )
+    )
+    samples_raw = file_obj.read(header.data_size)
+    common.data_from_binary(samples_raw, np.load)  # read samples
+    value.read_value(file_obj, version, {})  # read name
+
+
+def _loads_obj(type_key, binary_data, version, vectors):
+    """Wraps `value.loads_value` to deserialize binary data to dictionary
+    or list objects which are not supported by `value.loads_value`.
+    """
+    if type_key == b"D":
+        with BytesIO(binary_data) as container:
+            return common.read_mapping(
+                file_obj=container, deserializer=_loads_obj, version=version, vectors=vectors
+            )
+    elif type_key == b"l":
+        with BytesIO(binary_data) as container:
+            return common.read_sequence(
+                file_obj=container, deserializer=_loads_obj, version=version, vectors=vectors
+            )
+    else:
+        return value.loads_value(type_key, binary_data, version, vectors)
+
+
+def _read_kernel(file_obj, version) -> None:
+    common.read_mapping(
+        file_obj=file_obj,
+        deserializer=_loads_obj,
+        version=version,
+        vectors={},
+    )
+    value.read_value(file_obj, version, {})  # read name
+
+
+def _read_discriminator(file_obj, version) -> None:
+    # read params
+    common.read_mapping(
+        file_obj=file_obj,
+        deserializer=_loads_obj,
+        version=version,
+        vectors={},
+    )
+    value.read_value(file_obj, version, {})  # read name
+
+
+def _loads_symbolic_expr(expr_bytes, use_symengine=False):
+    if expr_bytes == b"":
+        return None
+    expr_bytes = zlib.decompress(expr_bytes)
+    if use_symengine:
+        return common.load_symengine_payload(expr_bytes)
+    else:
+        from sympy import parse_expr
+
+        expr_txt = expr_bytes.decode(common.ENCODE)
+        expr = parse_expr(expr_txt)
+        return sym.sympify(expr)
+
+
+def _read_symbolic_pulse(file_obj, version) -> None:
+    make = formats.SYMBOLIC_PULSE._make
+    pack = formats.SYMBOLIC_PULSE_PACK
+    size = formats.SYMBOLIC_PULSE_SIZE
+
+    header = make(
+        struct.unpack(
+            pack,
+            file_obj.read(size),
+        )
+    )
+    pulse_type = file_obj.read(header.type_size).decode(common.ENCODE)
+    _loads_symbolic_expr(file_obj.read(header.envelope_size))  # read envelope
+    _loads_symbolic_expr(file_obj.read(header.constraints_size))  # read constraints
+    _loads_symbolic_expr(
+        file_obj.read(header.valid_amp_conditions_size)
+    )  # read valid amp conditions
+    # read parameters
+    common.read_mapping(
+        file_obj,
+        deserializer=value.loads_value,
+        version=version,
+        vectors={},
+    )
+
+    # In the transition to Qiskit Terra 0.23 (QPY version 6), the representation of library pulses
+    # was changed from complex "amp" to float "amp" and "angle". The existing library pulses in
+    # previous versions are handled here separately to conform with the new representation. To
+    # avoid role assumption for "amp" for custom pulses, only the library pulses are handled this
+    # way.
+
+    # List of pulses in the library in QPY version 5 and below:
+    legacy_library_pulses = ["Gaussian", "GaussianSquare", "Drag", "Constant"]
+    class_name = "SymbolicPulse"  # Default class name, if not in the library
+
+    if pulse_type in legacy_library_pulses:
+        class_name = "ScalableSymbolicPulse"
+
+    value.read_value(file_obj, version, {})  # read duration
+    value.read_value(file_obj, version, {})  # read name
+
+    if class_name not in {"SymbolicPulse", "ScalableSymbolicPulse"}:
+        raise NotImplementedError(f"Unknown class '{class_name}'")
+
+
+def _read_symbolic_pulse_v6(file_obj, version, use_symengine) -> None:
+    make = formats.SYMBOLIC_PULSE_V2._make
+    pack = formats.SYMBOLIC_PULSE_PACK_V2
+    size = formats.SYMBOLIC_PULSE_SIZE_V2
+
+    header = make(
+        struct.unpack(
+            pack,
+            file_obj.read(size),
+        )
+    )
+    class_name = file_obj.read(header.class_name_size).decode(common.ENCODE)
+    file_obj.read(header.type_size).decode(common.ENCODE)  # read pulse type
+    _loads_symbolic_expr(file_obj.read(header.envelope_size), use_symengine)  # read envelope
+    _loads_symbolic_expr(file_obj.read(header.constraints_size), use_symengine)  # read constraints
+    _loads_symbolic_expr(
+        file_obj.read(header.valid_amp_conditions_size), use_symengine
+    )  # read valid_amp_conditions
+    # read parameters
+    common.read_mapping(
+        file_obj,
+        deserializer=value.loads_value,
+        version=version,
+        vectors={},
+    )
+
+    value.read_value(file_obj, version, {})  # read duration
+    value.read_value(file_obj, version, {})  # read name
+
+    if class_name not in {"SymbolicPulse", "ScalableSymbolicPulse"}:
+        raise NotImplementedError(f"Unknown class '{class_name}'")
+
+
+def _read_alignment_context(file_obj, version) -> None:
+    common.read_type_key(file_obj)
+
+    common.read_sequence(
+        file_obj,
+        deserializer=value.loads_value,
+        version=version,
+        vectors={},
+    )
+
+
+# pylint: disable=too-many-return-statements
+def _loads_operand(type_key, data_bytes, version, use_symengine):
+    if type_key == type_keys.ScheduleOperand.WAVEFORM:
+        return common.data_from_binary(data_bytes, _read_waveform, version=version)
+    if type_key == type_keys.ScheduleOperand.SYMBOLIC_PULSE:
+        if version < 6:
+            return common.data_from_binary(data_bytes, _read_symbolic_pulse, version=version)
+        else:
+            return common.data_from_binary(
+                data_bytes, _read_symbolic_pulse_v6, version=version, use_symengine=use_symengine
+            )
+    if type_key == type_keys.ScheduleOperand.CHANNEL:
+        return common.data_from_binary(data_bytes, _read_channel, version=version)
+    if type_key == type_keys.ScheduleOperand.OPERAND_STR:
+        return data_bytes.decode(common.ENCODE)
+    if type_key == type_keys.ScheduleOperand.KERNEL:
+        return common.data_from_binary(
+            data_bytes,
+            _read_kernel,
+            version=version,
+        )
+    if type_key == type_keys.ScheduleOperand.DISCRIMINATOR:
+        return common.data_from_binary(
+            data_bytes,
+            _read_discriminator,
+            version=version,
+        )
+
+    return value.loads_value(type_key, data_bytes, version, {})
+
+
+def _read_element(file_obj, version, metadata_deserializer, use_symengine) -> None:
+    type_key = common.read_type_key(file_obj)
+
+    if type_key == type_keys.Program.SCHEDULE_BLOCK:
+        return read_schedule_block(file_obj, version, metadata_deserializer, use_symengine)
+
+    # read operands
+    common.read_sequence(
+        file_obj, deserializer=_loads_operand, version=version, use_symengine=use_symengine
+    )
+    # read name
+    value.read_value(file_obj, version, {})
+
+    return None
+
+
+def _loads_reference_item(type_key, data_bytes, metadata_deserializer, version) -> None:
+    if type_key == type_keys.Value.NULL:
+        return None
+    if type_key == type_keys.Program.SCHEDULE_BLOCK:
+        return common.data_from_binary(
+            data_bytes,
+            deserializer=read_schedule_block,
+            version=version,
+            metadata_deserializer=metadata_deserializer,
+        )
+
+    raise QpyError(
+        f"Loaded schedule reference item is neither None nor ScheduleBlock. "
+        f"Type key {type_key} is not valid data type for a reference items. "
+        "This data cannot be loaded. Please check QPY version."
+    )
+
+
+def read_schedule_block(file_obj, version, metadata_deserializer=None, use_symengine=False):
+    """Consume a single ScheduleBlock from the file like object.
+
+    Args:
+        file_obj (File): A file like object that contains the QPY binary data.
+        version (int): QPY version.
+        metadata_deserializer (JSONDecoder): 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
+            the :attr:`.ScheduleBlock.metadata` attribute for a schedule block
+            in the file-like object. If this is not specified the circuit metadata will
+            be parsed as JSON with the stdlib ``json.load()`` function using
+            the default ``JSONDecoder`` class.
+        use_symengine (bool): If True, symbolic objects will be serialized using symengine's
+            native mechanism. This is a faster serialization alternative, but not supported in all
+            platforms. Please check that your target platform is supported by the symengine library
+            before setting this option, as it will be required by qpy to deserialize the payload.
+    Returns:
+        QuantumCircuit: Returns a dummy QuantumCircuit object, containing just name and metadata.
+        This function exists just to allow reading legacy payloads containing pulse information
+        without breaking the entire load flow.
+
+    Raises:
+        TypeError: If any of the instructions is invalid data format.
+        QiskitError: QPY version is earlier than block support.
+    """
+    if version < 5:
+        raise QiskitError(f"QPY version {version} does not support ScheduleBlock.")
+
+    data = formats.SCHEDULE_BLOCK_HEADER._make(
+        struct.unpack(
+            formats.SCHEDULE_BLOCK_HEADER_PACK,
+            file_obj.read(formats.SCHEDULE_BLOCK_HEADER_SIZE),
+        )
+    )
+    file_obj.read(data.name_size).decode(common.ENCODE)  # read name
+    metadata_raw = file_obj.read(data.metadata_size)
+    json.loads(metadata_raw, cls=metadata_deserializer)  # read metadata
+    _read_alignment_context(file_obj, version)
+
+    for _ in range(data.num_elements):
+        _read_element(file_obj, version, metadata_deserializer, use_symengine)
+
+    # Load references
+    if version >= 7:
+        common.read_mapping(
+            file_obj=file_obj,
+            deserializer=_loads_reference_item,
+            version=version,
+            metadata_deserializer=metadata_deserializer,
+        )