pass tests and parse results as quantumresult

Author: splch

src/qutip_qip/ionq/converter.py

@@ -1,4 +1,6 @@
-from qutip.qip.circuit import QubitCircuit, Gate
+from qutip import Qobj
+from qutip_qip.circuit import QubitCircuit, CircuitResult
+import numpy as np
 
 
 def convert_qutip_circuit(qc: QubitCircuit) -> dict:
@@ -17,7 +19,11 @@ def convert_qutip_circuit(qc: QubitCircuit) -> dict:
     """
     ionq_circuit = []
     for gate in qc.gates:
-        if isinstance(gate, Gate):
+        if (
+            hasattr(gate, "name")
+            and hasattr(gate, "targets")
+            and hasattr(gate, "controls")
+        ):
             ionq_circuit.append(
                 {
                     "gate": gate.name,
@@ -28,6 +34,46 @@ def convert_qutip_circuit(qc: QubitCircuit) -> dict:
     return ionq_circuit
 
 
+def convert_ionq_response_to_circuitresult(
+    ionq_response: dict,
+) -> CircuitResult:
+    """
+    Convert an IonQ response to a CircuitResult.
+
+    Parameters
+    ----------
+    ionq_response: dict
+        The IonQ response.
+
+    Returns
+    -------
+    CircuitResult
+        The CircuitResult.
+    """
+    states = list(ionq_response.keys())
+    # probabilities = list(ionq_response.values())
+
+    max_state = max(int(state) for state in states)
+    num_qubits = int(np.ceil(np.log2(max_state + 1))) if max_state > 0 else 1
+
+    final_states = []
+    final_probabilities = []
+
+    for state in states:
+        binary_state = format(int(state), "0{}b".format(num_qubits))
+        state_vector = np.zeros((2**num_qubits,), dtype=complex)
+        index = int(binary_state, 2)
+        state_vector[index] = 1.0
+
+        qobj_state = Qobj(
+            state_vector, dims=[[2] * num_qubits, [1] * num_qubits]
+        )
+        final_states.append(qobj_state)
+        final_probabilities.append(ionq_response[state])
+
+    return CircuitResult(final_states, final_probabilities)
+
+
 def create_job_body(
     circuit: dict,
     shots: int,

src/qutip_qip/ionq/job.py

@@ -1,6 +1,7 @@
 """Class for a running job."""
 
-from .converter import create_job_body
+from .converter import create_job_body, convert_ionq_response_to_circuitresult
+from qutip_qip.circuit import CircuitResult
 import requests
 import time
 
@@ -65,7 +66,7 @@ def get_status(self) -> dict:
         self.status = response.json()
         return self.status
 
-    def get_results(self, polling_rate: int = 1) -> dict:
+    def get_results(self, polling_rate: int = 1) -> CircuitResult:
         """
         Get the results of the job.
 
@@ -85,7 +86,4 @@ def get_results(self, polling_rate: int = 1) -> dict:
             headers=self.headers,
         )
         response.raise_for_status()
-        self.results = {
-            k: int(round(v * self.shots)) for k, v in response.json().items()
-        }
-        return self.results
+        return convert_ionq_response_to_circuitresult(response.json())

tests/test_ionq.py

@@ -1,7 +1,7 @@
 import unittest
 from unittest.mock import patch, MagicMock
-from qutip.qip.circuit import QubitCircuit, Gate
-from qutip.ionq import (
+from qutip_qip.circuit import QubitCircuit, Gate
+from qutip_qip.ionq import (
     Provider,
     IonQSimulator,
     IonQQPU,
@@ -14,24 +14,28 @@ class TestConverter(unittest.TestCase):
     def test_convert_qutip_circuit(self):
         # Create a simple QubitCircuit with one gate for testing
         qc = QubitCircuit(N=1)
-        qc.add_gate("X", targets=[0])
+        qc.add_gate("H", targets=[0])
+        qc.add_gate("CNOT", targets=[0], controls=[1])
         # Convert the qutip_qip circuit to IonQ format
         ionq_circuit = convert_qutip_circuit(qc)
-        expected_output = [{"gate": "X", "targets": [0], "controls": []}]
+        expected_output = [
+            {"gate": "H", "targets": [0], "controls": []},
+            {"gate": "CNOT", "targets": [0], "controls": [1]},
+        ]
         self.assertEqual(ionq_circuit, expected_output)
 
 
 class TestIonQBackend(unittest.TestCase):
     def setUp(self):
         self.provider = Provider(token="dummy_token")
 
-    @patch("qutip.ionq.Provider")
+    @patch("qutip_qip.ionq.Provider")
     def test_simulator_initialization(self, mock_provider):
         simulator = IonQSimulator(provider=mock_provider)
         self.assertEqual(simulator.provider, mock_provider)
         self.assertEqual(simulator.gateset, "qis")
 
-    @patch("qutip.ionq.Provider")
+    @patch("qutip_qip.ionq.Provider")
     def test_qpu_initialization(self, mock_provider):
         qpu = IonQQPU(provider=mock_provider, qpu="harmony")
         self.assertEqual(qpu.provider, mock_provider)
@@ -55,8 +59,15 @@ def test_submit(self, mock_post):
 
     @patch("requests.get")
     def test_get_results(self, mock_get):
-        mock_get.return_value.json.return_value = {"0": 0.5, "1": 0.5}
-        mock_get.return_value.status_code = 200
+        # Simulate the status check response and the final result response
+        mock_get.side_effect = [
+            MagicMock(
+                json=lambda: {"status": "completed"}
+            ),  # Simulated status check response
+            MagicMock(
+                json=lambda: {"0": 0.5, "1": 0.5}
+            ),  # Simulated final results response
+        ]
         job = Job(
             circuit={},
             shots=1024,