示例#1
0
    def download(self, synid):
        """Download a file into the dreamtools directory

        :param synid: a valid synapse id (e.g., syn123456)

        You must have a login on synapse website.
        """
        # If not connected, nothing will be possible, so just skip the download
        # step.
        if self.client._connected is False:
            print(
                red("You do not seem to have a network connection. ") +
                red("Downloading required data is not possible"))
            sys.exit(1)

        assert synid.startswith('syn'), \
                "synid must be a valid synapse identifier e.g., syn123456"

        try:
            self.client.get(synid, downloadLocation=self.directory)
        except Exception as err:
            print('Original error message from synapseclient:')
            print(err)
            print(
                "DREAMTools warning: this is most probably a file that requires you to accept the conditions of use of the data. We will open the relevant page for you now. Please click 'show; on the RHS of the Conditions of use and Accept the terms of use"
            )
            sys.exit()
示例#2
0
    def download(self, synid):
        """Download a file into the dreamtools directory

        :param synid: a valid synapse id (e.g., syn123456)

        You must have a login on synapse website.
        """
        # If not connected, nothing will be possible, so just skip the download
        # step.
        if self.client._connected is False:
            print(red("You do not seem to have a network connection. ") + 
                red("Downloading required data is not possible"))
            sys.exit(1)

        assert synid.startswith('syn'), \
                "synid must be a valid synapse identifier e.g., syn123456"


        try:
            self.client.get(synid, downloadLocation=self.directory)
        except Exception as err:
            print('Original error message from synapseclient:')
            print(err)
            print("DREAMTools warning: this is most probably a file that requires you to accept the conditions of use of the data. We will open the relevant page for you now. Please click 'show; on the RHS of the Conditions of use and Accept the terms of use")
            sys.exit()
示例#3
0
def anova_one_drug_one_feature(anova, options):
    """Analyse the entire data set"""
    from gdsctools import anova_report

    if options.tissue is not None:
        anova.set_cancer_type(options.tissue)

    odof = anova_report.Association(anova,
                                    drug=options.drug,
                                    feature=options.feature)

    #print(odof.settings)
    # for the HTML
    #odof.add_dependencies = True
    #odof.add_settings = True

    df = odof.run()

    if df.ix[1]['FEATURE_IC50_effect_size'] is None:
        msg = "association %s vs %s not valid for testing (not enough" +\
              " MSI or positives for that features ? Try with "+\
              " --exclude-msi (you must then set a tissue with "+\
              " --tissue"
        print(red(msg % (options.drug, options.feature)))
    else:
        print(df.T)
        # HTML report
        if options.no_html is True:
            return
        odof.create_report(onweb=options.onweb)
示例#4
0
def anova_one_drug_one_feature(anova, options):
    """Analyse the entire data set"""

    from gdsctools import anova_report
    from gdsctools.report import ReportMain

    if options.tissue is not None:
        anova.set_cancer_type(options.tissue)

    # just to create the directory
    ReportMain(directory=options.directory)

    odof = anova_report.Association(anova,
                                    drug=int(options.drug),
                                    feature=options.feature)
    odof.add_href = False
    df = odof.run()

    if df.loc[1]['FEATURE_IC50_effect_size'] is None:
        msg = "association %s vs %s not valid for testing (not enough" +\
              " MSI or positives for that features ? Try with "+\
              " --exclude-msi (you must then set a tissue with "+\
              " --tissue"
        print(red(msg % (options.drug, options.feature)))
    else:
        print(df.T)
        # HTML report
        if options.no_html is True:
            return
        odof.create_report(onweb=options.onweb)
