def get_version(self):
help_string1 = E.run("{self.path_manta} --version".format(**locals()),
return_stdout=True).strip()
help_string2 = E.run(
"{self.path_strelka} --version".format(**locals()),
return_stdout=True).strip()
return "-".join([help_string1, help_string2])
def get_version(self):
help_string = E.run("{self.path}".format(**locals()),
return_stderr=True).strip()
if "USAGE: pbsim" in help_string:
return "unknown"
else:
raise ValueError("pbsim not found")
def get_version(self):
help_string = E.run("{self.path} -h".format(**locals()),
return_stderr=True).strip()
if "vcf-concat [OPTIONS]" in help_string:
return "unknown"
else:
raise ValueError("vcf-concat not found")
def expand_globs(config, is_test=False):
"""detect and expand glob expressions in the input section.
A glob expression is any filename that contains a '*'. Multiple
glob expressions can be combined on the same line by a ','.
A "find" expression is detected starting with 'find'. These
expressions will be evaluated in a shell and the results insterted
into the dictionary.
If a filename starts with "file=", the contents of the file
following the "=" are read and inserted. Multiple files can be
separated by a ','.
If a glob or find expression is evaluated to nothing, an exception
is raised unless ``is_test`` is set. In that case, two files will be
returned called "test1" and "test2".
"""
for d, key, value in IOTools.nested_iter(config):
if isinstance(value, str):
if value.startswith("find"):
try:
data = E.run(value, return_stdout=True)
except Exception as e:
data = e.output
d[key] = [x for x in data.split("\n") if x]
elif "*" in value:
if "," in value:
v = [glob.glob(x.strip()) for x in value.split(",")]
v = [item for sublist in v for item in sublist]
else:
v = glob.glob(value)
d[key] = v
elif value.startswith("file="):
filenames = [x.strip() for x in value.split("=")[1].split(",")]
paths = []
for fn in filenames:
with IOTools.open_file(fn) as inf:
paths.extend([x.strip() for x in inf if x.strip()])
d[key] = paths
if len(d[key]) == 0:
if not is_test:
raise ValueError(
"expression '{}' expanded to nothing".format(value))
else:
# insert some random files for testing purposes:
if "*" in value:
# replace glob expressions
value = re.sub(",.*", "", value)
d[key] = [re.sub("[*]", "test1", value),
re.sub("[*]", "test2", value)]
else:
if "bam" in value:
d[key] = ["test1.bam", "test2.bam"]
elif "vcf" in value:
d[key] = ["test1.vcf.gz", "test2.vcf.gz"]
else:
d[key] = ["test1.txt", "test2.txt"]
return config
def get_version(self):
version_bedtools = run_metric_bedtools_intersection.get_version(self)
help_string = E.run(
"{self.gat_path} --version 2> /dev/null".format(**locals()),
return_stdout=True).strip()
return "{} {}".format(
version_bedtools,
re.search(r"gat-run.py version: (\S+):", help_string).groups()[0])
def get_version(self):
help_text = E.run("{self.path} -version".format(**locals()),
return_stderr=True).strip()
if help_text and "not found" not in help_text:
return re.search(r"BBMap version (\S+)", help_text).groups()[0]
else:
raise ValueError("bbmap not found at/as {}: {}".format(
self.path, help_text))
def get_version(self):
help_string = E.run("{self.path} --version".format(**locals()),
return_stderr=True).strip()
if help_string and "not found" not in help_string:
return re.search("Canu (.+)", help_string).groups()[0]
else:
raise ValueError("canu not found at/as {}: {}".format(
self.path, help_string))
def get_version(self):
help_string = E.run("{self.path} ".format(**locals()),
return_stdout=True,
on_error="ignore").strip()
if help_string:
return re.search("Delly \(Version: (\S+)\)",
help_string).groups()[0]
else:
raise ValueError("delly not found at/as {}".format(self.path))
def get_version(self):
help_string = E.run("{self.path} ".format(**locals()),
return_stdout=True,
on_error="ignore").strip()
# lumpy express without arguments ends in error
if help_string:
raise NotImplementedError()
return re.search(r"lumpy \(Version: (\S+)\)",
help_string).groups()[0]
else:
raise ValueError("lumpy not found at/as {}".format(self.path))
def get_version(self):
help_string = E.run(
"{self.path} version 2> /dev/null".format(**locals()),
return_stdout=True,
on_error="ignore").strip()
if help_string and "not found" not in help_string:
return re.search(r"Product: RTG Tools (\S+)",
help_string).groups()[0]
else:
raise ValueError("rtg not found at/as {}: {}".format(
self.path, help_string))
def get_version(self):
help_string = E.run("{self.path} --version".format(**locals()),
return_stdout=True).strip()
return re.search("stat \(GNU coreutils\) (\S+)",
help_string).groups()[0]
def get_version(self):
return E.run("java -jar {self.path} --version".format(**locals()),
return_stdout=True).strip()
def get_version(self):
help_string = E.run(
"{self.path} --version 2> /dev/null".format(**locals()),
return_stdout=True).strip()
return re.search("gat-run.py version: (\S+):", help_string).groups()[0]
def sra_peek(sra, outdir=None):
"""return the full file names for all files which will be extracted
Parameters
----------
outdir : path
perform extraction in outdir. If outdir is None, the extraction
will take place in a temporary directory, which will be deleted
afterwards.
Returns
-------
files : list
A list of fastq formatted files that are contained in the archive.
format : string
The quality score format in the :term:`fastq` formatted files.
"""
if outdir is None:
workdir = tempfile.mkdtemp()
else:
workdir = outdir
# --split-files creates files called prefix_#.fastq.gz,
# where # is the read number.
# If file cotains paired end data:
# output = prefix_1.fastq.gz, prefix_2.fastq.gz
# *special case: unpaired reads in a paired end --> prefix.fastq.gz
# *special case: if paired reads are stored in a single read,
# fastq-dump will split. There might be a joining
# sequence. The output would thus be:
# prefix_1.fastq.gz, prefix_2.fastq.gz, prefix_3.fastq.gz
# You want files 1 and 3.
E.run("""fastq-dump --split-files --gzip -X 1000
--outdir %(workdir)s %(sra)s""" % locals())
f = sorted(glob.glob(os.path.join(workdir, "*.fastq.gz")))
ff = [os.path.basename(x) for x in f]
if len(f) == 1:
# sra file contains one read: output = prefix.fastq.gz
pass
elif len(f) == 2:
# sra file contains read pairs:
# output = prefix_1.fastq.gz, prefix_2.fastq.gz
assert ff[0].endswith(
"_1.fastq.gz") and ff[1].endswith("_2.fastq.gz")
elif len(f) == 3:
if ff[2].endswith("_3.fastq.gz"):
f = glob.glob(os.path.join(workdir, "*_[13].fastq.gz"))
else:
f = glob.glob(os.path.join(workdir, "*_[13].fastq.gz"))
if outdir is None:
shutil.rmtree(workdir)
return [os.path.basename(x) for x in f]
def get_version(self):
help_string = E.run(
"{self.path} variants --version".format(**locals()),
return_stdout=True).strip()
return re.search("Version (\S+)", help_string).groups()[0]
def get_version(self):
help_string = E.run("{self.path}".format(**locals()),
return_stderr=True).strip()
return re.search("Version:\s*(\S+)", help_string).groups()[0]
def get_version(self):
help_text = E.run("{self.path} --version 2> /dev/null".format(**locals()),
return_stdout=True).strip()
return re.search("version (\S+)", help_text).groups()[0]
def get_version(self):
help_string = E.run(
"{self.path_freebayes} --version".format(**locals()),
return_stdout=True).strip()
return re.search("version:\s+(\S+)", help_string).groups()[0]
def get_version(self):
help_string = E.run("{self.path_lastal} -V".format(**locals()),
return_stdout=True).strip()
return re.search("lastal (.+)", help_string).groups()[0]
def get_version(self):
help_string = E.run("{self.path} --version".format(**locals()),
return_stdout=True).strip()
return help_string
def get_version(self):
help_string = E.run("{self.path} --help".format(**locals()),
return_stdout=True).strip()
return re.search("Welcome to FINEMAP (\S+)", help_string).groups()[0]
