def test_or__str__two_items__second_is_operator():
obj_1 = versions.GE(1, 2)
obj_2 = versions.And(versions.GE(2, 0), versions.LT(3, 4))
obj = versions.Or(obj_1, obj_2)
assert_equal(str(obj),
"at least v1.2.x or (at least v2.0.x and prior to v3.4.x)")
def test_or__check_version__insufficient_number_of_values():
def _do_or_check_num_values(obj_1, obj_2):
obj = versions.Or(obj_1, obj_2)
assert_raises(ValueError, obj, (1, 3))
yield _do_or_check_num_values, versions.GE(1, 2, 2), versions.LT(2, 0)
yield _do_or_check_num_values, versions.GE(1, 2, 2), versions.LT(2, 0, 1)
def test_or__check_version__truncated():
def _do_or_check_truncated(obj_1, obj_2):
obj = versions.Or(obj_1, obj_2)
assert obj((1, 3, 3))
yield _do_or_check_truncated, versions.GE(1, 2), versions.LT(2, 0)
yield _do_or_check_truncated, versions.GE(1, 2, 2), versions.LT(2, 0)
yield _do_or_check_truncated, versions.GE(1, 2), versions.LT(2, 0, 1)
def test_check__can_pickle():
def _do_test_can_pickle(obj):
pickle.dumps(obj)
yield _do_test_can_pickle, versions.EQ(1, 2, 3)
yield _do_test_can_pickle, versions.GE(1, 2, 3)
yield _do_test_can_pickle, versions.LT(1, 2, 3)
yield _do_test_can_pickle, versions.Any()
yield _do_test_can_pickle, versions.And(versions.EQ(1, 2, 3))
yield _do_test_can_pickle, versions.Or(versions.GE(1, 2, 3))
def test_requirement__same_obj_if_name_differ():
obj1 = versions.Requirement("echo", "", versions.GE(1))
assert_equal(obj1.name, "echo")
obj2 = versions.Requirement("echo", "", versions.GE(1), name="foo")
assert_equal(obj2.name, "foo")
assert_is(obj1, obj2)
obj3 = versions.Requirement("echo", "", versions.GE(1), name="bar")
assert_equal(obj3.name, "bar")
assert_is(obj2, obj3)
obj4 = versions.Requirement("echo", "", versions.GE(1))
assert_equal(obj3.name, "bar")
assert_is(obj3, obj4)
def picard_command(config, command):
"""Returns basic AtomicJavaCmdBuilder for Picard tools commands."""
jar_path = os.path.join(config.jar_root, _PICARD_JAR)
if jar_path not in _PICARD_VERSION_CACHE:
params = AtomicJavaCmdBuilder(jar_path,
temp_root=config.temp_root,
jre_options=config.jre_options)
# Arbitrary command, since just '--version' does not work
params.set_option("MarkDuplicates")
params.set_option("--version")
requirement = versions.Requirement(call=params.finalized_call,
name="Picard tools",
search=r"^(\d+)\.(\d+)",
checks=versions.GE(1, 124))
_PICARD_VERSION_CACHE[jar_path] = requirement
version = _PICARD_VERSION_CACHE[jar_path]
params = AtomicJavaCmdBuilder(jar_path,
temp_root=config.temp_root,
jre_options=config.jre_options,
CHECK_JAR=version)
params.set_option(command)
return params
def test_or__str__two_items__first_is_operator():
obj_1 = versions.Or(versions.GE(1, 2), versions.LT(2, 0))
obj_2 = versions.LT(3, 4)
obj = versions.Or(obj_1, obj_2)
assert_equal(str(obj),
"(at least v1.2.x or prior to v2.0.x) or prior to v3.4.x")
def _picard_version(jar_file):
if jar_file not in _PICARD_VERSION_CACHE:
requirement = versions.Requirement(call=("java", "-client", "-jar",
jar_file, "--version"),
search=r"^(\d+)\.(\d+)",
checks=versions.GE(1, 82))
_PICARD_VERSION_CACHE[jar_file] = requirement
return _PICARD_VERSION_CACHE[jar_file]
def _get_java_version(cls, version):
version = tuple(map(int, version))
if version not in JAVA_VERSIONS:
regexp = r"[\._]".join(r"(\d+)" for _ in version)
regexp = r'java version "%s' % (regexp, )
jre_call = ["java", "-Djava.awt.headless=true", "-version"]
JAVA_VERSIONS[version] \
= versions.Requirement(call=jre_call,
name="JAVA Runtime Environment",
search=regexp,
checks=versions.GE(*version),
priority=10)
return JAVA_VERSIONS[version]
def _picard_version(config, jar_file):
if jar_file not in _PICARD_VERSION_CACHE:
params = AtomicJavaCmdBuilder(jar_file,
temp_root=config.temp_root,
jre_options=config.jre_options)
params.add_value("--version")
name = "Picard " + os.path.basename(jar_file)
requirement = versions.Requirement(call=params.finalized_call,
name=name,
search=r"^(\d+)\.(\d+)",
checks=versions.GE(1, 82))
_PICARD_VERSION_CACHE[jar_file] = requirement
return _PICARD_VERSION_CACHE[jar_file]
def test_requirementobj__call__check_fails__function():
expected = \
"Version requirements not met for test#1; please refer\n" \
"to the PALEOMIX documentation for more information.\n" \
"\n" \
" Version: v1.0.x\n" \
" Required: at least v1.1.x"
obj = versions.RequirementObj(call=lambda: "v1.0.3",
search=r"(\d)\.(\d)",
checks=versions.GE(1, 1),
name="test#1")
try:
obj()
assert False # pragma: no coverage
except versions.VersionRequirementError, error:
assert_equal(str(error), expected)
def test_requirementobj__call__check_fails():
expected = \
"Version requirements not met for test#1; please refer\n" \
"to the PALEOMIX documentation for more information.\n" \
"\n" \
" Executable: /usr/bin/python\n" \
" Call: /usr/bin/python -c import sys; " \
"sys.stdout.write('v1.0.2'); sys.exit(0);\n" \
" Version: v1.0.x\n" \
" Required: at least v1.1.x"
obj = versions.RequirementObj(call=_echo_version("v1.0.2"),
search=r"(\d)\.(\d)",
checks=versions.GE(1, 1),
name="test#1")
try:
obj()
assert False # pragma: no coverage
except versions.VersionRequirementError, error:
assert_equal(str(error), expected)
def test_requirementobj__call__check_fails__jre_outdated():
expected = \
"Version could not be determined for test#1:\n" \
"\n" \
" Executable: /usr/bin/python\n" \
" Call: /usr/bin/python -c import sys; " \
"sys.stdout.write('UnsupportedClassVersionError'); sys.exit(0);\n" \
"\n" \
"The version of the Java Runtime Environment on this\n" \
"system is too old; please check the the requirement\n" \
"for the program and upgrade your version of Java.\n" \
"\n" \
"See the documentation for more information."
value = "UnsupportedClassVersionError"
obj = versions.RequirementObj(call=_echo_version(value),
search=r"(\d)\.(\d)",
checks=versions.GE(1, 1),
name="test#1")
try:
obj()
assert False # pragma: no coverage
except versions.VersionRequirementError, error:
assert_equal(str(error), expected)
def test_ge__str__one_value():
obj = versions.GE(1)
assert_equal(str(obj), "at least v1.x")
def test_or__check_version__insufficient_number_of_values__is_lazy():
obj_1 = versions.GE(1, 2)
obj_2 = versions.LT(2, 0, 1)
obj = versions.Or(obj_1, obj_2)
assert obj((1, 3))
check_fastq_files
import pypeline.common.utilities as utilities
import pypeline.common.fileutils as fileutils
import pypeline.common.versions as versions
import pypeline.tools.factory as factory
VERSION_14 = "1.4"
_VERSION_14_CHECK = versions.Requirement(call=("AdapterRemoval", "--version"),
search=r"ver. (\d+)\.(\d+)",
checks=versions.EQ(1, 4))
VERSION_15 = "1.5+"
_VERSION_15_CHECK = versions.Requirement(call=("AdapterRemoval", "--version"),
search=r"ver. (\d+)\.(\d+)\.(\d+)",
checks=versions.GE(1, 5, 0))
class SE_AdapterRemovalNode(CommandNode):
@create_customizable_cli_parameters
def customize(cls,
input_files,
output_prefix,
output_format="bz2",
quality_offset=33,
version=VERSION_15,
dependencies=()):
# See below for parameters in common between SE/PE
cmd = _get_common_parameters(version)
# Uncompressed reads (piped from 'paleomix cat')
def test_and__check_version__first_true():
obj_1 = versions.And(versions.GE(1, 2), versions.LT(2, 0))
obj_2 = versions.And(versions.GE(2, 3), versions.LT(3, 0))
obj = versions.And(obj_1, obj_2)
assert not obj((1, 3))
def test_or__check_version__second_true():
obj_1 = versions.And(versions.GE(1, 2), versions.LT(2, 0))
obj_2 = versions.And(versions.GE(2, 3), versions.LT(3, 0))
obj = versions.Or(obj_1, obj_2)
assert obj((2, 3))
def test_or__check_version__neither_true():
obj_1 = versions.And(versions.GE(1, 2), versions.LT(2, 0))
obj_2 = versions.And(versions.GE(2, 3), versions.LT(3, 0))
obj = versions.Or(obj_1, obj_2)
assert not obj((2, 2))
def test_ge__check_values__not_greater_than_or_equal():
obj = versions.GE(2, 3)
assert not obj((1, 3))
assert not obj((2, 2))
def test_or__check_version__both_true():
obj_1 = versions.GE(1, 2)
obj_2 = versions.LT(2, 0)
obj = versions.Or(obj_1, obj_2)
assert obj((1, 3))
def test_ge__check_values__greater_than_or_equal_truncated():
obj = versions.GE(2, 3)
assert obj((2, 3, 1))
assert obj((2, 4, 2))
def test_or__str__two_items():
obj_ge = versions.GE(1, 2)
obj_lt = versions.LT(3, 4)
obj = versions.Or(obj_ge, obj_lt)
assert_equal(str(obj), "at least v1.2.x or prior to v3.4.x")
def test_or__str__single_item():
obj = versions.Or(versions.GE(1))
assert_equal(str(obj), "at least v1.x")
def test_requirement__new_obj_if_checks_differ():
obj1 = versions.Requirement("echo", "", versions.GE(1))
obj2 = versions.Requirement("echo", "", versions.LT(1))
assert_is_not(obj1, obj2)
def test_ge__check_values__greater_than_or_equal():
obj = versions.GE(2, 3)
assert obj((2, 3))
assert obj((2, 4))
assert obj((3, 0))
from pypeline.atomiccmd.builder import AtomicJavaCmdBuilder,AtomicJava7CmdBuilder
from pypeline.atomiccmd.sets import ParallelCmds
from pypeline.atomiccmd.builder import \
AtomicCmdBuilder, \
use_customizable_cli_parameters, \
create_customizable_cli_parameters
from pypeline.nodes.samtools import GenotypeNode, TabixIndexNode, FastaIndexNode, MPileupNode
import pypeline.common.versions as versions
from pypeline.common.utilities import safe_coerce_to_tuple
SAMTOOLS_VERSION = versions.Requirement(
call = ("samtools",),
search = b"Version: (\d+)\.(\d+)\.(\d+)",
checks = versions.GE(0, 1, 18)
)
class SnpListNode(CommandNode):
@create_customizable_cli_parameters
def customize(cls, groups, prefix, options, dependencies = ()):
# Merge the VCF files
merge_vcf = AtomicCmdBuilder(['vcf_merge'], OUT_VCF = "merged.vcf")
for group in groups:
vcf_file = os.path.join(options.makefile['RecalDir'],
'gatk.{}.{}.raw.recal_final.vcf'.format(group,prefix)
)
merge_vcf.add_option("-i",vcf_file)
merge_vcf.add_option("-o", '%(OUT_VCF)s')
def test_ge__str__two_values():
obj = versions.GE(2, 1)
assert_equal(str(obj), "at least v2.1.x")
from pypeline.atomiccmd.sets import ParallelCmds, SequentialCmds
from pypeline.atomiccmd.builder import AtomicJavaCmdBuilder
from pypeline.nodes.picard import ValidateBAMNode, concatenate_input_bams
from pypeline.nodes.samtools import BAMIndexNode
from pypeline.common.fileutils import describe_files
import pypeline.common.versions as versions
# Number of reads to sample when running mapDamage
_MAPDAMAGE_MAX_READS = 100000
MAPDAMAGE_VERSION = versions.Requirement(call=("mapDamage", "--version"),
search=r"(\d+)\.(\d+)[\.-](\d+)",
pprint="{0}.{1}.{2}",
checks=versions.GE(2, 0, 45))
class MapDamageNode(CommandNode):
def __init__(self, config, reference, input_files, output_directory,
dependencies):
cat_cmds, cat_obj = concatenate_input_bams(config, input_files)
cmd_map = AtomicCmd(
[
"mapDamage", "--no-stats", "-n", _MAPDAMAGE_MAX_READS, "-i",
"-", "-d", "%(TEMP_DIR)s", "-r", reference
],
IN_STDIN=cat_obj,
OUT_FREQ_3p=os.path.join(output_directory, "3pGtoA_freq.txt"),
OUT_FREQ_5p=os.path.join(output_directory, "5pCtoT_freq.txt"),
def test_ge__check_values__not_equal_too_few_values():
obj = versions.GE(2, 3)
assert_raises(ValueError, obj, (1,))
