qoro-divi 0.2.2b1__py3-none-any.whl → 0.3.1b0__py3-none-any.whl

divi/parallel_simulator.py

@@ -7,7 +7,7 @@ import heapq
 import logging
 from functools import partial
 from multiprocessing import Pool
-from typing import Literal, Optional
+from typing import Literal
 from warnings import warn
 
 import qiskit_ibm_runtime.fake_provider as fk_prov
@@ -63,9 +63,9 @@ class ParallelSimulator(CircuitRunner):
         self,
         n_processes: int = 2,
         shots: int = 5000,
-        simulation_seed: Optional[int] = None,
+        simulation_seed: int | None = None,
         qiskit_backend: Backend | Literal["auto"] | None = None,
-        noise_model: Optional[NoiseModel] = None,
+        noise_model: NoiseModel | None = None,
     ):
         """
         A multi-process wrapper around Qiskit's AerSimulator.
@@ -73,7 +73,7 @@ class ParallelSimulator(CircuitRunner):
         Args:
             n_processes (int, optional): Number of parallel processes to use for simulation. Defaults to 2.
             shots (int, optional): Number of shots to perform. Defaults to 5000.
-            simulation_seed (Optional[int], optional): Seed for the random number generator to ensure reproducibility. Defaults to None.
+            simulation_seed (int, optional): Seed for the random number generator to ensure reproducibility. Defaults to None.
             backend (Backend or "auto, optional): A Qiskit backend to initiate the simulator from. If "auto" is passed,
              the best-fit most recent fake backend will be chosen for the given circuit. Defaults to None, resulting in noiseless simulation.
             noise_model (NoiseModel, optional): Qiskit noise model to use in simulation. Defaults to None.
@@ -96,9 +96,9 @@ class ParallelSimulator(CircuitRunner):
     def simulate_circuit(
         circuit_data: tuple[str, str],
         shots: int,
-        simulation_seed: Optional[int] = None,
-        qiskit_backend: Optional[Backend] = None,
-        noise_model: Optional[NoiseModel] = None,
+        simulation_seed: int | None = None,
+        qiskit_backend: Backend | None = None,
+        noise_model: NoiseModel | None = None,
     ):
         circuit_label, circuit = circuit_data
 
@@ -207,8 +207,8 @@ class ParallelSimulator(CircuitRunner):
 
     @staticmethod
     def estimate_run_time_batch(
-        circuits: Optional[list[str]] = None,
-        precomputed_duration: Optional[list[float]] = None,
+        circuits: list[str] | None = None,
+        precomputed_duration: list[float] | None = None,
         n_qpus: int = 5,
         **transpilation_kwargs,
     ) -> float:

divi/qasm.py

@@ -5,7 +5,6 @@
 import re
 from functools import partial
 from itertools import product
-from typing import Optional
 from warnings import warn
 
 import cirq
@@ -81,10 +80,10 @@ def to_openqasm(
     main_qscript,
     measurement_groups: list[list[qml.measurements.ExpectationMP]],
     measure_all: bool = True,
-    precision: Optional[int] = None,
+    precision: int | None = None,
     return_measurements_separately: bool = False,
     symbols: list[Symbol] = None,
-    qem_protocol: Optional[QEMProtocol] = None,
+    qem_protocol: QEMProtocol | None = None,
 ) -> list[str] | tuple[str, list[str]]:
     """
     Serialize the circuit as an OpenQASM 2.0 program.

divi/qoro_service.py

@@ -10,30 +10,42 @@ import time
 from collections.abc import Callable
 from enum import Enum
 from http import HTTPStatus
-from typing import Optional
 
 import requests
+from dotenv import dotenv_values
 from requests.adapters import HTTPAdapter, Retry
 
+from divi.exp.cirq import is_valid_qasm
 from divi.interfaces import CircuitRunner
+from divi.qpu_system import QPU, QPUSystem
 
 API_URL = "https://app.qoroquantum.net/api"
 MAX_PAYLOAD_SIZE_MB = 0.95
 
 session = requests.Session()
