Merge pull request #67 from johandahlberg/iseq_support

Support for iSeq, and improved org for testing

Author: matrulda

checkQC/app.py

@@ -60,7 +60,7 @@ def configure_and_run(self):
         try:
             config = ConfigFactory.from_config_path(self._config_file)
             parser_configurations = config.get("parser_configurations", None)
-            run_type_recognizer = RunTypeRecognizer(config=config, runfolder=self._runfolder)
+            run_type_recognizer = RunTypeRecognizer(runfolder=self._runfolder)
             instrument_and_reagent_version = run_type_recognizer.instrument_and_reagent_version()
 
             # TODO For now assume symmetric read lengths

checkQC/default_config/config.yaml

@@ -314,3 +314,20 @@ miseq_v3:
       - name: ReadsPerSampleHandler
         warning: unknown
         error: 9 # 50 % of threshold for clusters pass filter
+
+iseq_v1:
+  300:
+    handlers:
+      - name: ClusterPFHandler
+        warning: 4 # Millons of clusters
+        error: unknown
+      - name: Q30Handler
+        warning: 80 # Give percentage for reads greater than Q30
+        error: unknown # Give percentage for reads greater than Q30
+      - name: ErrorRateHandler
+        allow_missing_error_rate: False
+        warning: 1.5
+        error: unknown
+      - name: ReadsPerSampleHandler
+        warning: unknown
+        error: 2 # 50 % of threshold for clusters pass filter

checkQC/run_type_recognizer.py

@@ -1,9 +1,8 @@
 
-import os
 import logging
-import xmltodict
 
 from checkQC.exceptions import *
+from checkQC.runfolder_reader import RunfolderReader
 
 log = logging.getLogger(__name__)
 
@@ -57,6 +56,15 @@ def reagent_version(runtype_recognizer):
         """
         raise NotImplementedError
 
+class ISeq(IlluminaInstrument):
+
+    @staticmethod
+    def name():
+        return "iseq"
+
+    @staticmethod
+    def reagent_version(runtype_recognizer):
+        return "v1"
 
 class NovaSeq(IlluminaInstrument):
 
@@ -142,42 +150,18 @@ class RunTypeRecognizer(object):
     The runfolder needs to have a 'RunInfo.xml' and a '[R|r]unParameters.xml' file.
     """
 
-    def __init__(self, config, runfolder):
+    def __init__(self, runfolder, runfolder_reader=RunfolderReader()):
         """
         Create a RunTypeRecognizer instance
 
-        :param config: dictionary containing the app configuration
         :param runfolder: to gather data about
+        :param runfolder_reader: reader class for for runfolders, defaults to RunfolderReader. Here to make testing
+        easier.
         """
-        self._config = config
         self._runfolder = runfolder
-        try:
-            run_info_path = os.path.join(self._runfolder, "RunInfo.xml")
-            if not os.path.exists(run_info_path):
-                log.error("Could not find a RunInfo.xml in {}. Are you sure this is a runfolder?".format(run_info_path))
-                raise FileNotFoundError("Could not find {}".format(run_info_path))
-            with open(run_info_path) as f:
-                self.run_info = xmltodict.parse(f.read())
-        except FileNotFoundError:
-            raise RunInfoXMLNotFound("Could not find RunInfo.xml at {}".format(run_info_path))
+        self.run_info = runfolder_reader.read_run_info_xml(runfolder)
+        self.run_parameters = runfolder_reader.read_run_parameters_xml(runfolder)
 
