iqm-client 32.0.0__py3-none-any.whl → 33.0.0__py3-none-any.whl

iqm/qiskit_iqm/qiskit_to_iqm.py

@@ -15,21 +15,24 @@
 
 from __future__ import annotations
 
-from collections.abc import Collection
+from collections.abc import Collection, Iterable
 from dataclasses import dataclass
 from math import pi
 import re
+import warnings
 
 from iqm.qiskit_iqm.move_gate import MoveGate
+from packaging.version import Version
 from qiskit import QuantumCircuit as QiskitQuantumCircuit
-from qiskit.circuit import ClassicalRegister, Clbit, QuantumRegister
+from qiskit import __version__ as qiskit_version
+from qiskit.circuit import ClassicalRegister, Clbit, Operation, QuantumRegister, Qubit
 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."""
+    """Raised when a given instruction is not supported by the IQM Server."""
 
 
 @dataclass(frozen=True)
@@ -52,7 +55,7 @@ class MeasurementKey:
     ``IQMJob``, since otherwise users will not be able to retrieve results from a detached Python
     environment solely based on the job id. Another option is to use measurement key strings to
     store the required info. Qiskit does not use measurement keys, so we are free to use them
-    internally in the communication with the IQM server, and can encode the necessary information in
+    internally in the communication with the IQM Server, and can encode the necessary information in
     them.
 
     This class encapsulates the necessary info, and provides methods to transform between this
@@ -93,8 +96,107 @@ class MeasurementKey:
         return cls(creg.name, len(creg), creg_idx, clbit_idx)
 
 
+def _apply_condition(
+    operation: Operation,
+    native_instructions: Iterable[CircuitOperation],
+    clbit_to_measure: dict[Clbit, CircuitOperation],
+) -> None:
+    """Apply a classical condition to circuit instructions.
+
+    Modifies the instructions in place.
+
+    Args:
+        operation: Operation containing the classical condition.
+        native_instructions: Instructions to apply the condition to.
+        clbit_to_measure: Maps bits in the classical register to the measurement operation that
+            last wrote something into them.
+
+    """
+    # check that the condition is supported
+    creg, value = operation.condition
+    if isinstance(creg, ClassicalRegister):
+        if len(creg) != 1:
+            raise ValueError(f"{operation.name} is conditioned on multiple bits, this is not supported.")
+        clbit = creg[0]
+    else:
+        clbit = creg  # it is a Clbit
+    if value != 1:
+        raise ValueError(f"{operation.name} is conditioned on integer value {value}, only value 1 is supported.")
+
+    # Set up feedback routing.
+    # The latest "measure" instruction to write to that classical bit is modified, it is
+    # given an explicit feedback_key equal to its measurement key.
+    # The same feedback_key is given to the controlled instruction, along with the feedback qubit.
+    if (measure_inst := clbit_to_measure.get(clbit)) is None:
+        raise ValueError(f"{operation.name} conditioned on {clbit}, which does not contain a measurement result yet.")
+    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.locus[0]  # single-qubit measurement
+
+    for inst in native_instructions:
+        # TODO we do not check anywhere if cc_prx is available for this locus!
+        if inst.name != "prx":
+            raise ValueError(f"This backend only supports conditionals on r, x, y, rx and ry gates, not on {inst.name}")
+        inst.name = "cc_prx"
+        inst.args["feedback_key"] = feedback_key
+        inst.args["feedback_qubit"] = physical_qubit_name
+
+
+def _calculate_ifblock_idx2name_mapping(
+    circuit: QiskitQuantumCircuit,
+    if_block_qubits: list[Qubit],
+    overwrite_layout: Layout | None,
+    qubit_index_to_name: dict[int, str],
+) -> dict[int, str]:
+    """Calculate mapping from if-block qubit registers to physical qubit names.
+
+    The if-block circuit has no qregs of its own, just references to the parent circuit qubits.
+    Depending on how the circuit was transpiled, the if-block Qubit Objects might
+    not be present in the parent Circuit. This method finds the appropriate physical qubits
+    to make a new qubit index to name mapping for it.
+
+    Args:
+        circuit: The parent quantum circuit containing the if-block.
+        if_block_qubits: The qubits used in the if-block.
+        overwrite_layout: An alternative layout indicating the physical qubit mapping to use for the serialized
+            instructions, this overwrites the circuit's layout.
+        qubit_index_to_name: Mapping from qubit indices to the corresponding qubit names as obtained from a backend.
+
+    """
+    # Check if we can use the overwrite layout
+    use_overwrite_layout = overwrite_layout is not None and all(
+        qb in overwrite_layout.get_physical_bits().values() for qb in if_block_qubits
+    )
+    if use_overwrite_layout:
+        physical_qubits = {q: i for i, q in overwrite_layout.get_physical_bits().items()}  # type: ignore[union-attr]
+        return {k: qubit_index_to_name[physical_qubits[q]] for k, q in enumerate(if_block_qubits)}
+    # The if-block qubits are not in the circuit, so we hope they are in the layout
+    use_circuit_layout_guess = circuit.layout is not None and all(
+        qb in circuit.layout.initial_layout.get_physical_bits().values() for qb in if_block_qubits
+    )
+    if use_circuit_layout_guess:
+        physical_qubits = {q: i for i, q in circuit.layout.initial_layout.get_physical_bits().items()}
+        return {k: qubit_index_to_name[physical_qubits[q]] for k, q in enumerate(if_block_qubits)}
+
+    # Hope that we can find the qubits in the circuit - can be wrong.
+    use_circuit_find_bit = all(qb in circuit.qubits for qb in if_block_qubits)
+    if use_circuit_find_bit:
+        return {k: qubit_index_to_name[circuit.find_bit(q).index] for k, q in enumerate(if_block_qubits)}
+    # Catch-all: we cannot determine the mapping, this should never happen.
+    raise ValueError(
+        "Could not determine the physical locations for if-block qubits. "
+        "The if-block uses {if_block_qubits} qubits, but the parent circuit has qubits {circuit.qubits}, "
+        "the circuit layout is {circuit.layout.initial_layout}, and the overwrite layout is {overwrite_layout}."
+    )
+
+
 def serialize_instructions(  # noqa: PLR0912, PLR0915
-    circuit: QiskitQuantumCircuit, qubit_index_to_name: dict[int, str], allowed_nonnative_gates: Collection[str] = ()
+    circuit: QiskitQuantumCircuit,
+    qubit_index_to_name: dict[int, str],
+    allowed_nonnative_gates: Collection[str] = (),
+    *,
+    clbit_to_measure: dict[Clbit, CircuitOperation] | None = None,
+    overwrite_layout: Layout | None = None,
 ) -> list[CircuitOperation]:
     """Serialize a quantum circuit into the IQM data transfer format.
 
