kdock 2025.10.31__py3-none-any.whl

kdock/core/utils.py

@@ -0,0 +1,156 @@
+# AUTOGENERATED! DO NOT EDIT! File to edit: ../../nbs/core/01_utils.ipynb.
+
+# %% auto 0
+__all__ = ['rglob', 'copy_files', 'get_rec_lig', 'get_box', 'view_mol', 'view_complex']
+
+# %% ../../nbs/core/01_utils.ipynb 3
+from pathlib import Path
+import subprocess,shutil,zipfile
+import numpy as np
+
+import py3Dmol
+from rdkit import Chem
+
+# %% ../../nbs/core/01_utils.ipynb 6
+def rglob(path, pattern, max_depth):
+    "Get a file list given folder depths"
+    base_path = Path(path).resolve()
+    for path in base_path.rglob(pattern):
+        if len(path.relative_to(base_path).parts) <= max_depth:
+            yield path
+
+# %% ../../nbs/core/01_utils.ipynb 8
+def copy_files(file_list, dest_dir):
+    "Copy a list of files to the destination directory, or zip them if dest_dir ends with .zip."
+    dest_path = Path(dest_dir)
+
+    if dest_path.suffix == ".zip":
+        with zipfile.ZipFile(dest_path, 'w') as zipf:
+            for file_path in file_list:
+                file_path = Path(file_path)
+                zipf.write(file_path, arcname=file_path.name)
+        print(f'Zipped {len(file_list)} files to {dest_path}')
+    else:
+        dest_path.mkdir(parents=True, exist_ok=True)
+        for file_path in file_list:
+            file_path = Path(file_path)
+            shutil.copy2(file_path, dest_path / file_path.name)
+        print(f'Copied {len(file_list)} files to {dest_path}')
+
+# %% ../../nbs/core/01_utils.ipynb 11
+def get_rec_lig(pdb_id: str, # pdb id for download
+                            lig_id: str, # ligand id shown on the protein page
+                            out_dir = '.', # directory path to save pdb files
+                            ):
+    "Download pdb and extract receptor and ligand from a PDB ID."
+    out_dir = Path(out_dir).expanduser().resolve()
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    pdb_file = out_dir / f"{pdb_id}.pdb"
+    rec_file = out_dir / f"{pdb_id}_receptor.pdb"
+    lig_pdb_file = out_dir / f"{pdb_id}_lig.pdb"
+    lig_sdf_file = out_dir / f"{pdb_id}_lig.sdf"
+
+    # Download if not exists
+    if not pdb_file.exists():
+        url = f"http://files.rcsb.org/download/{pdb_id}.pdb"
+        print(f'Downloading pdb: {pdb_id}')
+        subprocess.run(["wget", url, "-O", str(pdb_file)], check=True,stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    print(f'{pdb_id}.pdb is detected!')
+
+    # Extract protein (all ATOM lines excluding ligand ID)
+    with open(pdb_file) as infile, open(rec_file, 'w') as out_rec:
+        for line in infile:
+            if line.startswith("ATOM") and lig_id not in line:
+                out_rec.write(line)
+
+    # Extract ligand
+    with open(pdb_file) as infile, open(lig_pdb_file, 'w') as out_lig:
+        for line in infile:
+            if lig_id in line and line.startswith(("HETATM", "ATOM")):
+                out_lig.write(line)
+
+    # Convert ligand PDB to SDF using RDKit
+    mol = Chem.MolFromPDBFile(str(lig_pdb_file), removeHs=False)
+    if mol is None:
+        raise ValueError("Failed to parse ligand from PDB.")
+    
+    writer = Chem.SDWriter(str(lig_sdf_file))
+    writer.write(mol)
+    writer.close()
+
+    return str(rec_file), str(lig_sdf_file)
+
+# %% ../../nbs/core/01_utils.ipynb 14
+def get_box(sdf_file, autobox_add=4.0,tolist=False):
+    "Get the box coordinates of ligand.sdf; mimic GNINA's --autobox_ligand behavior."
+    mol = Chem.SDMolSupplier(str(sdf_file), removeHs=False)[0]
+    if mol is None:
+        raise ValueError(f"Failed to read molecule from {sdf_file}")
+    
+    conf = mol.GetConformer()
+    coords = np.array([list(conf.GetAtomPosition(i)) for i in range(mol.GetNumAtoms())])
+    
+    min_coords = coords.min(axis=0)
+    max_coords = coords.max(axis=0)
+    
+    center = (min_coords + max_coords) / 2
+    size = (max_coords - min_coords) + autobox_add
+
+    box_dict = {
+        "center_x": round(float(center[0]), 3),
+        "center_y": round(float(center[1]), 3),
+        "center_z": round(float(center[2]), 3),
+        "size_x": round(float(size[0]), 3),
+        "size_y": round(float(size[1]), 3),
+        "size_z": round(float(size[2]), 3)
+    }
+    return list(box_dict.values()) if tolist else box_dict
+
+# %% ../../nbs/core/01_utils.ipynb 18
+def view_mol(file, #sdf or pdb file
+            ):
+    "Visualize pdb or sdf file"
+    
+    v = py3Dmol.view()
+    v.addModel(open(file).read())
+    v.setStyle({'stick':{}})
+    v.zoomTo()
+    v.show()
+
+# %% ../../nbs/core/01_utils.ipynb 20
+def view_complex(receptor,           # protein file
+                 ligand,             # ligand (green), or docked ligand
+                 ori_ligand=None,    # original ligand (yellow)
+                 box=None            # optional box: [x, y, z, sizeX, sizeY, sizeZ]
+                ):
+
+    "Visualize the receptor, ligand, optional original ligand, and optional box via py3Dmol."
+    v = py3Dmol.view()
+    
+    # Load receptor
+    v.addModel(open(receptor).read())
+    v.setStyle({'cartoon': {}, 'stick': {'radius': 0.15}})
+    
+    # Load docked ligand
+    v.addModel(open(ligand).read())
+    v.setStyle({'model': 1}, {'stick': {'colorscheme': 'greenCarbon'}})
+
+    # Load original ligand if provided
+    if ori_ligand is not None:
+        v.addModel(open(ori_ligand).read())
+        v.setStyle({'model': 2}, {'stick': {'colorscheme': 'yellowCarbon'}})
+
+    # Add bounding box if specified
+    if box is not None and len(box) == 6:
+        x, y, z, sizeX, sizeY, sizeZ = box
+        v.addBox({
+            'center': {'x': x, 'y': y, 'z': z},
+            'dimensions': {'w': sizeX, 'h': sizeY, 'd': sizeZ},
+            'color': 'red',
+            'opacity': 1,
+            'wireframe': True
+        })
+
+    v.zoomTo({'model': 1})
+    v.show()

kdock/gnina/dock.py

@@ -0,0 +1,114 @@
+# AUTOGENERATED! DO NOT EDIT! File to edit: ../../nbs/gnina/04_gnina_docking.ipynb.
+
+# %% auto 0
+__all__ = ['setup_gnina_local', 'setup_gnina_docker', 'extract_gnina_dock', 'gnina_dock']
+
+# %% ../../nbs/gnina/04_gnina_docking.ipynb 3
+# basics
+import re,subprocess, py3Dmol
+from tqdm import tqdm
+from pathlib import Path
+import pandas as pd,numpy as np
+
+# rdkit
+from rdkit import Chem
+from rdkit.Chem import AllChem
+
+# %% ../../nbs/gnina/04_gnina_docking.ipynb 8
+def setup_gnina_local(version='v1.3'):
+    "Download and install gnina in the current directory"
+    # Check CUDA availability
+    # try:
+    #     subprocess.run(["nvidia-smi"], check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    # except subprocess.CalledProcessError:
+    #     raise EnvironmentError("CUDA not detected. Please make sure a CUDA-capable GPU is available and drivers are installed.")
+    # except FileNotFoundError:
+    #     raise EnvironmentError("nvidia-smi not found. Make sure NVIDIA drivers and CUDA are installed.")
+
+    subprocess.run(["sudo", "apt-get", "update", "-yq"], check=True,stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    subprocess.run(["sudo", "apt-get", "install", "-yq", "openbabel"], check=True)
+
+    gnina_url = f"https://github.com/gnina/gnina/releases/download/{version}/gnina"
+    print(f'Downloading {version} gnina')
+    subprocess.run(["wget",gnina_url], check=True,stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    subprocess.run(["chmod", "+x", 'gnina'], check=True)
+    
+    print('Finish setup!')
+
+# %% ../../nbs/gnina/04_gnina_docking.ipynb 13
+def setup_gnina_docker():
+    "Pull gnina docker image"
+    print("Pulling GNINA Docker image: gnina/gnina")
+    subprocess.run(["docker", "pull", "gnina/gnina"], check=True,stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    print("GNINA Docker image is ready.")
+
+# %% ../../nbs/gnina/04_gnina_docking.ipynb 18
+def extract_gnina_dock(gnina_output):
+    "Extract values from gnina output"
+    mode1_line = re.search(r'\b1\s+(-?\d+\.\d+)\s+(-?\d+\.\d+)\s+(-?\d+\.\d+)\b', gnina_output)
+    
+    if mode1_line:
+        affinity = float(mode1_line.group(1))
+        cnn_pose_score = float(mode1_line.group(2))
+        cnn_affinity = float(mode1_line.group(3))
+        
+        return affinity, cnn_pose_score, cnn_affinity
+    
+    return None
+
+# %% ../../nbs/gnina/04_gnina_docking.ipynb 19
+def gnina_dock(receptor, # receptor file
+              ligand, # ligand file
+              autobox_ligand, # ligand file isolated from the complex
+              output = 'docked.sdf', # output file (sdf or sdf.gz) to be saved
+              seed=0, # set seeds
+              exhaustiveness=None, # number of MC chains, default is 8 if None, the higher the better (16,32); for whole protein, use 64
+              ):
+    
+    command = ['./gnina', 
+               '-r', receptor, 
+               '-l', ligand, 
+               '--autobox_ligand', autobox_ligand,
+               '-o', output,
+               '--seed', str(seed)]
+
+    if exhaustiveness is not None:
+        command.extend(['--exhaustiveness', str(exhaustiveness)])
+
+    output_txt = subprocess.run(command, capture_output=True, text=True).stdout
+    
+    print(f'save the docked file as {output}')
+    
+    values = extract_gnina_dock(output_txt)
+    
+    print(f'affinity, cnn_pose_score, and cnn_affinity are: {values}')
+
+    return values
+
+# %% ../../nbs/gnina/04_gnina_docking.ipynb 21
+def gnina_dock(df, 
+                 ID_col = 'ID',
+                 smi_col = 'SMILES',
+              output_dir = 'gnina_docked'
+                 ):
+    affinity_values = []
+    cnn_pose_score_values = []
+    cnn_affinity_values = []
+
+    
+    Path(output_dir).mkdir(parents=True,exist_ok=True)
+
+    for i, r in tqdm(df.iterrows(),total=len(df),desc='Docking'):
+        rdkit_conformer(SMILES=r[smi_col], output = f'ligand/{r[ID_col]}.sdf', visualize=False)
+        affinity, cnn_pose_score, cnn_affinity = gnina_dock('rec.pdb',f'ligand/{r[ID_col]}.sdf', 'lig.pdb',f'docked/docked_{r[ID_col]}.sdf')
+
+        affinity_values.append(affinity)
+        cnn_pose_score_values.append(cnn_pose_score)
+        cnn_affinity_values.append(cnn_affinity)
+
+    df = df.copy()
+    df['Affinity'] = affinity_values
+    df['CNN_Pose_Score'] = cnn_pose_score_values
+    df['CNN_Affinity'] = cnn_affinity_values
+    
+    return df

kdock/gnina/rescore.py

@@ -0,0 +1,204 @@
+# AUTOGENERATED! DO NOT EDIT! File to edit: ../../nbs/gnina/05_gnina_AF3_rescore.ipynb.
+
+# %% auto 0
+__all__ = ['ChainSelect', 'rename_residues', 'split_cif', 'pdb2sdf', 'prepare_rec_lig', 'gnina_rescore_local',
+           'gnina_rescore_docker', 'extract_gnina_rescore', 'get_gnina_rescore', 'get_gnina_rescore_folder']
+
+# %% ../../nbs/gnina/05_gnina_AF3_rescore.ipynb 3
+import pandas as pd
+import re, os, subprocess, py3Dmol
+from Bio.PDB import MMCIFParser, PDBIO, Select
+from rdkit import Chem
+from rdkit.Chem import AllChem
+from pathlib import Path
+from fastcore.all import L
+from tqdm.contrib.concurrent import process_map
+from functools import partial
+
+# %% ../../nbs/gnina/05_gnina_AF3_rescore.ipynb 5
+class ChainSelect(Select):
+    "Select chain to save"
+    def __init__(self, chain_ids):
+        self.chain_ids = chain_ids
+    def accept_chain(self, chain):
+        return chain.get_id() in self.chain_ids
+
+# %% ../../nbs/gnina/05_gnina_AF3_rescore.ipynb 6
+def rename_residues(structure, chain_id, new_resname='LIG'):
+    "Rename residue name from LIG_L to LIG as LIG_L exceeds lengths and leads to error in RDKit"
+    for model in structure:
+        for chain in model:
+            if chain.id == chain_id:
+                for residue in chain:
+                    residue.resname = new_resname
+
+# %% ../../nbs/gnina/05_gnina_AF3_rescore.ipynb 7
+def split_cif(cif_path, rec_chain_id,lig_chain_id, rec_pdb_path, lig_pdb_path):
+    "Split AF3 output CIF to protein and ligand PDBs"
+    parser = MMCIFParser(QUIET=True)
+    structure = parser.get_structure('complex', cif_path)
+    rename_residues(structure, chain_id=lig_chain_id, new_resname='LIG')
+    io = PDBIO()
+    io.set_structure(structure)
+    io.save(str(rec_pdb_path), ChainSelect(rec_chain_id))  # receptor
+    io.save(str(lig_pdb_path), ChainSelect(lig_chain_id))  # ligand
+
+# %% ../../nbs/gnina/05_gnina_AF3_rescore.ipynb 8
+def pdb2sdf(pdb_path, sdf_path):
+    "Convert ligand pdb to sdf file"
+    mol = Chem.MolFromPDBFile(pdb_path, sanitize=True, removeHs=False)
+    if mol:
+        writer = Chem.SDWriter(sdf_path)
+        writer.write(mol)
+        writer.close()
+        return None
+    else:
+        print('Conversion failed for:', pdb_path)
+        return pdb_path
+
+# %% ../../nbs/gnina/05_gnina_AF3_rescore.ipynb 9
+def prepare_rec_lig(cif_path, rec_chain_id, lig_chain_id, rec_pdb_path, lig_pdb_path):
+    "Split AF3 cif to protein.pdb (chainA) and ligand.sdf (chainL) "
+    
+    tmp_name = Path(cif_path).stem
+    tmp_path = f'{tmp_name}_lig.pdb'
+    split_cif(cif_path, rec_chain_id,lig_chain_id, rec_pdb_path, tmp_path)
+    failed = pdb2sdf(tmp_path, lig_pdb_path)
+    try:
+        os.remove(tmp_path)
+    except OSError:
+        pass
+    return failed
+
+# %% ../../nbs/gnina/05_gnina_AF3_rescore.ipynb 15
+def gnina_rescore_local(protein_pdb,  # receptor file
+                        ligand_sdf,   # ligand file
+                        CNN_affinity=True,
+                        vinardo=False, # if True, use vinardo instead of vina
+                        ):
+
+    command = ['./gnina', 
+               '-r', protein_pdb, 
+               '-l', ligand_sdf,
+               '--minimize']  # always include this
+
+    # Handle scoring options
+    if not CNN_affinity:
+        command += ['--cnn_scoring', 'none']
+    if vinardo:
+        command += ['--scoring', 'vinardo']
+
+    result = subprocess.run(command, capture_output=True, text=True)
+    return result.stdout
+
+# %% ../../nbs/gnina/05_gnina_AF3_rescore.ipynb 17
+def gnina_rescore_docker(protein_pdb, 
+                         ligand_sdf, 
+                         CNN_affinity=True, 
+                         vinardo=False):
+    "Run GNINA rescoring using Docker. Supports receptor and ligand in different folders."
+
+    protein_pdb = Path(protein_pdb).resolve()
+    ligand_sdf = Path(ligand_sdf).resolve()
+
+    # Mount points inside the Docker container
+    rec_mount = '/recdata'
+    lig_mount = '/ligdata'
+
+    command = [
+        'docker', 'run', '--rm',
+        '-v', f'{protein_pdb.parent}:{rec_mount}',  # mount receptor directory
+        '-v', f'{ligand_sdf.parent}:{lig_mount}',   # mount ligand directory
+        'gnina/gnina',
+        'gnina',
+        '-r', f'{rec_mount}/{protein_pdb.name}',
+        '-l', f'{lig_mount}/{ligand_sdf.name}',
+        '--minimize',  # always include
+    ]
+
+    if not CNN_affinity:
+        command += ['--cnn_scoring', 'none']
+    if vinardo:
+        command += ['--scoring', 'vinardo']
+
+    result = subprocess.run(command, capture_output=True, text=True)
+    return result.stdout
+
+# %% ../../nbs/gnina/05_gnina_AF3_rescore.ipynb 19
+def extract_gnina_rescore(txt):
+    """Extract GNINA output metrics into a dictionary (partial match allowed)."""
+    result = {}
+
+    patterns = {
+        'binding_energy': r'Affinity:\s+([-.\d]+)',
+        'uncertainty':    r'Affinity:\s+[-.\d]+\s+([-.\d]+)',
+        'RMSD':           r'RMSD:\s+([-.\d]+)',
+        'CNNscore':       r'CNNscore:\s+([-.\d]+)',
+        'CNNaffinity':    r'CNNaffinity:\s+([-.\d]+)',
+        'CNNvariance':    r'CNNvariance:\s+([-.\d]+)',
+    }
+
+    for key, pat in patterns.items():
+        match = re.search(pat, txt)
+        if match:
+            result[key] = float(match.group(1))
+
+    return result
+
+# %% ../../nbs/gnina/05_gnina_AF3_rescore.ipynb 24
+def get_gnina_rescore(cif_path,
+                      rec_chain_id='A', 
+                      lig_chain_id='L', 
+                      CNN_affinity=True,
+                      vinardo=False,
+                      is_local=True):
+    "Split the CIF into receptor and ligand folders, then extract the GNINA rescored affinity score"
+    cif_path = Path(cif_path).expanduser()
+    parent,stem = cif_path.parent,cif_path.stem
+
+    rec_dir,lig_dir = Path(str(parent) + '_receptor'),Path(str(parent) + '_ligand')
+    
+    rec_path,lig_path = rec_dir/f'{stem}.pdb',lig_dir/f'{stem}.sdf'
+    
+    rec_dir.mkdir(exist_ok=True)
+    lig_dir.mkdir(exist_ok=True)
+    
+    prepare_rec_lig(cif_path,rec_chain_id, lig_chain_id,rec_path,lig_path)
+    if is_local:
+        gnina_output = gnina_rescore_local(rec_path,lig_path,CNN_affinity,vinardo)
+    else:
+        gnina_output = gnina_rescore_docker(rec_path,lig_path,CNN_affinity,vinardo)
+    return extract_gnina_rescore(gnina_output)
+
+# %% ../../nbs/gnina/05_gnina_AF3_rescore.ipynb 29
+def get_gnina_rescore_folder(cif_folder,
+                             rec_chain_id='A', 
+                             lig_chain_id='L',
+                             CNN_affinity=True,
+                             vinardo=False,
+                             is_local=True):
+    "Parallel processing to get gnina rescore given folder path"
+    cifs = L(Path(cif_folder).expanduser().glob("*.cif")) # just take cif file
+    
+    func = partial(get_gnina_rescore,
+                   rec_chain_id=rec_chain_id, 
+                   lig_chain_id=lig_chain_id,
+                   CNN_affinity=CNN_affinity,
+                   vinardo=vinardo,
+                   is_local=is_local)
+    results = process_map(func, cifs, max_workers=4)
+
+    # use path.stem as df index
+    results_dict = dict(zip([p.stem for p in cifs], results))
+    result_df = pd.DataFrame(results_dict).T.reset_index(names='ID')
+    
+    prefix = "vinardo_" if vinardo else "vina_"
+    result_df = result_df.rename(columns={
+        "binding_energy": f"{prefix}binding_energy",
+        "uncertainty": f"{prefix}uncertainty",
+        "RMSD": f"{prefix}RMSD"
+    })
+
+    return result_df
+
+    

kdock/px/core.py

@@ -0,0 +1,130 @@
+# AUTOGENERATED! DO NOT EDIT! File to edit: ../../nbs/protenix/07_protenix.ipynb.
+
+# %% auto 0
+__all__ = ['get_single_job', 'get_single_protein_ligand_json', 'get_protein_ligand_df_json', 'get_virtual_screening_json']
+
+# %% ../../nbs/protenix/07_protenix.ipynb 6
+import json
+from pathlib import Path
+
+# %% ../../nbs/protenix/07_protenix.ipynb 9
+def get_single_job(job_name, protein_seq, msa_dir, SMILES=None,CCD=None):
+    "Get protenix json format of protein and ligand."
+    
+    if SMILES and CCD:
+        raise ValueError("Please provide only one of SMILES or CCD, not both.")
+    if not SMILES and not CCD:
+        raise ValueError("You must provide either SMILES or CCD.")
+
+    ligand_value = SMILES if SMILES else f"CCD_{CCD}"
+    
+    return {
+        "name": job_name,
+        "sequences": [
+            {
+                "proteinChain": {
+                    "count": 1,
+                    "sequence": protein_seq,
+                    "msa": {
+                        "precomputed_msa_dir": msa_dir,
+                        "pairing_db": "uniref100"
+                    }
+                }
+            },
+            {
+                "ligand": {
+                    "count": 1,
+                    "ligand": ligand_value
+                }
+            }
+        ]
+    }
+
+# %% ../../nbs/protenix/07_protenix.ipynb 11
+def get_single_protein_ligand_json(job_name, 
+                                   protein_seq, 
+                                   msa_dir, 
+                                   SMILES=None, 
+                                   CCD=None, 
+                                   json_path=None):
+    "Generate json input for one protein-ligand job."
+    data = [get_single_job(job_name, protein_seq, msa_dir, SMILES=SMILES, CCD=CCD)]
+
+    if json_path:
+        save_path = Path(json_path)
+        save_path.parent.mkdir(parents=True, exist_ok=True)
+        with save_path.open("w") as f:
+            json.dump(data, f, indent=4)
+        print(f"JSON saved to {save_path}")
+
+    return data
+
+# %% ../../nbs/protenix/07_protenix.ipynb 16
+def get_protein_ligand_df_json(df,
+                               id_col,
+                               seq_col, 
+                               msa_col, 
+                               smi_col=None, 
+                               ccd_col=None, 
+                               save_json=None):
+    "Get json file of protein and ligand in a dataframe."
+    
+    if smi_col and ccd_col:
+        raise ValueError("Provide only one of smi_col or ccd_col, not both.")
+    if not smi_col and not ccd_col:
+        raise ValueError("You must provide either smi_col or ccd_col.")
+
+    use_smiles = smi_col is not None
+
+    def build_job(row):
+        job_name = row[id_col]
+        protein_seq = row[seq_col]
+        msa_dir = row[msa_col]
+        SMILES = row[smi_col] if use_smiles else None
+        CCD = None if use_smiles else row[ccd_col]
+        return get_single_job(job_name, protein_seq, msa_dir, SMILES=SMILES, CCD=CCD)
+
+    all_jobs = df.apply(build_job, axis=1).tolist()
+
+    if save_json:
+        save_path = Path(save_json)
+        save_path.parent.mkdir(parents=True, exist_ok=True)
+        with save_path.open("w") as f:
+            json.dump(all_jobs, f, indent=4)
+        print(f"JSON saved to {save_path}")
+
+    return all_jobs
+
+
+# %% ../../nbs/protenix/07_protenix.ipynb 19
+def get_virtual_screening_json(df, 
+                               protein_seq, 
+                               msa_dir, 
+                               id_col,
+                               smi_col=None, 
+                               ccd_col=None, 
+                               save_json=None):
+    "Get json file of single protein against multiple SMILES in a dataframe."
+    if smi_col and ccd_col:
+        raise ValueError("Provide only one of smi_col or ccd_col, not both.")
+    if not smi_col and not ccd_col:
+        raise ValueError("You must provide either smi_col or ccd_col.")
+
+    use_smiles = smi_col is not None
+
+    def build_job(row):
+        job_name = row[id_col]
+        SMILES = row[smi_col] if use_smiles else None
+        CCD = None if use_smiles else row[ccd_col]
+        return get_single_job(job_name, protein_seq, msa_dir, SMILES=SMILES, CCD=CCD)
+
+    all_jobs = df.apply(build_job, axis=1).tolist()
+
+    if save_json:
+        save_path = Path(save_json)
+        save_path.parent.mkdir(parents=True, exist_ok=True)
+        with save_path.open("w") as f:
+            json.dump(all_jobs, f, indent=4)
+        print(f"JSON saved to {save_path}")
+
+    return all_jobs