rdworks 0.25.7__py3-none-any.whl → 0.35.1__py3-none-any.whl

rdworks/mollibr.py

@@ -4,38 +4,37 @@ import pandas as pd
 import gzip
 
 from pathlib import Path
-from typing import Optional, Union, Self, Iterator
+from collections.abc import Iterable
 from collections import defaultdict
+from typing import Self, Iterator
 from concurrent.futures import ProcessPoolExecutor
 from tqdm import tqdm
 
-from rdkit import Chem, DataStructs
-from rdkit.Chem import Draw
+from rdkit import Chem, DataStructs, Geometry
+from rdkit.Chem import Draw, AllChem, rdFMCS, rdDepictor
 from rdkit.ML.Cluster import Butina
 from rdkit.SimDivFilters.rdSimDivPickers import MaxMinPicker
+from PIL import Image
 
-from rdworks.conf import Conf
-from rdworks.mol import Mol
-
+from rdworks import Conf, Mol
+from rdworks.display import render_matrix_grid
 from rdworks.xml import list_predefined_xml
-from rdworks.utils import precheck_path, guess_mol_id
 
 
 class MolLibr:
     def __init__(self, 
-                 molecules: list | tuple | set | None = None,
-                 names: list | tuple | set | None = None,
+                 molecules: Iterable | None = None,
+                 names: Iterable | None = None,
                  std:bool=False,
                  max_workers:int=4,
-                 chunksize:int=100,
+                 chunksize:int=10,
                  progress:bool=False) -> None:
         """Create a rdworks.MolLibr object.
 
         Args:
-            molecules (Optional[Union[list,tuple,set]], optional): a list/tuple/set of molecules 
+            molecules (Iterable | None, optional): a list/tuple/set of molecules 
                 (rdworks.Mol | SMILES | rdkit.Chem.Mol). Defaults to None.
-            names (Optional[Union[list,tuple,set]], optional): a list/tuple/set of names. 
-                Defaults to None.
+            names (Iterable | None, optional): a list/tuple/set of names. Defaults to None.
             std (bool, optional): whether to standardize molecules. Defaults to False.
             max_workers (int, optional): max workers for parallel calculation. Defaults to 4.
             chunksize (int, optional): chunksize for parallel calculation. Defaults to 100.
@@ -53,29 +52,34 @@ class MolLibr:
         self.threshold = None
         self.clusters = None
 
-        if molecules and isinstance(molecules, (list, tuple, set)):
-            if names and isinstance(names, (list, tuple, set)):
-                if len(names) != len(molecules):
-                    raise ValueError('MolLibr() counts of molecules and names are different')
-            if isinstance(molecules[0], Mol):
-                self.libr = molecules
-            elif isinstance(molecules[0], Conf):
-                self.libr = [Mol(conf.rdmol, name=conf.name).props.update(conf.props) for conf in molecules]
-            elif isinstance(molecules[0], str): # SMILES string
-                if names:
-                    self.libr = [Mol(smi, name=name, std=std) for (smi, name) in zip(molecules, names)]                        
-                else:
-                    self.libr = [Mol(smi, std=std) for smi in molecules]                        
-                    self.rename(prefix='entry') # default name
-            elif isinstance(molecules[0], Chem.Mol):
-                if names:
-                    self.libr = [Mol(rdmol, name=name, std=std) for (rdmol, name) in zip(molecules, names)]
-                else:
-                    self.libr = [Mol(rdmol, std=std) for rdmol in molecules]
-                    self.rename(prefix='entry') # default name
-            else:
-                raise TypeError('MolLibr() takes a list|tuple|set of Mol|SMILES|Chem.Mol')
+        assert isinstance(molecules, Iterable) or molecules is None, "molecules must be iterable or None"
+        assert isinstance(names, Iterable) or names is None, "names must be iterable or None"
+        
+        if isinstance(molecules, Iterable):
+            if isinstance(names, Iterable):
+                assert len(molecules) == len(names), "molecules and names must be the same counts"
+            
+            if names is None:
+                names = [''] * len(molecules)
+            
+            for molecular_input, name in zip(molecules, names):
+                if isinstance(molecular_input, Mol):
+                    _mol = molecular_input
+                
+                elif isinstance(molecular_input, Chem.Mol) or isinstance(molecular_input, str):
+                    _mol = Mol(molecular_input, name=name, std=std)
+                
+                elif isinstance(molecular_input, Conf):
+                    _mol = Mol(molecular_input.rdmol,
+                                name=molecular_input.name, 
+                                std=std).props.update(molecular_input.props)
+
+                self.libr.append(_mol)
+            
+            if not any(names):
+                self.rename(prefix='entry')
     
+
     def copy(self) -> Self:
         """Returns a copy of self.
 
