feat: Add methods for identifying Quil-T instructions and filtering instructions from Programs

quil-py/pyproject.toml

@@ -33,6 +33,7 @@ maturin = "^1.2.3"
 mypy = "^1.1.1"
 pytest = "^7.2.2"
 pdoc = "^14.1.0"
+syrupy = "^3.0.6"
 
 [tool.maturin]
 features = ["pyo3/extension-module"]

quil-py/quil/instructions/__init__.pyi

@@ -116,6 +116,11 @@ class Instruction:
         """
         Returns a new ``Instruction`` from the given inner data.
         """
+    def is_quil_t(self) -> bool:
+        """
+        Returns ``True`` if the instruction is a Quil-T instruction, ``False`` otherwise.
+        """
+        ...
     def inner(
         self,
     ) -> Union[

quil-py/quil/program/__init__.pyi

@@ -120,6 +120,11 @@ class Program:
         Convert the instruction to a Quil string. If any part of the instruction can't
         be converted to valid Quil, it will be printed in a human-readable debug format.
         """
+    def filter_instructions(self, predicate: Callable[[Instruction], bool]) -> "Program":
+        """
+        Return a new ``Program`` containing only the instructions for which ``predicate`` returns ``True``.
+        """
+        ...
     def resolve_placeholders(self) -> None:
         """
         Resolve ``TargetPlaceholder``s and ``QubitPlaceholder``s within the program using default resolvers.

quil-py/src/instruction/mod.rs

@@ -2,6 +2,7 @@ use quil_rs::instruction::Instruction;
 use rigetti_pyo3::{
     create_init_submodule, impl_repr, py_wrap_union_enum,
     pyo3::{pymethods, types::PyDict, PyResult, Python},
+    PyWrapper,
 };
 
 use crate::{impl_eq, impl_to_quil};
@@ -100,6 +101,10 @@ impl_eq!(PyInstruction);
 
 #[pymethods]
 impl PyInstruction {
+    pub fn is_quil_t(&self) -> bool {
+        self.as_inner().is_quil_t()
+    }
+
     // Implement the __copy__ and __deepcopy__ dunder methods, which are used by Python's
     // `copy` module.
     //

quil-py/src/program/mod.rs

@@ -234,6 +234,19 @@ impl PyProgram {
             .to_owned())
     }
 
+    pub fn filter_instructions(&self, py: Python, predicate: Py<PyFunction>) -> PyResult<Self> {
+        let filtered = self.as_inner().filter_instructions(|inst| {
+            Python::with_gil(|py| {
+                predicate
+                    .call1(py, (inst.to_python(py).unwrap(),))
+                    .unwrap_or_else(|err| panic!("predicate function returned an error: {err}"))
+                    .extract(py)
+                    .unwrap_or_else(|err| panic!("predicate function must return a bool: {err}"))
+            })
+        });
+        filtered.to_python(py)
+    }
+
     pub fn resolve_placeholders(&mut self) {
         self.as_inner_mut().resolve_placeholders();
     }

quil-py/test/program/__snapshots__/test_program.ambr

@@ -0,0 +1,12 @@
+# name: test_filter_instructions
+  '''
+  DECLARE foo REAL[1]
+  DEFGATE BAR AS MATRIX:
+  	0, 1
+  	1, 0
+
+  H 1
+  CNOT 2 3
+
+  '''
+# ---

quil-py/test/program/test_program.py

@@ -2,6 +2,8 @@
 import pytest
 from typing import Optional
 
+from syrupy.assertion import SnapshotAssertion
+
 from quil.program import Program
 from quil.instructions import Instruction, QubitPlaceholder, TargetPlaceholder, Gate, Qubit, Jump, Target
 
@@ -49,3 +51,21 @@ def target_resolver(target: TargetPlaceholder) -> Optional[str]:
     print(program.to_quil_or_debug())
 
     assert program.to_quil() == "H 9\nJUMP @test\n"
+
+
+def test_filter_instructions(snapshot: SnapshotAssertion):
+    input = """DECLARE foo REAL[1]
+DEFFRAME 1 "rx":
+\tHARDWARE-OBJECT: "hardware"
+DEFCAL I 1:
+\tDELAY 0 1
+DEFGATE BAR AS MATRIX:
+\t0, 1
+\t1, 0
+
+H 1
+CNOT 2 3
+"""
+    program = Program.parse(input)
+    program_without_quil_t = program.filter_instructions(lambda instruction: not instruction.is_quil_t())
+    assert program_without_quil_t.to_quil() == snapshot