qoro-divi 0.2.0b1__py3-none-any.whl → 0.5.0__py3-none-any.whl

divi/reporting/_qlogger.py

@@ -0,0 +1,68 @@
+# SPDX-FileCopyrightText: 2025 Qoro Quantum Ltd <divi@qoroquantum.de>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import logging
+
+from rich.logging import RichHandler
+
+
+class CustomRichFormatter(logging.Formatter):
+    """
+    A custom log formatter that removes '._reporter' from the logger name.
+    Works with RichHandler.
+    """
+
+    def format(self, record):
+        # Modify the record's name attribute in place
+        if record.name.endswith("._reporter"):
+            record.name = record.name.removesuffix("._reporter")
+        return super().format(record)
+
+
+def enable_logging(level=logging.INFO):
+    """
+    Enable logging for the divi package with Rich formatting.
+
+    Sets up a RichHandler that provides colorized, formatted log output
+    and removes the '._reporter' suffix from logger names.
+
+    Args:
+        level (int, optional): Logging level to set (e.g., logging.INFO,
+            logging.DEBUG). Defaults to logging.INFO.
+
+    Note:
+        This function clears any existing handlers and sets up a new handler
+        with custom formatting.
+    """
+    root_logger = logging.getLogger(__name__.split(".")[0])
+
+    handler = RichHandler(
+        rich_tracebacks=True,
+        show_time=True,
+        show_path=False,
+        markup=True,
+    )
+
+    # Use a simpler formatter since RichHandler handles time display
+    formatter = CustomRichFormatter(
+        "%(name)s - %(levelname)s - %(message)s",
+    )
+    handler.setFormatter(formatter)
+
+    root_logger.setLevel(level)
+    root_logger.handlers.clear()
+    root_logger.addHandler(handler)
+
+
+def disable_logging():
+    """
+    Disable all logging for the divi package.
+
+    Removes all handlers and sets the logging level to above CRITICAL,
+    effectively suppressing all log messages. This is useful when using
+    progress bars that provide visual feedback.
+    """
+    root_logger = logging.getLogger(__name__.split(".")[0])
+    root_logger.handlers.clear()
+    root_logger.setLevel(logging.CRITICAL + 1)

divi/reporting/_reporter.py

@@ -0,0 +1,133 @@
+# SPDX-FileCopyrightText: 2025 Qoro Quantum Ltd <divi@qoroquantum.de>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import logging
+from abc import ABC, abstractmethod
+from queue import Queue
+
+from rich.console import Console
+
+logger = logging.getLogger(__name__)
+
+
+class ProgressReporter(ABC):
+    """An abstract base class for reporting progress of a quantum program."""
+
+    @abstractmethod
+    def update(self, **kwargs) -> None:
+        """Provides a progress update."""
+        pass
+
+    @abstractmethod
+    def info(self, message: str, **kwargs) -> None:
+        """Provides a simple informational message.
+
+        Args:
+            message: The message to display.
+            **kwargs: Additional keyword arguments for subclasses.
+        """
+        pass
+
+
+class QueueProgressReporter(ProgressReporter):
+    """Reports progress by putting structured dictionaries onto a Queue."""
+
+    def __init__(self, job_id: str, progress_queue: Queue):
+        self._job_id = job_id
+        self._queue = progress_queue
+
+    def update(self, **kwargs):
+        payload = {"job_id": self._job_id, "progress": 1}
+        self._queue.put(payload)
+
+    def info(self, message: str, **kwargs):
+        payload = {"job_id": self._job_id, "progress": 0, "message": message}
+
+        if "Finished successfully!" in message:
+            payload["final_status"] = "Success"
+
+        if "poll_attempt" in kwargs:
+            # For polling, remove the message key so the last message persists.
+            del payload["message"]
+            payload["poll_attempt"] = kwargs["poll_attempt"]
+            payload["max_retries"] = kwargs["max_retries"]
+            payload["service_job_id"] = kwargs["service_job_id"]
+            payload["job_status"] = kwargs["job_status"]
+        else:
+            # For any other message, explicitly reset the polling attempt counter.
+            payload["poll_attempt"] = 0
+
+        self._queue.put(payload)
+
+
+class LoggingProgressReporter(ProgressReporter):
+    """Reports progress by logging messages to the console."""
+
+    def __init__(self):
+        # Use the same console instance that RichHandler uses to avoid interference
+        self._console = Console(file=None)  # file=None uses stdout, same as RichHandler
+        self._status = None  # Track active status for overwriting messages
+        self._current_msg = None  # Track current main message
+        self._polling_msg = None  # Track current polling message
+
+    def _close_status(self):
+        """Close any active status."""
+        if self._status:
+            self._status.__exit__(None, None, None)
+            self._status = None
+        self._current_msg = None
+        self._polling_msg = None
+
+    def _build_status_msg(self) -> str:
+        """Build combined status message from current message and polling info."""
+        parts = []
+        if self._current_msg:
+            parts.append(self._current_msg)
+        if self._polling_msg:
+            parts.append(self._polling_msg)
+        return " - ".join(parts) if parts else ""
+
+    def _update_or_create_status(self):
+        """Update existing status or create a new one with combined message."""
+        status_msg = self._build_status_msg()
+        if not status_msg:
+            return
+        if self._status:
+            self._status.update(status_msg)
+        else:
+            self._status = self._console.status(status_msg, spinner="aesthetic")
+            self._status.__enter__()
+
+    def update(self, **kwargs):
+        # Close any active status before logging
+        self._close_status()
+        logger.info(f"Finished Iteration #{kwargs['iteration']}")
+
+    def info(self, message: str, overwrite: bool = False, **kwargs):
+        # A special check for iteration updates to use Rich's status for overwriting
+        if "poll_attempt" in kwargs:
+            self._polling_msg = (
+                f"Job [cyan]{kwargs['service_job_id'].split('-')[0]}[/cyan] is "
+                f"{kwargs['job_status']}. Polling attempt {kwargs['poll_attempt']} / "
+                f"{kwargs['max_retries']}"
+            )
+            self._update_or_create_status()
+            return
+
+        # Use Rich's status for iteration messages to enable overwriting
+        if "iteration" in kwargs:
+            self._current_msg = f"Iteration #{kwargs['iteration'] + 1}: {message}"
+            self._update_or_create_status()
+            return
+
+        # Use Rich's status for messages that should overwrite
+        if overwrite:
+            # Set current message, keep polling state so it can be concatenated
+            self._current_msg = message
+            self._update_or_create_status()
+            return
+
+        # Close status for normal messages
+        self._close_status()
+        logger.info(message)

