def ValidateOptions():
    """Validate option values"""
    
    MiscUtil.ValidateOptionTextValue("-a, --addHydrogens", Options["--addHydrogens"], "yes no")
    MiscUtil.ValidateOptionTextValue("-c, --conformerGenerator", Options["--conformerGenerator"], "SDG ETDG KDG ETKDG")
    
    MiscUtil.ValidateOptionTextValue("-f, --forceField", Options["--forceField"], "UFF MMFF")
    MiscUtil.ValidateOptionTextValue(" --forceFieldMMFFVariant", Options["--forceFieldMMFFVariant"], "MMFF94 MMFF94s")
    
    MiscUtil.ValidateOptionTextValue("--scaffoldRMSDOut", Options["--scaffoldRMSDOut"], "yes no")
    
    MiscUtil.ValidateOptionTextValue("--energyOut", Options["--energyOut"], "yes no")
    MiscUtil.ValidateOptionTextValue("--enforceChirality ", Options["--enforceChirality"], "yes no")
    
    MiscUtil.ValidateOptionFilePath("-i, --infile", Options["--infile"])
    MiscUtil.ValidateOptionFileExt("-i, --infile", Options["--infile"], "sdf sd mol smi txt csv tsv")

    MiscUtil.ValidateOptionFilePath("-r, --reffile", Options["--reffile"])
    MiscUtil.ValidateOptionFileExt("-r, --reffile", Options["--reffile"], "sdf sd mol")
    
    MiscUtil.ValidateOptionFileExt("-o, --outfile", Options["--outfile"], "sdf sd")
    MiscUtil.ValidateOptionsOutputFileOverwrite("-o, --outfile", Options["--outfile"], "--overwrite", Options["--overwrite"])
    MiscUtil.ValidateOptionsDistinctFileNames("-i, --infile", Options["--infile"], "-o, --outfile", Options["--outfile"])
        
    MiscUtil.ValidateOptionIntegerValue("--maxConfs", Options["--maxConfs"], {">": 0})
    
    MiscUtil.ValidateOptionTextValue("--mp", Options["--mp"], "yes no")
    MiscUtil.ValidateOptionTextValue("-q, --quiet", Options["--quiet"], "yes no")
    
    MiscUtil.ValidateOptionTextValue("-r, --removeHydrogens", Options["--removeHydrogens"], "yes no")
    
    MiscUtil.ValidateOptionTextValue("-u, --useTethers", Options["--useTethers"], "yes no")
def ValidateOptions():
    """Validate option values"""

    MiscUtil.ValidateOptionTextValue("--alignMethod", Options["--alignMethod"],
                                     "align cealign super")
    MiscUtil.ValidateOptionTextValue("--alignMode", Options["--alignMode"],
                                     "FirstChain Complex")

    # Expand infiles to handle presence of multiple input files...
    InfileNames = MiscUtil.ExpandFileNames(Options["--infiles"], ",")
    if len(InfileNames) < 2:
        MiscUtil.PrintError(
            "Number of input files specified for \"-i, --infiles\" option, %d, must be greater than 2..."
            % (len(InfileNames)))

    # Validate file extensions...
    for Infile in InfileNames:
        MiscUtil.ValidateOptionFilePath("-i, --infiles", Infile)
        MiscUtil.ValidateOptionFileExt("-i, --infiles", Infile, "pdb cif")
    Options["--infileNames"] = InfileNames

    if not re.match("^FirstInputFile$", Options["--alignRefFile"], re.I):
        AlignRefFile = Options["--alignRefFile"]
        MiscUtil.ValidateOptionFilePath("--alignRefFile", AlignRefFile)
        MiscUtil.ValidateOptionFileExt("--alignRefFile", AlignRefFile,
                                       "pdb cif")
def ValidateOptions():
    """Validate option values"""

    MiscUtil.ValidateOptionFilePath("-i, --infile", Options["--infile"])
    MiscUtil.ValidateOptionFileExt("-i, --infile", Options["--infile"],
                                   "sdf sd smi txt csv tsv")

    if Options["--outfile"]:
        MiscUtil.ValidateOptionFileExt("-o, --outfile", Options["--outfile"],
                                       "sdf sd smi")
        MiscUtil.ValidateOptionsOutputFileOverwrite("-o, --outfile",
                                                    Options["--outfile"],
                                                    "--overwrite",
                                                    Options["--overwrite"])
        MiscUtil.ValidateOptionsDistinctFileNames("-i, --infile",
                                                  Options["--infile"],
                                                  "-o, --outfile",
                                                  Options["--outfile"])

    MiscUtil.ValidateOptionTextValue("-m, --mode", Options["--mode"],
                                     "remove count")
    if re.match("^remove$", Options["--mode"], re.I):
        if not Options["--outfile"]:
            MiscUtil.PrintError(
                "The outfile must be specified using \"-o, --outfile\" during \"remove\" value of \"-m, --mode\" option"
            )

    MiscUtil.ValidateOptionTextValue("--saltsMode", Options["--saltsMode"],
                                     "ByComponent BySMARTSFile BySMARTS")

    if re.match("^BySMARTSFile$", Options["--saltsMode"], re.I):
        if not re.match("^auto$", Options["--saltsFile"], re.I):
            MiscUtil.ValidateOptionFilePath("--saltsFile",
                                            Options["--saltsFile"])