@@ -108,178 +112,192 @@ class MolLibr:
         """Next molecule.
 
         Returns:
-            Mol: next molecule (rdworks.Mol) object.
+            Mol: next molecule.
         """
         return next(self.libr)
     
 
-    def __eq__(self, other:Self) -> bool:
+    def __eq__(self, other: Self) -> bool:
         """Operator `==`.
 
         Args:
             other (rdworks.MolLibr): other rdworks.MolLibr object.
 
         Returns:
-            bool: True if other rdworks.MolLibr object is identical with self.
+            Bool: True if other MolLibr object is identical with self.
         """
         if isinstance(other, MolLibr):
             return len(frozenset(self.libr) - frozenset(other.libr)) == 0
-        else:
-            return False
+        
+        return False
         
 
-    def __getitem__(self, index: int | slice) -> Mol:
+    def __getitem__(self, index: int | slice) -> Mol | Self:
         """Operator `[]`.
 
         Args:
             index (Union[int, slice]): index or slice of indexes.
 
-        Raises:
-            ValueError: if library is empty or index is out of range.
-
         Returns:
-            Mol: rdworks.Mol object
+            Mol or MolLibr specified by single index or slice.
         """
-        if self.count() == 0:
-            raise ValueError(f"library is empty")
-        try:
+        assert self.count() != 0, "library is empty"
+        if isinstance(index, slice):
+            return MolLibr(self.libr[index])
+        else:
             return self.libr[index]
-        except:
-            raise ValueError(f"index should be 0..{self.count()-1}")
         
 
-    def __add__(self, other:object) -> Self:
-        """Operator `+`. Returns a copy of extended library.
+    def __setitem__(self, index: int, molecule: Mol) -> Self:
+        """Set item.
 
         Args:
-            other (object): other rdworks.Mol or rdworks.MolLibr object.
+            index (int): index
+            molecule (Mol): molecule to replace
+        
+        Returns:
+            Modified self.
+        """
+        self.libr[index] = molecule
 
-        Raises:
-            TypeError: if `other` is not rdworks.Mol or rdworks.MolLibr.
+        return self
+
+
+    def __add__(self, other: Mol | Self) -> Self:
+        """Operator `+`.
+
+        Returns a new object, leaving the original objects unchanged (conventional behavior).
+
+        Args:
+            other (object): other Mol or MolLibr object.
 
         Returns:
-            Self: rdworks.MolLibr object.
+            A new MolLibr object.
         """
+        assert isinstance(other, Mol | MolLibr), "'+' operator expects Mol or MolLibr object"
+        
+        new_object = self.copy()
+
         if isinstance(other, Mol):
-            obj = copy.deepcopy(self)
-            obj.libr.append(other)
-            return obj
+            new_object.libr.append(other)
+        
         elif isinstance(other, MolLibr):
-            obj = copy.deepcopy(self)
-            obj.libr.extend(other.libr)
-            return obj
-        else:
-            raise TypeError("'+' operator expects rdworks.Mol or rdworks.MolLibr object")
+            new_object.libr.extend(other.libr)
+
+        return new_object
 
 
     def __iadd__(self, other: Mol | Self) -> Self:
-        """Operator `+=`. Updates self by adding other molecule or library
+        """Operator `+=`.
 
         Args:
-            other (object): other rdworks.Mol or rdworks.MolLibr object.
-
-        Raises:
-            TypeError: if `other` is not rdworks.Mol or rdworks.MolLibr.
+            other (object): other Mol or MolLibr object.
 
         Returns:
-            Self: rdworks.MolLibr object. 
+            modified self.
         """
