diff --git a/core/pymod/core/pm3argparse.py b/core/pymod/core/pm3argparse.py
index e7d1da321a20ccc2efc4af159e13e1aa00105d19..bd6fd9a233f2a16619b5142d9528098bf26528fe 100644
--- a/core/pymod/core/pm3argparse.py
+++ b/core/pymod/core/pm3argparse.py
@@ -7,12 +7,159 @@ import sys
import os
import gzip
import tempfile
+#try:
+# import ujson as json
+#except ImportError:
+import json
import ost
from ost import io, seq
from promod3.core import helper
+def _TmpForGZip(filename, suffix, msg_prefix):
+ """Unpack a file to a tmp file if gzipped.
+ """
+ helper.FileExists(msg_prefix, 12, filename)
+ zip_fh = gzip.open(filename)
+ unzip_str = zip_fh.read()
+ zip_fh.close()
+ unzip_file = tempfile.NamedTemporaryFile(mode='w', suffix=suffix)
+ unzip_file.write(unzip_str)
+ unzip_file.flush()
+ return unzip_file
+
+def _CheckJSONAlnSeqKeyType(key_name, val_type, json_aln, seqtype, json_source):
+ '''Check a key/ value in a sequence exists and is of certain type.
+ '''
+ if key_name not in json_aln[seqtype].keys():
+ helper.MsgErrorAndExit("JSON 'alignmentlist' '%s' " % seqtype+
+ "from '%s' is " % json_source+
+ "missing the '%s' key" % key_name, 27)
+ altype = type(json_aln[seqtype][key_name])
+
+ if val_type is str or val_type is unicode:
+ if not (altype is unicode or altype is str):
+ helper.MsgErrorAndExit("JSON 'alignmentlist' '%s' " % seqtype+
+ "'%s' from" % key_name+
+ "'%s' is not a " % json_source+
+ "%s" % str(val_type), 28)
+ elif not altype is val_type:
+ helper.MsgErrorAndExit("JSON 'alignmentlist' '%s' " % seqtype+
+ "'%s' from" % key_name+
+ "'%s' is not a " % json_source+
+ "%s" % str(val_type), 28)
+
+def _CreateNewAln(trg_name, trg_seq, trg_start, trg_end, tpl_name, tpl_seq,
+ tpl_offset):
+ # iternal function to makes things easier in other places, pylint ignored
+ #pylint: disable=too-many-arguments
+ '''Produce a new target-template alignment
+ '''
+ new_aln = seq.CreateAlignment(seq.CreateSequence(\
+ trg_name,
+ trg_seq[trg_start:trg_end]),
+ seq.CreateSequence(tpl_name, tpl_seq))
+ new_aln.SetSequenceRole(0, 'TARGET')
+ new_aln.SetSequenceRole(1, 'TEMPLATE')
+ new_aln.SetSequenceOffset(1, tpl_offset)
+ return new_aln
+
+def _GetAlnFromJSON(json_object, json_source):
+ """Create alignments from a JSON object.
+
+ Iterate the alignments in a JSON object and deliver OST alignments via the
+ yield operator.
+ """
+ # alignments are stored via the 'alignmentlist' key
+ if 'alignmentlist' not in json_object.keys():
+ helper.MsgErrorAndExit("JSON object from '%s' does not " % json_source+
+ "provide an 'alignmentlist' key.", 21)
+ # alignments come as lists, to enable hetero oligos
+ if not type(json_object['alignmentlist']) is list:
+ helper.MsgErrorAndExit("JSON object from '%s' does not" % json_source+
+ "provide a list behind 'alignmentlist'.", 24)
+ # take the alignments apart, each alignment is a dictionary
+ for json_aln in json_object['alignmentlist']:
+ # json_aln needs to be a dictionary
+ if not type(json_aln) is dict:
+ helper.MsgErrorAndExit("JSON 'alignmentlist' member from "+
+ "'%s' is not a ' " % json_source+
+ " dictionary: %s" % json_aln, 25)
+ # an alignment has a 'target' and a 'template' dictionary
+ # each of them has a 'name' and a 'seqres' pair
+ for flav in ['target', 'template']:
+ if flav not in json_aln.keys():
+ helper.MsgErrorAndExit("JSON 'alignmentlist' from "+
+ "'%s' does not " % json_source+
+ "provide a '%s' key." % flav, 22)
+ # check sequence to be dictionary
+ if not type(json_aln[flav]) is dict:
+ helper.MsgErrorAndExit("JSON 'alignmentlist' '%s' from" % flav+
+ "'%s' is not a " % json_source+
+ "dictionary: %s" % json_aln[flav], 26)
+ # check for keys needed by both sequences:
+ for aln_key in ['name', 'seqres']:
+ _CheckJSONAlnSeqKeyType(aln_key, str, json_aln, flav,
+ json_source)
+ _CheckJSONAlnSeqKeyType('offset', int, json_aln, 'template',
+ json_source)
+
+ yield _CreateNewAln(str(json_aln['target']['name']).strip(),
+ str(json_aln['target']['seqres']),
+ 0,
+ len(json_aln['target']['seqres']),
+ str(json_aln['template']['name']).strip(),
+ str(json_aln['template']['seqres']),
+ json_aln['template']['offset'])
+
+def _GetJSONOBject(json_input):
+ """Get a JSON object out of a string which may be an object or a path.
+
+ If the input string starts with '{', we assume its a JSON object. File names
+ starting with '{' would be a bit weird.
+
+ If we are looking at a file, check and load it.
+
+ For a JSON object, check that everything is there. No checks for
+ superfluous stuff.
+
+ As returnvalue we only use JSON objects.
+ """
+ if json_input[0] != '{':
+ is_gz = helper.FileGzip("JSON alignment", 13, json_input)
+ readfile = json_input
+ if is_gz:
+ unzip_file = _TmpForGZip(json_input, '.json', "JSON alignment")
+ readfile = unzip_file.name
+ try:
+ jfh = open(readfile)
+ except IOError, ioe:
+ helper.MsgErrorAndExit("'--json' file '%s' " % json_input+
+ "can not be processed: %s" % ioe.strerror,
+ 19)
+ except:
+ raise
+ try:
+ json_object = json.load(jfh)
+ except ValueError, vae:
+ if vae.message == 'No JSON object could be decoded':
+ helper.MsgErrorAndExit("'--json' file '%s' could " % json_input+
+ "not be processed into a JSON object, "+
+ "probably it's empty.", 20)
+ else:
+ raise
+ except:
+ raise
+ jfh.close()
+ else:
+ try:
+ json_object = json.loads(json_input)
+ except ValueError, vae:
+ helper.MsgErrorAndExit("'--json' string '%s' " % json_input+\
+ "could not be decoded: %s" % vae.message, 23)
+ return json_object
+
def _GetTrgNameSeqFile(argstr):
"""Sort out what is target name and what is the sequence file name.
@@ -50,13 +197,7 @@ def _FetchAlnFromFastaOpt(argstr):
# loading the alignment, switch for gzip
readfile = seqfile
if is_gz:
- zip_fh = gzip.open(seqfile)
- unzip_str = zip_fh.read()
- zip_fh.close()
- unzip_file = tempfile.NamedTemporaryFile(mode='w',
- suffix='.fas')
- unzip_file.write(unzip_str)
- unzip_file.flush()
+ unzip_file = _TmpForGZip(seqfile, '.fas', "Alignment")
readfile = unzip_file.name
try:
aln = io.LoadAlignment(readfile, format="fasta")
@@ -114,12 +255,8 @@ def _AssembleTrgTplAln(target, template):
tpl_str = ''
for i in range(start, end):
tpl_str += template[i]
- new_aln = seq.CreateAlignment(seq.CreateSequence(target.name.strip(),
- str(target)[start:end]),
- seq.CreateSequence(template.name.strip(),
- tpl_str))
- new_aln.SetSequenceOffset(1, start)
- return new_aln
+ return _CreateNewAln(target.name.strip(), str(target), start, end,
+ template.name.strip(), tpl_str, start)
class PM3StoreOnceAction(argparse.Action):
@@ -207,7 +344,7 @@ class PM3ArgumentParser(argparse.ArgumentParser):
:param args: The argument string. As default |sysargv|_ is used.
:type args: :class:`list`
- :returns: :class:`promod3.cor.pm3argparse.PM3OptionsNamespace`.
+ :returns: :class:`promod3.core.pm3argparse.PM3OptionsNamespace`.
"""
opts = PM3OptionsNamespace()
self.parse_args(args=args, namespace=opts)
@@ -227,7 +364,8 @@ class PM3ArgumentParser(argparse.ArgumentParser):
self._AssembleAlignment()
def AddAlignment(self):
- """
+ """Commandline options for alignments.
+
Add everything needed to load alignments to the argument parser. Creates
several options/ arguments and adds some checks for post processing.
This method only adds a flag to the parser to add alignment options on
@@ -263,6 +401,29 @@ class PM3ArgumentParser(argparse.ArgumentParser):
* 18 - sequences in the alignment have different length
+ * 19 - problem with a JSON formatted file handed over to ``--json``
+
+ * 20 - JSON file could not be decoded into a JSON object
+
+ * 21 - JSON object has no 'alignmentlist' key
+
+ * 22 - JSON object has no 'target'/ 'template' in the 'alignmentlist'
+
+ * 23 - JSON string could not be decoded
+
+ * 24 - JSON object 'alignmentlist' does not point to a list
+
+ * 25 - JSON object 'alignmentlist' member is not a dictionary
+
+ * 26 - JSON object 'alignmentlist' 'target'/ 'template' does not point
+ to a dictionary
+
+ * 27 - JSON object 'alignmentlist' 'target'/ 'template' does not have
+ a needed key
+
+ * 28 - JSON object 'alignmentlist' 'target'/ 'template' has a value of
+ wrong type
+
Attributes added to the namespace returned by
:meth:`Parse`:
@@ -273,7 +434,10 @@ class PM3ArgumentParser(argparse.ArgumentParser):
be a filename of a JSON object string.
* :attr:`alignments` - :class:`ost.AlignmentList`, same order as
- :attr:`fasta`
+ :attr:`fasta`, likely to **not** follow the order
+ of JSON input; first sequence of the alignment is
+ the target sequence, if in doubt, check for
+ sequence roles ``TARGET`` or ``TEMPLATE``
* :attr:`aln_sources` - the original source of the alignment, may be
filename(s) or a string in JSON format,
@@ -307,6 +471,8 @@ class PM3ArgumentParser(argparse.ArgumentParser):
action=PM3StoreOnceAction)
class PM3OptionsNamespace(object):
+ # class will grow, so for the moment pylint is ignored
+ #pylint: disable=too-few-public-methods
"""
This one is mainly for internal use. You can use it like everything that
comes out of :meth:`argparse.ArgumentParser.parse_args`. Attributes are
@@ -338,6 +504,11 @@ class PM3OptionsNamespace(object):
return
# Now for JSON input. Since one of the options needs to be given and
# we already checked for FastA, no need to open a new branch, here.
+ # decide if file or object
+ json_obj = _GetJSONOBject(self.json)
+ for aln in _GetAlnFromJSON(json_obj, self.json):
+ self.alignments.append(aln)
+ self.aln_sources.append(self.json)
# LocalWords: param attr prog argparse ArgumentParser bool sys os init str
# LocalWords: progattr descattr argpinit argv formatter meth args namespace
diff --git a/core/tests/test_pm3argparse.py b/core/tests/test_pm3argparse.py
index d2101615d3955a6937fffcaa46a599ce67b0e07b..350a37a86c7d83a15ab544cf419a26e190f36c30 100644
--- a/core/tests/test_pm3argparse.py
+++ b/core/tests/test_pm3argparse.py
@@ -3,6 +3,12 @@ Testing our own little argument parser.
"""
import unittest
+import tempfile
+import gzip
+try:
+ import ujson as json
+except ImportError:
+ import json
import ost
from promod3.core import pm3argparse
@@ -23,6 +29,27 @@ class _FetchLog(ost.LogSink):
self.messages[level] = list()
self.messages[level].append(message.strip())
+def _GetJsonTestObj():
+ '''Create a JSOn object for testing
+ '''
+ obj = dict()
+ ali = dict()
+ ali['target'] = {'name': 'TARGET',
+ 'seqres':
+ 'VLSPADKTNVKAAWGKVGAHAGEYGAEALERMFLSFPTTKTYFPHF-DLS-----'+
+ 'HGSAQVKGHGKKVADALTNAVAHVDDMPNALSALSDLHAHK-LRVDPVNFKLLSH'+
+ 'CLLVTLAAHLPAEFTPAVHASLDKFLASVSTVLTSKYR'}
+ ali['template'] = {'name': 'TEMPLATE',
+ 'seqres':
+ 'HLTPEEKSAVTALWGKVN--VDEVGGEALGRLLVVYPWTQRFFESFGDLSTPD'+
+ 'AVMGNPKVKAHGKKVLGAFSDGLAHLDNLKGTFATLSELHC-DKLHVDPENFR'+
+ 'LLGNVLVCVLAHHFGKEFTPPVQAAYQKVVAGVANALAHKYH',
+ 'offset': 0}
+ obj['alignmentlist'] = list()
+ obj['alignmentlist'].append(ali)
+
+ return obj
+
class PM3ArgParseTests(unittest.TestCase):
def setUp(self):
self.log = _FetchLog()
@@ -240,6 +267,21 @@ class PM3ArgParseTests(unittest.TestCase):
'target ELTTRKDDQEETVRKRLVEYHQMTAPLL--YYYYKEAEAGNTK'+
'YAKVDGTKPVAEVRADLEKILG\n1AKE.B ELTTRKDDQEETVRKRLVE'+
'YHQMTAPLIGYYYYSKEAEAGNTKYAKVDGTKPV---AEVRADLEK\n')
+ self.assertEqual(opts.json, None)
+
+ def testAddAlignmentGzipNoExist(self):
+ # using a gzip FastA file which does not exist
+ parser = pm3argparse.PM3ArgumentParser(__doc__, action=False)
+ parser.AddAlignment()
+ parser.AssembleParser()
+ with self.assertRaises(SystemExit) as ecd:
+ parser.Parse(['--fasta', 'trg:target',
+ 'data/fasta/notthere.fas.gz'])
+ self.assertEqual(ecd.exception.code, 12)
+ self.assertEqual(len(self.log.messages['ERROR']), 1)
+ self.assertEqual(self.log.messages['ERROR'][0],
+ "Alignment file does not exist: "+
+ "data/fasta/notthere.fas.gz")
def testAddAlignmentSwitchSeqs(self):
parser = pm3argparse.PM3ArgumentParser(__doc__, action=False)
@@ -348,15 +390,508 @@ class PM3ArgParseTests(unittest.TestCase):
'test_pm3argparse.py: error: argument -j/--json: '+
'expected one argument'])
- def testAddAlignmentJsonWorkingFile(self):
+ def testAddAlignmentJsonFileNoExist(self):
+ # fail when a non-existing file is handed over to --json
+ parser = pm3argparse.PM3ArgumentParser(__doc__, action=False)
+ parser.AddAlignment()
+ parser.AssembleParser()
+ with self.assertRaises(SystemExit) as ecd:
+ parser.Parse(['--json', 'fileshouldnotexist'])
+ self.assertEqual(ecd.exception.code, 19)
+ self.assertEqual(len(self.log.messages['ERROR']), 1)
+ self.assertEqual(self.log.messages['ERROR'],
+ ["'--json' file 'fileshouldnotexist' can not be "+
+ "processed: No such file or directory"])
+
+ def testAddAlignmentJsonGzipNoExist(self):
+ # lets see what happens on json with a missing gzip file
+ parser = pm3argparse.PM3ArgumentParser(__doc__, action=False)
+ parser.AddAlignment()
+ parser.AssembleParser()
+ with self.assertRaises(SystemExit) as ecd:
+ parser.Parse(['--json', 'fileshouldnotexist.gzip'])
+ self.assertEqual(ecd.exception.code, 19)
+ self.assertEqual(len(self.log.messages['ERROR']), 1)
+ self.assertEqual(self.log.messages['ERROR'],
+ ["'--json' file 'fileshouldnotexist.gzip' can not be "+
+ "processed: No such file or directory"])
+
+ def testAddAlignmentJsonEmptyFile(self):
+ # we want to fail on empty JSON files
+ parser = pm3argparse.PM3ArgumentParser(__doc__, action=False)
+ parser.AddAlignment()
+ parser.AssembleParser()
+ tmp_ali = tempfile.NamedTemporaryFile(suffix='.json')
+ with self.assertRaises(SystemExit) as ecd:
+ parser.Parse(['--json', tmp_ali.name])
+ tmp_ali.close()
+ self.assertEqual(ecd.exception.code, 20)
+ self.assertEqual(len(self.log.messages['ERROR']), 1)
+ self.assertEqual(self.log.messages['ERROR'],
+ ["'--json' file '%s' could not be " % tmp_ali.name+
+ "processed into a JSON object, probably it's empty."])
+
+ def testAddAlignmentJsonNoAlnLstLstKey(self):
+ # check that 'alignmentlist' features a list
+ parser = pm3argparse.PM3ArgumentParser(__doc__, action=False)
+ parser.AddAlignment()
+ parser.AssembleParser()
+ json_str = json.dumps({'alignmentlist': "I'm not a list!"})
+ with self.assertRaises(SystemExit) as ecd:
+ parser.Parse(['--json', json_str])
+ self.assertEqual(ecd.exception.code, 24)
+ self.assertEqual(len(self.log.messages['ERROR']), 1)
+ self.assertEqual(self.log.messages['ERROR'],
+ ['JSON object from \'{"alignmentlist": "I\'m not a '+
+ 'list!"}\' does notprovide a list behind '+
+ '\'alignmentlist\'.'])
+
+ def testAddAlignmentJsonMalString(self):
+ # fail on improper JSON string
+ parser = pm3argparse.PM3ArgumentParser(__doc__, action=False)
+ parser.AddAlignment()
+ parser.AssembleParser()
+ json_obj = "{'Wrong': 'wrong'}"
+ with self.assertRaises(SystemExit) as ecd:
+ parser.Parse(['--json', json_obj])
+ self.assertEqual(ecd.exception.code, 23)
+ self.assertEqual(len(self.log.messages['ERROR']), 1)
+ self.assertEqual(self.log.messages['ERROR'],
+ ["'--json' string '{'Wrong': 'wrong'}' could not be "+
+ "decoded: Expecting property name: line 1 column 2 "+
+ "(char 1)"])
+
+ def testAddAlignmentJsonNoAlnLstKey(self):
+ # detect missing key 'alignmentlist
+ parser = pm3argparse.PM3ArgumentParser(__doc__, action=False)
+ parser.AddAlignment()
+ parser.AssembleParser()
+ json_obj = json.dumps({"Sth different": "Foo"})
+ with self.assertRaises(SystemExit) as ecd:
+ parser.Parse(['--json', json_obj])
+ self.assertEqual(ecd.exception.code, 21)
+ self.assertEqual(len(self.log.messages['ERROR']), 1)
+ self.assertEqual(self.log.messages['ERROR'],
+ ['JSON object from \'{"Sth different": "Foo"}\' '+
+ 'does not provide an \'alignmentlist\' key.'])
+
+ def testAddAlignmentJsonNoTargetKey(self):
+ # check that 'alignmentlist'target' is required
+ parser = pm3argparse.PM3ArgumentParser(__doc__, action=False)
+ parser.AddAlignment()
+ parser.AssembleParser()
+ json_str = json.dumps({'alignmentlist': [{'Foo': 'BAR'}]})
+ with self.assertRaises(SystemExit) as ecd:
+ parser.Parse(['--json', json_str])
+ self.assertEqual(ecd.exception.code, 22)
+ self.assertEqual(len(self.log.messages['ERROR']), 1)
+ self.assertEqual(self.log.messages['ERROR'],
+ ['JSON \'alignmentlist\' from \'{"alignmentlist": '+
+ '[{"Foo": "BAR"}]}\' does not provide a \'target\' '+
+ 'key.'])
+
+ def testAddAlignmentJsonNoTemplateKey(self):
+ # check that 'alignmentlist'template' is required
+ parser = pm3argparse.PM3ArgumentParser(__doc__, action=False)
+ parser.AddAlignment()
+ parser.AssembleParser()
+ json_str = json.dumps({'alignmentlist': [{'target': {'name' : 'AAA',
+ 'seqres': 'AA'}}]})
+ with self.assertRaises(SystemExit) as ecd:
+ parser.Parse(['--json', json_str])
+ self.assertEqual(ecd.exception.code, 22)
+ self.assertEqual(len(self.log.messages['ERROR']), 1)
+ self.assertEqual(self.log.messages['ERROR'],
+ ['JSON \'alignmentlist\' from \'{"alignmentlist": '+
+ '[{"target": {"seqres": "AA", "name": "AAA"}}]}\' '+
+ 'does not provide a \'template\' key.'])
+
+ def testAddAlignmentJsonAlnTrgNoDict(self):
+ # entries of the alignmentlist need to be dict's
+ parser = pm3argparse.PM3ArgumentParser(__doc__, action=False)
+ parser.AddAlignment()
+ parser.AssembleParser()
+ json_str = json.dumps({'alignmentlist': ['Seq1', 'Seq2']})
+ with self.assertRaises(SystemExit) as ecd:
+ parser.Parse(['--json', json_str])
+ self.assertEqual(ecd.exception.code, 25)
+ self.assertEqual(len(self.log.messages['ERROR']), 1)
+ self.assertEqual(self.log.messages['ERROR'],
+ ['JSON \'alignmentlist\' member from '+
+ '\'{"alignmentlist": ["Seq1", "Seq2"]}\' is not '+
+ 'a \' dictionary: Seq1'])
+
+ def testAddAlignmentJsonAlnTrgNotDict(self):
+ # entries of the alignmentlist need to be dict's of dict's
+ parser = pm3argparse.PM3ArgumentParser(__doc__, action=False)
+ parser.AddAlignment()
+ parser.AssembleParser()
+ json_str = json.dumps({'alignmentlist': [{'target': 'AAA',
+ 'template': 'BBB'}]})
+ with self.assertRaises(SystemExit) as ecd:
+ parser.Parse(['--json', json_str])
+ self.assertEqual(ecd.exception.code, 26)
+ self.assertEqual(len(self.log.messages['ERROR']), 1)
+ self.assertEqual(self.log.messages['ERROR'],
+ ['JSON \'alignmentlist\' \'target\' '+
+ 'from\'{"alignmentlist": [{"target": "AAA", '+
+ '"template": "BBB"}]}\' is not a dictionary: AAA'])
+
+ def testAddAlignmentJsonAlnTrgNoNameNoSeqres(self):
+ # entries of the alignmentlist need to be dict's
+ parser = pm3argparse.PM3ArgumentParser(__doc__, action=False)
+ parser.AddAlignment()
+ parser.AssembleParser()
+ json_str = json.dumps({'alignmentlist': [{'target': {'AAA': 1},
+ 'template': {'BBB': 2}}]})
+ with self.assertRaises(SystemExit) as ecd:
+ parser.Parse(['--json', json_str])
+ self.assertEqual(ecd.exception.code, 27)
+ self.assertEqual(len(self.log.messages['ERROR']), 1)
+ self.assertEqual(self.log.messages['ERROR'],
+ ['JSON \'alignmentlist\' \'target\' from '+
+ '\'{"alignmentlist": [{"target": {"AAA": 1}, '+
+ '"template": {"BBB": 2}}]}\' is missing the '+
+ '\'name\' key'])
+
+ def testAddAlignmentJsonAlnTrgTplNoString(self):
+ # entries of the sequence dict in an aln need to be str
+ parser = pm3argparse.PM3ArgumentParser(__doc__, action=False)
+ parser.AddAlignment()
+ parser.AssembleParser()
+ json_str = json.dumps({'alignmentlist': [{'target': {'name': 1,
+ 'seqres': 2},
+ 'template': {'name': 2,
+ 'seqres': 2}}]})
+ with self.assertRaises(SystemExit) as ecd:
+ parser.Parse(['--json', json_str])
+ self.assertEqual(ecd.exception.code, 28)
+ self.assertEqual(len(self.log.messages['ERROR']), 1)
+ self.assertEqual(self.log.messages['ERROR'],
+ ['JSON \'alignmentlist\' \'target\' \'name\' '+
+ 'from\'{"alignmentlist": [{"target": {"seqres": 2, '+
+ '"name": 1}, "template": {"seqres": 2, "name": '+
+ '2}}]}\' is not a <type \'str\'>'])
+
+ def testAddAlignmentJsonAlnTplNoOffset(self):
+ # no offset for template sequence
+ parser = pm3argparse.PM3ArgumentParser(__doc__, action=False)
+ parser.AddAlignment()
+ parser.AssembleParser()
+ json_str = json.dumps({'alignmentlist': [{'target': {'name': 'A',
+ 'seqres': 'AA'},
+ 'template': {'name': 'A',
+ 'seqres': 'AA'}}
+ ]})
+ with self.assertRaises(SystemExit) as ecd:
+ parser.Parse(['--json', json_str])
+ self.assertEqual(ecd.exception.code, 27)
+ self.assertEqual(len(self.log.messages['ERROR']), 1)
+ self.assertEqual(self.log.messages['ERROR'],
+ ['JSON \'alignmentlist\' \'template\' from '+
+ '\'{"alignmentlist": [{"target": {"seqres": "AA", '+
+ '"name": "A"}, "template": {"seqres": "AA", '+
+ '"name": "A"}}]}\' is missing the \'offset\' key'])
+
+ def testAddAlignmentJsonAlnTplOffsetStr(self):
+ # entries of the alignmentlist need to be dict's
+ parser = pm3argparse.PM3ArgumentParser(__doc__, action=False)
+ parser.AddAlignment()
+ parser.AssembleParser()
+ json_str = json.dumps({'alignmentlist': [{'target': {'name': 'A',
+ 'seqres': 'AA'},
+ 'template': {'name': 'A',
+ 'seqres': 'AA',
+ 'offset': '0'}}
+ ]})
+ with self.assertRaises(SystemExit) as ecd:
+ parser.Parse(['--json', json_str])
+ self.assertEqual(ecd.exception.code, 28)
+ self.assertEqual(len(self.log.messages['ERROR']), 1)
+ self.assertEqual(self.log.messages['ERROR'],
+ ['JSON \'alignmentlist\' \'template\' \'offset\' '+
+ 'from\'{"alignmentlist": [{"target": {"seqres": '+
+ '"AA", "name": "A"}, "template": {"seqres": "AA", '+
+ '"name": "A", "offset": "0"}}]}\' is not a <type '+
+ '\'int\'>'])
+
+ def testAddAlignmentJsonAlnString(self):
+ # entries of the alignmentlist need to be dict's
+ parser = pm3argparse.PM3ArgumentParser(__doc__, action=False)
+ parser.AddAlignment()
+ parser.AssembleParser()
+ json_str = json.dumps({'alignmentlist':
+ [{'target':
+ {'name': 'target',
+ 'seqres':
+ 'APGAGKGTQAQFIMEKYGIPQISTGGGLRAAVKS---LGKQA'+
+ 'KDIMDAGKLVTDELVIALVKERIAQEDCRNGFLLDGFPRTIP'+
+ 'QADAMKEAGINVDYVLEF----ELIVDRIVGRRVHAPSGRVY'+
+ 'HVKFNPPKVEGKDDVTGEELTTRKDDQEETVRKRLVEYHQMT'+
+ 'APLL--YYYYKEAEAGNTKYAKVDGTKPVAEVRADLEKILG'},
+ 'template':
+ {'name': '1AKE.B',
+ 'seqres':
+ 'APGAGKGTQAQFIMEKYGIPQISTGDMLRAAVKSGSELGKQA'+
+ 'KDIMDAGKLVTDELVIALVKERIAQEDCRNGFLLDGFPRTIP'+
+ 'QADAMKEAGINVDYVLEFDVPDELIVDRIVGRRVHAPSGRVY'+
+ 'HVKFNPPKVEGKDDVTGEELTTRKDDQEETVRKRLVEYHQMT'+
+ 'APLIGYYYYSKEAEAGNTKYAKVDGTKPV---AEVRADLEK',
+ 'offset': 7}}]})
+ opts = parser.Parse(['--json', json_str])
+ self.assertEqual(len(opts.alignments), 1)
+ self.assertEqual(opts.alignments[0].GetCount(), 2)
+ self.assertEqual(opts.alignments[0].GetLength(), 209)
+ self.assertEqual(opts.alignments[0].GetSequenceOffset(0), 0)
+ self.assertEqual(opts.alignments[0].GetSequenceOffset(1), 7)
+ self.assertEqual(opts.alignments[0].GetSequence(0).gapless_string,
+ 'APGAGKGTQAQFIMEKYGIPQISTGGGLRAAVKSLGKQAKDIMDAGKLVT'+
+ 'DELVIALVKERIAQEDCRNGFLLDGFPRTIPQADAMKEAGINVDYVLEFE'+
+ 'LIVDRIVGRRVHAPSGRVYHVKFNPPKVEGKDDVTGEELTTRKDDQEETV'+
+ 'RKRLVEYHQMTAPLLYYYYKEAEAGNTKYAKVDGTKPVAEVRADLEKILG')
+ self.assertEqual(opts.alignments[0].GetSequenceRole(0), 'TARGET')
+ self.assertEqual(opts.alignments[0].GetSequenceRole(1), 'TEMPLATE')
+ self.assertEqual(opts.alignments[0].GetSequence(0).name, 'target')
+ self.assertEqual(opts.alignments[0].GetSequence(1).name, '1AKE.B')
+ self.assertEqual(str(opts.alignments[0]),
+ 'target APGAGKGTQAQFIMEKYGIPQISTGGGLRAAVKS---LGKQAK'+
+ 'DIMDAGKLVTDELVIALVKERIAQEDCRN\n1AKE.B APGAGKGTQAQF'+
+ 'IMEKYGIPQISTGDMLRAAVKSGSELGKQAKDIMDAGKLVTDELVIALVKE'+
+ 'RIAQEDCRN\n\ntarget GFLLDGFPRTIPQADAMKEAGINVDYVLEF'+
+ '----ELIVDRIVGRRVHAPSGRVYHVKFNPPKVEGKDDVTGE\n1AKE.B '+
+ ' GFLLDGFPRTIPQADAMKEAGINVDYVLEFDVPDELIVDRIVGRRVHAPS'+
+ 'GRVYHVKFNPPKVEGKDDVTGE\n\ntarget ELTTRKDDQEETVRKRL'+
+ 'VEYHQMTAPLL--YYYYKEAEAGNTKYAKVDGTKPVAEVRADLEKILG\n1'+
+ 'AKE.B ELTTRKDDQEETVRKRLVEYHQMTAPLIGYYYYSKEAEAGNTKY'+
+ 'AKVDGTKPV---AEVRADLEK\n')
+ self.assertEqual(len(opts.aln_sources), 1)
+ self.assertEqual(opts.aln_sources[0],
+ '{"alignmentlist": [{"target": {"seqres": "APGAGKGTQ'+
+ 'AQFIMEKYGIPQISTGGGLRAAVKS---LGKQAKDIMDAGKLVTDELVIAL'+
+ 'VKERIAQEDCRNGFLLDGFPRTIPQADAMKEAGINVDYVLEF----ELIVD'+
+ 'RIVGRRVHAPSGRVYHVKFNPPKVEGKDDVTGEELTTRKDDQEETVRKRLV'+
+ 'EYHQMTAPLL--YYYYKEAEAGNTKYAKVDGTKPVAEVRADLEKILG", "'+
+ 'name": "target"}, "template": {"seqres": "APGAGKGTQ'+
+ 'AQFIMEKYGIPQISTGDMLRAAVKSGSELGKQAKDIMDAGKLVTDELVIAL'+
+ 'VKERIAQEDCRNGFLLDGFPRTIPQADAMKEAGINVDYVLEFDVPDELIVD'+
+ 'RIVGRRVHAPSGRVYHVKFNPPKVEGKDDVTGEELTTRKDDQEETVRKRLV'+
+ 'EYHQMTAPLIGYYYYSKEAEAGNTKYAKVDGTKPV---AEVRADLEK", "'+
+ 'name": "1AKE.B", "offset": 7}}]}')
+
+ def testAddAlignmentJsonAlnMultiString(self):
+ # test multiple alignments
+ parser = pm3argparse.PM3ArgumentParser(__doc__, action=False)
+ parser.AddAlignment()
+ parser.AssembleParser()
+ json_str = json.dumps({'alignmentlist':
+ [{'target':
+ {'name': ' target 1',
+ 'seqres':
+ 'VLSPADKTNVKAAWGKVGAHAGEYGAEALERMFLSFPTTKTY'+
+ 'FPHF-DL-S----HGSAQVKGHGKKVADALTNAVAHVDDMPN'+
+ 'ALSALSDLHAHK-LRVDPVNFKLLSHCLLVTLAAHLPAEFTP'+
+ 'AVHASLDKFLASVSTVLTSKYR'},
+ 'template':
+ {'name': '3e7b90809bd446a5',
+ 'seqres':
+ 'VLSEGEWQLVLHVWAKVEADVAGHGQDILIRLFKSHPETLEK'+
+ 'FDRFKHLKTEAEMKASEDLKKHGVTVLTALGAILKKKGHHEA'+
+ 'ELKPLAQSHA-TKHKIPIKYLEFISEAIIHVLHSRHPGDFGA'+
+ 'DAQGAMNKALELFRKDIAAKYK',
+ 'offset': 1}},
+ {'target':
+ {'name': 'target 2',
+ 'seqres':
+ 'VLSPADKTNVKAAWGKVGAHAGEYGAEALERMFLSFPTTKTY'+
+ 'FPHFDLSHGSAQVKGHGKKVADALTNAVAHVDDMPNALSALS'+
+ 'DLHAHKLRVDPVNFKLLSHCLLVTLAAHLPAEFTPAVHASLD'+
+ 'KFLASVSTVLTSKYR'},
+ 'template':
+ {'name': 'af828e69a5f2d0fd',
+ 'seqres':
+ 'VLSPADKTNVKAAWGKVGAHAGEYGAEALERMFLSFPTTKTY'+
+ 'FPHFDLSHGSAQVKGHGKKVADALTNAVAHVDDMPNALSALS'+
+ 'DLHAHKLRVDPVNFKLLSHCLLVTLAAHLPAEFTPAVHASLD'+
+ 'KFLASVSTVLTSKYR',
+ 'offset': 2}},
+ {'target':
+ {'name': 'target 3',
+ 'seqres':
+ 'VLSPADKTNVKAAWGKVGAHAGEYGAEALERMFLSFPTTKTY'+
+ 'FPHF-DLS-----HGSAQVKGHGKKVADALTNAVAHVDDMPN'+
+ 'ALSALSDLHAHK-LRVDPVNFKLLSHCLLVTLAAHLPAEFTP'+
+ 'AVHASLDKFLASVSTVLTSKYR'},
+ 'template':
+ {'name': '9287755aa6aa2758',
+ 'seqres':
+ 'HLTPEEKSAVTALWGKVN--VDEVGGEALGRLLVVYPWTQRF'+
+ 'FESFGDLSTPDAVMGNPKVKAHGKKVLGAFSDGLAHLDNLKG'+
+ 'TFATLSELHC-DKLHVDPENFRLLGNVLVCVLAHHFGKEFTP'+
+ 'PVQAAYQKVVAGVANALAHKYH',
+ 'offset': 3}},
+ {'target': {'name': 'target 4',
+ 'seqres': 'VDPVNFKLLSHCLLVTLAAHL'},
+ 'template': {'name': 'e69e1ac0a4b2554d',
+ 'seqres': 'ATPEQAQLVHKEIRKIVKDTC',
+ 'offset': 4}}]})
+ opts = parser.Parse(['--json', json_str])
+
+ self.assertEqual(len(opts.aln_sources), 1)
+ self.assertEqual(opts.aln_sources[0],
+ '{"alignmentlist": [{"target": {"seqres": "VLSPADKTN'+
+ 'VKAAWGKVGAHAGEYGAEALERMFLSFPTTKTYFPHF-DL-S----HGSAQ'+
+ 'VKGHGKKVADALTNAVAHVDDMPNALSALSDLHAHK-LRVDPVNFKLLSHC'+
+ 'LLVTLAAHLPAEFTPAVHASLDKFLASVSTVLTSKYR", "name": " ta'+
+ 'rget 1"}, "template": {"seqres": "VLSEGEWQLVLHVWAKV'+
+ 'EADVAGHGQDILIRLFKSHPETLEKFDRFKHLKTEAEMKASEDLKKHGVTV'+
+ 'LTALGAILKKKGHHEAELKPLAQSHA-TKHKIPIKYLEFISEAIIHVLHSR'+
+ 'HPGDFGADAQGAMNKALELFRKDIAAKYK", "name": "3e7b90809b'+
+ 'd446a5", "offset": 1}}, {"target": {"seqres": "VLSP'+
+ 'ADKTNVKAAWGKVGAHAGEYGAEALERMFLSFPTTKTYFPHFDLSHGSAQV'+
+ 'KGHGKKVADALTNAVAHVDDMPNALSALSDLHAHKLRVDPVNFKLLSHCLL'+
+ 'VTLAAHLPAEFTPAVHASLDKFLASVSTVLTSKYR", "name": "targ'+
+ 'et 2"}, "template": {"seqres": "VLSPADKTNVKAAWGKVGA'+
+ 'HAGEYGAEALERMFLSFPTTKTYFPHFDLSHGSAQVKGHGKKVADALTNAV'+
+ 'AHVDDMPNALSALSDLHAHKLRVDPVNFKLLSHCLLVTLAAHLPAEFTPAV'+
+ 'HASLDKFLASVSTVLTSKYR", "name": "af828e69a5f2d0fd", '+
+ '"offset": 2}}, {"target": {"seqres": "VLSPADKTNVKAA'+
+ 'WGKVGAHAGEYGAEALERMFLSFPTTKTYFPHF-DLS-----HGSAQVKGH'+
+ 'GKKVADALTNAVAHVDDMPNALSALSDLHAHK-LRVDPVNFKLLSHCLLVT'+
+ 'LAAHLPAEFTPAVHASLDKFLASVSTVLTSKYR", "name": "target'+
+ ' 3"}, "template": {"seqres": "HLTPEEKSAVTALWGKVN--V'+
+ 'DEVGGEALGRLLVVYPWTQRFFESFGDLSTPDAVMGNPKVKAHGKKVLGAF'+
+ 'SDGLAHLDNLKGTFATLSELHC-DKLHVDPENFRLLGNVLVCVLAHHFGKE'+
+ 'FTPPVQAAYQKVVAGVANALAHKYH", "name": "9287755aa6aa27'+
+ '58", "offset": 3}}, {"target": {"seqres": "VDPVNFKL'+
+ 'LSHCLLVTLAAHL", "name": "target 4"}, "template": {"'+
+ 'seqres": "ATPEQAQLVHKEIRKIVKDTC", "name": "e69e1ac0'+
+ 'a4b2554d", "offset": 4}}]}')
+ self.assertEqual(len(opts.alignments), 4)
+ # aln 1
+ self.assertEqual(opts.alignments[0].GetCount(), 2)
+ self.assertEqual(opts.alignments[0].GetLength(), 148)
+ self.assertEqual(opts.alignments[0].GetSequenceOffset(0), 0)
+ self.assertEqual(opts.alignments[0].GetSequenceOffset(1), 1)
+ self.assertEqual(opts.alignments[0].GetSequenceRole(0), 'TARGET')
+ self.assertEqual(opts.alignments[0].GetSequenceRole(1), 'TEMPLATE')
+ self.assertEqual(opts.alignments[0].GetSequence(0).name, 'target 1')
+ self.assertEqual(opts.alignments[0].GetSequence(1).name,
+ '3e7b90809bd446a5')
+ self.assertEqual(str(opts.alignments[0]),
+ 'target 1 VLSPADKTNVKAAWGKVGAHAGEYGAEALERMF'+
+ 'LSFPTTKTYFPHF-DL-S----HGSAQVK\n3e7b90809bd446a5 VL'+
+ 'SEGEWQLVLHVWAKVEADVAGHGQDILIRLFKSHPETLEKFDRFKHLKTEA'+
+ 'EMKASEDLK\n\ntarget 1 GHGKKVADALTNAVAHVDDM'+
+ 'PNALSALSDLHAHK-LRVDPVNFKLLSHCLLVTLAAHLPAEF\n3e7b908'+
+ '09bd446a5 KHGVTVLTALGAILKKKGHHEAELKPLAQSHA-TKHKIPI'+
+ 'KYLEFISEAIIHVLHSRHPGDF\n\ntarget 1 TPAVHAS'+
+ 'LDKFLASVSTVLTSKYR\n3e7b90809bd446a5 GADAQGAMNKALEL'+
+ 'FRKDIAAKYK\n')
+
+ # aln 2
+ self.assertEqual(opts.alignments[1].GetCount(), 2)
+ self.assertEqual(opts.alignments[1].GetLength(), 141)
+ self.assertEqual(opts.alignments[1].GetSequenceOffset(0), 0)
+ self.assertEqual(opts.alignments[1].GetSequenceOffset(1), 2)
+ self.assertEqual(opts.alignments[1].GetSequenceRole(0), 'TARGET')
+ self.assertEqual(opts.alignments[1].GetSequenceRole(1), 'TEMPLATE')
+ self.assertEqual(opts.alignments[1].GetSequence(0).name, 'target 2')
+ self.assertEqual(opts.alignments[1].GetSequence(1).name,
+ 'af828e69a5f2d0fd')
+ self.assertEqual(str(opts.alignments[1]),
+ 'target 2 VLSPADKTNVKAAWGKVGAHAGEYGAEALERMF'+
+ 'LSFPTTKTYFPHFDLSHGSAQVKGHGKKV\naf828e69a5f2d0fd VL'+
+ 'SPADKTNVKAAWGKVGAHAGEYGAEALERMFLSFPTTKTYFPHFDLSHGSA'+
+ 'QVKGHGKKV\n\ntarget 2 ADALTNAVAHVDDMPNALSA'+
+ 'LSDLHAHKLRVDPVNFKLLSHCLLVTLAAHLPAEFTPAVHAS\naf828e6'+
+ '9a5f2d0fd ADALTNAVAHVDDMPNALSALSDLHAHKLRVDPVNFKLLS'+
+ 'HCLLVTLAAHLPAEFTPAVHAS\n\ntarget 2 LDKFLAS'+
+ 'VSTVLTSKYR\naf828e69a5f2d0fd LDKFLASVSTVLTSKYR\n')
+ # aln 3
+ self.assertEqual(opts.alignments[2].GetCount(), 2)
+ self.assertEqual(opts.alignments[2].GetLength(), 148)
+ self.assertEqual(opts.alignments[2].GetSequenceOffset(0), 0)
+ self.assertEqual(opts.alignments[2].GetSequenceOffset(1), 3)
+ self.assertEqual(opts.alignments[2].GetSequenceRole(0), 'TARGET')
+ self.assertEqual(opts.alignments[2].GetSequenceRole(1), 'TEMPLATE')
+ self.assertEqual(opts.alignments[2].GetSequence(0).name, 'target 3')
+ self.assertEqual(opts.alignments[2].GetSequence(1).name,
+ '9287755aa6aa2758')
+ self.assertEqual(str(opts.alignments[2]),
+ 'target 3 VLSPADKTNVKAAWGKVGAHAGEYGAEALERMF'+
+ 'LSFPTTKTYFPHF-DLS-----HGSAQVK\n9287755aa6aa2758 HL'+
+ 'TPEEKSAVTALWGKVN--VDEVGGEALGRLLVVYPWTQRFFESFGDLSTPD'+
+ 'AVMGNPKVK\n\ntarget 3 GHGKKVADALTNAVAHVDDM'+
+ 'PNALSALSDLHAHK-LRVDPVNFKLLSHCLLVTLAAHLPAEF\n9287755'+
+ 'aa6aa2758 AHGKKVLGAFSDGLAHLDNLKGTFATLSELHC-DKLHVDP'+
+ 'ENFRLLGNVLVCVLAHHFGKEF\n\ntarget 3 TPAVHAS'+
+ 'LDKFLASVSTVLTSKYR\n9287755aa6aa2758 TPPVQAAYQKVVAG'+
+ 'VANALAHKYH\n')
+ # aln 4
+ self.assertEqual(opts.alignments[3].GetCount(), 2)
+ self.assertEqual(opts.alignments[3].GetLength(), 21)
+ self.assertEqual(opts.alignments[3].GetSequenceOffset(0), 0)
+ self.assertEqual(opts.alignments[3].GetSequenceOffset(1), 4)
+ self.assertEqual(opts.alignments[3].GetSequenceRole(0), 'TARGET')
+ self.assertEqual(opts.alignments[3].GetSequenceRole(1), 'TEMPLATE')
+ self.assertEqual(opts.alignments[3].GetSequence(0).name, 'target 4')
+ self.assertEqual(opts.alignments[3].GetSequence(1).name,
+ 'e69e1ac0a4b2554d')
+ self.assertEqual(str(opts.alignments[3]),
+ 'target 4 VDPVNFKLLSHCLLVTLAAHL\ne69e1ac0a4'+
+ 'b2554d ATPEQAQLVHKEIRKIVKDTC\n')
+
+ def testAddAlignmentJsonWorkingGzipFile(self):
# positive test: everything works!
parser = pm3argparse.PM3ArgumentParser(__doc__, action=False)
parser.AddAlignment()
parser.AssembleParser()
- parser.Parse(['--json', 'foo bar'])
+ json_obj = _GetJsonTestObj()
+ tmp_json = tempfile.NamedTemporaryFile(suffix='.json.gz')
+ with gzip.open(tmp_json.name, 'wb') as gfh:
+ json.dump(json_obj, gfh)
+ tmp_json.flush()
+ opts = parser.Parse(['--json', tmp_json.name])
+ self.assertEqual(len(opts.aln_sources), 1)
+ self.assertEqual(opts.aln_sources[0], tmp_json.name)
+ self.assertEqual(len(opts.alignments), 1)
+ self.assertEqual(str(opts.alignments[0]),
+ 'TARGET VLSPADKTNVKAAWGKVGAHAGEYGAEALERMFLSFPTTKT'+
+ 'YFPHF-DLS-----HGSAQVKGHGKKVAD\nTEMPLATE HLTPEEKSAV'+
+ 'TALWGKVN--VDEVGGEALGRLLVVYPWTQRFFESFGDLSTPDAVMGNPKV'+
+ 'KAHGKKVLG\n\nTARGET ALTNAVAHVDDMPNALSALSDLHAHK-L'+
+ 'RVDPVNFKLLSHCLLVTLAAHLPAEFTPAVHASLDKFLASVS\nTEMPLAT'+
+ 'E AFSDGLAHLDNLKGTFATLSELHC-DKLHVDPENFRLLGNVLVCVLAH'+
+ 'HFGKEFTPPVQAAYQKVVAGVA\n\nTARGET TVLTSKYR\nTEMPL'+
+ 'ATE NALAHKYH\n')
-# test that json always needs an argument
-# test json with sth that is not a file and not a JSON object
+ def testAddAlignmentJsonWorkingFile(self):
+ # positive test: everything works!
+ parser = pm3argparse.PM3ArgumentParser(__doc__, action=False)
+ parser.AddAlignment()
+ parser.AssembleParser()
+ json_obj = _GetJsonTestObj()
+ tmp_json = tempfile.NamedTemporaryFile(suffix='.json')
+ json.dump(json_obj, tmp_json)
+ tmp_json.flush()
+ opts = parser.Parse(['--json', tmp_json.name])
+ self.assertEqual(len(opts.aln_sources), 1)
+ self.assertEqual(opts.aln_sources[0], tmp_json.name)
+ self.assertEqual(len(opts.alignments), 1)
+ self.assertEqual(str(opts.alignments[0]),
+ 'TARGET VLSPADKTNVKAAWGKVGAHAGEYGAEALERMFLSFPTTKT'+
+ 'YFPHF-DLS-----HGSAQVKGHGKKVAD\nTEMPLATE HLTPEEKSAV'+
+ 'TALWGKVN--VDEVGGEALGRLLVVYPWTQRFFESFGDLSTPDAVMGNPKV'+
+ 'KAHGKKVLG\n\nTARGET ALTNAVAHVDDMPNALSALSDLHAHK-L'+
+ 'RVDPVNFKLLSHCLLVTLAAHLPAEFTPAVHASLDKFLASVS\nTEMPLAT'+
+ 'E AFSDGLAHLDNLKGTFATLSELHC-DKLHVDPENFRLLGNVLVCVLAH'+
+ 'HFGKEFTPPVQAAYQKVVAGVA\n\nTARGET TVLTSKYR\nTEMPL'+
+ 'ATE NALAHKYH\n')
+ self.assertEqual(opts.fasta, None)
+
+# test options: --disable-aln check (for amino acids)
+# test options: --disable-input-checks (for all)
+# test option: --disable-mm-check (macromolecule)
if __name__ == "__main__":
from ost import testutils
diff --git a/extras/pre_commit/pm3_csc/filecheck/pylint-unittest-rc b/extras/pre_commit/pm3_csc/filecheck/pylint-unittest-rc
index 9fbc13a8ad1c5f942c0f520d56acd811db87a803..3f21e8ffcac9d7d939390395fa465894955efb22 100644
--- a/extras/pre_commit/pm3_csc/filecheck/pylint-unittest-rc
+++ b/extras/pre_commit/pm3_csc/filecheck/pylint-unittest-rc
@@ -173,10 +173,10 @@ module-rgx=(([a-z_][a-z0-9_]*)|([A-Z][a-zA-Z0-9]+))$
module-name-hint=(([a-z_][a-z0-9_]*)|([A-Z][a-zA-Z0-9]+))$
# Regular expression matching correct method names
-method-rgx=(?:setUp|(?:[_A-Z]|test[A-Z])[a-zA-Z0-9_]{2,30})$
+method-rgx=(?:setUp|(?:[_A-Z]|test[A-Z])[a-zA-Z0-9_]{2,40})$
# Naming hint for method names
-method-name-hint=(?:setUp|(?:[A-Z]|test[A-Z])[a-zA-Z0-9_]{2,30})$
+method-name-hint=(?:setUp|(?:[A-Z]|test[A-Z])[a-zA-Z0-9_]{2,40})$
# Regular expression which should only match function or class names that do
# not require a docstring.