Beispiel #4
0
def ValidateOptions():
    """Validate option values"""

    MiscUtil.ValidateOptionTextValue("--calcRMSD", Options["--calcRMSD"],
                                     "RMSD BestRMSD")

    MiscUtil.ValidateOptionIntegerValue("--maxIters", Options["--maxIters"],
                                        {">": 0})
    MiscUtil.ValidateOptionTextValue("--mode", Options["--mode"],
                                     "OneToOne  AllToAll FirstToAll")

    MiscUtil.ValidateOptionFilePath("-r, --reffile", Options["--reffile"])
    MiscUtil.ValidateOptionFileExt("-r, --reffile", Options["--reffile"],
                                   "sdf sd mol")

    MiscUtil.ValidateOptionFilePath("-p, --probefile", Options["--probefile"])
    MiscUtil.ValidateOptionFileExt("-p, --probefile", Options["--probefile"],
                                   "sdf sd mol")

    MiscUtil.ValidateOptionFileExt("-o, --outfile", Options["--outfile"],
                                   "csv tsv txt")
    MiscUtil.ValidateOptionsOutputFileOverwrite("-o, --outfile",
                                                Options["--outfile"],
                                                "--overwrite",
                                                Options["--overwrite"])
    MiscUtil.ValidateOptionsDistinctFileNames("-r, --reffile",
                                              Options["--reffile"],
                                              "-o, --outfile",
                                              Options["--outfile"])
    MiscUtil.ValidateOptionsDistinctFileNames("-p, --probefile",
                                              Options["--probefile"],
                                              "-o, --outfile",
                                              Options["--outfile"])
def ValidateOptions():
    """Validate option values"""

    # Expand infile names..
    InfilesNames = MiscUtil.ExpandFileNames(Options["--infiles"], ",")

    # Validate file extensions...
    for Infile in InfilesNames:
        MiscUtil.ValidateOptionFilePath("-i, --infiles", Infile)
        MiscUtil.ValidateOptionFileExt("-i, --infiles", Infile, "pdb cif")
    Options["--infilesNames"] = InfilesNames

    if not re.match("^auto$", Options["--interfaceResiduesCutoff"], re.I):
        MiscUtil.ValidateOptionFloatValue("--interfaceResiduesCutoff",
                                          Options["--interfaceResiduesCutoff"],
                                          {">": 0.0})
    MiscUtil.ValidateOptionTextValue(
        "--interfaceResiduesMethod", Options["--interfaceResiduesMethod"],
        "BySASAChange ByHeavyAtomsDistance ByCAlphaAtomsDistance")

    MiscUtil.ValidateOptionFloatValue("--pocketDistanceCutoff",
                                      Options["--pocketDistanceCutoff"],
                                      {">": 0.0})
    MiscUtil.ValidateOptionTextValue("--phiPsiMode", Options["--phiPsiMode"],
                                     "All  Categories")
    MiscUtil.ValidateOptionIntegerValue("--phiPsiPrecision",
                                        Options["--phiPsiPrecision"], {">": 0})
    MiscUtil.ValidateOptionFloatValue("--surfaceResiduesCutoff",
                                      Options["--surfaceResiduesCutoff"],
                                      {">": 0.0})
    MiscUtil.ValidateOptionTextValue("--surfaceResiduesIDs",
                                     Options["--surfaceResiduesIDs"], "Yes No")
def ValidateOptions():
    """Validate option values"""

    MiscUtil.ValidateOptionTextValue("-f, --forceField",
                                     Options["--forceField"], "UFF MMFF")
    MiscUtil.ValidateOptionTextValue(" --forceFieldMMFFVariant",
                                     Options["--forceFieldMMFFVariant"],
                                     "MMFF94 MMFF94s")

    MiscUtil.ValidateOptionFilePath("-i, --infile", Options["--infile"])
    MiscUtil.ValidateOptionFileExt("-i, --infile", Options["--infile"],
                                   "sdf sd mol")

    MiscUtil.ValidateOptionFileExt("-o, --outfile", Options["--outfile"],
                                   "sdf sd")
    MiscUtil.ValidateOptionsOutputFileOverwrite("-o, --outfile",
                                                Options["--outfile"],
                                                "--overwrite",
                                                Options["--overwrite"])
    MiscUtil.ValidateOptionsDistinctFileNames("-i, --infile",
                                              Options["--infile"],
                                              "-o, --outfile",
                                              Options["--outfile"])

    MiscUtil.ValidateOptionTextValue("--mp", Options["--mp"], "yes no")
    MiscUtil.ValidateOptionTextValue("-q, --quiet", Options["--quiet"],
                                     "yes no")
Beispiel #7
0
def ValidateOptions():
    """Validate option values"""

    MiscUtil.ValidateOptionTextValue("-a, --allowParamFailure",
                                     Options["--allowParamFailure"], "yes no")
    MiscUtil.ValidateOptionTextValue("-c, --chargesSDFormat",
                                     Options["--chargesSDFormat"],
                                     "AtomAliases DataField")

    MiscUtil.ValidateOptionTextValue("-m, --mode", Options["--mode"],
                                     "Gasteiger MMFF")

    MiscUtil.ValidateOptionFilePath("-i, --infile", Options["--infile"])
    MiscUtil.ValidateOptionFileExt("-i, --infile", Options["--infile"],
                                   "sdf sd mol smi csv tsv txt")

    MiscUtil.ValidateOptionFileExt("-o, --outfile", Options["--outfile"],
                                   "sdf sd")
    MiscUtil.ValidateOptionsOutputFileOverwrite("-o, --outfile",
                                                Options["--outfile"],
                                                "--overwrite",
                                                Options["--overwrite"])
    MiscUtil.ValidateOptionsDistinctFileNames("-i, --infile",
                                              Options["--infile"],
                                              "-o, --outfile",
                                              Options["--outfile"])

    MiscUtil.ValidateOptionTextValue("--mp", Options["--mp"], "yes no")

    MiscUtil.ValidateOptionIntegerValue("-n, --numIters",
                                        Options["--numIters"], {">": 0})
    MiscUtil.ValidateOptionIntegerValue("-p, --precision",
                                        Options["--precision"], {">": 0})
