chiralfinder 0.0.1__tar.gz

chiralfinder-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Meteor-han
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

chiralfinder-0.0.1/PKG-INFO

@@ -0,0 +1,103 @@
+Metadata-Version: 2.3
+Name: chiralfinder
+Version: 0.0.1
+Summary: The chiralfinder package.
+License: MIT
+Keywords: Chirality,Chiral axis
+Author: Runhan Shi
+Author-email: han.run.jiangming@sjtu.edu.cn
+Maintainer: Runhan Shi
+Maintainer-email: han.run.jiangming@sjtu.edu.cn
+Requires-Python: >=3.8,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: numpy (>=1.26.4,<2.0.0)
+Requires-Dist: rdkit (>=2024.3.3,<2025.0.0)
+Requires-Dist: tqdm (>=4.65.0,<5.0.0)
+Project-URL: Documentation, https://github.com/Meteor-han/chiralfinder/
+Project-URL: Homepage, https://github.com/Meteor-han/chiralfinder/
+Project-URL: Repository, https://github.com/Meteor-han/chiralfinder/
+Project-URL: issues, https://github.com/Meteor-han/chiralfinder/issues
+Description-Content-Type: text/markdown
+
+# chiralfinder
+
+Data and codes for the paper "ChiralFinder: A Computational Framework for Identifying Stereogenic Elements and Distinguishing Stereoisomers in Complex Molecules", in submission.
+
+## Quick use
+
+Install Anaconda, create and enter your own environment like
+
+    conda create -n env_test python=3.10
+Enter the conda environment and install the ChiralFinder package through pip like
+
+```
+conda activate env_test
+pip install chiralfinder
+```
+
+Run `test.py` to get example results.
+
+```
+python test.py
+```
+
+```python
+from chiralfinder import ChiralFinder
+
+if __name__ == '__main__':
+    smi_list = ["C[C@H]1CC(=O)[C@]2(CCCC2=O)C1", "CC1=CC=C(SC2=C(C)N(C3=CC=CC=C3C(C)(C)C)C(C)=C2)C=C1"]
+
+    chiral_finder = ChiralFinder(smi_list, "SMILES")
+    res_ = chiral_finder.get_axial(n_cpus=8)
+    print(res_[0]["chiral axes"], res_[1]["chiral axes"])
+    chiral_finder.draw_res_axial("./img")
+
+    smi_list_center = ["BrC/C(=C\[C@@H]1CCCO1)C1CCCCC1"]
+    chiral_finder = ChiralFinder(smi_list_center, "SMILES")
+    res_ = chiral_finder.get_central()
+    print(res_)
+```
+
+You will get the images of two molecules with predicted chiral axes in the folder `./img` by default. Predicted chiral axes:
+
+```
+[(5,)] [(9, 10)]
+```
+
+<img src="https://github.com/Meteor-han/chiralfinder/blob/main/img_axial/0.png" alt="0" width="30%" height="auto" /><img src="https://github.com/Meteor-han/chiralfinder/blob/main/img_axial/1.png" alt="1"  width="30%" height="auto" />
+
+You will get the prediction of one molecule for central chirality.
+
+```
+[{
+'center id': [4], 
+'quadrupole matrix': 
+       [[array([[-0.29989323, -1.08474687,  0.09943544],
+       [-2.0754821 ,  0.47857598,  1.02051223],
+       [-0.0064714 , -0.03258116,  2.29906673]])]], 
+'determinant': [[-5.501797575969392]], 
+'sign': [[-1.0]]
+}]
+```
+
+
+## Dataset
+
+The RotA dataset is stored in the folder `./data`. The excel file contains labeled chiral axes and some calculated molecular properties. The pickle file includes calculated molecular conformers.
+
+We also provide sampled achiral molecules and centrally chiral molecules with multiple centers from the PubChem3D database in the folder `./data`.
+
+## Citation
+
+```
+To be filled
+```
+
+

chiralfinder-0.0.1/README.md