{qoro_divi-0.2.0b1.dist-info → qoro_divi-0.5.0.dist-info}/METADATA

@@ -1,33 +1,39 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: qoro-divi
-Version: 0.2.0b1
-Summary: 
+Version: 0.5.0
+Summary: A Python library to automate generating, parallelizing, and executing quantum programs.
+License-File: LICENSE
+License-File: LICENSES/.license-header
+License-File: LICENSES/Apache-2.0.txt
 Author: Ahmed Darwish
 Author-email: ahmed@qoroquantum.de
 Requires-Python: >=3.11,<3.13
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: cirq-core (<1.5.0)
+Requires-Dist: basis-set-exchange (>=0.11,<0.12)
+Requires-Dist: cirq-core (>=1.6,<2.0)
 Requires-Dist: dill (>=0.4.0,<0.5.0)
+Requires-Dist: dwave-hybrid (>=0.6.14,<0.7.0)
 Requires-Dist: matplotlib (>=3.10.3,<4.0.0)
-Requires-Dist: mitiq (>=0.46,<0.47)
+Requires-Dist: mitiq (>=0.48,<0.49)
 Requires-Dist: networkx (>=3.5,<4.0)
-Requires-Dist: pennylane (>=0.40,<0.41)
+Requires-Dist: numpy
+Requires-Dist: pennylane (>=0.42.3,<0.43.0)
 Requires-Dist: ply (>=3.11,<4.0)
+Requires-Dist: pydantic (>=2.5.0,<2.10)
 Requires-Dist: pymetis (>=2025.1.1,<2026.0.0)
-Requires-Dist: pyqt6 (>=6.9.1,<7.0.0)
+Requires-Dist: pymoo (>=0.6,<0.7)
 Requires-Dist: python-dotenv (>=1.1.1,<2.0.0)
-Requires-Dist: qiskit (<2.0)
-Requires-Dist: qiskit-aer (>=0.17.1,<0.18.0)
-Requires-Dist: qiskit-algorithms (>=0.3.1,<0.4.0)
-Requires-Dist: qiskit-ibm-runtime (>=0.37,<0.38)
-Requires-Dist: qiskit-optimization (>=0.6.1,<0.7.0)
+Requires-Dist: qiskit (>=2.2,<3.0)
+Requires-Dist: qiskit-aer
+Requires-Dist: qiskit-ibm-runtime (>0.42)
 Requires-Dist: requests (>=2.32.4,<3.0.0)
 Requires-Dist: rich (>=14.0.0,<15.0.0)
 Requires-Dist: scikit-learn (>=1.7.0,<2.0.0)