Beispiel #8
0
def ValidateOptions():
    """Validate option values"""

    MiscUtil.ValidateOptionFilePath("-i, --infile", Options["--infile"])
    MiscUtil.ValidateOptionFileExt("-i, --infile", Options["--infile"],
                                   "sdf sd smi txt csv tsv")

    MiscUtil.ValidateOptionFileExt("-o, --outfile", Options["--outfile"],
                                   "sdf sd smi")
    if re.match("^filter$", Options["--mode"], re.I):
        MiscUtil.ValidateOptionsOutputFileOverwrite("-o, --outfile",
                                                    Options["--outfile"],
                                                    "--overwrite",
                                                    Options["--overwrite"])
        MiscUtil.ValidateOptionsDistinctFileNames("-i, --infile",
                                                  Options["--infile"],
                                                  "-o, --outfile",
                                                  Options["--outfile"])

    MiscUtil.ValidateOptionTextValue("--outfileFiltered",
                                     Options["--outfileFiltered"], "yes no")

    MiscUtil.ValidateOptionTextValue("-m, --mode", Options["--mode"],
                                     "filter count")
    if re.match("^filter$", Options["--mode"], re.I):
        if not Options["--outfile"]:
            MiscUtil.PrintError(
                "The outfile must be specified using \"-o, --outfile\" during \"filter\" value of \"-m, --mode\" option"
            )

    MiscUtil.ValidateOptionTextValue("--mp", Options["--mp"], "yes no")
    MiscUtil.ValidateOptionTextValue("-n, --negate", Options["--negate"],
                                     "yes no")
def ValidateOptions():
    """Validate option values"""

    MiscUtil.ValidateOptionTextValue("-a, --autocorr2DExclude", Options["--autocorr2DExclude"], "yes no")
    MiscUtil.ValidateOptionTextValue("-f, --fragmentCount", Options["--fragmentCount"], "yes no")
    
    MiscUtil.ValidateOptionTextValue("-m, --mode", Options["--mode"], "2D 3D All FragmentCountOnly Specify")
    
    if re.match("^Specify$", Options["--mode"], re.I):
        if re.match("^none$", Options["--descriptorNames"], re.I):
            MiscUtil.PrintError("The name(s) of molecular descriptors must be specified using \"-d, --descriptorNames\" option during \"Specify\" value of \"-m, --mode\" option.")
    
    MiscUtil.ValidateOptionFilePath("-i, --infile", Options["--infile"])
    MiscUtil.ValidateOptionFileExt("-i, --infile", Options["--infile"], "sdf sd mol smi csv tsv txt")
    
    if re.match("^3D|All$", Options["--mode"], re.I):
        if MiscUtil.CheckFileExt(Options["--infile"], "smi"):
            MiscUtil.PrintError("The input SMILES file, %s, is not valid for  \"3D or All\" value of \"-m, --mode\" option.")
    
    MiscUtil.ValidateOptionFileExt("-o, --outfile", Options["--outfile"], "sdf sd csv tsv txt")
    MiscUtil.ValidateOptionsOutputFileOverwrite("-o, --outfile", Options["--outfile"], "--overwrite", Options["--overwrite"])
    MiscUtil.ValidateOptionsDistinctFileNames("-i, --infile", Options["--infile"], "-o, --outfile", Options["--outfile"])
    
    MiscUtil.ValidateOptionIntegerValue("-p, --precision", Options["--precision"], {">": 0})
    MiscUtil.ValidateOptionTextValue("-s, --smilesOut", Options["--smilesOut"], "yes no")
def ValidateOptions():
    """Validate option values"""

    MiscUtil.ValidateOptionTextValue("-d, --discardNonPhysical",
                                     Options["--discardNonPhysical"], "yes no")
    MiscUtil.ValidateOptionTextValue("-m, --mode", Options["--mode"],
                                     "UnassignedOnly All")

    MiscUtil.ValidateOptionFilePath("-i, --infile", Options["--infile"])
    MiscUtil.ValidateOptionFileExt("-i, --infile", Options["--infile"],
                                   "sdf sd mol smi txt csv tsv")

    MiscUtil.ValidateOptionFileExt("-o, --outfile", Options["--outfile"],
                                   "sdf sd smi")
    MiscUtil.ValidateOptionsOutputFileOverwrite("-o, --outfile",
                                                Options["--outfile"],
                                                "--overwrite",
                                                Options["--overwrite"])
    MiscUtil.ValidateOptionsDistinctFileNames("-i, --infile",
                                              Options["--infile"],
                                              "-o, --outfile",
                                              Options["--outfile"])

    MiscUtil.ValidateOptionIntegerValue("--maxIsomers",
                                        Options["--maxIsomers"], {">=": 0})
def ValidateOptions():
    """Validate option values"""

    MiscUtil.ValidateOptionFilePath("-i, --infile", Options["--infile"])
    MiscUtil.ValidateOptionFileExt("-i, --infile", Options["--infile"],
                                   "sdf sd smi txt csv tsv")

    MiscUtil.ValidateOptionFileExt("-o, --outfile", Options["--outfile"],
                                   "sdf sd smi")
    MiscUtil.ValidateOptionsOutputFileOverwrite("-o, --outfile",
                                                Options["--outfile"],
                                                "--overwrite",
                                                Options["--overwrite"])
    MiscUtil.ValidateOptionsDistinctFileNames("-i, --infile",
                                              Options["--infile"],
                                              "-o, --outfile",
                                              Options["--outfile"])

    MiscUtil.ValidateOptionTextValue("-m, --mode", Options["--mode"],
                                     "GraphFrameworks AtomicFrameworks")

    MiscUtil.ValidateOptionTextValue("-r, --removeDuplicates",
                                     Options["--removeDuplicates"], "yes no")
    MiscUtil.ValidateOptionTextValue("-s, --sort", Options["--sort"], "yes no")
    MiscUtil.ValidateOptionTextValue("--sortOrder", Options["--sortOrder"],
                                     "ascending descending")

    MiscUtil.ValidateOptionTextValue("--useChirality",
                                     Options["--useChirality"], "yes no")