示例#5
0
def anova_one_drug_one_feature(anova, options):
    """Analyse the entire data set"""
    from gdsctools import anova_report

    if options.tissue is not None:
        anova.set_cancer_type(options.tissue)

    odof = anova_report.Association(anova,
            drug=options.drug,
            feature=options.feature)

    #print(odof.settings)
    # for the HTML
    #odof.add_dependencies = True
    #odof.add_settings = True

    df = odof.run()

    if df.ix[1]['FEATURE_IC50_effect_size'] is None:
        msg = "association %s vs %s not valid for testing (not enough" +\
              " MSI or positives for that features ? Try with "+\
              " --exclude-msi (you must then set a tissue with "+\
              " --tissue"
        print(red(msg % (options.drug, options.feature)))
    else:
        print(df.T)
        # HTML report
        if options.no_html is True:
            return
        odof.create_report(onweb=options.onweb)
示例#6
0
def standalone(args=None):
    """This function is used by the standalone application called cellnopt_boolean

    ::

        cno_milp --help

    """
    if args is None:
        args = sys.argv[:]

    user_options = OptionsMILP()

    if len(args) == 1:
        user_options.parse_args(["prog", "--help"])
    else:
        options = user_options.parse_args(args[1:])

    if options.onweb is True or options.report is True:
        o = MILPTrain(options.pknmodel, options.data, verbose=options.verbose
             )

    if options.onweb is True:
        o.optimise()
        o.onweb()
    elif options.report is True:
        o.optimise()
        o.report()
    else:
        from easydev.console import red
        print(red("No report requested; nothing will be saved or shown"))
        print("use --on-web or --report options")
示例#7
0
def anova_one_drug(anova, options):
    """Analyse one specific drug"""
    from gdsctools import ANOVAReport
    anova.set_cancer_type(options.tissue)
    
    if options.feature:
        anova.feature_names = options.features

    results = anova.anova_one_drug(options.drug)

    print("\nFound %s associations" % len(results))
    if len(results)==0:
        print(red("\nPlease try with another drug or no --drug option"))
        return

    # ?? is this required ?
    N = len(results)
    results.df.insert(0, 'ASSOC_ID', range(1, N+1))

    if options.no_html is True:
        return

    r = ANOVAReport(anova, results=results)
    print(darkgreen("\nCreating all figure and html documents in %s" %
            r.settings.directory))
    r.create_html_pages(onweb=options.onweb)
示例#8
0
def anova_one_drug(anova, options):
    """Analyse one specific drug"""
    from gdsctools import ANOVAReport
    anova.set_cancer_type(options.tissue)

    if options.feature:
        anova.feature_names = options.features

    results = anova.anova_one_drug(options.drug)

    print("\nFound %s associations" % len(results))
    if len(results) == 0:
        print(red("\nPlease try with another drug or no --drug option"))
        return

    # ?? is this required ?
    N = len(results)
    results.df.insert(0, 'ASSOC_ID', range(1, N + 1))

    if options.no_html is True:
        return

    r = ANOVAReport(anova, results=results)
    print(
        darkgreen("\nCreating all figure and html documents in %s" %
                  r.settings.directory))
    r.create_html_pages(onweb=options.onweb)
示例#9
0
 def report(self):
     """Create report and shows report (or not)"""
     if self.options.onweb is True:
         self.trainer.report(show=True)
     elif self.options.report is True:
         self.trainer.report(show=False)
     else:
         from easydev.console import red
         print(red("No report requested; nothing will be saved or shown"))
         print("use --on-web or --report options")
