qoro-divi 0.2.0b1__py3-none-any.whl

divi/__init__.py

@@ -0,0 +1,8 @@
+# SPDX-FileCopyrightText: 2025 Qoro Quantum Ltd <divi@qoroquantum.de>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from .qlogger import enable_logging
+from .qoro_service import QoroService
+
+enable_logging()

divi/_pbar.py

@@ -0,0 +1,73 @@
+# SPDX-FileCopyrightText: 2025 Qoro Quantum Ltd <divi@qoroquantum.de>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Optional
+
+from rich.progress import (
+    BarColumn,
+    MofNCompleteColumn,
+    Progress,
+    ProgressColumn,
+    SpinnerColumn,
+    TextColumn,
+)
+from rich.text import Text
+
+
+class ConditionalSpinnerColumn(ProgressColumn):
+    def __init__(self):
+        super().__init__()
+        self.spinner = SpinnerColumn("point")
+
+    def render(self, task):
+        status = task.fields.get("final_status")
+
+        if status in ("Success", "Failed"):
+            return Text("")
+
+        return self.spinner.render(task)
+
+
+class PhaseStatusColumn(ProgressColumn):
+    def __init__(self, max_retries: int, table_column=None):
+        super().__init__(table_column)
+
+        self._max_retries = max_retries
+        self._last_message = ""
+
+    def render(self, task):
+        final_status = task.fields.get("final_status")
+
+        if final_status == "Success":
+            return Text("• Success! ✅", style="bold green")
+        elif final_status == "Failed":
+            return Text("• Failed! ❌", style="bold red")
+
+        message = task.fields.get("message")
+        if message != "":
+            self._last_message = message
+
+        poll_attempt = task.fields.get("poll_attempt")
+        if poll_attempt > 0:
+            return Text(
+                f"[{self._last_message}] Polling {poll_attempt}/{self._max_retries}"
+            )
+
+        return Text(f"[{self._last_message}]")
+
+
+def make_progress_bar(
+    max_retries: Optional[int] = None, is_jupyter: bool = False
+) -> Progress:
+    return Progress(
+        TextColumn("[bold blue]{task.fields[job_name]}"),
+        BarColumn(),
+        MofNCompleteColumn(),
+        ConditionalSpinnerColumn(),
+        PhaseStatusColumn(max_retries=max_retries),
+        # For jupyter notebooks, refresh manually instead
+        auto_refresh=not is_jupyter,
+        # Give a dummy positive value if is_jupyter
+        refresh_per_second=10 if not is_jupyter else 999,
+    )

divi/circuits.py

@@ -0,0 +1,139 @@
+# SPDX-FileCopyrightText: 2025 Qoro Quantum Ltd <divi@qoroquantum.de>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import re
+from copy import deepcopy
+from itertools import product
+from typing import Literal, Optional
+
+import dill
+import pennylane as qml
+from pennylane.transforms.core.transform_program import TransformProgram
+from qiskit.qasm2 import dumps
+
+from divi.qasm import to_openqasm
+from divi.qem import QEMProtocol
+
+TRANSFORM_PROGRAM = TransformProgram()
+TRANSFORM_PROGRAM.add_transform(qml.transforms.split_to_single_terms)
+TRANSFORM_PROGRAM.add_transform(qml.transforms.split_non_commuting)
+
+
+class Circuit:
+    _id_counter = 0
+
+    def __init__(
+        self,
+        main_circuit,
+        tags: list[str],
+        qasm_circuits: list[str] = None,
+    ):
+        self.main_circuit = main_circuit
+        self.circuit_type = main_circuit.__module__.split(".")[0]
+        self.tags = tags
+
+        self.qasm_circuits = qasm_circuits
+
+        if self.qasm_circuits is None:
+            self.convert_to_qasm()
+
+        self.circuit_id = Circuit._id_counter
+        Circuit._id_counter += 1
+
+    def __str__(self):
+        return f"Circuit: {self.circuit_id}"
+
+    def convert_to_qasm(self):
+        if self.circuit_type == "pennylane":
+            self.qasm_circuits = to_openqasm(
+                self.main_circuit,
+                measurement_groups=[self.main_circuit.measurements],
+                return_measurements_separately=False,
+            )
+
+        elif self.circuit_type == "qiskit":
+            self.qasm_circuits = [dumps(self.main_circuit)]
+
+        else:
+            raise ValueError(
+                f"Invalid circuit type. Circuit type {self.circuit_type} not currently supported."
+            )
+
+
+class MetaCircuit:
+    def __init__(
+        self,
+        main_circuit,
+        symbols,
+        grouping_strategy: Optional[Literal["wires", "default", "qwc"]] = None,
+        qem_protocol: Optional[QEMProtocol] = None,
+    ):
+        self.main_circuit = main_circuit
+        self.symbols = symbols
+        self.qem_protocol = qem_protocol
+
+        transform_program = deepcopy(TRANSFORM_PROGRAM)
+        transform_program[1].kwargs["grouping_strategy"] = grouping_strategy
+
+        qscripts, self.postprocessing_fn = transform_program((main_circuit,))
+
+        self.compiled_circuits_bodies, self.measurements = to_openqasm(
+            main_circuit,
+            measurement_groups=[qsc.measurements for qsc in qscripts],
+            return_measurements_separately=True,
+            # TODO: optimize later
+            measure_all=True,
+            symbols=self.symbols,
+            qem_protocol=qem_protocol,
+        )
+
+        # Need to store the measurement groups for computing
+        # expectation values later on, stripped of the `qml.expval` wrapper
+        self.measurement_groups = [
+            [meas.obs for meas in qsc.measurements] for qsc in qscripts
+        ]
+
+    def __getstate__(self):
+        state = self.__dict__.copy()
+        state["postprocessing_fn"] = dill.dumps(self.postprocessing_fn)
+        return state
+
+    def __setstate__(self, state):
+        state["postprocessing_fn"] = dill.loads(state["postprocessing_fn"])
+
+        self.__dict__.update(state)
+
+    def initialize_circuit_from_params(
+        self, param_list, tag_prefix: str = "", precision: int = 8
+    ) -> Circuit:
+        mapping = dict(
+            zip(
+                map(lambda x: re.escape(str(x)), self.symbols),
+                map(lambda x: f"{x:.{precision}f}", param_list),
+            )
+        )
+        pattern = re.compile("|".join(k for k in mapping.keys()))
+
+        final_qasm_strs = []
+        for circuit_body in self.compiled_circuits_bodies:
+            final_qasm_strs.append(
+                pattern.sub(lambda match: mapping[match.group(0)], circuit_body)
+            )
+
+        tags = []
+        qasm_circuits = []
+        for (i, body_str), (j, meas_str) in product(
+            enumerate(final_qasm_strs), enumerate(self.measurements)
+        ):
+            qasm_circuits.append(body_str + meas_str)
+
+            nonempty_subtags = filter(
+                None,
+                [tag_prefix, f"{self.qem_protocol.name}:{i}", str(j)],
+            )
+            tags.append("_".join(nonempty_subtags))
+
+        # Note: The main circuit's parameters are still in symbol form.
+        # Not sure if it is necessary for any useful application to parameterize them.
+        return Circuit(self.main_circuit, qasm_circuits=qasm_circuits, tags=tags)