Beispiel #12
0
def ValidateOptions():
    """Validate option values"""

    MiscUtil.ValidateOptionTextValue("-a, -addHydrogens",
                                     Options["--addHydrogens"], "yes no")
    MiscUtil.ValidateOptionTextValue("--keepInorganics",
                                     Options["--keepInorganics"], "yes no")
    MiscUtil.ValidateOptionTextValue("--keepLigands", Options["--keepLigands"],
                                     "yes no")
    MiscUtil.ValidateOptionTextValue("--keepSolvents",
                                     Options["--keepSolvents"], "yes no")

    # Expand infile names..
    InfilesNames = MiscUtil.ExpandFileNames(Options["--infiles"], ",")

    # Validate file extensions...
    for Infile in InfilesNames:
        MiscUtil.ValidateOptionFilePath("-i, --infiles", Infile)
        MiscUtil.ValidateOptionFileExt("-i, --infiles", Infile, "pdb cif")
    Options["--infilesNames"] = InfilesNames

    MiscUtil.ValidateOptionFileExt("-o, --outfile", Options["--outfile"],
                                   "csv tsv txt")
    MiscUtil.ValidateOptionsOutputFileOverwrite("-o, --outfile",
                                                Options["--outfile"],
                                                "--overwrite",
                                                Options["--overwrite"])

    MiscUtil.ValidateOptionIntegerValue("-p, --precision",
                                        Options["--precision"], {">": 0})
    MiscUtil.ValidateOptionTextValue("--quiet", Options["--quiet"], "yes no")
def ValidateOptions():
    """Validate option values"""

    MiscUtil.ValidateOptionTextValue(
        "-c, --clusteringMethod", Options["--clusteringMethod"],
        "Centroid CLink Gower McQuitty SLink UPGMA Ward")
    MiscUtil.ValidateOptionTextValue(
        "-f, --fingerprints", Options["--fingerprints"],
        "AtomPairs MACCS166Keys Morgan MorganFeatures PathLength TopologicalTorsions"
    )

    MiscUtil.ValidateOptionTextValue("-m, --mode", Options["--mode"],
                                     "MaxMin HierarchicalClustering")
    MiscUtil.ValidateOptionIntegerValue("-n, --numMols", Options["--numMols"],
                                        {">": 0})

    MiscUtil.ValidateOptionFilePath("-i, --infile", Options["--infile"])
    MiscUtil.ValidateOptionFileExt("-i, --infile", Options["--infile"],
                                   "sdf sd smi txt csv tsv")

    MiscUtil.ValidateOptionFileExt("-o, --outfile", Options["--outfile"],
                                   "sdf sd smi")
    MiscUtil.ValidateOptionsOutputFileOverwrite("-o, --outfile",
                                                Options["--outfile"],
                                                "--overwrite",
                                                Options["--overwrite"])
    MiscUtil.ValidateOptionsDistinctFileNames("-i, --infile",
                                              Options["--infile"],
                                              "-o, --outfile",
                                              Options["--outfile"])

    MiscUtil.ValidateOptionTextValue(
        "-s, --similarityMetric", Options["--similarityMetric"],
        "BraunBlanquet Cosine Dice Kulczynski RogotGoldberg Russel Sokal Tanimoto"
    )
Beispiel #14
0
def ValidateOptions():
    """Validate option values"""
    
    MiscUtil.ValidateOptionFilePath("-i, --infile", Options["--infile"])
    MiscUtil.ValidateOptionFileExt("-i, --infile", Options["--infile"], "pdb")
    
    MiscUtil.ValidateOptionsDistinctFileNames("-i, --infile", Options["--infile"], "-o, --outfile", Options["--outfile"])
    MiscUtil.ValidateOptionFileExt("-o, --outfile", Options["--outfile"], "pdb")
    MiscUtil.ValidateOptionsOutputFileOverwrite("-o, --outfile", Options["--outfile"], "--overwrite", Options["--overwrite"])
Beispiel #15
0
def ValidateOptions():
    """Validate option values"""

    MiscUtil.ValidateOptionTextValue("-c, --combineMatches",
                                     Options["--combineMatches"], "yes no")
    MiscUtil.ValidateOptionTextValue("--combineOperator",
                                     Options["--combineOperator"], "and or")

    if not re.match("^auto$", Options["--groupNamesFile"], re.I):
        MiscUtil.ValidateOptionFilePath("-g, groupNamesFile",
                                        Options["--groupNamesFile"])

    if re.match("^none$", Options["--functionalGroups"], re.I):
        MiscUtil.PrintError(
            "The name(s) of functional groups must be specified using \"-f, --functionalGroups\" option"
        )

    MiscUtil.ValidateOptionFilePath("-i, --infile", Options["--infile"])
    MiscUtil.ValidateOptionFileExt("-i, --infile", Options["--infile"],
                                   "sdf sd smi txt csv tsv")
    if Options["--outfile"]:
        MiscUtil.ValidateOptionFileExt("-o, --outfile", Options["--outfile"],
                                       "sdf sd smi")
        MiscUtil.ValidateOptionsOutputFileOverwrite("-o, --outfile",
                                                    Options["--outfile"],
                                                    "--overwrite",
                                                    Options["--overwrite"])
        MiscUtil.ValidateOptionsDistinctFileNames("-i, --infile",
                                                  Options["--infile"],
                                                  "-o, --outfile",
                                                  Options["--outfile"])

    MiscUtil.ValidateOptionTextValue("-m, --mode", Options["--mode"],
                                     "retrieve count")
    if re.match("^retrieve$", Options["--mode"], re.I):
        if not Options["--outfile"]:
            MiscUtil.PrintError(
                "The outfile must be specified using \"-o, --outfile\" during \"retrieve\" value of \"-m, --mode\" option"
            )

    MiscUtil.ValidateOptionTextValue("--mp", Options["--mp"], "yes no")

    MiscUtil.ValidateOptionTextValue("--useChirality",
                                     Options["--useChirality"], "yes no")
