iqm-client 30.2.0__py3-none-any.whl → 31.1.0__py3-none-any.whl

iqm/iqm_client/transpile.py

@@ -61,15 +61,15 @@ from collections.abc import Collection, Iterable, Sequence
 from enum import Enum
 
 from iqm.iqm_client import (
-    Circuit,
     CircuitTranspilationError,
     CircuitValidationError,
     DynamicQuantumArchitecture,
-    Instruction,
 )
 from iqm.iqm_client.models import GateImplementationInfo, GateInfo, Locus, _op_is_symmetric
 from iqm.iqm_client.validation import validate_circuit_moves, validate_instruction
 
+from iqm.pulse import Circuit, CircuitOperation
+
 Resolution = tuple[str, str, str]
 """A (gate qubit, move qubit, resonator) triple that represents a resolution of a fictional
  qubit-qubit gate."""
@@ -93,10 +93,10 @@ class ExistingMoveHandlingOptions(str, Enum):
 
 
 def _map_loci(
-    instructions: Iterable[Instruction],
+    instructions: Iterable[CircuitOperation],
     qubit_mapping: dict[str, str],
     inverse: bool = False,
-) -> tuple[Instruction, ...]:
+) -> tuple[CircuitOperation, ...]:
     """Map the loci of the given instructions using the given qubit mapping, or its inverse.
 
     Args:
@@ -111,7 +111,13 @@ def _map_loci(
     if inverse:
         qubit_mapping = {phys: log for log, phys in qubit_mapping.items()}
     return tuple(
-        inst.model_copy(update={"qubits": tuple(qubit_mapping[q] for q in inst.qubits)}) for inst in instructions
+        CircuitOperation(
+            name=inst.name,
+            locus=tuple(qubit_mapping[q] for q in inst.locus),
+            args=inst.args,
+            implementation=inst.implementation,
+        )
+        for inst in instructions
     )
 
 
@@ -212,7 +218,7 @@ class _ResonatorStateTracker:
         return cls.from_instructions(circuit.instructions)
 
     @classmethod
-    def from_instructions(cls, instructions: Iterable[Instruction]) -> _ResonatorStateTracker:
+    def from_instructions(cls, instructions: Iterable[CircuitOperation]) -> _ResonatorStateTracker:
         """Constructor to make the _ResonatorStateTracker from a sequence of instructions.
 
         Infers the resonator connectivity from the MOVE gates.
@@ -227,7 +233,7 @@ class _ResonatorStateTracker:
         qr_gates: dict[str, dict[str, set[str]]] = {}
         for i in instructions:
             if i.name in cls.qr_gate_names:
-                q, r = i.qubits
+                q, r = i.locus
                 qr_gates.setdefault(i.name, {}).setdefault(q, set()).add(r)
         return cls(qr_gates)
 
@@ -270,7 +276,7 @@ class _ResonatorStateTracker:
         self,
         qubit: str,
         resonator: str,
-    ) -> Iterable[Instruction]:
+    ) -> Iterable[CircuitOperation]:
         """MOVE instruction(s) to move the state of the given qubit into the given resonator,
         or back to the qubit.
 
@@ -292,7 +298,7 @@ class _ResonatorStateTracker:
         if owner not in [qubit, resonator]:
             locus = (owner, resonator)
             self.apply_move(*locus)
-            yield Instruction(name=self.move_gate, qubits=locus, args={})
+            yield CircuitOperation(name=self.move_gate, locus=locus, args={})
 
         # if the qubit does not hold its own state, restore it, unless it's in the resonator
         # find where the qubit state is (it can be in at most one resonator)
@@ -300,17 +306,17 @@ class _ResonatorStateTracker:
         if res and (holder := res[0]) != resonator:
             locus = (qubit, holder)
             self.apply_move(*locus)
-            yield Instruction(name=self.move_gate, qubits=locus, args={})
+            yield CircuitOperation(name=self.move_gate, locus=locus, args={})
 
         # move qubit state to resonator, or back to the qubit
         locus = (qubit, resonator)
         self.apply_move(*locus)
-        yield Instruction(name=self.move_gate, qubits=locus, args={})
+        yield CircuitOperation(name=self.move_gate, locus=locus, args={})
 
     def restore_as_move_instructions(
         self,
         resonators: Iterable[str] | None = None,
-    ) -> list[Instruction]:
+    ) -> list[CircuitOperation]:
         """MOVE instructions that move the states held in the given resonators back to their qubits.
 
         Applies the returned MOVE instructions on the tracker state.
@@ -327,13 +333,13 @@ class _ResonatorStateTracker:
         if resonators is None:
             resonators = self.resonators
 
-        instructions: list[Instruction] = []
+        instructions: list[CircuitOperation] = []
         for r in resonators:
             q = self.res_state_owner[r]
             # if the state in r does not belong to r, restore it to its owner
             if q != r:
                 locus = (q, r)
-                instructions.append(Instruction(name=self.move_gate, qubits=locus, args={}))
+                instructions.append(CircuitOperation(name=self.move_gate, locus=locus, args={}))
                 self.apply_move(*locus)
         return instructions
 
