GRASP Library Designer

Codon-optimize GRASP (Farley et al., NAR 2025) binder DNA for Golden Gate assembly.

PyPI: grasp-library-designer · Import: grasp_library · Python: ≥3.10 · License: AGPL-3.0

What this is

GRASP is a modular PPR (pentatricopeptide repeat) RNA-binding protein platform. Binders are assembled from level −1 DNA modules with fixed Golden Gate overhangs. This package redesigns those DNA sequences (synonymous codons only) so that:

1. Ligation fidelity of the Golden Gate overhang set is high (Potapov / GGAssembler tables)
2. Codon usage matches a chosen organism table (Kazusa or custom)
3. Synthesis fitness stays within vendor constraints (GC, homopolymers, repeats, forbidden sites)

Protein sequence is never changed. Coding Golden Gate overhang bases stay locked via a per-part coding_mask.

Two entry points:

Open in Google Colab

Click a badge → run 0 · Install (PyPI) → fill the forms top to bottom. No GitHub token needed.

Notebook	Open
One-shot (one RNA → free GGA oligos)
Library (42-module redesign → GAP compile)

Each notebook installs with:

%pip install -q -U "grasp-library-designer>=0.1.5"

Bundled GenBank modules and Potapov ligation tables ship inside the PyPI package (materialize_project()).

Install locally

pip install grasp-library-designer
# optional notebook extras
pip install "grasp-library-designer[notebook]"

from grasp_library import materialize_project, build_default_config, LigationFidelityCalculator

project = materialize_project()  # ./grasp_library_project + GenBank
config = build_default_config(project / "input")
print(LigationFidelityCalculator(25, 18).set_fidelity(["AATG", "GATA"]))

Write the Forms notebooks to disk from a blank environment:

%pip install -q -U grasp-library-designer
from grasp_library import write_notebook
write_notebook("oneshot")   # or "library"

Repository layout

grasp_library/                      # installable Python package
  binder.py                         # RNA → PPR code → binder AA
  oneshot.py                        # one-shot design pipeline
  workflows.py                      # library redesign / anneal / GAP compile
  optimizer.py                      # masked codon + synthesis anneal
  objectives.py                     # fidelity / codon / synthesis scores
  pareto.py                         # multi-objective overhang search
  ligation_fidelity.py              # Potapov table wrapper
  import_grasp.py                   # GenBank → parts / junctions / GAP
  gga_split.py                      # free cut-site planner (one-shot)
  codon_*.py / kazusa.py            # codon tables & organism validation
  control_panel.py                  # notebook widgets + default config
  paths.py                          # materialize_project()
  data/profiles/grasp_nar2025/      # bundled GenBank modules
  notebooks/                        # Colab Forms notebooks
third_party/dawdlib_golden_gate/    # vendored GGAssembler fidelity (AGPL)
grasp_library_project/              # writable working tree (created locally)
  input/                            # parts, junctions, codon table, config
  output/                           # oligos, Pareto CSVs, assembly plans
  profiles/.../genbank/             # copied GenBank for import
grasp_oneshot_designer.ipynb        # Colab / Jupyter UI (one-shot)
grasp_library_designer.ipynb        # Colab / Jupyter UI (library)

Project folder (grasp_library_project/)

Created by materialize_project(). Standard paths:

Regenerate notebook inputs from GenBank:

python -m grasp_library.import_grasp

Or in Python:

from grasp_library import project_paths, ensure_grasp_imported

paths = project_paths()
tables = ensure_grasp_imported(
    profile_genbank_dir=paths["profile_genbank"],
    input_dir=paths["input"],
)

GRASP profile (Farley et al., NAR 2025)

• Paper: https://academic.oup.com/nar/article/53/20/gkaf1169/8321212
• Upstream data: https://github.com/farleykvdg/GRASP
• Bundled: GRASP_-1.gb (42 modules) + individual pPR-1_*.gb plasmids

Default 9S overhang set (cut indices are fixed; bases may be synonym-swapped):

AGGT – ACTC – AAGA – GCAC – TGAA – CTTC – ACTC – AAGA – GCAC – TGAA – TTCG

B/C/D junctions are shared across CDS1/CDS2, so redesign uses 7 unique junction variables (J_Nterm … J_Cterm). Prefer 1A_*_AGGT for MoClo N-terminal fusion; AATG variants are kept as alternate parts.

Pipelines

One-shot (run_oneshot_design)

