feat: Instruction classes and execution results now support the pickle module

pyproject.toml

@@ -19,12 +19,13 @@ packages = [{ include = "pyquil" }]
 exclude = ["pyquil/conftest.py"]
 
 [tool.poetry.dependencies]
-python = "^3.9,<=3.14"
+python = "^3.9,<=4.0"
 numpy = "^1.25"
 scipy = "^1.11"
 rpcq = "^3.11.0"
 networkx = ">=2.5"
-qcs-sdk-python = "0.19.0"
+qcs-sdk-python = "0.19.2"
+quil = ">=0.11.2"
 packaging = "^23.1"
 deprecated = "^1.2.14"
 types-deprecated = "^1.2.9.3"
@@ -117,6 +118,12 @@ line-ending = "auto"
 docstring-code-format = true
 docstring-code-line-length = "dynamic"
 
+[tool.ruff.lint.per-file-ignores]
+"test/**/*.py" = [
+    "D",    # docstrings are not enforced in tests
+    "S101", # asserts are allowed in tests
+]
+
 [tool.pytest.ini_options]
 filterwarnings = ["ignore::DeprecationWarning:pyquil.*:", "ignore::DeprecationWarning:test.unit.*:"]
 

pyquil/api/__init__.py

@@ -30,7 +30,7 @@
     QVMCompiler,
 )
 from pyquil.api._qam import QAM, MemoryMap, QAMExecutionResult
-from pyquil.api._qpu import QPU
+from pyquil.api._qpu import QPU, QPUExecuteResponse
 from pyquil.api._quantum_computer import (
     QuantumComputer,
     get_qc,
@@ -59,6 +59,7 @@
     "MemoryMap",
     "QAMExecutionResult",
     "QPU",
+    "QPUExecuteResponse",
     "QuantumComputer",
     "get_qc",
     "list_quantum_computers",

pyquil/quilbase.py

@@ -1068,25 +1068,20 @@ class LogicalBinaryOp(quil_rs.BinaryLogic, AbstractInstruction):
 
     def __new__(cls, left: MemoryReference, right: Union[MemoryReference, int]) -> Self:
         """Initialize the operands of the binary logical instruction."""
-        operands = cls._to_rs_binary_operands(left, right)
-        return super().__new__(cls, cls.op, operands)
+        destination = left._to_rs_memory_reference()
+        source = cls._to_rs_binary_operand(right)
+        return super().__new__(cls, cls.op, destination, source)
 
     @classmethod
     def _from_rs_binary_logic(cls, binary_logic: quil_rs.BinaryLogic) -> "LogicalBinaryOp":
-        return super().__new__(cls, binary_logic.operator, binary_logic.operands)
+        return super().__new__(cls, binary_logic.operator, binary_logic.destination, binary_logic.source)
 
     @staticmethod
     def _to_rs_binary_operand(operand: Union[MemoryReference, int]) -> quil_rs.BinaryOperand:
         if isinstance(operand, MemoryReference):
             return quil_rs.BinaryOperand.from_memory_reference(operand._to_rs_memory_reference())
         return quil_rs.BinaryOperand.from_literal_integer(operand)
 
-    @staticmethod
-    def _to_rs_binary_operands(left: MemoryReference, right: Union[MemoryReference, int]) -> quil_rs.BinaryOperands:
-        left_operand = left._to_rs_memory_reference()
-        right_operand = LogicalBinaryOp._to_rs_binary_operand(right)
-        return quil_rs.BinaryOperands(left_operand, right_operand)
-
     @staticmethod
     def _to_py_binary_operand(operand: quil_rs.BinaryOperand) -> Union[MemoryReference, int]:
         if operand.is_literal_integer():
@@ -1096,24 +1091,22 @@ def _to_py_binary_operand(operand: quil_rs.BinaryOperand) -> Union[MemoryReferen
     @property
     def left(self) -> MemoryReference:
         """The left hand side of the binary expression."""
-        return MemoryReference._from_rs_memory_reference(super().operands.memory_reference)
+        return MemoryReference._from_rs_memory_reference(super().destination)
 
     @left.setter
     def left(self, left: MemoryReference) -> None:
-        operands = super().operands
-        operands.memory_reference = left._to_rs_memory_reference()
-        quil_rs.BinaryLogic.operands.__set__(self, operands)  # type: ignore[attr-defined]
+        destination = left._to_rs_memory_reference()
+        quil_rs.BinaryLogic.destination.__set__(self, destination)  # type: ignore[attr-defined]
 
     @property
     def right(self) -> Union[MemoryReference, int]:
         """The right hand side of the binary expression."""
-        return self._to_py_binary_operand(super().operands.operand)
+        return self._to_py_binary_operand(super().source)
 
     @right.setter
     def right(self, right: Union[MemoryReference, int]) -> None:
-        operands = super().operands
-        operands.operand = self._to_rs_binary_operand(right)
-        quil_rs.BinaryLogic.operands.__set__(self, operands)  # type: ignore[attr-defined]
+        source = self._to_rs_binary_operand(right)
+        quil_rs.BinaryLogic.source.__set__(self, source)  # type: ignore[attr-defined]
 
     def out(self) -> str:
         """Return the instruction as a valid Quil string. Raises an error if the instruction contains placeholders."""