示例#10
0
    def create_summary_pages(self):
        """Create summary pages

        Once the main analyis is done (:meth:`analyse`), and the company
        packages have been created (:meth:`create_data_packages_for_companies`),
        you can run this method that will creade a summary HTML page
        (index.html) for the tissue, and a similar summary HTML page for the
        tissues of each company. Finally, an HTML summary page for the 
        companies is also created.

        The final tree direcorty looks like::


            |-- index.html
            |-- company_packages
            |   |-- index.html
            |   |-- Company1
            |   |   |-- Tissue1
            |   |   |-- Tissue2
            |   |   |-- index.html
            |   |-- Company2
            |   |   |-- Tissue1
            |   |   |-- Tissue2
            |   |   |-- index.html
            |-- tissue_packages
            |   |-- index.html
            |   |-- Tissue1
            |   |-- Tissue2


        """
        # First for the main directory (tissue_packages):
        print(purple("Creating summary index.html for the tissues"))
        self._create_summary_pages(self.main_directory, verbose=False)

        # Then for each companies:
        print(purple("Creating summary index.html for each company"))
        pb = Progress(len(self.companies))
        for i, company in enumerate(self.companies):
            try:
                self._create_summary_pages(self.company_directory + os.sep +
                                           company,
                                           verbose=False,
                                           company=company)
            except Exception as err:
                print(
                    red("Issue with %s. Continue with other companies" %
                        company))
                print(err)
            pb.animate(i + 1)

        # Finally, an index towards each company
        self._create_main_index()
示例#11
0
    def create_summary_pages(self):
        """Create summary pages

        Once the main analyis is done (:meth:`analyse`), and the company
        packages have been created (:meth:`create_data_packages_for_companies`),
        you can run this method that will creade a summary HTML page
        (index.html) for the tissue, and a similar summary HTML page for the
        tissues of each company. Finally, an HTML summary page for the 
        companies is also created.

        The final tree direcorty looks like::


            |-- index.html
            |-- company_packages
            |   |-- index.html
            |   |-- Company1
            |   |   |-- Tissue1
            |   |   |-- Tissue2
            |   |   |-- index.html
            |   |-- Company2
            |   |   |-- Tissue1
            |   |   |-- Tissue2
            |   |   |-- index.html
            |-- tissue_packages
            |   |-- index.html
            |   |-- Tissue1
            |   |-- Tissue2


        """
        # First for the main directory (tissue_packages):
        print(purple("Creating summary index.html for the tissues"))
        self._create_summary_pages(self.main_directory, verbose=False)

        # Then for each companies:
        print(purple("Creating summary index.html for each company"))
        pb = Progress(len(self.companies))
        for i, company in enumerate(self.companies):
            try:
                self._create_summary_pages(self.company_directory + os.sep +
                    company, verbose=False, company=company)
            except Exception as err:
                print(red("Issue with %s. Continue with other companies" % company))
                print(err)
            pb.animate(i+1)

        # Finally, an index towards each company
        self._create_main_index()
