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__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 str(
obj) == "at least v1.2.x or (at least v2.0.x and prior to v3.4.x)"
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 test_requirement__same_obj_if_name_differ():
obj1 = versions.Requirement("echo", "", versions.GE(1))
assert obj1.name == "echo"
obj2 = versions.Requirement("echo", "", versions.GE(1), name="foo")
assert obj2.name == "foo"
assert obj1 is obj2
obj3 = versions.Requirement("echo", "", versions.GE(1), name="bar")
assert obj3.name == "bar"
assert obj2 is obj3
obj4 = versions.Requirement("echo", "", versions.GE(1))
assert obj3.name == "bar"
assert obj3 is obj4
def test_requirementobj__call__check_fails__jre_outdated():
expected = (
"Version could not be determined for test#1:\n"
"\n"
"Attempted to run command:\n"
" $ /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 as error:
assert str(error) == expected
def test_and__str__two_items__first_is_operator():
obj_1 = versions.And(versions.GE(1, 2), versions.LT(2, 0))
obj_2 = versions.LT(3, 4)
obj = versions.And(obj_1, obj_2)
assert_equal(str(obj),
"(at least v1.2.x and prior to v2.0.x) and prior to v3.4.x")
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 str(
obj) == "(at least v1.2.x or prior to v2.0.x) or prior to v3.4.x"
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"\b(\d+)\.(\d+)\.\d+",
checks=versions.GE(1, 137),
)
_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,
set_cwd=True,
)
params.set_option(command)
return params
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 as 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" \
"Attempted to run command:\n" \
" $ /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 as error:
assert_equal(str(error), expected)
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
#
from paleomix.node import CommandNode, NodeError
from paleomix.atomiccmd.builder import (
AtomicCmdBuilder,
apply_options,
)
from paleomix.common.fileutils import reroot_path
from paleomix.common.formats.msa import MSA, MSAError
import paleomix.common.versions as versions
MAFFT_VERSION = versions.Requirement(call=("mafft", "--version"),
search=r"v(\d+)\.(\d+)",
checks=versions.GE(7, 0))
# Presets mainly taken from
# http://mafft.cbrc.jp/alignment/software/algorithms/algorithms.html
_PRESETS = {
"mafft": ["mafft"],
"auto": ["mafft", "--auto"],
"fft-ns-1": ["mafft-fftns", "--retree", 1],
"fft-ns-2": ["mafft-fftns"],
"fft-ns-i": ["mafft-fftnsi"],
"nw-ns-i": ["mafft-nwnsi"],
"l-ins-i": ["mafft-linsi"],
"e-ins-i": ["mafft-einsi"],
"g-ins-i": ["mafft-ginsi"],
}
#
import os
from paleomix.node import CommandNode
from paleomix.atomiccmd.builder import (
AtomicCmdBuilder,
apply_options,
)
import paleomix.common.fileutils as fileutils
import paleomix.common.versions as versions
_VERSION_CHECK = versions.Requirement(
call=("AdapterRemoval", "--version"),
search=r"ver. (\d+)\.(\d+)\.(\d+)",
checks=versions.GE(2, 1, 5),
)
class SE_AdapterRemovalNode(CommandNode):
def __init__(self,
input_file,
output_prefix,
threads=1,
options={},
dependencies=()):
# See below for parameters in common between SE/PE
cmd = _get_common_parameters(threads=threads, options=options)
# Prefix for output files, ensure that all end up in temp folder
cmd.set_option("--basename", "%(TEMP_OUT_BASENAME)s")
from paleomix.common.utilities import \
safe_coerce_to_tuple
from paleomix.node import \
NodeError, \
CommandNode
from paleomix.nodes.picard import \
MultiBAMInputNode
from paleomix.atomiccmd.builder import \
AtomicCmdBuilder, \
use_customizable_cli_parameters, \
create_customizable_cli_parameters
MAPDAMAGE_VERSION = versions.Requirement(call=("mapDamage", "--version"),
search=r"(\d+)\.(\d+).(\d+)",
checks=versions.GE(2, 0, 1))
RSCRIPT_VERSION = versions.Requirement(call=("Rscript", "--version"),
search=r"(\d+)\.(\d+).(\d+)",
checks=versions.GE(2, 15, 1),
priority=10)
class MapDamagePlotNode(MultiBAMInputNode):
@create_customizable_cli_parameters
def customize(self,
config,
reference,
input_files,
output_directory,
title="mapDamage",
use_customizable_cli_parameters, \
create_customizable_cli_parameters
from paleomix.atomiccmd.sets import \
ParallelCmds
from paleomix.nodes.bwa import \
_get_node_description, \
_process_output, \
_get_max_threads
from paleomix.common.utilities import \
safe_coerce_to_tuple
import paleomix.common.versions as versions
BOWTIE2_VERSION = versions.Requirement(call=("bowtie2", "--version"),
search=r"version (\d+)\.(\d+)\.(\d+)",
checks=versions.GE(2, 1, 0))
class Bowtie2IndexNode(CommandNode):
def __init__(self, input_file, prefix=None, dependencies=()):
prefix = prefix if prefix else input_file
builder = _bowtie2_template(("bowtie2-build"),
prefix,
iotype="OUT",
IN_FILE=input_file,
TEMP_OUT_PREFIX=os.path.basename(prefix),
CHECK_VERSION=BOWTIE2_VERSION)
builder.add_value("%(IN_FILE)s")
# Destination prefix, in temp folder
builder.add_value("%(TEMP_OUT_PREFIX)s")
#
import os
import re
import random
import paleomix.common.fileutils as fileutils
import paleomix.common.versions as versions
from paleomix.node import CommandNode
from paleomix.atomiccmd.builder import AtomicCmdBuilder
RAXML_VERSION = versions.Requirement(
call=("raxmlHPC", "-version"),
search=r"version (\d+)\.(\d+)\.(\d+)",
checks=versions.GE(7, 3, 2),
)
RAXML_PTHREADS_VERSION = versions.Requirement(
call=("raxmlHPC-PTHREADS", "-version"),
search=r"version (\d+)\.(\d+)\.(\d+)",
checks=versions.GE(7, 3, 2),
)
class RAxMLRapidBSNode(CommandNode):
def __init__(
self,
input_alignment,
output_template,
input_partition=None,
model="GTRGAMMAI",
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
#
import os
from paleomix.node import CommandNode
from paleomix.atomiccmd.command import AtomicCmd
from paleomix.atomiccmd.sets import SequentialCmds
from paleomix.common.fileutils import reroot_path, swap_ext
import paleomix.common.versions as versions
_VERSION_REGEX = r"Version: (\d+)\.(\d+)(?:\.(\d+))?"
# v0.2.0 was the pre-release version of v1.0, and lacks required features
_COMMON_CHECK = versions.Or(versions.EQ(0, 1, 19), versions.GE(1, 0, 0))
SAMTOOLS_VERSION = versions.Requirement(call=("samtools", ),
search=_VERSION_REGEX,
checks=_COMMON_CHECK)
SAMTOOLS_VERSION_1x = versions.Requirement(call=("samtools", ),
search=_VERSION_REGEX,
checks=versions.GE(1, 0, 0))
SAMTOOLS_VERSION_0119 = versions.Requirement(call=("samtools", ),
search=_VERSION_REGEX,
checks=versions.EQ(0, 1, 19))
BCFTOOLS_VERSION_0119 \
= versions.Requirement(call=("bcftools",),
def test_or__str__single_item():
obj = versions.Or(versions.GE(1))
assert str(obj) == "at least v1.x"
# SOFTWARE.
#
import os
from paleomix.node import CommandNode
from paleomix.atomiccmd.builder import AtomicCmdBuilder
from paleomix.atomiccmd.command import AtomicCmd
from paleomix.common.fileutils import reroot_path
import paleomix.common.versions as versions
_VERSION_REGEX = r"Version: (\d+)\.(\d+)(?:\.(\d+))?"
SAMTOOLS_VERSION = versions.Requirement(call=("samtools", ),
search=_VERSION_REGEX,
checks=versions.GE(1, 3, 0))
BCFTOOLS_VERSION = versions.Requirement(call=("bcftools", ),
search=_VERSION_REGEX,
checks=versions.GE(1, 3, 0))
TABIX_VERSION = versions.Requirement(call=("tabix", ),
search=_VERSION_REGEX,
checks=versions.GE(1, 3, 0))
class TabixIndexNode(CommandNode):
"""Tabix indexes a BGZip compressed VCF or pileup file.
The class currently supports the following presets:
- vcf -- BGZipped VCF file.
import paleomix.common.versions as versions
import paleomix.tools.factory as factory
from paleomix.atomiccmd.builder import (
AtomicCmdBuilder,
apply_options,
)
from paleomix.atomiccmd.command import AtomicCmd
from paleomix.atomiccmd.sets import ParallelCmds
from paleomix.common.fileutils import describe_paired_files
from paleomix.node import CommandNode, NodeError
from paleomix.nodes.samtools import SAMTOOLS_VERSION
BWA_VERSION = versions.Requirement(call=("bwa", ),
search=r"Version: (\d+)\.(\d+)\.(\d+)",
checks=versions.GE(0, 7, 9))
class BWAIndexNode(CommandNode):
def __init__(self, input_file, prefix=None, dependencies=()):
prefix = prefix if prefix else input_file
builder = _new_bwa_command(
("bwa", "index", "%(IN_FILE)s", "-p", "%(TEMP_OUT_PREFIX)s"),
prefix,
iotype="OUT",
IN_FILE=input_file,
TEMP_OUT_PREFIX=os.path.basename(prefix),
)
description = "<BWA Index '%s' -> '%s.*'>" % (input_file, prefix)
CommandNode.__init__(
def test_requirement__new_obj_if_checks_differ():
obj1 = versions.Requirement("echo", "", versions.GE(1))
obj2 = versions.Requirement("echo", "", versions.LT(1))
assert obj1 is not obj2
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))
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_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__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))
import paleomix.common.fileutils as fileutils
import paleomix.common.versions as versions
from paleomix.node import CommandNode
from paleomix.atomiccmd.builder import \
AtomicCmdBuilder, \
AtomicMPICmdBuilder, \
use_customizable_cli_parameters, \
create_customizable_cli_parameters
from paleomix.nodegraph import \
FileStatusCache
EXAML_VERSION = versions.Requirement(call=("examl", "-version"),
search=r"version (\d+)\.(\d+)\.(\d+)",
checks=versions.GE(3, 0, 0))
PARSER_VERSION = versions.Requirement(call=("parse-examl", "-h"),
search=r"version (\d+)\.(\d+)\.(\d+)",
checks=versions.GE(3, 0, 0))
class ExaMLParserNode(CommandNode):
@create_customizable_cli_parameters
def customize(cls,
input_alignment,
input_partition,
output_file,
dependencies=()):
"""
Arguments:
import paleomix.common.fileutils as fileutils
import paleomix.common.versions as versions
from paleomix.node import CommandNode
from paleomix.atomiccmd.builder import (
AtomicCmdBuilder,
AtomicMPICmdBuilder,
)
from paleomix.nodegraph import FileStatusCache
EXAML_VERSION = versions.Requirement(
call=("examl", "-version"),
search=r"version (\d+)\.(\d+)\.(\d+)",
checks=versions.GE(3, 0, 0),
)
PARSER_VERSION = versions.Requirement(
call=("parse-examl", "-h"),
search=r"version (\d+)\.(\d+)\.(\d+)",
checks=versions.GE(3, 0, 0),
)
class ExaMLParserNode(CommandNode):
def __init__(self,
input_alignment,
input_partition,
output_file,
dependencies=()):
import paleomix.common.versions as versions
import paleomix.tools.factory as factory
from paleomix.atomiccmd.builder import AtomicCmdBuilder
from paleomix.atomiccmd.command import AtomicCmd
from paleomix.atomiccmd.sets import SequentialCmds
from paleomix.node import CommandNode, Node, NodeError
from paleomix.tools.zonkey.common import \
RSCRIPT_VERSION, \
contig_name_to_plink_name, \
read_summary
ADMIXTURE_VERSION = versions.Requirement(call=("admixture", "--version"),
search="(\d+)\.(\d+)",
checks=versions.GE(1, 3))
PLINK_VERSION = versions.Requirement(call=("plink", "--noweb", "--help",
"--out", "/tmp/plink"),
search="v(\d+)\.(\d+)",
checks=versions.GE(1, 7))
SMARTPCA_VERSION = versions.Requirement(call=("smartpca", ),
search="version: (\d+)",
checks=versions.GE(13050))
TREEMIX_VERSION = versions.Requirement(call=("treemix", ),
search="TreeMix v. (\d+)\.(\d+)",
checks=versions.GE(1, 12))
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 str(obj) == "at least v1.2.x or prior to v3.4.x"
