quil.instructions

class Instruction:
def from_arithmetic(inner):

The Python wrapper for [Instruction::Arithmetic], creating a [PyInstruction] and taking a Python argument.

def from_binary_logic(inner):

The Python wrapper for [Instruction::BinaryLogic], creating a [PyInstruction] and taking a Python argument.

def from_calibration_definition(inner):

The Python wrapper for [Instruction::CalibrationDefinition], creating a [PyInstruction] and taking a Python argument.

def from_call(inner):

The Python wrapper for [Instruction::Call], creating a [PyInstruction] and taking a Python argument.

def from_capture(inner):

The Python wrapper for [Instruction::Capture], creating a [PyInstruction] and taking a Python argument.

def from_circuit_definition(inner):

The Python wrapper for [Instruction::CircuitDefinition], creating a [PyInstruction] and taking a Python argument.

def from_convert(inner):

The Python wrapper for [Instruction::Convert], creating a [PyInstruction] and taking a Python argument.

def from_comparison(inner):

The Python wrapper for [Instruction::Comparison], creating a [PyInstruction] and taking a Python argument.

def from_declaration(inner):

The Python wrapper for [Instruction::Declaration], creating a [PyInstruction] and taking a Python argument.

def from_delay(inner):

The Python wrapper for [Instruction::Delay], creating a [PyInstruction] and taking a Python argument.

def from_exchange(inner):

The Python wrapper for [Instruction::Exchange], creating a [PyInstruction] and taking a Python argument.

def from_fence(inner):

The Python wrapper for [Instruction::Fence], creating a [PyInstruction] and taking a Python argument.

def from_frame_definition(inner):

The Python wrapper for [Instruction::FrameDefinition], creating a [PyInstruction] and taking a Python argument.

def from_gate(inner):

The Python wrapper for [Instruction::Gate], creating a [PyInstruction] and taking a Python argument.

def from_gate_definition(inner):

The Python wrapper for [Instruction::GateDefinition], creating a [PyInstruction] and taking a Python argument.

def new_halt():

Create a new [PyInstruction] wrapping a [Instruction::Halt].

def from_include(inner):

The Python wrapper for [Instruction::Include], creating a [PyInstruction] and taking a Python argument.

def from_jump(inner):

The Python wrapper for [Instruction::Jump], creating a [PyInstruction] and taking a Python argument.

def from_jump_when(inner):

The Python wrapper for [Instruction::JumpWhen], creating a [PyInstruction] and taking a Python argument.

def from_jump_unless(inner):

The Python wrapper for [Instruction::JumpUnless], creating a [PyInstruction] and taking a Python argument.

def from_label(inner):

The Python wrapper for [Instruction::Label], creating a [PyInstruction] and taking a Python argument.

def from_load(inner):

The Python wrapper for [Instruction::Load], creating a [PyInstruction] and taking a Python argument.

def from_measure_calibration_definition(inner):

The Python wrapper for [Instruction::MeasureCalibrationDefinition], creating a [PyInstruction] and taking a Python argument.

def from_measurement(inner):

The Python wrapper for [Instruction::Measurement], creating a [PyInstruction] and taking a Python argument.

def from_move(inner):

The Python wrapper for [Instruction::Move], creating a [PyInstruction] and taking a Python argument.

def new_nop():

Create a new [PyInstruction] wrapping a [Instruction::Nop].

def from_pragma(inner):

The Python wrapper for [Instruction::Pragma], creating a [PyInstruction] and taking a Python argument.

def from_pulse(inner):

The Python wrapper for [Instruction::Pulse], creating a [PyInstruction] and taking a Python argument.

def from_raw_capture(inner):

The Python wrapper for [Instruction::RawCapture], creating a [PyInstruction] and taking a Python argument.

def from_reset(inner):

The Python wrapper for [Instruction::Reset], creating a [PyInstruction] and taking a Python argument.

def from_set_frequency(inner):

The Python wrapper for [Instruction::SetFrequency], creating a [PyInstruction] and taking a Python argument.

def from_set_phase(inner):

The Python wrapper for [Instruction::SetPhase], creating a [PyInstruction] and taking a Python argument.

def from_set_scale(inner):

The Python wrapper for [Instruction::SetScale], creating a [PyInstruction] and taking a Python argument.

def from_shift_frequency(inner):

The Python wrapper for [Instruction::ShiftFrequency], creating a [PyInstruction] and taking a Python argument.

def from_shift_phase(inner):

The Python wrapper for [Instruction::ShiftPhase], creating a [PyInstruction] and taking a Python argument.

def from_store(inner):

The Python wrapper for [Instruction::Store], creating a [PyInstruction] and taking a Python argument.

def from_swap_phases(inner):

The Python wrapper for [Instruction::SwapPhases], creating a [PyInstruction] and taking a Python argument.

def from_unary_logic(inner):

The Python wrapper for [Instruction::UnaryLogic], creating a [PyInstruction] and taking a Python argument.

def from_waveform_definition(inner):

The Python wrapper for [Instruction::WaveformDefinition], creating a [PyInstruction] and taking a Python argument.

def new_wait():

Create a new [PyInstruction] wrapping a [Instruction::Wait].

def inner(self, /):

Directly return the Python version of the variant discriminant wrapped by this value; i.e., performs the match Instruction::Variant(x) => x for every variant constructor in [Instruction]

def is_arithmetic(self, /):

Tests if this [PyInstruction] wraps a [Instruction::arithmetic] value

def as_arithmetic(self, /):