-        try:
-            with open(self._find_run_parameters_xml()) as f:
-                self.run_parameters = xmltodict.parse(f.read())
-        except FileNotFoundError:
-            raise RunParametersNotFound("Could not find [R|r]unParameters.xml for runfolder {}".format(self._runfolder))
-
-    def _find_run_parameters_xml(self):
-        first_option = os.path.join(self._runfolder, "RunParameters.xml")
-        second_option = os.path.join(self._runfolder, "runParameters.xml")
-        if os.path.isfile(first_option):
-            return first_option
-        elif os.path.isfile(second_option):
-            return second_option
-        else:
-            log.error("Could not find [R|r]unParameters.xml in directory {}. "
-                      "Are you sure this is a runfolder?".format(self._runfolder))
-            raise FileNotFoundError("Could not find [R|r]unParameters.xml for runfolder {}".format(self._runfolder))
 
     def instrument_type(self):
         """
@@ -191,7 +175,8 @@ def instrument_type(self):
         machine_type_mappings = {"M": "miseq",
                                  "D": "hiseq2500",
                                  "ST": "hiseqx",
-                                 "A": "novaseq"}
+                                 "A": "novaseq",
+                                 "FFSP": "iseq"}
 
         for key, value in machine_type_mappings.items():
             if instrument_name.startswith(key):

checkQC/runfolder_reader.py

@@ -0,0 +1,65 @@
+
+import xmltodict
+import os
+import logging
+from checkQC.exceptions import RunParametersNotFound, RunInfoXMLNotFound
+
+log = logging.getLogger(__name__)
+
+
+class RunfolderReader(object):
+    """
+    This class provides methods to read files such as the runParameters.xml and RunInfo.xml files, which
+    often need to be read to pick up info about what type of run we are looking at etc.
+    """
+
+    @staticmethod
+    def read_run_parameters_xml(runfolder):
+        """
+        Read the run parameters of an Illumina instrument are recorded in a file called
+        runParameters or RunParameters depending on the exact instrument type. This method
+        will read it and return it as a dict.
+        :param runfolder: to look in
+        :return: the [R|r]unParameters.xml as a dict
+        :raises: RunParametersNotFound if no [R|r]unParameters.xml was found
+        """
+        try:
+            with open(RunfolderReader.find_run_parameters_xml(runfolder)) as f:
+                return xmltodict.parse(f.read())
+        except FileNotFoundError:
+            raise RunParametersNotFound("Could not find [R|r]unParameters.xml for runfolder {}".format(runfolder))
+
+    @staticmethod
+    def read_run_info_xml(runfolder):
+        """
+        Read the RunInfo.xml and return it as a dict
+        :param runfolder: to look in
+        :return: RunInfo.xml data as a dict
+        """
+        try:
+            run_info_path = os.path.join(runfolder, "RunInfo.xml")
+            if not os.path.exists(run_info_path):
+                log.error("Could not find a RunInfo.xml in {}. Are you sure this is a runfolder?".format(run_info_path))
+                raise FileNotFoundError("Could not find {}".format(run_info_path))
+            with open(run_info_path) as f:
+                return xmltodict.parse(f.read())
+        except FileNotFoundError:
+            raise RunInfoXMLNotFound("Could not find RunInfo.xml at {}".format(run_info_path))
+
+    @staticmethod
+    def find_run_parameters_xml(runfolder):
+        """
+        Finds the path to the [r|R]unParameters.xml
+        :param runfolder: to look in
+        :return: the path to the [r|R]unParameters.xml
+        """
+        first_option = os.path.join(runfolder, "RunParameters.xml")
+        second_option = os.path.join(runfolder, "runParameters.xml")
+        if os.path.isfile(first_option):
+            return first_option
+        elif os.path.isfile(second_option):
+            return second_option
+        else:
+            log.error("Could not find [R|r]unParameters.xml in directory {}. "
+                      "Are you sure this is a runfolder?".format(runfolder))
+            raise FileNotFoundError("Could not find [R|r]unParameters.xml for runfolder {}".format(runfolder))

tests/test_run_type_recognizer.py

@@ -1,17 +1,18 @@
 from unittest import TestCase
+import mock
 
 import os
 
 from checkQC.exceptions import RunModeUnknown, ReagentVersionUnknown
-from checkQC.run_type_recognizer import RunTypeRecognizer, HiSeq2500, MiSeq, NovaSeq
-class TestRunTypeRecognizer(TestCase):
+from checkQC.run_type_recognizer import RunTypeRecognizer, HiSeq2500, MiSeq, NovaSeq, ISeq
+from checkQC.runfolder_reader import RunfolderReader
 
-    CONFIG = {"instrument_type_mappings":{"M": "miseq","D": "hiseq2500"}}
+
+class TestRunTypeRecognizerFromFolder(TestCase):
 
     def setUp(self):
         self.runtype_recognizer = RunTypeRecognizer(runfolder=os.path.join(os.path.dirname(__file__),
-                                                                           "resources", "Rapid"),
-                                                    config=self.CONFIG)
+                                                                           "resources", "Rapid"))
 
     def test_instrument_type(self):
         expected = "hiseq2500"
@@ -29,6 +30,25 @@ def test_run_mode(self):
         self.assertEqual(expected, actual)
 
 
+class TestRunTypeRecognizerCorrectInstrumentsReturned(TestCase):
+
+    def _create_runtype_recognizer(self, instrument_name):
+        with mock.patch.object(RunfolderReader, 'read_run_info_xml',
+                               return_value={"RunInfo": {"Run": {"Instrument": instrument_name}}}), \
+             mock.patch.object(RunfolderReader, 'read_run_parameters_xml', return_value=None):
+            return RunTypeRecognizer(runfolder='foo')
+
+    def test_returns_hiseq2500(self):
+        runtyperecognizer = self._create_runtype_recognizer("D1000")
+        actual = runtyperecognizer.instrument_type()
+        self.assertTrue(isinstance(actual, HiSeq2500))
+
+    def test_returns_iseq(self):
+        runtyperecognizer = self._create_runtype_recognizer("FFSP100")
+        actual = runtyperecognizer.instrument_type()
+        self.assertTrue(isinstance(actual, ISeq))
+
+
 class TestIlluminaInstrument(TestCase):
 
     class MockRunTypeRecognizer():
@@ -39,6 +59,7 @@ def setUp(self):
         self.hiseq2500 = HiSeq2500()
         self.miseq = MiSeq()
         self.novaseq = NovaSeq()
+        self.iseq = ISeq()
 
     def test_all_is_well(self):
         runtype_dict = {"RunParameters": {"Setup": {"RunMode": "RapidHighOutput", "Sbs": "HiSeq SBS Kit v4"}}}