@@ -0,0 +1,74 @@
+# chiralfinder
+
+Data and codes for the paper "ChiralFinder: A Computational Framework for Identifying Stereogenic Elements and Distinguishing Stereoisomers in Complex Molecules", in submission.
+
+## Quick use
+
+Install Anaconda, create and enter your own environment like
+
+    conda create -n env_test python=3.10
+Enter the conda environment and install the ChiralFinder package through pip like
+
+```
+conda activate env_test
+pip install chiralfinder
+```
+
+Run `test.py` to get example results.
+
+```
+python test.py
+```
+
+```python
+from chiralfinder import ChiralFinder
+
+if __name__ == '__main__':
+    smi_list = ["C[C@H]1CC(=O)[C@]2(CCCC2=O)C1", "CC1=CC=C(SC2=C(C)N(C3=CC=CC=C3C(C)(C)C)C(C)=C2)C=C1"]
+
+    chiral_finder = ChiralFinder(smi_list, "SMILES")
+    res_ = chiral_finder.get_axial(n_cpus=8)
+    print(res_[0]["chiral axes"], res_[1]["chiral axes"])
+    chiral_finder.draw_res_axial("./img")
+
+    smi_list_center = ["BrC/C(=C\[C@@H]1CCCO1)C1CCCCC1"]
+    chiral_finder = ChiralFinder(smi_list_center, "SMILES")
+    res_ = chiral_finder.get_central()
+    print(res_)
+```
+
+You will get the images of two molecules with predicted chiral axes in the folder `./img` by default. Predicted chiral axes:
+
+```
+[(5,)] [(9, 10)]
+```
+
+<img src="https://github.com/Meteor-han/chiralfinder/blob/main/img_axial/0.png" alt="0" width="30%" height="auto" /><img src="https://github.com/Meteor-han/chiralfinder/blob/main/img_axial/1.png" alt="1"  width="30%" height="auto" />
+
+You will get the prediction of one molecule for central chirality.
+
+```
+[{
+'center id': [4], 
+'quadrupole matrix': 
+       [[array([[-0.29989323, -1.08474687,  0.09943544],
+       [-2.0754821 ,  0.47857598,  1.02051223],
+       [-0.0064714 , -0.03258116,  2.29906673]])]], 
+'determinant': [[-5.501797575969392]], 
+'sign': [[-1.0]]
+}]
+```
+
+
+## Dataset
+
+The RotA dataset is stored in the folder `./data`. The excel file contains labeled chiral axes and some calculated molecular properties. The pickle file includes calculated molecular conformers.
+
+We also provide sampled achiral molecules and centrally chiral molecules with multiple centers from the PubChem3D database in the folder `./data`.
+
+## Citation
+
+```
+To be filled
+```
+

chiralfinder-0.0.1/chiralfinder/__init__.py

@@ -0,0 +1,22 @@
+from ._quadrupole import (
+    ChiralCenter,
+    ChiralAxialType1,
+    ChiralAxialType2,
+    ChiralAxialType3,
+    ChiralAxialType4,
+    ChiralAxialType5,
+    ChiralAxialType6,
+    ChiralFinder
+)
+
+
+__all__ = (
+    "ChiralFinder",
+    "ChiralCenter",
+    "ChiralAxialType1",
+    "ChiralAxialType2",
+    "ChiralAxialType3",
+    "ChiralAxialType4",
+    "ChiralAxialType5",
+    "ChiralAxialType6"
+)

chiralfinder-0.0.1/chiralfinder/_quadrupole/__init__.py

@@ -0,0 +1,20 @@
+from .quadrupole_center import ChiralCenter
+from .quadrupole_v1 import ChiralAxialType1
+from .quadrupole_v2 import ChiralAxialType2
+from .quadrupole_v3 import ChiralAxialType3
+from .quadrupole_v4 import ChiralAxialType4
+from .quadrupole_v5 import ChiralAxialType5
+from .quadrupole_v6 import ChiralAxialType6
+from .run import ChiralFinder
+
+
+__all__ = (
+    "ChiralFinder",
+    "ChiralCenter",
+    "ChiralAxialType1",
+    "ChiralAxialType2",
+    "ChiralAxialType3",
+    "ChiralAxialType4",
+    "ChiralAxialType5",
+    "ChiralAxialType6"
+)