def ValidateOptions():
    """Validate option values"""

    MiscUtil.ValidateOptionTextValue("--alignment", Options["--alignment"],
                                     "Open3A CrippenOpen3A RMSD BestRMSD")

    MiscUtil.ValidateOptionIntegerValue("--maxIters", Options["--maxIters"],
                                        {">": 0})
    MiscUtil.ValidateOptionTextValue("--mode", Options["--mode"],
                                     "OneToOne  FirstToAll")

    MiscUtil.ValidateOptionFilePath("-r, --reffile", Options["--reffile"])
    MiscUtil.ValidateOptionFileExt("-r, --reffile", Options["--reffile"],
                                   "sdf sd mol")

    MiscUtil.ValidateOptionFilePath("-p, --probefile", Options["--probefile"])
    MiscUtil.ValidateOptionFileExt("-p, --probefile", Options["--probefile"],
                                   "sdf sd mol")

    MiscUtil.ValidateOptionFileExt("-o, --outfile", Options["--outfile"],
                                   "sd sdf")
    MiscUtil.ValidateOptionsOutputFileOverwrite("-o, --outfile",
                                                Options["--outfile"],
                                                "--overwrite",
                                                Options["--overwrite"])
    MiscUtil.ValidateOptionsDistinctFileNames("-r, --reffile",
                                              Options["--reffile"],
                                              "-o, --outfile",
                                              Options["--outfile"])
    MiscUtil.ValidateOptionsDistinctFileNames("-p, --probefile",
                                              Options["--probefile"],
                                              "-o, --outfile",
                                              Options["--outfile"])

    MiscUtil.ValidateOptionsDistinctFileNames("-r, --reffile",
                                              Options["--reffile"],
                                              "-o, --outfile",
                                              Options["--outfile"])
    MiscUtil.ValidateOptionsDistinctFileNames("-p, --probefile",
                                              Options["--probefile"],
                                              "-o, --outfile",
                                              Options["--outfile"])
def ValidateOptions():
    """Validate option values"""
    
    MiscUtil.ValidateOptionFilePath("-i, --infile", Options["--infile"])
    MiscUtil.ValidateOptionFileExt("-i, --infile", Options["--infile"], "sdf sd mol smi csv tsv txt")

    MiscUtil.ValidateOptionsOutputFileOverwrite("-o, --outfile", Options["--outfile"], "--overwrite", Options["--overwrite"])
    MiscUtil.ValidateOptionsDistinctFileNames("-i, --infile", Options["--infile"], "-o, --outfile", Options["--outfile"])
    
    if not re.match("^None$", Options["--alignmentSMARTS"], re.I):
        PatternMol = Chem.MolFromSmarts(Options["--alignmentSMARTS"])
        if PatternMol is None:
            MiscUtil.PrintError("The value specified, %s, using option \"--alignmentSMARTS\" is not a valid SMARTS: Failed to create pattern molecule" % Options["--alignmentSMARTS"])
    
    MiscUtil.ValidateOptionIntegerValue("--atomLabelFontSize", Options["--atomLabelFontSize"], {">": 0})
    MiscUtil.ValidateOptionFloatValue("-b, --bondLineWidth", Options["--bondLineWidth"], {">": 0.0})
    
    MiscUtil.ValidateOptionTextValue("--compute2DCoords", Options["--compute2DCoords"], "yes no auto")
    
    MiscUtil.ValidateOptionTextValue("--counterCol", Options["--counterCol"], "yes no")
    MiscUtil.ValidateOptionTextValue("--colVisibility", Options["--colVisibility"], "yes no")
    
    MiscUtil.ValidateOptionTextValue("--f, -fontBold", Options["--fontBold"], "yes no")
    
    if not re.match("^None$", Options["--highlightSMARTS"], re.I):
        PatternMol = Chem.MolFromSmarts(Options["--highlightSMARTS"])
        if PatternMol is None:
            MiscUtil.PrintError("The value specified, %s, using option \"--highlightSMARTS\" is not a valid SMARTS: Failed to create pattern molecule" % Options["--highlightSMARTS"])
    
    MiscUtil.ValidateOptionTextValue("--kekulize", Options["--kekulize"], "yes no")
    
    MiscUtil.ValidateOptionTextValue("-k, --keysNavigation", Options["--keysNavigation"], "yes no")
    
    MiscUtil.ValidateOptionNumberValues("-m, --molImageSize", Options["--molImageSize"], 2, ",", "integer", {">": 0})
    MiscUtil.ValidateOptionTextValue("--molImageEncoded", Options["--molImageEncoded"], "yes no")
    
    MiscUtil.ValidateOptionIntegerValue("--numOfMolsPerRow", Options["--numOfMolsPerRow"], {">": 0})
    
    MiscUtil.ValidateOptionTextValue("-p, --paging", Options["--paging"], "yes no")
    MiscUtil.ValidateOptionIntegerValue("--pageLength", Options["--pageLength"], {">": 0})
    
    MiscUtil.ValidateOptionTextValue("--popover", Options["--popover"], "yes no")
    MiscUtil.ValidateOptionIntegerValue("--popoverDataCount", Options["--popoverDataCount"], {">": 0})
    MiscUtil.ValidateOptionIntegerValue("--popoverTextWidth", Options["--popoverTextWidth"], {">": 0})
    
    MiscUtil.ValidateOptionTextValue("--showMolName", Options["--showMolName"], "yes no")
    
    MiscUtil.ValidateOptionTextValue("--scrollX", Options["--scrollX"], "yes no")
    MiscUtil.ValidateOptionTextValue("--scrollY", Options["--scrollY"], "yes no")
    if not re.search("vh$", Options["--scrollYSize"], re.I):
        MiscUtil.ValidateOptionIntegerValue("--scrollYSize", Options["--scrollYSize"], {">": 0})

    MiscUtil.ValidateOptionTextValue("--tableFooter", Options["--tableFooter"], "yes no")
    MiscUtil.ValidateOptionTextValue("--tableHeader", Options["--tableHeader"], "yes no")
Beispiel #18
0
def ProcessListFunctionalGroupsOption():
    """Process list functional groups information."""

    # Validate and process dataFile option for listing functional groups information...
    OptionsInfo["GroupNamesFile"] = None
    if not re.match("^auto$", Options["--groupNamesFile"], re.I):
        MiscUtil.ValidateOptionFilePath("-g, --groupNamesFile",
                                        Options["--groupNamesFile"])
        OptionsInfo["GroupNamesFile"] = Options["--groupNamesFile"]

    RetrieveFunctionalGroupsInfo()
    ListFunctionalGroupsInfo()