@@ -367,7 +373,7 @@ class _ResonatorStateTracker:
         """
         return tuple(self.res_state_owner.get(q, q) for q in locus)
 
-    def find_resolutions(self, inst: Instruction) -> list[Resolution]:
+    def find_resolutions(self, inst: CircuitOperation) -> list[Resolution]:
         """Find all the possible resolutions for the given fictional qubit-qubit gate.
 
         Given a fictional gate G acting on qubits (a, b), finds all resonators r for which the current DQA
@@ -390,10 +396,10 @@ class _ResonatorStateTracker:
             return gate_q2r.get(g, set()) & self.move_q2r.get(m, set())
 
         # G is assumed symmetric, hence we may reverse the locus order for more resolutions
-        a, b = inst.qubits
+        a, b = inst.locus
         return [(a, b, r) for r in get_resonators(a, b)] + [(b, a, r) for r in get_resonators(b, a)]
 
-    def find_best_resolution(self, inst: Instruction, lookahead: Iterable[Instruction]) -> Resolution | None:
+    def find_best_resolution(self, inst: CircuitOperation, lookahead: Iterable[CircuitOperation]) -> Resolution | None:
         """Find the best resolution for the fictional qubit-qubit gate instruction ``inst``
         using the available native qubit-resonator gates.
 
@@ -419,12 +425,12 @@ class _ResonatorStateTracker:
         # but that would scale exponentially in n. Instead we do some heuristics:
         # Look ahead until we find the instructions that target the locus qubits next, and include
         # their costs in the badness calculation.
-        followers: dict[str, Instruction] = {}
+        followers: dict[str, CircuitOperation] = {}
         for follower in lookahead:
             if len(followers) == 2:
                 break  # found a follower for both locus qubits
-            for q in follower.qubits:
-                if q in inst.qubits:
+            for q in follower.locus:
+                if q in inst.locus:
                     followers.setdefault(q, follower)
 
         def get_badness(res: Resolution, g_holder: str, m_holder: str, r_owner: str) -> int:
@@ -499,7 +505,7 @@ class _ResonatorStateTracker:
                     else:
                         # follower needs to use same resonator but different move qubit
                         badness += 2
-                elif len(m_follower.qubits) == 1:
+                elif len(m_follower.locus) == 1:
                     # Not a resolvable QR gate. For 1q gates on m, state must be restored.
                     badness += 1
 
@@ -529,7 +535,7 @@ class _ResonatorStateTracker:
         # return the best option
         return min(options, key=lambda x: x[1])[0]
 
-    def get_sequence(self, resolution: Resolution, inst: Instruction) -> list[Instruction]:
+    def get_sequence(self, resolution: Resolution, inst: CircuitOperation) -> list[CircuitOperation]:
         """Apply a fictional two-qubit gate using a sequence of native qubit-resonator gates.
 
         See :mod:`~iqm.iqm_client.transpile`.
@@ -547,7 +553,7 @@ class _ResonatorStateTracker:
 
         """
         g, m, r = resolution
-        seq: list[Instruction] = []
+        seq: list[CircuitOperation] = []
         # does m state need to be moved to the resonator?
         m_holder = self.qubit_state_holder.get(m, m)
         if m_holder != r:
@@ -557,14 +563,14 @@ class _ResonatorStateTracker:
         if g_holder != g:
             seq += self.restore_as_move_instructions([g_holder])
         # apply G(g, r)
-        seq.append(inst.model_copy(update={"qubits": (g, r)}))
+        seq.append(CircuitOperation(name=inst.name, locus=(g, r), args=inst.args, implementation=inst.implementation))
         return seq
 
     def insert_moves(
         self,
-        instructions: Sequence[Instruction],
+        instructions: Sequence[CircuitOperation],
         arch: DynamicQuantumArchitecture,
-    ) -> list[Instruction]:
+    ) -> list[CircuitOperation]:
         """Convert a simplified architecture circuit into a equivalent Star architecture circuit with
         resonators and MOVE gates.
 