+        assert isinstance(other, Mol | MolLibr), "'+=' operator expects Mol or MolLibr object"
+
         if isinstance(other, Mol):
             self.libr.append(other)
+        
         elif isinstance(other, MolLibr):
             self.libr.extend(other.libr)
-        else:
-            raise TypeError("'+=' operator expects Mol or MolLibr object")
+
         return self
 
 
     def __sub__(self, other: Mol | Self) -> Self:
-        """Operator `-`. Returns a copy of subtractive subset.
+        """Operator `-`.
 
-        Args:
-            other (Union[Mol,Self]): other rdworks.Mol or rdworks.MolLibr object.
+        Returns a new object, leaving the original objects unchanged (conventional behavior).
 
-        Raises:
-            TypeError: if `other` is not rdworks.Mol or rdworks.MolLibr.
+        Args:
+            other (Mol | MolLibr): other rdworks.Mol or rdworks.MolLibr object.
 
         Returns:
-            Self: a copy of subtractive subset.
+            A new MolLibr object.
         """
+        assert isinstance(other, Mol | MolLibr), "'-' operator expects Mol or MolLibr object"
+
         if isinstance(other, Mol):
             difference = frozenset(self.libr) - frozenset([other])
+        
         elif isinstance(other, MolLibr):
             difference = frozenset(self.libr) - frozenset(other.libr)
-        else:
-            raise TypeError("'-' operator expects rdworks.Mol or rdworks.MolLibr object")
-        obj = copy.deepcopy(self)
-        obj.libr = list(difference)
-        return obj
+
+        new_object = self.copy()
+        new_object.libr = list(difference)
+
+        return new_object
     
 
     def __isub__(self, other: Mol | Self) -> Self:
-        """Operator `-=`. Updates self by subtracting other molecule or library.
+        """Operator `-=`.
 
         Args:
-            other (Union[Mol,Self]): other molecule or library.
-
-        Raises:
-            TypeError: if `other` is not rdworks.Mol or rdworks.MolLibr.
+            other (Mol | MolLibr): other molecule or library.
 
         Returns:
-            Self: rdworks.MolLibr object.
+            Modified self.
         """
+        assert isinstance(other, Mol | MolLibr), "'-=' operator expects Mol or MolLibr object"
+
         if isinstance(other, Mol):
             difference = frozenset(self.libr) - frozenset([other])
+        
         elif isinstance(other, MolLibr):
             difference = frozenset(self.libr) - frozenset(other.libr)
-        else:
-            raise TypeError("'-=' operator expects rdworks.Mol or rdworks.MolLibr object")
+
         self.libr = list(difference)
+        
         return self
 
 
     def __and__(self, other: Mol | Self) -> Self:
-        """Operator `&`. Returns a copy of common subset.
+        """Operator `&`.
 
-        Args:
-            other (Union[Mol,Self]): other molecule or library.
+        Returns a new object, leaving the original objects unchanged (conventional behavior).
 
-        Raises:
-            TypeError: if `other` is not rdworks.Mol or rdworks.MolLibr.
+        Args:
+            other (Mol | MolLibr): other molecule or library.
 
         Returns:
-            Self: a copy of rdworks.MolLibr object.
+            A new MolLibr object.
         """
+        assert isinstance(other, Mol | MolLibr), "'&' operator expects Mol or MolLibr object"
+
         if isinstance(other, Mol):
             intersection = frozenset(self.libr) & frozenset([other])
+
         elif isinstance(other, MolLibr):
             intersection = frozenset(self.libr) & frozenset(other.libr)
-        else:
-            raise TypeError("'&' operator or overlap() expects rdworks.Mol or rdworks.MolLibr object")
-        obj = copy.deepcopy(self)
-        obj.libr = list(intersection)
-        return obj
+        
+        new_object = self.copy()
+        new_object.libr = list(intersection)
+        
+        return new_object
 
 
     def __iand__(self, other: Mol | Self) -> Self:
-        """Operator `&=`. Re-assigns self with common subset.
+        """Operator `&=`.
 
         Args:
-            other (Union[Mol,Self]): other molecule or library.
-
-        Raises:
-            TypeError: if `other` is not rdworks.Mol or rdworks.MolLibr.
+            other (Mol | Self): other molecule or library.
 
         Returns:
-            Self: rdworks.MolLibr object.
+            Modified self.
         """
+        assert isinstance(other, Mol | MolLibr), "'&=' operator expects Mol or MolLibr object"
+
         if isinstance(other, Mol):
             intersection = frozenset(self.libr) & frozenset([other])
+        
         elif isinstance(other, MolLibr):
             intersection = frozenset(self.libr) & frozenset(other.libr)
-        else:
-            raise TypeError("'&=' operator expects rdworks.Mol or rdworks.MolLibr object")
+
         self.libr = list(intersection)
+        
         return self
     
 
@@ -334,9 +352,9 @@ class MolLibr:
         """Change settings for parallel computing.
 
         Args:
-            max_workers (Optional[int], optional): max number of workers. Defaults to None.
-            chunksize (Optional[int], optional): chunksize of splitted workload. Defaults to None.
-            progress (Optional[bool], optional): whether to show progress bar. Defaults to None.
+            max_workers (int, optional): max number of workers. Defaults to 4.
+            chunksize (int, optional): chunksize of splitted workload. Defaults to 10.
+            progress (bool, optional): whether to show progress bar. Defaults to False.
 
         Returns:
             Self: rdworks.MolLibr object.
@@ -344,10 +362,11 @@ class MolLibr:
         self.max_workers = kwargs.get('max_workers', self.max_workers)
         self.chunksize = kwargs.get('chunksize', self.chunksize)
         self.progress = kwargs.get('progress', self.progress)
+        
         return self
 
 
-    def rename(self, prefix:Optional[str]=None, sep:str='.', start:int=1) -> Self:
+    def rename(self, prefix: str | None = None, sep: str='.', start: int=1) -> Self:
         """Rename molecules with serial numbers in-place and their conformers.
         
         Molecules will be named by a format, `{prefix}{sep}{serial_number}` and 
@@ -393,10 +412,11 @@ class MolLibr:
             # rename conformers
             for mol in self.libr:
                 mol.rename()
+        
         return self
     
 
-    def overlap(self, other:Self) -> Self:
+    def overlap(self, other: Self) -> Self:
         """Returns a common subset with `other` library.
 
         Args:
@@ -408,7 +428,7 @@ class MolLibr:
         return self.__and__(other)
     
 
-    def similar(self, query:Mol, threshold:float=0.2, **kwargs) -> Self:
+    def similar(self, query: Mol, threshold: float = 0.2, **kwargs) -> Self:
         """Returns a copy of subset that are similar to `query`.
 
         Args:
@@ -421,7 +441,8 @@ class MolLibr:
         Returns:
             Self: a copy of self.
         """
-        obj = copy.deepcopy(self).compute(**kwargs)
+        obj = self.copy().compute(**kwargs)
+        
         if isinstance(query, Mol):
             largs = [(query, threshold),] * obj.count()
         else:
@@ -434,6 +455,7 @@ class MolLibr:
             else:
                 mask = list(executor.map(MolLibr._mask_similar, obj.libr, largs, chunksize=obj.chunksize))
             obj.libr = list(itertools.compress(obj.libr, mask))
+        
         return obj
 
 
@@ -447,7 +469,8 @@ class MolLibr:
         Returns:
             Self: a copy of self.
         """
