qoro-divi 0.3.2b0__tar.gz → 0.3.4__tar.gz

{qoro_divi-0.3.2b0 → qoro_divi-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: qoro-divi
-Version: 0.3.2b0
+Version: 0.3.4
 Summary: A Python library to automate generating, parallelizing, and executing quantum programs.
 Author: Ahmed Darwish
 Author-email: ahmed@qoroquantum.de
@@ -21,7 +21,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-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.2b0 → qoro_divi-0.3.4}/divi/__init__.py

@@ -2,7 +2,6 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from .qlogger import enable_logging
-from .qoro_service import QoroService
+from .reporting import enable_logging
 
 enable_logging()

qoro_divi-0.3.4/divi/backends/__init__.py

@@ -0,0 +1,7 @@
+# SPDX-FileCopyrightText: 2025 Qoro Quantum Ltd <divi@qoroquantum.de>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from ._circuit_runner import CircuitRunner
+from ._parallel_simulator import ParallelSimulator
+from ._qoro_service import JobStatus, JobType, QoroService

qoro_divi-0.3.2b0/divi/parallel_simulator.py → qoro_divi-0.3.4/divi/backends/_parallel_simulator.py

@@ -18,7 +18,7 @@ from qiskit.providers import Backend
 from qiskit_aer import AerSimulator
 from qiskit_aer.noise import NoiseModel
 
-from divi.interfaces import CircuitRunner
+from divi.backends import CircuitRunner
 
 logger = logging.getLogger(__name__)
 