chiralfinder-0.0.1/chiralfinder/_quadrupole/quadrupole_center.py

@@ -0,0 +1,48 @@
+from .quadrupole_utils import *
+
+
+class ChiralCenter(ChiralBase):
+    def __init__(self, mol, mol_wo_Hs=None, CIP=True):
+        super().__init__(mol, mol_wo_Hs, CIP)
+
+    # get the chiral matrices
+    def get_chi_mat(self):
+        cen_chi = self.find_center_atoms()
+
+        mats, dets, norm_cp, signs = [], [], [], []  # for each conf
+        for i in cen_chi:
+            mat_confs = []
+            det_confs = []
+            norm_det_confs = []
+            sign_confs = []
+            for conf_ in self.coordinates:
+                atom = self.atoms[i]
+                neighbors = atom.GetNeighbors()
+                # (id_, rank_), sort by rank, increasing
+                neigh_id_rank = [(atom_.GetIdx(), self.CIP_list[atom_.GetIdx()]) for atom_ in neighbors]
+                neigh_id_rank = sorted(neigh_id_rank, key=lambda x: x[1])
+
+                # center, atom 1, 2, 3, 4
+                neigh_cor = [conf_[i]]
+                for one in neigh_id_rank:
+                    neigh_cor.append(conf_[one[0]])
+                # get the matrix
+                if len(neigh_cor) == 4:
+                    neigh_cor.insert(1, (neigh_cor[1]+neigh_cor[2]+neigh_cor[3]-neigh_cor[0]*3)/3*-1.0+neigh_cor[0])
+                if len(neigh_cor) < 5:
+                    continue
+                a = neigh_cor[1] - neigh_cor[0]
+                b = neigh_cor[4] - neigh_cor[3]
+                c = neigh_cor[4] - neigh_cor[2]
+                cp_max = np.linalg.norm(np.cross(a, b)) * np.linalg.norm(c)
+                mat = np.array([a, b, c])
+                mat_confs.append(mat)
+                det_, sign_ = self.criterion(mat)
+                det_confs.append(det_)
+                norm_det_confs.append(det_/cp_max)
+                sign_confs.append(sign_)
+            mats.append(mat_confs)
+            dets.append(det_confs)
+            norm_cp.append(norm_det_confs)
+            signs.append(sign_confs)
+        return {"center id": cen_chi, "quadrupole matrix": mats, "determinant": dets, "norm CP": norm_cp, "sign": signs}

chiralfinder-0.0.1/chiralfinder/_quadrupole/quadrupole_utils.py

