qiskit 1.4.2__cp39-abi3-win_amd64.whl → 2.0.0rc2__cp39-abi3-win_amd64.whl

qiskit/providers/fake_provider/fake_openpulse_3q.py

@@ -1,340 +0,0 @@
-# This code is part of Qiskit.
-#
-# (C) Copyright IBM 2019.
-#
-# 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.
-
-"""
-Fake backend supporting OpenPulse.
-"""
-import warnings
-
-from qiskit.providers.models.backendconfiguration import (
-    GateConfig,
-    PulseBackendConfiguration,
-    UchannelLO,
-)
-from qiskit.providers.models.pulsedefaults import PulseDefaults, Command
-from qiskit.qobj import PulseQobjInstruction
-
-from .fake_backend import FakeBackend
-
-
-class FakeOpenPulse3Q(FakeBackend):
-    """Trivial extension of the FakeOpenPulse2Q."""
-
-    def __init__(self):
-        configuration = PulseBackendConfiguration(
-            backend_name="fake_openpulse_3q",
-            backend_version="0.0.0",
-            n_qubits=3,
-            meas_levels=[0, 1, 2],
-            basis_gates=["u1", "u2", "u3", "cx", "id"],
-            simulator=False,
-            local=True,
-            conditional=True,
-            open_pulse=True,
-            memory=False,
-            max_shots=65536,
-            gates=[GateConfig(name="TODO", parameters=[], qasm_def="TODO")],
-            coupling_map=[[0, 1], [1, 2]],
-            n_registers=3,
-            n_uchannels=3,
-            u_channel_lo=[
-                [UchannelLO(q=0, scale=1.0 + 0.0j)],
-                [UchannelLO(q=0, scale=-1.0 + 0.0j), UchannelLO(q=1, scale=1.0 + 0.0j)],
-                [UchannelLO(q=0, scale=1.0 + 0.0j)],
-            ],
-            qubit_lo_range=[[4.5, 5.5], [4.5, 5.5], [4.5, 5.5]],
-            meas_lo_range=[[6.0, 7.0], [6.0, 7.0], [6.0, 7.0]],
-            dt=1.3333,
-            dtm=10.5,
-            rep_times=[100, 250, 500, 1000],
-            meas_map=[[0, 1, 2]],
-            channel_bandwidth=[
-                [-0.2, 0.4],
-                [-0.3, 0.3],
-                [-0.3, 0.3],
-                [-0.02, 0.02],
-                [-0.02, 0.02],
-                [-0.02, 0.02],
-                [-0.2, 0.4],
-                [-0.3, 0.3],
-                [-0.3, 0.3],
-            ],
-            meas_kernels=["kernel1"],
-            discriminators=["max_1Q_fidelity"],
-            acquisition_latency=[[100, 100], [100, 100], [100, 100]],
-            conditional_latency=[
-                [100, 1000],
-                [1000, 100],
-                [100, 1000],
-                [100, 1000],
-                [1000, 100],
-                [100, 1000],
-                [1000, 100],
-                [100, 1000],
-                [1000, 100],
-            ],
-            channels={
-                "acquire0": {"type": "acquire", "purpose": "acquire", "operates": {"qubits": [0]}},
-                "acquire1": {"type": "acquire", "purpose": "acquire", "operates": {"qubits": [1]}},
-                "acquire2": {"type": "acquire", "purpose": "acquire", "operates": {"qubits": [2]}},
-                "d0": {"type": "drive", "purpose": "drive", "operates": {"qubits": [0]}},
-                "d1": {"type": "drive", "purpose": "drive", "operates": {"qubits": [1]}},
-                "d2": {"type": "drive", "purpose": "drive", "operates": {"qubits": [2]}},
-                "m0": {"type": "measure", "purpose": "measure", "operates": {"qubits": [0]}},
-                "m1": {"type": "measure", "purpose": "measure", "operates": {"qubits": [1]}},
-                "m2": {"type": "measure", "purpose": "measure", "operates": {"qubits": [2]}},
-                "u0": {
-                    "type": "control",
-                    "purpose": "cross-resonance",
-                    "operates": {"qubits": [0, 1]},
-                },
-                "u1": {
-                    "type": "control",
-                    "purpose": "cross-resonance",
-                    "operates": {"qubits": [1, 0]},
-                },
-                "u2": {
-                    "type": "control",
-                    "purpose": "cross-resonance",
-                    "operates": {"qubits": [2, 1]},
-                },
-            },
-        )
-        with warnings.catch_warnings():
-            # The class PulseQobjInstruction is deprecated
-            warnings.filterwarnings("ignore", category=DeprecationWarning, module="qiskit")
-            self._defaults = PulseDefaults.from_dict(
-                {
-                    "qubit_freq_est": [4.9, 5.0, 4.8],
-                    "meas_freq_est": [6.5, 6.6, 6.4],
-                    "buffer": 10,
-                    "pulse_library": [
-                        {"name": "x90p_d0", "samples": 2 * [0.1 + 0j]},
-                        {"name": "x90p_d1", "samples": 2 * [0.1 + 0j]},
-                        {"name": "x90p_d2", "samples": 2 * [0.1 + 0j]},
-                        {"name": "x90m_d0", "samples": 2 * [-0.1 + 0j]},
-                        {"name": "x90m_d1", "samples": 2 * [-0.1 + 0j]},
-                        {"name": "x90m_d2", "samples": 2 * [-0.1 + 0j]},
-                        {"name": "y90p_d0", "samples": 2 * [0.1j]},
-                        {"name": "y90p_d1", "samples": 2 * [0.1j]},
-                        {"name": "y90p_d2", "samples": 2 * [0.1j]},
-                        {"name": "xp_d0", "samples": 2 * [0.2 + 0j]},
-                        {"name": "ym_d0", "samples": 2 * [-0.2j]},
-                        {"name": "xp_d1", "samples": 2 * [0.2 + 0j]},
-                        {"name": "ym_d1", "samples": 2 * [-0.2j]},
-                        {"name": "cr90p_u0", "samples": 9 * [0.1 + 0j]},
-                        {"name": "cr90m_u0", "samples": 9 * [-0.1 + 0j]},
-                        {"name": "cr90p_u1", "samples": 9 * [0.1 + 0j]},
-                        {"name": "cr90m_u1", "samples": 9 * [-0.1 + 0j]},
-                        {"name": "measure_m0", "samples": 10 * [0.1 + 0j]},
-                        {"name": "measure_m1", "samples": 10 * [0.1 + 0j]},
-                        {"name": "measure_m2", "samples": 10 * [0.1 + 0j]},
-                    ],
-                    "cmd_def": [
-                        Command.from_dict(
-                            {
-                                "name": "u1",
-                                "qubits": [0],
-                                "sequence": [
-                                    PulseQobjInstruction(
-                                        name="fc", ch="d0", t0=0, phase="-P0"
-                                    ).to_dict()
-                                ],
-                            }
-                        ).to_dict(),
-                        Command.from_dict(
-                            {
-                                "name": "u1",
-                                "qubits": [1],
-                                "sequence": [
-                                    PulseQobjInstruction(
-                                        name="fc", ch="d1", t0=0, phase="-P0"
-                                    ).to_dict()
-                                ],
-                            }
-                        ).to_dict(),
-                        Command.from_dict(
-                            {
-                                "name": "u1",
-                                "qubits": [2],
-                                "sequence": [
-                                    PulseQobjInstruction(
-                                        name="fc", ch="d2", t0=0, phase="-P0"
-                                    ).to_dict()
-                                ],
-                            }
-                        ).to_dict(),
-                        Command.from_dict(
-                            {
-                                "name": "u2",
-                                "qubits": [0],
-                                "sequence": [
-                                    PulseQobjInstruction(
-                                        name="fc", ch="d0", t0=0, phase="-P1"
-                                    ).to_dict(),
-                                    PulseQobjInstruction(name="y90p_d0", ch="d0", t0=0).to_dict(),
-                                    PulseQobjInstruction(
-                                        name="fc", ch="d0", t0=2, phase="-P0"
-                                    ).to_dict(),
-                                ],
-                            }
-                        ).to_dict(),
-                        Command.from_dict(
-                            {
-                                "name": "u2",
-                                "qubits": [1],
-                                "sequence": [
-                                    PulseQobjInstruction(
-                                        name="fc", ch="d1", t0=0, phase="-P1"
-                                    ).to_dict(),
-                                    PulseQobjInstruction(name="y90p_d1", ch="d1", t0=0).to_dict(),
-                                    PulseQobjInstruction(
-                                        name="fc", ch="d1", t0=2, phase="-P0"
-                                    ).to_dict(),
-                                ],
-                            }
-                        ).to_dict(),
-                        Command.from_dict(
-                            {
-                                "name": "u2",
-                                "qubits": [2],
-                                "sequence": [
-                                    PulseQobjInstruction(
-                                        name="fc", ch="d2", t0=0, phase="-P1"
-                                    ).to_dict(),
-                                    PulseQobjInstruction(name="y90p_d2", ch="d2", t0=0).to_dict(),
-                                    PulseQobjInstruction(
-                                        name="fc", ch="d2", t0=2, phase="-P0"
-                                    ).to_dict(),
-                                ],
-                            }
-                        ).to_dict(),
-                        Command.from_dict(
-                            {
-                                "name": "u3",
-                                "qubits": [0],
-                                "sequence": [
-                                    PulseQobjInstruction(
-                                        name="fc", ch="d0", t0=0, phase="-P2"
-                                    ).to_dict(),
-                                    PulseQobjInstruction(name="x90p_d0", ch="d0", t0=0).to_dict(),
-                                    PulseQobjInstruction(
-                                        name="fc", ch="d0", t0=2, phase="-P0"
-                                    ).to_dict(),
-                                    PulseQobjInstruction(name="x90m_d0", ch="d0", t0=2).to_dict(),
-                                    PulseQobjInstruction(
-                                        name="fc", ch="d0", t0=4, phase="-P1"
-                                    ).to_dict(),
-                                ],
-                            }
-                        ).to_dict(),
-                        Command.from_dict(
-                            {
-                                "name": "u3",
-                                "qubits": [1],
-                                "sequence": [
-                                    PulseQobjInstruction(
-                                        name="fc", ch="d1", t0=0, phase="-P2"
-                                    ).to_dict(),
-                                    PulseQobjInstruction(name="x90p_d1", ch="d1", t0=0).to_dict(),
-                                    PulseQobjInstruction(
-                                        name="fc", ch="d1", t0=2, phase="-P0"
-                                    ).to_dict(),
-                                    PulseQobjInstruction(name="x90m_d1", ch="d1", t0=2).to_dict(),
-                                    PulseQobjInstruction(
-                                        name="fc", ch="d1", t0=4, phase="-P1"
-                                    ).to_dict(),
-                                ],
-                            }
-                        ).to_dict(),
-                        Command.from_dict(
-                            {
-                                "name": "u3",
-                                "qubits": [2],
-                                "sequence": [
-                                    PulseQobjInstruction(
-                                        name="fc", ch="d2", t0=0, phase="-P2"
-                                    ).to_dict(),
-                                    PulseQobjInstruction(name="x90p_d2", ch="d2", t0=0).to_dict(),
-                                    PulseQobjInstruction(
-                                        name="fc", ch="d2", t0=2, phase="-P0"
-                                    ).to_dict(),
-                                    PulseQobjInstruction(name="x90m_d2", ch="d2", t0=2).to_dict(),
-                                    PulseQobjInstruction(
-                                        name="fc", ch="d2", t0=4, phase="-P1"
-                                    ).to_dict(),
-                                ],
-                            }
-                        ).to_dict(),
-                        Command.from_dict(
-                            {
-                                "name": "cx",
-                                "qubits": [0, 1],
-                                "sequence": [
-                                    PulseQobjInstruction(
-                                        name="fc", ch="d0", t0=0, phase=1.57
-                                    ).to_dict(),
-                                    PulseQobjInstruction(name="ym_d0", ch="d0", t0=0).to_dict(),
-                                    PulseQobjInstruction(name="xp_d0", ch="d0", t0=11).to_dict(),
-                                    PulseQobjInstruction(name="x90p_d1", ch="d1", t0=0).to_dict(),
-                                    PulseQobjInstruction(name="cr90p_u0", ch="u0", t0=2).to_dict(),
-                                    PulseQobjInstruction(name="cr90m_u0", ch="u0", t0=13).to_dict(),
-                                ],
-                            }
-                        ).to_dict(),
-                        Command.from_dict(
-                            {
-                                "name": "cx",
-                                "qubits": [1, 2],
-                                "sequence": [
-                                    PulseQobjInstruction(
-                                        name="fc", ch="d1", t0=0, phase=1.57
-                                    ).to_dict(),
-                                    PulseQobjInstruction(name="ym_d1", ch="d1", t0=0).to_dict(),
-                                    PulseQobjInstruction(name="xp_d1", ch="d1", t0=11).to_dict(),
-                                    PulseQobjInstruction(name="x90p_d2", ch="d2", t0=0).to_dict(),
-                                    PulseQobjInstruction(name="cr90p_u1", ch="u1", t0=2).to_dict(),
-                                    PulseQobjInstruction(name="cr90m_u1", ch="u1", t0=13).to_dict(),
-                                ],
-                            }
-                        ).to_dict(),
-                        Command.from_dict(
-                            {
-                                "name": "measure",
-                                "qubits": [0, 1, 2],
-                                "sequence": [
-                                    PulseQobjInstruction(
-                                        name="measure_m0", ch="m0", t0=0
-                                    ).to_dict(),
-                                    PulseQobjInstruction(
-                                        name="measure_m1", ch="m1", t0=0
-                                    ).to_dict(),
-                                    PulseQobjInstruction(
-                                        name="measure_m2", ch="m2", t0=0
-                                    ).to_dict(),
-                                    PulseQobjInstruction(
-                                        name="acquire",
-                                        duration=10,
-                                        t0=0,
-                                        qubits=[0, 1, 2],
-                                        memory_slot=[0, 1, 2],
-                                    ).to_dict(),
-                                ],
-                            }
-                        ).to_dict(),
-                    ],
-                }
-            )
-        super().__init__(configuration)
-
-    def defaults(self):  # pylint: disable=missing-function-docstring
-        return self._defaults