-retries = Retry(
+retry_configuration = Retry(
     total=5,
     backoff_factor=0.1,
     status_forcelist=[502],
     allowed_methods=["GET", "POST", "DELETE"],
 )
 
-session.mount("http://", HTTPAdapter(max_retries=retries))
-session.mount("https://", HTTPAdapter(max_retries=retries))
+session.mount("http://", HTTPAdapter(max_retries=retry_configuration))
+session.mount("https://", HTTPAdapter(max_retries=retry_configuration))
 
 logger = logging.getLogger(__name__)
 
 
+def _raise_with_details(resp: requests.Response):
+    try:
+        data = resp.json()
+        body = json.dumps(data, ensure_ascii=False)
+    except ValueError:
+        body = resp.text
+    msg = f"{resp.status_code} {resp.reason}: {body}"
+    raise requests.HTTPError(msg)
+
+
 class JobStatus(Enum):
     PENDING = "PENDING"
     RUNNING = "RUNNING"
@@ -52,47 +64,155 @@ class JobType(Enum):
 class MaxRetriesReachedError(Exception):
     """Exception raised when the maximum number of retries is reached."""
 
-    def __init__(self, retries, message="Maximum retries reached"):
+    def __init__(self, retries):
         self.retries = retries
-        self.message = f"{message}: {retries} retries attempted"
+        self.message = f"Maximum retries reached: {retries} retries attempted"
         super().__init__(self.message)
 
 
+def _parse_qpu_systems(json_data: list) -> list[QPUSystem]:
+    return [
+        QPUSystem(
+            name=system_data["name"],
+            qpus=[QPU(**qpu) for qpu in system_data.get("qpus", [])],
+            access_level=system_data["access_level"],
+        )
+        for system_data in json_data
+    ]
+
+
 class QoroService(CircuitRunner):
 
     def __init__(
         self,
-        auth_token: str,
+        auth_token: str | None = None,
         polling_interval: float = 3.0,
         max_retries: int = 5000,
         shots: int = 1000,
-        use_circuit_packing: Optional[bool] = False,
+        qpu_system_name: str | QPUSystem | None = None,
+        use_circuit_packing: bool = False,
     ):
         super().__init__(shots=shots)
 
+        if auth_token is None:
+            try:
+                auth_token = dotenv_values()["QORO_API_KEY"]
+            except KeyError:
+                raise ValueError("Qoro API key not provided nor found in a .env file.")
+
         self.auth_token = "Bearer " + auth_token
         self.polling_interval = polling_interval
         self.max_retries = max_retries
+        self._qpu_system_name = qpu_system_name
         self.use_circuit_packing = use_circuit_packing
 
-    def test_connection(self):
-        """Test the connection to the Qoro API"""
-        response = session.get(
-            API_URL, headers={"Authorization": self.auth_token}, timeout=10
-        )
+    @property
+    def qpu_system_name(self) -> str | QPUSystem | None:
+        return self._qpu_system_name
+
+    @qpu_system_name.setter
+    def qpu_system_name(self, system_name: str | QPUSystem | None):
+        """
+        Set the QPU system for the service.
+
+        Args:
+            system_name (str | QPUSystem): The QPU system to set or the name as a string.
+        """
+        if isinstance(system_name, str):
+            self._qpu_system_name = system_name
+        elif isinstance(system_name, QPUSystem):
+            self._qpu_system_name = system_name.name
+        elif system_name is None:
+            self._qpu_system_name = None
+        else:
+            raise TypeError("Expected a QPUSystem instance or str.")
+
+    def _make_request(self, method: str, endpoint: str, **kwargs) -> requests.Response:
+        """A centralized helper for making API requests."""
+        url = f"{API_URL}/{endpoint}"
+
+        headers = {"Authorization": self.auth_token}
+
+        if method.upper() in ["POST", "PUT", "PATCH"]:
+            headers["Content-Type"] = "application/json"
 
-        if response.status_code != HTTPStatus.OK:
+        # Allow overriding default headers
+        if "headers" in kwargs:
+            headers.update(kwargs.pop("headers"))
+
+        response = session.request(method, url, headers=headers, **kwargs)
+
+        # Generic error handling for non-OK statuses
+        if response.status_code >= 400:
             raise requests.exceptions.HTTPError(
-                f"Connection failed with error: {response.status_code}: {response.reason}"
+                f"API Error: {response.status_code} {response.reason} for URL {response.url}"
             )
 
         return response
 
+    def test_connection(self):
+        """Test the connection to the Qoro API"""
+        return self._make_request("get", "", timeout=10)
+
+    def fetch_qpu_systems(self) -> list[QPUSystem]:
+        """
+        Get the list of available QPU systems from the Qoro API.
+
+        Returns:
+            List of QPUSystem objects.
+        """
+        response = self._make_request("get", "qpusystem/", timeout=10)
+        return _parse_qpu_systems(response.json())
+
+    @staticmethod
+    def _compress_data(value) -> bytes:
+        return base64.b64encode(gzip.compress(value.encode("utf-8"))).decode("utf-8")
+
+    def _split_circuits(self, circuits: dict[str, str]) -> list[dict[str, str]]:
+        """
+        Splits circuits into chunks by estimating payload size with a simplified,
+        consistent overhead calculation.
+        Assumes that BASE64 encoding produces ASCI characters, which are 1 byte each.
+        """
+        max_payload_bytes = MAX_PAYLOAD_SIZE_MB * 1024 * 1024
+        circuit_chunks = []
+        current_chunk = {}
+
+        # Start with size 2 for the opening and closing curly braces '{}'
+        current_chunk_size_bytes = 2
+
+        for key, value in circuits.items():
+            compressed_value = self._compress_data(value)
+
+            item_size_bytes = len(key) + len(compressed_value) + 6
+
+            # If adding this item would exceed the limit, finalize the current chunk.
+            # This check only runs if the chunk is not empty.
+            if current_chunk and (
+                current_chunk_size_bytes + item_size_bytes > max_payload_bytes
+            ):
+                circuit_chunks.append(current_chunk)
+
+                # Start a new chunk
+                current_chunk = {}
+                current_chunk_size_bytes = 2
+
+            # Add the new item to the current chunk and update its size
+            current_chunk[key] = compressed_value
+            current_chunk_size_bytes += item_size_bytes
+
+        # Add the last remaining chunk if it's not empty
+        if current_chunk:
+            circuit_chunks.append(current_chunk)
+
+        return circuit_chunks
+
     def submit_circuits(
         self,
         circuits: dict[str, str],
         tag: str = "default",
         job_type: JobType = JobType.SIMULATE,
+        qpu_system_name: str | None = None,
         override_circuit_packing: bool | None = None,
     ):
         """
@@ -120,77 +240,39 @@ class QoroService(CircuitRunner):
         if job_type == JobType.CIRCUIT_CUT and len(circuits) > 1:
             raise ValueError("Only one circuit allowed for circuit-cutting jobs.")
 
-        def _compress_data(value) -> bytes:
-            return base64.b64encode(gzip.compress(value.encode("utf-8"))).decode(
-                "utf-8"
-            )
-
-        def _split_circuits(circuits: dict[str, str]) -> list[dict[str, str]]:
-            """
-            Split circuits into smaller chunks if the payload size exceeds the maximum allowed size.
-
-            Args:
-                circuits: Dictionary of circuits to be sent
-
-            Returns:
-                List of circuit chunks
-            """
-
-            def _estimate_size(data):
-                payload_json = json.dumps(data)
-                return len(payload_json.encode("utf-8")) / 1024 / 1024
-
-            circuit_chunks = []
-            current_chunk = {}
-            current_size = 0
-
-            for key, value in circuits.items():
-                compressed_value = _compress_data(value)
-                estimated_size = _estimate_size({key: compressed_value})
-
-                if current_size + estimated_size > MAX_PAYLOAD_SIZE_MB:
-                    circuit_chunks.append(current_chunk)
-                    current_chunk = {key: compressed_value}
-                    current_size = estimated_size
-                else:
-                    current_chunk[key] = compressed_value
-                    current_size += estimated_size
-
-            if current_chunk:
-                circuit_chunks.append(current_chunk)
+        for key, circuit in circuits.items():
+            if not is_valid_qasm(circuit):
+                raise ValueError(f"Circuit {key} is not a valid QASM string.")
 
-            return circuit_chunks
+        circuit_chunks = self._split_circuits(circuits)
 
-        circuit_chunks = _split_circuits(circuits)
+        payload = {
+            "shots": self.shots,
+            "tag": tag,
+            "job_type": job_type.value,
+            "qpu_system_name": qpu_system_name or self.qpu_system_name,
+            "use_packing": (
+                override_circuit_packing
+                if override_circuit_packing is not None
+                else self.use_circuit_packing
+            ),
+        }
 
         job_ids = []
         for chunk in circuit_chunks:
-            response = session.post(
-                API_URL + "/job/",
-                headers={
-                    "Authorization": self.auth_token,
-                    "Content-Type": "application/json",
-                },
-                json={
-                    "circuits": chunk,
-                    "shots": self.shots,
-                    "tag": tag,
-                    "job_type": job_type.value,
-                    "use_packing": (
-                        override_circuit_packing
-                        if override_circuit_packing is not None
-                        else self.use_circuit_packing
-                    ),
-                },
+            payload["circuits"] = chunk
+
+            response = self._make_request(
+                "post",
+                "job/",
+                json=payload,
                 timeout=100,
             )
 
             if response.status_code == HTTPStatus.CREATED:
                 job_ids.append(response.json()["job_id"])
             else:
-                raise requests.exceptions.HTTPError(
-                    f"{response.status_code}: {response.reason}"
-                )
+                _raise_with_details(response)
 
         return job_ids if len(job_ids) > 1 else job_ids[0]
 
@@ -206,16 +288,14 @@ class QoroService(CircuitRunner):
         if not isinstance(job_ids, list):
             job_ids = [job_ids]
 
-        responses = []
-
-        for job_id in job_ids:
-            response = session.delete(
-                API_URL + f"/job/{job_id}",
-                headers={"Authorization": self.auth_token},
+        responses = [
+            self._make_request(
+                "delete",
+                f"job/{job_id}",
                 timeout=50,
             )
-
-            responses.append(response)
+            for job_id in job_ids
+        ]
 
         return responses if len(responses) > 1 else responses[0]
 
@@ -231,14 +311,14 @@ class QoroService(CircuitRunner):
         if not isinstance(job_ids, list):
             job_ids = [job_ids]
 
-        responses = []
-        for job_id in job_ids:
-            response = session.get(
-                API_URL + f"/job/{job_id}/results",
-                headers={"Authorization": self.auth_token},
+        responses = [
+            self._make_request(
+                "get",
+                f"job/{job_id}/results",
                 timeout=100,
             )
-            responses.append(response)
+            for job_id in job_ids
+        ]
 
         if all(response.status_code == HTTPStatus.OK for response in responses):
             responses = [response.json() for response in responses]
@@ -260,9 +340,9 @@ class QoroService(CircuitRunner):
         self,
         job_ids: str | list[str],
         loop_until_complete: bool = False,
-        on_complete: Optional[Callable] = None,
+        on_complete: Callable | None = None,
         verbose: bool = True,
-        pbar_update_fn: Optional[Callable] = None,
+        pbar_update_fn: Callable | None = None,
     ):
         """
         Get the status of a job and optionally execute function *on_complete* on the results
@@ -273,7 +353,6 @@ class QoroService(CircuitRunner):
             loop_until_complete (bool): A flag to loop until the job is completed
             on_complete (optional): A function to be called when the job is completed
             polling_interval (optional): The time to wait between retries
-            max_retries (optional): The maximum number of retries
             verbose (optional): A flag to print the when retrying
             pbar_update_fn (optional): A function for updating progress bars while polling.
         Returns:
@@ -282,62 +361,52 @@ class QoroService(CircuitRunner):
         if not isinstance(job_ids, list):
             job_ids = [job_ids]
 
-        def _poll_job_status(job_id):
-            response = session.get(
-                API_URL + f"/job/{job_id}/status/",
-                headers={
-                    "Authorization": self.auth_token,
-                    "Content-Type": "application/json",
-                },
-                timeout=200,
-            )
+        if not loop_until_complete:
+            statuses = [
+                self._make_request(
+                    "get",
+                    f"job/{job_id}/status/",
+                    timeout=200,
+                ).json()["status"]
+                for job_id in job_ids
+            ]
+            return statuses if len(statuses) > 1 else statuses[0]
 
-            if response.status_code == HTTPStatus.OK:
-                return response.json()["status"], response
-            else:
-                raise requests.exceptions.HTTPError(
-                    f"{response.status_code}: {response.reason}"
+        pending_job_ids = set(job_ids)
+        responses = []
+        for retry_count in range(1, self.max_retries + 1):
+            # Exit early if all jobs are done
+            if not pending_job_ids:
+                break
+
+            for job_id in list(pending_job_ids):
+                response = self._make_request(
+                    "get",
+                    f"job/{job_id}/status/",
+                    timeout=200,
                 )
 
-        if loop_until_complete:
-            retries = 0
-            completed = False
-            while True:
-                responses = []
-                statuses = []
-
-                for job_id in job_ids:
-                    job_status, response = _poll_job_status(job_id)
-                    statuses.append(job_status)
+                if response.json()["status"] == JobStatus.COMPLETED.value:
+                    pending_job_ids.remove(job_id)
                     responses.append(response)
 
-                if all(status == JobStatus.COMPLETED.value for status in statuses):
-                    responses = [response.json() for response in responses]
-                    completed = True
-                    break
-
-                if retries >= self.max_retries:
-                    break
-
-                retries += 1
+            # Exit before sleeping if no jobs are pending
+            if not pending_job_ids:
+                break
 
-                time.sleep(self.polling_interval)
+            time.sleep(self.polling_interval)
 
-                if verbose:
-                    if pbar_update_fn:
-                        pbar_update_fn(retries)
-                    else:
-                        logger.info(
-                            rf"\cPolling {retries} / {self.max_retries} retries\r"
-                        )
+            if verbose:
+                if pbar_update_fn:
+                    pbar_update_fn(retry_count)
+                else:
+                    logger.info(
+                        rf"\cPolling {retry_count} / {self.max_retries} retries\r"
+                    )
 
-            if completed and on_complete:
+        if not pending_job_ids:
+            if on_complete:
                 on_complete(responses)
-                return JobStatus.COMPLETED
-            elif completed:
-                return JobStatus.COMPLETED
-            else:
-                raise MaxRetriesReachedError(retries)
+            return JobStatus.COMPLETED
         else:
-            statuses = [_poll_job_status(job_id)[0] for job_id in job_ids]
-            return statuses if len(statuses) > 1 else statuses[0]
+            raise MaxRetriesReachedError(retry_count)

divi/qprog/__init__.py

@@ -7,7 +7,7 @@ from .quantum_program import QuantumProgram
 from .batch import ProgramBatch
 from ._qaoa import QAOA, GraphProblem
 from ._vqe import VQE, VQEAnsatz
-from ._mlae import MLAE
 from ._graph_partitioning import GraphPartitioningQAOA, PartitioningConfig
-from ._vqe_sweep import VQEHyperparameterSweep
+from ._qubo_partitioning import QUBOPartitioningQAOA
+from ._vqe_sweep import VQEHyperparameterSweep, MoleculeTransformer
 from .optimizers import Optimizer