@@ -0,0 +1,142 @@
+from rdkit import Chem
+from rdkit.Chem import AllChem
+from copy import deepcopy
+import numpy as np
+from collections import defaultdict
+import warnings
+
+
+class ChiralBase:
+    def __init__(self, mol=None, mol_wo_Hs=None, max_conf_num=5, sign_eps=1e-4, CIP=True):
+        # with Hs
+        self.mol = mol
+        self.mol_wo_Hs = Chem.RemoveHs(mol) if mol_wo_Hs is None else mol_wo_Hs
+        self.atoms = mol.GetAtoms()
+        self.ssr = Chem.GetSymmSSSR(mol)
+        self.connection = Chem.GetAdjacencyMatrix(mol)
+        # coordinates, important; up to max_conf_num
+        self.coordinates = []
+        self.max_conf_num = max_conf_num
+        self.sign_eps = sign_eps
+        for conf in mol.GetConformers():
+            # np array
+            self.coordinates.append(conf.GetPositions())
+            if len(self.coordinates) >= max_conf_num:
+                break
+        # self.conformer = mol.GetConformer()
+        if CIP:
+            # dict is OK
+            # AssignStereochemistry may fail anyway, try AssignStereochemistryFrom3D
+            try:
+                Chem.AssignStereochemistryFrom3D(self.mol_wo_Hs)
+                self.CIP_list = defaultdict(lambda: -1)
+                for atom in self.mol_wo_Hs.GetAtoms():
+                    self.CIP_list[atom.GetIdx()] = int(atom.GetProp('_CIPRank'))
+            except:
+                warnings.warn("Fail to assign CIPs, use CanonicalRankAtoms instead.")
+                # just an order, not CIP, unable to relate to R/S
+                self.CIP_list = list(Chem.CanonicalRankAtoms(
+                    mol, breakTies=False, includeChirality=True, includeIsotopes=True))
+        else:
+            # just an order, not CIP, unable to relate to R/S
+            self.CIP_list = list(Chem.CanonicalRankAtoms(
+                mol, breakTies=False, includeChirality=True, includeIsotopes=True))
+
+    # find chiral atoms
+    # with Hs, may get false center C "?"
+    def find_center_atoms(self):
+        c0 = Chem.FindMolChiralCenters(self.mol_wo_Hs, useLegacyImplementation=False)
+        cen_chi = [i[0] for i in c0]
+        return cen_chi
+    
+    # find spiral atoms
+    def find_spiral_atoms(self):
+        # find all atoms shared by two rings
+        # for some molecules with Hs, "RingInfo not initialized"
+        ri = self.mol_wo_Hs.GetRingInfo()
+        spi_pot = []
+        for atom in self.atoms:
+            if ri.NumAtomRings(atom.GetIdx()) == 2:
+                spi_pot.append(atom.GetIdx())
+
+        # delete all atoms who share completely same rings with their neighbors
+        ssr = Chem.GetSymmSSSR(self.mol)
+        spi = deepcopy(spi_pot)
+        for j in spi_pot:
+            j_ring = []
+            for ring in ssr:
+                if j in ring:
+                    j_ring.append(list(ring))
+            j_ring = j_ring[0] + j_ring[1]
+
+            neighbors = [atom.GetIdx() for atom in self.atoms[j].GetNeighbors()]
+            for k in neighbors:
+                if j_ring.count(k) == 2:
+                    spi.remove(j)
+                    break
+        return spi
+
+    # whether two atoms share one ring
+    def pub_ring(self, atom_1, atom_2):        
+        atom_1_ring = []
+        # atom_1 rings
+        for ring in self.ssr:
+            if atom_1 in list(ring):
+                atom_1_ring.extend(list(ring))
+        # atom_2
+        return True if atom_2 in set(atom_1_ring) else False
+
+    # find 'C=C' like double bonds
+    def get_double_bond(self):
+        bonds = self.mol.GetBonds()
+        double_bonds = []
+        for bond in bonds:
+            if bond.GetBondType() == Chem.rdchem.BondType.DOUBLE:
+                double_bonds.append(bond)
+        return double_bonds
+
+    # whether two bonds share one atom
+    def pub_atom(self, bond_1_, bond_2_):
+        atom_1_id = [bond_1_.GetBeginAtomIdx(), bond_1_.GetEndAtomIdx()]
+        atom_2_id = [bond_2_.GetBeginAtomIdx(), bond_2_.GetEndAtomIdx()]
+        criterion = set(atom_1_id + atom_2_id)
+        return True if len(criterion) == 3 else False
+
+    # compute the absolute chirality
+    def criterion(self, mat):
+        det_ = np.linalg.det(mat)
+        sign_ = np.sign(det_) if abs(det_) > self.sign_eps else 0
+        return det_, sign_
+
+    def check_chain_equal(self, bonds_chain):
+        bonds2idx = []
+        for one_ in bonds_chain:
+            temp = []
+            for bond in one_:
+                temp.append(sorted([bond.GetBeginAtomIdx(), bond.GetEndAtomIdx()]))
+            bonds2idx.append(sorted(temp))
+        return sorted(bonds2idx)
+
+# add Hs, retain existing coor, xy axis reverse coor
+def transform_coordinate(mol_):
+    # if no conformer, try to embed
+    if mol_.GetNumConformers() == 0:
+        AllChem.EmbedMolecule(mol_, maxAttempts=100)
+    mol = Chem.AddHs(mol_, addCoords=True)
+    # copy
+    mol_r = Chem.Mol(mol)
+    mol_r.RemoveAllConformers()
+    num_atoms = mol.GetNumAtoms()
+    conf_num = mol.GetNumConformers()
+    assert conf_num > 0.5
+    for i in range(conf_num):
+        c = mol.GetConformer(i)
+        p = c.GetPositions()
+        p_r = np.copy(p)
+        p_r[:, 2] = -p_r[:, 2]
+        _conformer = Chem.Conformer(num_atoms)
+        for j in range(len(p_r)):
+            _conformer.SetAtomPosition(j, p_r[j])
+        mol_r.AddConformer(_conformer, assignId=True)
+
+    return mol, mol_r