qiskit/providers/fake_provider/fake_pulse_backend.py

@@ -1,49 +0,0 @@
-# This code is part of Qiskit.
-#
-# (C) Copyright IBM 2020.
-#
-# 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.
-
-"""
-Fake backend abstract class for mock backends supporting OpenPulse.
-"""
-
-import warnings
-
-from qiskit.exceptions import QiskitError
-from qiskit.providers.models.backendconfiguration import PulseBackendConfiguration
-from qiskit.providers.models.pulsedefaults import PulseDefaults
-
-from .fake_qasm_backend import FakeQasmBackend
-from .utils.json_decoder import decode_pulse_defaults
-
-
-class FakePulseBackend(FakeQasmBackend):
-    """A fake pulse backend."""
-
-    defs_filename = None
-
-    def defaults(self):
-        """Returns a snapshot of device defaults"""
-        if not self._defaults:
-            with warnings.catch_warnings():
-                warnings.simplefilter(action="ignore", category=DeprecationWarning)
-                # Filter deprecation warnings emitted from Qiskit Pulse
-                self._set_defaults_from_json()
-        return self._defaults
-
-    def _set_defaults_from_json(self):
-        if not self.props_filename:
-            raise QiskitError("No properties file has been defined")
-        defs = self._load_json(self.defs_filename)
-        decode_pulse_defaults(defs)
-        self._defaults = PulseDefaults.from_dict(defs)
-
-    def _get_config_from_dict(self, conf):
-        return PulseBackendConfiguration.from_dict(conf)