示例#12
0
def sequana_init(options):
    import sequana
    from sequana.misc import textwrap
    from sequana import SequanaConfig, sequana_data
    sa = Tools(verbose=options.verbose)

    # Check that the pipeline is well defined
    module = Module(options.pipeline)

    if os.path.exists(options.target_dir):
        txt = "Will override the following files if present: %s.rules " +\
              "config.yaml, runme.sh, ..."
        sa.blue(txt % options.pipeline)

        if options.force is True:
            choice = "y"
        else:
            choice = input(
                red("Do you want to proceed (to avoid this " +
                    " message, use --force)? [y]/n:"))
        if choice == "n":
            sys.exit(0)

    # Copying snakefile
    logger.info("Copying snakefile")
    sa.mkdir(options.target_dir)
    shutil.copy(module.snakefile,
                options.target_dir + os.sep + options.pipeline + ".rules")

    # Creating README to print on the screen and in a file
    txt = "User command::\n\n"
    txt += "    %s \n\n" % " ".join(sys.argv)
    txt += "You can now run snakemake yourself or type::"
    txt += purple("""

    snakemake -s %s.rules --stats stats.txt -p -j 4

    """ % options.pipeline)
    txt += """
    # -j 4 means you will use 4 cores
    # -p prints the commands used
    # --stats stats.txt must be used since stats.txt is expected to be found.

    or just run the bash script::

        sh runme.sh

    EDIT THE config.yaml if needed

    Once finished with success, the report/ directory contains a summary.html
    and relevant files (depends on the pipeline).
    """
    logger.info("Creating README")
    with open(options.target_dir + os.sep + "README", "w") as fh:
        fh.write(txt.replace("\x1b[35m", "").replace("\x1b[39;49;00m", ""))

    # Creating Config file
    logger.info("Creating the config file")

    # Create (if needed) and update the config file
    config_filename = options.target_dir + os.sep + "config.yaml"

    if options.config:
        # full existing path
        if os.path.exists(options.config):
            shutil.copy(options.config, config_filename)
        else:  # or a sequana config file in the module path ?
            raise (IOError("Config file %s not found locally" %
                           options.config))
    else:
        copy_config_from_sequana(module, "config.yaml", config_filename)

    # Copy multiqc if it is available
    multiqc_filename = options.target_dir + os.sep + "multiqc_config.yaml"
    copy_config_from_sequana(module, "multiqc_config.yaml", multiqc_filename)
    cluster_cfg_filename = options.target_dir + os.sep + "cluster_config.json"
    copy_config_from_sequana(module, "cluster_config.json",
                             cluster_cfg_filename)

    # The input
    cfg = SequanaConfig(config_filename)
    cfg.config.input_directory = options.input_directory
    cfg.config.input_pattern = options.pattern
    cfg.config.input_extension = options.extension
    cfg.config.input_samples.file1 = options.file1
    cfg.config.input_samples.file2 = options.file2
    cfg.config.input_readtag = options.input_readtag

    # Dedicated section for quality control section
    if options.pipeline == "quality_control":
        if options.design:
            shutil.copy(options.design, options.target_dir + os.sep)
            cfg.config['cutadapt'].design_file = os.path.basename(
                options.design)

        if options.kraken:
            cfg.config.kraken.database_directory = os.path.abspath(
                options.kraken)
            cfg.config.kraken.do = True
        else:
            cfg.config.kraken.do = False

        cfg.config['cutadapt'].fwd = options.adapter_fwd
        cfg.config['cutadapt'].rev = options.adapter_rev
        cfg.config['cutadapt'].adapter_type = options.adapters
        # Foir all pipeline using BWA
        if options.reference:
            cfg.config.bwa_mem.reference = os.path.abspath(options.reference)
    if options.pipeline == "variant_calling":
        if options.reference:
            cfg.config.bwa_mem_ref.reference = os.path.abspath(
                options.reference)

    if options.pipeline in ["rnaseq", "smallrnaseq"]:
        if options.design:
            shutil.copy(options.design, options.target_dir + os.sep)
            cfg.config['cutadapt'].design_file = os.path.basename(
                options.design)
        cfg.config['cutadapt'].fwd = options.adapter_fwd
        cfg.config['cutadapt'].rev = options.adapter_rev
        cfg.config['cutadapt'].adapter_choice = options.adapters

    cfg.copy_requirements(target=options.target_dir)

    # FIXME If invalid, no error raised
    if options.config_params:
        params = [this.strip() for this in options.config_params.split(",")]
        for param in params:
            if param.count(":") not in [1, 2, 3]:
                txt = "incorrect format following --config-params"
                txt += "Expected at least one : sign or at most 2 of them"
                txt += "Config file section such as :\n"
                txt += "project: tutorial\n"
                txt += "should be encoded project:tutorial"
                raise ValueError(txt)
            if param.count(":") == 1:
                k, v = param.split(':')
                cfg.config[k] = v
            elif param.count(":") == 2:
                k1, k2, v = param.split(":")
                cfg.config[k1][k2] = v
            elif param.count(":") == 3:
                k1, k2, k3, v = param.split(":")
                cfg.config[k1][k2][k3] = v

    # important to update yaml with content of config
    cfg._update_yaml()
    cfg.save(config_filename)

    # Creating a unique runme.sh file
    runme_filename = options.target_dir + os.sep + "runme.sh"
    with open(runme_filename, "w") as fout:
        cmd = "#!/bin/sh\n"
        cmd += "# generated with sequana version %s with this command:\n" % sequana.version
        cmd += "# %s\n" % " ".join(sys.argv)
        cmd += "snakemake -s %(project)s.rules --stats stats.txt -p -j %(jobs)s --nolock"
        if options.forceall:
            cmd += " --forceall "

        if options.cluster:
            # Do we want to include the cluster config option ?
            cluster_config = Module(options.pipeline).cluster_config
            if options.ignore_cluster_config is True:
                cluster_config = None

            if cluster_config is None:
                cmd += ' --cluster "%s"' % options.cluster
            else:
                cmd += ' --cluster "%s"  --cluster-config %s' %\
                    (options.cluster, os.path.basename(cluster_config))

        if options.redirection:
            cmd += " 1>run.out 2>run.err"
        fout.write(
            cmd % {
                'project': options.pipeline,
                'jobs': options.jobs,
                "version": sequana.version
            })
    # change permission of runme.sh to 755
    st = os.stat(runme_filename)
    os.chmod(runme_filename, st.st_mode | 0o755)

    sa.green("Initialisation of %s succeeded" % options.target_dir)
    sa.green("Please, go to the project directory ")
    sa.purple("\n   cd %s\n" % options.target_dir)
    sa.green("Check out the README and config.yaml files")
    sa.green("A basic script to run the analysis is named runme.sh ")
    sa.purple("\n    sh runme.sh\n")
    sa.purple("On a slurm cluster, you may type:")
    sa.purple("\n  srun --qos normal runme.sh\n")
    sa.green(
        "In case of trouble, please post an issue on https://github.com/sequana/sequana/issue "
    )
    sa.green(
        "or type sequana --issue and fill a post with the error and the config file (NO DATA PLEASE)"
    )

    # Change permission
    try:  #python 3
        os.chmod(runme_filename, 0o755)
    except:
        logger.info(
            "Please use Python3. Change the mode of %s manually to 755" %
            runme_filename)
