rdworks 0.25.8__py3-none-any.whl → 0.36.1__py3-none-any.whl

rdworks/units.py

@@ -1,63 +1,12 @@
-from types import SimpleNamespace
-
 # In ASE, the default energy unit is eV (electron volt).
-# It will be converted to kcal/mol
-#CODATA 2018 energy conversion factor
+# In xtb, the default energy unit it Eh (hartree).
+
+# CODATA 2018 energy conversion factor
+
 hartree2ev = 27.211386245988
 hartree2kcalpermol = 627.50947337481
 ev2kcalpermol = 23.060547830619026
 
-periodictable = SimpleNamespace(
-    symbol = {
-        1: 'H', 2: 'He', 3: 'Li', 4: 'Be', 5: 'B', 6: 'C', 7: 'N', 8: 'O', 9: 'F', 10: 'Ne', 
-        11: 'Na', 12: 'Mg', 13: 'Al', 14: 'Si', 15: 'P', 16: 'S', 17: 'Cl', 18: 'Ar', 19: 'K', 20: 'Ca', 
-        21: 'Sc', 22: 'Ti', 23: 'V', 24: 'Cr', 25: 'Mn', 26: 'Fe', 27: 'Co', 28: 'Ni', 29: 'Cu', 30: 'Zn', 
-        31: 'Ga', 32: 'Ge', 33: 'As', 34: 'Se', 35: 'Br', 36: 'Kr', 37: 'Rb', 38: 'Sr', 39: 'Y', 40: 'Zr', 
-        41: 'Nb', 42: 'Mo', 43: 'Tc', 44: 'Ru', 45: 'Rh', 46: 'Pd', 47: 'Ag', 48: 'Cd', 49: 'In', 50: 'Sn', 
-        51: 'Sb', 52: 'Te', 53: 'I', 54: 'Xe', 55: 'Cs', 56: 'Ba', 57: 'La', 58: 'Ce', 59: 'Pr', 60: 'Nd', 
-        61: 'Pm', 62: 'Sm', 63: 'Eu', 64: 'Gd', 65: 'Tb', 66: 'Dy', 67: 'Ho', 68: 'Er', 69: 'Tm', 70: 'Yb', 
-        71: 'Lu', 72: 'Hf', 73: 'Ta', 74: 'W', 75: 'Re', 76: 'Os', 77: 'Ir', 78: 'Pt', 79: 'Au', 80: 'Hg', 
-        81: 'Tl', 82: 'Pb', 83: 'Bi', 84: 'Po', 85: 'At', 86: 'Rn', 87: 'Fr', 88: 'Ra', 89: 'Ac', 90: 'Th', 
-        91: 'Pa', 92: 'U', 93: 'Np', 94: 'Pu', 95: 'Am', 96: 'Cm', 97: 'Bk', 98: 'Cf', 99: 'Es', 100: 'Fm', 
-        101: 'Md', 102: 'No', 103: 'Lr', 104: 'Rf', 105: 'Db', 106: 'Sg', 107: 'Bh', 108: 'Hs', 109: 'Mt', 110: 'Ds', 
-        111: 'Rg', 112: 'Cn', 113: 'Nh', 114: 'Fl', 115: 'Mc', 116: 'Lv', 117: 'Ts', 118: 'Og'
-        },
-    long_symbol = {
-        1: 'Hydrogen', 2: 'Helium', 3: 'Lithium', 4: 'Beryllium', 5: 'Boron', 
-        6: 'Carbon', 7: 'Nitrogen', 8: 'Oxygen', 9: 'Fluorine', 10: 'Neon', 
-        11: 'Sodium', 12: 'Magnesium', 13: 'Aluminum', 14: 'Silicon', 15: 'Phosphorus', 
-        16: 'Sulfur', 17: 'Chlorine', 18: 'Argon', 19: 'Potassium', 20: 'Calcium', 
-        21: 'Scandium', 22: 'Titanium', 23: 'Vanadium', 24: 'Chromium', 25: 'Manganese', 
-        26: 'Iron', 27: 'Cobalt', 28: 'Nickel', 29: 'Copper', 30: 'Zinc', 
-        31: 'Gallium', 32: 'Germanium', 33: 'Arsenic', 34: 'Selenium', 35: 'Bromine', 
-        36: 'Krypton', 37: 'Rubidium', 38: 'Strontium', 39: 'Yttrium', 40: 'Zirconium', 
-        41: 'Niobium', 42: 'Molybdenum', 43: 'Technetium', 44: 'Ruthenium', 45: 'Rhodium', 
-        46: 'Palladium', 47: 'Silver', 48: 'Cadmium', 49: 'Indium', 50: 'Tin', 
-        51: 'Antimony', 52: 'Tellurium', 53: 'Iodine', 54: 'Xenon', 55: 'Cesium', 
-        56: 'Barium', 57: 'Lanthanum', 58: 'Cerium', 59: 'Praseodymium', 60: 'Neodymium', 
-        61: 'Promethium', 62: 'Samarium', 63: 'Europium', 64: 'Gadolinium', 65: 'Terbium', 
-        66: 'Dysprosium', 67: 'Holmium', 68: 'Erbium', 69: 'Thulium', 70: 'Ytterbium', 
-        71: 'Lutetium', 72: 'Hafnium', 73: 'Tantalum', 74: 'Tungsten', 75: 'Rhenium', 
-        76: 'Osmium', 77: 'Iridium', 78: 'Platinum', 79: 'Gold', 80: 'Mercury', 
-        81: 'Thallium', 82: 'Lead', 83: 'Bismuth', 84: 'Polonium', 85: 'Astatine', 
-        86: 'Radon', 87: 'Francium', 88: 'Radium', 89: 'Actinium', 90: 'Thorium', 
-        91: 'Protactinium', 92: 'Uranium', 93: 'Neptunium', 94: 'Plutonium', 95: 'Americium', 
-        96: 'Curium', 97: 'Berkelium', 98: 'Californium', 99: 'Einsteinium', 100: 'Fermium', 
-        101: 'Mendelevium', 102: 'Nobelium', 103: 'Lawrencium', 104: 'Rutherfordium', 105: 'Dubnium', 
-        106: 'Seaborgium', 107: 'Bohrium', 108: 'Hassium', 109: 'Meitnerium', 110: 'Darmstadtium', 
-        111: 'Roentgenium', 112: 'Copernicium', 113: 'Nihonium', 114: 'Flerovium', 115: 'Moscovium', 
-        116: 'Livermorium', 117: 'Tennessine', 118: 'Oganesson'
-        },
-    )
-
-
-# Initialize UFF bond radii (Rappe et al. JACS 1992)
-# Units of angstroms 
-# These radii neglect the bond-order and electronegativity corrections in the original paper. 
-# Where several values exist for the same atom, the largest was used. 
-radii = { 
-    1:0.354,  5:0.838,  6:0.757,  7:0.700,  8:0.658,  9:0.668,
-    14:1.117, 15:1.117, 16:1.064, 17:1.044,
-    32:1.197, 33:1.211, 34:1.190, 35:1.192,
-    51:1.407, 52:1.386, 53:1.382,
-    }
+# In mendeleev, the default length unit is pm.
+# picometer (e-12) to angstrom (e-10)
+pm2angstrom = 0.01