@@ -109,9 +211,13 @@ def serialize_instructions(  # noqa: PLR0912, PLR0915
             If such gates are present in the circuit, the caller must edit the result to be valid and executable.
             Notably, since IQM transfer format requires named parameters and qiskit parameters don't have names, the
             `i` th parameter of an unrecognized instruction is given the name ``"p<i>"``.
+        clbit_to_measure: Maps clbits to the latest "measure" instruction to store its result there, or
+            None if nothing has been measured yet.
+        overwrite_layout: A layout indicating the physical qubit mapping to use for the serialized instructions, this
+            overwrites the circuit's layout.
 
     Returns:
-        list of instructions representing the circuit
+        list of IQM instructions representing the circuit
 
     Raises:
         ValueError: circuit contains an unsupported instruction or is not transpiled in general
@@ -119,10 +225,18 @@ def serialize_instructions(  # noqa: PLR0912, PLR0915
     """
     instructions: list[CircuitOperation] = []
     # maps clbits to the latest "measure" instruction to store its result there
-    clbit_to_measure: dict[Clbit, CircuitOperation] = {}
+    if clbit_to_measure is None:
+        clbit_to_measure = {}
+    invalid_layout = circuit.layout is None or circuit.layout.initial_layout.get_registers() != set(circuit.qregs)
     for circuit_instruction in circuit.data:
         instruction = circuit_instruction.operation
-        qubit_names = tuple(qubit_index_to_name[circuit.find_bit(qubit).index] for qubit in circuit_instruction.qubits)
+        if invalid_layout:
+            qubit_names = tuple(
+                qubit_index_to_name[circuit.find_bit(qubit).index] for qubit in circuit_instruction.qubits
+            )
+        else:
+            physical_qubits = {q: i for i, q in circuit.layout.initial_layout.get_physical_bits().items()}
+            qubit_names = tuple(qubit_index_to_name[physical_qubits[qubit]] for qubit in circuit_instruction.qubits)
         if instruction.name == "r":
             angle = float(instruction.params[0])
             phase = float(instruction.params[1])
@@ -178,44 +292,38 @@ def serialize_instructions(  # noqa: PLR0912, PLR0915
         elif instruction.name in allowed_nonnative_gates:
             args = {f"p{i}": param for i, param in enumerate(instruction.params)}
             native_inst = CircuitOperation(name=instruction.name, locus=qubit_names, args=args)
+        elif instruction.name == "if_else":
+            if_block, else_block = instruction.params
+            if else_block is not None and len(else_block) > 0:  # Non-empty circuit in else-block
+                raise ValueError("The use of an else-block with if_test is not supported.")
+            # Recursively serialize the if-block.
+            q_index_to_name = _calculate_ifblock_idx2name_mapping(
+                circuit, if_block.qubits, overwrite_layout, qubit_index_to_name
+            )
+            if_instructions = serialize_instructions(
+                if_block, q_index_to_name, allowed_nonnative_gates, clbit_to_measure=clbit_to_measure
+            )
+            _apply_condition(instruction, if_instructions, clbit_to_measure)
+            instructions.extend(if_instructions)
+            continue  # Skip the rest of the loop, as we already handled the instructions
         else:
             raise ValueError(
                 f"Instruction '{instruction.name}' in the circuit '{circuit.name}' is not natively supported. "
                 f"You need to transpile the circuit before execution."
             )
-
-        # classically controlled gates (using the c_if method)
-        # TODO we do not check anywhere if cc_prx is available for this locus!
-        condition = instruction.condition
-        if condition is not None:
-            if native_inst.name != "prx":
-                raise ValueError(
-                    f"This backend only supports conditionals on r, x, y, rx and ry gates, not on {instruction.name}"
-                )
-            native_inst.name = "cc_prx"
-            creg, value = condition
-            if isinstance(creg, ClassicalRegister):
-                if len(creg) != 1:
-                    raise ValueError(f"{instruction} is conditioned on multiple bits, this is not supported.")
-                if value != 1:
-                    raise ValueError(
-                        f"{instruction} is conditioned on integer value {value}, only value 1 is supported."
+        # classically controlled gates (using the c_if method) need to be updated
+        if (
+            Version(qiskit_version) < Version("2.0.0") and instruction.condition is not None
+        ):  # None means no classical condition
+            if Version(qiskit_version) < Version("1.3.0"):
+                # Avoid double deprecation warnings.
+                warnings.warn(
+                    DeprecationWarning(
+                        "The use of Qiskit's `c_if` method is deprecated and will be removed in a future release"
+                        "of IQM Client. Please use the `with circuit.if_test(...)` construction instead."
                     )
-                clbit = creg[0]
-            else:
-                clbit = creg  # it is a Clbit
-
-            # Set up feedback routing.
-            # The latest "measure" instruction to write to that classical bit is modified, it is
-            # given an explicit feedback_key equal to its measurement key.
-            # The same feedback_key is given to the controlled instruction, along with the feedback qubit.
-            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.locus[0]  # single-qubit measurement
-            native_inst.args["feedback_key"] = feedback_key
-            native_inst.args["feedback_qubit"] = physical_qubit_name
-
+                )
+            _apply_condition(instruction, [native_inst], clbit_to_measure)
         instructions.append(native_inst)
     return instructions
 
@@ -299,7 +407,8 @@ def deserialize_instructions(
             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, phase, locus[0]).c_if(fk_to_clbit[feedback_key], 1)
+            with circuit.if_test((fk_to_clbit[feedback_key], 1)):
+                circuit.r(angle, phase, locus[0])
         elif instr.name == "reset":
             for qubit in locus:
                 circuit.reset(qubit)

iqm/qiskit_iqm/transpiler_plugins.py

@@ -63,15 +63,18 @@ class IQMSchedulingPlugin(PassManagerStagePlugin):
             scheduling.append(
                 IQMOptimizeSingleQubitGates(drop_final_rz=self.drop_final_rz, ignore_barriers=self.ignore_barriers)
             )
-        if pass_manager_config.target is None:
-            raise ValueError("PassManagerConfig must have a target backend set, unable to schedule MoveGate routing.")
-        if self.move_gate_routing and isinstance(pass_manager_config.target, IQMTarget):
-            scheduling.append(
-                IQMNaiveResonatorMoving(
-                    target=pass_manager_config.target,
-                    existing_moves_handling=self.existing_move_handling,
+        if self.move_gate_routing:
+            if pass_manager_config.target is None:
+                raise ValueError(
+                    "PassManagerConfig must have a target backend set, unable to schedule MoveGate routing."
+                )
+            if isinstance(pass_manager_config.target, IQMTarget):
+                scheduling.append(
+                    IQMNaiveResonatorMoving(
+                        target=pass_manager_config.target,
+                        existing_moves_handling=self.existing_move_handling,
+                    )
                 )
-            )
         return scheduling
 
 

{iqm_client-32.0.0.dist-info → iqm_client-33.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: iqm-client
-Version: 32.0.0
+Version: 33.0.0
 Summary: Client library for accessing an IQM quantum computer
 Author-email: IQM Finland Oy <developers@meetiqm.com>
 License: Apache License
@@ -216,35 +216,25 @@ 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 <12,>=11
-Requires-Dist: iqm-exa-common <28,>=27
-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
+Requires-Dist: iqm-pulse
+Requires-Dist: iqm-station-control-client
 Provides-Extra: cirq
-Requires-Dist: iqm-station-control-client <12,>=11 ; extra == 'cirq'
-Requires-Dist: iqm-exa-common <28,>=27 ; 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 <12,>=11 ; extra == 'cli'
-Requires-Dist: iqm-exa-common <28,>=27 ; 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 <12,>=11 ; extra == 'qiskit'
-Requires-Dist: iqm-exa-common <28,>=27 ; extra == 'qiskit'
-Requires-Dist: iqm-pulse <13,>=12 ; extra == 'qiskit'
-Requires-Dist: qiskit <=1.4.2,>=1.0 ; extra == 'qiskit'
+Requires-Dist: qiskit <2.2,>=1.0 ; extra == 'qiskit'
 Requires-Dist: qiskit-aer <0.18,>=0.13.1 ; extra == 'qiskit'
 
 IQM Client

iqm_client-33.0.0.dist-info/RECORD

@@ -0,0 +1,63 @@
+iqm/cirq_iqm/__init__.py,sha256=1zTyxtF39OD11D00ZujgqciJ_9GBDYe-PVBLqZp4NaA,831
+iqm/cirq_iqm/extended_qasm_parser.py,sha256=csDzfHLhy_9maGbappLbnFo2NHQjQeyd-1F8P380Mbk,1917
+iqm/cirq_iqm/iqm_gates.py,sha256=xnZex5ZfNOk_WSsFjVCRybc14FlGNbmwOs3mIfOE_F8,2488
+iqm/cirq_iqm/iqm_sampler.py,sha256=b5CpcD7tgUAWKYdAKcFrshfv1I1GN5eC7mfMyXoGF_8,12606
+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=2w_8sk-X18qWb2FFocBP_MXJALoNmosZIs5Ilp7ueR8,8516
+iqm/cirq_iqm/transpiler.py,sha256=zjJzZb5HyjTfqhL0rMI3dt_3GPGLdVYah9UlGoC8hcc,2173
+iqm/cirq_iqm/devices/__init__.py,sha256=WxbvNAqmeoV4mNy9M9IpjwmyNDpAP7ec1XFdjN7w_YA,840
+iqm/cirq_iqm/devices/adonis.py,sha256=ZWaA4_OfO6fBcrLYHONTjtW8aSlVq2nwy9IiW529gQw,1390
+iqm/cirq_iqm/devices/aphrodite.py,sha256=0K8zRo6gVVadQo7LJfs6laUVLzS3fNkrXMrPlwieyJ8,4018
+iqm/cirq_iqm/devices/apollo.py,sha256=_k7L45zyHZnpdZWMMXO6zci3XY3UEnBj2RmvxM6D7Mg,2238
+iqm/cirq_iqm/devices/iqm_device.py,sha256=CyAP0kU9vfovNWvF4CVX8Wp6_QLxLN8fy9I2YZkHHwM,15425
+iqm/cirq_iqm/devices/iqm_device_metadata.py,sha256=3ONFzPa1G_nE4nSAldsd_Ly8i1__n2Sll43qN9yNQUw,7161
+iqm/cirq_iqm/examples/demo_adonis.py,sha256=rPd8VYqccYijG6t92hfvKsk8RAaMGHOmm4JelYjt3rw,1728
+iqm/cirq_iqm/examples/demo_apollo.py,sha256=vnDwcEXqEyew0cf4SDDQ2budP-giizSNJU3dgOw15H0,1751
+iqm/cirq_iqm/examples/demo_common.py,sha256=k0MAeLDNxZJGv8FNrgMEwaQZsuXeDY5NBM2rLSIQxvU,8745
+iqm/cirq_iqm/examples/demo_iqm_execution.py,sha256=_Wf6rsL_q93M5Ww6eurbXL8VPngGkxtpZBAbNpnn2ek,2440
+iqm/cirq_iqm/examples/usage.ipynb,sha256=Kyfyu_MwqzTavHVNjgrWJo1tZPeJwTw7ExcU0MFYNRk,34208
+iqm/iqm_client/__init__.py,sha256=43TjxuxX_iFl5h2GbQqyIkxmuraWkX4OyvF444Hlyvk,1306
+iqm/iqm_client/errors.py,sha256=weKTljBvDzJxK58NHCXaZXoITVMBvsOkvYP0abs5Dfc,1226
+iqm/iqm_client/iqm_client.py,sha256=OGKp6QDwtIY2RjJ8_uG44UJlMpm7VH_HTgqZFPPN2YA,22632
+iqm/iqm_client/models.py,sha256=UHlkdG0bjaksvyARYB4RZYx1EJ4nLMyHiPS_7-Bwr14,15888
+iqm/iqm_client/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+iqm/iqm_client/transpile.py,sha256=ZicsOJiT5zEaaYMWuFddnJT2e4e9Oyu7B5pO8Z_ah7M,37334
+iqm/iqm_client/util.py,sha256=obzh1g6PNEXOj7k3gUkiylNUhyqutbWlxlEpfyyU_fk,1505
+iqm/iqm_client/validation.py,sha256=SyshUOxmnlwb0haWEAVkgynGOYUMV7Os281sUe29tpE,12621
+iqm/iqm_server_client/__init__.py,sha256=hqfe65DmdYu5qDbYsg3Uq94DRe2zkbMJP_XFYsMbGSQ,645
+iqm/iqm_server_client/errors.py,sha256=I48dRY_Sies2vQzyjzQxhHm_J5RopyL5hqAmlnBy67w,192
+iqm/iqm_server_client/iqm_server_client.py,sha256=en2C4hZ4VzHtg07EtxpuC-cFEw2kzTi1_GzfYKk-NWY,31365
+iqm/iqm_server_client/models.py,sha256=YpyppxEu2obSIaUvuc3_mRKcGscs8YLrcWrTk7EHKzM,5597
+iqm/iqm_server_client/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+iqm/qiskit_iqm/__init__.py,sha256=VPmcMV5nBOEIhVsOceIUkdZtWJ3tGlaKrDFP-FRuOCs,1667
+iqm/qiskit_iqm/iqm_backend.py,sha256=3ydSroylh_Us-5RJfOQgOkL7eqF4fWe5ejXueDTcAj8,5584
+iqm/qiskit_iqm/iqm_circuit.py,sha256=jaPo3zc5FC0vAIumh5d56fr44fDaJXXwcquBzQEy1Yg,1400
+iqm/qiskit_iqm/iqm_circuit_validation.py,sha256=SzfCJclUh1kK6Kcz5puKlCtE0hZfWxYYKF35EagU204,1750
+iqm/qiskit_iqm/iqm_job.py,sha256=SdyZeQi5CoGxBeJyfIvOM7DA0ONJ5tbTHpk4hajpUFk,12395
+iqm/qiskit_iqm/iqm_move_layout.py,sha256=vFdba0DStu8Pebi3qxZBYOLCYC2Atl28YlSzbSGER4Y,10557
+iqm/qiskit_iqm/iqm_naive_move_pass.py,sha256=GcS2DyYWwG-qMyczXqTXxMxNqRB4IVeWNP3CzguKpBw,15639
+iqm/qiskit_iqm/iqm_provider.py,sha256=pK1CcAOQKG5jXYfjxshuVSmMLWQG1-k0cyghRmGpWN8,19273
+iqm/qiskit_iqm/iqm_target.py,sha256=nqurRgM_p2nOw8ty8ncw38vSErEdXpHSlbp7Rpavnc4,16232
+iqm/qiskit_iqm/iqm_transpilation.py,sha256=RccAHY7lNXvg7TWKG7fBNBCgFu5Xd9B_J9V9uKLlmuY,18336
+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=imMmuOi_tuujIrGzBFnGOtxpGHcIkncXutr5QFekJl4,20677
+iqm/qiskit_iqm/transpiler_plugins.py,sha256=BrCkUFQUdi0m8K8V0ERYgtPAkvoX4VlYIJwnFKyCN9Q,8831
+iqm/qiskit_iqm/examples/__init__.py,sha256=M4ElQHCo-WxtVXK39bF3QiFT3IGXPtZ1khqexHiTBEc,20
+iqm/qiskit_iqm/examples/bell_measure.py,sha256=-20oihBKuK4s9rA_9fuyJBM3Du8NWZUTZ8YhI3Q4TpM,3064
+iqm/qiskit_iqm/examples/transpile_example.py,sha256=vGcs2OpsYTVcWyX-qzmfjio4JcIBi_Dk-hrQRGO4oGs,2401
+iqm/qiskit_iqm/fake_backends/__init__.py,sha256=fkw2UHT-3aJbAKvR1WYUN7_4N5Gdwpx9bm6vlWj1tm0,874
+iqm/qiskit_iqm/fake_backends/fake_adonis.py,sha256=DWftCPu6ElE4P47Z-y3bojg0unDJ6F5ur2aDqfoY85s,2248
+iqm/qiskit_iqm/fake_backends/fake_aphrodite.py,sha256=oB5wFtZ2VYy0TxoL-eBgYnVAwamGPYlzIQK89npwQUg,15533
+iqm/qiskit_iqm/fake_backends/fake_apollo.py,sha256=C05u3knnCsA8DCuWU31EwUvJ6xilef36J06GoE2vAe4,6623
+iqm/qiskit_iqm/fake_backends/fake_deneb.py,sha256=HstlV-PSbyCttY1uEyWr-YgsMNkv9Ntf6zffav837_4,3216
+iqm/qiskit_iqm/fake_backends/fake_garnet.py,sha256=GI0xafTCj1Um09qVuccO6GPOGBm6ygul_O40Wu220Ys,5555
+iqm/qiskit_iqm/fake_backends/iqm_fake_backend.py,sha256=IfVKxlPlAVCHTgli2scRP1gkVCXIiSuL6-QjjsZp83Q,16808
+iqm_client-33.0.0.dist-info/AUTHORS.rst,sha256=qsxeK5A3-B_xK3hNbhFHEIkoHNpo7sdzYyRTs7Bdtm8,795
+iqm_client-33.0.0.dist-info/LICENSE.txt,sha256=2DXrmQtVVUV9Fc9RBFJidMiTEaQlG2oAtlC9PMrEwTk,11333
+iqm_client-33.0.0.dist-info/METADATA,sha256=7caTuL76eOR8Gh87dPMW9WpRecywAmFiss3E6T8Pe9Q,17290
+iqm_client-33.0.0.dist-info/WHEEL,sha256=y4mX-SOX4fYIkonsAGA5N0Oy-8_gI4FXw5HNI1xqvWg,91
+iqm_client-33.0.0.dist-info/entry_points.txt,sha256=Kk2qfRwk8vbIJ7qCAvmaUogfRRn6t92_hBFhe6kqAE4,1317
+iqm_client-33.0.0.dist-info/top_level.txt,sha256=NB4XRfyDS6_wG9gMsyX-9LTU7kWnTQxNvkbzIxGv3-c,4
+iqm_client-33.0.0.dist-info/RECORD,,

iqm/iqm_client/api.py

@@ -1,90 +0,0 @@
-# Copyright 2024 IQM client developers
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""This module contains definitions of IQM Server API endpoints."""
-
-from enum import Enum, auto
-from posixpath import join
-
-
-class APIEndpoint(Enum):
-    """Supported API endpoints."""
-
-    GET_JOB_RESULT = auto()
-    GET_JOB_REQUEST_PARAMETERS = auto()
-    GET_JOB_CALIBRATION_SET_ID = auto()
-    GET_JOB_CIRCUITS_BATCH = auto()
-    GET_JOB_ERROR_LOG = auto()
-    SUBMIT_JOB = auto()
-    GET_JOB_COUNTS = auto()
-    GET_JOB_STATUS = auto()
-    GET_JOB_TIMELINE = auto()
-    ABORT_JOB = auto()
-
-
-class APIConfig:
-    """Provides supported API endpoints for a given API variant."""
-
-    def __init__(self, station_control_url: str):
-        """Args:
-        station_control_url: URL of the IQM server,
-            e.g. https://test.qc.iqm.fi/station or https://cocos.resonance.meetiqm.com/garnet
-
-        """
-        self.station_control_url = station_control_url
-        self.urls = self._get_api_urls()
-
-    @staticmethod
-    def _get_api_urls() -> dict[APIEndpoint, str]:
-        """Returns:
-        Relative URLs for each supported API endpoints.
-
-        """
-        return {
-            # TODO SW-1434: Use StationControlClient methods for communication instead of REST endpoints
-            APIEndpoint.GET_JOB_RESULT: "jobs/%s/measurements",
-            APIEndpoint.GET_JOB_REQUEST_PARAMETERS: "jobs/%s/request_parameters",
-            APIEndpoint.GET_JOB_CALIBRATION_SET_ID: "jobs/%s/calibration_set_id",
-            APIEndpoint.GET_JOB_CIRCUITS_BATCH: "jobs/%s/circuits_batch",
-            APIEndpoint.GET_JOB_ERROR_LOG: "jobs/%s/error_log",
-            APIEndpoint.SUBMIT_JOB: "circuits",
-            APIEndpoint.GET_JOB_COUNTS: "circuits/%s/counts",
-            APIEndpoint.GET_JOB_STATUS: "jobs/%s/status",
-            APIEndpoint.GET_JOB_TIMELINE: "jobs/%s/timeline",
-            APIEndpoint.ABORT_JOB: "jobs/%s/abort",
-        }
-
-    def is_supported(self, endpoint: APIEndpoint) -> bool:
-        """Args:
-            endpoint: API endpoint.
-
-        Returns:
-            True if the endpoint is supported, False otherwise.
-
-        """
-        return endpoint in self.urls
-
-    def url(self, endpoint: APIEndpoint, *args) -> str:
-        """Args:
-            endpoint: API endpoint.
-            args: Arguments to be passed to the URL.
-
-        Returns:
-            URL for the given endpoint.
-
-        Raises:
-            ValueError: If the endpoint is not supported.
-
-        """
-        url = self.urls.get(endpoint, "")
-        return join(self.station_control_url, url % args)