Foundational support for implementing Program with qcs-sdk-python

pyproject.toml

@@ -26,7 +26,7 @@ lark = "^0.11.1"
 rpcq = "^3.10.0"
 networkx = "^2.5"
 importlib-metadata = { version = ">=3.7.3,<5", python = "<3.8" }
-qcs-sdk-python = "0.4.1"
+qcs-sdk-python = "0.4.2"
 qcs-api-client = ">=0.21.0,<0.22.0"
 retry = "^0.9.2"
 types-python-dateutil = "^2.8.19"
@@ -40,6 +40,7 @@ Sphinx = { version = "^4.0.2", optional = true }
 sphinx-rtd-theme = { version = "^0.5.2", optional = true }
 nbsphinx = { version = "^0.8.6", optional = true }
 recommonmark = { version = "^0.7.1", optional = true }
+deprecation = "^2.1.0"
 
 [tool.poetry.dev-dependencies]
 black = "^22.8.0"
@@ -55,6 +56,7 @@ pytest-freezegun = "^0.4.2"
 respx = "^0.20"
 nest-asyncio = "^1.5.6"
 mock = { version = "^4.0", python = "<3.8" }
+syrupy = "^3.0.6"
 
 [tool.poetry.extras]
 latex = ["ipython"]

pyquil/api/_abstract_compiler.py

@@ -125,30 +125,19 @@ def quil_to_native_quil(self, program: Program, *, protoquil: Optional[bool] = N
         """
         Convert a Quil program into native Quil, which is supported for execution on a QPU.
         """
-
-        # This is a work-around needed because calling `qcs_sdk.compile` happens _before_
-        # the event loop is available. Wrapping it in a Python async function ensures that
-        # the event loop is available. This is a limitation of pyo3:
-        # https://pyo3.rs/v0.17.1/ecosystem/async-await.html#a-note-about-asynciorun
-        async def _compile(*args, **kwargs) -> str:  # type: ignore
-            return await qcs_sdk.compile(*args, **kwargs)
-
         # TODO This ISA isn't always going to be available. Specifically, if the quantum processor is
         # a QVM-type processor, then `quantum_processor` will have a CompilerISA, not a QCSISA.
         # This will have to be addressed as part of this issue: https://github.com/rigetti/pyquil/issues/1496
         target_device = compiler_isa_to_target_quantum_processor(self.quantum_processor.to_compiler_isa())
-        native_quil = self._event_loop.run_until_complete(
-            _compile(
-                program.out(calibrations=False),
-                json.dumps(target_device.asdict(), indent=2),  # type: ignore
-                timeout=self._compiler_client.timeout,
-            )
+
+        native_quil = qcs_sdk.compile(
+            program.out(calibrations=False),
+            json.dumps(target_device.asdict(), indent=2),  # type: ignore
+            timeout=self._compiler_client.timeout,
         )
 
         native_program = Program(native_quil)
         native_program.num_shots = program.num_shots
-        native_program._calibrations = program._calibrations
-        native_program._waveforms = program._waveforms
         native_program._memory = program._memory.copy()
 
         return native_program

pyquil/api/_compiler.py

@@ -103,19 +103,10 @@ def native_quil_to_executable(self, nq_program: Program) -> QuantumExecutable:
         """
         rewrite_response = qcs_sdk.rewrite_arithmetic(nq_program.out())
 
-        # This is a work-around needed because calling `qcs_sdk.translate` happens _before_
-        # the event loop is available. Wrapping it in a Python async function ensures that
-        # the event loop is available. This is a limitation of pyo3:
-        # https://pyo3.rs/v0.17.1/ecosystem/async-await.html#a-note-about-asynciorun
-        async def _translate(*args):
-            return await qcs_sdk.translate(*args)
-
-        translated_program = self._event_loop.run_until_complete(
-            _translate(
-                rewrite_response["program"],
-                nq_program.num_shots,
-                self.quantum_processor_id,
-            )
+        translated_program = qcs_sdk.translate(
+            rewrite_response["program"],
+            nq_program.num_shots,
+            self.quantum_processor_id,
         )
 
         return EncryptedProgram(

pyquil/api/_compiler_client.py

@@ -181,10 +181,7 @@ def get_version(self) -> str:
         Get version info for compiler server.
         """
 
-        async def _get_quilc_version() -> str:
-            return await qcs_sdk.get_quilc_version()
-
-        return self._event_loop.run_until_complete(_get_quilc_version())
+        return qcs_sdk.get_quilc_version()
 
     def compile_to_native_quil(self, request: CompileToNativeQuilRequest) -> CompileToNativeQuilResponse:
         """