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

divi/qlogger.py

@@ -1,119 +0,0 @@
-# SPDX-FileCopyrightText: 2025 Qoro Quantum Ltd <divi@qoroquantum.de>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-import logging
-import shutil
-import sys
-
-
-def _is_jupyter():
-    """
-    Checks if the code is running inside a Jupyter Notebook or IPython environment.
-    """
-    try:
-        from IPython import get_ipython
-
-        # Check if get_ipython() returns a shell instance (not None)
-        # and if the shell class is 'ZMQInteractiveShell' for Jupyter notebooks/qtconsole
-        # or 'TerminalInteractiveShell' for IPython console.
-        shell = get_ipython().__class__.__name__
-        if shell == "ZMQInteractiveShell":
-            return True  # Jupyter notebook or qtconsole
-        elif shell == "TerminalInteractiveShell":
-            return False  # IPython terminal
-        else:
-            return False  # Other IPython environment (less common for typical Jupyter detection)
-    except NameError:
-        return False  # Not running in IPython
-    except ImportError:
-        return False  # IPython is not installed
-
-
-class OverwriteStreamHandler(logging.StreamHandler):
-    def __init__(self, stream=None):
-        super().__init__(stream)
-
-        self._last_record = ""
-        self._last_message = ""
-
-        # Worst case: 2 complex emojis (8 chars each) + buffer = 21 extra chars
-        self._emoji_buffer = 21
-
-        self._is_jupyter = _is_jupyter()
-
-    def emit(self, record):
-        msg = self.format(record)
-
-        if record.message.startswith(r"\c"):
-            sep = r"\c"
-            msg = f"{msg.split(sep)[0]}{self._last_record} [{record.message[2:-2]}]\r"
-
-        if msg.endswith("\r\n"):
-            overwrite_and_newline = True
-            clean_msg = msg[:-2]
-
-            if not record.message.startswith("\c"):
-                self._last_record = record.message[:-2]
-        elif msg.endswith("\r"):
-            overwrite_and_newline = False
-            clean_msg = msg[:-1]
-
-            if not record.message.startswith(r"\c"):
-                self._last_record = record.message[:-1]
-        else:
-            # Normal message - no overwriting
-            self.stream.write(msg + "\n")
-            self.stream.flush()
-            return
-
-        # Clear previous line if needed
-        if len(self._last_message) > 0:
-            if self._is_jupyter:
-                clear_length = len(self._last_message) + self._emoji_buffer + 50
-            else:
-                clear_length = min(
-                    len(self._last_message) + self._emoji_buffer,
-                    shutil.get_terminal_size().columns,
-                )
-
-            self.stream.write("\r" + " " * clear_length + "\r")
-            self.stream.flush()
-
-        # Write message with appropriate ending
-        if overwrite_and_newline:
-            self.stream.write(clean_msg + "\n")
-            self._last_message = ""
-        else:
-            self.stream.write(clean_msg + "\r")
-            self._last_message = self._strip_ansi(clean_msg)
-
-        self.stream.flush()
-
-    def _strip_ansi(self, text):
-        """Remove ANSI escape sequences for accurate length calculation"""
-        import re
-
-        ansi_escape = re.compile(r"\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])")
-        return ansi_escape.sub("", text)
-
-
-def enable_logging(level=logging.INFO):
-    root_logger = logging.getLogger(__name__.split(".")[0])
-
-    formatter = logging.Formatter(
-        "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-    )
-
-    handler = OverwriteStreamHandler(sys.stdout)
-    handler.setFormatter(formatter)
-
-    root_logger.setLevel(level)
-    root_logger.handlers.clear()
-    root_logger.addHandler(handler)
-
-
-def disable_logging():
-    root_logger = logging.getLogger(__name__.split(".")[0])
-    root_logger.handlers.clear()
-    root_logger.setLevel(logging.CRITICAL + 1)

divi/qoro_service.py

@@ -1,343 +0,0 @@
-# SPDX-FileCopyrightText: 2025 Qoro Quantum Ltd <divi@qoroquantum.de>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-import base64
-import gzip
-import json
-import logging
-import time
-from collections.abc import Callable
-from enum import Enum
-from http import HTTPStatus
-from typing import Optional
-
-import requests
-from requests.adapters import HTTPAdapter, Retry
-
-from divi.interfaces import CircuitRunner
-
-API_URL = "https://app.qoroquantum.net/api"
-MAX_PAYLOAD_SIZE_MB = 0.95
-
-session = requests.Session()
-retries = 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))
-
-logger = logging.getLogger(__name__)
-
-
-class JobStatus(Enum):
-    PENDING = "PENDING"
-    RUNNING = "RUNNING"
-    COMPLETED = "COMPLETED"
-    FAILED = "FAILED"
-    CANCELLED = "CANCELLED"
-
-
-class JobType(Enum):
-    EXECUTE = "EXECUTE"
-    SIMULATE = "SIMULATE"
-    ESTIMATE = "ESTIMATE"
-    CIRCUIT_CUT = "CIRCUIT_CUT"
-
-
-class MaxRetriesReachedError(Exception):
-    """Exception raised when the maximum number of retries is reached."""
-
-    def __init__(self, retries, message="Maximum retries reached"):
-        self.retries = retries
-        self.message = f"{message}: {retries} retries attempted"
-        super().__init__(self.message)
-
-
-class QoroService(CircuitRunner):
-
-    def __init__(
-        self,
-        auth_token: str,
-        polling_interval: float = 3.0,
-        max_retries: int = 5000,
-        shots: int = 1000,
-        use_circuit_packing: Optional[bool] = False,
-    ):
-        super().__init__(shots=shots)
-
-        self.auth_token = "Bearer " + auth_token
-        self.polling_interval = polling_interval
-        self.max_retries = max_retries
-        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
-        )
-
-        if response.status_code != HTTPStatus.OK:
-            raise requests.exceptions.HTTPError(
-                f"Connection failed with error: {response.status_code}: {response.reason}"
-            )
-
-        return response
-
-    def submit_circuits(
-        self,
-        circuits: dict[str, str],
-        tag: str = "default",
-        job_type: JobType = JobType.SIMULATE,
-        override_circuit_packing: bool | None = None,
-    ):
-        """
-        Submit quantum circuits to the Qoro API for execution.
-
-        Args:
-            circuits (dict[str, str]):
-                Dictionary mapping unique circuit IDs to QASM circuit strings.
-            tag (str, optional):
-                Tag to associate with the job for identification. Defaults to "default".
-            job_type (JobType, optional):
-                Type of job to execute (e.g., SIMULATE, EXECUTE, ESTIMATE, CIRCUIT_CUT). Defaults to JobType.SIMULATE.
-            use_packing (bool):
-                Whether to use circuit packing optimization. Defaults to False.
-
-        Raises:
-            ValueError: If more than one circuit is submitted for a CIRCUIT_CUT job.
-
-        Returns:
-            str or list[str]:
-                The job ID(s) of the created job(s). Returns a single job ID if only one job is created,
-                otherwise returns a list of job IDs if the circuits are split into multiple jobs due to payload size.
-        """
-
-        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)
-
-            return circuit_chunks
-
-        circuit_chunks = _split_circuits(circuits)
-
-        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
-                    ),
-                },
-                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}"
-                )
-
-        return job_ids if len(job_ids) > 1 else job_ids[0]
-
-    def delete_job(self, job_ids):
-        """
-        Delete a job from the Qoro Database.
-
-        Args:
-            job_id: The ID of the jobs to be deleted
-        Returns:
-            response: The response from the API
-        """
-        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},
-                timeout=50,
-            )
-
-            responses.append(response)
-
-        return responses if len(responses) > 1 else responses[0]
-
-    def get_job_results(self, job_ids):
-        """
-        Get the results of a job from the Qoro Database.
-
-        Args:
-            job_id: The ID of the job to get results from
-        Returns:
-            results: The results of the job
-        """
-        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},
-                timeout=100,
-            )
-            responses.append(response)
-
-        if all(response.status_code == HTTPStatus.OK for response in responses):
-            responses = [response.json() for response in responses]
-            return sum(responses, [])
-        elif any(
-            response.status_code == HTTPStatus.BAD_REQUEST for response in responses
-        ):
-            raise requests.exceptions.HTTPError(
-                "400 Bad Request: Job results not available, likely job is still running"
-            )
-        else:
-            for response in responses:
-                if response.status_code not in [HTTPStatus.OK, HTTPStatus.BAD_REQUEST]:
-                    raise requests.exceptions.HTTPError(
-                        f"{response.status_code}: {response.reason}"
-                    )
-
-    def poll_job_status(
-        self,
-        job_ids: str | list[str],
-        loop_until_complete: bool = False,
-        on_complete: Optional[Callable] = None,
-        verbose: bool = True,
-        pbar_update_fn: Optional[Callable] = None,
-    ):
-        """
-        Get the status of a job and optionally execute function *on_complete* on the results
-        if the status is COMPLETE.
-
-        Args:
-            job_ids: The job id of the jobs to check
-            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:
-            status: The status of the job
-        """
-        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 response.status_code == HTTPStatus.OK:
-                return response.json()["status"], response
-            else:
-                raise requests.exceptions.HTTPError(
-                    f"{response.status_code}: {response.reason}"
-                )
-
-        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)
-                    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
-
-                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 completed and on_complete:
-                on_complete(responses)
-                return JobStatus.COMPLETED
-            elif completed:
-                return JobStatus.COMPLETED
-            else:
-                raise MaxRetriesReachedError(retries)
-        else:
-            statuses = [_poll_job_status(job_id)[0] for job_id in job_ids]
-            return statuses if len(statuses) > 1 else statuses[0]