divi/exp/cirq/__init__.py

@@ -0,0 +1,7 @@
+# SPDX-FileCopyrightText: 2025 Qoro Quantum Ltd <divi@qoroquantum.de>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+# TODO: delete whole module once Cirq properly supports parameters in openqasm 3.0
+from . import _qasm_export  # Does nothing, just initiates the patch
+from ._qasm_import import cirq_circuit_from_qasm

divi/exp/cirq/_lexer.py

@@ -0,0 +1,126 @@
+# Copyright 2018 The Cirq 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
+#
+#     https://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.
+
+from __future__ import annotations
+
+import re
+
+import ply.lex as lex
+
+from .exception import QasmException
+
+
+class QasmLexer:
+    def __init__(self):
+        self.lex = lex.lex(object=self, debug=False)
+
+    literals = "{}[]();,+/*-^="
+
+    reserved = {
+        "qubit": "QUBIT",
+        "qreg": "QREG",
+        "bit": "BIT",
+        "creg": "CREG",
+        "measure": "MEASURE",
+        "reset": "RESET",
+        "gate": "GATE",
+        "if": "IF",
+        "pi": "PI",
+        "input": "INPUT",  # <-- Add this
+        "angle": "ANGLE",  # <-- Add this
+    }
+
+    tokens = [
+        "FORMAT_SPEC",
+        "NUMBER",
+        "NATURAL_NUMBER",
+        "STDGATESINC",
+        "QELIBINC",
+        "ID",
+        "ARROW",
+        "EQ",
+    ] + list(reserved.values())
+
+    def t_newline(self, t):
+        r"""\n+"""
+        t.lexer.lineno += len(t.value)
+
+    t_ignore = " \t"
+
+    # all numbers except NATURAL_NUMBERs:
+    # it's useful to have this separation to be able to handle indices
+    # separately. In case of the parameter expressions, we are "OR"-ing
+    # them together (see p_term in _parser.py)
+    def t_NUMBER(self, t):
+        r"""(
+        (
+        [0-9]+\.?|
+        [0-9]?\.[0-9]+
+        )
+        [eE][+-]?[0-9]+
+        )|
+        (
+        ([0-9]+)?\.[0-9]+|
+        [0-9]+\.)"""
+        t.value = float(t.value)
+        return t
+
+    def t_NATURAL_NUMBER(self, t):
+        r"""\d+"""
+        t.value = int(t.value)
+        return t
+
+    def t_FORMAT_SPEC(self, t):
+        r"""OPENQASM(\s+)([^\s\t\;]*);"""
+        match = re.match(r"""OPENQASM(\s+)([^\s\t;]*);""", t.value)
+        t.value = match.groups()[1]
+        return t
+
+    def t_QELIBINC(self, t):
+        r"""include(\s+)"qelib1.inc";"""
+        return t
+
+    def t_STDGATESINC(self, t):
+        r"""include(\s+)"stdgates.inc";"""
+        return t
+
+    def t_ARROW(self, t):
+        """->"""
+        return t
+
+    def t_EQ(self, t):
+        """=="""
+        return t
+
+    def t_ID(self, t):
+        r"""[^\W\d_][\w_]*"""
+        # This regex matches any Unicode letter (not digit/underscore) at the start,
+        # followed by any number of Unicode word characters or underscores.
+        if t.value in QasmLexer.reserved:
+            t.type = QasmLexer.reserved[t.value]
+        return t
+
+    t_ID.__doc__ = r"[^\W\d_][\w_]*"
+
+    def t_COMMENT(self, t):
+        r"""//.*"""
+
+    def t_error(self, t):
+        raise QasmException(f"Illegal character '{t.value[0]}' at line {t.lineno}")
+
+    def input(self, qasm):
+        self.lex.input(qasm)
+
+    def token(self) -> lex.Token | None:
+        return self.lex.token()