Data Management¶

from biopipelines.extract_metrics import ExtractMetrics

metrics = ExtractMetrics(
    tables=[cycle0.tables.merged, cycle1.tables.merged, cycle2.tables.merged],
    metrics=["affinity_delta", "pLDDT"],
    table_names=["Cycle0", "Cycle1", "Cycle2"]
)
# Output: affinity_delta.csv, pLDDT.csv

from biopipelines.panda import Panda

# Filter
filtered = Panda(
    tables=boltz.tables.confidence,
    operations=[Panda.filter("confidence_score > 0.8")]
)

# Sort + head (replaces SelectBest)
best = Panda(
    tables=boltz.tables.confidence,
    operations=[
        Panda.sort("confidence_score", ascending=False),
        Panda.head(5)
    ]
)

# Rank with renamed IDs
ranked = Panda(
    tables=boltz.tables.confidence,
    operations=[Panda.sort("score", ascending=False)],
    rename="best",  # Output: best_1, best_2, ...
    pool=boltz
)

# Merge tables (on=None uses biopipelines ID matching by default)
merged = Panda(
    tables=[apo.tables.affinity, holo.tables.affinity],
    operations=[
        Panda.merge(prefixes=["apo_", "holo_"]),
        Panda.calculate({"delta": "holo_affinity - apo_affinity"})
    ]
)

# Tip: when both tables share a literal `id` column with no auto-rename
# in between, prefer Panda.merge(on="id") — it skips the suffix / provenance
# matcher and uses pandas.merge directly. ~20× faster on large tables and
# the result is identical when the IDs already match exactly.
fast_merged = Panda(
    tables=[boltz.tables.confidence, boltz.tables.affinity],
    operations=[Panda.merge(on="id")]
)

# Calculate with math functions (cos, sin, sqrt, log, exp, radians, degrees, pi, ...)
# Expressions can reference columns defined earlier in the same calculate call
fret = Panda(
    tables=[distances.tables.result, angles.tables.angles],
    operations=[
        Panda.merge(),
        Panda.calculate({
            "kappa2": "cos(orientation) ** 2",
            "R0_eff": "49.0 * (kappa2 / 0.6667) ** (1.0 / 6.0)",
            "efficiency": "1 / (1 + (distance / R0_eff) ** 6)"
        })
    ]
)

# Concatenate tables. With >1 inputs, every row is implicitly tagged with
# its origin index in the internal `Panda.SOURCE` column for the rest of
# the chain (stripped from the final CSV). Reference it as a column name
# in groupby / filter / etc.
combined = Panda(
    tables=[cycle0.tables.results, cycle1.tables.results],
    operations=[Panda.concat(fill="")]
)

# Multi-pool selection (select best from multiple sources). The implicit
# Panda.SOURCE column drives multi-pool file routing too: each surviving
# row's structure is copied from its origin pool.
best = Panda(
    tables=[cycle1.tables.result, cycle2.tables.result],
    operations=[
        Panda.concat(),
        Panda.sort("metric", ascending=True),
        Panda.head(1)
    ],
    pool=[cycle1, cycle2],  # Pools match tables
    rename="best"
)

# Best per source — natural form: per-frame ops broadcast over a list
# of input tables (sort/head/tail/sample/filter/etc. apply independently
# to each table), then concat stacks the results.
best_per_source = Panda(
    tables=[a.tables.result, b.tables.result, c.tables.result],
    operations=[
        Panda.sort("score", ascending=False),  # applied per table
        Panda.head(1),                         # best row per table
        Panda.concat(),                        # stack into one frame
    ],
)

# Renaming the survivors. `rename=` runs once at the very end of the chain
# on whatever rows are left, so just pass it on the Panda(...) call — no
# extra operation step needed. Concat preserves input order, so the
# default below gives best_1 = a's best, best_2 = b's best, best_3 = c's.
ranked_per_source = Panda(
    tables=[a.tables.result, b.tables.result, c.tables.result],
    operations=[
        Panda.sort("score", ascending=False),
        Panda.head(1),
        Panda.concat(),
    ],
    rename="best",  # → best_1, best_2, best_3 (one per source)
)

# Want best_1 to be the GLOBALLY top-scoring row instead of the first
# source's best? Add a cross-source sort after concat so rename ranks
# across sources rather than mirroring input order.
ranked_globally = Panda(
    tables=[a.tables.result, b.tables.result, c.tables.result],
    operations=[
        Panda.sort("score", ascending=False),  # per table
        Panda.head(1),                         # per table
        Panda.concat(),                        # stack
        Panda.sort("score", ascending=False),  # cross-source rank
    ],
    rename="best",
)

# Same outcome, post-concat form: useful when you also want a cross-source
# aggregate (mean/std/etc.) — groupby/pivot/melt/average_by_source must
# come AFTER concat because they aggregate across sources.
mean_per_source = Panda(
    tables=[a.tables.result, b.tables.result, c.tables.result],
    operations=[
        Panda.concat(),
        Panda.groupby(Panda.SOURCE, {"score": "mean"}),
    ],
)

from biopipelines.entities import PDB
from biopipelines.pipeline import Parallel, Resources
from biopipelines.rfdiffusion import RFdiffusion
from biopipelines.pool import Pool

# Run RFdiffusion 10x in parallel, gather all 100 designs into one stream
seed = PDB("4AKE")
runs = []
with Parallel():
    for _ in range(10):
        Resources(gpu="A100", time="6:00:00")
        runs.append(RFdiffusion(pdb=seed, num_designs=10))

Resources(gpu="A100", time="12:00:00")
combined = Pool(runs=runs)
# combined.streams.structures has 100 ids of the form
# design_1_1, design_2_1, ..., design_10_1, design_1_2, ..., design_10_10
# combined map_table also carries a pool.path column.

from biopipelines.remap import ReMap

# Auto-numbered
remapped = ReMap(source=tool_a, onto="design")

# Explicit list
remapped = ReMap(source=tool_a, onto=["kinase_apo", "kinase_holo"])

# Dict mapping
remapped = ReMap(source=tool_a, onto={"prot1": "complex_A", "prot2": "complex_B"})

# List of tuples
remapped = ReMap(source=tool_a, onto=[("prot1", "complex_A"), ("prot2", "complex_B")])

# Align onto another tool's IDs
remapped = ReMap(source=tool_a, onto=tool_b)

# Align onto a specific stream
remapped = ReMap(source=tool_a, onto=tool_b.streams.structures)

# Use intermediate tool as provenance bridge
remapped = ReMap(source=tool_a, onto=tool_c, map=tool_b)

from biopipelines.selection import Selection
from biopipelines.distance_selector import DistanceSelector

distances = DistanceSelector(structures=rfdaa, ligand=rfdaa, distance=5)

# Expand by 2 residues
expanded = Selection(
    Selection.add(distances.tables.selections.within),
    Selection.expand(2),
    structures=rfdaa,
)

# Union two columns then invert
fixed = Selection(
    Selection.add(fuse.tables.sequences.L1, fuse.tables.sequences.L2),
    Selection.invert(),
    structures=rfdaa,
)