Returns x if this [PyInstruction] wraps a Instruction::arithmetic(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_arithmetic(self, /):

Returns x if this [PyInstruction] wraps a Instruction::arithmetic(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def is_binary_logic(self, /):

Tests if this [PyInstruction] wraps a [Instruction::binary_logic] value

def as_binary_logic(self, /):

Returns x if this [PyInstruction] wraps a Instruction::binary_logic(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_binary_logic(self, /):

Returns x if this [PyInstruction] wraps a Instruction::binary_logic(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def is_calibration_definition(self, /):

Tests if this [PyInstruction] wraps a [Instruction::calibration_definition] value

def as_calibration_definition(self, /):

Returns x if this [PyInstruction] wraps a Instruction::calibration_definition(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_calibration_definition(self, /):

Returns x if this [PyInstruction] wraps a Instruction::calibration_definition(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def is_call(self, /):

Tests if this [PyInstruction] wraps a [Instruction::call] value

def as_call(self, /):

Returns x if this [PyInstruction] wraps a Instruction::call(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_call(self, /):

Returns x if this [PyInstruction] wraps a Instruction::call(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def is_capture(self, /):

Tests if this [PyInstruction] wraps a [Instruction::capture] value

def as_capture(self, /):

Returns x if this [PyInstruction] wraps a Instruction::capture(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_capture(self, /):

Returns x if this [PyInstruction] wraps a Instruction::capture(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def is_circuit_definition(self, /):

Tests if this [PyInstruction] wraps a [Instruction::circuit_definition] value

def as_circuit_definition(self, /):

Returns x if this [PyInstruction] wraps a Instruction::circuit_definition(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_circuit_definition(self, /):

Returns x if this [PyInstruction] wraps a Instruction::circuit_definition(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def is_convert(self, /):

Tests if this [PyInstruction] wraps a [Instruction::convert] value

def as_convert(self, /):

Returns x if this [PyInstruction] wraps a Instruction::convert(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_convert(self, /):

Returns x if this [PyInstruction] wraps a Instruction::convert(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def is_comparison(self, /):

Tests if this [PyInstruction] wraps a [Instruction::comparison] value

def as_comparison(self, /):

Returns x if this [PyInstruction] wraps a Instruction::comparison(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_comparison(self, /):

Returns x if this [PyInstruction] wraps a Instruction::comparison(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def is_declaration(self, /):

Tests if this [PyInstruction] wraps a [Instruction::declaration] value

def as_declaration(self, /):

Returns x if this [PyInstruction] wraps a Instruction::declaration(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_declaration(self, /):

Returns x if this [PyInstruction] wraps a Instruction::declaration(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def is_delay(self, /):

Tests if this [PyInstruction] wraps a [Instruction::delay] value

def as_delay(self, /):

Returns x if this [PyInstruction] wraps a Instruction::delay(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_delay(self, /):

Returns x if this [PyInstruction] wraps a Instruction::delay(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def is_exchange(self, /):

Tests if this [PyInstruction] wraps a [Instruction::exchange] value

def as_exchange(self, /):

Returns x if this [PyInstruction] wraps a Instruction::exchange(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_exchange(self, /):

Returns x if this [PyInstruction] wraps a Instruction::exchange(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def is_fence(self, /):

Tests if this [PyInstruction] wraps a [Instruction::fence] value

def as_fence(self, /):

Returns x if this [PyInstruction] wraps a Instruction::fence(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_fence(self, /):

Returns x if this [PyInstruction] wraps a Instruction::fence(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def is_frame_definition(self, /):

Tests if this [PyInstruction] wraps a [Instruction::frame_definition] value

def as_frame_definition(self, /):

Returns x if this [PyInstruction] wraps a Instruction::frame_definition(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_frame_definition(self, /):

Returns x if this [PyInstruction] wraps a Instruction::frame_definition(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def is_gate(self, /):

Tests if this [PyInstruction] wraps a [Instruction::gate] value

def as_gate(self, /):

Returns x if this [PyInstruction] wraps a Instruction::gate(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_gate(self, /):

Returns x if this [PyInstruction] wraps a Instruction::gate(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def is_gate_definition(self, /):

Tests if this [PyInstruction] wraps a [Instruction::gate_definition] value

def as_gate_definition(self, /):

Returns x if this [PyInstruction] wraps a Instruction::gate_definition(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_gate_definition(self, /):

Returns x if this [PyInstruction] wraps a Instruction::gate_definition(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def is_halt(self, /):

Tests if this [PyInstruction] wraps a [Instruction::halt] value

def is_include(self, /):

Tests if this [PyInstruction] wraps a [Instruction::include] value

def as_include(self, /):

Returns x if this [PyInstruction] wraps a Instruction::include(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_include(self, /):

Returns x if this [PyInstruction] wraps a Instruction::include(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def is_jump(self, /):

Tests if this [PyInstruction] wraps a [Instruction::jump] value

def as_jump(self, /):

Returns x if this [PyInstruction] wraps a Instruction::jump(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_jump(self, /):

Returns x if this [PyInstruction] wraps a Instruction::jump(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def is_jump_when(self, /):

Tests if this [PyInstruction] wraps a [Instruction::jump_when] value

def as_jump_when(self, /):

Returns x if this [PyInstruction] wraps a Instruction::jump_when(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_jump_when(self, /):

Returns x if this [PyInstruction] wraps a Instruction::jump_when(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def is_jump_unless(self, /):

Tests if this [PyInstruction] wraps a [Instruction::jump_unless] value

def as_jump_unless(self, /):

Returns x if this [PyInstruction] wraps a Instruction::jump_unless(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_jump_unless(self, /):

Returns x if this [PyInstruction] wraps a Instruction::jump_unless(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def is_label(self, /):

Tests if this [PyInstruction] wraps a [Instruction::label] value

def as_label(self, /):

Returns x if this [PyInstruction] wraps a Instruction::label(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_label(self, /):

Returns x if this [PyInstruction] wraps a Instruction::label(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def is_load(self, /):

Tests if this [PyInstruction] wraps a [Instruction::load] value

def as_load(self, /):

Returns x if this [PyInstruction] wraps a Instruction::load(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_load(self, /):

Returns x if this [PyInstruction] wraps a Instruction::load(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def is_measure_calibration_definition(self, /):

Tests if this [PyInstruction] wraps a [Instruction::measure_calibration_definition] value

def as_measure_calibration_definition(self, /):

Returns x if this [PyInstruction] wraps a Instruction::measure_calibration_definition(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_measure_calibration_definition(self, /):

Returns x if this [PyInstruction] wraps a Instruction::measure_calibration_definition(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def is_measurement(self, /):

Tests if this [PyInstruction] wraps a [Instruction::measurement] value

def as_measurement(self, /):

Returns x if this [PyInstruction] wraps a Instruction::measurement(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_measurement(self, /):

Returns x if this [PyInstruction] wraps a Instruction::measurement(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def is_move(self, /):

Tests if this [PyInstruction] wraps a [Instruction::move] value

def as_move(self, /):

Returns x if this [PyInstruction] wraps a Instruction::move(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_move(self, /):

Returns x if this [PyInstruction] wraps a Instruction::move(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def is_nop(self, /):

Tests if this [PyInstruction] wraps a [Instruction::nop] value

def is_pragma(self, /):

Tests if this [PyInstruction] wraps a [Instruction::pragma] value

def as_pragma(self, /):

Returns x if this [PyInstruction] wraps a Instruction::pragma(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_pragma(self, /):

Returns x if this [PyInstruction] wraps a Instruction::pragma(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def is_pulse(self, /):

Tests if this [PyInstruction] wraps a [Instruction::pulse] value

def as_pulse(self, /):

Returns x if this [PyInstruction] wraps a Instruction::pulse(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_pulse(self, /):

Returns x if this [PyInstruction] wraps a Instruction::pulse(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def is_raw_capture(self, /):

Tests if this [PyInstruction] wraps a [Instruction::raw_capture] value

def as_raw_capture(self, /):

Returns x if this [PyInstruction] wraps a Instruction::raw_capture(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_raw_capture(self, /):

Returns x if this [PyInstruction] wraps a Instruction::raw_capture(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def is_reset(self, /):

Tests if this [PyInstruction] wraps a [Instruction::reset] value

def as_reset(self, /):

Returns x if this [PyInstruction] wraps a Instruction::reset(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_reset(self, /):

Returns x if this [PyInstruction] wraps a Instruction::reset(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def is_set_frequency(self, /):

Tests if this [PyInstruction] wraps a [Instruction::set_frequency] value

def as_set_frequency(self, /):

Returns x if this [PyInstruction] wraps a Instruction::set_frequency(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_set_frequency(self, /):

Returns x if this [PyInstruction] wraps a Instruction::set_frequency(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def is_set_phase(self, /):

Tests if this [PyInstruction] wraps a [Instruction::set_phase] value

def as_set_phase(self, /):

Returns x if this [PyInstruction] wraps a Instruction::set_phase(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_set_phase(self, /):

Returns x if this [PyInstruction] wraps a Instruction::set_phase(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def is_set_scale(self, /):

Tests if this [PyInstruction] wraps a [Instruction::set_scale] value

def as_set_scale(self, /):

Returns x if this [PyInstruction] wraps a Instruction::set_scale(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_set_scale(self, /):

Returns x if this [PyInstruction] wraps a Instruction::set_scale(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def is_shift_frequency(self, /):

Tests if this [PyInstruction] wraps a [Instruction::shift_frequency] value

def as_shift_frequency(self, /):

Returns x if this [PyInstruction] wraps a Instruction::shift_frequency(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_shift_frequency(self, /):

Returns x if this [PyInstruction] wraps a Instruction::shift_frequency(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def is_shift_phase(self, /):

Tests if this [PyInstruction] wraps a [Instruction::shift_phase] value

def as_shift_phase(self, /):

Returns x if this [PyInstruction] wraps a Instruction::shift_phase(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_shift_phase(self, /):

Returns x if this [PyInstruction] wraps a Instruction::shift_phase(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def is_store(self, /):

Tests if this [PyInstruction] wraps a [Instruction::store] value

def as_store(self, /):

Returns x if this [PyInstruction] wraps a Instruction::store(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_store(self, /):

Returns x if this [PyInstruction] wraps a Instruction::store(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def is_swap_phases(self, /):

Tests if this [PyInstruction] wraps a [Instruction::swap_phases] value

def as_swap_phases(self, /):

Returns x if this [PyInstruction] wraps a Instruction::swap_phases(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_swap_phases(self, /):

Returns x if this [PyInstruction] wraps a Instruction::swap_phases(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def is_unary_logic(self, /):

Tests if this [PyInstruction] wraps a [Instruction::unary_logic] value

def as_unary_logic(self, /):

Returns x if this [PyInstruction] wraps a Instruction::unary_logic(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_unary_logic(self, /):

Returns x if this [PyInstruction] wraps a Instruction::unary_logic(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def is_waveform_definition(self, /):

Tests if this [PyInstruction] wraps a [Instruction::waveform_definition] value

def as_waveform_definition(self, /):

Returns x if this [PyInstruction] wraps a Instruction::waveform_definition(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_waveform_definition(self, /):

Returns x if this [PyInstruction] wraps a Instruction::waveform_definition(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def is_wait(self, /):

Tests if this [PyInstruction] wraps a [Instruction::wait] value

def to_quil(self, /):
def to_quil_or_debug(self, /):
def is_quil_t(self, /):
def parse(string):
class Arithmetic:
def to_quil(self, /):
def to_quil_or_debug(self, /):
source

Get the source field from Python. Annotated with @property.

destination

Get the destination field from Python. Annotated with @property.

operator

Get the operator field from Python. Annotated with @property.

class ArithmeticOperand:
def from_literal_integer(inner):

The Python wrapper for [ArithmeticOperand::LiteralInteger], creating a [PyArithmeticOperand] and taking a Python argument.

def from_literal_real(inner):

The Python wrapper for [ArithmeticOperand::LiteralReal], creating a [PyArithmeticOperand] and taking a Python argument.

def from_memory_reference(inner):

The Python wrapper for [ArithmeticOperand::MemoryReference], creating a [PyArithmeticOperand] and taking a Python argument.

def inner(self, /):

Directly return the Python version of the variant discriminant wrapped by this value; i.e., performs the match ArithmeticOperand::Variant(x) => x for every variant constructor in [ArithmeticOperand]

def is_literal_integer(self, /):

Tests if this [PyArithmeticOperand] wraps a [ArithmeticOperand::literal_integer] value

def as_literal_integer(self, /):

Returns x if this [PyArithmeticOperand] wraps a ArithmeticOperand::literal_integer(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_literal_integer(self, /):

Returns x if this [PyArithmeticOperand] wraps a ArithmeticOperand::literal_integer(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def is_literal_real(self, /):

Tests if this [PyArithmeticOperand] wraps a [ArithmeticOperand::literal_real] value

def as_literal_real(self, /):

Returns x if this [PyArithmeticOperand] wraps a ArithmeticOperand::literal_real(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_literal_real(self, /):

Returns x if this [PyArithmeticOperand] wraps a ArithmeticOperand::literal_real(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def is_memory_reference(self, /):

Tests if this [PyArithmeticOperand] wraps a [ArithmeticOperand::memory_reference] value

def as_memory_reference(self, /):

Returns x if this [PyArithmeticOperand] wraps a ArithmeticOperand::memory_reference(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_memory_reference(self, /):

Returns x if this [PyArithmeticOperand] wraps a ArithmeticOperand::memory_reference(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def to_quil(self, /):
def to_quil_or_debug(self, /):
class ArithmeticOperator:
def to_quil(self, /):
def to_quil_or_debug(self, /):
Add = Add
Subtract = Subtract
Divide = Divide
Multiply = Multiply
class BinaryLogic:
def to_quil(self, /):
def to_quil_or_debug(self, /):
destination

Get the destination field from Python. Annotated with @property.

source

Get the source field from Python. Annotated with @property.

operator

Get the operator field from Python. Annotated with @property.

class BinaryOperand:
def from_literal_integer(inner):

The Python wrapper for [BinaryOperand::LiteralInteger], creating a [PyBinaryOperand] and taking a Python argument.

def from_memory_reference(inner):

The Python wrapper for [BinaryOperand::MemoryReference], creating a [PyBinaryOperand] and taking a Python argument.

def inner(self, /):

Directly return the Python version of the variant discriminant wrapped by this value; i.e., performs the match BinaryOperand::Variant(x) => x for every variant constructor in [BinaryOperand]

def is_literal_integer(self, /):

Tests if this [PyBinaryOperand] wraps a [BinaryOperand::literal_integer] value

def as_literal_integer(self, /):

Returns x if this [PyBinaryOperand] wraps a BinaryOperand::literal_integer(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_literal_integer(self, /):

Returns x if this [PyBinaryOperand] wraps a BinaryOperand::literal_integer(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def is_memory_reference(self, /):

Tests if this [PyBinaryOperand] wraps a [BinaryOperand::memory_reference] value

def as_memory_reference(self, /):

Returns x if this [PyBinaryOperand] wraps a BinaryOperand::memory_reference(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_memory_reference(self, /):

Returns x if this [PyBinaryOperand] wraps a BinaryOperand::memory_reference(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def to_quil(self, /):
def to_quil_or_debug(self, /):
class BinaryOperator:
def to_quil(self, /):
def to_quil_or_debug(self, /):
And = And
Ior = Ior
Xor = Xor
class Call:
def to_quil(self, /):
def to_quil_or_debug(self, /):
name
arguments
class CallArgument:
def from_identifier(inner):

The Python wrapper for [UnresolvedCallArgument::Identifier], creating a [PyCallArgument] and taking a Python argument.

def from_memory_reference(inner):

The Python wrapper for [UnresolvedCallArgument::MemoryReference], creating a [PyCallArgument] and taking a Python argument.

def from_immediate(inner):

The Python wrapper for [UnresolvedCallArgument::Immediate], creating a [PyCallArgument] and taking a Python argument.

def inner(self, /):

Directly return the Python version of the variant discriminant wrapped by this value; i.e., performs the match UnresolvedCallArgument::Variant(x) => x for every variant constructor in [UnresolvedCallArgument]

def is_identifier(self, /):

Tests if this [PyCallArgument] wraps a [UnresolvedCallArgument::identifier] value

def as_identifier(self, /):

Returns x if this [PyCallArgument] wraps a UnresolvedCallArgument::identifier(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_identifier(self, /):

Returns x if this [PyCallArgument] wraps a UnresolvedCallArgument::identifier(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def is_memory_reference(self, /):

Tests if this [PyCallArgument] wraps a [UnresolvedCallArgument::memory_reference] value

def as_memory_reference(self, /):

Returns x if this [PyCallArgument] wraps a UnresolvedCallArgument::memory_reference(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_memory_reference(self, /):

Returns x if this [PyCallArgument] wraps a UnresolvedCallArgument::memory_reference(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def is_immediate(self, /):

Tests if this [PyCallArgument] wraps a [UnresolvedCallArgument::immediate] value

def as_immediate(self, /):

Returns x if this [PyCallArgument] wraps a UnresolvedCallArgument::immediate(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_immediate(self, /):

Returns x if this [PyCallArgument] wraps a UnresolvedCallArgument::immediate(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def to_quil(self, /):
def to_quil_or_debug(self, /):
class Comparison:
def to_quil(self, /):
def to_quil_or_debug(self, /):
lhs

Get the lhs field from Python. Annotated with @property.

destination

Get the destination field from Python. Annotated with @property.

operator

Get the operator field from Python. Annotated with @property.

rhs

Get the rhs field from Python. Annotated with @property.

class ComparisonOperand:
def from_literal_integer(inner):

The Python wrapper for [ComparisonOperand::LiteralInteger], creating a [PyComparisonOperand] and taking a Python argument.

def from_literal_real(inner):

The Python wrapper for [ComparisonOperand::LiteralReal], creating a [PyComparisonOperand] and taking a Python argument.

def from_memory_reference(inner):

The Python wrapper for [ComparisonOperand::MemoryReference], creating a [PyComparisonOperand] and taking a Python argument.

def inner(self, /):

Directly return the Python version of the variant discriminant wrapped by this value; i.e., performs the match ComparisonOperand::Variant(x) => x for every variant constructor in [ComparisonOperand]

def is_literal_integer(self, /):

Tests if this [PyComparisonOperand] wraps a [ComparisonOperand::literal_integer] value

def as_literal_integer(self, /):

Returns x if this [PyComparisonOperand] wraps a ComparisonOperand::literal_integer(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_literal_integer(self, /):

Returns x if this [PyComparisonOperand] wraps a ComparisonOperand::literal_integer(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def is_literal_real(self, /):

Tests if this [PyComparisonOperand] wraps a [ComparisonOperand::literal_real] value

def as_literal_real(self, /):

Returns x if this [PyComparisonOperand] wraps a ComparisonOperand::literal_real(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_literal_real(self, /):

Returns x if this [PyComparisonOperand] wraps a ComparisonOperand::literal_real(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def is_memory_reference(self, /):

Tests if this [PyComparisonOperand] wraps a [ComparisonOperand::memory_reference] value

def as_memory_reference(self, /):

Returns x if this [PyComparisonOperand] wraps a ComparisonOperand::memory_reference(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_memory_reference(self, /):

Returns x if this [PyComparisonOperand] wraps a ComparisonOperand::memory_reference(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def to_quil(self, /):
def to_quil_or_debug(self, /):
class ComparisonOperator:
class Convert:
def to_quil(self, /):
def to_quil_or_debug(self, /):
source

Get the source field from Python. Annotated with @property.

destination

Get the destination field from Python. Annotated with @property.

class Exchange:
def to_quil(self, /):
def to_quil_or_debug(self, /):
left

Get the left field from Python. Annotated with @property.

right

Get the right field from Python. Annotated with @property.

class ExternParameter:
def to_quil(self, /):
def to_quil_or_debug(self, /):
data_type
mutable
name
class ExternParameterType:
def from_scalar(inner):

The Python wrapper for [ExternParameterType::Scalar], creating a [PyExternParameterType] and taking a Python argument.

def from_fixed_length_vector(inner):

The Python wrapper for [ExternParameterType::FixedLengthVector], creating a [PyExternParameterType] and taking a Python argument.

def from_variable_length_vector(inner):

The Python wrapper for [ExternParameterType::VariableLengthVector], creating a [PyExternParameterType] and taking a Python argument.

def inner(self, /):

Directly return the Python version of the variant discriminant wrapped by this value; i.e., performs the match ExternParameterType::Variant(x) => x for every variant constructor in [ExternParameterType]

def is_scalar(self, /):

Tests if this [PyExternParameterType] wraps a [ExternParameterType::scalar] value

def as_scalar(self, /):

Returns x if this [PyExternParameterType] wraps a ExternParameterType::scalar(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_scalar(self, /):

Returns x if this [PyExternParameterType] wraps a ExternParameterType::scalar(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def is_fixed_length_vector(self, /):

Tests if this [PyExternParameterType] wraps a [ExternParameterType::fixed_length_vector] value

def as_fixed_length_vector(self, /):

Returns x if this [PyExternParameterType] wraps a ExternParameterType::fixed_length_vector(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_fixed_length_vector(self, /):

Returns x if this [PyExternParameterType] wraps a ExternParameterType::fixed_length_vector(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def is_variable_length_vector(self, /):

Tests if this [PyExternParameterType] wraps a [ExternParameterType::variable_length_vector] value

def as_variable_length_vector(self, /):

Returns x if this [PyExternParameterType] wraps a ExternParameterType::variable_length_vector(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_variable_length_vector(self, /):

Returns x if this [PyExternParameterType] wraps a ExternParameterType::variable_length_vector(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def to_quil(self, /):
def to_quil_or_debug(self, /):
class ExternSignature:
def to_quil(self, /):
def to_quil_or_debug(self, /):
parameters
return_type
class Move:
def to_quil(self, /):
def to_quil_or_debug(self, /):
destination

Get the destination field from Python. Annotated with @property.

source

Get the source field from Python. Annotated with @property.

class UnaryLogic:
def to_quil(self, /):
def to_quil_or_debug(self, /):
operator

Get the operator field from Python. Annotated with @property.

operand

Get the operand field from Python. Annotated with @property.

class UnaryOperator:
def to_quil(self, /):
def to_quil_or_debug(self, /):
Neg = Neg
Not = Not
class Calibration:
def to_quil(self, /):
def to_quil_or_debug(self, /):
qubits
modifiers
instructions

Get the instructions field from Python. Annotated with @property.

identifier

Get the identifier field from Python. Annotated with @property.

name
parameters
class CalibrationIdentifier:
def to_quil(self, /):
def to_quil_or_debug(self, /):
name

Get the name field from Python. Annotated with @property.

modifiers

Get the modifiers field from Python. Annotated with @property.

qubits

Get the qubits field from Python. Annotated with @property.

parameters

Get the parameters field from Python. Annotated with @property.

class CircuitDefinition:
def to_quil(self, /):
def to_quil_or_debug(self, /):
qubit_variables

Get the qubit_variables field from Python. Annotated with @property.

parameters

Get the parameters field from Python. Annotated with @property.

name

Get the name field from Python. Annotated with @property.

instructions

Get the instructions field from Python. Annotated with @property.

class MeasureCalibrationDefinition:
def to_quil(self, /):
def to_quil_or_debug(self, /):
identifier

Get the identifier field from Python. Annotated with @property.

parameter
qubit
instructions

Get the instructions field from Python. Annotated with @property.

class MeasureCalibrationIdentifier:
def to_quil(self, /):
def to_quil_or_debug(self, /):
qubit

Get the qubit field from Python. Annotated with @property.

parameter

Get the parameter field from Python. Annotated with @property.

class Declaration:
def to_quil(self, /):
def to_quil_or_debug(self, /):
sharing

Get the sharing field from Python. Annotated with @property.

name

Get the name field from Python. Annotated with @property.

size

Get the size field from Python. Annotated with @property.

class Load:
def to_quil(self, /):
def to_quil_or_debug(self, /):
offset

Get the offset field from Python. Annotated with @property.

destination

Get the destination field from Python. Annotated with @property.

source

Get the source field from Python. Annotated with @property.

class Offset:
def to_quil(self, /):
def to_quil_or_debug(self, /):
offset

Get the offset field from Python. Annotated with @property.

data_type

Get the data_type field from Python. Annotated with @property.

class Sharing:
name

Get the name field from Python. Annotated with @property.

offsets

Get the offsets field from Python. Annotated with @property.

class Store:
def to_quil(self, /):
def to_quil_or_debug(self, /):
destination

Get the destination field from Python. Annotated with @property.

offset

Get the offset field from Python. Annotated with @property.

source

Get the source field from Python. Annotated with @property.

class ScalarType:
def to_quil(self, /):
def to_quil_or_debug(self, /):
Bit = Bit
Integer = Integer
Octet = Octet
Real = Real
class Vector:
def to_quil(self, /):
def to_quil_or_debug(self, /):
length

Get the length field from Python. Annotated with @property.

data_type

Get the data_type field from Python. Annotated with @property.

class Measurement:
def to_quil(self, /):
def to_quil_or_debug(self, /):
qubit

Get the qubit field from Python. Annotated with @property.

target

Get the target field from Python. Annotated with @property.

class Include:
def to_quil(self, /):
def to_quil_or_debug(self, /):
filename

Get the filename field from Python. Annotated with @property.

class Pragma:
def to_quil(self, /):
def to_quil_or_debug(self, /):
name

Get the name field from Python. Annotated with @property.

arguments

Get the arguments field from Python. Annotated with @property.

data

Get the data field from Python. Annotated with @property.

class PragmaArgument:
def from_identifier(inner):

The Python wrapper for [PragmaArgument::Identifier], creating a [PyPragmaArgument] and taking a Python argument.

def from_integer(inner):

The Python wrapper for [PragmaArgument::Integer], creating a [PyPragmaArgument] and taking a Python argument.

def inner(self, /):

Directly return the Python version of the variant discriminant wrapped by this value; i.e., performs the match PragmaArgument::Variant(x) => x for every variant constructor in [PragmaArgument]

def is_identifier(self, /):

Tests if this [PyPragmaArgument] wraps a [PragmaArgument::identifier] value

def as_identifier(self, /):

Returns x if this [PyPragmaArgument] wraps a PragmaArgument::identifier(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_identifier(self, /):

Returns x if this [PyPragmaArgument] wraps a PragmaArgument::identifier(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def is_integer(self, /):

Tests if this [PyPragmaArgument] wraps a [PragmaArgument::integer] value

def as_integer(self, /):

Returns x if this [PyPragmaArgument] wraps a PragmaArgument::integer(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_integer(self, /):

Returns x if this [PyPragmaArgument] wraps a PragmaArgument::integer(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def to_quil(self, /):
def to_quil_or_debug(self, /):
class AttributeValue:
def from_string(inner):

The Python wrapper for [AttributeValue::String], creating a [PyAttributeValue] and taking a Python argument.

def from_expression(inner):

The Python wrapper for [AttributeValue::Expression], creating a [PyAttributeValue] and taking a Python argument.

def inner(self, /):

Directly return the Python version of the variant discriminant wrapped by this value; i.e., performs the match AttributeValue::Variant(x) => x for every variant constructor in [AttributeValue]

def is_string(self, /):

Tests if this [PyAttributeValue] wraps a [AttributeValue::string] value

def as_string(self, /):

Returns x if this [PyAttributeValue] wraps a AttributeValue::string(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_string(self, /):

Returns x if this [PyAttributeValue] wraps a AttributeValue::string(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def is_expression(self, /):

Tests if this [PyAttributeValue] wraps a [AttributeValue::expression] value

def as_expression(self, /):

Returns x if this [PyAttributeValue] wraps a AttributeValue::expression(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_expression(self, /):

Returns x if this [PyAttributeValue] wraps a AttributeValue::expression(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def to_quil(self, /):
def to_quil_or_debug(self, /):
class Capture:
def to_quil(self, /):
def to_quil_or_debug(self, /):
frame

Get the frame field from Python. Annotated with @property.

waveform

Get the waveform field from Python. Annotated with @property.

blocking

Get the blocking field from Python. Annotated with @property.

memory_reference

Get the memory_reference field from Python. Annotated with @property.

class FrameDefinition:
def to_quil(self, /):
def to_quil_or_debug(self, /):
attributes

Get the attributes field from Python. Annotated with @property.

identifier

Get the identifier field from Python. Annotated with @property.

class FrameIdentifier:
def to_quil(self, /):
def to_quil_or_debug(self, /):
qubits

Get the qubits field from Python. Annotated with @property.

name

Get the name field from Python. Annotated with @property.

class Pulse:
def to_quil(self, /):
def to_quil_or_debug(self, /):
waveform

Get the waveform field from Python. Annotated with @property.

blocking

Get the blocking field from Python. Annotated with @property.

frame

Get the frame field from Python. Annotated with @property.

class RawCapture:
def to_quil(self, /):
def to_quil_or_debug(self, /):
duration

Get the duration field from Python. Annotated with @property.

blocking

Get the blocking field from Python. Annotated with @property.

memory_reference

Get the memory_reference field from Python. Annotated with @property.

frame

Get the frame field from Python. Annotated with @property.

class SetFrequency:
def to_quil(self, /):
def to_quil_or_debug(self, /):
frame

Get the frame field from Python. Annotated with @property.

frequency

Get the frequency field from Python. Annotated with @property.

class SetPhase:
def to_quil(self, /):
def to_quil_or_debug(self, /):
phase

Get the phase field from Python. Annotated with @property.

frame

Get the frame field from Python. Annotated with @property.

class SetScale:
def to_quil(self, /):
def to_quil_or_debug(self, /):
frame

Get the frame field from Python. Annotated with @property.

scale

Get the scale field from Python. Annotated with @property.

class ShiftFrequency:
def to_quil(self, /):
def to_quil_or_debug(self, /):
frequency

Get the frequency field from Python. Annotated with @property.

frame

Get the frame field from Python. Annotated with @property.

class ShiftPhase:
def to_quil(self, /):
def to_quil_or_debug(self, /):
phase

Get the phase field from Python. Annotated with @property.

frame

Get the frame field from Python. Annotated with @property.

class SwapPhases:
def to_quil(self, /):
def to_quil_or_debug(self, /):
frame_1

Get the frame_1 field from Python. Annotated with @property.

frame_2

Get the frame_2 field from Python. Annotated with @property.

class Gate:
def to_quil(self, /):
def to_quil_or_debug(self, /):
def dagger(self, /):
def controlled(self, /, control_qubit):
def forked(self, /, fork_qubit, alt_params):
def to_unitary_mut(self, /, n_qubits):
modifiers

Get the modifiers field from Python. Annotated with @property.

qubits

Get the qubits field from Python. Annotated with @property.

name

Get the name field from Python. Annotated with @property.

parameters

Get the parameters field from Python. Annotated with @property.

class GateDefinition:
def to_quil(self, /):
def to_quil_or_debug(self, /):
name

Get the name field from Python. Annotated with @property.

parameters

Get the parameters field from Python. Annotated with @property.

specification

Get the specification field from Python. Annotated with @property.

class GateModifier:
def to_quil(self, /):
def to_quil_or_debug(self, /):
Controlled = Controlled
Dagger = Dagger
Forked = Forked
class GateSpecification:
def from_matrix(inner):

The Python wrapper for [GateSpecification::Matrix], creating a [PyGateSpecification] and taking a Python argument.

def from_permutation(inner):

The Python wrapper for [GateSpecification::Permutation], creating a [PyGateSpecification] and taking a Python argument.

def from_pauli_sum(inner):

The Python wrapper for [GateSpecification::PauliSum], creating a [PyGateSpecification] and taking a Python argument.

def inner(self, /):

Directly return the Python version of the variant discriminant wrapped by this value; i.e., performs the match GateSpecification::Variant(x) => x for every variant constructor in [GateSpecification]

def is_matrix(self, /):

Tests if this [PyGateSpecification] wraps a [GateSpecification::matrix] value

def as_matrix(self, /):

Returns x if this [PyGateSpecification] wraps a GateSpecification::matrix(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_matrix(self, /):

Returns x if this [PyGateSpecification] wraps a GateSpecification::matrix(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def is_permutation(self, /):

Tests if this [PyGateSpecification] wraps a [GateSpecification::permutation] value

def as_permutation(self, /):

Returns x if this [PyGateSpecification] wraps a GateSpecification::permutation(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_permutation(self, /):

Returns x if this [PyGateSpecification] wraps a GateSpecification::permutation(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def is_pauli_sum(self, /):

Tests if this [PyGateSpecification] wraps a [GateSpecification::pauli_sum] value

def as_pauli_sum(self, /):

Returns x if this [PyGateSpecification] wraps a GateSpecification::pauli_sum(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_pauli_sum(self, /):

Returns x if this [PyGateSpecification] wraps a GateSpecification::pauli_sum(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def to_quil(self, /):
def to_quil_or_debug(self, /):
class PauliGate:
def parse(input):

Implements a static parse method for Python in terms of the Rust FromStr instance.

I = I
X = X
Y = Y
Z = Z
class PauliTerm:
expression

Get the expression field from Python. Annotated with @property.

arguments

Get the arguments field from Python. Annotated with @property.

class PauliSum:
arguments

Get the arguments field from Python. Annotated with @property.

terms

Get the terms field from Python. Annotated with @property.

class Jump:
def to_quil(self, /):
def to_quil_or_debug(self, /):
target

Get the target field from Python. Annotated with @property.

class JumpWhen:
def to_quil(self, /):
def to_quil_or_debug(self, /):
condition

Get the condition field from Python. Annotated with @property.

target

Get the target field from Python. Annotated with @property.

class JumpUnless:
def to_quil(self, /):
def to_quil_or_debug(self, /):
target

Get the target field from Python. Annotated with @property.

condition

Get the condition field from Python. Annotated with @property.

class Label:
def to_quil(self, /):
def to_quil_or_debug(self, /):
target

Get the target field from Python. Annotated with @property.

class Target:
def from_fixed(inner):

The Python wrapper for [Target::Fixed], creating a [PyTarget] and taking a Python argument.

def from_placeholder(inner):

The Python wrapper for [Target::Placeholder], creating a [PyTarget] and taking a Python argument.

def inner(self, /):

Directly return the Python version of the variant discriminant wrapped by this value; i.e., performs the match Target::Variant(x) => x for every variant constructor in [Target]

def is_fixed(self, /):

Tests if this [PyTarget] wraps a [Target::fixed] value

def as_fixed(self, /):

Returns x if this [PyTarget] wraps a Target::fixed(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_fixed(self, /):

Returns x if this [PyTarget] wraps a Target::fixed(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def is_placeholder(self, /):

Tests if this [PyTarget] wraps a [Target::placeholder] value

def as_placeholder(self, /):

Returns x if this [PyTarget] wraps a Target::placeholder(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_placeholder(self, /):

Returns x if this [PyTarget] wraps a Target::placeholder(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def to_quil(self, /):
def to_quil_or_debug(self, /):
class TargetPlaceholder:
base_label
class MemoryReference:
def to_quil(self, /):
def to_quil_or_debug(self, /):
def parse(input):

Implements a static parse method for Python in terms of the Rust FromStr instance.

index

Get the index field from Python. Annotated with @property.

name

Get the name field from Python. Annotated with @property.

class Qubit:
def from_fixed(inner):

The Python wrapper for [Qubit::Fixed], creating a [PyQubit] and taking a Python argument.

def from_variable(inner):

The Python wrapper for [Qubit::Variable], creating a [PyQubit] and taking a Python argument.

def from_placeholder(inner):

The Python wrapper for [Qubit::Placeholder], creating a [PyQubit] and taking a Python argument.

def inner(self, /):

Directly return the Python version of the variant discriminant wrapped by this value; i.e., performs the match Qubit::Variant(x) => x for every variant constructor in [Qubit]

def is_fixed(self, /):

Tests if this [PyQubit] wraps a [Qubit::fixed] value

def as_fixed(self, /):

Returns x if this [PyQubit] wraps a Qubit::fixed(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_fixed(self, /):

Returns x if this [PyQubit] wraps a Qubit::fixed(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def is_variable(self, /):

Tests if this [PyQubit] wraps a [Qubit::variable] value

def as_variable(self, /):

Returns x if this [PyQubit] wraps a Qubit::variable(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_variable(self, /):

Returns x if this [PyQubit] wraps a Qubit::variable(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def is_placeholder(self, /):

Tests if this [PyQubit] wraps a [Qubit::placeholder] value

def as_placeholder(self, /):

Returns x if this [PyQubit] wraps a Qubit::placeholder(x); otherwise returns (Python) None. On the Rust side, this corresponds to either Some(x) or [None].

def to_placeholder(self, /):

Returns x if this [PyQubit] wraps a Qubit::placeholder(x); otherwise raises a ValueError. On the Rust side, this corresponds to either Ok(x) or Err(...).

def to_quil(self, /):
def to_quil_or_debug(self, /):
class QubitPlaceholder:
class Reset:
def to_quil(self, /):
def to_quil_or_debug(self, /):
qubit

Get the qubit field from Python. Annotated with @property.

class Delay:
def to_quil(self, /):
def to_quil_or_debug(self, /):
frame_names

Get the frame_names field from Python. Annotated with @property.

qubits

Get the qubits field from Python. Annotated with @property.

duration

Get the duration field from Python. Annotated with @property.

class Fence:
def to_quil(self, /):
def to_quil_or_debug(self, /):
qubits

Get the qubits field from Python. Annotated with @property.

class Waveform:
matrix

Get the matrix field from Python. Annotated with @property.

parameters

Get the parameters field from Python. Annotated with @property.

class WaveformDefinition:
def to_quil(self, /):
def to_quil_or_debug(self, /):
definition

Get the definition field from Python. Annotated with @property.

name

Get the name field from Python. Annotated with @property.

class WaveformInvocation:
def to_quil(self, /):
def to_quil_or_debug(self, /):
parameters

Get the parameters field from Python. Annotated with @property.

name

Get the name field from Python. Annotated with @property.

class CallError(builtins.ValueError):

Inappropriate argument value (of correct type).

class ExternError(builtins.ValueError):

Inappropriate argument value (of correct type).

class GateError(builtins.ValueError):

Inappropriate argument value (of correct type).

class ParseMemoryReferenceError(builtins.ValueError):

Inappropriate argument value (of correct type).