Beispiel #19
0
def ProcessListReactionNamesOption():
    """Process list reaction names information."""

    # Validate and process dataFile option for listing reaction names information...
    OptionsInfo["RxnNamesFile"] = None
    if not re.match("^auto$", Options["--rxnNamesFile"], re.I):
        MiscUtil.ValidateOptionFilePath("--rxnNamesFile",
                                        Options["--rxnNamesFile"])
        OptionsInfo["RxnNamesFile"] = Options["--rxnNamesFile"]

    RetrieveReactionNamesInfo()
    ListReactionNamesInfo()
Beispiel #20
0
def ValidateOptions():
    """Validate option values"""
    
    MiscUtil.ValidateOptionTextValue("Alignment", Options["--alignment"], "Open3A CrippenOpen3A")
    MiscUtil.ValidateOptionTextValue("Distance", Options["--distance"], "Tanimoto Protrude Both")
    
    MiscUtil.ValidateOptionIntegerValue("--maxIters", Options["--maxIters"], {">": 0})
    
    MiscUtil.ValidateOptionTextValue("--mode", Options["--mode"], "OneToOne  AllToAll FirstToAll")
    
    MiscUtil.ValidateOptionFilePath("-r, --reffile", Options["--reffile"])
    MiscUtil.ValidateOptionFileExt("-r, --reffile", Options["--reffile"], "sdf sd mol")
    
    MiscUtil.ValidateOptionFilePath("-p, --probefile", Options["--probefile"])
    MiscUtil.ValidateOptionFileExt("-p, --probefile", Options["--probefile"], "sdf sd mol")
    
    MiscUtil.ValidateOptionFileExt("-o, --outfile", Options["--outfile"], "csv tsv txt")
    MiscUtil.ValidateOptionsOutputFileOverwrite("-o, --outfile", Options["--outfile"], "--overwrite", Options["--overwrite"])
    
    MiscUtil.ValidateOptionsDistinctFileNames("-r, --reffile", Options["--reffile"], "-o, --outfile", Options["--outfile"])
    MiscUtil.ValidateOptionsDistinctFileNames("-p, --probefile", Options["--probefile"], "-o, --outfile", Options["--outfile"])
Beispiel #21
0
def ValidateOptions():
    """Validate option values"""

    MiscUtil.ValidateOptionTextValue("-a, --alignMethod",
                                     Options["--alignMethod"],
                                     "align cealign super")
    MiscUtil.ValidateOptionTextValue("--alignMode", Options["--alignMode"],
                                     "FirstChain Complex")

    MiscUtil.ValidateOptionTextValue("-m, --mode", Options["--mode"],
                                     "OneToOne AllToAll FirstToAll")

    # Expand reffiles to handle presence of multiple input files...
    RefFilesNames = MiscUtil.ExpandFileNames(Options["--reffiles"], ",")

    # Validate file extensions...
    for RefFile in RefFilesNames:
        MiscUtil.ValidateOptionFilePath("-r, --reffiles", RefFile)
        MiscUtil.ValidateOptionFileExt("-r, --reffiles", RefFile, "pdb cif")
    Options["--refFilesNames"] = RefFilesNames

    # Expand probefiles to handle presence of multiple input files...
    ProbeFilesNames = MiscUtil.ExpandFileNames(Options["--probefiles"], ",")

    # Validate file extensions...
    for ProbeFile in ProbeFilesNames:
        MiscUtil.ValidateOptionFilePath("-p, --probefiles", ProbeFile)
        MiscUtil.ValidateOptionFileExt("-p, --probefiles", ProbeFile,
                                       "pdb cif")
    Options["--probeFilesNames"] = ProbeFilesNames

    MiscUtil.ValidateOptionFileExt("-o, --outfile", Options["--outfile"],
                                   "csv tsv txt")
    MiscUtil.ValidateOptionsOutputFileOverwrite("-o, --outfile",
                                                Options["--outfile"],
                                                "--overwrite",
                                                Options["--overwrite"])

    MiscUtil.ValidateOptionTextValue("--outMatrix", Options["--outMatrix"],
                                     "Yes No")
def ValidateOptions():
    """Validate option values"""

    MiscUtil.ValidateOptionIntegerValue("--figDPI", Options["--figDPI"],
                                        {">": 0})
    if not re.match("^auto$", Options["--figSize"], re.I):
        MiscUtil.ValidateOptionNumberValues("--figSize", Options["--figSize"],
                                            2, ",", "float", {">": 0})

    MiscUtil.ValidateOptionFilePath("-i, --infile", Options["--infile"])
    MiscUtil.ValidateOptionFileExt("-i, --infile", Options["--infile"],
                                   "pdb cif")

    MiscUtil.ValidateOptionTextValue("-g, --greek", Options["--greek"],
                                     "yes no")

    MiscUtil.ValidateOptionTextValue("--grid", Options["--grid"], "yes no")
    MiscUtil.ValidateOptionFloatValue("--gridLineWidth",
                                      Options["--gridLineWidth"], {">": 0})

    MiscUtil.ValidateOptionTextValue(
        "--levelsAndColorsScheme", Options["--levelsAndColorsScheme"],
        "MuttedColorShades1 MuttedColorShades2 BrightColorShades")

    MiscUtil.ValidateOptionsOutputFileOverwrite("-o, --outfile",
                                                Options["--outfile"],
                                                "--overwrite",
                                                Options["--overwrite"])

    MiscUtil.ValidateOptionTextValue("--outMode", Options["--outMode"],
                                     "SingleFile MultipleFiles")
    MiscUtil.ValidateOptionIntegerValue("-p, --precision",
                                        Options["--precision"], {">": 0})

    MiscUtil.ValidateOptionFloatValue("--scatterMarkerSize",
                                      Options["--scatterMarkerSize"], {">": 0})

    if not re.match("^auto$", Options["--ticksMajorInterval"], re.I):
        MiscUtil.ValidateOptionIntegerValue("--ticksMajorInterval",
                                            Options["--ticksMajorInterval"], {
                                                ">": 0,
                                                "<": 360
                                            })

    MiscUtil.ValidateOptionTextValue("--ticksMinor", Options["--ticksMinor"],
                                     "yes no")
    if not re.match("^auto$", Options["--ticksMinorInterval"], re.I):
        MiscUtil.ValidateOptionIntegerValue("--ticksMinorInterval",
                                            Options["--ticksMinorInterval"], {
                                                ">": 0,
                                                "<": 360
                                            })
