ipdassembly

Golden Gate assembly library design: split designs to a chip oligo length, pick overhangs with a greedy solver and/or a genetic algorithm, reverse-translate protein input, clear enzyme sites by synonymous substitution, add adapters/primers/padding, report a per-design success probability, and QC by in-silico digest and re-assembly.

pip install "ipdassembly[all]"

or use it with no install at all — it is pure Python with its data bundled, so sys.path.insert(0, "IPDassembly/src") is enough if you already have numpy, pandas, biopython and tqdm. See docs/install.md.

from ipd_assembly import Config, Designer

d = Designer(Config(vector="LM0627", oligo_length=230, designs_per_rxn=8))
df = d.run(fasta_files=["library.fa"])

ipdassembly run library.fa --oligo-length 230 --designs-per-rxn 8

Or use a notebook — two ship, differing only in how they install and where files come from:

Documentation

What it takes as input

Either way the vector is separate from the FASTA and can be a registered name, a backbone sequence, the two sticky ends outright, or nothing at all ("None" / "None-BsaI") when the fragments carry their own ends. See docs/input-modes.md.

Several libraries in one order. Pass more than one FASTA and each becomes a subpool with its own plates and its own primers, so they share a chip but still amplify apart. Libraries needing different vectors or oligo lengths — or a predefined set alongside protein designs — go through order_chip. See docs/chip-orders.md.

Designing and ordering are two steps, because the slow half (splitting, choosing overhangs) and the instant half (adapters, primers, padding, addressing) have different scopes — so changing the chip layout costs a second, not a re-solve.

from ipd_assembly import Config, Subpool, design_campaign, build_order

lib = design_campaign([
    Subpool("binders",  "binders.fa",  input_type="protein", vector="LM0627", pooled=True),
    Subpool("controls", "controls.fa", input_type="protein", vector="LM0627", pooled=False),
    Subpool("presets",  "presets.fa",  vector="None-BsaI", input_mode="predefined_set"),
], base=Config(oligo_length=300))

order = build_order(lib, output_prefix="out/run7_")

Three things to decide before anything else

Everything downstream follows from these, and none of them has a defensible default.

The fourth number — designs per reaction — you should not decide: it is measured from your own sequences in well under a second.

d.recommend_designs_per_rxn(sequences, off_target_allowed=12)
# -> {"designs_per_rxn": 7, "n_fragments": 4, "pool_fidelity": 0.79, ...}

d.plan_pooling(sequences, target=15)      # or ask for a number and be told what it costs

docs/pooling.md has the measured tables behind both.

Pipeline

FASTA ─┬─ DNA ───────────────────────────────┐
       ├─ protein → reverse translate ───────┤
       └─ Set<N>- names → predefined set ────┤   (fragments taken as given)
            ↓  domesticate (clear pre-existing enzyme sites)
            ↓  split to the oligo length
     greedy MRV/LCV overhang pick (~5 ms) ── pool filled → done
            ↓  pool not filled
     GA seeded from the greedy solution (~10 s)
            ↓  designs still unplaced
     synonymous codon swap → reshuffle → retry
            ↓
     pool fidelity → per-design success probability
            ↓
     enzyme adapters / vector sticky ends / nested PCR primers / padding
            ↓
     QC: primer placement, cut counts, re-assembly, translation
            ↓
     CSV + fragments / oligos / new-template FASTA

Oligo layout — the pad sits on the 3' side, so the forward primer abuts the enzyme site:

F1 ── enzyme site ── (sticky) ── fragment ── (sticky) ── enzyme site ── pad ── R2 ── R1
└──────────────────── oligo_length when pad_to_fixed_length=True ────────────────────┘

Tests

pip install -e ".[dev]"
pytest -q          # ~140 tests, ~3 min

tests/test_golden.py pins output against the validated reference implementation — discrete columns byte-for-byte, fidelity floats to 16 ULP. tests/test_determinism.py runs the pipeline under two different PYTHONHASHSEED values and requires identical output. tests/test_notebook.py executes every cell of the shipped notebook.

License

Code: MIT — see LICENSE.

Bundled data: the overhang-ligation matrices are from Pryor JM et al. (2020) PLoS ONE 15(9): e0238592, used under CC BY 4.0 — see NOTICE, docs/enzymes.md and src/ipd_assembly/data/SOURCES.md.