-Requires-Dist: scipy (<=1.15.2)
+Requires-Dist: scipy (>=1.16,<2.0)
 Requires-Dist: sympy (>=1.14.0,<2.0.0)
+Requires-Dist: tuna (>=0.5.11,<0.6.0)
 Description-Content-Type: text/markdown
 
 # Divi
@@ -38,6 +44,9 @@ Divi is designed to allow researchers, students, and enterprises to deploy quant
 
 ---
 
+> [!IMPORTANT]
+> Divi is under active development and in early stages. Users should expect frequent changes that are likely to be incompatible with previously published versions.
+
 ## 🚀 Features
 
 - 🧠 **Smart Job Parallelization**: Automatically parallelizes your quantum programs based on task structure.
@@ -49,9 +58,28 @@ Divi is designed to allow researchers, students, and enterprises to deploy quant
 
 ## 📦 Installation
 
-[TODO]
+Divi can be easily installed from Pypi
+
+```bash
+pip install qoro-divi
+```
 
 ## 📚 Documentation
 
-Full documentation is available at: <https://docs.qoroquantum.net/divi>
+- Full documentation is available at: <https://docs.qoroquantum.net/divi>
+- Tutorials can be found in the `tutorials` folder.
+
+## 🧪 Testing
+
+To run the test suite:
+
+```bash
+# Run all tests
+pytest
+
+# Run only API tests (requires API token)
+pytest --run-api-tests
+```
+
+**Note:** Some tests require a Qoro API token to test the cloud REST API. Set the `QORO_API_KEY` environment variable or use the `--api-token` option. For local development, you can create a `.env`.
 

qoro_divi-0.5.0.dist-info/RECORD