qiskit/providers/fake_provider/fake_qasm_backend.py

@@ -1,77 +0,0 @@
-# This code is part of Qiskit.
-#
-# (C) Copyright IBM 2020.
-#
-# 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.
-
-"""
-Fake backend abstract class for mock backends.
-"""
-
-import json
-import os
-import warnings
-
-from qiskit.exceptions import QiskitError
-from qiskit.providers.models.backendproperties import BackendProperties
-from qiskit.providers.models.backendconfiguration import QasmBackendConfiguration
-
-from .utils.json_decoder import (
-    decode_backend_configuration,
-    decode_backend_properties,
-)
-from .fake_backend import FakeBackend
-
-
-class FakeQasmBackend(FakeBackend):
-    """A fake OpenQASM backend."""
-
-    dirname = None
-    conf_filename = None
-    props_filename = None
-    backend_name = None
-
-    def __init__(self):
-        configuration = self._get_conf_from_json()
-        self._defaults = None
-        self._properties = None
-        super().__init__(configuration)
-
-    def properties(self):
-        """Returns a snapshot of device properties"""
-        if not self._properties:
-            self._set_props_from_json()
-        return self._properties
-
-    def _get_conf_from_json(self):
-        if not self.conf_filename:
-            raise QiskitError("No configuration file has been defined")
-        conf = self._load_json(self.conf_filename)
-        decode_backend_configuration(conf)
-        configuration = self._get_config_from_dict(conf)
-        configuration.backend_name = self.backend_name
-        return configuration
-
-    def _set_props_from_json(self):
-        if not self.props_filename:
-            raise QiskitError("No properties file has been defined")
-        props = self._load_json(self.props_filename)
-        decode_backend_properties(props)
-        with warnings.catch_warnings():
-            # This raises the BackendProperties deprecation warning internally
-            warnings.filterwarnings("ignore", category=DeprecationWarning, module="qiskit")
-            self._properties = BackendProperties.from_dict(props)
-
-    def _load_json(self, filename):
-        with open(os.path.join(self.dirname, filename)) as f_json:
-            the_json = json.load(f_json)
-        return the_json
-
-    def _get_config_from_dict(self, conf):
-        return QasmBackendConfiguration.from_dict(conf)

