qoro-divi 0.3.1b0__tar.gz → 0.3.3__tar.gz

{qoro_divi-0.3.1b0 → qoro_divi-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: qoro-divi
-Version: 0.3.1b0
+Version: 0.3.3
 Summary: A Python library to automate generating, parallelizing, and executing quantum programs.
 Author: Ahmed Darwish
 Author-email: ahmed@qoroquantum.de
@@ -14,14 +14,14 @@ 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: networkx (>=3.5,<4.0)
-Requires-Dist: pennylane (>=0.40,<0.41)
+Requires-Dist: pennylane (>=0.42.3,<0.43.0)
 Requires-Dist: ply (>=3.11,<4.0)
 Requires-Dist: pymetis (>=2025.1.1,<2026.0.0)
 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-ibm-runtime (>=0.37,<0.38)
-Requires-Dist: qiskit-optimization (>=0.6.1,<0.7.0)
+Requires-Dist: qiskit-optimization[cplex] (>=0.7.0,<0.8.0)
 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)

{qoro_divi-0.3.1b0 → qoro_divi-0.3.3}/divi/_pbar.py

@@ -28,12 +28,9 @@ class ConditionalSpinnerColumn(ProgressColumn):
 
 
 class PhaseStatusColumn(ProgressColumn):
-    def __init__(self, max_retries: int, table_column=None):
+    def __init__(self, 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")
 
@@ -43,27 +40,29 @@ class PhaseStatusColumn(ProgressColumn):
             return Text("• Failed! ❌", style="bold red")
 
         message = task.fields.get("message")
-        if message != "":
-            self._last_message = message
 
         poll_attempt = task.fields.get("poll_attempt")
+        polling_str = ""
+        service_job_id = ""
         if poll_attempt > 0:
-            return Text(
-                f"[{self._last_message}] Polling {poll_attempt}/{self._max_retries}"
-            )
+            max_retries = task.fields.get("max_retries")
+            service_job_id = task.fields.get("service_job_id").split("-")[0]
+            job_status = task.fields.get("job_status")
+            polling_str = f" [Job {service_job_id} is {job_status}. Polling attempt {poll_attempt} / {max_retries}]"
+
+        final_text = Text(f"[{message}]{polling_str}")
+        final_text.highlight_words([service_job_id], "blue")
 
-        return Text(f"[{self._last_message}]")
+        return final_text
 
 
-def make_progress_bar(
-    max_retries: int | None = None, is_jupyter: bool = False
-) -> Progress:
+def make_progress_bar(is_jupyter: bool = False) -> Progress:
     return Progress(
         TextColumn("[bold blue]{task.fields[job_name]}"),
         BarColumn(),
         MofNCompleteColumn(),
         ConditionalSpinnerColumn(),
-        PhaseStatusColumn(max_retries=max_retries),
+        PhaseStatusColumn(),
         # For jupyter notebooks, refresh manually instead
         auto_refresh=not is_jupyter,
         # Give a dummy positive value if is_jupyter

{qoro_divi-0.3.1b0 → qoro_divi-0.3.3}/divi/exp/cirq/__init__.py

@@ -5,4 +5,4 @@
 # 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
-from ._validator import is_valid_qasm
+from ._validator import is_valid_qasm, validate_qasm_raise

{qoro_divi-0.3.1b0 → qoro_divi-0.3.3}/divi/exp/cirq/_validator.py

@@ -558,7 +558,7 @@ class Parser:
             self._expr_power(allow_id)
 
     def _expr_unary(self, allow_id: bool):
-        if self.peek().type in ("PLUS", "MINUS"):
+        while self.peek().type in ("PLUS", "MINUS"):
             self.match(self.peek().type)
         self._expr_atom(allow_id)
 

{qoro_divi-0.3.1b0 → qoro_divi-0.3.3}/divi/qlogger.py

@@ -44,22 +44,23 @@ class OverwriteStreamHandler(logging.StreamHandler):
 
     def emit(self, record):
         msg = self.format(record)
+        append = getattr(record, "append", False)
 
-        if record.message.startswith(r"\c"):
-            sep = r"\c"
-            msg = f"{msg.split(sep)[0]}{self._last_record} [{record.message[2:-2]}]\r"
+        if append:
+            space = " " if self._last_record else ""
+            msg = f"{msg[:msg.index(record.message)]}{self._last_record}{space}[{record.message[:-2]}]\r"
 
         if msg.endswith("\r\n"):
             overwrite_and_newline = True
             clean_msg = msg[:-2]
 
-            if not record.message.startswith("\c"):
+            if not append:
                 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"):
+            if not append:
                 self._last_record = record.message[:-1]
         else:
             # Normal message - no overwriting

{qoro_divi-0.3.1b0 → qoro_divi-0.3.3}/divi/qoro_service.py

@@ -15,7 +15,7 @@ import requests
 from dotenv import dotenv_values
 from requests.adapters import HTTPAdapter, Retry
 
-from divi.exp.cirq import is_valid_qasm
+from divi.exp.cirq import validate_qasm_raise
 from divi.interfaces import CircuitRunner
 from divi.qpu_system import QPU, QPUSystem
 
@@ -241,8 +241,9 @@ class QoroService(CircuitRunner):
             raise ValueError("Only one circuit allowed for circuit-cutting jobs.")
 
         for key, circuit in circuits.items():
-            if not is_valid_qasm(circuit):
-                raise ValueError(f"Circuit {key} is not a valid QASM string.")
+            validate_qasm_raise(circuit)
+            # if not is_valid_qasm(circuit):
+            #     raise ValueError(f"Circuit {key} is not a valid QASM string.")
 
         circuit_chunks = self._split_circuits(circuits)
 
@@ -342,7 +343,7 @@ class QoroService(CircuitRunner):
         loop_until_complete: bool = False,
         on_complete: Callable | None = None,
         verbose: bool = True,
-        pbar_update_fn: Callable | None = None,
+        poll_callback: Callable[[int, str], None] | None = None,
     ):
         """
         Get the status of a job and optionally execute function *on_complete* on the results
@@ -354,13 +355,28 @@ class QoroService(CircuitRunner):
             on_complete (optional): A function to be called when the job is completed
             polling_interval (optional): The time to wait between retries
             verbose (optional): A flag to print the when retrying
-            pbar_update_fn (optional): A function for updating progress bars while polling.
+            poll_callback (optional): A function for updating progress bars while polling.
+                Definition should be `poll_callback(retry_count: int, status: str) -> None`.
         Returns:
             status: The status of the job
         """
         if not isinstance(job_ids, list):
             job_ids = [job_ids]
 
+        # Decide once at the start
+        if poll_callback:
+            update_fn = poll_callback
+        elif verbose:
+            CYAN = "\033[36m"
+            RESET = "\033[0m"
+
+            update_fn = lambda retry_count, status: logger.info(
+                rf"Job {CYAN}{job_ids[0].split('-')[0]}{RESET} is {status}. Polling attempt {retry_count} / {self.max_retries}\r",
+                extra={"append": True},
+            )
+        else:
+            update_fn = lambda _, __: None
+
         if not loop_until_complete:
             statuses = [
                 self._make_request(
@@ -386,7 +402,10 @@ class QoroService(CircuitRunner):
                     timeout=200,
                 )
 
-                if response.json()["status"] == JobStatus.COMPLETED.value:
+                if response.json()["status"] in (
+                    JobStatus.COMPLETED.value,
+                    JobStatus.FAILED.value,
+                ):
                     pending_job_ids.remove(job_id)
                     responses.append(response)
 
@@ -396,13 +415,7 @@ class QoroService(CircuitRunner):
 
             time.sleep(self.polling_interval)
 
-            if verbose:
-                if pbar_update_fn:
-                    pbar_update_fn(retry_count)
-                else:
-                    logger.info(
-                        rf"\cPolling {retry_count} / {self.max_retries} retries\r"
-                    )
+            update_fn(retry_count, response.json()["status"])
 
         if not pending_job_ids:
             if on_complete:

{qoro_divi-0.3.1b0 → qoro_divi-0.3.3}/divi/qprog/__init__.py

@@ -10,4 +10,4 @@ from ._vqe import VQE, VQEAnsatz
 from ._graph_partitioning import GraphPartitioningQAOA, PartitioningConfig
 from ._qubo_partitioning import QUBOPartitioningQAOA
 from ._vqe_sweep import VQEHyperparameterSweep, MoleculeTransformer
-from .optimizers import Optimizer
+from .optimizers import ScipyOptimizer, ScipyMethod, MonteCarloOptimizer

{qoro_divi-0.3.1b0 → qoro_divi-0.3.3}/divi/qprog/_graph_partitioning.py

@@ -21,16 +21,14 @@ from pymetis import part_graph
 from sklearn.cluster import SpectralClustering
 
 from divi.interfaces import CircuitRunner
-from divi.qprog import QAOA, ProgramBatch
+from divi.qprog import QAOA, ProgramBatch, QuantumProgram
 from divi.qprog._qaoa import (
     _SUPPORTED_INITIAL_STATES_LITERAL,
     GraphProblem,
     GraphProblemTypes,
     draw_graph_solution_nodes,
 )
-from divi.qprog.quantum_program import QuantumProgram
-
-from .optimizers import Optimizer
+from divi.qprog.optimizers import MonteCarloOptimizer, Optimizer
 
 AggregateFn = Callable[
     [list[int], str, nx.Graph | rx.PyGraph, dict[int, int]], list[int]
@@ -390,7 +388,6 @@ def dominance_aggregation(
 
 
 def _run_and_compute_solution(program: QuantumProgram):
-
     program.run()
 
     final_sol_circuit_count, final_sol_run_time = program.compute_final_solution()
@@ -408,7 +405,7 @@ class GraphPartitioningQAOA(ProgramBatch):
         partitioning_config: PartitioningConfig,
         initial_state: _SUPPORTED_INITIAL_STATES_LITERAL = "Recommended",
         aggregate_fn: AggregateFn = linear_aggregation,
-        optimizer=Optimizer.MONTE_CARLO,
+        optimizer: Optimizer | None = None,
         max_iterations=10,
         **kwargs,
     ):
@@ -452,7 +449,7 @@ class GraphPartitioningQAOA(ProgramBatch):
             QAOA,
             initial_state=initial_state,
             graph_problem=graph_problem,
-            optimizer=optimizer,
+            optimizer=optimizer if optimizer is not None else MonteCarloOptimizer(),
             max_iterations=self.max_iterations,
             backend=self.backend,
             n_layers=n_layers,

{qoro_divi-0.3.1b0 → qoro_divi-0.3.3}/divi/qprog/_qaoa.py

@@ -23,7 +23,7 @@ from qiskit_optimization.problems import VarType
 
 from divi.circuits import MetaCircuit
 from divi.qprog import QuantumProgram
-from divi.qprog.optimizers import Optimizer
+from divi.qprog.optimizers import MonteCarloOptimizer, Optimizer
 from divi.utils import convert_qubo_matrix_to_pennylane_ising
 
 logger = logging.getLogger(__name__)
@@ -153,10 +153,11 @@ class QAOA(QuantumProgram):
     def __init__(
         self,
         problem: GraphProblemTypes | QUBOProblemTypes,
+        *,
         graph_problem: GraphProblem | None = None,
         n_layers: int = 1,
         initial_state: _SUPPORTED_INITIAL_STATES_LITERAL = "Recommended",
-        optimizer: Optimizer = Optimizer.MONTE_CARLO,
+        optimizer: Optimizer | None = None,
         max_iterations: int = 10,
         **kwargs,
     ):
@@ -221,11 +222,11 @@ class QAOA(QuantumProgram):
 
         # Local Variables
         self.n_layers = n_layers
-        self.optimizer = optimizer
         self.max_iterations = max_iterations
         self.current_iteration = 0
         self.n_params = 2
         self._is_compute_probabilites = False
+        self.optimizer = optimizer if optimizer is not None else MonteCarloOptimizer()
 
         # Shared Variables
         self.probs = kwargs.pop("probs", {})
@@ -245,10 +246,17 @@ class QAOA(QuantumProgram):
         )
         self.problem_metadata = problem_metadata[0] if problem_metadata else {}
 
-        self.loss_constant = self.problem_metadata.get("constant", 0.0)
+        if "constant" in self.problem_metadata:
+            self.loss_constant = self.problem_metadata.get("constant")
+            try:
+                self.loss_constant = self.loss_constant.item()
+            except AttributeError:
+                pass
+        else:
+            self.loss_constant = 0.0
 
         kwargs.pop("is_constrained", None)
-        super().__init__(**kwargs)
+        super().__init__(has_final_computation=True, **kwargs)
 
         self._meta_circuits = self._create_meta_circuits_dict()
 
@@ -387,16 +395,7 @@ class QAOA(QuantumProgram):
             - float: The total runtime of the optimization process.
         """
 
-        if self._progress_queue:
-            self._progress_queue.put(
-                {
-                    "job_id": self.job_id,
-                    "message": "🏁 Computing Final Solution 🏁",
-                    "progress": 0,
-                }
-            )
-        else:
-            logger.info("🏁 Computing Final Solution 🏁")
+        self.reporter.info(message="🏁 Computing Final Solution 🏁")
 
         # Convert losses dict to list to apply ordinal operations
         final_losses_list = list(self.losses[-1].values())
@@ -440,16 +439,7 @@ class QAOA(QuantumProgram):
                 m.start() for m in re.finditer("1", best_solution_bitstring)
             ]
 
-        if self._progress_queue:
-            self._progress_queue.put(
-                {
-                    "job_id": self.job_id,
-                    "progress": 0,
-                    "final_status": "Success",
-                }
-            )
-        else:
-            logger.info(f"Computed Solution!")
+        self.reporter.info(message="Computed Final Solution!")
 
         return self._total_circuit_count, self._total_run_time
 

{qoro_divi-0.3.1b0 → qoro_divi-0.3.3}/divi/qprog/_qubo_partitioning.py

@@ -15,7 +15,7 @@ from dimod import BinaryQuadraticModel
 from divi.interfaces import CircuitRunner
 from divi.qprog._qaoa import QAOA, QUBOProblemTypes
 from divi.qprog.batch import ProgramBatch
-from divi.qprog.optimizers import Optimizer
+from divi.qprog.optimizers import MonteCarloOptimizer, Optimizer
 from divi.qprog.quantum_program import QuantumProgram
 
 
@@ -50,7 +50,6 @@ def _sanitize_problem_input(qubo: T) -> tuple[T, BinaryQuadraticModel]:
 
 
 def _run_and_compute_solution(program: QuantumProgram):
-
     program.run()
 
     final_sol_circuit_count, final_sol_run_time = program.compute_final_solution()
@@ -66,8 +65,8 @@ class QUBOPartitioningQAOA(ProgramBatch):
         n_layers: int,
         backend: CircuitRunner,
         composer: hybrid.traits.SubsamplesComposer = hybrid.SplatComposer(),
-        optimizer=Optimizer.MONTE_CARLO,
-        max_iterations=10,
+        optimizer: Optimizer | None = None,
+        max_iterations: int = 10,
         **kwargs,
     ):
         """
@@ -101,7 +100,7 @@ class QUBOPartitioningQAOA(ProgramBatch):
 
         self._constructor = partial(
             QAOA,
-            optimizer=optimizer,
+            optimizer=optimizer if optimizer is not None else MonteCarloOptimizer(),
             max_iterations=self.max_iterations,
             backend=self.backend,
             n_layers=n_layers,

{qoro_divi-0.3.1b0 → qoro_divi-0.3.3}/divi/qprog/_vqe.py

@@ -10,7 +10,7 @@ import sympy as sp
 
 from divi.circuits import MetaCircuit
 from divi.qprog import QuantumProgram
-from divi.qprog.optimizers import Optimizer
+from divi.qprog.optimizers import MonteCarloOptimizer, Optimizer
 
 
 class VQEAnsatz(Enum):
@@ -50,7 +50,7 @@ class VQE(QuantumProgram):
         n_electrons: int | None = None,
         n_layers: int = 1,
         ansatz=VQEAnsatz.HARTREE_FOCK,
-        optimizer=Optimizer.MONTE_CARLO,
+        optimizer: Optimizer | None = None,
         max_iterations=10,
         **kwargs,
     ) -> None:
@@ -71,10 +71,11 @@ class VQE(QuantumProgram):
         self.n_layers = n_layers
         self.results = {}
         self.ansatz = ansatz
-        self.optimizer = optimizer
         self.max_iterations = max_iterations
         self.current_iteration = 0
 
+        self.optimizer = optimizer if optimizer is not None else MonteCarloOptimizer()
+
         self._process_problem_input(
             hamiltonian=hamiltonian, molecule=molecule, n_electrons=n_electrons
         )
@@ -137,8 +138,8 @@ class VQE(QuantumProgram):
             )
         )
 