@@ -0,0 +1,43 @@
+divi/__init__.py,sha256=SyBWflbDS6qGEtHg-AfzD1TRNgfXoW2H5qTYGJ-W3XQ,167
+divi/backends/__init__.py,sha256=4catD73mnCHd6EHpo0vZkR-MLnZeCBFC7Xn6VnMUFlc,404
+divi/backends/_circuit_runner.py,sha256=BOLLyZTVvj-YzqPDQh9tbOdD4crBqGdxAZdtgLmMGLU,2130
+divi/backends/_execution_result.py,sha256=1p7l-e7Opxq7SU433fYmIMedoyO-mvH_jC927GUI7zE,2614
+divi/backends/_parallel_simulator.py,sha256=p3BLvX7Y1gY2-rMDEes4uKutUgN1Fj0PqZZ4DGnlWsA,18271
+divi/backends/_qoro_service.py,sha256=n_gbllNlwwgHGhlBIrjS_00qKJfKooB4HoiIzp68FJk,24418
+divi/backends/_qpu_system.py,sha256=mo0SIlih5TEgJ9XdW_JFVbRP8pcNQ9jqzwK-08WzkiI,3065
+divi/backends/_results_processing.py,sha256=2yakh9-kDEiW7cJvfClzE5fbgRumJZ-jGSTKdUdgHCY,3873
+divi/circuits/__init__.py,sha256=XcQVYHb8HakdrANwGwBgM40EotVZI6DNtCncGx40r6Y,328
+divi/circuits/_cirq/__init__.py,sha256=EtdMjq4MGwpR7GnJb5WrqhlmXEoV284QA4nM6K5bmtU,220
+divi/circuits/_cirq/_parser.py,sha256=4VVUG-BQuGEyfiX3sJGUTDFZcO_awcm_FjlwWjq3D-A,3746
+divi/circuits/_cirq/_qasm_export.py,sha256=32h5a-m_7tVfje6MmEgwRNPd9U0ximqddbCsOIqVg6U,2944
+divi/circuits/_core.py,sha256=Zg_3TcxzboYoxDj5Sz0WzPP7KVU_FxrfJD6Hqk2s9pU,15310
+divi/circuits/_qasm_conversion.py,sha256=-ZXVWmcetgP7N-YeSpxX6E2MhazuhdTqlyZEhPjC-tQ,9665
+divi/circuits/_qasm_validation.py,sha256=A4LqllrYzzMgWVuAVdVUBlU6A99pw5qqLyWiRXkDScE,22704
+divi/circuits/qem.py,sha256=o6rMPUcxLuCBitBb8-QcxveUiKZVsP3HMamxyVFLi6M,6805
+divi/qprog/__init__.py,sha256=y1vTwQWmtBooD7JS_LjKIXVp8WIc1MeOtoBsFdodmlE,809
+divi/qprog/_expectation.py,sha256=2Imgdng8gU1ImVXHprMUS1YbpAY0eI19Mp08Vw5lGvU,7395
+divi/qprog/_hamiltonians.py,sha256=UHiCRo1k3h3cPQcIrRYhd82n-vS78I8U1LYT6AjJkdc,9419
+divi/qprog/algorithms/__init__.py,sha256=KLGD3zRk3z4nJQDqBjejTGgJ5m0n02jyBVHLJihMMws,355
+divi/qprog/algorithms/_ansatze.py,sha256=kks5SZ2fbGAX1hMdiuBfn8-45ocvFzJMLXpdnaOtVwg,12766
+divi/qprog/algorithms/_qaoa.py,sha256=wRESmK4llPGOluM0M67FdB-kdPIFQUCurmjR4novAYU,21903
+divi/qprog/algorithms/_vqe.py,sha256=kh-olGVMfoiaaMutxgbfi4SaHUXhIOcqW8ksElNllkQ,9571
+divi/qprog/batch.py,sha256=qNVb9Y751NLI5zkVmuN8MSIvi-cQmwU7yS_yjG2acgI,20431
+divi/qprog/checkpointing.py,sha256=g0I5fV4LMVjZZ-780WsojlwgQmJvY6nxZILAkUrOwk0,17369
+divi/qprog/exceptions.py,sha256=2VvUf8qgNBw60Q4wyt_2nbE4JHHMmZiT2JaGmWChp2o,231
+divi/qprog/optimizers.py,sha256=BdjJl1Fw56RMdXiVcNedNH1uOCxdmj-en4s_cbixl5U,39104
+divi/qprog/quantum_program.py,sha256=daPEZRM9Z0JwHVUjQx560yaowj8ZFKLdEoqFqZsfxt4,11678
+divi/qprog/variational_quantum_algorithm.py,sha256=ijC7z5ednw48sEed8AzkdEA0q-x0GL0zfq7Og3pB2mQ,37874
+divi/qprog/workflows/__init__.py,sha256=_GAFsZsgj9p61E1xUXasa1aspwcOWp4s8i6hA6mQ9eg,320
+divi/qprog/workflows/_graph_partitioning.py,sha256=nTxpPom7Aulfndlqws0FkaTvs1siRCeixiBkwRqV1Xc,24435
+divi/qprog/workflows/_qubo_partitioning.py,sha256=hp4c5YYyLyFkkbsyIyBxpK8cDzo4Pwf-5-i23fQpjUQ,8397
+divi/qprog/workflows/_vqe_sweep.py,sha256=rT79jYex04linD42mdXCM54LdZ83eFCwUGAKnX1PQSM,19658
+divi/reporting/__init__.py,sha256=gaBUZrhNxR53VHojZxfjvQRDl-eDHo901vLE8I95kIw,290
+divi/reporting/_pbar.py,sha256=of9vI37puHWVPCUwRbwtiT1cDQVCpUbpbxNx__hF7mE,4180
+divi/reporting/_qlogger.py,sha256=d16eT_n8Me83Qn1QOFmzEoVnRYTePM5l_I1GeNVCo4o,1990
+divi/reporting/_reporter.py,sha256=MLDShH8wWIL7WTeBLWYa4iiTVe-_P6lU-kqeVcq2Qm0,4755
+qoro_divi-0.5.0.dist-info/METADATA,sha256=i84uZ0ap0FNvL2a5YyCjjcbcvZ44JbdUt3y4MrP_X3g,2980
+qoro_divi-0.5.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+qoro_divi-0.5.0.dist-info/licenses/LICENSE,sha256=NS4JlQrgNwg1bvB3kE5shE-P4cJgnntgl-kClbOpG_Q,10760
+qoro_divi-0.5.0.dist-info/licenses/LICENSES/.license-header,sha256=2jN_xtJscqP8LG-NaveY2KHUkfRCC543Y_XjOyKEfWY,105
+qoro_divi-0.5.0.dist-info/licenses/LICENSES/Apache-2.0.txt,sha256=yoILHpvVuguUBpk8UwMnzJbcHUUyst9iGNNuEwUtWVc,10270
+qoro_divi-0.5.0.dist-info/RECORD,,

{qoro_divi-0.2.0b1.dist-info → qoro_divi-0.5.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.1
+Generator: poetry-core 2.2.1
 Root-Is-Purelib: true
 Tag: py3-none-any

qoro_divi-0.5.0.dist-info/licenses/LICENSES/.license-header

@@ -0,0 +1,3 @@
+SPDX-FileCopyrightText: 2025 Qoro Quantum Ltd <divi@qoroquantum.de>
+
+SPDX-License-Identifier: Apache-2.0

divi/_pbar.py

@@ -1,73 +0,0 @@
-# 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

@@ -1,139 +0,0 @@
-# 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/_lexer.py

@@ -1,126 +0,0 @@
-# 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()