@@ -74,8 +74,9 @@ class ParallelSimulator(CircuitRunner):
             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 (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.
+            qiskit_backend (Backend | Literal["auto"] | None, 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.
         """
         super().__init__(shots=shots)

qoro_divi-0.3.2b0/divi/qoro_service.py → qoro_divi-0.3.4/divi/backends/_qoro_service.py

@@ -15,9 +15,9 @@ 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
+from divi.backends import CircuitRunner
+from divi.backends._qpu_system import QPU, QPUSystem
+from divi.extern.cirq import is_valid_qasm
 
 API_URL = "https://app.qoroquantum.net/api"
 MAX_PAYLOAD_SIZE_MB = 0.95
@@ -241,8 +241,8 @@ 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.")
+            if not (err := is_valid_qasm(circuit)):
+                raise ValueError(f"Circuit '{key}' is not a valid QASM: {err}")
 
         circuit_chunks = self._split_circuits(circuits)
 
@@ -342,7 +342,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 +354,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 +401,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 +414,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.4/divi/circuits/__init__.py

@@ -0,0 +1,5 @@
+# SPDX-FileCopyrightText: 2025 Qoro Quantum Ltd <divi@qoroquantum.de>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from ._core import Circuit, MetaCircuit

qoro_divi-0.3.2b0/divi/circuits.py → qoro_divi-0.3.4/divi/circuits/_core.py

@@ -10,10 +10,9 @@ from typing import Literal
 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
+from divi.circuits.qasm import to_openqasm
+from divi.circuits.qem import QEMProtocol
 
 TRANSFORM_PROGRAM = TransformProgram()
 TRANSFORM_PROGRAM.add_transform(qml.transforms.split_to_single_terms)
@@ -30,35 +29,22 @@ class Circuit:
         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)]
+        self.circuit_id = Circuit._id_counter
+        Circuit._id_counter += 1
 
-        else:
-            raise ValueError(
-                f"Invalid circuit type. Circuit type {self.circuit_type} not currently supported."
-            )
+    def __str__(self):
+        return f"Circuit: {self.circuit_id}"
 
 
 class MetaCircuit:

{qoro_divi-0.3.2b0/divi → qoro_divi-0.3.4/divi/circuits}/qasm.py

@@ -14,8 +14,8 @@ from pennylane.tape import QuantumScript
 from pennylane.wires import Wires
 from sympy import Symbol
 
-from divi.exp.cirq import cirq_circuit_from_qasm
-from divi.qem import QEMProtocol
+from divi.circuits.qem import QEMProtocol
+from divi.extern.cirq import cirq_circuit_from_qasm
 
 OPENQASM_GATES = {
     "CNOT": "cx",

{qoro_divi-0.3.2b0/divi/exp → qoro_divi-0.3.4/divi/extern}/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.2b0/divi/exp → qoro_divi-0.3.4/divi/extern}/cirq/_validator.py

@@ -289,7 +289,12 @@ class Parser:
     # ---- gate definitions ----
     def gate_def(self):
         self.match("GATE")
-        gname = self.match("ID").value
+        gname_tok = self.match("ID")
+        gname = gname_tok.value
+        if gname in BUILTINS:
+            raise SyntaxError(
+                f"Cannot redefine built-in gate '{gname}' at {gname_tok.line}:{gname_tok.col}"
+            )
         if gname in self.user_gates:
             self._dupe(gname)
         params: tuple[str, ...] = ()
@@ -558,7 +563,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)
 
@@ -570,7 +575,6 @@ class Parser:
         if t.type == "PI":
             self.match("PI")
             return
-        # ---- NEW BLOCK TO HANDLE MATH FUNCTIONS ----
         if t.type in _MATH_FUNCS:
             self.match(t.type)  # Consume the function name (e.g., COS)
             self.match("LPAREN")
@@ -578,13 +582,11 @@ class Parser:
             # Note: QASM 2.0 math functions only take one argument
             self.match("RPAREN")
             return
-        # --------------------------------------------
         if t.type == "ID":
             # function call or plain ID
             id_tok = self.match("ID")
             ident = id_tok.value
             if self.accept("LPAREN"):
-                # This now correctly handles user-defined functions (if any)
                 if self.peek().type != "RPAREN":
                     self._expr(allow_id)
                     while self.accept("COMMA"):
@@ -637,9 +639,9 @@ def validate_qasm_raise(src: str) -> None:
     Parser(toks).parse()
 
 
-def is_valid_qasm(src: str) -> bool:
+def is_valid_qasm(src: str) -> bool | str:
     try:
         validate_qasm_raise(src)
         return True
-    except SyntaxError:
-        return False
+    except SyntaxError as e:
+        return str(e)

qoro_divi-0.3.4/divi/qprog/__init__.py

@@ -0,0 +1,26 @@
+# SPDX-FileCopyrightText: 2025 Qoro Quantum Ltd <divi@qoroquantum.de>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+# isort: skip_file
+from .quantum_program import QuantumProgram
+from .batch import ProgramBatch
+from .algorithms import (
+    QAOA,
+    GraphProblem,
+    VQE,
+    Ansatz,
+    UCCSDAnsatz,
+    QAOAAnsatz,
+    HardwareEfficientAnsatz,
+    HartreeFockAnsatz,
+    GenericLayerAnsatz,
+)
+from .workflows import (
+    GraphPartitioningQAOA,
+    PartitioningConfig,
+    QUBOPartitioningQAOA,
+    VQEHyperparameterSweep,
+    MoleculeTransformer,
+)
+from .optimizers import ScipyOptimizer, ScipyMethod, MonteCarloOptimizer

qoro_divi-0.3.4/divi/qprog/algorithms/__init__.py

@@ -0,0 +1,14 @@
+# SPDX-FileCopyrightText: 2025 Qoro Quantum Ltd <divi@qoroquantum.de>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from ._ansatze import (
+    Ansatz,
+    GenericLayerAnsatz,
+    HardwareEfficientAnsatz,
+    HartreeFockAnsatz,
+    QAOAAnsatz,
+    UCCSDAnsatz,
+)
+from ._qaoa import QAOA, GraphProblem, GraphProblemTypes, QUBOProblemTypes
+from ._vqe import VQE

qoro_divi-0.3.4/divi/qprog/algorithms/_ansatze.py

@@ -0,0 +1,215 @@
+# SPDX-FileCopyrightText: 2025 Qoro Quantum Ltd <divi@qoroquantum.de>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from abc import ABC, abstractmethod
+from itertools import tee
+from typing import Literal, Sequence
+from warnings import warn
+
+import pennylane as qml
+
+
+class Ansatz(ABC):
+    """Abstract base class for all VQE ansaetze."""
+
+    @property
+    def name(self) -> str:
+        """Returns the human-readable name of the ansatz."""
+        return self.__class__.__name__
+
+    @staticmethod
+    @abstractmethod
+    def n_params_per_layer(n_qubits: int, **kwargs) -> int:
+        """Returns the number of parameters required by the ansatz for one layer."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def build(self, params, n_qubits: int, n_layers: int, **kwargs):
+        """
+        Builds the ansatz circuit.
+
+        Args:
+            params (array): The parameters (weights) for the ansatz.
+            n_qubits (int): The number of qubits.
+            n_layers (int): The number of layers.
+            **kwargs: Additional arguments like n_electrons for chemistry ansaetze.
+        """
+        raise NotImplementedError
+
+
+# --- Template Ansaetze ---
+
+
+class GenericLayerAnsatz(Ansatz):
+    """
+    A flexible ansatz alternating single-qubit gates with optional entanglers.
+    """
+
+    def __init__(
+        self,
+        gate_sequence: list[qml.operation.Operator],
+        entangler: qml.operation.Operator | None = None,
+        entangling_layout: (
+            Literal["linear", "brick", "circular", "all-to-all"]
+            | Sequence[tuple[int, int]]
+            | None
+        ) = None,
+    ):
+        """
+        Args:
+            gate_sequence (list[Callable]): List of one-qubit gate classes (e.g., qml.RY, qml.Rot).
+            entangler (Callable): Two-qubit entangling gate class (e.g., qml.CNOT, qml.CZ).
+                                  If None, no entanglement is applied.
+            entangling_layout (str): Layout for entangling layer ("linear", "all_to_all", etc.).
+        """
+        if not all(
+            issubclass(g, qml.operation.Operator) and g.num_wires == 1
+            for g in gate_sequence
+        ):
+            raise ValueError(
+                "All elements in gate_sequence must be PennyLane one-qubit gate classes."
+            )
+        self.gate_sequence = gate_sequence
+
+        if entangler not in (None, qml.CNOT, qml.CZ):
+            raise ValueError("Only qml.CNOT and qml.CZ are supported as entanglers.")
+        self.entangler = entangler
+
+        self.entangling_layout = entangling_layout
+        if entangler is None and self.entangling_layout is not None:
+            warn("`entangling_layout` provided but `entangler` is None.")
+        match self.entangling_layout:
+            case None | "linear":
+                self.entangling_layout = "linear"
+
+                self._layout_fn = lambda n_qubits: zip(
+                    range(n_qubits), range(1, n_qubits)
+                )
+            case "brick":
+                self._layout_fn = lambda n_qubits: [
+                    (i, i + 1) for r in range(2) for i in range(r, n_qubits - 1, 2)
+                ]
+            case "circular":
+                self._layout_fn = lambda n_qubits: zip(
+                    range(n_qubits), [(i + 1) % n_qubits for i in range(n_qubits)]
+                )
+            case "all_to_all":
+                self._layout_fn = lambda n_qubits: (
+                    (i, j) for i in range(n_qubits) for j in range(i + 1, n_qubits)
+                )
+            case _:
+                if not all(
+                    isinstance(ent, tuple)
+                    and len(ent) == 2
+                    and isinstance(ent[0], int)
+                    and isinstance(ent[1], int)
+                    for ent in entangling_layout
+                ):
+                    raise ValueError(
+                        "entangling_layout must be 'linear', 'circular', "
+                        "'all_to_all', or a Sequence of tuples of integers."
+                    )
+
+                self._layout_fn = lambda _: entangling_layout
+
+    def n_params_per_layer(self, n_qubits: int, **kwargs) -> int:
+        """Total parameters = sum of gate.num_params per qubit per layer."""
+        per_qubit = sum(getattr(g, "num_params", 1) for g in self.gate_sequence)
+        return per_qubit * n_qubits
+
+    def build(self, params, n_qubits: int, n_layers: int, **kwargs):
+        # calculate how many params each gate needs per qubit
+        gate_param_counts = [getattr(g, "num_params", 1) for g in self.gate_sequence]
+        per_qubit = sum(gate_param_counts)
+
+        # reshape into [layers, qubits, per_qubit]
+        params = params.reshape(n_layers, n_qubits, per_qubit)
+        layout_gen = iter(tee(self._layout_fn(n_qubits), n_layers))
+
+        def _layer(layer_params, wires):
+            for w, qubit_params in zip(wires, layer_params):
+                idx = 0
+                for gate, n_p in zip(self.gate_sequence, gate_param_counts):
+                    theta = qubit_params[idx : idx + n_p]
+                    gate(*theta, wires=w)
+                    idx += n_p
+
+            if self.entangler is not None:
+                for wire_a, wire_b in next(layout_gen):
+                    self.entangler(wires=[wire_a, wire_b])
+
+        qml.layer(_layer, n_layers, params, wires=range(n_qubits))
+
+
+class QAOAAnsatz(Ansatz):
+    @staticmethod
+    def n_params_per_layer(n_qubits: int, **kwargs) -> int:
+        return qml.QAOAEmbedding.shape(n_layers=1, n_wires=n_qubits)[1]
+
+    def build(self, params, n_qubits: int, n_layers: int, **kwargs):
+        qml.QAOAEmbedding(
+            features=[],
+            weights=params.reshape(n_layers, -1),
+            wires=range(n_qubits),
+        )
+
+
+class HardwareEfficientAnsatz(Ansatz):
+    @staticmethod
+    def n_params_per_layer(n_qubits: int, **kwargs) -> int:
+        raise NotImplementedError("HardwareEfficientAnsatz is not yet implemented.")
+
+    def build(self, params, n_qubits: int, n_layers: int, **kwargs) -> None:
+        raise NotImplementedError("HardwareEfficientAnsatz is not yet implemented.")
+
+
+# --- Chemistry Ansaetze ---
+
+
+class UCCSDAnsatz(Ansatz):
+    @staticmethod
+    def n_params_per_layer(n_qubits: int, n_electrons: int, **kwargs) -> int:
+        singles, doubles = qml.qchem.excitations(n_electrons, n_qubits)
+        s_wires, d_wires = qml.qchem.excitations_to_wires(singles, doubles)
+        return len(s_wires) + len(d_wires)
+
+    def build(self, params, n_qubits: int, n_layers: int, n_electrons: int, **kwargs):
+        singles, doubles = qml.qchem.excitations(n_electrons, n_qubits)
+        s_wires, d_wires = qml.qchem.excitations_to_wires(singles, doubles)
+        hf_state = qml.qchem.hf_state(n_electrons, n_qubits)
+
+        qml.UCCSD(
+            params.reshape(n_layers, -1),
+            wires=range(n_qubits),
+            s_wires=s_wires,
+            d_wires=d_wires,
+            init_state=hf_state,
+            n_repeats=n_layers,
+        )
+
+
+class HartreeFockAnsatz(Ansatz):
+    @staticmethod
+    def n_params_per_layer(n_qubits: int, n_electrons: int, **kwargs) -> int:
+        singles, doubles = qml.qchem.excitations(n_electrons, n_qubits)
+        return len(singles) + len(doubles)
+
+    def build(self, params, n_qubits: int, n_layers: int, n_electrons: int, **kwargs):
+        singles, doubles = qml.qchem.excitations(n_electrons, n_qubits)
+        hf_state = qml.qchem.hf_state(n_electrons, n_qubits)
+
+        qml.layer(
+            qml.AllSinglesDoubles,
+            n_layers,
+            params.reshape(n_layers, -1),
+            wires=range(n_qubits),
+            hf_state=hf_state,
+            singles=singles,
+            doubles=doubles,
+        )
+
+        # Reset the BasisState operations after the first layer
+        # for behaviour similar to UCCSD ansatz
+        for op in qml.QueuingManager.active_context().queue[1:]:
+            op._hyperparameters["hf_state"] = 0

{qoro_divi-0.3.2b0/divi/qprog → qoro_divi-0.3.4/divi/qprog/algorithms}/_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._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