Adaptyv Bio

pip install adaptyvbio requests pandas
# Set API key as environment variable
export ADAPTYV_API_KEY="your_api_key_here"

import adaptyvbio as ab
import os

# Initialize client
client = ab.Client(api_key=os.environ["ADAPTYV_API_KEY"])

# List available experiment types
experiment_types = client.get_experiment_types()
for et in experiment_types:
    print(f"  {et['name']}: {et['description']}")

import adaptyvbio as ab
import os

client = ab.Client(api_key=os.environ["ADAPTYV_API_KEY"])

# Submit a single protein sequence for expression
sequence = "MAQRITLPSGMKELRLSYNMGEIVYKIEPVGSIVHIEYYDPENKDTLVNKPSDIVELTMPGKLVVENAKTFAEK"

submission = client.submit_experiment(
    experiment_type="expression",   # "expression" or "binding"
    sequences=[sequence],
    metadata={
        "project": "nanobody_optimization_round1",
        "designer": "ESM2_1000_candidates",
    }
)

experiment_id = submission["experiment_id"]
print(f"Submitted experiment: {experiment_id}")
print(f"Status: {submission['status']}")
print(f"Estimated completion: {submission.get('estimated_completion', 'N/A')}")

# Submit batch of sequences (up to 96 per experiment)
import pandas as pd

# Load candidate sequences from CSV
candidates = pd.read_csv("esm_candidates.csv")  # columns: name, sequence, score
top_candidates = candidates.nlargest(48, "score")

sequences = top_candidates["sequence"].tolist()
names = top_candidates["name"].tolist()

batch_submission = client.submit_experiment(
    experiment_type="binding",
    sequences=sequences,
    sequence_names=names,
    target="target_protein_name",  # registered target in your Adaptyv account
    metadata={"round": 2, "parent_experiment": experiment_id}
)
print(f"Batch experiment: {batch_submission['experiment_id']}")
print(f"Sequences submitted: {len(sequences)}")

import adaptyvbio as ab
import os
import time

client = ab.Client(api_key=os.environ["ADAPTYV_API_KEY"])
experiment_id = "exp_abc123"  # from submission step

# Check current status
status = client.get_experiment_status(experiment_id)
print(f"Status: {status['status']}")  # "pending", "running", "complete", "failed"
print(f"Progress: {status.get('progress', 0):.0%}")

# Poll until complete (with timeout)
max_wait_hours = 72
poll_interval_minutes = 30
timeout = max_wait_hours * 3600

start = time.time()
while time.time() - start < timeout:
    status = client.get_experiment_status(experiment_id)
    print(f"[{time.strftime('%H:%M')}] Status: {status['status']}")
    if status["status"] in ("complete", "failed"):
        break
    time.sleep(poll_interval_minutes * 60)

print(f"Final status: {status['status']}")

import adaptyvbio as ab
import pandas as pd
import os

client = ab.Client(api_key=os.environ["ADAPTYV_API_KEY"])
experiment_id = "exp_abc123"

# Get results (only available when status is "complete")
results = client.get_experiment_results(experiment_id)

# Convert to DataFrame
records = []
for result in results["results"]:
    records.append({
        "name": result.get("sequence_name", "unnamed"),
        "sequence": result["sequence"],
        "kd_nM": result.get("kd_nM"),          # binding dissociation constant
        "yield_ug": result.get("yield_ug"),      # expression yield
        "expression_pass": result.get("expression_pass"),
        "binding_pass": result.get("binding_pass"),
    })

df = pd.DataFrame(records)
df = df.sort_values("kd_nM", ascending=True)  # rank by affinity (lower KD = tighter binding)

print(f"Results: {len(df)} sequences")
print(f"Successfully expressed: {df['expression_pass'].sum()}")
print(f"KD range: {df['kd_nM'].min():.2f} – {df['kd_nM'].max():.2f} nM")
print(df[["name", "kd_nM", "yield_ug", "expression_pass"]].head(10).to_string())

df.to_csv(f"{experiment_id}_results.csv", index=False)

import adaptyvbio as ab
import pandas as pd
import os

client = ab.Client(api_key=os.environ["ADAPTYV_API_KEY"])

# List all experiments
experiments = client.list_experiments(project="nanobody_optimization")
print(f"Total experiments: {len(experiments)}")

for exp in experiments:
    print(f"  {exp['experiment_id']}: {exp['status']} | "
          f"{exp['n_sequences']} seqs | {exp['created_at'][:10]}")

# Retrieve all results across experiments for a project
all_results = []
for exp in experiments:
    if exp["status"] == "complete":
        results = client.get_experiment_results(exp["experiment_id"])
        for r in results["results"]:
            r["experiment_id"] = exp["experiment_id"]
            r["round"] = exp.get("metadata", {}).get("round", "unknown")
            all_results.append(r)

project_df = pd.DataFrame(all_results)
print(f"\nAll results: {len(project_df)} sequences across {len(experiments)} experiments")
print(f"Best KD: {project_df['kd_nM'].min():.3f} nM")

