MayaChemTools

   1 #!/bin/env python
   2 #
   3 # File: RDKitSearchSMARTS.py
   4 # Author: Manish Sud <msud@san.rr.com>
   5 #
   6 # Copyright (C) 2021 Manish Sud. All rights reserved.
   7 #
   8 # The functionality available in this script is implemented using RDKit, an
   9 # open source toolkit for cheminformatics developed by Greg Landrum.
  10 #
  11 # This file is part of MayaChemTools.
  12 #
  13 # MayaChemTools is free software; you can redistribute it and/or modify it under
  14 # the terms of the GNU Lesser General Public License as published by the Free
  15 # Software Foundation; either version 3 of the License, or (at your option) any
  16 # later version.
  17 #
  18 # MayaChemTools is distributed in the hope that it will be useful, but without
  19 # any warranty; without even the implied warranty of merchantability of fitness
  20 # for a particular purpose.  See the GNU Lesser General Public License for more
  21 # details.
  22 #
  23 # You should have received a copy of the GNU Lesser General Public License
  24 # along with MayaChemTools; if not, see <http://www.gnu.org/licenses/> or
  25 # write to the Free Software Foundation Inc., 59 Temple Place, Suite 330,
  26 # Boston, MA, 02111-1307, USA.
  27 #
  28 
  29 from __future__ import print_function
  30 
  31 # Add local python path to the global path and import standard library modules...
  32 import os
  33 import sys;  sys.path.insert(0, os.path.join(os.path.dirname(sys.argv[0]), "..", "lib", "Python"))
  34 import time
  35 import re
  36 import multiprocessing as mp
  37 
  38 # RDKit imports...
  39 try:
  40     from rdkit import rdBase
  41     from rdkit import Chem
  42     from rdkit.Chem import AllChem
  43 except ImportError as ErrMsg:
  44     sys.stderr.write("\nFailed to import RDKit module/package: %s\n" % ErrMsg)
  45     sys.stderr.write("Check/update your RDKit environment and try again.\n\n")
  46     sys.exit(1)
  47 
  48 # MayaChemTools imports...
  49 try:
  50     from docopt import docopt
  51     import MiscUtil
  52     import RDKitUtil
  53 except ImportError as ErrMsg:
  54     sys.stderr.write("\nFailed to import MayaChemTools module/package: %s\n" % ErrMsg)
  55     sys.stderr.write("Check/update your MayaChemTools environment and try again.\n\n")
  56     sys.exit(1)
  57 
  58 ScriptName = os.path.basename(sys.argv[0])
  59 Options = {}
  60 OptionsInfo = {}
  61 
  62 def main():
  63     """Start execution of the script"""
  64     
  65     MiscUtil.PrintInfo("\n%s (RDK v%s; %s): Starting...\n" % (ScriptName, rdBase.rdkitVersion, time.asctime()))
  66     
  67     (WallClockTime, ProcessorTime) = MiscUtil.GetWallClockAndProcessorTime()
  68     
  69     # Retrieve command line arguments and options...
  70     RetrieveOptions()
  71     
  72     # Process and validate command line arguments and options...
  73     ProcessOptions()
  74     
  75     # Perform actions required by the script...
  76     PerformSearch()
  77     
  78     MiscUtil.PrintInfo("\n%s: Done...\n" % ScriptName)
  79     MiscUtil.PrintInfo("Total time: %s" % MiscUtil.GetFormattedElapsedTime(WallClockTime, ProcessorTime))
  80 
  81 def PerformSearch():
  82     """Perform search using specified SMARTS pattern."""
  83     
  84     # Set up a pattern molecule...
  85     PatternMol = Chem.MolFromSmarts(OptionsInfo["Pattern"])
  86     
  87     # Setup a molecule reader...
  88     MiscUtil.PrintInfo("\nProcessing file %s..." % OptionsInfo["Infile"])
  89     Mols  = RDKitUtil.ReadMolecules(OptionsInfo["Infile"], **OptionsInfo["InfileParams"])
  90     
  91     # Set up molecule writers...
  92     Writer, WriterFiltered = SetupMoleculeWriters()
  93     
  94     MolCount, ValidMolCount, RemainingMolCount = ProcessMolecules(Mols, PatternMol, Writer, WriterFiltered)
  95     
  96     if Writer is not None:
  97         Writer.close()
  98     if WriterFiltered is not None:
  99         WriterFiltered.close()
 100     
 101     MiscUtil.PrintInfo("\nTotal number of molecules: %d" % MolCount)
 102     MiscUtil.PrintInfo("Number of valid molecules: %d" % ValidMolCount)
 103     MiscUtil.PrintInfo("Number of ignored molecules: %d" % (MolCount - ValidMolCount))
 104 
 105     MiscUtil.PrintInfo("\nNumber of remaining molecules: %d" % RemainingMolCount)
 106     MiscUtil.PrintInfo("Number of filtered molecules: %d" % (ValidMolCount - RemainingMolCount))
 107 
 108 def ProcessMolecules(Mols, PatternMol, Writer, WriterFiltered):
 109     """Process and filter molecules. """
 110     
 111     if OptionsInfo["MPMode"]:
 112         return ProcessMoleculesUsingMultipleProcesses(Mols, PatternMol, Writer, WriterFiltered)
 113     else:
 114         return ProcessMoleculesUsingSingleProcess(Mols, PatternMol, Writer, WriterFiltered)
 115 
 116 def ProcessMoleculesUsingSingleProcess(Mols, PatternMol, Writer, WriterFiltered):
 117     """Process and filter molecules using a single process."""
 118     
 119     NegateMatch = OptionsInfo["NegateMatch"]
 120     OutfileFilteredMode = OptionsInfo["OutfileFilteredMode"]
 121     Compute2DCoords = OptionsInfo["OutfileParams"]["Compute2DCoords"]
 122     SetSMILESMolProps = OptionsInfo["OutfileParams"]["SetSMILESMolProps"]
 123     
 124     MiscUtil.PrintInfo("\nFiltering molecules...")
 125     
 126     (MolCount, ValidMolCount, RemainingMolCount) = [0] * 3
 127     FirstMol = True
 128     for Mol in Mols:
 129         MolCount += 1
 130         
 131         if Mol is None:
 132             continue
 133         
 134         if RDKitUtil.IsMolEmpty(Mol):
 135             MolName = RDKitUtil.GetMolName(Mol, MolCount)
 136             MiscUtil.PrintWarning("Ignoring empty molecule: %s" % MolName)
 137             continue
 138         
 139         ValidMolCount += 1
 140         if FirstMol:
 141             FirstMol = False
 142             if SetSMILESMolProps:
 143                 if Writer is not None:
 144                     RDKitUtil.SetWriterMolProps(Writer, Mol)
 145                 if WriterFiltered is not None:
 146                     RDKitUtil.SetWriterMolProps(WriterFiltered, Mol)
 147         
 148         MolMatched = DoesMoleculeContainsPattern(Mol, PatternMol)
 149         if MolMatched != NegateMatch:
 150             RemainingMolCount += 1
 151             WriteMolecule(Writer, Mol, Compute2DCoords)
 152         else:
 153             if OutfileFilteredMode:
 154                 WriteMolecule(WriterFiltered, Mol, Compute2DCoords)
 155     
 156     return (MolCount, ValidMolCount, RemainingMolCount)
 157     
 158 def ProcessMoleculesUsingMultipleProcesses(Mols, PatternMol, Writer, WriterFiltered):
 159     """Process and filter molecules using multiprocessing."""
 160     
 161     MiscUtil.PrintInfo("\nFiltering molecules using multiprocessing...")
 162     
 163     MPParams = OptionsInfo["MPParams"]
 164     NegateMatch = OptionsInfo["NegateMatch"]
 165     OutfileFilteredMode = OptionsInfo["OutfileFilteredMode"]
 166     Compute2DCoords = OptionsInfo["OutfileParams"]["Compute2DCoords"]
 167     SetSMILESMolProps = OptionsInfo["OutfileParams"]["SetSMILESMolProps"]
 168     
 169     # Setup data for initializing a worker process...
 170     MiscUtil.PrintInfo("Encoding options info and pattern molecule...")
 171     OptionsInfo["EncodedPatternMol"] = RDKitUtil.MolToBase64EncodedMolString(PatternMol)
 172     InitializeWorkerProcessArgs = (MiscUtil.ObjectToBase64EncodedString(Options), MiscUtil.ObjectToBase64EncodedString(OptionsInfo))
 173 
 174     # Setup a encoded mols data iterable for a worker process...
 175     WorkerProcessDataIterable = RDKitUtil.GenerateBase64EncodedMolStrings(Mols)
 176 
 177     # Setup process pool along with data initialization for each process...
 178     MiscUtil.PrintInfo("\nConfiguring multiprocessing using %s method..." % ("mp.Pool.imap()" if re.match("^Lazy$", MPParams["InputDataMode"], re.I) else "mp.Pool.map()"))
 179     MiscUtil.PrintInfo("NumProcesses: %s; InputDataMode: %s; ChunkSize: %s\n" % (MPParams["NumProcesses"], MPParams["InputDataMode"], ("automatic" if MPParams["ChunkSize"] is None else MPParams["ChunkSize"])))
 180     
 181     ProcessPool = mp.Pool(MPParams["NumProcesses"], InitializeWorkerProcess, InitializeWorkerProcessArgs)
 182     
 183     # Start processing...
 184     if re.match("^Lazy$", MPParams["InputDataMode"], re.I):
 185         Results = ProcessPool.imap(WorkerProcess, WorkerProcessDataIterable, MPParams["ChunkSize"])
 186     elif re.match("^InMemory$", MPParams["InputDataMode"], re.I):
 187         Results = ProcessPool.map(WorkerProcess, WorkerProcessDataIterable, MPParams["ChunkSize"])
 188     else:
 189         MiscUtil.PrintError("The value, %s, specified for \"--inputDataMode\" is not supported." % (MPParams["InputDataMode"]))
 190     
 191     (MolCount, ValidMolCount, RemainingMolCount) = [0] * 3
 192     FirstMol = True
 193     for Result in Results:
 194         MolCount += 1
 195         MolIndex, EncodedMol, MolMatched = Result
 196         
 197         if EncodedMol is None:
 198             continue
 199         ValidMolCount += 1
 200         
 201         Mol = RDKitUtil.MolFromBase64EncodedMolString(EncodedMol)
 202         
 203         if FirstMol:
 204             FirstMol = False
 205             if SetSMILESMolProps:
 206                 if Writer is not None:
 207                     RDKitUtil.SetWriterMolProps(Writer, Mol)
 208                 if WriterFiltered is not None:
 209                     RDKitUtil.SetWriterMolProps(WriterFiltered, Mol)
 210         
 211         if MolMatched != NegateMatch:
 212             RemainingMolCount += 1
 213             WriteMolecule(Writer, Mol, Compute2DCoords)
 214         else:
 215             if OutfileFilteredMode:
 216                 WriteMolecule(WriterFiltered, Mol, Compute2DCoords)
 217     
 218     return (MolCount, ValidMolCount, RemainingMolCount)
 219 
 220 def InitializeWorkerProcess(*EncodedArgs):
 221     """Initialize data for a worker process."""
 222 
 223     global Options, OptionsInfo
 224     
 225     MiscUtil.PrintInfo("Starting process (PID: %s)..." % os.getpid())
 226 
 227     # Decode Options and OptionInfo...
 228     Options = MiscUtil.ObjectFromBase64EncodedString(EncodedArgs[0])
 229     OptionsInfo = MiscUtil.ObjectFromBase64EncodedString(EncodedArgs[1])
 230 
 231     # Decode PatternMol...
 232     OptionsInfo["PatternMol"] = RDKitUtil.MolFromBase64EncodedMolString(OptionsInfo["EncodedPatternMol"])
 233     
 234 def WorkerProcess(EncodedMolInfo):
 235     """Process data for a worker process."""
 236 
 237     MolIndex, EncodedMol = EncodedMolInfo
 238 
 239     if EncodedMol is None:
 240         return [MolIndex, None, False]
 241         
 242     Mol = RDKitUtil.MolFromBase64EncodedMolString(EncodedMol)
 243     if RDKitUtil.IsMolEmpty(Mol):
 244         MolName = RDKitUtil.GetMolName(Mol, (MolIndex + 1))
 245         MiscUtil.PrintWarning("Ignoring empty molecule: %s" % MolName)
 246         return [MolIndex, None, False]
 247         
 248     MolMatched = DoesMoleculeContainsPattern(Mol, OptionsInfo["PatternMol"])
 249 
 250     return [MolIndex, EncodedMol, MolMatched]
 251 
 252 def WriteMolecule(Writer, Mol, Compute2DCoords):
 253     """Write out molecule."""
 254     
 255     if OptionsInfo["CountMode"]:
 256         return
 257     
 258     if Compute2DCoords:
 259         AllChem.Compute2DCoords(Mol)
 260     
 261     Writer.write(Mol)
 262     
 263 def SetupMoleculeWriters():
 264     """Setup molecule writers."""
 265     
 266     Writer = None
 267     WriterFiltered = None
 268 
 269     if OptionsInfo["CountMode"]:
 270         return (Writer, WriterFiltered)
 271 
 272     Writer = RDKitUtil.MoleculesWriter(OptionsInfo["Outfile"], **OptionsInfo["OutfileParams"])
 273     if Writer is None:
 274         MiscUtil.PrintError("Failed to setup a writer for output fie %s " % OptionsInfo["Outfile"])
 275     MiscUtil.PrintInfo("Generating file %s..." % OptionsInfo["Outfile"])
 276     
 277     if OptionsInfo["OutfileFilteredMode"]:
 278         WriterFiltered = RDKitUtil.MoleculesWriter(OptionsInfo["OutfileFiltered"], **OptionsInfo["OutfileParams"])
 279         if WriterFiltered is None:
 280             MiscUtil.PrintError("Failed to setup a writer for output fie %s " % OptionsInfo["OutfileFiltered"])
 281         MiscUtil.PrintInfo("Generating file %s..." % OptionsInfo["OutfileFiltered"])
 282     
 283     return (Writer, WriterFiltered)
 284 
 285 def DoesMoleculeContainsPattern(Mol, PatternMol):
 286     """Check presence of pattern in the molecule"""
 287 
 288     return True if Mol.HasSubstructMatch(PatternMol, useChirality = OptionsInfo["UseChirality"]) else False
 289 
 290 def ProcessOptions():
 291     """Process and validate command line arguments and options"""
 292     
 293     MiscUtil.PrintInfo("Processing options...")
 294     
 295     # Validate options...
 296     ValidateOptions()
 297     
 298     OptionsInfo["Infile"] = Options["--infile"]
 299     OptionsInfo["InfileParams"] = MiscUtil.ProcessOptionInfileParameters("--infileParams", Options["--infileParams"], Options["--infile"])
 300     
 301     OptionsInfo["Outfile"] = Options["--outfile"]
 302     OptionsInfo["OutfileParams"] = MiscUtil.ProcessOptionOutfileParameters("--outfileParams", Options["--outfileParams"], Options["--infile"], Options["--outfile"])
 303     
 304     OptionsInfo["OutfileFiltered"] = ""
 305     if Options["--outfile"]:
 306         FileDir, FileName, FileExt = MiscUtil.ParseFileName(Options["--outfile"])
 307         OutfileFiltered = "%s_Filtered.%s" % (FileName, FileExt)
 308         OptionsInfo["OutfileFiltered"] = OutfileFiltered
 309     OptionsInfo["OutfileFilteredMode"] = True if re.match("^yes$", Options["--outfileFiltered"], re.I) else False
 310         
 311     OptionsInfo["Overwrite"] = Options["--overwrite"]
 312 
 313     OptionsInfo["CountMode"] = True if re.match("^count$", Options["--mode"], re.I) else False
 314     OptionsInfo["NegateMatch"] = True if re.match("^yes$", Options["--negate"], re.I) else False
 315     
 316     OptionsInfo["MPMode"] = True if re.match("^yes$", Options["--mp"], re.I) else False
 317     OptionsInfo["MPParams"] = MiscUtil.ProcessOptionMultiprocessingParameters("--mpParams", Options["--mpParams"])
 318     
 319     OptionsInfo["Pattern"] = Options["--pattern"]
 320     OptionsInfo["UseChirality"] = True if re.match("^yes$", Options["--useChirality"], re.I) else False
 321 
 322 def RetrieveOptions():
 323     """Retrieve command line arguments and options"""
 324     
 325     # Get options...
 326     global Options
 327     Options = docopt(_docoptUsage_)
 328     
 329     # Set current working directory to the specified directory...
 330     WorkingDir = Options["--workingdir"]
 331     if WorkingDir:
 332         os.chdir(WorkingDir)
 333     
 334     # Handle examples option...
 335     if "--examples" in Options and Options["--examples"]:
 336         MiscUtil.PrintInfo(MiscUtil.GetExamplesTextFromDocOptText(_docoptUsage_))
 337         sys.exit(0)
 338 
 339 def ValidateOptions():
 340     """Validate option values"""
 341     
 342     MiscUtil.ValidateOptionFilePath("-i, --infile", Options["--infile"])
 343     MiscUtil.ValidateOptionFileExt("-i, --infile", Options["--infile"], "sdf sd smi txt csv tsv")
 344     if Options["--outfile"]:
 345         MiscUtil.ValidateOptionFileExt("-o, --outfile", Options["--outfile"], "sdf sd smi")
 346         MiscUtil.ValidateOptionsOutputFileOverwrite("-o, --outfile", Options["--outfile"], "--overwrite", Options["--overwrite"])
 347         MiscUtil.ValidateOptionsDistinctFileNames("-i, --infile", Options["--infile"], "-o, --outfile", Options["--outfile"])
 348         
 349     MiscUtil.ValidateOptionTextValue("--outfileFiltered", Options["--outfileFiltered"], "yes no")
 350     
 351     MiscUtil.ValidateOptionTextValue("-m, --mode", Options["--mode"], "retrieve count")
 352     if re.match("^retrieve$", Options["--mode"], re.I):
 353         if not Options["--outfile"]:
 354             MiscUtil.PrintError("The outfile must be specified using \"-o, --outfile\" during \"retrieve\" value of \"-m, --mode\" option")
 355         
 356     MiscUtil.ValidateOptionTextValue("--mp", Options["--mp"], "yes no")
 357     MiscUtil.ValidateOptionTextValue("-n, --negate", Options["--negate"], "yes no")
 358     
 359     PatternMol = Chem.MolFromSmarts(Options["--pattern"])
 360     if PatternMol is None:
 361         MiscUtil.PrintError("The value specified, %s, using option \"-p, --pattern\" is not a valid SMARTS: Failed to create pattern molecule" % Options["--pattern"])
 362     
 363     MiscUtil.ValidateOptionTextValue("--useChirality", Options["--useChirality"], "yes no")
 364 
 365 # Setup a usage string for docopt...
 366 _docoptUsage_ = """
 367 RDKitSearchSMARTS.py - Perform a substructure search using SMARTS pattern
 368 
 369 Usage:
 370     RDKitSearchSMARTS.py  [--infileParams <Name,Value,...>] [--mode <retrieve or count>]
 371                           [--mp <yes or no>] [--mpParams <Name,Value,...>] [--negate <yes or no>]
 372                           [--outfileFiltered <yes or no>] [--outfileParams <Name,Value,...>] [--overwrite]
 373                           [--useChirality <yes or no>] [-w <dir>] [-o <outfile>] -p <SMARTS> -i <infile>
 374     RDKitSearchSMARTS.py -h | --help | -e | --examples
 375 
 376 Description:
 377     Perform a substructure search in an input file using specified SMARTS pattern and
 378     write out the matched molecules to an output file or simply count the number
 379     of matches.
 380 
 381     The supported input file formats are: SD (.sdf, .sd), SMILES (.smi., csv, .tsv, .txt)
 382 
 383     The supported output file formats are: SD (.sdf, .sd), SMILES (.smi)
 384 
 385 Options:
 386     -e, --examples
 387         Print examples.
 388     -h, --help
 389         Print this help message.
 390     -i, --infile <infile>
 391         Input file name.
 392     --infileParams <Name,Value,...>  [default: auto]
 393         A comma delimited list of parameter name and value pairs for reading
 394         molecules from files. The supported parameter names for different file
 395         formats, along with their default values, are shown below:
 396             
 397             SD, MOL: removeHydrogens,yes,sanitize,yes,strictParsing,yes
 398             SMILES: smilesColumn,1,smilesNameColumn,2,smilesDelimiter,space,
 399                 smilesTitleLine,auto,sanitize,yes
 400             
 401         Possible values for smilesDelimiter: space, comma or tab.
 402     -m, --mode <retrieve or count>  [default: retrieve]
 403         Specify whether to retrieve and write out matched molecules to an output
 404         file or simply count the number of matches.
 405     --mp <yes or no>  [default: no]
 406         Use multiprocessing.
 407          
 408         By default, input data is retrieved in a lazy manner via mp.Pool.imap()
 409         function employing lazy RDKit data iterable. This allows processing of
 410         arbitrary large data sets without any additional requirements memory.
 411         
 412         All input data may be optionally loaded into memory by mp.Pool.map()
 413         before starting worker processes in a process pool by setting the value
 414         of 'inputDataMode' to 'InMemory' in '--mpParams' option.
 415         
 416         A word to the wise: The default 'chunkSize' value of 1 during 'Lazy' input
 417         data mode may adversely impact the performance. The '--mpParams' section
 418         provides additional information to tune the value of 'chunkSize'.
 419     --mpParams <Name,Value,...>  [default: auto]
 420         A comma delimited list of parameter name and value pairs to configure
 421         multiprocessing.
 422         
 423         The supported parameter names along with their default and possible
 424         values are shown below:
 425         
 426             chunkSize, auto
 427             inputDataMode, Lazy   [ Possible values: InMemory or Lazy ]
 428             numProcesses, auto   [ Default: mp.cpu_count() ]
 429         
 430         These parameters are used by the following functions to configure and
 431         control the behavior of multiprocessing: mp.Pool(), mp.Pool.map(), and
 432         mp.Pool.imap().
 433         
 434         The chunkSize determines chunks of input data passed to each worker
 435         process in a process pool by mp.Pool.map() and mp.Pool.imap() functions.
 436         The default value of chunkSize is dependent on the value of 'inputDataMode'.
 437         
 438         The mp.Pool.map() function, invoked during 'InMemory' input data mode,
 439         automatically converts RDKit data iterable into a list, loads all data into
 440         memory, and calculates the default chunkSize using the following method
 441         as shown in its code:
 442         
 443             chunkSize, extra = divmod(len(dataIterable), len(numProcesses) * 4)
 444             if extra: chunkSize += 1
 445         
 446         For example, the default chunkSize will be 7 for a pool of 4 worker processes
 447         and 100 data items.
 448         
 449         The mp.Pool.imap() function, invoked during 'Lazy' input data mode, employs
 450         'lazy' RDKit data iterable to retrieve data as needed, without loading all the
 451         data into memory. Consequently, the size of input data is not known a priori.
 452         It's not possible to estimate an optimal value for the chunkSize. The default 
 453         chunkSize is set to 1.
 454         
 455         The default value for the chunkSize during 'Lazy' data mode may adversely
 456         impact the performance due to the overhead associated with exchanging
 457         small chunks of data. It is generally a good idea to explicitly set chunkSize to
 458         a larger value during 'Lazy' input data mode, based on the size of your input
 459         data and number of processes in the process pool.
 460         
 461         The mp.Pool.map() function waits for all worker processes to process all
 462         the data and return the results. The mp.Pool.imap() function, however,
 463         returns the the results obtained from worker processes as soon as the
 464         results become available for specified chunks of data.
 465         
 466         The order of data in the results returned by both mp.Pool.map() and 
 467         mp.Pool.imap() functions always corresponds to the input data.
 468     -n, --negate <yes or no>  [default: no]
 469         Specify whether to find molecules not matching the specified SMARTS pattern.
 470     -o, --outfile <outfile>
 471         Output file name.
 472     --outfileFiltered <yes or no>  [default: no]
 473         Write out a file containing filtered molecules. Its name is automatically
 474         generated from the specified output file. Default: <OutfileRoot>_
 475         Filtered.<OutfileExt>.
 476     --outfileParams <Name,Value,...>  [default: auto]
 477         A comma delimited list of parameter name and value pairs for writing
 478         molecules to files. The supported parameter names for different file
 479         formats, along with their default values, are shown below:
 480             
 481             SD: compute2DCoords,auto,kekulize,yes
 482             SMILES: smilesKekulize,no,smilesDelimiter,space, smilesIsomeric,yes,
 483                 smilesTitleLine,yes,smilesMolName,yes,smilesMolProps,no
 484             
 485         Default value for compute2DCoords: yes for SMILES input file; no for all other
 486         file types.
 487     --overwrite
 488         Overwrite existing files.
 489     -p, --pattern <SMARTS>  [default: none]
 490         SMARTS pattern for performing search.
 491     -u, --useChirality <yes or no>  [default: no]
 492         Use stereochemistry information for SMARTS search.
 493     -w, --workingdir <dir>
 494         Location of working directory which defaults to the current directory.
 495 
 496 Examples:
 497     To retrieve molecules containing the substructure corresponding to a specified
 498     SMARTS pattern and write out a SMILES file, type: 
 499 
 500         % RDKitSearchSMARTS.py -p 'c1ccccc1' -i Sample.smi -o SampleOut.smi
 501 
 502     To retrieve molecules containing the substructure corresponding to a specified
 503     SMARTS pattern,  perform filtering in multiprocessing mode on all available
 504     CPUs without loading all data into memory, and write out a SMILES file, type: 
 505 
 506         % RDKitSearchSMARTS.py --mp yes -p 'c1ccccc1' -i Sample.smi -o SampleOut.smi
 507 
 508     To retrieve molecules containing the substructure corresponding to a specified
 509     SMARTS pattern,  perform filtering in multiprocessing mode on all available
 510     CPUs by loading all data into memory, and write out a SMILES file, type: 
 511 
 512         % RDKitSearchSMARTS.py --mp yes --mpParams "inputDataMode,InMemory"
 513           -p 'c1ccccc1' -i Sample.smi -o SampleOut.smi
 514 
 515     To retrieve molecules containing the substructure corresponding to a specified
 516     SMARTS pattern,  perform filtering in multiprocessing mode on specific number
 517     of CPUs and chunk size without loading all data into memory, and write out
 518     a SMILES file, type: 
 519 
 520         % RDKitSearchSMARTS.py --mp yes --mpParams "inputDataMode,Lazy,
 521           numProcesses,4,chunkSize,8" -p 'c1ccccc1' -i Sample.smi -o SampleOut.smi
 522 
 523     To only count the number of molecules containing the substructure corresponding
 524     to a specified SMARTS pattern without writing out any file, type: 
 525 
 526         % RDKitSearchSMARTS.py -m count -p 'c1ccccc1' -i Sample.smi
 527 
 528     To count the number of molecules in a SD file not containing the substructure
 529     corresponding to a specified SMARTS pattern and write out a SD file, type: 
 530 
 531         % RDKitSearchSMARTS.py -n yes -p 'c1ccccc1' -i Sample.sdf -o SampleOut.sdf
 532 
 533     To retrieve molecules containing the substructure corresponding to a specified
 534     SMARTS pattern from a CSV SMILES file, SMILES strings in column 1, name in
 535     and write out a SD file, type: 
 536 
 537         % RDKitSearchSMARTS.py -p 'c1ccccc1' --infileParams
 538           "smilesDelimiter,comma,smilesTitleLine,yes,smilesColumn,1,
 539           smilesNameColumn,2" --outfileParams "compute2DCoords,yes"
 540           -i SampleSMILES.csv -o SampleOut.sdf
 541 
 542 Author:
 543     Manish Sud(msud@san.rr.com)
 544 
 545 See also:
 546     RDKitConvertFileFormat.py, RDKitFilterPAINS.py, RDKitSearchFunctionalGroups.py 
 547 
 548 Copyright:
 549     Copyright (C) 2021 Manish Sud. All rights reserved.
 550 
 551     The functionality available in this script is implemented using RDKit, an
 552     open source toolkit for cheminformatics developed by Greg Landrum.
 553 
 554     This file is part of MayaChemTools.
 555 
 556     MayaChemTools is free software; you can redistribute it and/or modify it under
 557     the terms of the GNU Lesser General Public License as published by the Free
 558     Software Foundation; either version 3 of the License, or (at your option) any
 559     later version.
 560 
 561 """
 562 
 563 if __name__ == "__main__":
 564     main()