-        self.loss_constant = sum(
-            map(lambda x: hamiltonian[x].scalar, constant_terms_idx)
+        self.loss_constant = float(
+            sum(map(lambda x: hamiltonian[x].scalar, constant_terms_idx))
         )
 
         for idx in constant_terms_idx:

{qoro_divi-0.3.1b0 → qoro_divi-0.3.3}/divi/qprog/_vqe_sweep.py

@@ -15,8 +15,7 @@ import numpy as np
 import pennylane as qml
 
 from divi.qprog import VQE, ProgramBatch, VQEAnsatz
-
-from .optimizers import Optimizer
+from divi.qprog.optimizers import MonteCarloOptimizer, Optimizer
 
 
 def _ctor_attrs(obj):
@@ -395,7 +394,7 @@ class VQEHyperparameterSweep(ProgramBatch):
         self,
         ansatze: Sequence[VQEAnsatz],
         molecule_transformer: MoleculeTransformer,
-        optimizer: Optimizer = Optimizer.MONTE_CARLO,
+        optimizer: Optimizer | None = None,
         max_iterations: int = 10,
         **kwargs,
     ):
@@ -424,7 +423,7 @@ class VQEHyperparameterSweep(ProgramBatch):
 
         self._constructor = partial(
             VQE,
-            optimizer=optimizer,
+            optimizer=optimizer if optimizer is not None else MonteCarloOptimizer(),
             max_iterations=self.max_iterations,
             backend=self.backend,
             **kwargs,

{qoro_divi-0.3.1b0 → qoro_divi-0.3.3}/divi/qprog/batch.py

@@ -10,6 +10,7 @@ from multiprocessing import Event, Manager
 from multiprocessing.synchronize import Event as EventClass
 from queue import Empty, Queue
 from threading import Lock, Thread
+from typing import Any
 from warnings import warn
 
 from rich.console import Console
@@ -32,7 +33,7 @@ def queue_listener(
 ):
     while not done_event.is_set():
         try:
-            msg = queue.get(timeout=0.1)
+            msg: dict[str, Any] = queue.get(timeout=0.1)
         except Empty:
             continue
         except Exception as e:
@@ -42,14 +43,25 @@ def queue_listener(
         with lock:
             task_id = pb_task_map[msg["job_id"]]
 
-        progress_bar.update(
-            task_id,
-            advance=msg["progress"],
-            poll_attempt=msg.get("poll_attempt", 0),
-            message=msg.get("message", ""),
-            final_status=msg.get("final_status", ""),
-            refresh=is_jupyter,
-        )
+        # Prepare update arguments, starting with progress.
+        update_args = {"advance": msg["progress"]}
+
+        if "poll_attempt" in msg:
+            update_args["poll_attempt"] = msg.get("poll_attempt", 0)
+        if "max_retries" in msg:
+            update_args["max_retries"] = msg.get("max_retries")
+        if "service_job_id" in msg:
+            update_args["service_job_id"] = msg.get("service_job_id")
+        if "job_status" in msg:
+            update_args["job_status"] = msg.get("job_status")
+        if msg.get("message"):
+            update_args["message"] = msg.get("message")
+        if "final_status" in msg:
+            update_args["final_status"] = msg.get("final_status", "")
+
+        update_args["refresh"] = is_jupyter
+
+        progress_bar.update(task_id, **update_args)
 
 
 def _default_task_function(program: QuantumProgram):
@@ -182,10 +194,7 @@ class ProgramBatch(ABC):
             raise RuntimeError("No programs to run.")
 
         self._progress_bar = (
-            make_progress_bar(
-                max_retries=None if self._is_local else self.backend.max_retries,
-                is_jupyter=self._is_jupyter,
-            )
+            make_progress_bar(is_jupyter=self._is_jupyter)
             if hasattr(self, "max_iterations")
             else None
         )
@@ -217,8 +226,7 @@ class ProgramBatch(ABC):
         if not blocking:
             # Arm safety net
             atexit.register(self._atexit_cleanup_hook)
-
-        if blocking:
+        else:
             self.join()
 
         return self