import adaptyvbio as ab
import pandas as pd
import numpy as np
import os

client = ab.Client(api_key=os.environ["ADAPTYV_API_KEY"])

def run_design_iteration(previous_results_df, n_new_candidates=48):
    """
    Closed-loop protein engineering iteration.
    Input: DataFrame with sequence, kd_nM from previous round
    Output: submitted experiment_id for new round
    """
    # Select top performers as parents for next round
    parents = previous_results_df.nsmallest(5, "kd_nM")["sequence"].tolist()
    print(f"Top parent KDs: {previous_results_df.nsmallest(5, 'kd_nM')['kd_nM'].values}")

    # --- Placeholder for computational design step ---
    # In practice: call ESM, ProteinMPNN, or mutation scanning here
    # new_sequences = design_model.generate(parents, n=n_new_candidates)
    # For demonstration, create random variants:
    new_sequences = [p[:20] + "X" * 10 + p[30:] for p in parents[:3]]  # placeholder

    # Submit new candidates
    submission = client.submit_experiment(
        experiment_type="binding",
        sequences=new_sequences,
        metadata={"round": "auto", "parent_kd_min": parents[0] if parents else None}
    )
    print(f"Round submitted: {submission['experiment_id']}")
    return submission["experiment_id"]

# Example: load round 1 results and start round 2
round1 = pd.read_csv("exp_round1_results.csv")
if not round1.empty:
    next_id = run_design_iteration(round1)
    print(f"Round 2 experiment ID: {next_id}")

import adaptyvbio as ab
import pandas as pd
import os
import time

client = ab.Client(api_key=os.environ["ADAPTYV_API_KEY"])

ROUNDS = 3
CANDIDATES_PER_ROUND = 48
TARGET = "your_target_protein"

all_data = pd.DataFrame()

for round_num in range(1, ROUNDS + 1):
    print(f"\n=== Round {round_num} ===")

    # Step 1: Generate candidates (replace with actual design model)
    if round_num == 1:
        sequences = ["MAQRITLPSGMKELRL" + "A" * 20 for _ in range(CANDIDATES_PER_ROUND)]
    else:
        parents = all_data.nsmallest(5, "kd_nM")["sequence"].tolist()
        # In practice: sequences = design_model.generate_variants(parents, n=CANDIDATES_PER_ROUND)
        sequences = parents[:CANDIDATES_PER_ROUND]  # placeholder

    # Step 2: Submit
    submission = client.submit_experiment(
        experiment_type="binding",
        sequences=sequences,
        target=TARGET,
        metadata={"round": round_num}
    )
    exp_id = submission["experiment_id"]
    print(f"Submitted {len(sequences)} sequences: {exp_id}")

    # Step 3: Wait for results (skip in demo; poll in production)
    # time.sleep(72 * 3600)

    # Step 4: Retrieve results
    results = client.get_experiment_results(exp_id)
    round_df = pd.DataFrame(results["results"])
    round_df["round"] = round_num
    all_data = pd.concat([all_data, round_df], ignore_index=True)

    best = round_df.nsmallest(1, "kd_nM").iloc[0]
    print(f"Best KD this round: {best['kd_nM']:.2f} nM")

all_data.to_csv("directed_evolution_all_rounds.csv", index=False)
print(f"\nFinal best KD: {all_data['kd_nM'].min():.3f} nM")

import adaptyvbio as ab
import pandas as pd
import matplotlib.pyplot as plt
import os

client = ab.Client(api_key=os.environ["ADAPTYV_API_KEY"])

# Retrieve completed experiment results and rank
exp_id = "exp_completed_123"
results = client.get_experiment_results(exp_id)
df = pd.DataFrame(results["results"])
df = df.dropna(subset=["kd_nM"]).sort_values("kd_nM")

# Summary statistics
print(f"Sequences tested: {len(df)}")
print(f"Expression success rate: {df['expression_pass'].mean():.0%}")
print(f"Binding positives (KD < 100 nM): {(df['kd_nM'] < 100).sum()}")

# Rank plot
fig, ax = plt.subplots(figsize=(10, 4))
ax.semilogy(range(len(df)), df["kd_nM"].values, 'o', markersize=4)
ax.axhline(100, color='red', linestyle='--', label='100 nM threshold')
ax.set_xlabel("Sequence rank")
ax.set_ylabel("KD (nM)")
ax.set_title(f"Binding Affinity Rank — {exp_id}")
ax.legend()
plt.tight_layout()
plt.savefig(f"{exp_id}_rank_plot.pdf", bbox_inches="tight")

# Export top hits
top_hits = df.head(10)[["sequence_name", "sequence", "kd_nM", "yield_ug"]]
top_hits.to_csv(f"{exp_id}_top_hits.csv", index=False)
print(f"\nTop 10 hits:\n{top_hits.to_string(index=False)}")