rf-score-vs

#!/usr/bin/env python
# -*- coding: utf-8 -*-
import os
import sys
import six
import gzip
from os.path import isfile, abspath, dirname, join as path_join
import argparse
import joblib

from six.moves import cPickle

import oddt
from oddt.scoring import scorer

# FIX Windows multiprocessing
# Module multiprocessing is organized differently in Python 3.4+
try:
    # Python 3.4+
    if sys.platform.startswith('win'):
        import multiprocessing.popen_spawn_win32 as forking
    else:
        import multiprocessing.popen_fork as forking
except ImportError:
    import multiprocessing.forking as forking

if sys.platform.startswith('win'):
    # First define a modified version of Popen.
    class _Popen(forking.Popen):
        def __init__(self, *args, **kw):
            if hasattr(sys, 'frozen'):
                # We have to set original _MEIPASS2 value from sys._MEIPASS
                # to get --onefile mode working.
                os.putenv('_MEIPASS2', sys._MEIPASS)
            try:
                super(_Popen, self).__init__(*args, **kw)
            finally:
                if hasattr(sys, 'frozen'):
                    # On some platforms (e.g. AIX) 'os.unsetenv()' is not
                    # available. In those cases we cannot delete the variable
                    # but only set it to the empty string. The bootloader
                    # can handle this case.
                    if hasattr(os, 'unsetenv'):
                        os.unsetenv('_MEIPASS2')
                    else:
                        os.putenv('_MEIPASS2', '')

    # Second override 'Popen' class with our modified version.
    forking.Popen = _Popen
# END Fix Windows multiprocessing
import multiprocessing

__version__ = '1.0'

# arguments
parser = argparse.ArgumentParser(description='RF-Score-VS command line tools')

parser.add_argument('-n',
                    '--n_cpu',
                    dest='n_cpu',
                    type=int,
                    default=1,
                    help='The number of parallel processes. -1 automatically assigns maximum number of CPUs. (default=-1)')
parser.add_argument('--version', action='version', version='%(prog)s ' + __version__)

# in/out files and formats
parser.add_argument('in_file', nargs='+', help='Input files of formats supported by toolkit.')
parser.add_argument('-i',
                    choices=['sdf', 'mol2', 'pdb', 'pdbqt'],
                    dest='in_format',
                    help='Input file(s) format')
parser.add_argument('-o',
                    choices=['csv', 'sdf', 'mol2', 'pdb', 'pdbqt'],
                    dest='out_format', help='Output file format')
parser.add_argument('-O', '--output', dest='out_file', help='Output file')
parser.add_argument('--receptor', help='Protein file')

parser.add_argument('--field',
                    dest='save_fields',
                    action='append',
                    default=[],
                    help='Field to save (eg. in CSV). Each field should be specified separately.')


if __name__ == '__main__':
    multiprocessing.freeze_support()

    args = parser.parse_args()

    from oddt.virtualscreening import virtualscreening as vs

    # Create pipeline for docking and rescoring
    pipeline = vs(n_cpu=args.n_cpu if 'n_cpu' in args else 1)
    for f in args.in_file:
        if args.in_format:
            fmt = args.in_format
        else:  # autodiscover
            tmp = f.split('.')
            if tmp[-1] == 'gz':
                fmt = tmp[-2]
            else:
                fmt = tmp[-1]
        if isfile(f):
            pipeline.load_ligands(fmt, f)  # add loading ligands from STDIN?
        else:
            raise IOError("File does not exist: '%s'" % f)

    # load protein once
    if args.receptor:
        extension = args.receptor.split('.')[-1]
        receptor = six.next(oddt.toolkit.readfile(extension, args.receptor))
        if receptor:
            receptor.protein = True
        else:
            raise Exception("Could not parse receptor file")

    score_file = path_join(sys._MEIPASS if sys.frozen else dirname(abspath(__file__)), 'RFScoreVS_v2_vina.pickle')
    if isfile(score_file):  # load pickle
        sf = scorer.load(score_file)
        pipeline.score(sf, receptor)
    else:
        raise IOError('Could not read pickle file %s' % score_file)

    # Write to file or STDOUT
    if args.out_file:
        if args.out_format:
            fmt = args.out_format
        else:  # autodiscover
            tmp = args.out_file.split('.')
            if tmp[-1] == 'gz':
                fmt = tmp[-2]
            else:
                fmt = tmp[-1]
        if not fmt:
            raise ValueError('No output format nor output file specified.')
        if fmt == 'csv':
            pipeline.write_csv(args.out_file, fields=args.save_fields)
        else:
            pipeline.write(fmt, args.out_file, overwrite=True)
    else:
        fmt = args.out_format
        if not fmt:
            raise ValueError('No output format nor output file specified.')
        if fmt == 'csv':
            pipeline.write_csv(sys.stdout, fields=args.save_fields)
        else:
            for lig in pipeline.fetch():
                sys.stdout.write(lig.write(fmt))