-        obj = copy.deepcopy(self)
+        obj = self.copy()
+        
         U = {} # unique SMILES
         mask = []
         for mol in obj.libr:
@@ -466,6 +489,7 @@ class MolLibr:
                 if len(mol.props['aka']) > 0:
                     print(f"  {mol.name}({len(mol.props['aka'])}) - {','.join(mol.props['aka'])}")
             print(f"de-duplicated to {obj.count()} molecules")
+        
         return obj
     
 
@@ -491,10 +515,11 @@ class MolLibr:
                 self.libr = list(
                     executor.map(MolLibr._map_qed, self.libr, lprops, chunksize=self.chunksize)
                     )
+        
         return self
     
 
-    def drop(self, terms:str | Path | None = None, invert:bool=False, **kwargs) -> Self:
+    def drop(self, terms: str | Path | None = None, invert: bool = False, **kwargs) -> Self:
         """Drops matched molecules and returns a copy of library with remaining molecules.
 
         Args:
@@ -507,7 +532,9 @@ class MolLibr:
         if not terms:
             print(list_predefined_xml())
             return self
-        obj = copy.deepcopy(self).compute(**kwargs)
+        
+        obj = self.copy().compute(**kwargs)
+        
         lterms = [ terms ] * obj.count()
         with ProcessPoolExecutor(max_workers=obj.max_workers) as executor:
             if obj.progress:
@@ -521,10 +548,101 @@ class MolLibr:
             if invert:
                 mask = [not b for b in mask]
             obj.libr = list(itertools.compress(obj.libr, mask))
+        
         return obj
     
 
-    def pick(self, n:int, **kwargs) -> Self:
+    @staticmethod
+    def _mcs_coord_map(subject:Mol, r:Chem.Mol) -> dict:
+        s = subject.rdmol
+        lcs = rdFMCS.FindMCS([r, s])
+        # reference matching indices
+        r_indices = r.GetSubstructMatch(lcs.queryMol)
+        # subject matching indices
+        s_indices = s.GetSubstructMatch(lcs.queryMol)
+        # reference matching coordinates (2D)
+        r_xy = []
+        for i in r_indices:
+            pt = r.GetConformer().GetAtomPosition(i)
+            r_xy.append(Geometry.Point2D(pt.x, pt.y))
+        coord_map = { i : xy for i, xy in zip(s_indices, r_xy) }
+        
+        return coord_map
+
+
+    def align_drawing(self, 
+                      ref: int = 0, 
+                      mcs: bool = True, 
+                      scaffold: str = "", 
+                      coordgen:bool = True, 
+                      **kwargs,
+                      ) -> Self:
+        """Align 2D drawings by using MCS or scaffold SMILES.
+
+        Args:
+            ref (int, optional): index to the reference. Defaults to 0.
+            mcs (bool, optional): whether to use MCS(maximum common substructure). Defaults to True.
+            scaffold (str, optional): whether to use scaffold (SMILES). Defaults to "".
+
+        Returns:
+            Self: self
+        """
+
+        obj = self.copy().compute(**kwargs)
+        
+        if scaffold:
+            # scaffold (SMILES) of the reference 2D drawing
+            ref_2d_rdmol = Chem.MolFromSmiles(scaffold)
+        else:
+            # maximum common substructure to the reference 2D drawing
+            assert ref >=0 and ref < obj.count(), f"ref should be [0,{obj.count()-1}]"
+            ref_2d_rdmol = obj.libr[ref].rdmol
+
+        rdDepictor.SetPreferCoordGen(coordgen)
+        rdDepictor.Compute2DCoords(ref_2d_rdmol)
+        # AllChem.Compute2DCoords(ref_2d_rdmol)
+        
+        with ProcessPoolExecutor(max_workers=obj.max_workers) as executor:
+            if obj.progress:
+                coord_maps = list(tqdm(
+                    executor.map(MolLibr._mcs_coord_map, 
+                        obj.libr, # subject
+                        itertools.repeat(ref_2d_rdmol), # infinite iterator
+                        chunksize=obj.chunksize),
+                    desc="align drawingp",
+                    total=obj.count()))
+            else:
+                coord_maps = list(
+                    executor.map(MolLibr._mcs_coord_map,
+                        obj.libr, # subject
+                        itertools.repeat(ref_2d_rdmol), # infinite iterator
+                        chunksize=obj.chunksize))
+        
+        for mol, coord_map in zip(obj.libr, coord_maps):
+            rdDepictor.Compute2DCoords(mol.rdmol, coordMap=coord_map)
+            # AllChem.Compute2DCoords(mol.rdmol, coordMap=coord_map)
+
+
+        # for idx, mol in enumerate(obj.libr):
+        #     if mcs and idx == ref:
+        #         continue
+
+        #     # largest common substructure
+        #     lcs = rdFMCS.FindMCS([ref_2d_rdmol, mol.rdmol])
+
+        #     # matching indices
+        #     ref_xy_coords = []
+        #     for i in ref_2d_rdmol.GetSubstructMatch(lcs.queryMol):
+        #         pt = ref_2d_rdmol.GetConformer().GetAtomPosition(i)
+        #         ref_xy_coords.append(Geometry.Point2D(pt.x, pt.y))
+        #     sub_indices = mol.rdmol.GetSubstructMatch(lcs.queryMol)
+        #     coord_map = { i : xy for i, xy in zip(sub_indices, ref_xy_coords) }
+        #     AllChem.Compute2DCoords(mol.rdmol, coordMap=coord_map)
+
+        return obj
+
+
+    def pick(self, n: int, **kwargs) -> Self:
         """Picks n diverse molecules.
 
         Args:
@@ -533,7 +651,7 @@ class MolLibr:
         Returns:
             Self: a copy of self.
         """
-        obj = copy.deepcopy(self)
+        obj = self.copy()
         raise NotImplementedError
         return obj
     
@@ -554,7 +672,11 @@ class MolLibr:
         return len(self.libr)
     
 
-    def cluster(self, threshold:float=0.3, ordered:bool=True, drop_singleton:bool=True) -> list:
+    def cluster(self, 
+                threshold: float = 0.3, 
+                ordered: bool = True, 
+                drop_singleton: bool = True,
+                ) -> list:
         """Clusters molecules using fingerprint.
 
         Args:
@@ -594,10 +716,11 @@ class MolLibr:
 
     
     def to_sdf(self, 
-                path:str | Path, 
-                confs:bool=False, 
-                props:bool=True, 
-                separate:bool=False) -> None:
+                path: str | Path, 
+                confs: bool = False, 
+                props: bool = True, 
+                separate: bool = False,
+                ) -> None:
         """Writes to .sdf or .sdf.gz file.
 
         Chem.SDWriter is supposed to write all non-private molecular properties.
@@ -640,7 +763,7 @@ class MolLibr:
                         f.write(mol.to_sdf(confs, props))
 
 
-    def to_smi(self, path:str | Path) -> None:
+    def to_smi(self, path: str | Path) -> None:
         """Writes to .smi file.
 
         Args:
@@ -658,55 +781,82 @@ class MolLibr:
                     smi.write(f'{mol.smiles} {mol.name}\n')
 
 
-    def to_image(self, width:int=200, height:int=200, index:bool=False, mols_per_row:int=5) -> str:
-        """Returns SVG strings for Jupyter notebook.
+    def to_svg(self, 
+               mols_per_row: int = 5,
+               width: int = 200, 
+               height: int = 200,
+               atom_index: bool = False,
+               redraw: bool = False,
+               coordgen: bool = False) -> str:
+        """Writes to a .svg strings for Jupyter notebook.
 
         Args:
+            path (str | Path): output filename or path.
+            mols_per_row (int, optional): number of molecules per row. Defaults to 5.
             width (int, optional): width. Defaults to 200.
             height (int, optional): height. Defaults to 200.
-            index (bool, optional): whether to show atom index. Defaults to False.
-            mols_per_row (int, optional): number of molecules per row. Defaults to 5.
-
-        Returns:
-            str: SVG strings for Jupyter notebook.
+            atom_index (bool, optional): whether to show atom index. Defaults to False.
+            redraw (bool, optional): whether to redraw. Defaults to False.
+            coordgen (bool, optional): whether to use coordgen. Defaults to False.
         """
         
-        if index:
-            for mol in self.libr: 
-                for a in mol.rdmol.GetAtoms():
-                    a.SetProp("atomNote", str(a.GetIdx()+1))
-        rdmols = [mol.rdmol for mol in self.libr]
+        rdmols  = [mol.rdmol for mol in self.libr]
         legends = [mol.name for mol in self.libr]
-        return Draw.MolsToGridImage(rdmols,
-                                    legends=legends,
-                                    molsPerRow=min(mols_per_row, len(rdmols)),
-                                    subImgSize=(width,height),
-                                    useSVG=True)
+
+        svg_string = render_matrix_grid(rdmols, 
+                                        legends,
+                                        mols_per_row = mols_per_row, 
+                                        width = width, 
+                                        height = height,
+                                        atom_index = atom_index,
+                                        redraw = redraw,
+                                        coordgen = coordgen,
+                                        svg = True,
+                                        )
         
+        return svg_string
+
 
-    def to_png(self, path:str | Path, width:int=200, height:int=200, index:bool=False, mols_per_row:int=5) -> None:
+
+    def to_png(self,
+               filename: str | Path | None = None,
+               mols_per_row: int = 5,
+               width: int = 200, 
+               height: int = 200,
+               atom_index: bool = False,
+               redraw: bool = False,
+               coordgen: bool = False,
+               ) -> Image.Image | None:
         """Writes to a .png file.
 
         Args:
-            path (str | Path): output filename or path.
+            mols_per_row (int, optional): number of molecules per row. Defaults to 5.
             width (int, optional): width. Defaults to 200.
             height (int, optional): height. Defaults to 200.
-            index (bool, optional): whether to show atom index. Defaults to False.
-            mols_per_row (int, optional): number of molecules per row. Defaults to 5.
+            atom_index (bool, optional): whether to show atom index. Defaults to False.
+            redraw (bool, optional): whether to redraw. Defaults to False.
+            coordgen (bool, optional): whether to use coordgen. Defaults to False.
         """
-        if isinstance(path, Path):
-            path = path.as_posix() # convert to string
-        if index:
-            for mol in self.libr: 
-                for a in mol.rdmol.GetAtoms():
-                    a.SetProp("atomNote", str(a.GetIdx()+1))
-        rdmols = [mol.rdmol for mol in self.libr]
+        rdmols  = [mol.rdmol for mol in self.libr]
         legends = [mol.name for mol in self.libr]
-        Draw.MolsToGridImage(rdmols,
-                                legends=legends,
-                                molsPerRow=min(mols_per_row,len(rdmols)),
-                                subImgSize=(width,height),
-                                useSVG=False).save(path)
+
+        img = render_matrix_grid(rdmols, 
+                                legends,
+                                mols_per_row = mols_per_row, 
+                                width = width, 
+                                height = height,
+                                atom_index = atom_index,
+                                redraw = redraw,
+                                coordgen = coordgen,
+                                svg = False,
+                                )
+        
+        if filename is None:
+            return img
+        else:
+            if isinstance(filename, Path):
+                filename = filename.as_posix()
+            img.save(filename)
 
 
     def to_html(self) -> str:
@@ -723,9 +873,10 @@ class MolLibr:
 
 
     def to_dataframe(self, 
-                        name:str='name', 
-                        smiles:str='smiles', 
-                        confs:bool=False) -> pd.DataFrame:
+                     name: str = 'name', 
+                     smiles: str = 'smiles', 
+                     confs: bool = False,
+                     ) -> pd.DataFrame:
         """Returns a Pandas DataFrame.
 
         Args:
@@ -772,44 +923,46 @@ class MolLibr:
                         data[k].append(mol.props[k])
                     else:
                         data[k].append(None)
+        
         return pd.DataFrame(data)
 
 
     def to_csv(self, 
-                path:str | Path, 
-                confs:bool=False, 
-                decimal_places:int=3) -> None:
+               path: str | Path, 
+               confs: bool = False, 
+               decimals:int = 3,
+               ) -> None:
         """Writes to a .csv file.
 
         Args:
             path (str | Path): output filename or path.
             confs (bool, optional): whether to include conformer properties. Defaults to False.
-            decimal_places (int, optional): decimal places for float numbers. Defaults to 3.
+            decimals (int, optional): decimal places for float numbers. Defaults to 3.
         """
         df = self.to_dataframe(confs=confs)
-        df.to_csv(path, index=False, float_format=f'%.{decimal_places}f')
+        df.to_csv(path, index=False, float_format=f'%.{decimals}f')
 
 
     @staticmethod
-    def _mask_nn_applicable(mol:Mol, model:str) -> bool:
-        """A mask function to return True if molecule is NN applicable. 
+    def _mask_nnp_ready(mol: Mol, model: str) -> bool:
+        """A mask function to return True if molecule is NNP ready. 
 
         Args:
             mol (Mol): rdworks.Mol object.
-            model (str): name of NN model.
+            model (str): name of NNP model.
 
         Returns:
-            bool: True if molecule is NN applicable.
+            bool: True if molecule is NNP ready.
         """
-        return mol.is_nn_applicable(model)
+        return mol.nnp_ready(model)
     
 
-    def nn_applicable(self, model:str, **kwargs) -> Self:
-        """Returns a copy of subset of library that is applicable to given neural network `model`.
+    def nnp_ready(self, model: str, **kwargs) -> Self:
+        """Returns a copy of subset of library that is ready to given neural network potential.
 
         Examples:
             >>> libr = rdworks.MolLibr(drug_smiles, drug_names)
-            >>> ani2x_compatible_subset = libr.nn_applicable('ANI-2x', progress=False)
+            >>> ani2x_compatible_subset = libr.nnp_ready('ANI-2x', progress=False)
 
         Args:
             model (str): name of model.
@@ -817,22 +970,23 @@ class MolLibr:
         Returns:
             Self: subset of library.
         """
-        obj = copy.deepcopy(self).compute(**kwargs)
+        obj = self.copy().compute(**kwargs)
         lmodel = [model,] * self.count()
         with ProcessPoolExecutor(max_workers=obj.max_workers) as executor:
             if obj.progress:
                 mask = list(tqdm(
-                    executor.map(self.mask_nn_applicable, obj.libr, lmodel, chunksize=obj.chunksize),
-                    desc="NN applicable",
+                    executor.map(self._mask_nnp_ready, obj.libr, lmodel, chunksize=obj.chunksize),
+                    desc="NNP ready",
                     total=obj.count()))
             else:
                 mask = list(
-                    executor.map(self._mask_nn_applicable, obj.libr, lmodel, chunksize=obj.chunksize))
+                    executor.map(self._mask_nnp_ready, obj.libr, lmodel, chunksize=obj.chunksize))
             obj.libr = list(itertools.compress(obj.libr, mask))
+        
         return obj
     
 
-    def to_nnbatches(self, batchsize:int=1000) -> list:
+    def to_nnbatches(self, batchsize: int = 1000) -> list:
         """Split workload flexibily into a numer of batches.
 
         - Each batch has up to `batchsize` number of atoms.