@@ -587,10 +593,10 @@ class _ResonatorStateTracker:
         """
         # This method can handle real single- and two-qubit gates, real q-r gates including MOVE,
         # and fictional two-qubit gates which it decomposes into real q-r gates.
-        new_instructions: list[Instruction] = []
+        new_instructions: list[CircuitOperation] = []
 
         for idx, inst in enumerate(instructions):
-            locus = inst.qubits
+            locus = inst.locus
             try:
                 validate_instruction(architecture=arch, instruction=inst)
                 # inst can be applied as is on locus, but we may first need to use MOVEs to make
@@ -828,11 +834,11 @@ def transpile_remove_moves(circuit: Circuit) -> Circuit:
     for inst in circuit.instructions:
         if inst.name == tracker.move_gate:
             # update the state tracking, drop the MOVE
-            tracker.apply_move(*inst.qubits)
+            tracker.apply_move(*inst.locus)
         else:
             # map the instruction locus
-            new_qubits = tracker.map_resonators_in_locus(inst.qubits)
+            new_locus = tracker.map_resonators_in_locus(inst.locus)
             new_instructions.append(
-                Instruction(name=inst.name, implementation=inst.implementation, qubits=new_qubits, args=inst.args)
+                CircuitOperation(name=inst.name, implementation=inst.implementation, locus=new_locus, args=inst.args)
             )
     return Circuit(name=circuit.name, instructions=tuple(new_instructions), metadata=circuit.metadata)

iqm/iqm_client/validation.py

@@ -13,14 +13,14 @@ import itertools
 from iqm.iqm_client.errors import CircuitValidationError
 from iqm.iqm_client.models import (
     _SUPPORTED_OPERATIONS,
-    Circuit,
     CircuitBatch,
     DynamicQuantumArchitecture,
-    Instruction,
     MoveGateValidationMode,
     QIRCode,
 )
 
+from iqm.pulse import Circuit, CircuitOperation
+
 
 def validate_qubit_mapping(
     architecture: DynamicQuantumArchitecture,
@@ -52,7 +52,7 @@ def validate_qubit_mapping(
     for i, circuit in enumerate(circuits):
         if isinstance(circuit, (QIRCode)):
             continue
-        diff = circuit.all_qubits() - set(qubit_mapping)
+        diff = circuit.all_locus_components() - set(qubit_mapping)
         if diff:
             raise CircuitValidationError(
                 f"The qubits {diff} in circuit '{circuit.name}' at index {i} "
@@ -112,7 +112,7 @@ def validate_circuit_instructions(
 
 def validate_instruction(
     architecture: DynamicQuantumArchitecture,
-    instruction: Instruction,
+    instruction: CircuitOperation,
     qubit_mapping: dict[str, str] | None = None,
 ) -> None:
     """Validate an instruction against the dynamic quantum architecture.
