rdworks 0.47.1__tar.gz → 0.48.1__tar.gz

{rdworks-0.47.1 → rdworks-0.48.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rdworks
-Version: 0.47.1
+Version: 0.48.1
 Summary: Routine tasks built on RDKit and other tools
 Author-email: Sung-Hun Bae <sunghun.bae@gmail.com>
 Maintainer-email: Sung-Hun Bae <sunghun.bae@gmail.com>

{rdworks-0.47.1 → rdworks-0.48.1}/src/rdworks/__init__.py

@@ -1,4 +1,4 @@
-__version__ = '0.47.1'
+__version__ = '0.48.1'
 
 from rdworks.conf    import Conf
 from rdworks.mol     import Mol

{rdworks-0.47.1 → rdworks-0.48.1}/src/rdworks/ionized.py

@@ -1,4 +1,5 @@
 import importlib.resources
+from types import SimpleNamespace
 import pandas as pd
 
 from rdkit import Chem
@@ -6,6 +7,11 @@ from rdkit import Chem
 # adapted from https://github.com/dptech-corp/Uni-pKa/enumerator
 
 class IonizedStates:
+    """Knowledge-based enumeration of (de)protonated states"""
+
+    smarts_path = importlib.resources.files('rdworks.predefined.ionized')
+    ionization_patterns = pd.read_csv(smarts_path / 'simple_smarts_pattern.csv')
+    
     # Unreasonable chemical structures
     unreasonable_patterns = [
         Chem.MolFromSmarts(s) for s in [
@@ -31,67 +37,38 @@ class IonizedStates:
             "[N+1](=O)-[O]-[H]",
         ]]
 
-    smarts_path = importlib.resources.files('rdworks.predefined.ionized')
-    protonation_patterns = pd.read_csv(smarts_path / 'simple_smarts_pattern.csv')
 
-    def __init__(self, smiles:str):
+    def __init__(self, smiles: str, charge_min: int = -2, charge_max: int = 2):
         self.smiles = Chem.CanonSmiles(smiles)
+        self.charge_max = charge_max
+        self.charge_min = charge_min
+
         self.rdmol = Chem.MolFromSmiles(self.smiles)
         self.rdmol_H = Chem.AddHs(self.rdmol)
         self.charge = Chem.GetFormalCharge(self.rdmol_H)
-        self.charge_max =  2
-        self.charge_min = -2
+        
         # initial states
         self.states = {self.smiles : (self.rdmol_H, self.charge)}
-        # initial protonation sites
-        self.protonation_sites = {self.smiles : self.set_protonation_sites(self.smiles)}
-        # generate initial states
-        self.protonate(self.smiles)
+        
+        # initial ionization sites
+        self.sites = {self.smiles: self.set_ionization_sites(self.smiles)}
 
-    
-    def get_protonation_sites(self) -> dict:
-        return self.protonation_sites
+        # pKa pairs: 
+        # HA(acid) + H2O == A-(base) + H3O+ or HA+(acid) + H2O == A(base) + H3O+
+        self.pairs = []
 
-    
-    def get_states_by_charge(self) -> dict:
+        # iteratively build an ensemble of ionized states
         self.ensemble()
-        data = {}
-        for smiles, (romol, charge) in self.states.items():
-            if charge in data:
-                data[charge].append(smiles)
-            else:
-                data[charge] = [smiles]
 
-        return data
-
-    def get_states(self) -> list:
-        return [smiles for smiles in self.states]
-    
-
-    def get_states_mol(self) -> list[Chem.Mol]:
-        return [romol for smiles, (romol, charge) in self.states.items()]
-    
-
-    def get_num_states(self) -> int:
-        return len(self.states)
 
     
     @staticmethod
-    def clean_smiles(rdmol:Chem.Mol) -> str:
-        Chem.SanitizeMol(rdmol)
-        rdmol = Chem.MolFromSmiles(Chem.MolToSmiles(rdmol))
-        rdmol_H = Chem.AddHs(rdmol)
-        rdmol = Chem.RemoveHs(rdmol_H)
-        return Chem.CanonSmiles(Chem.MolToSmiles(rdmol))
-
-
-    @staticmethod
-    def set_protonation_sites(smiles:str) -> tuple:
+    def set_ionization_sites(smiles: str) -> tuple:
         subject = Chem.MolFromSmiles(smiles)
         subject = Chem.AddHs(subject)
         charge = Chem.GetFormalCharge(subject)        
         indices = [] # atom indices of protonation/deprotonation site(s)
-        for i, name, smarts, smarts_index, acid_or_base in IonizedStates.protonation_patterns.itertuples():
+        for i, name, smarts, smarts_index, acid_or_base in IonizedStates.ionization_patterns.itertuples():
             pattern = Chem.MolFromSmarts(smarts)
             matches = subject.GetSubstructMatches(pattern)
             # returns a list of tuples, where each tuple contains the indices 
@@ -100,21 +77,34 @@ class IonizedStates:
             if len(matches) > 0:
                 smarts_index = int(smarts_index)
                 indices += [(match[smarts_index], acid_or_base) for match in matches]
+        
         return (list(set(indices)), subject, charge)
+    
+
+    @staticmethod
+    def clean_smiles(rdmol: Chem.Mol) -> str:
+        Chem.SanitizeMol(rdmol)
+        rdmol = Chem.MolFromSmiles(Chem.MolToSmiles(rdmol))
+        rdmol_H = Chem.AddHs(rdmol)
+        rdmol = Chem.RemoveHs(rdmol_H)
+        return Chem.CanonSmiles(Chem.MolToSmiles(rdmol))
 
 
     @staticmethod
-    def reasonable(romol:Chem.Mol) -> bool:
+    def reasonable(romol: Chem.Mol) -> bool:
         return all([len(romol.GetSubstructMatches(p)) == 0 for p in IonizedStates.unreasonable_patterns])
+    
 
-        
-    def protonate(self, smiles:str) -> int:
+    def ionize(self, smiles: str | None = None) -> int:
         num_added_states = 0
         
-        if smiles not in self.protonation_sites:
-            self.protonation_sites[smiles] = self.set_protonation_sites(smiles)   
+        if smiles is None:
+            smiles = self.smiles
+
+        if smiles not in self.sites:
+            self.sites[smiles] = self.set_ionization_sites(smiles)
         
-        (indices, subject, charge) = self.protonation_sites[smiles]
+        (indices, subject, charge) = self.sites[smiles]
         
         if (charge >= self.charge_max) or (charge <= self.charge_min):
             # formal charge will be increased or decreased by protonation/deprotonation
@@ -149,22 +139,56 @@ class IonizedStates:
                 edmol = Chem.AddHs(edmol)
             
             # Clean up and save SMILES
-            state_smiles = IonizedStates.clean_smiles(edmol)
-            state_mol = Chem.MolFromSmiles(state_smiles)
-            state_mol = Chem.AddHs(state_mol)
-            state_charge = Chem.GetFormalCharge(state_mol)
-            if self.reasonable(state_mol):
-                if state_smiles in self.states:
+            ionized_smiles = IonizedStates.clean_smiles(edmol)
+            ionized_mol = Chem.MolFromSmiles(ionized_smiles)
+            ionized_mol = Chem.AddHs(ionized_mol)
+            ionized_charge = Chem.GetFormalCharge(ionized_mol)
+            if self.reasonable(ionized_mol):
+                if ionized_smiles in self.states:
                     continue
-                self.states[state_smiles] = (state_mol, state_charge)
+                self.states[ionized_smiles] = (ionized_mol, ionized_charge)
                 num_added_states += 1
+            
+                # store acid-base pair information for pKa
+                if acid_or_base == 'A':
+                    self.pairs.append((i, smiles, ionized_smiles))
+                elif acid_or_base == 'B':
+                    self.pairs.append((i, ionized_smiles, smiles))
 
         return num_added_states
-
+    
     
     def ensemble(self) -> None:
+        # populate initial states
+        self.ionize()
+
+        # propagate
         num_added_states = None       
         while num_added_states is None or num_added_states > 0:
-            states = self.states.copy()
+            states = self.states.copy() # dictionary
+            # self.ionize(smiles) below will change self.states
+            # so we cannot iterate self.states. Instead we will
+            # iterate over a copy of the self.states
             for smiles in states:
-                num_added_states = self.protonate(smiles)
+                num_added_states = self.ionize(smiles) 
+                
+    
+    def count(self) -> int:
+        return len(self.states)
+
+
+    def get_sites(self) -> dict:
+        return self.sites
+    
+    
+    def get_smiles(self) -> list[str]:
+        return [smiles for smiles in self.states]
+    
+
+    def get_rdmol(self) -> list[Chem.Mol]:
+        return [romol for smiles, (romol, charge) in self.states.items()]
+    
+
+    def get_pairs(self) -> list:
+        return self.pairs
+    

{rdworks-0.47.1 → rdworks-0.48.1}/src/rdworks.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rdworks
-Version: 0.47.1
+Version: 0.48.1
 Summary: Routine tasks built on RDKit and other tools
 Author-email: Sung-Hun Bae <sunghun.bae@gmail.com>
 Maintainer-email: Sung-Hun Bae <sunghun.bae@gmail.com>

{rdworks-0.47.1 → rdworks-0.48.1}/src/rdworks.egg-info/SOURCES.txt

@@ -75,9 +75,7 @@ src/rdworks/predefined/misc/reactive.xml
 src/rdworks/xtb/__init__.py
 src/rdworks/xtb/wrapper.py
 tests/test_basics.py
-tests/test_decimals.py
-tests/test_gypsumdl.py
-tests/test_iupac_name.py
-tests/test_nn_xtb.py
-tests/test_web.py
+tests/test_ionized.py
+tests/test_round.py
+tests/test_torsion.py
 tests/test_xtb.py

{rdworks-0.47.1 → rdworks-0.48.1}/tests/test_basics.py

@@ -51,24 +51,6 @@ drug_names = [
     "Methixene",  "Ethopropazine", "Aspirin", "Fluconazole", "Linezolid",
     ]
 
-# Lahey, S.-L. J., Thien Phuc, T. N. & Rowley, C. N. 
-# Benchmarking Force Field and the ANI Neural Network Potentials for the 
-# Torsional Potential Energy Surface of Biaryl Drug Fragments. 
-# J. Chem. Inf. Model. 60, 6258–6268 (2020)
-
-torsion_dataset_smiles = [
-    "C1(C2=CC=CN2)=CC=CC=C1",
-    "C1(C2=NC=CN2)=CC=CC=C1",
-    "C1(N2C=CC=C2)=NC=CC=N1",
-    "C1(C2=NC=NC=N2)=CC=CC=C1",
-    "C1(N2C=CC=C2)=CC=CC=C1",
-    "O=C(N1)C=CC=C1C2=COC=C2",
-    "C1(C2=NC=CC=N2)=NC=CC=N1",
-    "O=C(N1)C=CC=C1C2=NC=CN2",
-    ]
-
-torsion_dataset_names=["07", "09","20", "39", "10", "23", "12", "29"]
-
 
 def test_init_mol():
     mol = Mol(drug_smiles[0], drug_names[0])
@@ -458,86 +440,6 @@ def test_optimize_confs():
     mol = mol.make_confs().optimize_confs(calculator='MMFF94')
 
 
-def test_xtb_wrapper():
-    from rdworks.xtb.wrapper import GFN2xTB
-    assert GFN2xTB.is_xtb_ready() == True
-    assert GFN2xTB.is_cpx_ready() == True
-    assert GFN2xTB.is_cpcmx_option_ready() == True
-    assert GFN2xTB.is_ready() == True
-    assert GFN2xTB.version() is not None
-
-
-def test_torsion_fragment():
-    from rdworks.torsion import create_torsion_fragment
-    mol = Mol(molecule="CC(C)C1=C(C(=C(N1CC[C@H](C[C@H](CC(=O)O)O)O)C2=CC=C(C=C2)F)C3=CC=CC=C3)C(=O)NC4=CC=CC=C4",
-              name="atorvastatin").make_confs(n=1)
-    ta = mol.torsion_atoms()
-    assert len(ta) == 12
-    # {0: (0, 1, 3, 7),  1: (3, 4, 32, 33),  2: (4, 5, 26, 27),  3: (7, 6, 19, 20),
-    # 4: (3, 7, 8, 9),  5: (7, 8, 9, 10),   6: (8, 9, 10, 18),   7: (18, 10, 11, 12),
-    # 8: (10, 11, 12, 17),  9: (17, 12, 13, 14),   10: (12, 13, 14, 15),   11: (36, 35, 34, 32)}
-    (frag, frag_ijkl, frag_created, wbo_filtered) = create_torsion_fragment(mol.confs[0].rdmol, ta[6])
-    assert frag_ijkl == (5, 6, 7, 12)
-    assert frag_created == True
-    assert wbo_filtered == True
-
-    mol2 = Mol(molecule='CC(=O)Nc1ccc(O)cc1', name='acetaminophen.3').make_confs(n=1)
-    ta2 = mol2.torsion_atoms()
-    # {0: (5, 4, 3, 1)}
-    assert len(ta2) == 1
-
-    (frag, frag_ijkl, frag_created, wbo_filtered) = create_torsion_fragment(mol2.confs[0].rdmol, ta2[0])
-    # expects no fragmentation
-    assert frag == mol2.confs[0].rdmol
-    assert frag_ijkl == ta2[0]
-    assert frag_created == False
-    assert wbo_filtered == False
-
-
-def test_torsion_fragment_from_conf():
-    from rdworks.torsion import create_torsion_fragment
-    mol = Mol(molecule="CC(C)C1=C(C(=C(N1CC[C@H](C[C@H](CC(=O)O)O)O)C2=CC=C(C=C2)F)C3=CC=CC=C3)C(=O)NC4=CC=CC=C4",
-              name="atorvastatin").make_confs(n=1)
-    ref_conf = mol.confs[0]
-    ta = ref_conf.torsion_atoms()
-    assert len(ta) == 12
-    # {0: (0, 1, 3, 7),  1: (3, 4, 32, 33),  2: (4, 5, 26, 27),  3: (7, 6, 19, 20),
-    # 4: (3, 7, 8, 9),  5: (7, 8, 9, 10),   6: (8, 9, 10, 18),   7: (18, 10, 11, 12),
-    # 8: (10, 11, 12, 17),  9: (17, 12, 13, 14),   10: (12, 13, 14, 15),   11: (36, 35, 34, 32)}
-    frag, frag_ijkl, frag_created, wbo_filtered = create_torsion_fragment(ref_conf.rdmol, ta[6])
-    assert frag_ijkl == (5, 6, 7, 12)
-    assert frag_created == True
-    assert wbo_filtered == True
-
-    ref_conf = ref_conf.torsion_energies(calculator='MMFF94', torsion_key=6, interval=15)
-
-    mol2 = Mol(molecule='CC(=O)Nc1ccc(O)cc1', name='acetaminophen.3').make_confs(n=1)
-    ref_conf2 = mol2.confs[0]
-    ta2 = ref_conf2.torsion_atoms()
-    # {0: (5, 4, 3, 1)}
-    assert len(ta2) == 1
-    frag, frag_ijkl, frag_created, wbo_filtered = create_torsion_fragment(ref_conf2.rdmol, ta2[0])
-    # expects no fragmentation
-    assert frag == ref_conf2.rdmol
-    assert frag_ijkl == ta2[0]
-    assert frag_created == False
-    assert wbo_filtered == False
-
-    ref_conf2 = ref_conf2.torsion_energies(calculator='MMFF94', interval=15)
-    ref_conf3 = ref_conf2.torsion_energies_one(calculator='MMFF94', indices=frag_ijkl)
-
-
-def test_torsion_energies():
-    libr = MolLibr(torsion_dataset_smiles, torsion_dataset_names)
-    with open(workdir / 'test_torsion_energies.html', 'w') as f:
-        for mol in libr[:1]:
-            mol = mol.make_confs().drop_confs(similar=True, similar_rmsd=0.3).sort_confs().rename()
-            mol = mol.optimize_confs(calculator='MMFF94').torsion_energies(calculator='MMFF94', 
-                                                                           interval=15)
-            f.write(mol.to_html())
-            print(mol.dumps('torsion', decimals=2))
-
-
 def test_workflow():
     state_mol = Mol('Cc1nc2cc(Cl)nc(Cl)c2nc1C', 'A-1250')
     state_mol = state_mol.make_confs(n=50, method='ETKDG')
@@ -563,4 +465,4 @@ def test_serialization():
     rebuilt = Mol().deserialize(serialized)
     assert rebuilt.count() == 10
     assert rebuilt.name == name
-    assert rebuilt == mol
+    assert rebuilt == mol

rdworks-0.48.1/tests/test_ionized.py

@@ -0,0 +1,34 @@
+from rdworks import IonizedStates
+
+
+def test_ionizedstate():    
+    smiles = 'O=C(NCCCC)[C@H](CCC1)N1[C@@H](CC)C2=NN=C(CC3=CC=C(C)C=C3)O2'
+    x = IonizedStates(smiles)
+
+    assert x.count() == 7
+    
+    d = x.get_sites()
+    print('sites:')
+    for k, v in d.items():
+        print(k, v)
+    print()
+
+    indices = d['CCCCNC(=O)[C@@H]1CCCN1[C@@H](CC)c1nnc(Cc2ccc(C)cc2)o1'][0]
+    
+    assert (11, 'B') in indices
+    assert (16, 'B') in indices
+    assert (17, 'B') in indices
+
+    expected = ['CCCCNC(=O)[C@@H]1CCCN1[C@@H](CC)c1nnc(Cc2ccc(C)cc2)o1', 
+                'CCCCNC(=O)[C@@H]1CCCN1[C@@H](CC)c1[nH+]nc(Cc2ccc(C)cc2)o1', 
+                'CCCCNC(=O)[C@@H]1CCC[NH+]1[C@@H](CC)c1nnc(Cc2ccc(C)cc2)o1', 
+                'CCCCNC(=O)[C@@H]1CCCN1[C@@H](CC)c1n[nH+]c(Cc2ccc(C)cc2)o1', 
+                'CCCCNC(=O)[C@@H]1CCC[NH+]1[C@@H](CC)c1[nH+]nc(Cc2ccc(C)cc2)o1', 
+                'CCCCNC(=O)[C@@H]1CCCN1[C@@H](CC)c1[nH+][nH+]c(Cc2ccc(C)cc2)o1', 
+                'CCCCNC(=O)[C@@H]1CCC[NH+]1[C@@H](CC)c1n[nH+]c(Cc2ccc(C)cc2)o1']
+    results = x.get_smiles()
+    assert set(expected).intersection(set(results)) == set(expected)
+
+
+if __name__ == '__main__':
+    test_ionizedstate()

rdworks-0.47.1/tests/test_decimals.py → rdworks-0.48.1/tests/test_round.py

@@ -1,71 +1,79 @@
-from rdworks.utils import recursive_round
-
-def test_recursive_round():
-    data1 = {
-        "name": "Test Data",
-        "version": 1.0,
-        "values": [1.23456, 2.34567, {"nested_value": 3.456789}],
-        "details": {
-            "temperature": 25.1234567,
-            "pressure": 1013.256789,
-            "measurements": [0.000123, 123.45000, 987.654321]
-        },
-        "another_list": [
-            {"a": 1.111, "b": 2.2222},
-            [3.33333, 4.444444]
-        ],
-        "integer_val": 10,
-        "string_val": "hello"
-    }
-
-    data2 = [
-        10.123,
-        "string",
-        [1.0, 2.3456, {"key": 9.87654321}],
-        {"val1": 7.777777, "val2": [0.1, 0.02, 0.003]}
-    ]
-
-    data3 = 123.456789
-
-    data4 = "Just a string"
-
-    data5 = [1, 2, 3] # No floats
-
-    print("Original data1:", data1)
-    modified_data1_dp2 = recursive_round(data1, 2)
-    print("Modified data1 (2 decimal places):", modified_data1_dp2)
-    modified_data1_dp0 = recursive_round(data1, 0)
-    
-    print("Modified data1 (0 decimal places):", modified_data1_dp0)
-    modified_data1_dp4 = recursive_round(data1, 4)
-    print("Modified data1 (4 decimal places):", modified_data1_dp4)
-
-    print("\nOriginal data2:", data2)
-    modified_data2_dp3 = recursive_round(data2, 3)
-    print("Modified data2 (3 decimal places):", modified_data2_dp3)
-
-    print("\nOriginal data3:", data3)
-    modified_data3_dp1 = recursive_round(data3, 1)
-    print("Modified data3 (1 decimal place):", modified_data3_dp1)
-
-    print("\nOriginal data4:", data4)
-    modified_data4_dp2 = recursive_round(data4, 2)
-    print("Modified data4 (2 decimal places):", modified_data4_dp2) # Should be unchanged
-
-    print("\nOriginal data5:", data5)
-    modified_data5_dp2 = recursive_round(data5, 2)
-    print("Modified data5 (2 decimal places):", modified_data5_dp2) # Should be unchanged
-
-    # Example of invalid decimal_places
-    try:
-        recursive_round(data1, -1)
-    except ValueError as e:
-        print(f"\nError caught: {e}")
-
-    try:
-        recursive_round(data1, 1.5)
-    except ValueError as e:
-        print(f"Error caught: {e}")
-
-if __name__ == '__main__':
-    test_recursive_round()
+def test_recursive_round():
+    
+    from rdworks.utils import recursive_round
+
+    data1 = {
+        "name": "Test Data",
+        "version": 1.0,
+        "values": [1.23456, 2.34567, {"nested_value": 3.456789}],
+        "details": {
+            "temperature": 25.1234567,
+            "pressure": 1013.256789,
+            "measurements": [0.000123, 123.45000, 987.654321]
+        },
+        "another_list": [
+            {"a": 1.111, "b": 2.2222},
+            [3.33333, 4.444444]
+        ],
+        "integer_val": 10,
+        "string_val": "hello"
+    }
+
+    data2 = [
+        10.123,
+        "string",
+        [1.0, 2.3456, {"key": 9.87654321}],
+        {"val1": 7.777777, "val2": [0.1, 0.02, 0.003]}
+    ]
+
+    data3 = 123.456789
+
+    data4 = "Just a string"
+
+    data5 = [1, 2, 3] # No floats
+
+    print("Original data1:", data1)
+    
+    modified_data1_dp2 = recursive_round(data1, 2)
+    
+    assert modified_data1_dp2 == {'name': 'Test Data', 'version': 1.0, 'values': [1.23, 2.35, {'nested_value': 3.46}], 'details': {'temperature': 25.12, 'pressure': 1013.26, 'measurements': [0.0, 123.45, 987.65]}, 'another_list': [{'a': 1.11, 'b': 2.22}, [3.33, 4.44]], 'integer_val': 10, 'string_val': 'hello'}
+    print("\nModified data1 (2 decimal places):", modified_data1_dp2)
+    
+    modified_data1_dp0 = recursive_round(data1, 0)
+    assert modified_data1_dp0 == {'name': 'Test Data', 'version': 1.0, 'values': [1.0, 2.0, {'nested_value': 3.0}], 'details': {'temperature': 25.0, 'pressure': 1013.0, 'measurements': [0.0, 123.0, 988.0]}, 'another_list': [{'a': 1.0, 'b': 2.0}, [3.0, 4.0]], 'integer_val': 10, 'string_val': 'hello'}
+    print("\nModified data1 (0 decimal places):", modified_data1_dp0)
+
+    print("\nOriginal data2:", data2)
+    modified_data2_dp3 = recursive_round(data2, 3)
+    assert modified_data2_dp3 == [10.123, 'string', [1.0, 2.346, {'key': 9.877}], {'val1': 7.778, 'val2': [0.1, 0.02, 0.003]}]
+    print("\nModified data2 (3 decimal places):", modified_data2_dp3)
+
+    print("\nOriginal data3:", data3)
+    modified_data3_dp1 = recursive_round(data3, 1)
+    assert modified_data3_dp1 == 123.5
+    print("\nModified data3 (1 decimal place):", modified_data3_dp1)
+
+    print("\nOriginal data4:", data4)
+    modified_data4_dp2 = recursive_round(data4, 2)
+    assert modified_data4_dp2 == 'Just a string'
+    print("\nModified data4 (2 decimal places):", modified_data4_dp2) # Should be unchanged
+
+    print("\nOriginal data5:", data5)
+    modified_data5_dp2 = recursive_round(data5, 2)
+    assert modified_data5_dp2 == [1, 2, 3]
+    print("\nModified data5 (2 decimal places):", modified_data5_dp2) # Should be unchanged
+
+    # Example of invalid decimal_places
+    try:
+        recursive_round(data1, -1)
+    except ValueError as e:
+        print(f"\nError caught: {e}")
+
+    try:
+        recursive_round(data1, 1.5)
+    except ValueError as e:
+        print(f"Error caught: {e}")
+
+
+if __name__ == '__main__':
+    test_recursive_round()

rdworks-0.48.1/tests/test_torsion.py

@@ -0,0 +1,98 @@
+from rdworks.torsion import create_torsion_fragment
+from rdworks import Mol, MolLibr
+from pathlib import Path
+
+
+datadir = Path(__file__).parent.resolve() / "data"
+workdir = Path(__file__).parent.resolve() / "outfiles"
+
+workdir.mkdir(exist_ok=True)
+
+
+# Lahey, S.-L. J., Thien Phuc, T. N. & Rowley, C. N. 
+# Benchmarking Force Field and the ANI Neural Network Potentials for the 
+# Torsional Potential Energy Surface of Biaryl Drug Fragments. 
+# J. Chem. Inf. Model. 60, 6258–6268 (2020)
+
+torsion_dataset_smiles = [
+    "C1(C2=CC=CN2)=CC=CC=C1",
+    "C1(C2=NC=CN2)=CC=CC=C1",
+    "C1(N2C=CC=C2)=NC=CC=N1",
+    "C1(C2=NC=NC=N2)=CC=CC=C1",
+    "C1(N2C=CC=C2)=CC=CC=C1",
+    "O=C(N1)C=CC=C1C2=COC=C2",
+    "C1(C2=NC=CC=N2)=NC=CC=N1",
+    "O=C(N1)C=CC=C1C2=NC=CN2",
+    ]
+
+torsion_dataset_names=["07", "09","20", "39", "10", "23", "12", "29"]
+
+
+def test_torsion_fragment():
+    
+    mol = Mol(molecule="CC(C)C1=C(C(=C(N1CC[C@H](C[C@H](CC(=O)O)O)O)C2=CC=C(C=C2)F)C3=CC=CC=C3)C(=O)NC4=CC=CC=C4",
+              name="atorvastatin").make_confs(n=1)
+    ta = mol.torsion_atoms()
+    assert len(ta) == 12
+    # {0: (0, 1, 3, 7),  1: (3, 4, 32, 33),  2: (4, 5, 26, 27),  3: (7, 6, 19, 20),
+    # 4: (3, 7, 8, 9),  5: (7, 8, 9, 10),   6: (8, 9, 10, 18),   7: (18, 10, 11, 12),
+    # 8: (10, 11, 12, 17),  9: (17, 12, 13, 14),   10: (12, 13, 14, 15),   11: (36, 35, 34, 32)}
+    (frag, frag_ijkl, frag_created, wbo_filtered) = create_torsion_fragment(mol.confs[0].rdmol, ta[6])
+    assert frag_ijkl == (5, 6, 7, 12)
+    assert frag_created == True
+    assert wbo_filtered == True
+
+    mol2 = Mol(molecule='CC(=O)Nc1ccc(O)cc1', name='acetaminophen.3').make_confs(n=1)
+    ta2 = mol2.torsion_atoms()
+    # {0: (5, 4, 3, 1)}
+    assert len(ta2) == 1
+
+    (frag, frag_ijkl, frag_created, wbo_filtered) = create_torsion_fragment(mol2.confs[0].rdmol, ta2[0])
+    # expects no fragmentation
+    assert frag == mol2.confs[0].rdmol
+    assert frag_ijkl == ta2[0]
+    assert frag_created == False
+    assert wbo_filtered == False
+
+
+def test_torsion_fragment_from_conf():
+    mol = Mol(molecule="CC(C)C1=C(C(=C(N1CC[C@H](C[C@H](CC(=O)O)O)O)C2=CC=C(C=C2)F)C3=CC=CC=C3)C(=O)NC4=CC=CC=C4",
+              name="atorvastatin").make_confs(n=1)
+    ref_conf = mol.confs[0]
+    ta = ref_conf.torsion_atoms()
+    assert len(ta) == 12
+    # {0: (0, 1, 3, 7),  1: (3, 4, 32, 33),  2: (4, 5, 26, 27),  3: (7, 6, 19, 20),
+    # 4: (3, 7, 8, 9),  5: (7, 8, 9, 10),   6: (8, 9, 10, 18),   7: (18, 10, 11, 12),
+    # 8: (10, 11, 12, 17),  9: (17, 12, 13, 14),   10: (12, 13, 14, 15),   11: (36, 35, 34, 32)}
+    frag, frag_ijkl, frag_created, wbo_filtered = create_torsion_fragment(ref_conf.rdmol, ta[6])
+    assert frag_ijkl == (5, 6, 7, 12)
+    assert frag_created == True
+    assert wbo_filtered == True
+
+    ref_conf = ref_conf.torsion_energies(calculator='MMFF94', torsion_key=6, interval=15)
+
+    mol2 = Mol(molecule='CC(=O)Nc1ccc(O)cc1', name='acetaminophen.3').make_confs(n=1)
+    ref_conf2 = mol2.confs[0]
+    ta2 = ref_conf2.torsion_atoms()
+    # {0: (5, 4, 3, 1)}
+    assert len(ta2) == 1
+    frag, frag_ijkl, frag_created, wbo_filtered = create_torsion_fragment(ref_conf2.rdmol, ta2[0])
+    # expects no fragmentation
+    assert frag == ref_conf2.rdmol
+    assert frag_ijkl == ta2[0]
+    assert frag_created == False
+    assert wbo_filtered == False
+
+    ref_conf2 = ref_conf2.torsion_energies(calculator='MMFF94', interval=15)
+    ref_conf3 = ref_conf2.torsion_energies_one(calculator='MMFF94', indices=frag_ijkl)
+
+
+def test_torsion_energies():
+    libr = MolLibr(torsion_dataset_smiles, torsion_dataset_names)
+    with open(workdir / 'test_torsion_energies.html', 'w') as f:
+        for mol in libr[:1]:
+            mol = mol.make_confs().drop_confs(similar=True, similar_rmsd=0.3).sort_confs().rename()
+            mol = mol.optimize_confs(calculator='MMFF94').torsion_energies(calculator='MMFF94', 
+                                                                           interval=15)
+            f.write(mol.to_html())
+            print(mol.dumps('torsion', decimals=2))