示例#13
0
 def red(self, txt, force=False):
     if self.verbose or force is True:
         print(red(txt))
    def run(self, color=True):
        """Executes 'python setup.py' with the user commands on all packages. """
        if color:
            try:
                from easydev.console import bold, red, green, \
                    color_terminal, nocolor, underline, purple
            except:
                try:
                    sys.path.insert(0, os.path.join('deploy', 'src', 'deploy'))
                    from console import bold, red, green, \
                        color_terminal, nocolor, underline, purple
                except:
                    pass
            if not color_terminal():
                # Windows' poor cmd box doesn't understand ANSI sequences
                nocolor()
        else:
            bold = purple = red = green = underline = str

        print(bold("Running multisetup version %s" % __revision__.split()[2]))

        #project_dir = self.curdir.basename()
        directories = [package for package in self.packages]

        print('Will process the following directories: ', )
        for directory in directories:
            print(bold(directory)),
            #print bold(directory.basename()),
        print('')

        try:
            for directory in directories:
                try:
                    os.chdir(directory)
                    print(
                        underline('Entering %s package' %
                                  os.path.basename(directory)))
                    #          % directory.basename())
                except OSError as err:
                    print(
                        underline('Entering %s package' %
                                  os.path.basename(directory)))
                    print(
                        red("cannot find this directory (%s)" %
                            os.path.basename(directory)))
                    print(err)

                print('Python exec : ', sys.executable)

                #print underline('Entering %s package' % directory.basename())
                for cmd in self.commands:
                    setup_command = '%s setup.py %s ' % (sys.executable, cmd)
                    print("\tExecuting " + setup_command + '...processing', )

                    #Run setup.py with user commands
                    outputs = None
                    errors = None
                    if self.verbose:
                        process = Popen(setup_command, shell=True)
                        status = process.wait()
                    else:
                        process = Popen(setup_command,
                                        stdout=PIPE,
                                        stderr=PIPE,
                                        shell=True)
                        #status = process.wait()
                        outputs, errors = process.communicate()
                    if process.returncode == 0:
                        print(green('done'))
                    else:
                        if not self.verbose:
                            print(
                                red('\tFailed. ( error code %s) ' %
                                    (process.returncode)))
                            os.chdir(self.curdir)

                        if not self.force:
                            raise RuntimeError()

                    if 'pylint' in cmd:
                        if outputs is not None:
                            for x in outputs.split('\n'):
                                if x.startswith('Your code has been'):
                                    print(purple('\t%s' % x))
                    if 'nosetests' in cmd:
                        if errors is not None:
                            for x in errors.split('\n'):
                                if x.startswith('TOTAL'):
                                    res = x.replace('TOTAL', 'Total coverage')
                                    res = " ".join(res.split())
                                    print(purple('\t%s' % res))
                                if x.startswith('Ran'):
                                    print(purple('\t%s' % x))
                                if x.startswith('FAILED'):
                                    print(purple('\t%s' % x))
                        else:
                            print(purple('all right'))

                os.chdir(self.curdir)

        except RuntimeError:
            sys.exit()

        os.chdir(self.curdir)
