Boltz

Boltz module for the Rush Python client.

Boltz predicts folded structures from protein sequences, optional ligands, and MSA inputs. The fetched output is parsed into Python-friendly result objects, while the saved output writes the model and JSON artifacts into the workspace.

Usage:

from rush import boltz

result = boltz.fold([ProteinSequence(...)]).fetch()
print(next(result).metrics.confidence_score)

class rush.boltz.Affinities(affinity_pred_value, affinity_probability_binary, affinity_pred_value1, affinity_probability_binary1, affinity_pred_value2, affinity_probability_binary2)

Bases: object

Optional affinity predictions returned for binding runs.

Parameters:

• affinity_pred_value (float)

• affinity_probability_binary (float)

• affinity_pred_value1 (float)

• affinity_probability_binary1 (float)

• affinity_pred_value2 (float)

• affinity_probability_binary2 (float)

affinity_pred_value: float

affinity_pred_value1: float

affinity_pred_value2: float

affinity_probability_binary: float

affinity_probability_binary1: float

affinity_probability_binary2: float

class rush.boltz.DiffusionSampleRef(model, metrics, plddt, pae, affinities)

Bases: object

Parsed reference to a single Boltz diffusion sample.

Parameters:

• model (TRCRef)

• metrics (dict[str, Any])

• plddt (RushObject)

• pae (RushObject)

• affinities (dict[str, Any] | None)

affinities: dict[str, Any] | None

metrics: dict[str, Any]

model: TRCRef

pae: RushObject

plddt: RushObject

class rush.boltz.LigandSequence(id: list[str], smiles: str)

Bases: object

Parameters:

• id (list[str])

• smiles (str)

id: list[str]

smiles: str

class rush.boltz.Metrics(confidence_score, ptm, iptm, ligand_iptm, protein_iptm, complex_plddt, complex_iplddt, complex_pde, complex_ipde)

Bases: object

Summary confidence metrics returned by Boltz.

Parameters:

• confidence_score (float)

• ptm (float)

• iptm (float)

• ligand_iptm (float)

• protein_iptm (float)

• complex_plddt (float)

• complex_iplddt (float)

• complex_pde (float)

• complex_ipde (float)

complex_ipde: float

complex_iplddt: float

complex_pde: float

complex_plddt: float

confidence_score: float

iptm: float

ligand_iptm: float

protein_iptm: float

ptm: float

class rush.boltz.Modification(position: int, ccd: str)

Bases: object

Parameters:

• position (int)

• ccd (str)

ccd: str

position: int

class rush.boltz.ProteinSequence(id: list[str], sequence: str, msa: pathlib.Path | str | RushObject, modifications: list[Modification] | None = None, cyclic: bool | None = None)

Bases: object

Parameters:

• id (list[str])

• sequence (str)

• msa (Path | str | RushObject)

• modifications (list[Modification] | None)

• cyclic (bool | None)

cyclic: bool | None = None

id: list[str]

modifications: list[Modification] | None = None

msa: Path | str | RushObject

sequence: str

class rush.boltz.Result(model, metrics, plddt, pae, affinities=None)

Bases: object

Parsed Boltz fold result.

Returned by ResultRef.fetch() — one per diffusion sample.

Parameters:

• model (TRC)

• metrics (Metrics)

• plddt (ndarray[tuple[Any, ...], dtype[float32]])

• pae (ndarray[tuple[Any, ...], dtype[float32]])

• affinities (Affinities | None)

affinities: Affinities | None = None

metrics: Metrics

model: TRC

pae: ndarray[tuple[Any, ...], dtype[float32]]

plddt: ndarray[tuple[Any, ...], dtype[float32]]

class rush.boltz.ResultPaths(model, metrics, plddt, pae, affinities=None)

Bases: object

Workspace paths for a saved Boltz result bundle.

Parameters:

• model (TRCPaths)

• metrics (Path)

• plddt (Path)

• pae (Path)

• affinities (Path | None)

affinities: Path | None = None

metrics: Path

model: TRCPaths

pae: Path

plddt: Path

class rush.boltz.ResultRef(diffusion_samples)

Bases: object

Lightweight reference to Boltz outputs in the Rush object store.

Each element of samples is a parsed DiffusionSampleRef for one diffusion sample.

Parameters:

diffusion_samples (list[DiffusionSampleRef])

classmethod from_raw_output(res)

Parse raw collect_run output into a ResultRef.

Parameters:

res (Any)

Return type:

ResultRef

fetch()

Download Boltz outputs and parse into Python objects.

Yields one Result per diffusion sample. Each sample is downloaded lazily on iteration — stop early to skip downloads.

Return type:

Iterator[Result]

save()

Download Boltz outputs and save to the workspace.

Yields one ResultPaths per diffusion sample. Each sample is downloaded lazily on iteration — stop early to skip downloads.

Return type:

Iterator[ResultPaths]

diffusion_samples: list[DiffusionSampleRef]

rush.boltz.fold(sequences, recycling_steps=None, sampling_steps=None, diffusion_samples=None, step_scale=None, affinity_binder_chain_id=None, affinity_mw_correction=None, sampling_steps_affinity=None, diffusion_samples_affinity=None, max_msa_seqs=None, subsample_msa=None, num_subsampled_msa=None, use_potentials=None, seed=None, template_path=None, template_threshold_angstroms=None, template_chain_mapping=None, run_spec=RunSpec(gpus=1), run_opts=RunOpts())

Submit a Boltz fold job for the given protein/ligand sequences.

Returns a RushRun handle. Call .collect() to get a ResultRef, then .fetch() or .save() on that ref.

Parameters:

• sequences (list[ProteinSequence | LigandSequence])

• recycling_steps (int | None)

• sampling_steps (int | None)

• diffusion_samples (int | None)

• step_scale (float | None)

• affinity_binder_chain_id (str | None)

• affinity_mw_correction (bool | None)

• sampling_steps_affinity (int | None)

• diffusion_samples_affinity (bool | None)

• max_msa_seqs (int | None)

• subsample_msa (bool | None)

• num_subsampled_msa (int | None)

• use_potentials (bool | None)

• seed (int | None)

• template_path (Path | str | None)

• template_threshold_angstroms (float | None)

• template_chain_mapping (dict[str, str] | None)

• run_spec (RunSpec)

• run_opts (RunOpts)

Return type:

RushRun[ResultRef]