Beispiel #23
0
def ValidateOptions():
    """Validate option values"""

    MiscUtil.ValidateOptionFilePath("-i, --infile", Options["--infile"])
    MiscUtil.ValidateOptionFileExt("-i, --infile", Options["--infile"], "pdb cif")

    MiscUtil.ValidateOptionFileExt("-o, --outfile", Options["--outfile"], "csv tsv txt")
    MiscUtil.ValidateOptionsOutputFileOverwrite("-o, --outfile", Options["--outfile"], "--overwrite", Options["--overwrite"])
    
    MiscUtil.ValidateOptionTextValue("--outMode", Options["--outMode"], "SingleFile MultipleFiles")
    MiscUtil.ValidateOptionTextValue("--outChainID", Options["--outChainID"], "yes no")
    MiscUtil.ValidateOptionTextValue("--outCategory", Options["--outCategory"], "yes no")
    MiscUtil.ValidateOptionIntegerValue("-p, --precision", Options["--precision"], {">": 0})
def ValidateOptions():
    """Validate option values"""

    # Expand infile names..
    InfilesNames = MiscUtil.ExpandFileNames(Options["--infiles"], ",")

    # Validate file extensions...
    for Infile in InfilesNames:
        MiscUtil.ValidateOptionFilePath("-i, --infiles", Infile)
        MiscUtil.ValidateOptionFileExt("-i, --infiles", Infile, "pdb cif")
    Options["--infilesNames"] = InfilesNames

    MiscUtil.ValidateOptionFloatValue("--pocketDistanceCutoff",
                                      Options["--pocketDistanceCutoff"],
                                      {">": 0.0})
Beispiel #25
0
def ValidateOptions():
    """Validate option values"""

    MiscUtil.ValidateOptionFloatValue("-b, --butinaSimilarityCutoff",
                                      Options["--butinaSimilarityCutoff"], {
                                          ">": 0.0,
                                          "<=": 1.0
                                      })
    MiscUtil.ValidateOptionTextValue("--butinaReordering",
                                     Options["--butinaReordering"], "yes no")

    MiscUtil.ValidateOptionTextValue(
        "-c, --clusteringMethod", Options["--clusteringMethod"],
        "Butina Centroid CLink Gower McQuitty SLink UPGMA Ward")
    MiscUtil.ValidateOptionTextValue(
        "-f, --fingerprints", Options["--fingerprints"],
        "AtomPairs MACCS166Keys Morgan MorganFeatures PathLength TopologicalTorsions"
    )
    MiscUtil.ValidateOptionTextValue("--fingerprintsType",
                                     Options["--fingerprintsType"],
                                     "IntVect BitVect  auto")

    MiscUtil.ValidateOptionIntegerValue("-n, --numClusters",
                                        Options["--numClusters"], {">": 0})

    MiscUtil.ValidateOptionFilePath("-i, --infile", Options["--infile"])
    MiscUtil.ValidateOptionFileExt("-i, --infile", Options["--infile"],
                                   "sdf sd mol smi csv tsv txt")

    MiscUtil.ValidateOptionFileExt("-o, --outfile", Options["--outfile"],
                                   "sdf sd smi csv tsv txt")
    MiscUtil.ValidateOptionsOutputFileOverwrite("-o, --outfile",
                                                Options["--outfile"],
                                                "--overwrite",
                                                Options["--overwrite"])
    MiscUtil.ValidateOptionsDistinctFileNames("-i, --infile",
                                              Options["--infile"],
                                              "-o, --outfile",
                                              Options["--outfile"])

    MiscUtil.ValidateOptionTextValue("--outfileMode", Options["--outfileMode"],
                                     "SingleFile MultipleFiles")

    MiscUtil.ValidateOptionTextValue(
        "-s, --similarityMetric", Options["--similarityMetric"],
        "BraunBlanquet Cosine Dice Kulczynski RogotGoldberg Russel Sokal Tanimoto"
    )
def ValidateOptions():
    """Validate option values"""

    MiscUtil.ValidateOptionTextValue("--ligandFileFormat",
                                     Options["--ligandFileFormat"],
                                     "PDB SDF SD MDLMOL")

    MiscUtil.ValidateOptionTextValue("-m, --mode", Options["--mode"],
                                     "Chains ChainsLigands")

    MiscUtil.ValidateOptionFilePath("-i, --infile", Options["--infile"])
    MiscUtil.ValidateOptionFileExt("-i, --infile", Options["--infile"],
                                   "pdb cif")

    MiscUtil.ValidateOptionTextValue("--keepInorganics",
                                     Options["--keepInorganics"], "yes no")
    MiscUtil.ValidateOptionTextValue("--keepSolvents",
                                     Options["--keepSolvents"], "yes no")
Beispiel #27
0
def ValidateOptions():
    """Validate option values"""

    MiscUtil.ValidateOptionTextValue("-f, --feedback", Options["--feedback"],
                                     "yes no")

    MiscUtil.ValidateOptionFilePath("-i, --infile", Options["--infile"])
    MiscUtil.ValidateOptionFileExt("-i, --infile", Options["--infile"], "pml")

    MiscUtil.ValidateOptionFileExt("-o, --outfile", Options["--outfile"],
                                   "pse")
    MiscUtil.ValidateOptionsOutputFileOverwrite("-o, --outfile",
                                                Options["--outfile"],
                                                "--overwrite",
                                                Options["--overwrite"])
    MiscUtil.ValidateOptionsDistinctFileNames("-i, --infile",
                                              Options["--infile"],
                                              "-o, --outfile",
                                              Options["--outfile"])