divi/qprog/_mlae.py

@@ -1,182 +0,0 @@
-# SPDX-FileCopyrightText: 2025 Qoro Quantum Ltd <divi@qoroquantum.de>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from functools import reduce
-
-import numpy as np
-import scipy.optimize as optimize
-from qiskit import QuantumCircuit
-from qiskit_algorithms import EstimationProblem, MaximumLikelihoodAmplitudeEstimation
-
-from divi.circuits import Circuit
-from divi.qprog.quantum_program import QuantumProgram
-
-
-class BernoulliA(QuantumCircuit):
-    """A circuit representing the Bernoulli A operator."""
-
-    def __init__(self, probability):
-        super().__init__(1)
-
-        theta_p = 2 * np.arcsin(np.sqrt(probability))
-        self.ry(theta_p, 0)
-
-
-class BernoulliQ(QuantumCircuit):
-    """A circuit representing the Bernoulli Q operator."""
-
-    def __init__(self, probability):
-        super().__init__(1)
-
-        self._theta_p = 2 * np.arcsin(np.sqrt(probability))
-        self.ry(2 * self._theta_p, 0)
-
-    def power(self, k):
-        # implement the efficient power of Q
-        q_k = QuantumCircuit(1)
-        q_k.ry(2 * k * self._theta_p, 0)
-        return q_k
-
-
-class MLAE(QuantumProgram):
-    """
-    An implementation of the Maximum Likelihood Amplitude Estimateion described in
-    https://arxiv.org/pdf/1904.10246
-    """
-
-    def __init__(
-        self,
-        grovers: list[int],
-        qubits_to_measure: list[int],
-        probability: float,
-        **kwargs,
-    ):
-        """
-        Initializes the MLAE problem.
-        args:
-            grovers (list): A list of non-negative integers corresponding to the powers of the Grover
-            operator for each iteration
-            qubits: An integer or list of integers containing the index of the qubits to measure
-            probability: The probability of being in the good state to estimate
-            shots: The number of shots to run for each circuit. Default set at 5000.
-        """
-
-        super().__init__(**kwargs)
-
-        self.grovers = grovers
-        self.qubits_to_measure = qubits_to_measure
-        self.probability = probability
-        self.likelihood_functions = []
-
-    def _create_meta_circuits_dict(self):
-        return super()._create_meta_circuits_dict()
-
-    def _generate_circuits(self, params=None, **kwargs):
-        """
-        Generates the circuits that perform step one of the MLAE algorithm,
-            the quantum amplitude amplification.
-
-        Inputs a selection of m values corresponding to the powers of the
-            Grover operatorfor each iteration.
-
-        Returns:
-            A list of QASM circuits to run on various devices
-        """
-        self.circuits.clear()
-
-        A = BernoulliA(self.probability)
-        Q = BernoulliQ(self.probability)
-
-        problem = EstimationProblem(
-            state_preparation=A,
-            grover_operator=Q,
-            objective_qubits=self.qubits_to_measure,
-        )
-
-        qiskit_circuits = MaximumLikelihoodAmplitudeEstimation(
-            self.grovers
-        ).construct_circuits(problem)
-
-        for circuit, grover in zip(qiskit_circuits, self.grovers):
-            circuit.measure_all()
-            self.circuits.append(Circuit(circuit, tags=[f"{grover}"]))
-
-    def run(self, store_data=False, data_file=None):
-        self._generate_circuits()
-        self._dispatch_circuits_and_process_results(
-            store_data=store_data, data_file=data_file
-        )
-
-    def _post_process_results(self, results):
-        """
-        Generates the likelihood function for each circuit of the quantum
-        amplitude amplification. These likelihood functions will then
-        be combined to create a maximum likelihood function to analyze.
-
-        Returns:
-            A callable maximum likelihood function
-        """
-
-        # Define the necessary variables Nk, Mk, Lk
-        for label, shots_dict in results.items():
-            mk = int(label)
-            Nk = 0
-            hk = 0
-            for key, shots in shots_dict.items():
-                Nk += shots
-                hk += shots if key.count("1") == len(key) else 0
-
-            def likelihood_function(theta, mk=mk, hk=hk, Nk=Nk):
-                as_theta = np.arcsin(np.sqrt(theta))
-                return ((np.sin((2 * mk + 1) * as_theta)) ** (2 * hk)) * (
-                    (np.cos((2 * mk + 1) * as_theta)) ** (2 * (Nk - hk))
-                )
-
-            self.likelihood_functions.append(likelihood_function)
-
-    def generate_maximum_likelihood_function(self, factor=1.0):
-        """
-        Post-processing takes in likelihood functions.
-
-        A large factor (e.g. 1e200) should be used for visualization purposes.
-        Returns:
-            The maximum likelihood function.
-        """
-
-        def combined_likelihood_function(theta):
-            return (
-                reduce(
-                    lambda result, f: result * f(theta), self.likelihood_functions, 1.0
-                )
-                * factor
-            )
-
-        self.maximum_likelihood_fn = combined_likelihood_function
-
-        return combined_likelihood_function
-
-    def estimate_amplitude(self, factor):
-        """
-        Uses the maximum likelihood function to ascertain
-        a value for the amplitude.
-
-        Returns
-            Estimation of the amplitude
-        """
-
-        def minimum_likelihood_function(theta):
-            # The factor to set to -10e30 in the older branch
-            return (
-                reduce(
-                    lambda result, f: result * f(theta), self.likelihood_functions, 1.0
-                )
-                * factor
-            )
-
-        # create the range of possible amplitudes
-        amplitudes = np.linspace(0, 1, 100)
-
-        bounds = [(min(amplitudes), max(amplitudes))]
-
-        return optimize.differential_evolution(minimum_likelihood_function, bounds).x[0]