rdworks/utils.py

@@ -1,18 +1,16 @@
 import numpy as np
 import math
-import networkx as nx
-import gzip
 import operator
-import re
-import shlex
 
-from rdkit import Chem
 from pathlib import Path
-from typing import Any, Callable
-from functools import reduce
+from types import SimpleNamespace
+from typing import Any
+from collections.abc import Callable
 from concurrent.futures import ProcessPoolExecutor
 from tqdm import tqdm
 
+from rdkit import Chem
+
 from rdworks.autograph.centroid import centroid_medoid
 
 
@@ -96,13 +94,47 @@ def guess_mol_id(lprops:list[dict]) -> tuple[str, int, int]:
     return (property_key, count, total)
 
 
+def dict_to_simplenamespace(data):
+    if isinstance(data, dict):
+        return SimpleNamespace(**{k: dict_to_simplenamespace(v) for k, v in data.items()})
+    elif isinstance(data, list):
+        return [dict_to_simplenamespace(item) for item in data]
+    else:
+        return data
+    
+
+def recursive_round(data:Any, decimals:int=2) -> Any:
+    """Recursively round float values to a given decimal places.
 
-def fix_decimal_places_in_list(in_list:list, decimal_places:int=2) -> list:
+    Args:
+    data: The input data, which can be a list, dictionary, or any
+            other data type. It can contain nested lists and dictionaries.
+    decimals: number of decimal places.
+    """
+    if not isinstance(decimals, int) or decimals < 0:
+        raise ValueError("decimals must be a non-negative integer.")
+
+    def _recursive_round(current_item):
+        if isinstance(current_item, float):
+            return round(current_item, decimals)
+        elif isinstance(current_item, np.float64):
+            return round(float(current_item), decimals)
+        elif isinstance(current_item, list):
+            return [_recursive_round(item) for item in current_item]
+        elif isinstance(current_item, dict):
+            return {key: _recursive_round(value) for key, value in current_item.items()}
+        else:
+            return current_item
+
+    return _recursive_round(data)
+
+
+def fix_decimals_in_list(in_list:list, decimals:int=2) -> list:
     """Fixes the decimal places of all float values in a list.
 
     Args:
         list: The list to fix.
-        decimal_places (int): The number of decimal places to fix the float values to.
+        decimals (int): The number of decimal places to fix the float values to.
 
     Returns:
         list: a list with the float values fixed to the specified number of decimal places.
@@ -111,22 +143,22 @@ def fix_decimal_places_in_list(in_list:list, decimal_places:int=2) -> list:
     out_list = []
     for item in in_list:
         if isinstance(item, float):
-            out_list.append(round(item, decimal_places))
+            out_list.append(round(item, decimals))
         elif isinstance(item, dict):
-            out_list.append(fix_decimal_places_in_dict(item, decimal_places))
+            out_list.append(fix_decimals_in_dict(item, decimals))
         elif isinstance(item, list) or isinstance(item, tuple):
-            out_list.append(fix_decimal_places_in_list(item, decimal_places))
+            out_list.append(fix_decimals_in_list(item, decimals))
         else:
             out_list.append(item)
     return out_list
 
 
-def fix_decimal_places_in_dict(in_dict:dict, decimal_places:int=2) -> dict:
+def fix_decimals_in_dict(in_dict:dict, decimals:int=2) -> dict:
     """Fixes the decimal places of all float values in a dictionary.
 
     Args:
         dictionary: The dictionary to fix.
