Merge pull request #3 from scaleway/qio-upgrade

Qio upgrade

Author: Sonderfall

cirq_scaleway/scaleway_device.py

@@ -17,7 +17,7 @@
 
 from scaleway_qaas_client.v1alpha1 import QaaSClient, QaaSPlatform
 
-from .scaleway_session import ScalewaySession
+from cirq_scaleway.scaleway_session import ScalewaySession
 
 
 class ScalewayDevice(cirq.devices.Device):

cirq_scaleway/scaleway_service.py

@@ -17,7 +17,7 @@
 
 from scaleway_qaas_client.v1alpha1 import QaaSClient
 
-from .scaleway_device import ScalewayDevice
+from cirq_scaleway.scaleway_device import ScalewayDevice
 
 
 class ScalewayQuantumService:

cirq_scaleway/scaleway_session.py

@@ -12,26 +12,27 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 import time
-import json
 import cirq
 import httpx
 
 from typing import Union, Optional, List
 
-from cirq.study import ResultDict
+from qio.core import (
+    QuantumProgram,
+    QuantumProgramSerializationFormat,
+    QuantumProgramResult,
+    QuantumComputationModel,
+    QuantumComputationParameters,
+    BackendData,
+    ClientData,
+)
 
 from scaleway_qaas_client.v1alpha1 import (
     QaaSClient,
     QaaSJobResult,
-    QaaSJobData,
-    QaaSJobClientData,
-    QaaSCircuitData,
-    QaaSJobRunData,
-    QaaSJobBackendData,
-    QaaSCircuitSerializationFormat,
 )
 
-from .versions import USER_AGENT
+from cirq_scaleway.versions import USER_AGENT
 
 
 class ScalewaySession(cirq.work.Sampler):
@@ -173,24 +174,19 @@ def run_sweep(
 
         for param_resolver in cirq.study.to_resolvers(params):
             circuit = cirq.protocols.resolve_parameters(program, param_resolver)
-            serialized_circuit = cirq.to_json(circuit)
-
-            run_opts = QaaSJobRunData(
-                options={"shots": repetitions},
-                circuits=[
-                    QaaSCircuitData(
-                        serialization_format=QaaSCircuitSerializationFormat.JSON,
-                        circuit_serialization=serialized_circuit,
-                    )
-                ],
+
+            program = QuantumProgram.from_cirq_circuit(
+                circuit, QuantumProgramSerializationFormat.CIRQ_CIRCUIT_JSON_V1
             )
 
-            results = self._submit(run_opts, self.__id)
+            results = self._submit(program, repetitions, self.__id)
             trial_results.append(results)
 
         return trial_results
 
-    def _extract_payload_from_response(self, job_result: QaaSJobResult) -> str:
+    def _extract_payload_from_response(
+        self, job_result: QaaSJobResult
+    ) -> QuantumProgramResult:
         result = job_result.result
 
         if result is None or result == "":
@@ -199,12 +195,11 @@ def _extract_payload_from_response(self, job_result: QaaSJobResult) -> str:
             if url is not None:
                 resp = httpx.get(url)
                 resp.raise_for_status()
-
-                return resp.text
+                result = resp.text
             else:
-                raise Exception("Got result with both empty data and url fields")
-        else:
-            return result
+                raise RuntimeError("Got result with empty data and url fields")
+
+        return QuantumProgramResult.from_json_str(result)
 
     def _wait_for_result(
         self, job_id: str, timeout: Optional[int] = None, fetch_interval: int = 2
@@ -217,47 +212,56 @@ def _wait_for_result(
             elapsed = time.time() - start_time
 
             if timeout is not None and elapsed >= timeout:
-                raise Exception("Timed out waiting for result")
+                raise RuntimeError("Timed out waiting for result")
 
             job = self.__client.get_job(job_id)
 
             if job.status == "completed":
                 return self.__client.list_job_results(job_id)
 
             if job.status in ["error", "unknown_status"]:
-                raise Exception("Job error")
-
-    def _to_cirq_result(self, job_results: List[QaaSJobResult]) -> cirq.Result:
-        if len(job_results) == 0:
-            raise Exception("Empty result list")
-
-        payload = self._extract_payload_from_response(job_results[0])
-        payload_dict = json.loads(payload)
-        cirq_result = ResultDict._from_json_dict_(**payload_dict)
-
-        return cirq_result
-
-    def _submit(self, run_opts: QaaSJobRunData, session_id: str) -> cirq.study.Result:
-        data = QaaSJobData.schema().dumps(
-            QaaSJobData(
-                backend=QaaSJobBackendData(
-                    name=self.__device.name, version=self.__device.version, options={}
-                ),
-                client=QaaSJobClientData(user_agent=USER_AGENT),
-                run=run_opts,
-            )
+                raise RuntimeError(f"Job failed: {job.progress_message}")
+
+    def _submit(
+        self, program: QuantumProgram, shots: int, session_id: str
+    ) -> cirq.study.Result:
+        backend_data = BackendData(
+            name=self.__device.name,
+            version=self.__device.version,
+        )
+
+        client_data = ClientData(
+            user_agent=USER_AGENT,
         )
 
+        computation_model_json = QuantumComputationModel(
+            programs=[program],
+            backend=backend_data,
+            client=client_data,
+        ).to_json_str()
+
+        computation_parameters_json = QuantumComputationParameters(
+            shots=shots,
+        ).to_json_str()
+
         model = self.__client.create_model(
-            payload=data,
+            payload=computation_model_json,
         )
 
         if not model:
             raise RuntimeError("Failed to push circuit data")
 
-        job_id = self.__client.create_job(session_id=session_id, model_id=model.id).id
+        job_id = self.__client.create_job(
+            session_id=session_id,
+            model_id=model.id,
+            parameters=computation_parameters_json,
+        ).id
+
+        job_results = self._wait_for_result(job_id, 60 * 100, 2)
+
+        if len(job_results) != 1:
+            raise RuntimeError("Expected a single result for Cirq job")
 
-        job_results = self._wait_for_result(job_id, 60 * 10, 2)
-        result = self._to_cirq_result(job_results)
+        result = self._extract_payload_from_response(job_results[0]).to_cirq_result()
 
         return result

requirements.txt

@@ -1,3 +1,4 @@
 pandas==2.3.1
 cirq-core>=1.3.0
-scaleway-qaas-client>=0.1.16
+scaleway-qaas-client>=0.1.16
+qio>=0.1.12

setup.py

@@ -22,7 +22,7 @@
 
 setup(
     name="cirq_scaleway",
-    version="0.1.9",
+    version="0.1.10",
     project_urls={
         "Documentation": "https://www.scaleway.com/en/quantum-as-a-service/",
         "Source": "https://github.com/scaleway/cirq-scaleway",