def ValidateOptions():
    """Validate option values"""

    MiscUtil.ValidateOptionTextValue("-a, --addHydrogens",
                                     Options["--addHydrogens"], "yes no")
    MiscUtil.ValidateOptionTextValue("-c, --conformerGenerator",
                                     Options["--conformerGenerator"],
                                     "SDG ETDG KDG ETKDG None")
    MiscUtil.ValidateOptionTextValue("-f, --forceField",
                                     Options["--forceField"], "UFF MMFF")

    MiscUtil.ValidateOptionTextValue("--enforceChirality ",
                                     Options["--enforceChirality"], "yes no")

    MiscUtil.ValidateOptionFilePath("-i, --infile", Options["--infile"])
    MiscUtil.ValidateOptionFileExt("-i, --infile", Options["--infile"],
                                   "sdf sd mol smi txt csv tsv")

    MiscUtil.ValidateOptionFileExt("-o, --outfile", Options["--outfile"],
                                   "sdf sd")
    MiscUtil.ValidateOptionsOutputFileOverwrite("-o, --outfile",
                                                Options["--outfile"],
                                                "--overwrite",
                                                Options["--overwrite"])
    MiscUtil.ValidateOptionsDistinctFileNames("-i, --infile",
                                              Options["--infile"],
                                              "-o, --outfile",
                                              Options["--outfile"])

    MiscUtil.ValidateOptionIntegerValue("--maxConfs", Options["--maxConfs"],
                                        {">": 0})
    MiscUtil.ValidateOptionIntegerValue("--maxIters", Options["--maxIters"],
                                        {">": 0})

    if not re.match("^auto$", Options["--randomSeed"], re.I):
        MiscUtil.ValidateOptionIntegerValue("--randomSeed",
                                            Options["--randomSeed"], {})
        RandomSeed = int(Options["--randomSeed"])

    MiscUtil.ValidateOptionTextValue("-r, --removeHydrogens",
                                     Options["--removeHydrogens"], "yes no")
def ValidateOptions():
    """Validate option values"""

    MiscUtil.ValidateOptionFilePath("-i, --infile", Options["--infile"])
    MiscUtil.ValidateOptionFileExt("-i, --infile", Options["--infile"],
                                   "sdf sd smi txt csv tsv")
    if Options["--outfile"]:
        MiscUtil.ValidateOptionFileExt("-o, --outfile", Options["--outfile"],
                                       "sdf sd smi")
        MiscUtil.ValidateOptionsOutputFileOverwrite("-o, --outfile",
                                                    Options["--outfile"],
                                                    "--overwrite",
                                                    Options["--overwrite"])
        MiscUtil.ValidateOptionsDistinctFileNames("-i, --infile",
                                                  Options["--infile"],
                                                  "-o, --outfile",
                                                  Options["--outfile"])

    MiscUtil.ValidateOptionTextValue("--outfileFiltered",
                                     Options["--outfileFiltered"], "yes no")

    MiscUtil.ValidateOptionTextValue("-m, --mode", Options["--mode"],
                                     "retrieve count")
    if re.match("^retrieve$", Options["--mode"], re.I):
        if not Options["--outfile"]:
            MiscUtil.PrintError(
                "The outfile must be specified using \"-o, --outfile\" during \"retrieve\" value of \"-m, --mode\" option"
            )

    MiscUtil.ValidateOptionTextValue("--mp", Options["--mp"], "yes no")
    MiscUtil.ValidateOptionTextValue("-n, --negate", Options["--negate"],
                                     "yes no")

    PatternMol = Chem.MolFromSmarts(Options["--pattern"])
    if PatternMol is None:
        MiscUtil.PrintError(
            "The value specified, %s, using option \"-p, --pattern\" is not a valid SMARTS: Failed to create pattern molecule"
            % Options["--pattern"])

    MiscUtil.ValidateOptionTextValue("--useChirality",
                                     Options["--useChirality"], "yes no")
def ValidateOptions():
    """Validate option values"""

    MiscUtil.ValidateOptionTextValue("-c, --coreScaffold",
                                     Options["--coreScaffold"],
                                     "ByMCS BySMARTS BySMILES")

    MiscUtil.ValidateOptionFilePath("-i, --infile", Options["--infile"])
    MiscUtil.ValidateOptionFileExt("-i, --infile", Options["--infile"],
                                   "sdf sd mol smi csv tsv txt")

    MiscUtil.ValidateOptionFileExt("-o, --outfile", Options["--outfile"],
                                   "sdf sd csv tsv txt")
    MiscUtil.ValidateOptionsOutputFileOverwrite("-o, --outfile",
                                                Options["--outfile"],
                                                "--overwrite",
                                                Options["--overwrite"])
    MiscUtil.ValidateOptionsDistinctFileNames("-i, --infile",
                                              Options["--infile"],
                                              "-o, --outfile",
                                              Options["--outfile"])

    if re.match("^none$", Options["--smartsOrSmilesCoreScaffold"],
                re.I) or not len(Options["--smartsOrSmilesCoreScaffold"]):
        if re.match("^(BySMARTS|BySMILES)$", Options["--coreScaffold"], re.I):
            MiscUtil.PrintError(
                "A non empty value must be specified for \"-s, --smartsOrSmilesCoreScaffold\" during %s value of \"-c, --coreScaffold\" option "
                % (Options["--coreScaffold"]))
    else:
        if not re.match("^(BySMARTS|BySMILES)$", Options["--coreScaffold"],
                        re.I):
            MiscUtil.PrintError(
                "%s value of \"-s, --smartsOrSmilesCoreScaffold\" is not allowed during %s value of \"-c, --coreScaffold\" option "
                % (Options["--smartsOrSmilesCoreScaffold"],
                   Options["--coreScaffold"]))

    MiscUtil.ValidateOptionTextValue("-q, --quote", Options["--quote"],
                                     "yes no auto")
    MiscUtil.ValidateOptionTextValue("-r, --removeUnmatched",
                                     Options["--removeUnmatched"], "yes no")