qiskit/providers/fake_provider/utils/backend_converter.py

@@ -1,150 +0,0 @@
-# This code is part of Qiskit.
-#
-# (C) Copyright IBM 2022.
-#
-# 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.
-
-"""
-Utilities for constructing Target object from configuration, properties and
-pulse defaults json files
-"""
-
-from qiskit.transpiler.target import Target, InstructionProperties
-from qiskit.providers.backend import QubitProperties
-from qiskit.utils.units import apply_prefix
-from qiskit.circuit.library.standard_gates import IGate, SXGate, XGate, CXGate, RZGate
-from qiskit.circuit.parameter import Parameter
-from qiskit.circuit.gate import Gate
-from qiskit.circuit.delay import Delay
-from qiskit.circuit.measure import Measure
-from qiskit.circuit.reset import Reset
-from qiskit.providers.models.pulsedefaults import PulseDefaults
-
-
-def convert_to_target(conf_dict: dict, props_dict: dict = None, defs_dict: dict = None) -> Target:
-    """Uses configuration, properties and pulse defaults dicts
-    to construct and return Target class.
-    """
-    name_mapping = {
-        "id": IGate(),
-        "sx": SXGate(),
-        "x": XGate(),
-        "cx": CXGate(),
-        "rz": RZGate(Parameter("λ")),
-        "reset": Reset(),
-    }
-    custom_gates = {}
-    qubit_props = None
-    if props_dict:
-        qubit_props = qubit_props_from_props(props_dict)
-    target = Target(qubit_properties=qubit_props, concurrent_measurements=conf_dict.get("meas_map"))
-    # Parse from properties if it exsits
-    if props_dict is not None:
-        # Parse instructions
-        gates = {}
-        for gate in props_dict["gates"]:
-            name = gate["gate"]
-            if name in name_mapping:
-                if name not in gates:
-                    gates[name] = {}
-            elif name not in custom_gates:
-                custom_gate = Gate(name, len(gate["qubits"]), [])
-                custom_gates[name] = custom_gate
-                gates[name] = {}
-
-            qubits = tuple(gate["qubits"])
-            gate_props = {}
-            for param in gate["parameters"]:
-                if param["name"] == "gate_error":
-                    gate_props["error"] = param["value"]
-                if param["name"] == "gate_length":
-                    gate_props["duration"] = apply_prefix(param["value"], param["unit"])
-            gates[name][qubits] = InstructionProperties(**gate_props)
-        for gate, props in gates.items():
-            if gate in name_mapping:
-                inst = name_mapping.get(gate)
-            else:
-                inst = custom_gates[gate]
-            target.add_instruction(inst, props)
-        # Create measurement instructions:
-        measure_props = {}
-        count = 0
-        for qubit in props_dict["qubits"]:
-            qubit_prop = {}
-            for prop in qubit:
-                if prop["name"] == "readout_length":
-                    qubit_prop["duration"] = apply_prefix(prop["value"], prop["unit"])
-                if prop["name"] == "readout_error":
-                    qubit_prop["error"] = prop["value"]
-            measure_props[(count,)] = InstructionProperties(**qubit_prop)
-            count += 1
-        target.add_instruction(Measure(), measure_props)
-    # Parse from configuration because properties doesn't exist
-    else:
-        for gate in conf_dict["gates"]:
-            name = gate["name"]
-            gate_props = {tuple(x): None for x in gate["coupling_map"]}
-            if name in name_mapping:
-                target.add_instruction(name_mapping[name], gate_props)
-            else:
-                custom_gate = Gate(name, len(gate["coupling_map"][0]), [])
-                target.add_instruction(custom_gate, gate_props)
-        measure_props = {(n,): None for n in range(conf_dict["n_qubits"])}
-        target.add_instruction(Measure(), measure_props)
-    # parse global configuration properties
-    dt = conf_dict.get("dt")
-    if dt:
-        target.dt = dt * 1e-9
-    if "timing_constraints" in conf_dict:
-        target.granularity = conf_dict["timing_constraints"].get("granularity")
-        target.min_length = conf_dict["timing_constraints"].get("min_length")
-        target.pulse_alignment = conf_dict["timing_constraints"].get("pulse_alignment")
-        target.acquire_alignment = conf_dict["timing_constraints"].get("acquire_alignment")
-    # If pulse defaults exists use that as the source of truth
-    if defs_dict is not None:
-        # TODO remove the usage of PulseDefaults as it will be deprecated in the future
-        pulse_defs = PulseDefaults.from_dict(defs_dict)
-        inst_map = pulse_defs.instruction_schedule_map
-        for inst in inst_map.instructions:
-            for qarg in inst_map.qubits_with_instruction(inst):
-                try:
-                    qargs = tuple(qarg)
-                except TypeError:
-                    qargs = (qarg,)
-                # Do NOT call .get method. This parses Qpbj immediately.
-                # This operation is computationally expensive and should be bypassed.
-                calibration_entry = inst_map._get_calibration_entry(inst, qargs)
-                if inst in target:
-                    if inst == "measure":
-                        for qubit in qargs:
-                            target[inst][(qubit,)].calibration = calibration_entry
-                    elif qargs in target[inst]:
-                        target[inst][qargs].calibration = calibration_entry
-    target.add_instruction(
-        Delay(Parameter("t")), {(bit,): None for bit in range(target.num_qubits)}
-    )
-    return target
-
-
-def qubit_props_from_props(properties: dict) -> list:
-    """Returns a dictionary of `qiskit.providers.backend.QubitProperties` using
-    a backend properties dictionary created by loading props.json payload.
-    """
-    qubit_props = []
-    for qubit in properties["qubits"]:
-        qubit_properties = {}
-        for prop_dict in qubit:
-            if prop_dict["name"] == "T1":
-                qubit_properties["t1"] = apply_prefix(prop_dict["value"], prop_dict["unit"])
-            elif prop_dict["name"] == "T2":
-                qubit_properties["t2"] = apply_prefix(prop_dict["value"], prop_dict["unit"])
-            elif prop_dict["name"] == "frequency":
-                qubit_properties["frequency"] = apply_prefix(prop_dict["value"], prop_dict["unit"])
-        qubit_props.append(QubitProperties(**qubit_properties))
-    return qubit_props