示例#15
0
def anova_pipeline(args=None):
    """This function is used by the standalone application called
    **gdsctools_anova**

    Type::

        gdsctools_anova --help

    to get some help.
    """
    msg = "Welcome to GDSCTools standalone"
    print_color(msg, purple, underline=True)

    # Keep the argument args as None by default to
    # allow testing e.g., in nosetests
    if args is None:
        args = sys.argv[:]
    elif len(args) == 1:
        args += ['--help']

    user_options = ANOVAOptions(prog="gdsctools_anova")
    try:
        options = user_options.parse_args(args[1:])
    except SystemExit:
        return

    # -----------------------------------------------------------------
    # ---------------------------------------- options without analysis
    # -----------------------------------------------------------------

    if options.version is True:
        print("This is version %s of gdsctools_anova" % gdsctools.version)
        return

    if options.testing is True:
        print('Testing mode:')
        from gdsctools import ANOVA, ic50_test
        an = ANOVA(ic50_test)
        df = an.anova_one_drug_one_feature('Drug_1047_IC50', 'TP53_mut')

        assert df.loc[1,'N_FEATURE_pos'] == 554, \
            "N_feature_pos must be equal to 554"
        print(df.T)
        print(darkgreen("\nGDSCTools seems to be installed properly"))
        return

    if options.save_settings:
        from gdsctools import ANOVA, ic50_test
        an = ANOVA(ic50_test)
        an.settings.to_json(options.save_settings)
        print('Save a default parameter set in %s' % options.save_settings)
        return

    if options.license is True:
        print(gdsctools.license)
        return

    if options.summary is True:
        from gdsctools import anova
        an = anova.ANOVA(options.input_ic50, options.input_features)
        print(an)
        return

    if options.print_tissues is True:
        from gdsctools import anova
        an = anova.ANOVA(options.input_ic50, options.input_features)

        tissues = an.tissue_factor
        try:
            tissues = tissues.sort_values('Tissue Factor').unique()
        except:
            tissues = tissues.sort(inplace=False).unique()
        for name in tissues:
            print(name)
        return

    if options.print_drugs is True:
        from gdsctools import anova
        gdsc = anova.ANOVA(options.input_ic50, options.input_features)
        import textwrap
        print("\n".join(textwrap.wrap(" , ".join(gdsc.drugIds))))
        return

    if options.print_features is True:
        from gdsctools import anova
        gdsc = anova.ANOVA(options.input_ic50, options.input_features)
        import textwrap
        print("\n".join(textwrap.wrap(" , ".join(gdsc.feature_names))))
        return

    # -----------------------------------------------------------------
    # --------------------------------------------------- real analysis
    # -----------------------------------------------------------------
    # dispatcher to the functions according to the user parameters

    from gdsctools import ANOVA, ANOVAReport
    anova = ANOVA(options.input_ic50,
                  options.input_features,
                  options.input_drug,
                  low_memory=not options.fast)
    anova = _set_settings(anova, options)

    if options.drug and options.drug not in anova.ic50.df.columns:
        print(red("Invalid Drug. Try --print-drug-names"))
        sys.exit(1)

    if options.drug is not None and options.feature is not None:
        print_color("ODOF mode", purple)
        anova_one_drug_one_feature(anova, options)
    elif options.drug is not None:
        print_color("ODAF mode", purple)
        anova_one_drug(anova, options)
    else:  # analyse everything
        if options.feature is None:
            print_color("ADAF mode", purple)
        else:
            print_color("ADOF mode", purple)
        anova_all(anova, options)

    if options.onweb is False and options.no_html is False:
        msg = "\nNote that a directory {} was created and files saved into it"
        print(purple(msg.format(options.directory)))

    return