-        decimal_places (int): The number of decimal places to fix the float values to.
+        decimals (int): The number of decimal places to fix the float values to.
 
     Returns:
         dict: a dictionary with the float values fixed to the specified number of decimal places.
@@ -134,11 +166,11 @@ def fix_decimal_places_in_dict(in_dict:dict, decimal_places:int=2) -> dict:
     out_dict = {}
     for k, v in in_dict.items():
         if isinstance(v, float):
-            out_dict[k] = round(v, decimal_places)
+            out_dict[k] = round(v, decimals)
         elif isinstance(v, list) or isinstance(v, tuple):
-            out_dict[k] = fix_decimal_places_in_list(v, decimal_places)
+            out_dict[k] = fix_decimals_in_list(v, decimals)
         elif isinstance(v, dict):
-            out_dict[k] = fix_decimal_places_in_dict(v, decimal_places)
+            out_dict[k] = fix_decimals_in_dict(v, decimals)
         else:
             out_dict[k] = v
     return out_dict
@@ -252,244 +284,95 @@ def QT(rmsd_matrix:np.ndarray, threshold:float) -> tuple:
     return cluster_assignment, centroid_indices
 
 
-def rdmol_to_graph(rdmol:Chem.Mol) -> nx.Graph:
-    """Converts rdkit.Chem.Mol to a networkx graph object.
-
-    Args:
-        rdmol (Chem.Mol): input molecule.
-
-    Returns:
-        nx.Graph: networkx graph object.
-    """
-    G = nx.Graph()
-    for atom in rdmol.GetAtoms():
-        G.add_node(atom.GetIdx(), # 0-based index
-                   atomic_num=atom.GetAtomicNum(),
-                   formal_charge=atom.GetFormalCharge(),
-                   chiral_tag=atom.GetChiralTag(),
-                   hybridization=atom.GetHybridization(),
-                   num_explicit_hs=atom.GetNumExplicitHs(),
-                   is_aromatic=atom.GetIsAromatic())
-    for bond in rdmol.GetBonds():
-        G.add_edge(bond.GetBeginAtomIdx(),
-                   bond.GetEndAtomIdx(),
-                   bond_type=bond.GetBondType())
-    return G
-
-
-def rdmol_to_graph_(rdmol:Chem.Mol) -> nx.Graph:
-    """Converts rdkit.Chem.Mol to a networkx graph object (another implementation).
-
-    Args:
-        rdmol (Chem.Mol): input molecule.
-
-    Returns:
-        nx.Graph: networkx graph object.
-    """ 
-    atomic_nums = [atom.GetAtomicNum() for atom in rdmol.GetAtoms()]
-    formal_charges = [atom.GetFormalCharge() for atom in rdmol.GetAtoms()]
-    ad_matrix = Chem.GetAdjacencyMatrix(rdmol, useBO=True)
-    # useBO: (optional) toggles use of bond orders in calculating the matrix. Default value is 0.
-    # RETURNS: a Numeric array of floats containing the adjacency matrix
-    # [[0. 1. 0. 0. 0. 0. 0. 0. 0.]
-    # [1. 0. 1. 1. 1. 0. 0. 0. 0.]
-    # [0. 1. 0. 0. 0. 0. 0. 0. 0.]
-    # [0. 1. 0. 0. 0. 0. 0. 0. 0.]
-    # [0. 1. 0. 0. 0. 1. 0. 1. 0.]
-    # [0. 0. 0. 0. 1. 0. 2. 0. 0.]
-    # [0. 0. 0. 0. 0. 2. 0. 0. 0.]
-    # [0. 0. 0. 0. 1. 0. 0. 0. 2.]
-    # [0. 0. 0. 0. 0. 0. 0. 2. 0.]]
-    for i,(a_num,f_c) in enumerate(zip(atomic_nums, formal_charges)):
-        if f_c !=0:
-            ad_matrix[i,i] = a_num + f_c
-        else:
-            ad_matrix[i,i] = a_num
-    G = nx.from_numpy_array(ad_matrix)
-    return G
-
-
-def graph_to_rdmol(G:nx.Graph) -> Chem.Mol:
-    """Converts a networkx graph object to rdkit.Chem.Mol object.
-
-    Args:
-        G (nx.Graph): a networkx graph.
-
-    Returns:
-        Chem.Mol: rdkit.Chem.Mol object.
-    """
-    rdmol = Chem.RWMol()
-    atomic_nums = nx.get_node_attributes(G, 'atomic_num')
-    chiral_tags = nx.get_node_attributes(G, 'chiral_tag')
-    formal_charges = nx.get_node_attributes(G, 'formal_charge')
-    node_is_aromatics = nx.get_node_attributes(G, 'is_aromatic')
-    node_hybridizations = nx.get_node_attributes(G, 'hybridization')
-    num_explicit_hss = nx.get_node_attributes(G, 'num_explicit_hs')
-    node_to_idx = {}
-    for node in G.nodes():
-        a=Chem.Atom(atomic_nums[node])
-        a.SetChiralTag(chiral_tags[node])
-        a.SetFormalCharge(formal_charges[node])
-        a.SetIsAromatic(node_is_aromatics[node])
-        a.SetHybridization(node_hybridizations[node])
-        a.SetNumExplicitHs(num_explicit_hss[node])
-        idx = rdmol.AddAtom(a)
-        node_to_idx[node] = idx
-    bond_types = nx.get_edge_attributes(G, 'bond_type')
-    for edge in G.edges():
-        first, second = edge
-        ifirst = node_to_idx[first]
-        isecond = node_to_idx[second]
-        bond_type = bond_types[first, second]
-        rdmol.AddBond(ifirst, isecond, bond_type)
-    Chem.SanitizeMol(rdmol)
-    return rdmol
-
-
-def mae_rd_index(mol_dict:dict, smiles:str) -> dict:
-    """Returns a map for atom indexes between a rdkit.Chem.Mol and a maestro file.
-
-    It uses networkx's `vf2pp_all_isomorphisms()` function.
-
-    Args:
-        mol_dict (dict): a dictionary generated from a maestro file.
-        smiles (str): SMILES of the molecule.
-
-    Returns:
-        dict: a map for atom indexes (maestro -> rdkit.Chem.Mol)
-    """
-    bond_order_map = {
-        Chem.BondType.SINGLE : 1.0,
-        Chem.BondType.DOUBLE : 2.0,
-        Chem.BondType.TRIPLE : 3.0,
-        Chem.BondType.AROMATIC : 1.5,
-        Chem.BondType.UNSPECIFIED : 0.0,
-        }
-
-    G = nx.Graph()
-    for idx, atomic_num in enumerate(mol_dict['f_m_ct']['m_atom']['i_m_atomic_number'], start=1):
-        G.add_node(idx, atomic_num=int(atomic_num))
-    for (bond_from, bond_to, bond_order) in zip(mol_dict['f_m_ct']['m_bond']['i_m_from'],
-                                                mol_dict['f_m_ct']['m_bond']['i_m_to'],
-                                                mol_dict['f_m_ct']['m_bond']['i_m_order']):
-        G.add_edge(int(bond_from), int(bond_to), bond_order=int(bond_order))
-    
-    H = nx.Graph()
-    rdmol = Chem.MolFromSmiles(smiles)
-    rdmol = Chem.AddHs(rdmol)
-    for atom in rdmol.GetAtoms():
-        H.add_node(atom.GetIdx(), atomic_num=atom.GetAtomicNum())
-    for bond in rdmol.GetBonds():
-        H.add_edge(bond.GetBeginAtomIdx(),
-                   bond.GetEndAtomIdx(),
-                   bond_order=bond_order_map[bond.GetBondType()])
-
-    try:
-        assert nx.is_isomorphic(G, H)
-        return nx.vf2pp_isomorphism(G, H, node_label="atomic_num")
-    except:
-        return {}
-    
-
-def _get_from_dict(dataDict:dict, mapList:list) -> None:
-    """A subroutine for `mae_to_dict()`.
-
-    Args:
-        dataDict (dict): data dictionary.
-        mapList (list): map list.
-    """
-    return reduce(operator.getitem, mapList, dataDict)
-
-
-def _set_in_dict(dataDict:dict, mapList:list, value:Any) -> None:
-    """A subroutine for `mae_to_dict()`.
-
-    Args:
-        dataDict (dict): data dictionary.
-        mapList (list): map list.
-        value (Any): value to set.
-    """
-    if mapList:
-        _get_from_dict(dataDict, mapList[:-1])[mapList[-1]] = value
-    else:
-        for k,v in value.items():
-            dataDict[k] = v
-
-
-
-def mae_to_dict(path:str | Path) -> dict:
-    """Converts Schrodinger Maestro file to a dictionary.
-
-    Args:
-        path (Union[str, Path]): filename or path to a .mae or .maegz file.
-
-    Returns:
-        dict: python dictionary.
-    """
-    tokens = None
-    if isinstance(path, str):
-        path = Path(path)
-    if path.suffix == 'gz':
-        with gzip.open(path, "rt") as f:
-            tokens = shlex.split(f.read())
-    else:
-        with open(path, "r") as f:
-            tokens = shlex.split(f.read())
-    count = re.compile(r'(\w+)\[(\d+)\]')
-    DATA = []
-    level = []
-    data = {}
-    previous_token = None
-    header = False
-    extra_column = 0
-    num_repeat = 1
-    skip = False
-    for token in tokens :
-        if token == "#" :
-            skip = not skip # invert
-            continue
-        elif skip:
-            continue
-        elif token == "{" :
-            header = True
-            key = []
-            val = []
-            arr = []
-            if previous_token:
-                if previous_token == "f_m_ct" and data:
-                    DATA.append(data)
-                    data = {}
-                try:
-                    (block, num_repeat) = count.findall(previous_token)[0]
-                    num_repeat = int(num_repeat)
-                    extra_column = 1
-                except:
-                    block = previous_token
-                    num_repeat = 1
-                    extra_column = 0
-                level.append(block)
-
-        elif token == "}":
-            if level: 
-                level.pop()
-        elif token == ":::":
-            header = False
-        elif header:
-            key.append(token)
-        else:
-            val.append(token)
-            # only store f_m_ct blocks (level != [])
-            if len(val) == (len(key)+extra_column) and level :
-                arr.append(val[extra_column:])
-                val = []
-                if len(arr) == num_repeat:
-                    if len(arr) == 1:
-                        _set_in_dict(data, level, dict(zip(key,arr[0])))
-                    else:
-                        T = list(zip(*arr)) # transpose
-                        _set_in_dict(data, level, dict(zip(key,T)))
-        previous_token = token
-    if data:
-        DATA.append(data)
-    
-    return DATA
+# def rdmol_to_graph(rdmol:Chem.Mol) -> nx.Graph:
+#     """Converts rdkit.Chem.Mol to a networkx graph object.
+
+#     Args:
+#         rdmol (Chem.Mol): input molecule.
+
+#     Returns:
+#         nx.Graph: networkx graph object.
+#     """
+#     G = nx.Graph()
+#     for atom in rdmol.GetAtoms():
+#         G.add_node(atom.GetIdx(), # 0-based index
+#                    atomic_num=atom.GetAtomicNum(),
+#                    formal_charge=atom.GetFormalCharge(),
+#                    chiral_tag=atom.GetChiralTag(),
+#                    hybridization=atom.GetHybridization(),
+#                    num_explicit_hs=atom.GetNumExplicitHs(),
+#                    is_aromatic=atom.GetIsAromatic())
+#     for bond in rdmol.GetBonds():
+#         G.add_edge(bond.GetBeginAtomIdx(),
+#                    bond.GetEndAtomIdx(),
+#                    bond_type=bond.GetBondType())
+#     return G
+
+
+# def rdmol_to_graph_(rdmol:Chem.Mol) -> nx.Graph:
+#     """Converts rdkit.Chem.Mol to a networkx graph object (another implementation).
+
+#     Args:
+#         rdmol (Chem.Mol): input molecule.
+
+#     Returns:
+#         nx.Graph: networkx graph object.
+#     """ 
+#     atomic_nums = [atom.GetAtomicNum() for atom in rdmol.GetAtoms()]
+#     formal_charges = [atom.GetFormalCharge() for atom in rdmol.GetAtoms()]
+#     ad_matrix = Chem.GetAdjacencyMatrix(rdmol, useBO=True)
+#     # useBO: (optional) toggles use of bond orders in calculating the matrix. Default value is 0.
+#     # RETURNS: a Numeric array of floats containing the adjacency matrix
+#     # [[0. 1. 0. 0. 0. 0. 0. 0. 0.]
+#     # [1. 0. 1. 1. 1. 0. 0. 0. 0.]
+#     # [0. 1. 0. 0. 0. 0. 0. 0. 0.]
+#     # [0. 1. 0. 0. 0. 0. 0. 0. 0.]
+#     # [0. 1. 0. 0. 0. 1. 0. 1. 0.]
+#     # [0. 0. 0. 0. 1. 0. 2. 0. 0.]
+#     # [0. 0. 0. 0. 0. 2. 0. 0. 0.]
+#     # [0. 0. 0. 0. 1. 0. 0. 0. 2.]
+#     # [0. 0. 0. 0. 0. 0. 0. 2. 0.]]
+#     for i,(a_num,f_c) in enumerate(zip(atomic_nums, formal_charges)):
+#         if f_c !=0:
+#             ad_matrix[i,i] = a_num + f_c
+#         else:
+#             ad_matrix[i,i] = a_num
+#     G = nx.from_numpy_array(ad_matrix)
+#     return G
+
+
+# def graph_to_rdmol(G:nx.Graph) -> Chem.Mol:
+#     """Converts a networkx graph object to rdkit.Chem.Mol object.
+
+#     Args:
+#         G (nx.Graph): a networkx graph.
+
+#     Returns:
+#         Chem.Mol: rdkit.Chem.Mol object.
+#     """
+#     rdmol = Chem.RWMol()
+#     atomic_nums = nx.get_node_attributes(G, 'atomic_num')
+#     chiral_tags = nx.get_node_attributes(G, 'chiral_tag')
+#     formal_charges = nx.get_node_attributes(G, 'formal_charge')
+#     node_is_aromatics = nx.get_node_attributes(G, 'is_aromatic')
+#     node_hybridizations = nx.get_node_attributes(G, 'hybridization')
+#     num_explicit_hss = nx.get_node_attributes(G, 'num_explicit_hs')
+#     node_to_idx = {}
+#     for node in G.nodes():
+#         a=Chem.Atom(atomic_nums[node])
+#         a.SetChiralTag(chiral_tags[node])
+#         a.SetFormalCharge(formal_charges[node])
+#         a.SetIsAromatic(node_is_aromatics[node])
+#         a.SetHybridization(node_hybridizations[node])
+#         a.SetNumExplicitHs(num_explicit_hss[node])
+#         idx = rdmol.AddAtom(a)
+#         node_to_idx[node] = idx
+#     bond_types = nx.get_edge_attributes(G, 'bond_type')
+#     for edge in G.edges():
+#         first, second = edge
+#         ifirst = node_to_idx[first]
+#         isecond = node_to_idx[second]
+#         bond_type = bond_types[first, second]
+#         rdmol.AddBond(ifirst, isecond, bond_type)
+#     Chem.SanitizeMol(rdmol)
+#     return rdmol