def mol_passes_filters(mol,
allowed=None,
allow_charge=False,
isomericSmiles=False):
"""
Checks if mol
* passes MCF and PAINS filters,
* has only allowed atoms
* is not charged
"""
allowed = allowed or {'C', 'N', 'S', 'O', 'F', 'Cl', 'Br', 'H'}
mol = get_mol(mol)
if mol is None:
return False
ring_info = mol.GetRingInfo()
if ring_info.NumRings() != 0 and any(
len(x) >= 8 for x in ring_info.AtomRings()):
return False
h_mol = Chem.AddHs(mol)
if not allow_charge:
if any(atom.GetFormalCharge() != 0 for atom in mol.GetAtoms()):
return False
if any(atom.GetSymbol() not in allowed for atom in mol.GetAtoms()):
return False
if any(h_mol.HasSubstructMatch(smarts) for smarts in _filters):
return False
smiles = Chem.MolToSmiles(mol, isomericSmiles=isomericSmiles)
if smiles is None or len(smiles) == 0:
return False
if Chem.MolFromSmiles(smiles) is None:
return False
return True
def fingerprint(smiles_or_mol,
fp_type='maccs',
dtype=None,
morgan__r=2,
morgan__n=1024,
*args,
**kwargs):
"""
Generates fingerprint for SMILES
If smiles is invalid, returns None
Returns numpy array of fingerprint bits
Parameters:
smiles: SMILES string
type: type of fingerprint: [MACCS|morgan]
dtype: if not None, specifies the dtype of returned array
"""
fp_type = fp_type.lower()
molecule = get_mol(smiles_or_mol, *args, **kwargs)
if molecule is None:
return None
if fp_type == 'maccs':
keys = MACCSkeys.GenMACCSKeys(molecule)
keys = np.array(keys.GetOnBits())
fingerprint = np.zeros(166, dtype='uint8')
if len(keys) != 0:
fingerprint[keys - 1] = 1 # We drop 0-th key that is always zero
elif fp_type == 'morgan':
fingerprint = np.asarray(Morgan(molecule, morgan__r, nBits=morgan__n),
dtype='uint8')
else:
raise ValueError("Unknown fingerprint type {}".format(fp_type))
if dtype is not None:
fingerprint = fingerprint.astype(dtype)
return fingerprint
def fragmenter(mol):
"""
fragment mol using BRICS and return smiles list
"""
mol = get_mol(mol) #
if mol is None: #
return None #
fgs = AllChem.FragmentOnBRICSBonds(mol) # get_mol(mol) -> mol
fgs_smi = Chem.MolToSmiles(fgs).split(".")
return fgs_smi
def compute_scaffold(mol, min_rings=2):
mol = get_mol(mol)
if mol is None: #
return None #
try:
scaffold = MurckoScaffold.GetScaffoldForMol(mol)
except (ValueError, RuntimeError):
return None
n_rings = get_n_rings(scaffold)
scaffold_smiles = Chem.MolToSmiles(scaffold)
if scaffold_smiles == '' or n_rings < min_rings:
return None
else: #
return scaffold_smiles #
def neutralize_atoms(mol, isomericSmiles=False):
mol = get_mol(mol)
if mol:
pattern = Chem.MolFromSmarts(
"[+1!h0!$([*]~[-1,-2,-3,-4]),-1!$([*]~[+1,+2,+3,+4])]")
at_matches = mol.GetSubstructMatches(pattern)
at_matches_list = [y[0] for y in at_matches]
if len(at_matches_list) > 0:
try:
for at_idx in at_matches_list:
atom = mol.GetAtomWithIdx(at_idx)
chg = atom.GetFormalCharge()
hcount = atom.GetTotalNumHs()
atom.SetFormalCharge(0)
atom.SetNumExplicitHs(hcount - chg)
atom.UpdatePropertyCache()
smiles = Chem.MolToSmiles(mol, isomericSmiles=isomericSmiles)
return smiles
except:
return None
else:
return Chem.MolToSmiles(mol, isomericSmiles=isomericSmiles)
else:
return None
def canonic_smiles(smiles_or_mol):
mol = get_mol(smiles_or_mol)
if mol is None:
return None
return Chem.MolToSmiles(mol)