示例#16
0
def anova_pipeline(args=None):
    """This function is used by the standalone application called
    **gdsctools_anova**

    Type::

        gdsctools_anova --help

    to get some help.
    """
    msg = "Welcome to GDSCTools standalone"
    print_color(msg, purple, underline=True)

    # Keep the argument args as None by default to
    # allow testing e.g., in nosetests
    if args is None:
        args = sys.argv[:]
    elif len(args) == 1:
        args += ['--help']

    user_options = ANOVAOptions(prog="gdsctools_anova")
    try:
        options = user_options.parse_args(args[1:])
    except SystemExit:
        return

    # -----------------------------------------------------------------
    # ---------------------------------------- options without analysis
    # -----------------------------------------------------------------

    if options.version is True:
        print("This is version %s of gdsctools_anova" % gdsctools.version)
        return

    if options.testing is True:
        print('Testing mode:')
        from gdsctools import ANOVA, ic50_test
        an = ANOVA(ic50_test)
        df = an.anova_one_drug_one_feature('Drug_1047_IC50', 'TP53_mut')

        assert df.loc[1,'N_FEATURE_pos'] == 554, \
            "N_feature_pos must be equal to 554"
        print(df.T)
        print(darkgreen("\nGDSCTools seems to be installed properly"))
        return

    if options.save_settings:
        from gdsctools import ANOVA, ic50_test
        an = ANOVA(ic50_test)
        an.settings.to_json(options.save_settings)
        print('Save a default parameter set in %s' % options.save_settings)
        return 

    if options.license is True:
        print(gdsctools.license)
        return

    if options.summary is True:
        from gdsctools import anova
        an = anova.ANOVA(options.input_ic50, options.input_features)
        print(an)
        return


    if options.print_tissues is True:
        from gdsctools import anova
        an = anova.ANOVA(options.input_ic50, options.input_features)

        tissues = an.tissue_factor
        try:
            tissues = tissues.sort_values('Tissue Factor').unique()
        except:
            tissues = tissues.sort(inplace=False).unique()
        for name in tissues:
            print(name)
        return

    if options.print_drugs is True:
        from gdsctools import anova
        gdsc = anova.ANOVA(options.input_ic50, options.input_features)
        import textwrap
        print("\n".join(textwrap.wrap(" , ".join(gdsc.drugIds))))
        return

    if options.print_features is True:
        from gdsctools import anova
        gdsc = anova.ANOVA(options.input_ic50, options.input_features)
        import textwrap
        print("\n".join(textwrap.wrap(" , ".join(gdsc.feature_names))))
        return

    # -----------------------------------------------------------------
    # --------------------------------------------------- real analysis
    # -----------------------------------------------------------------
    # dispatcher to the functions according to the user parameters


    from gdsctools import ANOVA, ANOVAReport
    anova = ANOVA(options.input_ic50, options.input_features,
            options.input_drug,
            low_memory=not options.fast)
    anova = _set_settings(anova, options)


    if options.drug and options.drug not in anova.ic50.df.columns:
        print(red("Invalid Drug. Try --print-drug-names"))
        sys.exit(1)


    if options.drug is not None and options.feature is not None:
        print_color("ODOF mode", purple)
        anova_one_drug_one_feature(anova, options)
    elif options.drug is not None:
        print_color("ODAF mode", purple)
        anova_one_drug(anova, options)
    else: # analyse everything
        if options.feature is None:
            print_color("ADAF mode", purple)
        else:
            print_color("ADOF mode", purple)
        anova_all(anova, options)

    if options.onweb is False and options.no_html is False:
        msg = "\nNote that a directory {} was created and files saved into it"
        print(purple(msg.format(options.directory)))

    return
