Merge branch 'MarkerPulse-Qblox-backend' into 'main'

- Gettables - When `ScheduleGettable.get()` is called and the associated `InstrumentCoordinator` returns nothing (for example, if the hardware configuration was never set), this will no longer raise a KeyError from the xarray module. Instead, a more helpful error is raised before the data processing (!671).

- Qblox backend - Raise RuntimeWarning instead of NotImplementedError upon using `reference_magnitude` parameter (introduced in !652) (!684)

- Qblox backend - Compilation uses `math.isclose` instead of `numpy.isclose` in certain cases to improve compile time (!682)

- Qblox backend - Add `MarkerPulse` to pulse library, and implement Qblox backend compilation for this pulse (!628)

## 0.13.0 (2023-05-05)

},

```

### Digital mode

The markers can be controlled by defining a digital I/O, and adding a `MarkerPulse` on this I/O.

A digital I/O is defined by adding a `"digital_output_n"` to the module configuration. `n` is the number of the digital output port.

For a digital I/O only a port is required, no clocks or other parameters are needed.

```{code-block} python

"qcm0": {

    "instrument_type": "QCM",

    "ref": "internal",

    "digital_output_0": {

        "portclock_configs": [

            {

                "port": "q0:switch",

            },

        ],   

    },

},

```

The `MarkerPulse` is defined by adding a `MarkerPulse` to the sequence in question. It takes the same parameters as any other pulse.

```{code-block} python

schedule.add(MarkerPulse(duration=52e-9, port="q0:switch"))

```

### Marker configuration

The markers can be configured by adding a `"marker_debug_mode_enable"` key to I/O configurations. If the value is set to True, the operations defined for this I/O will be accompanied by a 4 ns trigger pulse on the marker located next to the I/O port.

        operation_info = operation["pulse_info"] + operation["acquisition_info"]

        clocks_used = set([info["clock"] for info in operation_info])

        for clock in clocks_used:

            # In digital IO's clocks are non-existant, so we skip them.

            if clock == "digital":

                continue

            if clock in verified_clocks:

                continue

            # raises ValueError if no clock found;

            # enters if condition if clock only in device config

            if not _valid_clock_in_schedule(clock, device_cfg, schedule, operation):

from quantify_scheduler.backends.qblox import (

    constants,

    driver_version_check,

    enums,

    helpers,

    instrument_compilers,

    q1asm_instructions,

        static_hw_properties: StaticHardwareProperties,

        connected_outputs: Optional[Union[Tuple[int], Tuple[int, int]]],

        connected_inputs: Optional[Union[Tuple[int], Tuple[int, int]]],

        io_mode: enums.IoMode,

        seq_settings: Dict[str, Any],

        latency_corrections: Dict[str, float],

        lo_name: Optional[str] = None,

            connected_inputs=connected_inputs,

        )

        self._io_mode = io_mode

        self.qasm_hook_func: Optional[Callable] = seq_settings.get(

            "qasm_hook_func", None

        )

        return self._settings.connected_inputs

    @property

    def io_mode(self) -> Literal["complex", "real", "imag"]:

    def io_mode(self) -> enums.IoMode:

        """

        Specifies whether the sequencer is using only path0 (real), path1 (imag) or

        both (complex).

        Return :class:`~.enums.IoMode` used by this sequencer.

        If real or imag, the sequencer is restricted to only using real valued data.

        If complex, the sequencer may also use complex data.

        If digital, the sequencer is restricted to only producing MarkerPulses.

        """

        if self._settings.connected_outputs is not None:

            return helpers.io_mode_from_ios(self._settings.connected_outputs)

        else:

            return helpers.io_mode_from_ios(self._settings.connected_inputs)

        return self._io_mode

    @property

    def portclock(self) -> Tuple[str, str]:

        qasm = QASMProgram(self.static_hw_properties, self.register_manager)

        qasm.set_marker(self.default_marker)

        qasm.emit(q1asm_instructions.UPDATE_PARAMETERS, constants.GRID_TIME)

        # program header

        qasm.emit(q1asm_instructions.WAIT_SYNC, constants.GRID_TIME)

        qasm.emit(q1asm_instructions.UPDATE_PARAMETERS, constants.GRID_TIME)

                portclock = (target["port"], target["clock"])

                if portclock in self._portclocks_with_data:

                    connected_outputs = helpers.output_name_to_outputs(io)

                    connected_inputs = helpers.input_name_to_inputs(io)

                    io_mode, connected_outputs, connected_inputs = helpers.get_io_info(

                        io

                    )

                    seq_idx = len(sequencers)

                    new_seq = Sequencer(

                        parent=self,

                        static_hw_properties=self.static_hw_properties,

                        connected_outputs=connected_outputs,

                        connected_inputs=connected_inputs,

                        io_mode=io_mode,

                        seq_settings=target,

                        latency_corrections=self.latency_corrections,

                        lo_name=lo_name,

                        seq.pulses = []

                    for pulse_strategy in strategies_for_pulses:

                        if seq.io_mode == enums.IoMode.DIGITAL:

                            # Digital mode always has one output.

                            pulse_strategy.operation_info.data[

                                "output"

                            ] = seq.connected_outputs[0]

                        seq.pulses.append(pulse_strategy)

        acq_data_list: List[OpInfo]

# Repository: https://gitlab.com/quantify-os/quantify-scheduler

# Licensed according to the LICENCE file on the main branch

"""Enums used by Qblox backend."""

from enum import Enum

class IoMode(str, Enum):

    """Enum for the IO mode of the Sequencer."""

    COMPLEX = "complex"

    REAL = "real"

    IMAG = "imag"

    DIGITAL = "digital"