update(cirq-rigetti): use pyquil v4

cirq-rigetti/cirq_rigetti/circuit_sweep_executors.py

@@ -57,21 +57,22 @@ def _execute_and_read_result(
     Raises:
         ValueError: measurement_id_map references an undefined pyQuil readout region.
     """
-    if memory_map is None:
-        memory_map = {}
 
-    for region_name, values in memory_map.items():
-        if isinstance(region_name, str):
-            executable.write_memory(region_name=region_name, value=values)
-        else:
-            raise ValueError(f'Symbols not valid for region name {region_name}')
-    qam_execution_result = quantum_computer.qam.run(executable)
+    # convert all atomic memory values into 1-length lists
+    if memory_map is not None:
+        for region_name, value in memory_map.items():
+            if not isinstance(region_name, str):
+                raise ValueError(f'Symbols not valid for region name {region_name}')
+            value = [value] if not isinstance(value, Sequence) else value
+            memory_map[region_name] = value
+
+    qam_execution_result = quantum_computer.qam.run(executable, memory_map)
 
     measurements = {}
     # For every key, value in QuilOutput#measurement_id_map, use the value to read
     # Rigetti QCS results and assign to measurements by key.
     for cirq_memory_key, pyquil_region in measurement_id_map.items():
-        readout = qam_execution_result.readout_data.get(pyquil_region)
+        readout = qam_execution_result.get_register_map().get(pyquil_region)
         if readout is None:
             raise ValueError(f'readout data does not have values for region "{pyquil_region}"')
         measurements[cirq_memory_key] = readout
@@ -122,9 +123,7 @@ def _prepend_real_declarations(
         param_dict = _get_param_dict(resolver)
         for key in param_dict.keys():
             declaration = Declare(str(key), "REAL")
-            program._instructions.insert(0, declaration)
-            program._synthesized_instructions = None
-            program.declarations[declaration.name] = declaration
+            program = Program(declaration) + program
             logger.debug(f"prepended declaration {declaration}")
     return program
 

cirq-rigetti/cirq_rigetti/circuit_transformers_test.py

@@ -3,6 +3,7 @@
 from unittest.mock import create_autospec
 import cirq
 import numpy as np
+from pyquil import Program
 from pyquil.gates import MEASURE, RX, DECLARE, H, CNOT, I
 from pyquil.quilbase import Pragma, Reset
 from cirq_rigetti import circuit_transformers as transformers
@@ -63,15 +64,15 @@ def test_transform_with_post_transformation_hooks(
     bell_circuit, qubits = bell_circuit_with_qids
 
     def reset_hook(program, measurement_id_map):
-        program._instructions.insert(0, Reset())
+        program = Program(Reset()) + program
         return program, measurement_id_map
 
     reset_hook_spec = create_autospec(reset_hook, side_effect=reset_hook)
 
     pragma = Pragma('INTIAL_REWIRING', freeform_string='GREEDY')
 
     def rewire_hook(program, measurement_id_map):
-        program._instructions.insert(0, pragma)
+        program = Program(pragma) + program
         return program, measurement_id_map
 
     rewire_hook_spec = create_autospec(rewire_hook, side_effect=rewire_hook)

cirq-rigetti/cirq_rigetti/conftest.py

@@ -18,13 +18,17 @@
 import pytest
 from pyquil import Program
 from pyquil.quantum_processor import AbstractQuantumProcessor, NxQuantumProcessor
-from pyquil.api import QAM, QuantumComputer, QuantumExecutable, QAMExecutionResult, EncryptedProgram
-from pyquil.api._abstract_compiler import AbstractCompiler
-from qcs_api_client.client._configuration.settings import QCSClientConfigurationSettings
-from qcs_api_client.client._configuration import (
-    QCSClientConfiguration,
-    QCSClientConfigurationSecrets,
+from pyquil.api import (
+    QAM,
+    QuantumComputer,
+    QuantumExecutable,
+    QAMExecutionResult,
+    EncryptedProgram,
+    MemoryMap,
 )
+from pyquil.api._abstract_compiler import AbstractCompiler
+from qcs_sdk import QCSClient, ExecutionData, ResultData, RegisterData
+from qcs_sdk.qvm import QVMResultData
 import networkx as nx
 import cirq
 import sympy
@@ -71,18 +75,14 @@ def quantum_processor() -> AbstractQuantumProcessor:
 
 
 @pytest.fixture
-def qcs_client_configuration() -> QCSClientConfiguration:
-    settings = QCSClientConfigurationSettings()
-    secrets = QCSClientConfigurationSecrets()
-    return QCSClientConfiguration(profile_name="default", settings=settings, secrets=secrets)
+def qcs_client() -> QCSClient:
+    return QCSClient()
 
 
 @pytest.fixture
-def compiler(quantum_processor, qcs_client_configuration) -> AbstractCompiler:
+def compiler(quantum_processor, qcs_client) -> AbstractCompiler:
     return MockCompiler(
-        client_configuration=qcs_client_configuration,
-        timeout=0,
-        quantum_processor=quantum_processor,
+        client_configuration=qcs_client, timeout=0, quantum_processor=quantum_processor
     )
 
 
@@ -158,14 +158,23 @@ def native_quil_to_executable(nq_program: Program) -> QuantumExecutable:
             side_effect=native_quil_to_executable,
         )
 
-        def run(program: Union[Program, EncryptedProgram]) -> QAMExecutionResult:
+        def run(
+            program: Union[Program, EncryptedProgram], memory_map: MemoryMap
+        ) -> QAMExecutionResult:
             qam = quantum_computer.qam
             qam._mock_results = qam._mock_results or {}  # type: ignore
             qam._mock_results["m0"] = results[qam._run_count]  # type: ignore
 
             quantum_computer.qam._run_count += 1  # type: ignore
             return QAMExecutionResult(
-                executable=program, readout_data=qam._mock_results  # type: ignore
+                executable=program,
+                data=ExecutionData(
+                    result_data=ResultData.from_qvm(
+                        QVMResultData.from_memory_map(
+                            {k: RegisterData.from_f64([v]) for k, v in qam._mock_results.items()}  # type: ignore
+                        )
+                    )
+                ),
             )
 
         quantum_computer.qam.run = Mock(quantum_computer.qam.run, side_effect=run)  # type: ignore

cirq-rigetti/cirq_rigetti/qcs_sampler_and_service_test.py

@@ -24,7 +24,7 @@ def __call__(
         *,
         executor: executors.CircuitSweepExecutor = _default_executor,
         transformer: transformers.CircuitTransformer = transformers.default,
-    ) -> Tuple[Sequence[cirq.Result], QuantumComputer, List[np.ndarray], List[cirq.ParamResolver],]:
+    ) -> Tuple[Sequence[cirq.Result], QuantumComputer, List[np.ndarray], List[cirq.ParamResolver]]:
         pass
 
 
@@ -35,7 +35,7 @@ def _build_service_results(
     *,
     executor: executors.CircuitSweepExecutor = _default_executor,
     transformer: transformers.CircuitTransformer = transformers.default,
-) -> Tuple[Sequence[cirq.Result], QuantumComputer, List[np.ndarray], List[cirq.ParamResolver],]:
+) -> Tuple[Sequence[cirq.Result], QuantumComputer, List[np.ndarray], List[cirq.ParamResolver]]:
     repetitions = 2
     param_resolvers = [r for r in cirq.to_resolvers(sweepable)]
     param_resolver_index = min(1, len(param_resolvers) - 1)
@@ -63,7 +63,7 @@ def _build_sampler_results(
     *,
     executor: executors.CircuitSweepExecutor = _default_executor,
     transformer: transformers.CircuitTransformer = transformers.default,
-) -> Tuple[Sequence[cirq.Result], QuantumComputer, List[np.ndarray], cirq.Sweepable,]:
+) -> Tuple[Sequence[cirq.Result], QuantumComputer, List[np.ndarray], cirq.Sweepable]:
     repetitions = 2
 
     param_resolvers = [r for r in cirq.to_resolvers(sweepable)]