comparison toolfactory/ToolFactory_tester.xml @ 6:efefe43f23c8 draft default tip

Uploaded

5:e2c8c2fa192d

  <stdio>
    <exit_code range="1:" level="fatal"/>
  </stdio>
  <version_command><![CDATA[echo "1"]]></version_command>
  <command><![CDATA[
python
$runme
--in_tool_archive
$in_tool_archive
--new_tested_tool_archive
$new_tested_tool_archive
--galaxy_root
"$galaxyroot"
>
$tf_archive_tester_log;
]]></command>
  <configfiles>
    <configfile name="runme"><![CDATA[#raw

# see https://github.com/fubar2/toolfactory

def timenow():
    """return current time as a string"""
    return time.strftime("%d/%m/%Y %H:%M:%S", time.localtime(time.time()))

class ToolTester():
    # requires highly insecure docker settings - like write to tool_conf.xml and to tools !
    # if in a container possibly not so courageous.
    # Fine on your own laptop but security red flag for most production instances
    # uncompress passed tar, run planemo and rebuild a new tarball with tests

    def __init__(self, args=None, in_tool_archive='/galaxy-central/tools/newtool/newtool_toolshed.gz', new_tool_archive=None):
        self.args = args
        self.new_tool_archive = new_tool_archive

        self.moveRunOutputs()
        self.makeToolTar()

    def call_planemo(self,xmlpath,ourdir):
        penv = os.environ
        #penv['HOME'] = os.path.join(self.args.galaxy_root,'planemo')
        #penv["GALAXY_VIRTUAL_ENV"] = os.path.join(penv['HOME'],'.planemo','gx_venv_3.9')
        penv["PIP_CACHE_DIR"] = os.path.join(self.args.galaxy_root,'pipcache')
        toolfile = os.path.split(xmlpath)[1]
        tool_name = self.tool_name
        tool_test_output = f"{tool_name}_planemo_test_report.html"
        cll = [
            "planemo",
            "test",
            "--biocontainers",
            "--test_output",
            os.path.abspath(tool_test_output),
            "--galaxy_root",
            self.args.galaxy_root,
            "--update_test_data",
            os.path.abspath(xmlpath),
        ]
        print(cll)
        p = subprocess.run(
            cll,
            #capture_output=True,
            encoding='utf8',
            env = penv,
            shell=False,
        )
        return p

        """write xmls and input samples into place"""
        for xreal in self.ourxmls:
            x = os.path.split(xreal)[1]
            xout = os.path.join(self.tooloutdir,x)
            shutil.copyfile(xreal, xout)
        # for p in self.infiles:
            # pth = p["name"]
            # dest = os.path.join(self.testdir, "%s_sample" % p["infilename"])
            # shutil.copyfile(pth, dest)
            # dest = os.path.join(self.repdir, "%s_sample" % p["infilename"])
            # shutil.copyfile(pth, dest)

    def makeToolTar(self):
        """move outputs into test-data and prepare the tarball"""
        excludeme = "_planemo_test_report.html"

                dest = os.path.join(self.repdir, newname)
                src = os.path.join(self.tooloutdir, entry.name)
                shutil.copyfile(src, dest)
        with os.scandir('.') as outs:
            for entry in outs:
                if not entry.is_file():
                    continue
                if "." in entry.name:
                    _, ext = os.path.splitext(entry.name)
                    if ext in [".yml", ".xml", ".yaml"]:
                        newname = f"{entry.name.replace('.','_')}.txt"

    def update_tests(self,ourdir):
        for xmlf in self.ourxmls:
            capture = self.call_planemo(xmlf,ourdir)
            #sys.stderr.write('%s, stdout=%s, stderr=%s' % (xmlf, capture.stdout, capture.stdout))
            #print('%s, stdout=%s, stderr=%s' % (capture.stdout, capture.stdout,xmlf))

def main():
    """
    This is a Galaxy wrapper.
    It expects to be called by a special purpose tool.xml

#end raw]]></configfile>
  </configfiles>
  <inputs>
    <param name="new_tool_name" value="" type="hidden"/>
    <param name="in_tool_archive" type="data" optional="false" label="Select a no_test tarfile to test and update for a toolshed" help="" format="toolshed.gz" multiple="false"/>
    <param name="galaxyroot" type="text" value="/home/ross/gal21" label="Galaxy root for planemo to use - MUST be made available in the Galaxy job runner configuration" help=""/>
  </inputs>
  <outputs>
    <data name="new_tested_tool_archive" format="toolshed.gz" label="${in_tool_archive.name.split('_')[0]}_tested_toolshed.gz"  hidden="false"/>
    <data name="tf_archive_tester_log" format="txt" label="${in_tool_archive.name}_test_log" hidden="false"/>
    <collection name="TF_run_report" type="list" label="${in_tool_archive.name} test Run reports">
      <discover_datasets pattern="__name_and_ext__" directory="TF_run_report" visible="false"/>
    </collection>
  </outputs>
  <tests>
    <test>
      <output name="new_tested_tool_archive" value="new_tested_tool_archive_sample" compare="sim_size" delta_frac="0.5"/>
      <output name="tf_archive_tester_log" value="tf_archive_tester_log_sample" compare="sim_size" delta_frac="0.1"/>
      <param name="in_tool_archive" value="in_tool_archive_sample"/>
      <param name="galaxyroot" value="/home/ross/gal21"/>
      <output_collection name="TF_run_report"/>
    </test>
  </tests>
  <help><![CDATA[

**What it Does**

------

Script::

    import argparse
    import copy
    import os
    import subprocess

    import sys
    import tarfile
    import tempfile
    import time
    import xml.etree.ElementTree as ET
    myversion = "V2.2 April 2021"
    verbose = True
    debug = True
    toolFactoryURL = "https://github.com/fubar2/toolfactory"
    def timenow():
        """return current time as a string"""
        return time.strftime("%d/%m/%Y %H:%M:%S", time.localtime(time.time()))

    class ToolTester():
        # requires highly insecure docker settings - like write to tool_conf.xml and to tools !
        # if in a container possibly not so courageous.
        # Fine on your own laptop but security red flag for most production instances
        # uncompress passed tar, run planemo and rebuild a new tarball with tests
        def __init__(self, args=None, in_tool_archive='/galaxy-central/tools/newtool/newtool_toolshed.gz', new_tool_archive=None):
            self.args = args
            self.new_tool_archive = new_tool_archive
            assert tarfile.is_tarfile(in_tool_archive)
            # this is not going to go well with arbitrary names.
            tff = tarfile.open(in_tool_archive, "r:*")
            flist = tff.getnames()
            ourdir = os.path.commonpath(flist) # eg pyrevpos
            self.tool_name = ourdir
            ourxmls = [x for x in flist if x.lower().endswith('.xml') and os.path.split(x)[0] == ourdir]
            # planemo_test/planemo_test.xml
            assert len(ourxmls) > 0
            self.ourxmls = ourxmls # [os.path.join(tool_path,x) for x in ourxmls]
            res = tff.extractall()
            self.update_tests(ourdir)
            tff.close()

            self.moveRunOutputs()
            self.makeToolTar()

        def call_planemo(self,xmlpath,ourdir):
            penv = os.environ
            penv['HOME'] = '/home/ross/galaxy-release_21.01'
            toolfile = os.path.split(xmlpath)[1]
            tool_name = self.tool_name
            tool_test_output = f"{tool_name}_planemo_test_report.html"
            cll = [
                "planemo",
                "test",
                "--test_output",
                os.path.abspath(tool_test_output),
                "--galaxy_root",
                self.args.galaxy_root,
                "--update_test_data",
                os.path.abspath(xmlpath),
            ]
            print(cll)
            p = subprocess.run(
                cll,
                capture_output=True,
                encoding='utf8',
                env = penv,
                shell=False,
            )
            return p

            """write xmls and input samples into place"""
            for xreal in self.ourxmls:
                x = os.path.split(xreal)[1]
                xout = os.path.join(self.tooloutdir,x)
                shutil.copyfile(xreal, xout)
            # for p in self.infiles:
                # pth = p["name"]
                # dest = os.path.join(self.testdir, "%s_sample" % p["infilename"])
                # shutil.copyfile(pth, dest)
                # dest = os.path.join(self.repdir, "%s_sample" % p["infilename"])
                # shutil.copyfile(pth, dest)

        def makeToolTar(self):
            """move outputs into test-data and prepare the tarball"""
            excludeme = "_planemo_test_report.html"
            def exclude_function(tarinfo):
                filename = tarinfo.name
                return None if filename.endswith(excludeme) else tarinfo
            newtar = 'new_%s_toolshed.gz' % self.tool_name
            ttf = tarfile.open(newtar, "w:gz")
            ttf.add(name=self.tooloutdir,
                arcname=self.tool_name,
                filter=exclude_function)
            ttf.close()
            shutil.copyfile(newtar, self.new_tool_archive)

                            newname = f"{entry.name}.txt"
                        dest = os.path.join(self.repdir, newname)
                        src = os.path.join(self.testdir, entry.name)
                        shutil.copyfile(src, dest)

        def update_tests(self,ourdir):
            for xmlf in self.ourxmls:
                capture = self.call_planemo(xmlf,ourdir)
                #sys.stderr.write('%s, stdout=%s, stderr=%s' % (xmlf, capture.stdout, capture.stdout))
                print('%s, stdout=%s, stderr=%s' % (capture.stdout, capture.stdout,xmlf))

    def main():
        """
        This is a Galaxy wrapper.
        It expects to be called by a special purpose tool.xml
        """
        parser = argparse.ArgumentParser()
        a = parser.add_argument
        a("--in_tool_archive", default=None)
        a("--new_tested_tool_archive", default=None)
        a("--galaxy_root", default="/home/ross/gal21/")
        args = parser.parse_args()
        print('Hello from',os.getcwd())
        tt = ToolTester(args=args, in_tool_archive=args.in_tool_archive, new_tool_archive=args.new_tested_tool_archive)
    if __name__ == "__main__":
        main()

]]></help>
  <citations>
    <citation type="doi">10.1093/bioinformatics/bts573</citation>
  </citations>

6:efefe43f23c8

  <stdio>
    <exit_code range="1:" level="fatal"/>
  </stdio>
  <version_command><![CDATA[echo "1"]]></version_command>
  <command><![CDATA[
mkdir 'TF_run_report';
python
$runme
--in_tool_archive
$in_tool_archive
--new_tested_tool_archive
$new_tested_tool_archive
--galaxy_root
"$__root_dir__"
>
"TF_run_report/${in_tool_archive.name}_test_log.txt"
]]></command>
  <configfiles>
    <configfile name="runme"><![CDATA[#raw

# see https://github.com/fubar2/toolfactory

def timenow():
    """return current time as a string"""
    return time.strftime("%d/%m/%Y %H:%M:%S", time.localtime(time.time()))

class ToolTester():
    # uncompress passed tar, run planemo and rebuild a new tarball with tests

    def __init__(self, args=None, in_tool_archive='/galaxy-central/tools/newtool/newtool_toolshed.gz', new_tool_archive=None):
        self.args = args
        self.new_tool_archive = new_tool_archive

        self.moveRunOutputs()
        self.makeToolTar()

    def call_planemo(self,xmlpath,ourdir):
        penv = os.environ
        penv['HOME'] = os.path.join(self.args.galaxy_root,'planemo')
        newpath = f"{penv['HOME']}:{penv['PATH']}"
        penv['PATH'] = newpath
        penv["GALAXY_VIRTUAL_ENV"] = os.path.join(self.args.galaxy_root,'.venv')
        penv["PIP_CACHE_DIR"] = os.path.join(self.args.galaxy_root,'pipcache')
        toolfile = os.path.split(xmlpath)[1]
        tool_name = self.tool_name
        tool_test_output = f"{tool_name}_planemo_test_report.html"
        cll = [
            "planemo",
            "test",
            "--no_cleanup",
            "--test_data",
            os.path.abspath(ourdir),
            "--test_output",
            os.path.abspath(self.tool_test_output),
            "--galaxy_root",
            self.args.galaxy_root,
            "--update_test_data",
            os.path.abspath(xmlpath),
        ]
        print(cll)
        p = subprocess.run(
            cll,
            #capture_output=True,
            encoding='utf8',
            cwd = os.path.abspath(self.tool_name),
            env = penv,
            shell=False,
        )
        return p

        """write xmls and input samples into place"""
        for xreal in self.ourxmls:
            x = os.path.split(xreal)[1]
            xout = os.path.join(self.tooloutdir,x)
            shutil.copyfile(xreal, xout)

    def makeToolTar(self):
        """move outputs into test-data and prepare the tarball"""
        excludeme = "_planemo_test_report.html"

                dest = os.path.join(self.repdir, newname)
                src = os.path.join(self.tooloutdir, entry.name)
                shutil.copyfile(src, dest)
        with os.scandir('.') as outs:
            for entry in outs:
                if not entry.is_file() or entry.name == "conda_activate.log":
                    continue
                if "." in entry.name:
                    _, ext = os.path.splitext(entry.name)
                    if ext in [".yml", ".xml", ".yaml"]:
                        newname = f"{entry.name.replace('.','_')}.txt"

    def update_tests(self,ourdir):
        for xmlf in self.ourxmls:
            capture = self.call_planemo(xmlf,ourdir)

def main():
    """
    This is a Galaxy wrapper.
    It expects to be called by a special purpose tool.xml

#end raw]]></configfile>
  </configfiles>
  <inputs>
    <param name="new_tool_name" value="" type="hidden"/>
    <param name="in_tool_archive" type="data" optional="false" label="Select a no_test tarfile to test and update for a toolshed" help="" format="toolshed.gz" multiple="false"/>
  </inputs>
  <outputs>
    <data name="new_tested_tool_archive" format="toolshed.gz" label="${in_tool_archive.name.split('_')[0]}_tested_toolshed.gz"  hidden="false"/>
    <collection name="TF_run_report" type="list" label="${in_tool_archive.name} test Run reports">
      <discover_datasets pattern="__name_and_ext__" directory="TF_run_report" visible="false"/>
    </collection>
  </outputs>
  <tests>
    <test>
      <output name="new_tested_tool_archive" value="new_tested_tool_archive_sample" compare="sim_size" delta_frac="0.5"/>
      <param name="in_tool_archive" value="in_tool_archive_sample"/>
      <output_collection name="TF_run_report"/>
    </test>
  </tests>
  <help><![CDATA[

**What it Does**

------

Script::

    # see https://github.com/fubar2/toolfactory
    #
    # copyright ross lazarus (ross stop lazarus at gmail stop com) May 2012
    #
    # all rights reserved
    # Licensed under the LGPL
    # suggestions for improvement and bug fixes welcome at
    # https://github.com/fubar2/toolfactory

    import argparse
    import copy
    import os
    import subprocess

    import sys
    import tarfile
    import tempfile
    import time
    import xml.etree.ElementTree as ET


    myversion = "V2.2 April 2021"
    verbose = True
    debug = True
    toolFactoryURL = "https://github.com/fubar2/toolfactory"

    def timenow():
        """return current time as a string"""
        return time.strftime("%d/%m/%Y %H:%M:%S", time.localtime(time.time()))

    class ToolTester():
        # uncompress passed tar, run planemo and rebuild a new tarball with tests

        def __init__(self, args=None, in_tool_archive='/galaxy-central/tools/newtool/newtool_toolshed.gz', new_tool_archive=None):
            self.args = args
            self.new_tool_archive = new_tool_archive
            assert tarfile.is_tarfile(in_tool_archive)
            # this is not going to go well with arbitrary names.
            tff = tarfile.open(in_tool_archive, "r:*")
            flist = tff.getnames()
            ourdir = os.path.commonpath(flist) # eg pyrevpos
            self.tool_name = ourdir
            ourxmls = [x for x in flist if x.lower().endswith('.xml') and os.path.split(x)[0] == ourdir]
            assert len(ourxmls) > 0
            self.ourxmls = ourxmls # [os.path.join(tool_path,x) for x in ourxmls]
            res = tff.extractall()
            self.update_tests(ourdir)
            tff.close()

            self.moveRunOutputs()
            self.makeToolTar()

        def call_planemo(self,xmlpath,ourdir):
            penv = os.environ
            penv["PIP_CACHE_DIR"] = os.path.join(self.args.galaxy_root,'pipcache')
            toolfile = os.path.split(xmlpath)[1]
            tool_name = self.tool_name
            tool_test_output = f"{tool_name}_planemo_test_report.html"
            cll = [
                "planemo",
                "test",
                "--biocontainers",
                "--test_output",
                os.path.abspath(tool_test_output),
                "--galaxy_root",
                self.args.galaxy_root,
                "--update_test_data",
                os.path.abspath(xmlpath),
            ]
            print(cll)
            p = subprocess.run(
                cll,
                #capture_output=True,
                encoding='utf8',
                env = penv,
                shell=False,
            )
            return p

            """write xmls and input samples into place"""
            for xreal in self.ourxmls:
                x = os.path.split(xreal)[1]
                xout = os.path.join(self.tooloutdir,x)
                shutil.copyfile(xreal, xout)

        def makeToolTar(self):
            """move outputs into test-data and prepare the tarball"""
            excludeme = "_planemo_test_report.html"

            def exclude_function(tarinfo):
                filename = tarinfo.name
                return None if filename.endswith(excludeme) else tarinfo

            newtar = 'new_%s_toolshed.gz' % self.tool_name
            ttf = tarfile.open(newtar, "w:gz")
            ttf.add(name=self.tool_name,
                arcname=self.tool_name,
                filter=exclude_function)
            ttf.close()
            shutil.copyfile(newtar, self.new_tool_archive)

                            newname = f"{entry.name}.txt"
                        dest = os.path.join(self.repdir, newname)
                        src = os.path.join(self.testdir, entry.name)
                        shutil.copyfile(src, dest)


        def update_tests(self,ourdir):
            for xmlf in self.ourxmls:
                capture = self.call_planemo(xmlf,ourdir)

    def main():
        """
        This is a Galaxy wrapper.
        It expects to be called by a special purpose tool.xml

        """
        parser = argparse.ArgumentParser()
        a = parser.add_argument
        a("--in_tool_archive", default=None)
        a("--new_tested_tool_archive", default=None)
        a("--galaxy_root", default="/home/ross/gal21/")
        args = parser.parse_args()
        print('Hello from',os.getcwd())
        tt = ToolTester(args=args, in_tool_archive=args.in_tool_archive, new_tool_archive=args.new_tested_tool_archive)

    if __name__ == "__main__":
        main()


]]></help>
  <citations>
    <citation type="doi">10.1093/bioinformatics/bts573</citation>
  </citations>