chiralfinder-0.0.1/chiralfinder/_quadrupole/quadrupole_v1.py

@@ -0,0 +1,72 @@
+# Quadrupole Matrix, spiral atom
+from .quadrupole_utils import *
+
+
+class ChiralAxialType1(ChiralBase):
+    """axial spiral (1 atom)"""
+    def __init__(self, mol):
+        super().__init__(mol)
+
+    # find spiral atoms with "axial chirality"
+    def find_chi_spi(self, spi_):
+        chi_spi = []
+        ssr = Chem.GetSymmSSSR(self.mol)
+        for i in spi_:
+            # get the rings where spiral atoms are in
+            i_ring = []
+            for ring in ssr:
+                if i in ring:
+                    i_ring.append(list(ring))
+            # classify the spiral atom's neighbors with rings
+            nei_1 = self.atoms[i].GetNeighbors()
+            nei_1 = [x.GetIdx() for x in nei_1]
+            raw_nei_1 = deepcopy(nei_1)
+            nei_2 = []
+            for j in range(len(raw_nei_1)):
+                if raw_nei_1[j] in i_ring[0]:
+                    nei_2.append(raw_nei_1[j])
+                    nei_1.remove(raw_nei_1[j])
+            # whether neighbors who are in the same ring are equivalent
+            if (nei_1[0] - nei_1[1]) * (nei_2[0] - nei_2[1]) != 0:
+                chi_spi.append([i, nei_1, nei_2])
+
+        return chi_spi
+
+    # get the chiral matrices
+    def get_chi_mat(self):
+        chi_spi_ = self.find_chi_spi(self.find_spiral_atoms())
+
+        mats, dets, norm_cp, signs = [], [], [], []  # for each conf
+        for one in chi_spi_:
+            # (id_, rank_), sort by rank, increasing
+            nei_1_id_rank = [(i, self.CIP_list[self.atoms[i].GetIdx()]) for i in one[1]]
+            nei_2_id_rank = [(i, self.CIP_list[self.atoms[i].GetIdx()]) for i in one[2]]
+            nei_1_id_rank = sorted(nei_1_id_rank, key=lambda x: x[1])
+            nei_2_id_rank = sorted(nei_2_id_rank, key=lambda x: x[1])
+            neigh_id_rank = nei_1_id_rank + nei_2_id_rank
+
+            mat_confs = []
+            det_confs = []
+            norm_det_confs = []
+            sign_confs = []
+            for conf_ in self.coordinates:
+                neigh_cor = [conf_[one[0]]]
+                for one_ in neigh_id_rank:
+                    neigh_cor.append(conf_[one_[0]])
+                # get the matrix
+                a = neigh_cor[1] - neigh_cor[0]
+                b = neigh_cor[2] - neigh_cor[0]
+                c = neigh_cor[3] - neigh_cor[4]
+                cp_max = np.linalg.norm(np.cross(a, b)) * np.linalg.norm(c)
+                mat = np.array([a, b, c])
+                mat_confs.append(mat)
+                det_, sign_ = self.criterion(mat)
+                det_confs.append(det_)
+                norm_det_confs.append(det_/cp_max)
+                sign_confs.append(sign_)
+            mats.append(mat_confs)
+            dets.append(det_confs)
+            norm_cp.append(norm_det_confs)
+            signs.append(sign_confs)
+        return {"spiral id": chi_spi_, "chiral axes": [(one[0],) for one in chi_spi_], "quadrupole matrix": mats, 
+                "determinant": dets, "norm CP": norm_cp, "sign": signs}