No combinatorial library. Builds a continuous binder from the PPR recognition code.

1. RNA → protein — target length must be 9, 14, or 19 nt; classic PPR pairs (5th, last) fill a GRASP repeat scaffold
2. Anneal full CDS — synonymous codon + synthesis optimization (coding_mask all N)
3. Plan GGA cuts — choose codon-aligned overhangs already present in the DNA that form a high-fidelity set
4. Export oligos — flanks + fragment DNA (FASTA / CSV)

from grasp_library import (
    materialize_project,
    build_default_config,
    apply_organism_codon_table,
    run_oneshot_design,
)

project = materialize_project()
config = build_default_config(project / "input")
codon_data = apply_organism_codon_table(
    project / "input",
    "Chlamydomonas reinhardtii nuclear (Kazusa)",
)
result = run_oneshot_design(
    target_rna="UUACACGUG",
    codon_data=codon_data,
    config=config,
    output_dir=project / "output",
)

Library (run_library_redesign_and_anneal → GAP compile)

Redesigns the shared module catalog, then picks parts for a target RNA.

1. Import GenBank → parts.csv, junction map, overhang candidates
2. Pareto overhang redesign (optional) — search synonym-compatible 4-mers; score ligation fidelity, codon optimality, synthesis; pick knee / max-fidelity
3. Write overhangs into masks — lock chosen 4-mers at fixed cut indices
4. Anneal library — masked CDS optimization for every module → oligos
5. Rescore / plot Pareto (optional) — uniform post-anneal scores
6. GAP compile — pick modules for a target RNA and stitch assembled CDS + ordered oligos

from grasp_library import (
    project_paths,
    build_default_config,
    apply_organism_codon_table,
    ensure_grasp_imported,
    run_library_redesign_and_anneal,
    export_optimized_library,
    compile_and_assemble_target,
)

paths = project_paths()
config = build_default_config(paths["input"])
codon_data = apply_organism_codon_table(
    paths["input"],
    "Chlamydomonas reinhardtii nuclear (Kazusa)",
)
tables = ensure_grasp_imported(
    profile_genbank_dir=paths["profile_genbank"],
    input_dir=paths["input"],
)
result = run_library_redesign_and_anneal(
    parts=tables["parts"],
    codon_data=codon_data,
    config=config,
    input_dir=paths["input"],
    output_dir=paths["output"],
)
export_optimized_library(
    result["optimized_library"],
    paths["output"],
    selected_overhangs=result["selected_overhangs"],
)
assembly = compile_and_assemble_target(
    target_rna="UUACACGUG",
    optimized_library=result["optimized_library"],
    config=config,
    input_dir=paths["input"],
    output_dir=paths["output"],
    codon_data=codon_data,
)

Typical library outputs

Design constraints and objectives

Hard constraints

• Synonymous redesign only (protein fixed)
• Coding overhang bases locked in coding_mask (N = free, A/C/G/T = fixed)
• Forbidden restriction sites from config (default BsaI / BpiI / BsmBI)
• Translation must match the organism codon table / genetic code

Objectives (all maximized)

Weights and anneal schedule live under weights: and optimizer: in config.yaml.

Config highlights (input/config.yaml)

Notebook control panels write this file via GraspControlPanel / build_default_config.

Binder protein (PPR code)

Classic recognition pairs (5th AA, last AA of each ~31-aa repeat):

Scaffold: N-terminal solvating helix + one repeat per base (W{fifth}AM…PER{last}VVS), matching Farley et al. 9S native assemblies. Target RNA length must be 9, 14, or 19.

from grasp_library import describe_binder
print(describe_binder("UUACACGUG"))

Package API (selected)

Full public surface is listed in grasp_library.__all__.

Develop from source

git clone https://github.com/JustABiologist/grasp-library-designer.git
cd grasp-library-designer
python3 -m venv .venv
source .venv/bin/activate
pip install -e ".[notebook,dev]"

Build / publish (maintainers):

python -m build
twine check dist/*

Citation and license

Software: AGPL-3.0 (required by the vendored GGAssembler / dawdlib ligation engine). See LICENSE and THIRD_PARTY_LICENSES.md.

GRASP sequences / biology: Farley et al., Nucleic Acids Research 2025 — https://academic.oup.com/nar/article/53/20/gkaf1169/8321212

Ligation frequency data: Potapov et al., ACS Synthetic Biology (2018), via Fleishman-Lab/GGAssembler.