import os import re import shutil import logging import gc import glob import multiprocessing as mp import traceback import queue as queue_module import base64 from io import BytesIO from tqdm import tqdm from IPython.display import display from morfeus.buried_volume import BuriedVolume from morfeus.conformer import ConformerEnsemble from morfeus.dispersion import Dispersion from morfeus.sasa import SASA from morfeus.xtb import XTB import numpy as np import pandas as pd from rdkit import Chem from rdkit.Chem import rdFMCS, Draw def calculate_morfeus_descriptors (smiles_list, filename, common_core=None, chunk_size=10, find_restart = True, starting_smiles_nr=1, chunk_label=1): """ Calculate morfeus descriptors at the GFN2-xTB level for a list of given smiles strings. --------------- smiles_list: list list of smiles strings common_core: str or None smarts for the common core of interest Default is None --> will look for the largest common substructure in the molecule filename: str path for the generated dataset common_core: str or None SMARTS for a substructure for which atom descriptors will be extracted If common_core=None (Default), the atom descriptors will be calculated for the maximum common substructure. chunk_size: int number of compounds that will be calculated in one chunk before saving the obtained data at the end of the run, all chunks will be concatenated. Default: 10 find_restart: Boolean If True, the algorithm will parse if some chunks were already calculated and auto-restart with the next chunk, overwriting the starting_smiles_nr and chunk_label variables. NOTE: Assumes that the chunk_size was not changed starting_smiles_nr: int (one-indexed) first entry of the smiles list to be calculated Default: 1 (useful for restarting in case the calculation crashes) NOTE: overwritten if find_restart = True chunk_label: int label for the next chunk to be calculated Default: 1 (useful for restarting in case the calculation crashes) NOTE: overwritten if find_restart = True ---------------------- Save the descriptor data under the indicated filename Also returns a list of pd.DataFrames for the data of the individual chunks as well as a pd.DataFrame for the combined Data of all calculated structures """ print("This might take several minutes or even hours. Please stand by.") # Find common substructure and align the template # Create a folder to save the separate chunks of calculation results if not os.path.exists("./featurization_temp"): # Create the folder os.makedirs("./featurization_temp") # Create a template for the common core with consistent atom ordering template = None if common_core is None: # find the maximum common substructure if no common core is provided template = _get_mcs_template_with_consistent_atom_order(smiles_list) else: # use the provided common core template = _map_common_core_with_consistent_atom_order(smiles_list,common_core) # draw the template print("Atom properties will be calculated for the following common substructure:") depiction = Draw.MolToImage(template) display(depiction) pt = Chem.GetPeriodicTable() results = [] smiles_list_chunk = [] properties = None # check if some chunks have already been calculated and automatically restart if find_restart: # check if ./featurization_temp (temporary results folder) is empty last_chunk = None chunk_folder = "./featurization_temp" if not os.listdir(chunk_folder): last_chunk = 0 # no chunks run yet else: # some chunks already exist # check which chunk was run last pattern = re.compile(r"feat_chunk_(\d+)\.csv$") for fname in os.listdir(chunk_folder): match = pattern.match(fname) if match: obs_chunk = int(match.group(1)) if last_chunk is None or obs_chunk > last_chunk: last_chunk = obs_chunk # update the next chunk label and the starting_smiles_nr chunk_label = last_chunk + 1 starting_smiles_nr = last_chunk * chunk_size +1 # go through the provided smiles for smiles_index, smiles in enumerate(tqdm(smiles_list[(starting_smiles_nr-1):])): smiles_index = smiles_index + starting_smiles_nr -1 current_results = {} # Generate conformer ensemble ce = ConformerEnsemble.from_rdkit(smiles,optimize="MMFF94") ce.prune_rmsd() ce.sort() if len(ce) > 5: ce = ce[:5] # prune to top 5 conformers # Optimize conformers model = {"method": "GFN2-xTB"} ce.optimize_qc_engine(program="xtb",model=model,procedure="geometric") ce.sp_qc_engine(program="xtb",model=model) ce.prune_energy() # Get the matching substructure (excluding hydrogens) match = ce.mol.GetSubstructMatch(template) substruct_atoms = [pt.GetElementSymbol(int(ce.elements[nr])) for nr in match] substruct_labels = _append_occurrence_numbers(substruct_atoms) # calculate properties for each conformer for conformer in ce: props = conformer.properties sasa = SASA(ce.elements, conformer.coordinates) disp = Dispersion(ce.elements, conformer.coordinates) xtb = XTB(ce.elements, conformer.coordinates) # save the global property values props["SASA"] = sasa.area props["Volume"] = disp.volume props["HOMO"] = xtb.get_homo() props["LUMO"] = xtb.get_lumo() props["IP"] = xtb.get_ip(corrected=True) props["EA"] = xtb.get_ea(corrected=True) props["Dipole"] = np.linalg.norm(xtb.get_dipole()) # calculate atom properties sasa_atom_areas = sasa.atom_areas disp_atom_p_int = disp.atom_p_int charges = xtb.get_charges() electrophilicity = xtb.get_fukui("electrophilicity") nucleophilicity = xtb.get_fukui("nucleophilicity") radical_fukui = xtb.get_fukui("radical") # save the atom properties for i,idx in enumerate(match): atom_label = substruct_labels[i] bv = BuriedVolume(ce.elements, conformer.coordinates, idx+1) props[f"{atom_label}_BV"] = bv.fraction_buried_volume props[f"{atom_label}_SASA"] = sasa_atom_areas[idx+1] props[f"{atom_label}_P_int"] = disp_atom_p_int[idx+1] props[f"{atom_label}_charge"] = charges[idx+1] props[f"{atom_label}_electrophilicity"] = electrophilicity[idx+1] props[f"{atom_label}_nucleophilicity"] = nucleophilicity[idx+1] props[f"{atom_label}_radicalFukui"] = radical_fukui[idx+1] # collect the property names during the first iteration if smiles == smiles_list[(starting_smiles_nr-1)] and conformer == ce[0]: properties = props.keys() # calculate Boltzmann-weighted average for each property for property in properties: current_results[property] = ce.boltzmann_statistic(property) results.append(current_results) smiles_list_chunk.append(smiles) # add the smiles to the list of smiles in this chunk if (smiles_index + 1) % chunk_size == 0: # check if the chunk is full; +1 due to zero-indexing # save the current chunk pd.DataFrame(results,index=smiles_list_chunk,columns=properties).to_csv(f"./featurization_temp/feat_chunk_{chunk_label}.csv", index=True, header=True) # clean out the collection variables for the next chunk results = [] smiles_list_chunk = [] chunk_label += 1 # update the chunk label for the next chunk # once all smiles have been calculated, save the last samples in a final chunk if smiles_list_chunk: pd.DataFrame(results,index=smiles_list_chunk,columns=properties).to_csv(f"./featurization_temp/feat_chunk_{chunk_label}.csv",index=True,header=True) # combine the chunks and clean up dfs = [] for chunk_file in os.listdir("./featurization_temp"): dfs.append(pd.read_csv(f"./featurization_temp/{chunk_file}",index_col=0,header=0)) df_combined = pd.concat(dfs,axis=0) df_combined.to_csv(filename,index=True,header=True) shutil.rmtree("./featurization_temp") os.remove("qce_optim.xyz") print("Finished descriptor calculation.") return dfs, df_combined def calculate_morfeus_descriptors_web( smiles_list, filename, common_core=None, chunk_size=5, worker_batch_size=5, find_restart=True, starting_smiles_nr=1, chunk_label=1, progress_callback=None, check_cancel=None, temp_dir="./featurization_temp_web", ): """ Webapp-oriented variant of calculate_morfeus_descriptors. Differences to the notebook version: - No tqdm progress bar output - No IPython display output - Optional progress callback for UI updates - Optional cancellation callback for long-running jobs - Uses a separate temporary directory by default - Does not write a final combined csv file; returns the dataframe progress_callback signature: progress_callback(done_count, total_count, message) check_cancel signature: check_cancel() -> bool """ if progress_callback is not None: progress_callback(0, len(smiles_list), "Setting up featurization calculation...") # Start from a clean slate so stale temporary files do not accumulate across runs. _cleanup_qcengine_artifacts() # For restart-enabled runs, keep existing chunks so calculation can resume. # For fresh runs, clear stale temporary data first. if os.path.exists(temp_dir) and not find_restart: shutil.rmtree(temp_dir, ignore_errors=True) os.makedirs(temp_dir, exist_ok=True) if common_core is None: template = _get_mcs_template_with_consistent_atom_order(smiles_list) else: template = _map_common_core_with_consistent_atom_order(smiles_list, common_core) template_smarts = Chem.MolToSmarts(template) mp_ctx = mp.get_context("spawn") worker_batch_size = max(1, int(worker_batch_size)) results = [] smiles_list_chunk = [] properties = None if find_restart: last_chunk = 0 if os.listdir(temp_dir): pattern = re.compile(r"feat_chunk_(\d+)\.csv$") for fname in os.listdir(temp_dir): match = pattern.match(fname) if match: obs_chunk = int(match.group(1)) if obs_chunk > last_chunk: last_chunk = obs_chunk chunk_label = last_chunk + 1 starting_smiles_nr = last_chunk * chunk_size + 1 if progress_callback is not None and last_chunk > 0: progress_callback( 0, len(smiles_list), f"Resuming from existing chunks: found {last_chunk} completed chunk(s) of size {chunk_size}.", ) smiles_slice = smiles_list[(starting_smiles_nr - 1):] total_count = len(smiles_slice) total_full_count = len(smiles_list) completed_before_restart = max(0, starting_smiles_nr - 1) if progress_callback is not None and completed_before_restart > 0: progress_callback( completed_before_restart, total_full_count, f"Processed {completed_before_restart}/{total_full_count}", ) completed_successfully = False try: for batch_start in range(0, total_count, worker_batch_size): queue = None worker = None try: if check_cancel is not None and check_cancel(): raise RuntimeError("Featurization interrupted by user.") smiles_batch = smiles_slice[batch_start: batch_start + worker_batch_size] queue = mp_ctx.Queue() worker = mp_ctx.Process( target=_compute_smiles_batch_descriptors_worker, args=(smiles_batch, template_smarts, queue), ) worker.start() done_marker_received = False processed_in_batch = 0 while True: if check_cancel is not None and check_cancel(): raise RuntimeError("Featurization interrupted by user.") try: payload = queue.get(timeout=0.2) except queue_module.Empty: if worker.is_alive(): continue # Worker exited; if no explicit completion marker arrived, stop waiting. if not done_marker_received: break continue payload_type = payload.get("type") if payload_type == "item": smiles = payload["smiles"] current_results = payload["results"] child_properties = payload["properties"] if properties is None: properties = child_properties for prop in properties: if prop not in current_results: current_results[prop] = np.nan results.append(current_results) smiles_list_chunk.append(smiles) smiles_index = batch_start + processed_in_batch + starting_smiles_nr - 1 processed_in_batch += 1 if (smiles_index + 1) % chunk_size == 0: pd.DataFrame(results, index=smiles_list_chunk, columns=properties).to_csv( f"{temp_dir}/feat_chunk_{chunk_label}.csv", index=True, header=True ) results = [] smiles_list_chunk = [] chunk_label += 1 if progress_callback is not None: done_count = completed_before_restart + batch_start + processed_in_batch progress_callback( done_count, total_full_count, f"Processed {done_count}/{total_full_count}", ) elif payload_type == "error": raise RuntimeError( f"Descriptor worker error for batch starting at index {batch_start + starting_smiles_nr}: " f"{payload.get('error', 'unknown')}\n" f"{payload.get('traceback', '')}" ) elif payload_type == "done": done_marker_received = True break worker.join() if worker.exitcode != 0: raise RuntimeError( f"Descriptor worker failed for batch starting at index {batch_start + starting_smiles_nr} " f"with exit code {worker.exitcode}." ) if not done_marker_received: raise RuntimeError( f"Descriptor worker did not report completion for batch starting at index " f"{batch_start + starting_smiles_nr}." ) finally: if queue is not None: try: queue.close() queue.join_thread() except Exception: pass if worker is not None and worker.is_alive(): worker.terminate() worker.join() _close_qcengine_file_handlers() _cleanup_qcengine_artifacts() gc.collect() if smiles_list_chunk: pd.DataFrame(results, index=smiles_list_chunk, columns=properties).to_csv( f"{temp_dir}/feat_chunk_{chunk_label}.csv", index=True, header=True ) dfs = [] chunk_files = sorted( [f for f in os.listdir(temp_dir) if re.match(r"feat_chunk_\d+\.csv$", f)] ) for chunk_file in chunk_files: dfs.append(pd.read_csv(f"{temp_dir}/{chunk_file}", index_col=0, header=0)) df_combined = pd.concat(dfs, axis=0) if progress_callback is not None: progress_callback(total_full_count, total_full_count, "Featurization finished") # Match notebook behavior: clean temporary chunk folder only after successful combine. if os.path.exists(temp_dir): try: shutil.rmtree(temp_dir) except OSError as cleanup_error: if progress_callback is not None: progress_callback( total_full_count, total_full_count, f"Warning: temporary cleanup failed ({cleanup_error}).", ) completed_successfully = True return dfs, df_combined finally: # Preserve temp_dir/chunks on interruption or failure for inspection/restart. # It is removed only after successful chunk combination above. if not completed_successfully and progress_callback is not None and os.path.exists(temp_dir): progress_callback( 0, total_count, f"Interrupted or failed run: retained temporary chunks in {temp_dir}.", ) if os.path.exists("qce_optim.xyz"): try: os.remove("qce_optim.xyz") except OSError: # Best-effort cleanup only. pass _cleanup_qcengine_artifacts() def _compute_smiles_batch_descriptors_worker(smiles_batch, template_smarts, queue): """Compute descriptors for a small SMILES batch in one isolated process.""" try: for smiles in smiles_batch: current_results, properties = _compute_single_smiles_descriptors(smiles, template_smarts) queue.put( { "type": "item", "smiles": smiles, "results": current_results, "properties": properties, } ) _close_qcengine_file_handlers() _cleanup_qcengine_artifacts() gc.collect() queue.put({"type": "done"}) except Exception as exc: queue.put({ "type": "error", "error": str(exc), "traceback": traceback.format_exc(), }) finally: _close_qcengine_file_handlers() _cleanup_qcengine_artifacts() gc.collect() def _compute_single_smiles_descriptors(smiles, template_smarts): """Compute descriptors for one SMILES and return (results_dict, properties_list).""" _cleanup_qcengine_artifacts() template = Chem.MolFromSmarts(template_smarts) if template is None: raise ValueError("Invalid template SMARTS for descriptor calculation.") pt = Chem.GetPeriodicTable() current_results = {} properties = None ce = ConformerEnsemble.from_rdkit(smiles, optimize="MMFF94") ce.prune_rmsd() ce.sort() if len(ce) > 5: ce = ce[:5] model = {"method": "GFN2-xTB"} ce.optimize_qc_engine(program="xtb", model=model, procedure="geometric") ce.sp_qc_engine(program="xtb", model=model) ce.prune_energy() match = ce.mol.GetSubstructMatch(template) substruct_atoms = [pt.GetElementSymbol(int(ce.elements[nr])) for nr in match] substruct_labels = _append_occurrence_numbers(substruct_atoms) for conformer in ce: props = conformer.properties sasa = SASA(ce.elements, conformer.coordinates) disp = Dispersion(ce.elements, conformer.coordinates) xtb = XTB(ce.elements, conformer.coordinates) props["SASA"] = sasa.area props["Volume"] = disp.volume props["HOMO"] = xtb.get_homo() props["LUMO"] = xtb.get_lumo() props["IP"] = xtb.get_ip(corrected=True) props["EA"] = xtb.get_ea(corrected=True) props["Dipole"] = np.linalg.norm(xtb.get_dipole()) sasa_atom_areas = sasa.atom_areas disp_atom_p_int = disp.atom_p_int charges = xtb.get_charges() electrophilicity = xtb.get_fukui("electrophilicity") nucleophilicity = xtb.get_fukui("nucleophilicity") radical_fukui = xtb.get_fukui("radical") for i, idx in enumerate(match): atom_label = substruct_labels[i] bv = BuriedVolume(ce.elements, conformer.coordinates, idx + 1) props[f"{atom_label}_BV"] = bv.fraction_buried_volume props[f"{atom_label}_SASA"] = sasa_atom_areas[idx + 1] props[f"{atom_label}_P_int"] = disp_atom_p_int[idx + 1] props[f"{atom_label}_charge"] = charges[idx + 1] props[f"{atom_label}_electrophilicity"] = electrophilicity[idx + 1] props[f"{atom_label}_nucleophilicity"] = nucleophilicity[idx + 1] props[f"{atom_label}_radicalFukui"] = radical_fukui[idx + 1] if properties is None and conformer == ce[0]: properties = list(props.keys()) if properties is None: raise RuntimeError("No descriptors were generated for the given SMILES.") for prop in properties: current_results[prop] = ce.boltzmann_statistic(prop) return current_results, properties def _append_occurrence_numbers(strings): counts = {} result = [] for s in strings: counts[s] = counts.get(s, 0) + 1 result.append(f"{s}_{counts[s]}") return result def _close_qcengine_file_handlers(): """Best-effort cleanup of leaked file log handlers from qcengine/geometric.""" logger_names = {"", "geometric", "qcengine"} # Include all currently registered logger names to catch nested namespaces. manager = logging.getLogger().manager for name in manager.loggerDict.keys(): if isinstance(name, str): logger_names.add(name) for name in logger_names: logger = logging.getLogger(name) for handler in list(logger.handlers): if isinstance(handler, logging.FileHandler): try: handler.close() finally: logger.removeHandler(handler) def _cleanup_qcengine_artifacts(base_dir="."): """Best-effort cleanup of transient qce/geometric/xtb artifacts.""" file_patterns = [ "qce_optim.xyz", "qce_*.json", "qce_*.log", "qce_*.txt", "xtbopt.xyz", "xtbopt.log", "xtbopt.coord", "xtbrestart", "xtb.trj", "g98.out", "gradient", "hessian", "charges", "wbo", ".xtboptok", "coord", "coord.original", ] dir_patterns = [ "qce_*", "geometric*", "xtbtmp*", ] for pattern in file_patterns: for path in glob.glob(os.path.join(base_dir, pattern)): if os.path.isfile(path): try: os.remove(path) except OSError: pass for pattern in dir_patterns: for path in glob.glob(os.path.join(base_dir, pattern)): if os.path.isdir(path): try: shutil.rmtree(path) except OSError: pass def build_common_core_preview(smiles_list, common_core=None, image_size=(320, 180)): """Build SMARTS + PNG data URI preview for the common-core template.""" if common_core is None: template = _get_mcs_template_with_consistent_atom_order(smiles_list) else: template = _map_common_core_with_consistent_atom_order(smiles_list, common_core) template_smarts = Chem.MolToSmarts(template) image = Draw.MolToImage(template, size=image_size) buffer = BytesIO() image.save(buffer, format="PNG") encoded = base64.b64encode(buffer.getvalue()).decode() image_src = f"data:image/png;base64,{encoded}" return template, template_smarts, image_src def _generate_template(ref_mol,core_mol): """ Generate a template mol with consistent atom ordering based on a reference molecule and a common core. """ match = ref_mol.GetSubstructMatch(core_mol) # Create a substructure mol (just the MCS) with atom mapping em = Chem.EditableMol(Chem.Mol()) atom_map = {} for new_idx, old_idx in enumerate(match): atom = ref_mol.GetAtomWithIdx(old_idx) atom_map[old_idx] = new_idx new_atom = Chem.Atom(atom.GetAtomicNum()) new_atom.SetAtomMapNum(new_idx + 1) # Atom map numbers start at 1 em.AddAtom(new_atom) # Add bonds within the MCS for i, idx1 in enumerate(match): for j, idx2 in enumerate(match): if idx1 >= idx2: continue bond = ref_mol.GetBondBetweenAtoms(idx1, idx2) if bond: em.AddBond(atom_map[idx1], atom_map[idx2], bond.GetBondType()) mcs_submol = em.GetMol() smarts_with_map = Chem.MolToSmarts(mcs_submol) template = Chem.MolFromSmarts(smarts_with_map) return template def _get_mcs_template_with_consistent_atom_order(smiles_list): """Generate a template mol with consistent atom ordering based on the MCS of a list of smiles strings.""" # Convert SMILES to H-added mols mols = [Chem.AddHs(Chem.MolFromSmiles(smi)) for smi in smiles_list] # Find MCS mcs_result = rdFMCS.FindMCS(mols) mcs_mol = Chem.RemoveAllHs(Chem.MolFromSmarts(mcs_result.smartsString)) # Use first molecule as reference for the template generation template = _generate_template(ref_mol=mols[0],core_mol=mcs_mol) return template def _map_common_core_with_consistent_atom_order(smiles_list,common_core): """Generate a template mol with consistent atom ordering based on a provided common core and a list of smiles strings.""" # generate mol objects for smiles_list mols = [Chem.AddHs(Chem.MolFromSmiles(smiles)) for smiles in smiles_list] # generate mol for common_core core_mol = Chem.RemoveAllHs(Chem.MolFromSmarts(common_core)) # Use first molecule as reference for the template generation template = _generate_template(ref_mol=mols[0],core_mol=core_mol) return template