@@ -134,11 +134,11 @@ def validate_instruction(
         raise CircuitValidationError(f"Unknown quantum operation '{instruction.name}'.")
 
     # apply the qubit mapping if any
-    mapped_qubits = tuple(qubit_mapping[q] for q in instruction.qubits) if qubit_mapping else instruction.qubits
+    mapped_qubits = tuple(qubit_mapping[q] for q in instruction.locus) if qubit_mapping else instruction.locus
 
     def check_locus_components(allowed_components: Iterable[str], msg: str) -> None:
         """Checks that the instruction locus consists of the allowed components only."""
-        for q, mapped_q in zip(instruction.qubits, mapped_qubits):
+        for q, mapped_q in zip(instruction.locus, mapped_qubits):
             if mapped_q not in allowed_components:
                 raise CircuitValidationError(
                     f"{instruction!r}: Component {q} = {mapped_q} {msg}."
@@ -146,10 +146,14 @@ def validate_instruction(
                     else f"{instruction!r}: Component {q} {msg}."
                 )
 
-    if op_info.no_calibration_needed:
-        # all QPU loci are allowed
-        check_locus_components(architecture.components, msg="does not exist on the QPU")
-        return
+    impl_name = instruction.implementation or _SUPPORTED_OPERATIONS[
+        instruction.name
+    ].get_default_implementation_for_locus(instruction.locus)
+    if (impl := op_info.implementations.get(impl_name)) is not None:
+        if not impl.needs_calibration():
+            # all QPU loci are allowed
+            check_locus_components(architecture.components, msg="does not exist on the QPU")
+            return
 
     gate_info = architecture.gates.get(instruction.name)
     if gate_info is None:
@@ -187,13 +191,13 @@ def validate_instruction(
     )
     if mapped_qubits not in all_loci:
         raise CircuitValidationError(
-            f"{instruction.qubits} = {tuple(mapped_qubits)} is not allowed as locus for '{instruction_name}'"
+            f"{instruction.locus} = {tuple(mapped_qubits)} is not allowed as locus for '{instruction_name}'"
             if qubit_mapping
-            else f"{instruction.qubits} is not allowed as locus for '{instruction_name}'"
+            else f"{instruction.locus} is not allowed as locus for '{instruction_name}'"
         )
 
 
-def validate_circuit_moves(
+def validate_circuit_moves(  # noqa: PLR0912
     architecture: DynamicQuantumArchitecture,
     circuit: Circuit,
     qubit_mapping: dict[str, str] | None = None,
@@ -243,17 +247,17 @@ def validate_circuit_moves(
 
     for inst in circuit.instructions:
         if inst.name == "move":
-            qubit, resonator = inst.qubits
+            qubit, resonator = inst.locus
             if not (qubit in all_qubits and resonator in all_resonators):
                 raise CircuitValidationError(
-                    f"MOVE instructions are only allowed between qubit and resonator, not {inst.qubits}."
+                    f"MOVE instructions are only allowed between qubit and resonator, not {inst.locus}."
                 )
 
             if (resonator_qubit := resonator_occupations.get(resonator)) is None:
                 # Beginning MOVE: check that the qubit hasn't been moved to another resonator
                 if qubit in moved_qubits:
                     raise CircuitValidationError(
-                        f"MOVE instruction {inst.qubits}: state of {qubit} is "
+                        f"MOVE instruction {inst.locus}: state of {qubit} is "
                         f"in another resonator: {resonator_occupations}."
                     )
                 resonator_occupations[resonator] = qubit
@@ -262,16 +266,16 @@ def validate_circuit_moves(
                 # Ending MOVE: check that the qubit matches to the qubit that was moved to the resonator
                 if resonator_qubit != qubit:
                     raise CircuitValidationError(
-                        f"MOVE instruction {inst.qubits} to an already occupied resonator: {resonator_occupations}."
+                        f"MOVE instruction {inst.locus} to an already occupied resonator: {resonator_occupations}."
                     )
                 del resonator_occupations[resonator]
                 moved_qubits.remove(qubit)
         elif moved_qubits:
             # Validate that moved qubits are not used during MOVE operations
             if inst.name not in allowed_gates:
-                if overlap := set(inst.qubits) & moved_qubits:
+                if overlap := set(inst.locus) & moved_qubits:
                     raise CircuitValidationError(
-                        f"Instruction {inst.name} acts on {inst.qubits} while the state(s) of {overlap} "
+                        f"Instruction {inst.name} acts on {inst.locus} while the state(s) of {overlap} "
                         f"are in a resonator. Current resonator occupation: {resonator_occupations}."
                     )
 

iqm/qiskit_iqm/iqm_job.py

@@ -24,7 +24,6 @@ import warnings
 from iqm.iqm_client import (
     DEFAULT_TIMEOUT_SECONDS,
     APITimeoutError,
-    Circuit,
     CircuitMeasurementResults,
     HeraldingMode,
     IQMClient,
@@ -38,6 +37,8 @@ import numpy as np
 from qiskit.providers import JobStatus, JobV1
 from qiskit.result import Counts, Result
 
+from iqm.pulse import Circuit
+
 if TYPE_CHECKING:
     from iqm.qiskit_iqm.iqm_provider import IQMBackend
 

iqm/qiskit_iqm/iqm_provider.py

@@ -22,7 +22,6 @@ from uuid import UUID
 import warnings
 
 from iqm.iqm_client import (
-    Circuit,
     CircuitBatch,
     CircuitCompilationOptions,
     CircuitValidationError,
@@ -39,6 +38,8 @@ from iqm.qiskit_iqm.qiskit_to_iqm import serialize_instructions
 from qiskit import QuantumCircuit
 from qiskit.providers import JobStatus, JobV1, Options
 
+from iqm.pulse import Circuit
+
 try:
     __version__ = version("qiskit-iqm")
 except PackageNotFoundError:  # pragma: no cover

iqm/qiskit_iqm/qiskit_to_iqm.py

@@ -17,15 +17,16 @@ from __future__ import annotations
 
 from collections.abc import Collection
 from dataclasses import dataclass
+from math import pi
 import re
 
-from iqm.iqm_client import Instruction
 from iqm.qiskit_iqm.move_gate import MoveGate
-import numpy as np
 from qiskit import QuantumCircuit as QiskitQuantumCircuit
 from qiskit.circuit import ClassicalRegister, Clbit, QuantumRegister
 from qiskit.transpiler.layout import Layout
 
+from iqm.pulse import CircuitOperation
+
 
 class InstructionNotSupportedError(RuntimeError):
     """Raised when a given instruction is not supported by the IQM server."""
@@ -94,7 +95,7 @@ class MeasurementKey:
 
 def serialize_instructions(  # noqa: PLR0912, PLR0915
     circuit: QiskitQuantumCircuit, qubit_index_to_name: dict[int, str], allowed_nonnative_gates: Collection[str] = ()
-) -> list[Instruction]:
+) -> list[CircuitOperation]:
     """Serialize a quantum circuit into the IQM data transfer format.
 
     This is IQM's internal helper for :meth:`.IQMBackend.serialize_circuit` that gives slightly more control.
@@ -116,32 +117,32 @@ def serialize_instructions(  # noqa: PLR0912, PLR0915
         ValueError: circuit contains an unsupported instruction or is not transpiled in general
 
     """
-    instructions: list[Instruction] = []
+    instructions: list[CircuitOperation] = []
     # maps clbits to the latest "measure" instruction to store its result there
-    clbit_to_measure: dict[Clbit, Instruction] = {}
+    clbit_to_measure: dict[Clbit, CircuitOperation] = {}
     for circuit_instruction in circuit.data:
         instruction = circuit_instruction.operation
-        qubit_names = [qubit_index_to_name[circuit.find_bit(qubit).index] for qubit in circuit_instruction.qubits]
+        qubit_names = tuple(qubit_index_to_name[circuit.find_bit(qubit).index] for qubit in circuit_instruction.qubits)
         if instruction.name == "r":
-            angle_t = float(instruction.params[0] / (2 * np.pi))
-            phase_t = float(instruction.params[1] / (2 * np.pi))
-            native_inst = Instruction(name="prx", qubits=qubit_names, args={"angle_t": angle_t, "phase_t": phase_t})
+            angle = float(instruction.params[0])
+            phase = float(instruction.params[1])
+            native_inst = CircuitOperation(name="prx", locus=qubit_names, args={"angle": angle, "phase": phase})
         elif instruction.name == "x":
-            native_inst = Instruction(name="prx", qubits=qubit_names, args={"angle_t": 0.5, "phase_t": 0.0})
+            native_inst = CircuitOperation(name="prx", locus=qubit_names, args={"angle": pi, "phase": 0.0})
         elif instruction.name == "rx":
-            angle_t = float(instruction.params[0] / (2 * np.pi))
-            native_inst = Instruction(name="prx", qubits=qubit_names, args={"angle_t": angle_t, "phase_t": 0.0})
+            angle = float(instruction.params[0])
+            native_inst = CircuitOperation(name="prx", locus=qubit_names, args={"angle": angle, "phase": 0.0})
         elif instruction.name == "y":
-            native_inst = Instruction(name="prx", qubits=qubit_names, args={"angle_t": 0.5, "phase_t": 0.25})
+            native_inst = CircuitOperation(name="prx", locus=qubit_names, args={"angle": pi, "phase": 0.5 * pi})
         elif instruction.name == "ry":
-            angle_t = float(instruction.params[0] / (2 * np.pi))
-            native_inst = Instruction(name="prx", qubits=qubit_names, args={"angle_t": angle_t, "phase_t": 0.25})
+            angle = float(instruction.params[0])
+            native_inst = CircuitOperation(name="prx", locus=qubit_names, args={"angle": angle, "phase": 0.5 * pi})
         elif instruction.name == "cz":
-            native_inst = Instruction(name="cz", qubits=qubit_names, args={})
+            native_inst = CircuitOperation(name="cz", locus=qubit_names, args={})
         elif instruction.name == "move":
-            native_inst = Instruction(name="move", qubits=qubit_names, args={})
+            native_inst = CircuitOperation(name="move", locus=qubit_names, args={})
         elif instruction.name == "barrier":
-            native_inst = Instruction(name="barrier", qubits=qubit_names, args={})
+            native_inst = CircuitOperation(name="barrier", locus=qubit_names, args={})
         elif instruction.name == "delay":
             duration = float(instruction.params[0])
             # convert duration to seconds
@@ -160,7 +161,7 @@ def serialize_instructions(  # noqa: PLR0912, PLR0915
                 duration *= 1e-12
             else:
                 raise ValueError(f"Delay: Unsupported unit '{unit}'")
-            native_inst = Instruction(name="delay", qubits=qubit_names, args={"duration": duration})
+            native_inst = CircuitOperation(name="delay", locus=qubit_names, args={"duration": duration})
         elif instruction.name == "measure":
             if len(circuit_instruction.clbits) != 1:
                 raise ValueError(
@@ -168,15 +169,15 @@ def serialize_instructions(  # noqa: PLR0912, PLR0915
                 )
             clbit = circuit_instruction.clbits[0]  # always a single-qubit measurement
             mk = str(MeasurementKey.from_clbit(clbit, circuit))
-            native_inst = Instruction(name="measure", qubits=qubit_names, args={"key": mk})
+            native_inst = CircuitOperation(name="measure", locus=qubit_names, args={"key": mk})
             clbit_to_measure[clbit] = native_inst
         elif instruction.name == "reset":
-            native_inst = Instruction(name="reset", qubits=qubit_names, args={})
+            native_inst = CircuitOperation(name="reset", locus=qubit_names, args={})
         elif instruction.name == "id":
             continue
         elif instruction.name in allowed_nonnative_gates:
             args = {f"p{i}": param for i, param in enumerate(instruction.params)}
-            native_inst = Instruction.model_construct(name=instruction.name, qubits=tuple(qubit_names), args=args)
+            native_inst = CircuitOperation(name=instruction.name, locus=qubit_names, args=args)
         else:
             raise ValueError(
                 f"Instruction '{instruction.name}' in the circuit '{circuit.name}' is not natively supported. "
@@ -211,7 +212,7 @@ def serialize_instructions(  # noqa: PLR0912, PLR0915
             measure_inst = clbit_to_measure[clbit]
             feedback_key = measure_inst.args["key"]
             measure_inst.args["feedback_key"] = feedback_key  # this measure is used to provide feedback
-            physical_qubit_name = measure_inst.qubits[0]  # single-qubit measurement
+            physical_qubit_name = measure_inst.locus[0]  # single-qubit measurement
             native_inst.args["feedback_key"] = feedback_key
             native_inst.args["feedback_qubit"] = physical_qubit_name
 
@@ -220,7 +221,7 @@ def serialize_instructions(  # noqa: PLR0912, PLR0915
 
 
 def deserialize_instructions(
-    instructions: list[Instruction], qubit_name_to_index: dict[str, int], layout: Layout
+    instructions: list[CircuitOperation], qubit_name_to_index: dict[str, int], layout: Layout
 ) -> QiskitQuantumCircuit:
     """Helper function to turn a list of IQM Instructions into a Qiskit QuantumCircuit.
 
@@ -276,11 +277,11 @@ def deserialize_instructions(
         *(cl_regs.get(i, ClassicalRegister(0)) for i in range(max(cl_regs) + 1 if cl_regs else 0)),
     )
     for instr in instructions:
-        locus = [index_to_qiskit_qubit[qubit_name_to_index[q]] for q in instr.qubits]
+        locus = [index_to_qiskit_qubit[qubit_name_to_index[q]] for q in instr.locus]
         if instr.name == "prx":
-            angle_t = instr.args["angle_t"] * 2 * np.pi
-            phase_t = instr.args["phase_t"] * 2 * np.pi
-            circuit.r(angle_t, phase_t, locus[0])
+            angle = instr.args["angle"]
+            phase = instr.args["phase"]
+            circuit.r(angle, phase, locus[0])
         elif instr.name == "cz":
             circuit.cz(*locus)
         elif instr.name == "move":
@@ -294,11 +295,11 @@ def deserialize_instructions(
             duration = instr.args["duration"]
             circuit.delay(duration, locus, unit="s")  # native delay instructions always use seconds
         elif instr.name == "cc_prx":
-            angle_t = instr.args["angle_t"] * 2 * np.pi
-            phase_t = instr.args["phase_t"] * 2 * np.pi
+            angle = instr.args["angle"]
+            phase = instr.args["phase"]
             feedback_key = instr.args["feedback_key"]
             # NOTE: 'feedback_qubit' is not needed, because in Qiskit you only have single-qubit measurements.
-            circuit.r(angle_t, phase_t, locus[0]).c_if(fk_to_clbit[feedback_key], 1)
+            circuit.r(angle, phase, locus[0]).c_if(fk_to_clbit[feedback_key], 1)
         elif instr.name == "reset":
             for qubit in locus:
                 circuit.reset(qubit)

{iqm_client-30.2.0.dist-info → iqm_client-31.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: iqm-client
-Version: 30.2.0
+Version: 31.1.0
 Summary: Client library for accessing an IQM quantum computer
 Author-email: IQM Finland Oy <developers@meetiqm.com>
 License: Apache License
@@ -216,30 +216,34 @@ Requires-Python: <3.13,>=3.10
 Description-Content-Type: text/x-rst
 License-File: LICENSE.txt
 License-File: AUTHORS.rst
-Requires-Dist: iqm-station-control-client <10,>=9
+Requires-Dist: iqm-station-control-client <11,>=10
 Requires-Dist: iqm-exa-common <27,>=26
+Requires-Dist: iqm-pulse <13,>=12
 Requires-Dist: numpy <3.0,>=1.26.4
 Requires-Dist: packaging ==24.1
 Requires-Dist: pydantic <3.0,>=2.9.2
 Requires-Dist: requests ==2.32.3
 Provides-Extra: cirq
-Requires-Dist: iqm-station-control-client <10,>=9 ; extra == 'cirq'
+Requires-Dist: iqm-station-control-client <11,>=10 ; extra == 'cirq'
 Requires-Dist: iqm-exa-common <27,>=26 ; extra == 'cirq'
+Requires-Dist: iqm-pulse <13,>=12 ; extra == 'cirq'
 Requires-Dist: cirq-core[contrib] ~=1.2 ; extra == 'cirq'
 Requires-Dist: ply ==3.11 ; extra == 'cirq'
 Requires-Dist: llvmlite >=0.44.0 ; extra == 'cirq'
 Requires-Dist: numba >=0.61.0 ; extra == 'cirq'
 Provides-Extra: cli
-Requires-Dist: iqm-station-control-client <10,>=9 ; extra == 'cli'
+Requires-Dist: iqm-station-control-client <11,>=10 ; extra == 'cli'
 Requires-Dist: iqm-exa-common <27,>=26 ; extra == 'cli'
+Requires-Dist: iqm-pulse <13,>=12 ; extra == 'cli'
 Requires-Dist: click <9,>=8.1.6 ; extra == 'cli'
 Requires-Dist: jsonschema >=4.6.0 ; extra == 'cli'
 Requires-Dist: psutil >=5.9.2 ; extra == 'cli'
 Requires-Dist: types-psutil ; extra == 'cli'
 Requires-Dist: python-daemon >=2.3.0 ; extra == 'cli'
 Provides-Extra: qiskit
-Requires-Dist: iqm-station-control-client <10,>=9 ; extra == 'qiskit'
+Requires-Dist: iqm-station-control-client <11,>=10 ; extra == 'qiskit'
 Requires-Dist: iqm-exa-common <27,>=26 ; extra == 'qiskit'
+Requires-Dist: iqm-pulse <13,>=12 ; extra == 'qiskit'
 Requires-Dist: qiskit <=1.4.2,>=1.0 ; extra == 'qiskit'
 Requires-Dist: qiskit-aer <0.18,>=0.13.1 ; extra == 'qiskit'
 

{iqm_client-30.2.0.dist-info → iqm_client-31.1.0.dist-info}/RECORD

@@ -4,7 +4,7 @@ iqm/cirq_iqm/iqm_gates.py,sha256=xnZex5ZfNOk_WSsFjVCRybc14FlGNbmwOs3mIfOE_F8,248
 iqm/cirq_iqm/iqm_sampler.py,sha256=uDlxd1cU7yKVYsj-wxfsUDkK9lDdHQzzN4mKonRFow8,11472
 iqm/cirq_iqm/optimizers.py,sha256=Jcb6W7-M9wYa5mZztq33jQpWuIzD5ulE16ZperIc-wU,8566
 iqm/cirq_iqm/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-iqm/cirq_iqm/serialize.py,sha256=tRkNrzef24va8UMq_Z-TKCsmP7xXtHm3R5qB2VyiIt4,8141
+iqm/cirq_iqm/serialize.py,sha256=UwW9plc_qHwxa0DOVB8nSEx7wmzSZ4NgtUTlm77joYc,8516
 iqm/cirq_iqm/transpiler.py,sha256=c3-KE4c-4WenbdOcBMnCS30Ynm4Wt35i-bl4iG8pKAs,2112
 iqm/cirq_iqm/devices/__init__.py,sha256=WxbvNAqmeoV4mNy9M9IpjwmyNDpAP7ec1XFdjN7w_YA,840
 iqm/cirq_iqm/devices/adonis.py,sha256=ZWaA4_OfO6fBcrLYHONTjtW8aSlVq2nwy9IiW529gQw,1390
@@ -21,12 +21,12 @@ iqm/iqm_client/__init__.py,sha256=D-8W54EcQIxk_1JZo_86GYlR1YitHhPIiFwwLJ2IfGE,14
 iqm/iqm_client/api.py,sha256=_c6OVuv2dyzBF7J2XlK_qxisTSPyOiI4gYokZPsuaJY,3083
 iqm/iqm_client/authentication.py,sha256=kHFqPI6w3OAk9k5ioPxi-FrD2EP-vjn8Z_wZYccJVyE,12259
 iqm/iqm_client/errors.py,sha256=ty2P-sg80zlAoL3_kC3PlprgDUv4PI-KFhmmxaaapS0,1429
-iqm/iqm_client/iqm_client.py,sha256=oEeosKvXd_lVreB0r7TwHnYs6AAOjJs1sUDNk-AtzAk,41793
-iqm/iqm_client/models.py,sha256=DldEBjU3oHG4_1m5IPP_veZP9ZFOnVvmpsPipsSyt78,51693
+iqm/iqm_client/iqm_client.py,sha256=LtfznCt9RPvYn45mcVnfIWT8vekoZ548iWwl5iS318U,41798
+iqm/iqm_client/models.py,sha256=hvnJYLOiycaXluWQgsip9CAnyb5l8i4xFYHt2qqUg7A,41831
 iqm/iqm_client/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-iqm/iqm_client/transpile.py,sha256=eEv9eY5QG94Lke7Xp6BkQapl1rvlmlVQ_IkQFopPNQ8,36981
+iqm/iqm_client/transpile.py,sha256=2hDxQK8F4eMgpJC06XMIA8YbguFnRVNMlE1iKQNiTZk,37268
 iqm/iqm_client/util.py,sha256=obzh1g6PNEXOj7k3gUkiylNUhyqutbWlxlEpfyyU_fk,1505
-iqm/iqm_client/validation.py,sha256=IKXBxnhLLnEuUCU2J0q6VEYn9k-O9z_MI4ys7mpFZdE,11912
+iqm/iqm_client/validation.py,sha256=GAe5GQAEXyplbmS_ioIRLR4fhCYKSranB0vE06qMfe8,12192
 iqm/iqm_client/cli/__init__.py,sha256=zzLDDz5rc3lJke3OKU8zxR5zQyQoM9oI2bLJ2YKk_zQ,692
 iqm/iqm_client/cli/auth.py,sha256=kESEK9-vpEhrjba3Lb6Wqx24yGfbjxUASeCArnVRYrw,6364
 iqm/iqm_client/cli/cli.py,sha256=vdhRJPKbqKRL0D_Z0uc3V73jQKKftAKE5Hx44oOCBwA,28689
@@ -36,15 +36,15 @@ iqm/qiskit_iqm/__init__.py,sha256=Mv9V_r8ZcmGC8Ke5S8-7yLOx02vjZ1qiVx8mtbOpwnY,14
 iqm/qiskit_iqm/iqm_backend.py,sha256=HddizT6yHHq-MOG_U48n6ftE9AqmzaqbXYayEC1ljso,5548
 iqm/qiskit_iqm/iqm_circuit.py,sha256=jaPo3zc5FC0vAIumh5d56fr44fDaJXXwcquBzQEy1Yg,1400
 iqm/qiskit_iqm/iqm_circuit_validation.py,sha256=9pneZKs-KjBDGeDI6RHj6lB-ACqugbnYr1BqkJwLcXg,1737
-iqm/qiskit_iqm/iqm_job.py,sha256=A8IvhsU_DTGMG2itBYXRMyQcOZSQ-48IE5ltkzbuc6k,11682
+iqm/qiskit_iqm/iqm_job.py,sha256=YLkAF4oqQ44dOLWbsqMiYCyj7pd3Rk6NIZ_TI1XtcQ8,11700
 iqm/qiskit_iqm/iqm_move_layout.py,sha256=ECf1BcRmXKeClc7AL0lHedvJbqtwV5rEHcOOFR8shKU,10534
 iqm/qiskit_iqm/iqm_naive_move_pass.py,sha256=jhTfvhrNDKt6NhhJg_3Y-5x6E1HRNzC_n4A27ZQTuvQ,12962
-iqm/qiskit_iqm/iqm_provider.py,sha256=56WzHzfa3FeOdMB7RRARgSEc6KRU0I7ozX1iCiTyMFw,18214
+iqm/qiskit_iqm/iqm_provider.py,sha256=gpQ8RLdjc0iyp1nSowiu7VoUrH3wZ9AgeJCHFKnu150,18232
 iqm/qiskit_iqm/iqm_target.py,sha256=UyULiGMn6UJsyILBQiriso9KbhlmzP9TZItS2URaXWg,15832
 iqm/qiskit_iqm/iqm_transpilation.py,sha256=6_6Mri01_HQBV_GTX94WSvIbu-pDMLMzEU6zVMEt6Gc,9153
 iqm/qiskit_iqm/move_gate.py,sha256=UbrQSfrpVV3QKGJ93TelxEfZkl1wY4uWL8IH_QDpGUw,2840
 iqm/qiskit_iqm/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-iqm/qiskit_iqm/qiskit_to_iqm.py,sha256=9JGcR_7K1Y5W6_PBP1bVCZqy7khCOa-BU9m1I9MJB5k,15056
+iqm/qiskit_iqm/qiskit_to_iqm.py,sha256=3Sm1gLELFLCLf6QiATZSiPzLzkjvzUakhU2N6KoBXC8,14948
 iqm/qiskit_iqm/transpiler_plugins.py,sha256=iuReGL42fCe5aOoH-KMUsb6t7Ok9qmIIj2S4yotJJ-U,8749
 iqm/qiskit_iqm/examples/__init__.py,sha256=M4ElQHCo-WxtVXK39bF3QiFT3IGXPtZ1khqexHiTBEc,20
 iqm/qiskit_iqm/examples/bell_measure.py,sha256=iMZB_MNMf2XP6Eiv2XbhtNs4bXbMGQeMw7ohw2JWKS8,1903
@@ -57,10 +57,10 @@ iqm/qiskit_iqm/fake_backends/fake_apollo.py,sha256=eT2vd3kQBi1rrvxCpePymBCfFK84d
 iqm/qiskit_iqm/fake_backends/fake_deneb.py,sha256=RzQXmLXmBARDiMKVxk5Aw9fVbc6IYlW0A5jibk9iYD0,3156
 iqm/qiskit_iqm/fake_backends/fake_garnet.py,sha256=GI0xafTCj1Um09qVuccO6GPOGBm6ygul_O40Wu220Ys,5555
 iqm/qiskit_iqm/fake_backends/iqm_fake_backend.py,sha256=wJtfsxjPYbDKmzaz5R4AuaXvvPHa21WyPtRgNctL9eY,16785
-iqm_client-30.2.0.dist-info/AUTHORS.rst,sha256=qsxeK5A3-B_xK3hNbhFHEIkoHNpo7sdzYyRTs7Bdtm8,795
-iqm_client-30.2.0.dist-info/LICENSE.txt,sha256=2DXrmQtVVUV9Fc9RBFJidMiTEaQlG2oAtlC9PMrEwTk,11333
-iqm_client-30.2.0.dist-info/METADATA,sha256=nXvgyDgwhFoCjrAsin1iwwp8ooLY1yM6IVMfEaYLm-4,17692
-iqm_client-30.2.0.dist-info/WHEEL,sha256=y4mX-SOX4fYIkonsAGA5N0Oy-8_gI4FXw5HNI1xqvWg,91
-iqm_client-30.2.0.dist-info/entry_points.txt,sha256=Kk2qfRwk8vbIJ7qCAvmaUogfRRn6t92_hBFhe6kqAE4,1317
-iqm_client-30.2.0.dist-info/top_level.txt,sha256=NB4XRfyDS6_wG9gMsyX-9LTU7kWnTQxNvkbzIxGv3-c,4
-iqm_client-30.2.0.dist-info/RECORD,,
+iqm_client-31.1.0.dist-info/AUTHORS.rst,sha256=qsxeK5A3-B_xK3hNbhFHEIkoHNpo7sdzYyRTs7Bdtm8,795
+iqm_client-31.1.0.dist-info/LICENSE.txt,sha256=2DXrmQtVVUV9Fc9RBFJidMiTEaQlG2oAtlC9PMrEwTk,11333
+iqm_client-31.1.0.dist-info/METADATA,sha256=hEG2wANHjcQrrGk3v9sTahl1E6DguwJozpTok8e7Ts0,17887
+iqm_client-31.1.0.dist-info/WHEEL,sha256=y4mX-SOX4fYIkonsAGA5N0Oy-8_gI4FXw5HNI1xqvWg,91
+iqm_client-31.1.0.dist-info/entry_points.txt,sha256=Kk2qfRwk8vbIJ7qCAvmaUogfRRn6t92_hBFhe6kqAE4,1317
+iqm_client-31.1.0.dist-info/top_level.txt,sha256=NB4XRfyDS6_wG9gMsyX-9LTU7kWnTQxNvkbzIxGv3-c,4
+iqm_client-31.1.0.dist-info/RECORD,,