示例#17
0
    def run(self, color=True):
        """Executes 'python setup.py' with the user commands on all packages. """
        if color:
            try:
                from easydev.console import bold, red, green, \
                    color_terminal, nocolor, underline, purple
            except:
                try:
                    sys.path.insert(0, os.path.join('deploy', 'src',  'deploy'))
                    from console import bold, red, green, \
                        color_terminal, nocolor, underline, purple
                except:
                    pass
            if not color_terminal():
                # Windows' poor cmd box doesn't understand ANSI sequences
                nocolor()
        else:
            bold = purple = red = green = underline = str

        print(bold("Running multisetup version %s" % __revision__.split()[2]))

        #project_dir = self.curdir.basename()
        directories = [package for package in self.packages]


        print('Will process the following directories: ',)
        for directory in directories:
            print(bold(directory)),
            #print bold(directory.basename()),
        print('')


        try:
            for directory in directories:
                try:
                    os.chdir(directory)
                    print(underline('Entering %s package'
                          % os.path.basename(directory)))
                          #          % directory.basename())
                except OSError as err:
                    print(underline('Entering %s package'
                              % os.path.basename(directory)))
                    print(red("cannot find this directory (%s)"
                              % os.path.basename(directory)))
                    print(err)

                print('Python exec : ' , sys.executable)

                #print underline('Entering %s package' % directory.basename())
                for cmd in self.commands:
                    setup_command = '%s setup.py %s ' % (sys.executable,cmd)
                    print("\tExecuting " + setup_command + '...processing',)


                    #Run setup.py with user commands
                    outputs = None
                    errors = None
                    if self.verbose:
                        process = Popen(setup_command,
                                        shell=True)
                        status = process.wait()
                    else:
                        process = Popen(setup_command, stdout=PIPE, stderr=PIPE,
                                        shell=True)
                        #status = process.wait()
                        outputs, errors = process.communicate()
                    if process.returncode == 0:
                        print(green('done'))
                    else:
                        if not self.verbose:
                            print(red('\tFailed. ( error code %s) ' %
                                  (process.returncode)))
                            os.chdir(self.curdir)

                        if not self.force:
                            raise RuntimeError()

                    if 'pylint' in cmd:
                        if outputs is not None:
                            for x in outputs.split('\n'):
                                if x.startswith('Your code has been'):
                                    print(purple('\t%s' % x))
                    if 'nosetests' in cmd:
                        if errors is not None:
                            for x in errors.split('\n'):
                                if x.startswith('TOTAL'):
                                    res = x.replace('TOTAL', 'Total coverage')
                                    res = " ".join (res.split())
                                    print(purple('\t%s' % res))
                                if x.startswith('Ran'):
                                    print(purple('\t%s' % x))
                                if x.startswith('FAILED'):
                                    print(purple('\t%s' % x))
                        else:
                            print(purple('all right'))

                os.chdir(self.curdir)

        except RuntimeError:
            sys.exit()

        os.chdir(self.curdir)